rapina 0.11.0

A fast, type-safe web framework for Rust inspired by FastAPI
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

use std::collections::HashMap;

use http::Method;

/// O(1) lookup table for routes with no path parameters.
///
/// Built at `prepare()` time from the full route list. Routes whose
/// patterns contain `:param` segments are skipped — they go through
/// the linear scanner.
pub(super) struct StaticMap {
    map: HashMap<Method, HashMap<String, usize>>,
}

impl StaticMap {
    pub(super) fn build(routes: &[(Method, super::Route)]) -> Self {
        let mut map: HashMap<Method, HashMap<String, usize>> = HashMap::new();
        for (idx, (method, route)) in routes.iter().enumerate() {
            if !super::is_dynamic(&route.pattern) {
                map.entry(method.clone())
                    .or_default()
                    .insert(route.pattern.clone(), idx);
            }
        }
        Self { map }
    }

    pub(super) fn lookup(&self, method: &Method, path: &str) -> Option<usize> {
        self.map.get(method)?.get(path).copied()
    }

    #[cfg(test)]
    pub fn len(&self) -> usize {
        self.map.values().map(|m| m.len()).sum()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_build_partitions_static_and_dynamic() {
        let router = crate::router::Router::new()
            .route(Method::GET, "/health", |_, _, _| async {
                http::StatusCode::OK
            })
            .route(Method::GET, "/users", |_, _, _| async {
                http::StatusCode::OK
            })
            .route(Method::GET, "/users/:id", |_, _, _| async {
                http::StatusCode::OK
            })
            .route(Method::POST, "/users", |_, _, _| async {
                http::StatusCode::CREATED
            });

        let static_map = StaticMap::build(&router.routes);

        // 3 static routes: GET /health, GET /users, POST /users
        assert_eq!(static_map.len(), 3);
        assert!(static_map.lookup(&Method::GET, "/health").is_some());
        assert!(static_map.lookup(&Method::GET, "/users").is_some());
        assert!(static_map.lookup(&Method::POST, "/users").is_some());
        // dynamic route not in static map
        assert!(static_map.lookup(&Method::GET, "/users/:id").is_none());
    }

    #[test]
    fn test_lookup_miss_wrong_method() {
        let router = crate::router::Router::new().route(Method::GET, "/health", |_, _, _| async {
            http::StatusCode::OK
        });

        let static_map = StaticMap::build(&router.routes);

        assert!(static_map.lookup(&Method::GET, "/health").is_some());
        assert!(static_map.lookup(&Method::POST, "/health").is_none());
    }

    #[test]
    fn test_lookup_miss_wrong_path() {
        let router = crate::router::Router::new().route(Method::GET, "/health", |_, _, _| async {
            http::StatusCode::OK
        });

        let static_map = StaticMap::build(&router.routes);

        assert!(static_map.lookup(&Method::GET, "/nonexistent").is_none());
    }

    #[test]
    fn test_empty_routes() {
        let router = crate::router::Router::new();
        let static_map = StaticMap::build(&router.routes);
        assert_eq!(static_map.len(), 0);
    }

    #[test]
    fn test_all_dynamic_routes() {
        let router = crate::router::Router::new()
            .route(Method::GET, "/users/:id", |_, _, _| async {
                http::StatusCode::OK
            })
            .route(Method::GET, "/posts/:id/comments/:cid", |_, _, _| async {
                http::StatusCode::OK
            });

        let static_map = StaticMap::build(&router.routes);
        assert_eq!(static_map.len(), 0);
    }

    #[test]
    fn test_returns_correct_index() {
        let router = crate::router::Router::new()
            .route(Method::GET, "/first", |_, _, _| async {
                http::StatusCode::OK
            })
            .route(Method::GET, "/second", |_, _, _| async {
                http::StatusCode::OK
            })
            .route(Method::GET, "/third", |_, _, _| async {
                http::StatusCode::OK
            });

        let static_map = StaticMap::build(&router.routes);

        assert_eq!(static_map.lookup(&Method::GET, "/first"), Some(0));
        assert_eq!(static_map.lookup(&Method::GET, "/second"), Some(1));
        assert_eq!(static_map.lookup(&Method::GET, "/third"), Some(2));
    }
}