dusa_collection_utils/tests/
errors.rs

1#[cfg(test)]
2mod tests {
3    use crate::core::errors::ErrorArray;
4    use crate::core::errors::ErrorArrayItem;
5    use crate::core::errors::Errors;
6    use crate::core::errors::OkWarning;
7    use crate::core::errors::UnifiedResult;
8    use crate::core::errors::WarningArray;
9    use crate::core::errors::WarningArrayItem;
10    use crate::core::errors::Warnings;
11
12    use std::error::Error;
13    // use super::*;
14    use std::io;
15    use std::net;
16    use std::net::AddrParseError;
17    use std::sync::mpsc;
18    // use std::time::SystemTime;
19
20    #[test]
21    fn can_be_trait_object() {
22        let err = ErrorArrayItem::new(Errors::OpeningFile, "couldn’t open foo.txt");
23        // if this compiles, ErrorArrayItem implements std::error::Error:
24        let _obj: &dyn Error = &err;
25    }
26
27    #[test]
28    fn test_error_array_item_creation() {
29        let error_item =
30            ErrorArrayItem::new(Errors::OpeningFile, String::from("Failed to open file"));
31        assert_eq!(error_item.err_type, Errors::OpeningFile);
32        assert_eq!(error_item.err_mesg, "Failed to open file".into());
33    }
34
35    #[test]
36    fn test_warning_array_item_creation() {
37        let warning_item = WarningArrayItem::new(Warnings::Warning);
38        assert_eq!(warning_item.warn_type, Warnings::Warning);
39        assert!(warning_item.warn_mesg.is_none());
40
41        let detailed_warning_item = WarningArrayItem::new_details(
42            Warnings::OutdatedVersion,
43            String::from("Version is outdated"),
44        );
45        assert_eq!(detailed_warning_item.warn_type, Warnings::OutdatedVersion);
46        assert_eq!(
47            detailed_warning_item.warn_mesg.as_deref(),
48            Some("Version is outdated")
49        );
50    }
51
52    #[test]
53    fn test_error_array_operations() {
54        let mut error_array = ErrorArray::new_container();
55        let error_item1 =
56            ErrorArrayItem::new(Errors::ReadingFile, String::from("Failed to read file"));
57        let error_item2 =
58            ErrorArrayItem::new(Errors::CreatingFile, String::from("Failed to create file"));
59
60        error_array.push(error_item1.clone());
61        error_array.push(error_item2.clone());
62
63        assert_eq!(error_array.len(), 2);
64
65        // Displaying and clearing the array
66        error_array.clone().display(false);
67        assert_eq!(error_array.len(), 0);
68
69        error_array.push(error_item1.clone());
70        error_array.push(error_item2.clone());
71        error_array.clear();
72        assert_eq!(error_array.len(), 0);
73
74        error_array = ErrorArray::from(error_item1);
75        assert_eq!(error_array.len(), 1);
76    }
77
78    #[test]
79    fn test_warning_array_operations() {
80        let mut warning_array = WarningArray::new_container();
81        let warning_item1 = WarningArrayItem::new(Warnings::UnexpectedBehavior);
82        let warning_item2 = WarningArrayItem::new_details(
83            Warnings::ConnectionLost,
84            String::from("Connection lost"),
85        );
86
87        warning_array.push(warning_item1);
88        warning_array.push(warning_item2);
89
90        assert_eq!(warning_array.len(), 2);
91
92        // Displaying and clearing the array
93        warning_array.clone().display();
94        assert_eq!(warning_array.len(), 0);
95    }
96
97    #[test]
98    fn test_error_array_conversion() {
99        // Converting io::Error
100        let io_error = io::Error::new(io::ErrorKind::Other, "I/O error");
101        let error_item: ErrorArrayItem = io_error.into();
102        assert_eq!(error_item.err_type, Errors::InputOutput);
103        assert_eq!(error_item.err_mesg, "I/O error".into());
104
105        // Converting net::AddrParseError
106        let addr_error: AddrParseError = "invalid address".parse::<net::IpAddr>().unwrap_err();
107        let error_item: ErrorArrayItem = addr_error.into();
108        assert_eq!(error_item.err_type, Errors::InputOutput);
109        assert_eq!(error_item.err_mesg, "invalid IP address syntax".into());
110
111        // Converting mpsc::SendError
112        let (sender, receiver) = mpsc::channel::<i32>();
113        drop(receiver);
114        let send_error: mpsc::SendError<i32> = sender.send(1).unwrap_err();
115        let error_item: ErrorArrayItem = send_error.into();
116        assert_eq!(error_item.err_type, Errors::InputOutput);
117        assert_eq!(error_item.err_mesg, "sending on a closed channel".into());
118
119        // // Converting SystemTimeError
120        // let system_time_error: SystemTime = SystemTime::now() - SystemTime::UNIX_EPOCH;
121        // let error_item: ErrorArrayItem = system_time_error.elapsed().unwrap_err().into();
122        // assert_eq!(error_item.err_type, Errors::InputOutput);
123        // assert_eq!(error_item.err_mesg, "second time provided was later than self");
124
125        // Ensure that we can push these items to an ErrorArray
126        let mut error_array = ErrorArray::new_container();
127        error_array.push(error_item);
128        assert_eq!(error_array.len(), 1);
129    }
130
131    #[test]
132    fn test_warning_array_append() {
133        let warning_item1 = WarningArrayItem::new(Warnings::UnexpectedBehavior);
134        let warning_item2 = WarningArrayItem::new_details(
135            Warnings::ConnectionLost,
136            String::from("Connection lost"),
137        );
138
139        let mut array1 = WarningArray::new(vec![warning_item1.clone()]);
140        let array2 = WarningArray::new(vec![warning_item2.clone()]);
141
142        array1.append(array2);
143        assert_eq!(array1.len(), 2);
144        let vec = array1.0.read().unwrap();
145        assert_eq!(vec[0].warn_type, Warnings::UnexpectedBehavior);
146        assert_eq!(vec[1].warn_type, Warnings::ConnectionLost);
147    }
148
149    #[test]
150    fn test_error_array_append() {
151        let error_item1 =
152            ErrorArrayItem::new(Errors::ReadingFile, String::from("Failed to read file"));
153        let error_item2 =
154            ErrorArrayItem::new(Errors::CreatingFile, String::from("Failed to create file"));
155
156        let mut array1 = ErrorArray::new(vec![error_item1.clone()]);
157        let array2 = ErrorArray::new(vec![error_item2.clone()]);
158
159        array1.append(array2);
160        assert_eq!(array1.len(), 2);
161        let vec = array1.0.read().unwrap();
162        assert_eq!(vec[0].err_type, Errors::ReadingFile);
163        assert_eq!(vec[1].err_type, Errors::CreatingFile);
164    }
165
166    #[test]
167    fn test_warning_array() {
168        let mut warning_array = WarningArray::new_container();
169        let warning_item = WarningArrayItem::new(Warnings::Warning);
170        warning_array.push(warning_item);
171
172        assert_eq!(warning_array.len(), 1);
173        let warnings = warning_array.0.read().unwrap();
174        assert_eq!(warnings[0].warn_type, Warnings::Warning);
175    }
176
177    #[test]
178    fn test_error_array() {
179        let mut error_array = ErrorArray::new_container();
180        let error_item =
181            ErrorArrayItem::new(Errors::OpeningFile, String::from("Failed to open file"));
182        error_array.push(error_item);
183
184        assert_eq!(error_array.len(), 1);
185        let errors = error_array.0.read().unwrap();
186        assert_eq!(errors[0].err_type, Errors::OpeningFile);
187        assert_eq!(errors[0].err_mesg, "Failed to open file".into());
188    }
189
190    #[test]
191    fn test_unified_result_ok() {
192        let warning_item = WarningArrayItem::new(Warnings::Warning);
193        let warning_array = WarningArray::new(vec![warning_item]);
194        let ok_warning = OkWarning {
195            data: 42,
196            warning: warning_array.clone(),
197        };
198
199        let result = UnifiedResult::new_warn(Ok(ok_warning));
200        assert!(result.is_ok());
201
202        match result {
203            UnifiedResult::ResultWarning(Ok(ok_warning)) => {
204                assert_eq!(ok_warning.data, 42);
205                assert_eq!(ok_warning.warning.len(), 1);
206            }
207            _ => panic!("Expected ResultWarning with Ok"),
208        }
209    }
210
211    #[test]
212    fn test_error_array_item_from_io_error() {
213        let io_error = io::Error::new(io::ErrorKind::Other, "io error");
214        let error_item: ErrorArrayItem = io_error.into();
215        assert_eq!(error_item.err_type, Errors::InputOutput);
216        assert_eq!(error_item.err_mesg, "io error".into());
217    }
218
219    #[test]
220    fn test_error_array_item_from_net_error() {
221        let addr_parse_error: AddrParseError =
222            "invalid address".parse::<net::IpAddr>().unwrap_err();
223        let error_item: ErrorArrayItem = addr_parse_error.into();
224        assert_eq!(error_item.err_type, Errors::InputOutput);
225        assert_eq!(error_item.err_mesg, "invalid IP address syntax".into());
226    }
227
228    #[test]
229    fn test_pop_from_empty_array() {
230        let mut errors: ErrorArray = ErrorArray::new_container();
231        let result: ErrorArrayItem = errors.pop();
232
233        assert_eq!(result.err_type, Errors::GeneralError);
234        assert_eq!(result.err_mesg, "No previous error".into());
235    }
236
237    #[test]
238    fn test_pop_single_error() {
239        let mut errors: ErrorArray = ErrorArray::new_container();
240
241        let error_item: ErrorArrayItem = ErrorArrayItem::new(
242            Errors::AuthenticationError,
243            String::from("Auth error occurred"),
244        );
245        errors.push(error_item.clone());
246
247        let result: ErrorArrayItem = errors.pop();
248
249        assert_eq!(result.err_type, error_item.err_type);
250        assert_eq!(result.err_mesg, error_item.err_mesg);
251
252        // Ensure the array is empty after popping
253        let empty_result: ErrorArrayItem = errors.pop();
254        assert_eq!(empty_result.err_type, Errors::GeneralError);
255        assert_eq!(empty_result.err_mesg, "No previous error".into());
256    }
257
258    #[test]
259    fn test_pop_multiple_errors() {
260        let mut errors = ErrorArray::new_container();
261
262        let error_item1 = ErrorArrayItem::new(Errors::AuthenticationError, String::from("First"));
263        let error_item2 = ErrorArrayItem::new(Errors::InvalidAuthRequest, String::from("Second"));
264        errors.push(error_item1.clone());
265        errors.push(error_item2.clone());
266
267        let result2: ErrorArrayItem = errors.pop();
268        assert_eq!(result2.err_type, error_item2.err_type);
269        assert_eq!(result2.err_mesg, error_item2.err_mesg);
270
271        let result1: ErrorArrayItem = errors.pop();
272        assert_eq!(result1.err_type, error_item1.err_type);
273        assert_eq!(result1.err_mesg, error_item1.err_mesg);
274
275        // Ensure the array is empty after popping all errors
276        let empty_result: ErrorArrayItem = errors.pop();
277        assert_eq!(empty_result.err_type, Errors::GeneralError);
278        assert_eq!(empty_result.err_mesg, "No previous error".into());
279    }
280
281    #[test]
282    fn strip_warning_from_type() {
283        let mut warnings = WarningArray::new_container();
284        warnings.push(WarningArrayItem::new(Warnings::Warning));
285
286        let okwarning = OkWarning {
287            data: String::new(),
288            warning: warnings,
289        };
290
291        assert_eq!(okwarning.strip(), String::new())
292    }
293}
dusa_collection_utils/tests/errors.rs

dusa_collection_utils/tests/
errors.rs
