rkt_codegen 0.6.0

Procedural macros for the rkt web framework.
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

// Rocket sometimes generates mangled identifiers that activate the
// non_snake_case lint. We deny the lint in this test to ensure that
// code generation uses #[allow(non_snake_case)] in the appropriate places.
#![deny(non_snake_case)]

#[macro_use]
extern crate rkt;

use rkt::http::Status;
use rkt::local::blocking::Client;
use rkt::{Build, Request, Rocket};

#[catch(404)]
fn not_found_0() -> &'static str {
    "404-0"
}
#[catch(404)]
fn not_found_1(_: &Request<'_>) -> &'static str {
    "404-1"
}
#[catch(404)]
fn not_found_2(_: Status, _: &Request<'_>) -> &'static str {
    "404-2"
}
#[catch(default)]
fn all(_: Status, r: &Request<'_>) -> String {
    r.uri().to_string()
}

#[test]
fn test_simple_catchers() {
    fn rocket() -> Rocket<Build> {
        rkt::build()
            .register("/0", catchers![not_found_0])
            .register("/1", catchers![not_found_1])
            .register("/2", catchers![not_found_2])
            .register("/", catchers![all])
    }

    let client = Client::debug(rocket()).unwrap();
    for i in 0..6 {
        let response = client.get(format!("/{}", i)).dispatch();
        assert_eq!(response.status(), Status::NotFound);

        match i {
            0..=2 => assert_eq!(response.into_string().unwrap(), format!("404-{}", i)),
            _ => assert_eq!(response.into_string().unwrap(), format!("/{}", i)),
        }
    }
}

#[get("/<code>")]
fn forward(code: u16) -> Status {
    Status::new(code)
}
#[catch(400)]
fn forward_400(status: Status, _: &Request<'_>) -> String {
    status.code.to_string()
}
#[catch(404)]
fn forward_404(status: Status, _: &Request<'_>) -> String {
    status.code.to_string()
}
#[catch(444)]
fn forward_444(status: Status, _: &Request<'_>) -> String {
    status.code.to_string()
}
#[catch(500)]
fn forward_500(status: Status, _: &Request<'_>) -> String {
    status.code.to_string()
}

#[test]
fn test_status_param() {
    fn rocket() -> Rocket<Build> {
        rkt::build().mount("/", routes![forward]).register(
            "/",
            catchers![forward_400, forward_404, forward_444, forward_500],
        )
    }

    let client = Client::debug(rocket()).unwrap();
    for code in &[400, 404, 444, 400, 800, 3480] {
        let response = client.get(uri!(forward(*code))).dispatch();
        let code = std::cmp::min(*code, 500);
        assert_eq!(response.status(), Status::new(code));
        assert_eq!(response.into_string().unwrap(), code.to_string());
    }
}