axum_responses 0.4.3

A Simple way to use Axum responses
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

mod handlers;

use axum::{routing::get, Router};
use axum_test::TestServer;
use handlers::*;

#[allow(dead_code)]
fn app() -> TestServer {
    let router = Router::new()
        .route("/http-response-ok", get(http_response_simple_handler))
        .route("/http-response-macro", get(http_response_macro_handler))
        .route("/http-response-data", get(http_response_data_handler))
        .route("/http-response-error", get(http_response_error_handler))
        .route(
            "/single-object-response",
            get(single_object_response_handler),
        )
        .route("/http-message-macro", get(http_message_macro_handler))
        .route("/http-no-data", get(http_no_data_handler));

    TestServer::new(router).unwrap()
}

#[tokio::test]
async fn test_http_response_simple() {
    use crate::http::ResponseBody;

    let server = app();
    let response = server.get("/http-response-ok").await;

    let body = response.json::<ResponseBody>();

    assert_eq!(response.status_code().as_u16(), 200_u16);
    assert_eq!(*body.message, *"This is a simple response");
}

#[tokio::test]
async fn test_http_response_macro() {
    let server = app();
    let response = server.get("/http-response-macro").await;

    let body = response.json::<serde_json::Value>();
    let message = body.get("message").unwrap().as_str().unwrap();

    assert_eq!(response.status_code().as_u16(), 200_u16);
    assert_eq!(message, "This is the response macro!");
}

#[tokio::test]
async fn test_http_response_data() {
    use crate::http::ResponseBody;

    let server = app();
    let response = server.get("/http-response-data").await;

    let body = response.json::<ResponseBody>();

    assert_eq!(response.status_code().as_u16(), 201_u16);
    assert_eq!(*body.message, *"Item created successfully");

    assert!(body.data.is_some());
    let data = body.data.unwrap();

    assert_eq!(data.get("id").unwrap().as_u64().unwrap(), 1);
    assert_eq!(data.get("name").unwrap().as_str().unwrap(), "Test Item");
    assert_eq!(
        data.get("tags").unwrap().as_array().unwrap(),
        &vec![
            serde_json::Value::String("test".to_string()),
            serde_json::Value::String("demo".to_string())
        ]
    );
}

#[tokio::test]
async fn test_http_response_error() {
    use crate::http::ResponseBody;

    let server = app();
    let response = server.get("/http-response-error").await;

    let body = response.json::<ResponseBody>();

    assert_eq!(response.status_code().as_u16(), 400_u16);
    assert_eq!(*body.message, *"This is an error response");

    assert!(body.error.is_some());
    let error = body.error.unwrap();

    assert_eq!(
        error.get("type").unwrap().as_str().unwrap(),
        "ValidationError"
    );

    let errors = error.get("errors").unwrap().as_object().unwrap();
    assert_eq!(
        errors.get("param1").unwrap().as_str().unwrap(),
        "Invalid value for param1"
    );
    assert_eq!(
        errors.get("param2").unwrap().as_str().unwrap(),
        "Param2 is required"
    );
}

#[tokio::test]
async fn test_single_object_response() {
    use crate::http::ResponseBody;

    let server = app();
    let response = server.get("/single-object-response").await;

    let body = response.json::<ResponseBody>();

    assert_eq!(response.status_code().as_u16(), 200_u16);

    assert!(body.data.is_some());
    let data = body.data.unwrap();

    assert_eq!(data.get("id").unwrap().as_u64().unwrap(), 1);
    assert_eq!(data.get("name").unwrap().as_str().unwrap(), "Test Object");
}

#[tokio::test]
async fn test_http_message_macro() {
    use crate::http::ResponseBody;
    let server = app();
    let response = server.get("/http-message-macro").await;

    let body = response.json::<ResponseBody>();

    assert_eq!(response.status_code().as_u16(), 200_u16);
    assert_eq!(*body.message, *"This is a message macro response!");
    assert_eq!(body.data, None);
}

#[tokio::test]
async fn test_http_no_data() {
    use crate::http::ResponseBody;
    let server = app();
    let response = server.get("/http-no-data").await;

    let body = response.json::<ResponseBody>();

    assert_eq!(response.status_code().as_u16(), 200_u16);
    assert_eq!(*body.message, *"This is a no data response");
    assert_eq!(body.data, None);
}