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

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

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

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

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

impl_web! {
    impl TestCatch {
        #[get("/buggy")]
        fn buggy(&self) -> Result<String, ()> {
            Err(())
        }

        #[get("/not_buggy")]
        fn not_buggy(&self) -> Result<String, ()> {
            Ok("not buggy".to_string())
        }

        #[catch]
        fn catch(&self) -> Result<&'static str, ()> {
            Ok("catch")
        }
    }

    impl TestDefaultCatch {
        #[get("/buggy")]
        fn buggy(&self) -> Result<String, ()> {
            Err(())
        }
    }
}

#[test]
fn catch_error() {
    let mut web = service(TestCatch);

    let response = web.call_unwrap(get!("/buggy"));
    assert_ok!(response);
    assert_body!(response, "catch");
}

#[test]
fn success() {
    let mut web = service(TestCatch);

    let response = web.call_unwrap(get!("/not_buggy"));
    assert_ok!(response);
    assert_body!(response, "not buggy");
}

#[test]
fn default_catch_internal() {
    let mut web = service(TestDefaultCatch);

    let response = web.call_unwrap(get!("/buggy"));
    assert_internal_error!(response);
    assert_body!(response, r#"{"type":"about:blank","title":"Internal Server Error"}"#);
}

#[test]
fn default_catch_not_found() {
    let mut web = service(TestDefaultCatch);

    let response = web.call_unwrap(get!("/missing"));
    assert_not_found!(response);
    assert_body!(response, r#"{"type":"about:blank","title":"Not Found"}"#);
}

#[test]
fn custom_global_catch() {
    use tower_service::NewService;

    let mut web = ::tower_web::ServiceBuilder::new()
        .resource(TestDefaultCatch)
        .catch(|_: &http::Request<()>, error: ::tower_web::Error| {
            assert!(error.status_code() == http::StatusCode::NOT_FOUND);

            let response = http::response::Builder::new()
                .status(http::StatusCode::NOT_FOUND)
                .header("content-type", "text/plain")
                .body("where you at?")
                .unwrap();

            Ok(response)
        })
        .build_new_service()
        .new_service()
        .wait().unwrap();

    let response = web.call_unwrap(get!("/missing"));
    assert_not_found!(response);
    assert_body!(response, "where you at?");
}