ohkami_lib 0.24.9

internal library for Ohkami - 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

use crate::serde_utf8;

#[test]
#[allow(clippy::bool_assert_comparison)]
fn serialize_bool() {
    assert_eq!(serde_utf8::to_string(&true).unwrap(), "true");
    assert_eq!(serde_utf8::to_string(&false).unwrap(), "false");
}

#[test]
fn serialize_newtype() {
    #[derive(serde::Serialize)]
    struct MyText(String);

    assert_eq!(
        serde_utf8::to_string(&MyText(String::from("Hello, serde!"))).unwrap(),
        "Hello, serde!"
    );

    #[derive(serde::Serialize)]
    struct MyCowText(std::borrow::Cow<'static, str>);

    assert_eq!(
        serde_utf8::to_string(&MyCowText(std::borrow::Cow::Borrowed("Hello, serde!"))).unwrap(),
        "Hello, serde!"
    );
}

#[test]
fn serialize_enum() {
    #![allow(dead_code)]

    #[derive(serde::Serialize)]
    enum Color {
        Red,
        Blue,
        Green,
    }

    assert_eq!(serde_utf8::to_string(&Color::Blue).unwrap(), "Blue");

    #[derive(serde::Serialize)]
    enum Color2 {
        #[serde(rename = "red")]
        Red,
        #[serde(rename = "blue")]
        Blue,
        #[serde(rename = "green")]
        Green,
    }

    assert_eq!(serde_utf8::to_string(&Color2::Blue).unwrap(), "blue");
}

#[test]
fn serialize_non_newtype_struct_makes_err() {
    #[derive(serde::Serialize)]
    struct User {
        id: usize,
        name: String,
    }

    assert!(
        serde_utf8::to_string(&User {
            id: 42,
            name: String::from("ohkami"),
        })
        .is_err()
    );
}

#[test]
#[allow(clippy::bool_assert_comparison)]
fn deserialize_bool() {
    assert_eq!(serde_utf8::from_str::<bool>("true").unwrap(), true);

    assert!(serde_utf8::from_str::<bool>("unknown").is_err(),);
}

#[test]
fn deserialize_newtype() {
    #[derive(serde::Deserialize, Debug, PartialEq)]
    struct MyText(String);

    assert_eq!(
        serde_utf8::from_str::<MyText>("Hello, serde!").unwrap(),
        MyText(String::from("Hello, serde!"))
    );

    #[derive(serde::Deserialize, Debug, PartialEq)]
    struct MyCowText(std::borrow::Cow<'static, str>);

    assert_eq!(
        serde_utf8::from_str::<MyCowText>("Hello, serde!").unwrap(),
        MyCowText(std::borrow::Cow::Borrowed("Hello, serde!"))
    );
}

#[test]
fn deserialize_non_newtype_struct_makes_err() {
    #[derive(serde::Deserialize)]
    struct User {
        _id: usize,
        _name: String,
    }

    assert!(serde_utf8::from_str::<User>("hogefuga").is_err());
}