actix-web 0.7.0

Actix web is a simple, pragmatic and extremely fast web framework for Rust.
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

//! `x-www-form-urlencoded` meets Serde

extern crate dtoa;
extern crate itoa;

pub mod de;
pub mod ser;

#[doc(inline)]
pub use self::de::{from_bytes, from_reader, from_str, Deserializer};
#[doc(inline)]
pub use self::ser::{to_string, Serializer};

#[cfg(test)]
mod tests {
    #[test]
    fn deserialize_bytes() {
        let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];

        assert_eq!(super::from_bytes(b"first=23&last=42"), Ok(result));
    }

    #[test]
    fn deserialize_str() {
        let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];

        assert_eq!(super::from_str("first=23&last=42"), Ok(result));
    }

    #[test]
    fn deserialize_reader() {
        let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];

        assert_eq!(super::from_reader(b"first=23&last=42" as &[_]), Ok(result));
    }

    #[test]
    fn deserialize_option() {
        let result = vec![
            ("first".to_owned(), Some(23)),
            ("last".to_owned(), Some(42)),
        ];
        assert_eq!(super::from_str("first=23&last=42"), Ok(result));
    }

    #[test]
    fn deserialize_unit() {
        assert_eq!(super::from_str(""), Ok(()));
        assert_eq!(super::from_str("&"), Ok(()));
        assert_eq!(super::from_str("&&"), Ok(()));
        assert!(super::from_str::<()>("first=23").is_err());
    }

    #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
    enum X {
        A,
        B,
        C,
    }

    #[test]
    fn deserialize_unit_enum() {
        let result = vec![
            ("one".to_owned(), X::A),
            ("two".to_owned(), X::B),
            ("three".to_owned(), X::C),
        ];

        assert_eq!(super::from_str("one=A&two=B&three=C"), Ok(result));
    }

    #[test]
    fn serialize_option_map_int() {
        let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];

        assert_eq!(super::to_string(params), Ok("first=23&last=42".to_owned()));
    }

    #[test]
    fn serialize_option_map_string() {
        let params = &[
            ("first", Some("hello")),
            ("middle", None),
            ("last", Some("world")),
        ];

        assert_eq!(
            super::to_string(params),
            Ok("first=hello&last=world".to_owned())
        );
    }

    #[test]
    fn serialize_option_map_bool() {
        let params = &[("one", Some(true)), ("two", Some(false))];

        assert_eq!(
            super::to_string(params),
            Ok("one=true&two=false".to_owned())
        );
    }

    #[test]
    fn serialize_map_bool() {
        let params = &[("one", true), ("two", false)];

        assert_eq!(
            super::to_string(params),
            Ok("one=true&two=false".to_owned())
        );
    }

    #[test]
    fn serialize_unit_enum() {
        let params = &[("one", X::A), ("two", X::B), ("three", X::C)];
        assert_eq!(
            super::to_string(params),
            Ok("one=A&two=B&three=C".to_owned())
        );
    }
}