caelix 0.0.40

Public Caelix framework crate.
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

#![cfg(all(feature = "openapi", feature = "validator"))]

use caelix::openapi::{OpenApiConfig, ToSchema, response, utoipa};
use caelix::{
    Module, ModuleMetadata, Response, Result, TestApplication, controller, injectable,
    validator::Validate,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;

#[derive(Clone, Deserialize, Serialize, ToSchema, Validate)]
struct ValidatedBody {
    #[validate(length(min = 1))]
    email: String,
}

#[derive(Deserialize, ToSchema, Validate)]
struct ValidatedQuery {
    #[validate(length(min = 1))]
    search: String,
}

#[injectable]
struct ValidatedDocumentationController;

#[controller("/validated-docs")]
impl ValidatedDocumentationController {
    #[post("/body")]
    #[response(body = ValidatedBody)]
    async fn body(
        &self,
        #[body]
        #[validate]
        input: ValidatedBody,
    ) -> Result<Response<ValidatedBody>> {
        Ok(Response::Body(input))
    }

    #[get("/query")]
    #[response(body = ValidatedBody)]
    async fn query(
        &self,
        #[query]
        #[validate]
        query: ValidatedQuery,
    ) -> Result<Response<ValidatedBody>> {
        Ok(Response::Body(ValidatedBody {
            email: query.search,
        }))
    }
}

struct ValidatedDocumentationModule;

impl Module for ValidatedDocumentationModule {
    fn register() -> ModuleMetadata {
        ModuleMetadata::new().controller::<ValidatedDocumentationController>()
    }
}

#[caelix::test]
async fn validated_extractors_keep_their_openapi_schema_fields() {
    let app = TestApplication::new::<ValidatedDocumentationModule>()
        .with_openapi(OpenApiConfig::new("Validation", "1.0.0"))
        .await
        .unwrap();

    let document: Value = app.get("/openapi.json").send().await.unwrap().json().await;
    let body = &document["paths"]["/validated-docs/body"]["post"];
    let query = &document["paths"]["/validated-docs/query"]["get"];

    assert_eq!(
        body["requestBody"]["content"]["application/json"]["schema"]["$ref"],
        "#/components/schemas/ValidatedBody"
    );
    assert!(
        document["components"]["schemas"]["ValidatedBody"]["properties"]
            .get("email")
            .is_some()
    );
    assert!(
        query["parameters"][0]["schema"]["properties"]
            .get("search")
            .is_some()
    );
    assert_eq!(
        body["responses"]["400"]["content"]["application/json"]["schema"]["$ref"],
        "#/components/schemas/ValidationErrorEnvelope"
    );
    assert!(
        document["components"]["schemas"]["ValidationErrorEnvelope"]["properties"]
            .get("errors")
            .is_some()
    );
}