ohkami 0.24.9

A performant, declarative, and runtime-flexible web 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
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

#![cfg(all(test, feature = "__rt_native__", feature = "DEBUG"))]

use crate::claw::{Json, Query, status};
use crate::prelude::*;
use crate::testing::*;
use ::serde::Deserialize;

#[cfg(feature = "openapi")]
use crate::openapi;

#[derive(Deserialize)]
#[allow(unused)]
struct User<'req> {
    name: &'req str,
    password: &'req str,
}
#[cfg(feature = "openapi")]
impl<'req> openapi::Schema for User<'req> {
    fn schema() -> impl Into<openapi::schema::SchemaRef> {
        openapi::component(
            "User",
            openapi::object()
                .property("name", openapi::string())
                .property("password", openapi::string()),
        )
    }
}

#[derive(Deserialize)]
struct HelloQuery<'req> {
    name: &'req str,
    repeat: Option<usize>,
}
#[cfg(feature = "openapi")]
impl<'req> openapi::Schema for HelloQuery<'req> {
    fn schema() -> impl Into<openapi::schema::SchemaRef> {
        openapi::component(
            "HelloQuery",
            openapi::object()
                .property("name", openapi::string())
                .optional("repeat", openapi::integer()),
        )
    }
}

#[test]
fn extract_required_payload() {
    async fn create_user(Json(_user): Json<User<'_>>) -> status::Created {
        status::Created(())
    }

    let t = Ohkami::new(("/".POST(create_user),)).test();

    crate::__rt__::testing::block_on(async {
        {
            let req = TestRequest::POST("/").json_lit(
                r#"{
                    "name": "kanarus",
                    "password": "passw0rd"
                }"#,
            );
            let _ = t.oneshot(req).await;
        }
    });
}

#[test]
fn extract_optional_payload() {
    async fn post_user(body: Option<Json<User<'_>>>) -> &'static str {
        if body.is_none() { "none" } else { "some" }
    }

    let t = Ohkami::new(("/".POST(post_user),)).test();

    crate::__rt__::testing::block_on(async {
        {
            let req = TestRequest::POST("/").json_lit(
                r#"{
                    "name": "kanarus",
                    "password": "passw0rd"
                }"#,
            );
            let res = t.oneshot(req).await;
            assert_eq!(res.text(), Some("some"));
        }
        {
            let req = TestRequest::POST("/");
            let res = t.oneshot(req).await;
            assert_eq!(res.text(), Some("none"));
        }
    });
}

#[test]
fn extract_query() {
    async fn hello(Query(HelloQuery { name, repeat }): Query<HelloQuery<'_>>) -> String {
        format!("Hello, {name}!").repeat(repeat.unwrap_or(1))
    }

    let t = Ohkami::new(("/".GET(hello),)).test();

    crate::__rt__::testing::block_on(async {
        {
            let req = TestRequest::GET("/").query("name", "ohkami");
            let res = t.oneshot(req).await;
            assert_eq!(res.status().code(), 200);
            assert_eq!(res.text(), Some("Hello, ohkami!"));
        }
        {
            let req = TestRequest::GET("/");
            let res = t.oneshot(req).await;
            assert_eq!(res.status().code(), 400);
            assert_eq!(res.text(), Some("missing field `name`"));
        }
        {
            let req = TestRequest::GET("/")
                .query("name", "ohkami")
                .query("repeat", "3");
            let res = t.oneshot(req).await;
            assert_eq!(res.status().code(), 200);
            assert_eq!(
                res.text(),
                Some("Hello, ohkami!Hello, ohkami!Hello, ohkami!")
            );
        }
    });
}