axum_error_macro 0.1.5

Simple derive macro for your custom Error enum to generate quickly its status code and message
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

mod params {
    use axum_error_macro::IntoResponse;
    use hyper::body::HttpBody;
    use serde_json::json;

    #[tokio::test]
    async fn right_param() {
        #[derive(IntoResponse)]
        enum Error {
            #[error(code = 404, msg = "Post by {} id was not found")]
            PostByIdNotFound(u32),
            #[error(code = 404, msg = "User by {} username was not found")]
            UserByUsernameNotFound(String),
        }
        let id = 12;
        let username = "Bebra";

        let post_error_msg = json!({
            "message": format!("Post by {} id was not found", id),
        });
        let user_error_msg = json!({
            "message": format!("User by {} username was not found", username),
        });

        assert_eq!(
            Error::PostByIdNotFound(id)
                .into_response()
                .data()
                .await
                .unwrap()
                .unwrap()
                .to_vec(),
            post_error_msg.to_string().as_bytes()
        );

        assert_eq!(
            Error::UserByUsernameNotFound(username.into())
                .into_response()
                .data()
                .await
                .unwrap()
                .unwrap()
                .to_vec(),
            user_error_msg.to_string().as_bytes()
        );
    }

    #[tokio::test]
    async fn right_multiply_params() {
        #[derive(IntoResponse)]
        enum Error {
            #[error(code = 404, msg = "User by {} username with {} role was not found")]
            UserByUsernameAndRoleNotFound(String, String),
        }

        let role = "ADMIN";
        let username = "Bebra";

        let error_msg = json!({
          "message": format!(
            "User by {} username with {} role was not found",
            username, role
        )
        });

        assert_eq!(
            Error::UserByUsernameAndRoleNotFound(username.into(), role.into())
                .into_response()
                .data()
                .await
                .unwrap()
                .unwrap()
                .to_vec(),
            error_msg.to_string().as_bytes()
        );
    }

    #[tokio::test]
    async fn struct_param() {
        #[derive(Debug)]
        struct User {
            username: String,
        }

        #[derive(IntoResponse)]
        enum Error {
            #[error(code = 404, msg = "User {:?}  was not found")]
            UserNotFound(User),
        }
        let user = User {
            username: "bebra".into(),
        };

        let error_msg = json!({
            "message": format!("User {:?}  was not found", user)
        });

        assert_eq!(
            Error::UserNotFound(user)
                .into_response()
                .data()
                .await
                .unwrap()
                .unwrap()
                .to_vec(),
            error_msg.to_string().as_bytes()
        );
    }
}