rocketmq_remoting/protocol/header/namesrv/
query_data_version_header.rs

1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18use cheetah_string::CheetahString;
19use rocketmq_macros::RequestHeaderCodecV2;
20use serde::Deserialize;
21use serde::Serialize;
22
23#[derive(Debug, Clone, Deserialize, Serialize, Default, RequestHeaderCodecV2)]
24#[serde(rename_all = "camelCase")]
25pub struct QueryDataVersionRequestHeader {
26    #[required]
27    pub broker_name: CheetahString,
28
29    #[required]
30    pub broker_addr: CheetahString,
31
32    #[required]
33    pub cluster_name: CheetahString,
34
35    #[required]
36    pub broker_id: u64,
37}
38
39impl QueryDataVersionRequestHeader {
40    pub fn new(
41        broker_name: impl Into<CheetahString>,
42        broker_addr: impl Into<CheetahString>,
43        cluster_name: impl Into<CheetahString>,
44        broker_id: u64,
45    ) -> Self {
46        Self {
47            broker_name: broker_name.into(),
48            broker_addr: broker_addr.into(),
49            cluster_name: cluster_name.into(),
50            broker_id,
51        }
52    }
53}
54
55#[derive(Debug, Clone, Deserialize, Serialize, Default, RequestHeaderCodecV2)]
56pub struct QueryDataVersionResponseHeader {
57    changed: bool,
58}
59
60impl QueryDataVersionResponseHeader {
61    pub fn new(changed: bool) -> Self {
62        Self { changed }
63    }
64}
65
66#[cfg(test)]
67mod tests {
68    use cheetah_string::CheetahString;
69
70    use super::*;
71
72    #[test]
73    fn query_data_version_request_header_new() {
74        let header = QueryDataVersionRequestHeader::new("broker1", "127.0.0.1", "cluster1", 1);
75        assert_eq!(header.broker_name, CheetahString::from("broker1"));
76        assert_eq!(header.broker_addr, CheetahString::from("127.0.0.1"));
77        assert_eq!(header.cluster_name, CheetahString::from("cluster1"));
78        assert_eq!(header.broker_id, 1);
79    }
80
81    #[test]
82    fn query_data_version_request_header_serialization() {
83        let header = QueryDataVersionRequestHeader::new("broker1", "127.0.0.1", "cluster1", 1);
84        let serialized = serde_json::to_string(&header).unwrap();
85        assert_eq!(
86            serialized,
87            r#"{"brokerName":"broker1","brokerAddr":"127.0.0.1","clusterName":"cluster1","brokerId":1}"#
88        );
89    }
90
91    #[test]
92    fn query_data_version_request_header_deserialization() {
93        let json = r#"{"brokerName":"broker1","brokerAddr":"127.0.0.1","clusterName":"cluster1","brokerId":1}"#;
94        let deserialized: QueryDataVersionRequestHeader = serde_json::from_str(json).unwrap();
95        assert_eq!(deserialized.broker_name, CheetahString::from("broker1"));
96        assert_eq!(deserialized.broker_addr, CheetahString::from("127.0.0.1"));
97        assert_eq!(deserialized.cluster_name, CheetahString::from("cluster1"));
98        assert_eq!(deserialized.broker_id, 1);
99    }
100
101    #[test]
102    fn query_data_version_response_header_new() {
103        let header = QueryDataVersionResponseHeader::new(true);
104        assert!(header.changed);
105    }
106
107    #[test]
108    fn query_data_version_response_header_serialization() {
109        let header = QueryDataVersionResponseHeader::new(true);
110        let serialized = serde_json::to_string(&header).unwrap();
111        assert_eq!(serialized, r#"{"changed":true}"#);
112    }
113
114    #[test]
115    fn query_data_version_response_header_deserialization() {
116        let json = r#"{"changed":true}"#;
117        let deserialized: QueryDataVersionResponseHeader = serde_json::from_str(json).unwrap();
118        assert!(deserialized.changed);
119    }
120}