simbld-http 1.0.0

A comprehensive HTTP response library for Rust.
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

/// Provides response codes, helpers, and utility functions for HTTP response management.
#[macro_use]
pub mod helpers;

pub mod mocks;
pub mod responses;
pub mod traits;
pub mod utils;

// Public exports for helpers
pub use helpers::auth_middleware::AuthMiddleware;
pub use helpers::generate_responses_functions;
pub use helpers::http_interceptor_helper::HttpInterceptor;
pub use helpers::unified_middleware_helper::UnifiedMiddleware;

// Public exports for mocks
pub use mocks::mock_responses::MockResponses;

// External crates re-exported for convenience
pub use serde_json::{json, Value};

// Public exports for response modules
pub use responses::ResponsesClientCodes;
pub use responses::ResponsesCrawlerCodes;
pub use responses::ResponsesInformationalCodes;
pub use responses::ResponsesLocalApiCodes;
pub use responses::ResponsesRedirectionCodes;
pub use responses::ResponsesServerCodes;
pub use responses::ResponsesServiceCodes;
pub use responses::ResponsesSuccessCodes;

// Module for tests
#[cfg(test)]
mod tests {
    use crate::helpers::http_code_helper::HttpCode;
    use crate::responses::ResponsesCrawlerCodes;
    use crate::ResponsesSuccessCodes;
    use serde_json::json;

    /// Test `get_code` method for `ResponsesCrawlerCodes`.
    #[test]
    fn test_crawler_codes_get_code() {
        assert_eq!(ResponsesCrawlerCodes::ParsingErrorHeader.get_code(), 400);
    }

    /// Test `from_u16` method for `ResponsesCrawlerCodes`.
    #[test]
    fn test_crawler_codes_from_u16() {
        assert_eq!(
            ResponsesCrawlerCodes::from_u16(700),
            Some(ResponsesCrawlerCodes::ParsingErrorUnfinishedHeader)
        );
    }

    /// Test `as_tuple` method for `ResponsesCrawlerCodes`.
    #[test]
    fn test_crawler_codes_as_tuple() {
        let code = ResponsesCrawlerCodes::InvalidURL;
        let http_code = code.to_http_code();
        assert_eq!(
            http_code,
            HttpCode {
                standard_code: 400,
                standard_name: "Bad Request",
                unified_description: "Invalid URL encountered by crawler.",
                internal_code: Some(786),
                internal_name: Some("Invalid URL")
            }
        );
    }

    /// Test `as_json` method for unified tuple format with standard code equals internal code.
    #[test]
    fn test_ok_codes_as_json() {
        let code = ResponsesSuccessCodes::Ok;
        let json_result = code.as_json();

        let expected = json!({
            "type": "Success responses",
            "details": {
                "standard http code": {
                    "code": 200,
                    "name": "OK"
                },
            "description": "Request processed successfully. Response will depend on the request method used, and the result will be either a representation of the requested resource or an empty response",
                "internal http code": {
                    "code": null,
                    "name": null,
        }}});

        assert_eq!(json_result, expected);
    }

    /// Test `as_json` method for unified tuple format with standard code differs internal code.
    #[test]
    fn test_crawler_codes_as_json() {
        let code = ResponsesCrawlerCodes::RobotsTemporarilyUnavailable;
        let json_result = code.as_json();

        let expected = json!({
            "type": "Crawler responses",
            "details": {
            "standard http code": {
                "code": 503,
                "name": "Service Unavailable"
            },
            "description": "Robots temporarily unavailable.",
            "internal http code": {
                "code": 741,
                "name": "Robots Temporarily Unavailable"
            },
        }});

        assert_eq!(json_result, expected);
    }
}