rocketmq_client_rust/consumer/
ack_status.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::Display;
16
17use cheetah_string::CheetahString;
18use serde::Deserialize;
19use serde::Deserializer;
20use serde::Serialize;
21use serde::Serializer;
22
23#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
24pub enum AckStatus {
25    #[default]
26    Ok, //ack success
27    NotExist, // msg not exist
28}
29
30impl AckStatus {
31    pub fn from_i32(value: i32) -> Option<Self> {
32        match value {
33            0 => Some(AckStatus::Ok),
34            1 => Some(AckStatus::NotExist),
35            _ => None,
36        }
37    }
38
39    pub fn to_i32(self) -> i32 {
40        match self {
41            AckStatus::Ok => 0,
42            AckStatus::NotExist => 1,
43        }
44    }
45}
46
47impl Display for AckStatus {
48    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
49        match self {
50            AckStatus::Ok => write!(f, "OK"),
51            AckStatus::NotExist => write!(f, "NO_EXIST"),
52        }
53    }
54}
55
56impl From<String> for AckStatus {
57    fn from(s: String) -> Self {
58        match s.as_str() {
59            "OK" => AckStatus::Ok,
60            "NO_EXIST" => AckStatus::NotExist,
61            _ => AckStatus::default(),
62        }
63    }
64}
65
66impl From<&str> for AckStatus {
67    fn from(s: &str) -> Self {
68        match s {
69            "OK" => AckStatus::Ok,
70            "NO_EXIST" => AckStatus::NotExist,
71            _ => AckStatus::default(),
72        }
73    }
74}
75
76impl From<AckStatus> for String {
77    fn from(status: AckStatus) -> Self {
78        match status {
79            AckStatus::Ok => "OK".to_string(),
80            AckStatus::NotExist => "NO_EXIST".to_string(),
81        }
82    }
83}
84
85impl From<AckStatus> for i32 {
86    fn from(status: AckStatus) -> Self {
87        match status {
88            AckStatus::Ok => 0,
89            AckStatus::NotExist => 1,
90        }
91    }
92}
93
94impl From<i32> for AckStatus {
95    fn from(value: i32) -> Self {
96        match value {
97            0 => AckStatus::Ok,
98            1 => AckStatus::NotExist,
99            _ => AckStatus::default(),
100        }
101    }
102}
103
104impl From<CheetahString> for AckStatus {
105    fn from(s: CheetahString) -> Self {
106        match s.as_str() {
107            "OK" => AckStatus::Ok,
108            "NO_EXIST" => AckStatus::NotExist,
109            _ => AckStatus::default(),
110        }
111    }
112}
113
114impl Serialize for AckStatus {
115    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
116    where
117        S: Serializer,
118    {
119        let s = match *self {
120            AckStatus::Ok => "OK",
121            AckStatus::NotExist => "NO_EXIST",
122        };
123        serializer.serialize_str(s)
124    }
125}
126
127impl<'de> Deserialize<'de> for AckStatus {
128    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
129    where
130        D: Deserializer<'de>,
131    {
132        let s = String::deserialize(deserializer)?;
133        match s.as_str() {
134            "OK" => Ok(AckStatus::Ok),
135            "NO_EXIST" => Ok(AckStatus::NotExist),
136            _ => Err(serde::de::Error::custom("unknown value")),
137        }
138    }
139}
140
141#[cfg(test)]
142mod tests {
143    use cheetah_string::CheetahString;
144    use serde_json;
145
146    use super::*;
147
148    #[test]
149    fn ack_status_from_i32_valid_values() {
150        assert_eq!(AckStatus::from_i32(0), Some(AckStatus::Ok));
151        assert_eq!(AckStatus::from_i32(1), Some(AckStatus::NotExist));
152    }
153
154    #[test]
155    fn ack_status_from_i32_invalid_value() {
156        assert_eq!(AckStatus::from_i32(2), None);
157    }
158
159    #[test]
160    fn ack_status_to_i32() {
161        assert_eq!(AckStatus::Ok.to_i32(), 0);
162        assert_eq!(AckStatus::NotExist.to_i32(), 1);
163    }
164
165    #[test]
166    fn ack_status_display() {
167        assert_eq!(format!("{}", AckStatus::Ok), "OK");
168        assert_eq!(format!("{}", AckStatus::NotExist), "NO_EXIST");
169    }
170
171    #[test]
172    fn ack_status_from_string() {
173        assert_eq!(AckStatus::from("OK".to_string()), AckStatus::Ok);
174        assert_eq!(AckStatus::from("NO_EXIST".to_string()), AckStatus::NotExist);
175        assert_eq!(AckStatus::from("UNKNOWN".to_string()), AckStatus::default());
176    }
177
178    #[test]
179    fn ack_status_from_str() {
180        assert_eq!(AckStatus::from("OK"), AckStatus::Ok);
181        assert_eq!(AckStatus::from("NO_EXIST"), AckStatus::NotExist);
182        assert_eq!(AckStatus::from("UNKNOWN"), AckStatus::default());
183    }
184
185    #[test]
186    fn ack_status_from_cheetah_string() {
187        assert_eq!(AckStatus::from(CheetahString::from("OK")), AckStatus::Ok);
188        assert_eq!(AckStatus::from(CheetahString::from("NO_EXIST")), AckStatus::NotExist);
189        assert_eq!(AckStatus::from(CheetahString::from("UNKNOWN")), AckStatus::default());
190    }
191
192    #[test]
193    fn ack_status_to_string() {
194        assert_eq!(String::from(AckStatus::Ok), "OK".to_string());
195        assert_eq!(String::from(AckStatus::NotExist), "NO_EXIST".to_string());
196    }
197
198    #[test]
199    fn ack_status_from_i32_conversion() {
200        assert_eq!(i32::from(AckStatus::Ok), 0);
201        assert_eq!(i32::from(AckStatus::NotExist), 1);
202    }
203
204    #[test]
205    fn ack_status_from_i32_default() {
206        assert_eq!(AckStatus::from(2), AckStatus::default());
207    }
208
209    #[test]
210    fn ack_status_serialize() {
211        let ok_status = AckStatus::Ok;
212        let serialized = serde_json::to_string(&ok_status).unwrap();
213        assert_eq!(serialized, "\"OK\"");
214
215        let not_exist_status = AckStatus::NotExist;
216        let serialized = serde_json::to_string(&not_exist_status).unwrap();
217        assert_eq!(serialized, "\"NO_EXIST\"");
218    }
219
220    #[test]
221    fn ack_status_deserialize() {
222        let ok_status: AckStatus = serde_json::from_str("\"OK\"").unwrap();
223        assert_eq!(ok_status, AckStatus::Ok);
224
225        let not_exist_status: AckStatus = serde_json::from_str("\"NO_EXIST\"").unwrap();
226        assert_eq!(not_exist_status, AckStatus::NotExist);
227    }
228}
rocketmq_client_rust/consumer/ack_status.rs

rocketmq_client_rust/consumer/
ack_status.rs
