rustfs-kafka 1.2.0

Rust client for Apache Kafka
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Some utility structures
//!
//! This module is _not_ exposed to the public directly.

/// A retrieved offset for a particular partition in the context of an
/// already known topic.
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct PartitionOffset {
    /// The offset value for the partition.
    pub offset: i64,
    /// The partition identifier.
    pub partition: i32,
}

/// A retrieved offset for a particular partition in the context of an
/// already known topic, specific to a timestamp.
#[derive(Debug, Hash, PartialEq, Eq)]
pub struct TimestampedPartitionOffset {
    /// The offset value for the partition.
    pub offset: i64,
    /// The partition identifier.
    pub partition: i32,
    /// The timestamp (ms since epoch) associated with the offset.
    pub time: i64,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_partition_offset_construction() {
        let po = PartitionOffset {
            offset: 42,
            partition: 3,
        };
        assert_eq!(po.offset, 42);
        assert_eq!(po.partition, 3);
    }

    #[test]
    fn test_partition_offset_zero_values() {
        let po = PartitionOffset {
            offset: 0,
            partition: 0,
        };
        assert_eq!(po.offset, 0);
        assert_eq!(po.partition, 0);
    }

    #[test]
    fn test_partition_offset_negative_values() {
        let po = PartitionOffset {
            offset: -1,
            partition: -5,
        };
        assert_eq!(po.offset, -1);
        assert_eq!(po.partition, -5);
    }

    #[test]
    fn test_partition_offset_equality() {
        let a = PartitionOffset {
            offset: 100,
            partition: 2,
        };
        let b = PartitionOffset {
            offset: 100,
            partition: 2,
        };
        let c = PartitionOffset {
            offset: 100,
            partition: 3,
        };
        assert_eq!(a, b);
        assert_ne!(a, c);
    }

    #[test]
    fn test_timestamped_partition_offset_construction() {
        let tpo = TimestampedPartitionOffset {
            offset: 99,
            partition: 1,
            time: 1_700_000_000_000,
        };
        assert_eq!(tpo.offset, 99);
        assert_eq!(tpo.partition, 1);
        assert_eq!(tpo.time, 1_700_000_000_000);
    }

    #[test]
    fn test_timestamped_partition_offset_zero_values() {
        let tpo = TimestampedPartitionOffset {
            offset: 0,
            partition: 0,
            time: 0,
        };
        assert_eq!(tpo.offset, 0);
        assert_eq!(tpo.partition, 0);
        assert_eq!(tpo.time, 0);
    }

    #[test]
    fn test_timestamped_partition_offset_negative_time() {
        let tpo = TimestampedPartitionOffset {
            offset: -10,
            partition: 0,
            time: -1,
        };
        assert_eq!(tpo.offset, -10);
        assert_eq!(tpo.time, -1);
    }

    #[test]
    fn test_timestamped_partition_offset_equality() {
        let a = TimestampedPartitionOffset {
            offset: 50,
            partition: 0,
            time: 123,
        };
        let b = TimestampedPartitionOffset {
            offset: 50,
            partition: 0,
            time: 123,
        };
        let c = TimestampedPartitionOffset {
            offset: 50,
            partition: 0,
            time: 124,
        };
        assert_eq!(a, b);
        assert_ne!(a, c);
    }

    #[test]
    fn test_timestamped_partition_offset_differs_from_partition_offset() {
        // Ensure they are distinct types — this compiles only if the types are separate.
        let po = PartitionOffset {
            offset: 1,
            partition: 0,
        };
        let tpo = TimestampedPartitionOffset {
            offset: 1,
            partition: 0,
            time: 0,
        };
        assert_eq!(po.offset, tpo.offset);
        assert_eq!(po.partition, tpo.partition);
    }
}