vantus 0.3.0

Macro-first async Rust backend framework with explicit composition, typed extraction, and hardened HTTP defaults.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use vantus::{HostBuilder, Path, Request, Response, module};

#[derive(Clone, Default)]
struct RoutingModule;

#[derive(Clone, Default)]
struct AlternateRoutingModule;

#[derive(Clone, Default)]
struct CanonicalRoutingModule;

#[derive(Clone, Default)]
struct MethodModule;

#[module]
impl RoutingModule {
    #[vantus::get("/users/{id}")]
    fn show(&self, id: Path<u32>) -> Response {
        Response::text(format!("user {}", id.into_inner()))
    }
}

#[module]
impl AlternateRoutingModule {
    #[vantus::get("/users/{name}")]
    fn show(&self, name: Path<String>) -> Response {
        Response::text(format!("user {}", name.into_inner()))
    }
}

#[module]
impl CanonicalRoutingModule {
    #[vantus::get("/teams//{id}//")]
    fn team(&self, id: Path<u32>) -> Response {
        Response::text(format!("team {}", id.into_inner()))
    }

    #[vantus::get("/users/me")]
    fn me(&self) -> Response {
        Response::text("me")
    }

    #[vantus::get("/users/{id}")]
    fn user(&self, id: Path<String>) -> Response {
        Response::text(format!("user {}", id.into_inner()))
    }
}

#[module]
impl MethodModule {
    #[vantus::get("/items")]
    fn list(&self) -> Response {
        Response::text("items")
    }

    #[vantus::post("/items")]
    fn create(&self) -> Response {
        Response::text("created")
    }
}

#[tokio::test]
async fn macro_registered_route_matches_path_params() {
    let mut builder = HostBuilder::new();
    builder.module(RoutingModule);
    let host = builder.build();

    let response = host
        .handle(Request::from_bytes(b"GET /users/42 HTTP/1.1\r\nHost: local\r\n\r\n").unwrap())
        .await;

    assert_eq!(response.status_code, 200);
    assert_eq!(String::from_utf8(response.body).unwrap(), "user 42");
}

#[tokio::test]
async fn request_paths_are_normalized_before_routing() {
    let mut builder = HostBuilder::new();
    builder.module(CanonicalRoutingModule);
    let host = builder.build();

    let response = host
        .handle(Request::from_bytes(b"GET /teams//42// HTTP/1.1\r\nHost: local\r\n\r\n").unwrap())
        .await;

    assert_eq!(response.status_code, 200);
    assert_eq!(String::from_utf8(response.body).unwrap(), "team 42");
}

#[tokio::test]
async fn static_routes_win_over_dynamic_routes() {
    let mut builder = HostBuilder::new();
    builder.module(CanonicalRoutingModule);
    let host = builder.build();

    let response = host
        .handle(Request::from_bytes(b"GET /users/me HTTP/1.1\r\nHost: local\r\n\r\n").unwrap())
        .await;

    assert_eq!(response.status_code, 200);
    assert_eq!(String::from_utf8(response.body).unwrap(), "me");
}

#[tokio::test]
async fn wrong_method_returns_405_and_allow_header() {
    let mut builder = HostBuilder::new();
    builder.module(MethodModule);
    let host = builder.build();

    let response = host
        .handle(Request::from_bytes(b"PUT /items HTTP/1.1\r\nHost: local\r\n\r\n").unwrap())
        .await;

    assert_eq!(response.status_code, 405);
    assert!(
        response
            .headers
            .iter()
            .any(|(key, value)| key == "Allow" && value == "GET, POST")
    );
}

#[test]
#[should_panic(expected = "Module registration failed")]
fn duplicate_routes_fail_with_build_error() {
    let mut builder = HostBuilder::new();
    builder.module(RoutingModule);
    builder.module(RoutingModule);
    builder.build();
}

#[test]
fn semantically_equivalent_parameterized_routes_conflict() {
    let mut builder = HostBuilder::new();
    builder.module(RoutingModule);
    builder.module(AlternateRoutingModule);

    let error = builder.try_build().err().expect("build should fail");
    let message = error.to_string();

    assert!(message.contains("duplicate route registration"));
    assert!(message.contains("/users/{id}"));
    assert!(message.contains("/users/{name}"));
}