rocket_modules 0.1.2

A small crate that adds macros to conveniently organize Rocket route handlers in modules.
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

#[macro_use]
extern crate rocket_modules;

#[macro_use]
extern crate rocket;

fn str(route: &rocket::Route) -> String { route.name.as_ref().unwrap().to_string() }
macro_rules! assert_routes_eq {
    ($routes: ident, $module: ident) => {
        // Make sure all routes generated with routes! macro are present in module! macro output as well
        assert!($routes.iter().all(|r| $module.iter().any(|other| str(r) == str(other))));
        // Make sure all routes generated with module! would be generated when using routes! macro
    };
}

#[route_module]
mod articles {
    #[get("/")]
    pub fn _all() {}

    #[get("/<_id>")]
    pub fn _get_with_id(_id: &str) {}

    #[post("/<_id>")]
    pub fn _post_with_id(_id: &str) {}

    #[route(PATCH, uri = "/<_id>")]
    pub fn _patch_with_id(_id: &str) {}

    pub fn no_route() -> bool { true }

    pub fn no_route_too() {}
}

mod nested {
    #[route_module]
    pub mod authors {
        #[get("/")]
        pub fn _all() {}

        #[post("/")]
        pub fn _new() {}
    }
}

#[test]
fn test_route_number() {
    assert_eq!(articles::__routes().len(),  4);

    // Ensure functions are still there and did not got replaced by macro
    assert_eq!(articles::no_route(), true);
    assert_eq!(articles::no_route_too(), ());
}

#[test]
fn test_generated_route_fn() {
    assert!(articles::__routes().iter().any(|route| str(route) == "_all"));
}

#[test]
fn test_module_macro() {
    assert_eq!(articles::__routes().len(), module!(articles).len());

    let routes = routes![articles::_all, articles::_get_with_id, articles::_post_with_id, articles::_patch_with_id];
    let module = module!(articles);
    assert_eq!(routes.len(), module.len());

    assert_routes_eq!(routes, module);
}

#[test]
fn test_nested_module() {
    let routes = routes![nested::authors::_all, nested::authors::_new];
    let module = module!(nested::authors);
    assert_eq!(module.len(), 2);
    assert_routes_eq!(routes, module);
}