nestforge 1.9.0

NestJS-inspired modular backend framework 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

use axum::{routing::get, Json, Router};
use nestforge::{dto, Query, Validate};
use serde::Deserialize;
use tower::ServiceExt;

#[dto]
struct CreateUserDto {
    #[validate(required, email)]
    email: String,
    #[validate(min_length = 3, max_length = 12)]
    username: String,
    #[validate(min = 18, max = 120)]
    age: u32,
}

#[derive(Debug, Deserialize)]
struct SearchQuery {
    page: u32,
}

#[tokio::test]
async fn validate_supports_length_and_numeric_rules() {
    let dto = CreateUserDto {
        email: "bad-email".to_string(),
        username: "ab".to_string(),
        age: 17,
    };

    let errors = dto.validate().expect_err("dto should fail validation");
    let messages = errors
        .errors
        .iter()
        .map(|error| error.message.clone())
        .collect::<Vec<_>>();

    assert!(messages
        .iter()
        .any(|message| message.contains("valid email")));
    assert!(messages
        .iter()
        .any(|message| message.contains("at least 3 characters")));
    assert!(messages
        .iter()
        .any(|message| message.contains("at least 18")));
}

#[tokio::test]
async fn query_extractor_parses_typed_query_parameters() {
    let app = Router::new().route(
        "/search",
        get(|query: Query<SearchQuery>| async move { Json(query.value().page) }),
    );

    let response = app
        .oneshot(
            axum::http::Request::builder()
                .uri("/search?page=7")
                .body(axum::body::Body::empty())
                .expect("request should build"),
        )
        .await
        .expect("request should succeed");

    assert_eq!(response.status(), axum::http::StatusCode::OK);
}