confluent_kafka/common/quota/
client_quota_entity.rs1use std::collections::HashMap;
20use std::hash::{Hash, Hasher};
21
22#[derive(Clone, Debug, Eq)]
29#[doc(alias = "org.apache.kafka.common.quota.ClientQuotaEntity")]
30pub struct ClientQuotaEntity {
31 entries: HashMap<String, Option<String>>,
32}
33
34impl ClientQuotaEntity {
35 pub const USER: &str = "user";
37
38 pub const CLIENT_ID: &str = "client-id";
40
41 pub const IP: &str = "ip";
43
44 #[doc(alias = "org.apache.kafka.common.quota.ClientQuotaEntity#isValidEntityType")]
50 pub fn is_valid_entity_type(entity_type: &str) -> bool {
51 entity_type == ClientQuotaEntity::USER
52 || entity_type == ClientQuotaEntity::CLIENT_ID
53 || entity_type == ClientQuotaEntity::IP
54 }
55
56 #[doc(alias = "org.apache.kafka.common.quota.ClientQuotaEntity#ClientQuotaEntity")]
64 pub fn new(entries: HashMap<String, Option<String>>) -> Self {
65 Self { entries }
66 }
67
68 #[doc(alias = "org.apache.kafka.common.quota.ClientQuotaEntity#entries")]
72 pub fn entries(&self) -> &HashMap<String, Option<String>> {
73 &self.entries
74 }
75}
76
77impl PartialEq for ClientQuotaEntity {
78 fn eq(&self, other: &Self) -> bool {
79 self.entries == other.entries
80 }
81}
82
83impl Hash for ClientQuotaEntity {
87 fn hash<H: Hasher>(&self, state: &mut H) {
88 crate::common::utils::Utils::hash_unordered(&self.entries, state);
89 }
90}
91
92impl std::fmt::Display for ClientQuotaEntity {
93 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
94 write!(f, "ClientQuotaEntity(entries={:?})", self.entries)
95 }
96}
97
98#[cfg(test)]
99mod tests {
100 use super::*;
101
102 fn entity(pairs: &[(&str, &str)]) -> ClientQuotaEntity {
103 ClientQuotaEntity::new(pairs.iter().map(|(k, v)| ((*k).to_string(), Some((*v).to_string()))).collect())
104 }
105
106 #[test]
109 fn is_valid_entity_type_matches_builtins() {
110 assert!(ClientQuotaEntity::is_valid_entity_type(ClientQuotaEntity::USER));
111 assert!(ClientQuotaEntity::is_valid_entity_type(ClientQuotaEntity::CLIENT_ID));
112 assert!(ClientQuotaEntity::is_valid_entity_type(ClientQuotaEntity::IP));
113 assert!(!ClientQuotaEntity::is_valid_entity_type("group"));
114 }
115
116 #[test]
118 fn equality_is_order_independent() {
119 let a = entity(&[(ClientQuotaEntity::USER, "u1"), (ClientQuotaEntity::CLIENT_ID, "c1")]);
120 let b = entity(&[(ClientQuotaEntity::CLIENT_ID, "c1"), (ClientQuotaEntity::USER, "u1")]);
121 assert_eq!(a, b);
122 assert_ne!(a, entity(&[(ClientQuotaEntity::USER, "u2")]));
123 }
124
125 #[test]
128 fn equal_entities_hash_equal() {
129 use std::collections::HashMap as Map;
130 let mut map: Map<ClientQuotaEntity, i32> = Map::new();
131 map.insert(
132 entity(&[(ClientQuotaEntity::USER, "u1"), (ClientQuotaEntity::CLIENT_ID, "c1")]),
133 7,
134 );
135 assert_eq!(
136 map.get(&entity(&[
137 (ClientQuotaEntity::CLIENT_ID, "c1"),
138 (ClientQuotaEntity::USER, "u1")
139 ])),
140 Some(&7)
141 );
142 }
143
144 #[test]
146 fn entries_accessor_round_trips() {
147 let e = entity(&[(ClientQuotaEntity::USER, "u1")]);
148 assert_eq!(e.entries().get(ClientQuotaEntity::USER), Some(&Some("u1".to_string())));
149 }
150
151 #[test]
155 fn default_entity_none_distinct_from_empty_name() {
156 let default_user = ClientQuotaEntity::new(HashMap::from([(ClientQuotaEntity::USER.to_string(), None)]));
157 let empty_named_user =
158 ClientQuotaEntity::new(HashMap::from([(ClientQuotaEntity::USER.to_string(), Some(String::new()))]));
159 assert_eq!(default_user.entries().get(ClientQuotaEntity::USER), Some(&None));
160 assert_eq!(
161 empty_named_user.entries().get(ClientQuotaEntity::USER),
162 Some(&Some(String::new()))
163 );
164 assert_ne!(default_user, empty_named_user);
165 }
166}