cdumay_core 0.1.7

A Rust Library for standard code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#[cfg(test)]
mod tests {
    use std::collections::BTreeMap;
    use serde_value::Value;
    use cdumay_core::{define_errors, define_kinds, Error};

    define_kinds! {
        NotFound = (404, "Resource Not Found"),
        Unauthorized = (401, "Unauthorized Access"),
    }

    define_errors! {
        NotFoundError = NotFound,
        UnauthorizedError = Unauthorized,
        Forbidden = (Unauthorized, 403),
        LoginTimeout = (Unauthorized, 440, "Login Time-out") 
    }

    #[test]
    fn test_not_found_error_defaults() {
        let err = NotFoundError::new();
        assert_eq!(err.code(), 404);
        assert_eq!(err.message(), "Resource Not Found");
        assert_eq!(err.class(), "Client::NotFound::NotFoundError");
    }

    #[test]
    fn test_forbidden_error_override_code() {
        let err = Forbidden::new();
        assert_eq!(err.code(), 403);
        assert_eq!(err.message(), "Unauthorized Access");
        assert_eq!(err.class(), "Client::Unauthorized::Forbidden");
    }

    #[test]
    fn test_forbidden_error_override_message() {
        let err = LoginTimeout::new();
        assert_eq!(err.code(), 440);
        assert_eq!(err.message(), "Login Time-out");
        assert_eq!(err.class(), "Client::Unauthorized::LoginTimeout");
    }

    #[test]
    fn test_with_custom_fields() {
        let mut details = BTreeMap::new();
        details.insert("reason".to_string(), Value::String("token_expired".into()));

        let err = UnauthorizedError::new()
            .with_code(498)
            .with_message("Token expired".to_string())
            .with_details(details.clone());

        assert_eq!(err.code(), 498);
        assert_eq!(err.message(), "Token expired");
        assert_eq!(err.details(), details);
    }

    #[test]
    fn test_conversion_to_core_error() {
        let err = NotFoundError::new().with_message("Page missing".to_string());
        let core: Error = err.into();

        assert_eq!(core.code(), 404);
        assert_eq!(core.message(), "Page missing");
    }

    #[test]
    fn test_generated_error_display() {
        let err = NotFoundError::new();
        let s = format!("{}", err);
        assert!(s.contains("NotFoundError"));
        assert!(s.contains("404"));
        assert!(s.contains("Resource Not Found"));
    }

    #[test]
    fn test_generated_error_with_code_and_details() {
        let mut details = BTreeMap::new();
        details.insert("path".to_string(), Value::String("/missing".into()));
        let err = NotFoundError::new()
            .with_code(404)
            .with_details(details.clone());
        assert_eq!(err.code(), 404);
        assert_eq!(err.details(), details);
    }

    #[test]
    fn test_generated_error_std_error_trait() {
        let err = NotFoundError::new();
        let _: &dyn std::error::Error = &err;
    }
}