rocketmq_protocol/protocol/heartbeat/
message_model.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 std::fmt;
16use std::fmt::Display;
17
18use serde::Deserialize;
19use serde::Deserializer;
20use serde::Serialize;
21use serde::Serializer;
22
23#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Default)]
24pub enum MessageModel {
25    Broadcasting,
26    #[default]
27    Clustering,
28}
29
30impl MessageModel {
31    fn get_mode_cn(&self) -> &'static str {
32        match self {
33            MessageModel::Broadcasting => "BROADCASTING",
34            MessageModel::Clustering => "CLUSTERING",
35        }
36    }
37}
38
39impl Serialize for MessageModel {
40    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
41    where
42        S: Serializer,
43    {
44        let value = match self {
45            MessageModel::Broadcasting => "BROADCASTING",
46            MessageModel::Clustering => "CLUSTERING",
47        };
48        serializer.serialize_str(value)
49    }
50}
51
52impl<'de> Deserialize<'de> for MessageModel {
53    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
54    where
55        D: Deserializer<'de>,
56    {
57        struct MessageModelVisitor;
58
59        impl serde::de::Visitor<'_> for MessageModelVisitor {
60            type Value = MessageModel;
61
62            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
63                formatter.write_str("a string representing MessageModel")
64            }
65
66            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
67            where
68                E: serde::de::Error,
69            {
70                match value {
71                    "BROADCASTING" => Ok(MessageModel::Broadcasting),
72                    "CLUSTERING" => Ok(MessageModel::Clustering),
73                    _ => Err(E::custom(format_args!(
74                        "MessageModel: {}",
75                        E::unknown_variant(value, &["BROADCASTING", "CLUSTERING"])
76                    ))),
77                }
78            }
79        }
80
81        deserializer.deserialize_str(MessageModelVisitor)
82    }
83}
84
85impl Display for MessageModel {
86    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
87        write!(f, "{}", self.get_mode_cn())
88    }
89}
90
91#[cfg(test)]
92mod tests {
93    use serde_json;
94
95    use super::*;
96
97    #[test]
98    fn serialize_message_model_broadcasting() {
99        let model = MessageModel::Broadcasting;
100        let serialized = serde_json::to_string(&model).unwrap();
101        assert_eq!(serialized, "\"BROADCASTING\"");
102    }
103
104    #[test]
105    fn serialize_message_model_clustering() {
106        let model = MessageModel::Clustering;
107        let serialized = serde_json::to_string(&model).unwrap();
108        assert_eq!(serialized, "\"CLUSTERING\"");
109    }
110
111    #[test]
112    fn deserialize_message_model_broadcasting() {
113        let json = "\"BROADCASTING\"";
114        let deserialized: MessageModel = serde_json::from_str(json).unwrap();
115        assert_eq!(deserialized, MessageModel::Broadcasting);
116    }
117
118    #[test]
119    fn deserialize_message_model_clustering() {
120        let json = "\"CLUSTERING\"";
121        let deserialized: MessageModel = serde_json::from_str(json).unwrap();
122        assert_eq!(deserialized, MessageModel::Clustering);
123    }
124
125    #[test]
126    fn deserialize_message_model_invalid() {
127        let json = "\"INVALID\"";
128        let error = serde_json::from_str::<MessageModel>(json).unwrap_err().to_string();
129        for fragment in ["MessageModel", "unknown variant", "BROADCASTING", "CLUSTERING"] {
130            assert!(error.contains(fragment), "{error}");
131        }
132        let error = serde_json::from_str::<MessageModel>("1").unwrap_err().to_string();
133        assert!(error.contains("a string representing MessageModel"), "{error}");
134    }
135
136    #[test]
137    fn display_message_model_broadcasting() {
138        let model = MessageModel::Broadcasting;
139        assert_eq!(model.to_string(), "BROADCASTING");
140    }
141
142    #[test]
143    fn display_message_model_clustering() {
144        let model = MessageModel::Clustering;
145        assert_eq!(model.to_string(), "CLUSTERING");
146    }
147}
rocketmq_protocol/protocol/heartbeat/message_model.rs

rocketmq_protocol/protocol/heartbeat/
message_model.rs
