1mod builder;
2mod parameters;
3mod route;
4mod router;
5
6pub use self::{builder::RouterBuilder, parameters::UrlParams, route::Route, router::Router};
7
8#[cfg(test)]
9mod integration_tests {
10 use super::router::RouterSvc;
11 use super::*;
12 use hyper::{Body, Method, Request, Response, Uri};
13 use std::str::FromStr;
14
15 fn handle_get_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
16 unimplemented!()
17 }
18 fn handle_post_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
19 unimplemented!()
20 }
21 fn handle_delete_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
22 unimplemented!()
23 }
24 fn handle_options_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
25 unimplemented!()
26 }
27 fn handle_put_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
28 unimplemented!()
29 }
30 fn handle_head_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
31 unimplemented!()
32 }
33 fn handle_trace_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
34 unimplemented!()
35 }
36 fn handle_patch_hello(_: UrlParams, _: Request<Body>) -> Response<Body> {
37 unimplemented!()
38 }
39 fn handle_get_root(_: UrlParams, _: Request<Body>) -> Response<Body> {
40 unimplemented!()
41 }
42 fn handle_post_root(_: UrlParams, _: Request<Body>) -> Response<Body> {
43 unimplemented!()
44 }
45 fn handle_get_foo(_: UrlParams, _: Request<Body>) -> Response<Body> {
46 unimplemented!()
47 }
48 fn handle_post_foo(_: UrlParams, _: Request<Body>) -> Response<Body> {
49 unimplemented!()
50 }
51 fn handle_get_bar(_: UrlParams, _: Request<Body>) -> Response<Body> {
52 unimplemented!()
53 }
54 fn handle_param_foo(_: UrlParams, _: Request<Body>) -> Response<Body> {
55 unimplemented!()
56 }
57 fn handle_param_bar(_: UrlParams, _: Request<Body>) -> Response<Body> {
58 unimplemented!()
59 }
60
61 fn test_router() -> RouterSvc {
62 let router = RouterBuilder::new()
63 .route(Route::url("/").get(handle_get_root).post(handle_post_root))
64 .route(
65 Route::url("/hello")
66 .get(handle_get_hello)
67 .post(handle_post_hello)
68 .patch(handle_patch_hello)
69 .put(handle_put_hello)
70 .delete(handle_delete_hello)
71 .options(handle_options_hello)
72 .trace(handle_trace_hello)
73 .head(handle_head_hello),
74 )
75 .route(Route::url("/foo").get(handle_get_foo).post(handle_post_foo))
76 .route(Route::url("/bar").get(handle_get_bar))
77 .route(Route::url("/foo/:id").get(handle_param_foo))
78 .route(Route::url("/bar/:id").get(handle_param_bar))
79 .build();
80
81 let routes = router.routes;
82 RouterSvc::new(routes)
83 }
84
85 #[test]
86 fn test_get_route() {
87 let request = Request::builder()
88 .method(Method::GET)
89 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
90 .body(Body::empty())
91 .unwrap();
92 let router = test_router();
93 let (handler, _) = router.route(&request).unwrap();
94 assert!(handler as fn(_, _) -> _ == handle_get_hello as fn(_, _) -> _);
95 }
96
97 #[test]
98 fn test_post_route() {
99 let request = Request::builder()
100 .method(Method::POST)
101 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
102 .body(Body::empty())
103 .unwrap();
104
105 let router = test_router();
106 let (handler, _) = router.route(&request).unwrap();
107 assert!(handler as fn(_, _) -> _ == handle_post_hello as fn(_, _) -> _);
108 }
109
110 #[test]
111 fn test_delete_route() {
112 let request = Request::builder()
113 .method(Method::DELETE)
114 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
115 .body(Body::empty())
116 .unwrap();
117
118 let router = test_router();
119 let (handler, _) = router.route(&request).unwrap();
120 assert!(handler as fn(_, _) -> _ == handle_delete_hello as fn(_, _) -> _);
121 }
122
123 #[test]
124 fn test_options_route() {
125 let request = Request::builder()
126 .method(Method::OPTIONS)
127 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
128 .body(Body::empty())
129 .unwrap();
130
131 let router = test_router();
132 let (handler, _) = router.route(&request).unwrap();
133 assert!(handler as fn(_, _) -> _ == handle_options_hello as fn(_, _) -> _);
134 }
135
136 #[test]
137 fn test_put_route() {
138 let request = Request::builder()
139 .method(Method::PUT)
140 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
141 .body(Body::empty())
142 .unwrap();
143
144 let router = test_router();
145 let (handler, _) = router.route(&request).unwrap();
146 assert!(handler as fn(_, _) -> _ == handle_put_hello as fn(_, _) -> _);
147 }
148
149 #[test]
150 fn test_head_route() {
151 let request = Request::builder()
152 .method(Method::HEAD)
153 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
154 .body(Body::empty())
155 .unwrap();
156
157 let router = test_router();
158 let (handler, _) = router.route(&request).unwrap();
159 assert!(handler as fn(_, _) -> _ == handle_head_hello as fn(_, _) -> _);
160 }
161
162 #[test]
163 fn test_trace_route() {
164 let request = Request::builder()
165 .method(Method::TRACE)
166 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
167 .body(Body::empty())
168 .unwrap();
169
170 let router = test_router();
171 let (handler, _) = router.route(&request).unwrap();
172 assert!(handler as fn(_, _) -> _ == handle_trace_hello as fn(_, _) -> _);
173 }
174
175 #[test]
176 fn test_patch_route() {
177 let request = Request::builder()
178 .method(Method::PATCH)
179 .uri(Uri::from_str("http://www.example.com/hello").unwrap())
180 .body(Body::empty())
181 .unwrap();
182
183 let router = test_router();
184 let (handler, _) = router.route(&request).unwrap();
185 assert!(handler as fn(_, _) -> _ == handle_patch_hello as fn(_, _) -> _);
186 }
187
188 #[test]
189 fn test_no_route() {
190 let request = Request::builder()
191 .method(Method::GET)
192 .uri(Uri::from_str("http://www.example.com/notfound").unwrap())
193 .body(Body::empty())
194 .unwrap();
195
196 let router = test_router();
197 match router.route(&request) {
198 Ok(_) => panic!("Expected an error, but got a handler instead"),
199 Err(e) => assert_eq!(e, hyper::StatusCode::NOT_FOUND),
200 }
201 }
202
203 #[test]
204 fn test_url_path_parameters() {
205 let request = Request::builder()
206 .method(Method::GET)
207 .uri(Uri::from_str("http://www.example.com/foo/bar").unwrap())
208 .body(Body::empty())
209 .unwrap();
210
211 let router = test_router();
212 let (handler, params) = router.route(&request).unwrap();
213 assert!(handler as fn(_, _) -> _ == handle_param_foo as fn(_, _) -> _);
214 assert!(params.captures.contains_key(":id"));
215 assert!(params.captures.get(":id") == Some(&"bar".to_string()));
216 }
217}