purwa-core 0.2.0

Purwa framework kernel — router, middleware, and HTTP primitives
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

//! ValidatedJson / PurwaError response shape (Sprint 5).

use axum::Router;
use axum::body::Body;
use axum::http::{Request, StatusCode};
use axum::routing::post;
use purwa_core::ValidatedJson;
use serde::Deserialize;
use tower::ServiceExt;
use validator::Validate;

#[derive(Debug, Deserialize, Validate)]
struct SignUpDto {
    #[validate(email(message = "must be a valid email"))]
    email: String,
}

async fn signup(ValidatedJson(body): ValidatedJson<SignUpDto>) -> &'static str {
    let _ = body;
    "ok"
}

#[tokio::test]
async fn validation_failure_is_422_with_errors_map() {
    let app = Router::new().route("/signup", post(signup));
    let res = app
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/signup")
                .header("content-type", "application/json")
                .body(Body::from(r#"{"email":"not-an-email"}"#))
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY);
    let bytes = axum::body::to_bytes(res.into_body(), usize::MAX)
        .await
        .unwrap();
    let v: serde_json::Value = serde_json::from_slice(&bytes).unwrap();
    assert_eq!(v["message"], "Validation failed");
    let email_errs = v["errors"]["email"].as_array().expect("email errors");
    assert!(!email_errs.is_empty());
}

#[tokio::test]
async fn valid_json_passes_validation() {
    let app = Router::new().route("/signup", post(signup));
    let res = app
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/signup")
                .header("content-type", "application/json")
                .body(Body::from(r#"{"email":"a@b.co"}"#))
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(res.status(), StatusCode::OK);
}

#[tokio::test]
async fn malformed_json_is_400() {
    let app = Router::new().route("/signup", post(signup));
    let res = app
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/signup")
                .header("content-type", "application/json")
                .body(Body::from("{not json"))
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(res.status(), StatusCode::BAD_REQUEST);
}

use axum::routing::get;
use purwa_core::ValidatedForm;

#[derive(Debug, Deserialize, Validate)]
struct SearchDto {
    #[validate(length(min = 1))]
    q: String,
}

async fn search(ValidatedForm(q): ValidatedForm<SearchDto>) -> &'static str {
    let _ = q;
    "ok"
}

#[tokio::test]
async fn validated_form_query_validation_failure_422() {
    let app = Router::new().route("/search", get(search));
    let res = app
        .oneshot(
            Request::builder()
                .method("GET")
                .uri("/search?q=")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY);
}