Skip to main content

rocketmq_remoting/protocol/header/
unregister_client_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
20use crate::rpc::rpc_request_header::RpcRequestHeader;
21
22#[derive(Debug, Serialize, Deserialize, Default, RequestHeaderCodecV2)]
23pub struct UnregisterClientRequestHeader {
24    #[required]
25    #[serde(rename = "clientID")]
26    pub client_id: CheetahString,
27    pub producer_group: Option<CheetahString>,
28    pub consumer_group: Option<CheetahString>,
29    #[serde(flatten)]
30    pub rpc_request_header: Option<RpcRequestHeader>,
31}
32
33#[cfg(test)]
34mod tests {
35
36    use std::collections::HashMap;
37
38    use cheetah_string::CheetahString;
39
40    use super::*;
41    use crate::protocol::command_custom_header::CommandCustomHeader;
42    use crate::protocol::command_custom_header::FromMap;
43
44    #[test]
45    fn un_register_client_request_header_serializes_correctly() {
46        let header: UnregisterClientRequestHeader = UnregisterClientRequestHeader {
47            client_id: CheetahString::from_static_str("test_client_id"),
48            producer_group: Some(CheetahString::from_static_str("test_producer_group")),
49            consumer_group: Some(CheetahString::from_static_str("test_consumer_group")),
50            rpc_request_header: None,
51        };
52        let map = header.to_map().unwrap();
53        assert_eq!(
54            map.get(&CheetahString::from_static_str("consumerGroup")).unwrap(),
55            "test_consumer_group"
56        );
57        assert_eq!(
58            map.get(&CheetahString::from_static_str("clientId")).unwrap(),
59            "test_client_id"
60        );
61        assert_eq!(
62            map.get(&CheetahString::from_static_str("producerGroup")).unwrap(),
63            "test_producer_group"
64        );
65        assert_eq!(map.get(&CheetahString::from_static_str("rpcRequestHeader")), None);
66    }
67
68    #[test]
69    fn un_register_client_request_header_deserializes_correctly() {
70        let mut map = HashMap::new();
71        map.insert(
72            CheetahString::from_static_str("consumerGroup"),
73            CheetahString::from_static_str("test_consumer_group"),
74        );
75        map.insert(
76            CheetahString::from_static_str("clientId"),
77            CheetahString::from_static_str("test_client_id"),
78        );
79        map.insert(
80            CheetahString::from_static_str("producerGroup"),
81            CheetahString::from_static_str("test_producer_group"),
82        );
83        let header: UnregisterClientRequestHeader = <UnregisterClientRequestHeader as FromMap>::from(&map).unwrap();
84        assert_eq!(header.consumer_group.as_deref(), Some("test_consumer_group"));
85        assert_eq!(header.client_id, "test_client_id");
86        assert_eq!(header.producer_group.as_deref(), Some("test_producer_group"));
87    }
88
89    #[test]
90    fn un_register_client_request_header_missing_optional_fields() {
91        let mut map = HashMap::new();
92        map.insert(
93            CheetahString::from_static_str("clientId"),
94            CheetahString::from_static_str("test_client_id"),
95        );
96
97        let header: UnregisterClientRequestHeader = <UnregisterClientRequestHeader as FromMap>::from(&map).unwrap();
98        assert_eq!(header.client_id, "test_client_id");
99        assert!(header.rpc_request_header.is_some());
100    }
101
102    #[test]
103    fn un_register_client_request_header_deserialize_from_json() {
104        let data = r#"{"clientID":"test_client_id","consumerGroup":"test_consumer_group"}"#;
105        let header: UnregisterClientRequestHeader = serde_json::from_str(data).unwrap();
106        assert_eq!(header.client_id, CheetahString::from_static_str("test_client_id"));
107        assert_eq!(header.consumer_group.as_deref(), None);
108        assert!(header.rpc_request_header.is_some());
109    }
110}