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
109
110
111
112
113
114
115
116
117
118
119
120
121

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

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

use serde_json::Value;

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

#[derive(Response)]
struct Foo {
    bar: &'static str,
}

impl_web! {
    impl TestContentType {
        #[get("/str_no_content_type")]
        fn str_no_content_type(&self) -> Result<&'static str, ()> {
            Ok("str_no_content_type")
        }

        #[get("/str_no_content_type.html")]
        fn str_no_content_type_html(&self) -> Result<&'static str, ()> {
            Ok("<html></html>")
        }

        #[get("/str_with_content_type")]
        #[content_type("foo/bar")]
        fn str_with_content_type(&self) -> Result<&'static str, ()> {
            Ok("str_with_content_type")
        }

        #[get("/json_no_content_type")]
        fn json_no_content_type(&self) -> Result<Value, ()> {
            Ok(json!({
                "foo": "hello world",
            }))
        }

        #[get("/json_with_content_type")]
        #[content_type("json")]
        fn json_with_content_type(&self) -> Result<Foo, ()> {
            Ok(Foo { bar: "baz" })
        }

        #[get("/json_with_content_type2")]
        #[content_type("foo/bar")]
        fn json_with_content_type2(&self) -> Result<Value, ()> {
            Ok(json!({
                "foo": "hello world",
            }))
        }
    }
}

#[test]
fn str_no_content_type() {
    let mut web = service(TestContentType);

    let response = web.call_unwrap(get!("/str_no_content_type"));
    assert_ok!(response);
    assert_header!(response, "content-type", "text/plain");
    assert_body!(response, "str_no_content_type");
}

#[test]
fn str_no_content_type_html() {
    let mut web = service(TestContentType);

    let response = web.call_unwrap(get!("/str_no_content_type.html"));
    assert_ok!(response);
    assert_header!(response, "content-type", "text/html");
    assert_body!(response, "<html></html>");
}

#[test]
fn str_with_content_type() {
    let mut web = service(TestContentType);

    let response = web.call_unwrap(get!("/str_with_content_type"));
    assert_ok!(response);
    assert_header!(response, "content-type", "foo/bar");
    assert_body!(response, "str_with_content_type");
}

#[test]
fn json_no_content_type() {
    let mut web = service(TestContentType);

    let response = web.call_unwrap(get!("/json_no_content_type"));
    assert_ok!(response);
    assert_header!(response, "content-type", "application/json");
    assert_body!(response, "{\"foo\":\"hello world\"}");
}

#[test]
fn json_with_content_type() {
    let mut web = service(TestContentType);

    let response = web.call_unwrap(get!("/json_with_content_type"));
    assert_ok!(response);
    assert_header!(response, "content-type", "application/json");
    assert_body!(response, "{\"bar\":\"baz\"}");
}

#[test]
fn json_with_content_type2() {
    let mut web = service(TestContentType);

    let response = web.call_unwrap(get!("/json_with_content_type2"));
    assert_ok!(response);
    assert_header!(response, "content-type", "foo/bar");
    assert_body!(response, "{\"foo\":\"hello world\"}");
}