Skip to main content

rocketmq_remoting/protocol/header/
update_user_request_header.rs

1// Copyright 2023 The RocketMQ Rust Authors
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
15use cheetah_string::CheetahString;
16use rocketmq_macros::RequestHeaderCodecV2;
17use serde::Deserialize;
18use serde::Serialize;
19
20#[derive(Debug, Clone, Serialize, Deserialize, Default, RequestHeaderCodecV2)]
21#[serde(rename_all = "camelCase")]
22pub struct UpdateUserRequestHeader {
23    pub username: CheetahString,
24}
25impl UpdateUserRequestHeader {
26    pub fn set_username(&mut self, username: CheetahString) {
27        self.username = username;
28    }
29}
30
31#[cfg(test)]
32mod tests {
33    use cheetah_string::CheetahString;
34    use serde_json;
35
36    use super::*;
37
38    #[test]
39    fn test_default_username_is_empty() {
40        let header = UpdateUserRequestHeader::default();
41        assert_eq!(header.username, CheetahString::from(""));
42    }
43
44    #[test]
45    fn test_new_with_explicit_username() {
46        let header = UpdateUserRequestHeader {
47            username: CheetahString::from("alice"),
48        };
49        assert_eq!(header.username, CheetahString::from("alice"));
50    }
51
52    #[test]
53    fn test_set_username_updates_value() {
54        let mut header = UpdateUserRequestHeader::default();
55        header.set_username(CheetahString::from("bob"));
56        assert_eq!(header.username, CheetahString::from("bob"));
57    }
58
59    #[test]
60    fn test_set_username_overwrites_existing() {
61        let mut header = UpdateUserRequestHeader {
62            username: CheetahString::from("old_user"),
63        };
64        header.set_username(CheetahString::from("new_user"));
65        assert_eq!(header.username, CheetahString::from("new_user"));
66    }
67
68    #[test]
69    fn test_set_username_with_empty_string() {
70        let mut header = UpdateUserRequestHeader {
71            username: CheetahString::from("someone"),
72        };
73        header.set_username(CheetahString::from(""));
74        assert_eq!(header.username, CheetahString::from(""));
75    }
76
77    #[test]
78    fn test_set_username_with_unicode() {
79        let mut header = UpdateUserRequestHeader::default();
80        header.set_username(CheetahString::from("用户名"));
81        assert_eq!(header.username, CheetahString::from("用户名"));
82    }
83
84    #[test]
85    fn test_set_username_with_special_characters() {
86        let mut header = UpdateUserRequestHeader::default();
87        header.set_username(CheetahString::from("user@domain.com!#$"));
88        assert_eq!(header.username, CheetahString::from("user@domain.com!#$"));
89    }
90
91    #[test]
92    fn test_clone_produces_equal_value() {
93        let original = UpdateUserRequestHeader {
94            username: CheetahString::from("charlie"),
95        };
96        let cloned = original.clone();
97        assert_eq!(original.username, cloned.username);
98    }
99
100    #[test]
101    fn test_clone_is_independent() {
102        let original = UpdateUserRequestHeader {
103            username: CheetahString::from("delta"),
104        };
105        let mut cloned = original.clone();
106        cloned.set_username(CheetahString::from("epsilon"));
107        // Original must be unchanged
108        assert_eq!(original.username, CheetahString::from("delta"));
109        assert_eq!(cloned.username, CheetahString::from("epsilon"));
110    }
111
112    #[test]
113    fn test_serialise_uses_camel_case_key() {
114        let header = UpdateUserRequestHeader {
115            username: CheetahString::from("frank"),
116        };
117        let json = serde_json::to_string(&header).expect("serialisation failed");
118        // The serde rename_all = "camelCase" keeps "username" as-is (already camel)
119        assert!(json.contains("\"username\""));
120        assert!(json.contains("\"frank\""));
121    }
122
123    #[test]
124    fn test_serialise_default_produces_empty_username() {
125        let header = UpdateUserRequestHeader::default();
126        let json = serde_json::to_string(&header).expect("serialisation failed");
127        assert!(json.contains("\"username\":\"\""));
128    }
129
130    #[test]
131    fn test_deserialise_from_valid_json() {
132        let json = r#"{"username":"grace"}"#;
133        let header: UpdateUserRequestHeader = serde_json::from_str(json).expect("deserialisation failed");
134        assert_eq!(header.username, CheetahString::from("grace"));
135    }
136    #[test]
137    fn test_roundtrip_serialisation() {
138        let original = UpdateUserRequestHeader {
139            username: CheetahString::from("henry"),
140        };
141        let json = serde_json::to_string(&original).expect("serialisation failed");
142        let restored: UpdateUserRequestHeader = serde_json::from_str(&json).expect("deserialisation failed");
143        assert_eq!(original.username, restored.username);
144    }
145
146    #[test]
147    fn test_roundtrip_with_whitespace_username() {
148        let original = UpdateUserRequestHeader {
149            username: CheetahString::from("  spaces  "),
150        };
151        let json = serde_json::to_string(&original).unwrap();
152        let restored: UpdateUserRequestHeader = serde_json::from_str(&json).unwrap();
153        assert_eq!(original.username, restored.username);
154    }
155    #[test]
156    fn test_debug_output_contains_username() {
157        let header = UpdateUserRequestHeader {
158            username: CheetahString::from("ivy"),
159        };
160        let debug_str = format!("{:?}", header);
161        assert!(debug_str.contains("ivy"));
162    }
163}