tower-web 0.3.7

Web framework with a focus on removing boilerplate
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

extern crate futures;
extern crate http;
#[macro_use]
extern crate tower_web;

#[macro_use]
mod support;
use support::*;

#[derive(Clone, Debug)]
struct TestParams;

impl_web! {
    impl TestParams {
        #[get("/str/:foo")]
        #[content_type("plain")]
        fn one_str_param(&self, foo: String) -> Result<&'static str, ()> {
            assert_eq!(foo, "hello");
            Ok("one_str_param")
        }

        #[get("/x-hello")]
        #[content_type("plain")]
        fn one_str_header(&self, x_hello: String) -> Result<&'static str, ()> {
            assert_eq!(x_hello, "world");
            Ok("one_str_header")
        }

        #[get("/u32/:foo")]
        #[content_type("plain")]
        fn one_u32_param(&self, foo: u32) -> Result<&'static str, ()> {
            assert_eq!(foo, 123);
            Ok("one_u32_param")
        }

        #[post("/content_length")]
        #[content_type("plain")]
        fn one_u32_header(&self, content_length: u32) -> Result<&'static str, ()> {
            assert_eq!(content_length, 5);
            Ok("one_u32_header")
        }

        #[get("/option_hdr")]
        #[content_type("plain")]
        fn option_header(&self, user_agent: Option<String>) -> Result<&'static str, ()> {
            if let Some(user_agent) = user_agent {
                assert_eq!(user_agent, "testin");
                Ok("option_header - some")
            } else {
                Ok("option_header - none")
            }
        }
    }
}

// TODO:
// - header missing

#[test]
fn one_str_param() {
    let mut web = service(TestParams);

    let response = web.call_unwrap(get!("/str/hello"));
    assert_ok!(response);
    assert_body!(response, "one_str_param");
}

#[test]
fn one_str_header() {
    let mut web = service(TestParams);


    let response = web.call_unwrap(get!("/x-hello", "x-hello": "world"));
    assert_ok!(response);
    assert_body!(response, "one_str_header");
}

#[test]
fn one_u32_param() {
    let mut web = service(TestParams);

    let response = web.call_unwrap(get!("/u32/123"));
    assert_ok!(response);
    assert_body!(response, "one_u32_param");
}

#[test]
fn one_u32_header() {
    let mut web = service(TestParams);

    let response = web.call_unwrap(post!("/content_length", "hello", "content-length": "5"));
    assert_ok!(response);
    assert_body!(response, "one_u32_header");
}

#[test]
fn option_header() {
    let mut web = service(TestParams);

    let response = web.call_unwrap(get!("/option_hdr"));
    assert_ok!(response);
    assert_body!(response, "option_header - none");

    let response = web.call_unwrap(get!("/option_hdr", "user-agent": "testin"));

    assert_ok!(response);
    assert_body!(response, "option_header - some");
}