Skip to main content

confluent_kafka/admin/
finalized_version_range.rs

1// Copyright 2025 Confluent Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15//! A range of version levels supported by every broker for a feature.
16
17use crate::common::Error;
18
19/// Represents a range of version levels supported by every broker in a cluster
20/// for some feature.
21#[derive(Clone, Debug, PartialEq, Eq, Hash)]
22#[doc(alias = "org.apache.kafka.clients.admin.FinalizedVersionRange")]
23pub struct FinalizedVersionRange {
24    min_version_level: i16,
25    max_version_level: i16,
26}
27
28impl FinalizedVersionRange {
29    /// Raises an error unless the following condition is met: `min_version_level >= 0` and
30    /// `max_version_level >= 0` and `max_version_level >= min_version_level`.
31    ///
32    /// # Arguments
33    ///
34    /// - `min_version_level` - The minimum version level value.
35    /// - `max_version_level` - The maximum version level value.
36    ///
37    /// # Errors
38    ///
39    /// - `Error::is_local_illegal_argument_error` Raised when the condition described above is not
40    ///   met.
41    ///
42    /// # Translation notes
43    ///
44    /// Java's Javadoc says `>= 1`; Java's code, like this one, checks `>= 0`.
45    #[doc(alias = "org.apache.kafka.clients.admin.FinalizedVersionRange#FinalizedVersionRange")]
46    pub fn new(min_version_level: i16, max_version_level: i16) -> Result<Self, Error> {
47        if min_version_level < 0 || max_version_level < 0 || max_version_level < min_version_level {
48            return Err(Error::local_illegal_argument(format!(
49                "Expected minVersionLevel >= 0, maxVersionLevel >= 0 and maxVersionLevel >= minVersionLevel, but \
50                 received minVersionLevel: {min_version_level}, maxVersionLevel: {max_version_level}"
51            )));
52        }
53        Ok(Self { min_version_level, max_version_level })
54    }
55
56    /// Returns the minimum version level value.
57    #[doc(alias = "org.apache.kafka.clients.admin.FinalizedVersionRange#minVersionLevel")]
58    pub fn min_version_level(&self) -> i16 {
59        self.min_version_level
60    }
61
62    /// Returns the maximum version level value.
63    #[doc(alias = "org.apache.kafka.clients.admin.FinalizedVersionRange#maxVersionLevel")]
64    pub fn max_version_level(&self) -> i16 {
65        self.max_version_level
66    }
67}
68
69impl std::fmt::Display for FinalizedVersionRange {
70    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
71        write!(
72            f,
73            "FinalizedVersionRange[min_version_level:{}, max_version_level:{}]",
74            self.min_version_level, self.max_version_level
75        )
76    }
77}
78
79#[cfg(test)]
80mod tests {
81    use super::*;
82
83    #[test]
84    fn new_valid_range() {
85        let range = FinalizedVersionRange::new(1, 3).unwrap();
86        assert_eq!(range.min_version_level(), 1);
87        assert_eq!(range.max_version_level(), 3);
88    }
89
90    #[test]
91    fn new_equal_bounds_is_allowed() {
92        let range = FinalizedVersionRange::new(2, 2).unwrap();
93        assert_eq!(range.min_version_level(), 2);
94        assert_eq!(range.max_version_level(), 2);
95    }
96
97    #[test]
98    fn new_rejects_negative_and_inverted_ranges() {
99        let expected = "Expected minVersionLevel >= 0, maxVersionLevel >= 0 and maxVersionLevel >= minVersionLevel, \
100                        but received minVersionLevel: -1, maxVersionLevel: 2";
101        assert_eq!(FinalizedVersionRange::new(-1, 2).unwrap_err().message(), expected);
102        assert!(FinalizedVersionRange::new(3, 2).is_err());
103        assert!(FinalizedVersionRange::new(0, -1).is_err());
104    }
105
106    #[test]
107    fn to_string_matches_java() {
108        let range = FinalizedVersionRange::new(2, 5).unwrap();
109        assert_eq!(
110            range.to_string(),
111            "FinalizedVersionRange[min_version_level:2, max_version_level:5]"
112        );
113    }
114}