1 use super::*;
2 use crate::{error_handling::HandleErrorLayer, extract::OriginalUri, response::IntoResponse, Json};
3 use serde_json::{json, Value};
4 use tower::{limit::ConcurrencyLimitLayer, timeout::TimeoutLayer};
5
6 #[crate::test]
basic()7 async fn basic() {
8 let one = Router::new()
9 .route("/foo", get(|| async {}))
10 .route("/bar", get(|| async {}));
11 let two = Router::new().route("/baz", get(|| async {}));
12 let app = one.merge(two);
13
14 let client = TestClient::new(app);
15
16 let res = client.get("/foo").send().await;
17 assert_eq!(res.status(), StatusCode::OK);
18
19 let res = client.get("/bar").send().await;
20 assert_eq!(res.status(), StatusCode::OK);
21
22 let res = client.get("/baz").send().await;
23 assert_eq!(res.status(), StatusCode::OK);
24
25 let res = client.get("/qux").send().await;
26 assert_eq!(res.status(), StatusCode::NOT_FOUND);
27 }
28
29 #[crate::test]
multiple_ors_balanced_differently()30 async fn multiple_ors_balanced_differently() {
31 let one = Router::new().route("/one", get(|| async { "one" }));
32 let two = Router::new().route("/two", get(|| async { "two" }));
33 let three = Router::new().route("/three", get(|| async { "three" }));
34 let four = Router::new().route("/four", get(|| async { "four" }));
35
36 test(
37 "one",
38 one.clone()
39 .merge(two.clone())
40 .merge(three.clone())
41 .merge(four.clone()),
42 )
43 .await;
44
45 test(
46 "two",
47 one.clone()
48 .merge(two.clone())
49 .merge(three.clone().merge(four.clone())),
50 )
51 .await;
52
53 test(
54 "three",
55 one.clone()
56 .merge(two.clone().merge(three.clone()).merge(four.clone())),
57 )
58 .await;
59
60 test("four", one.merge(two.merge(three.merge(four)))).await;
61
62 async fn test(name: &str, app: Router) {
63 let client = TestClient::new(app);
64
65 for n in ["one", "two", "three", "four"].iter() {
66 println!("running: {name} / {n}");
67 let res = client.get(&format!("/{n}")).send().await;
68 assert_eq!(res.status(), StatusCode::OK);
69 assert_eq!(res.text().await, *n);
70 }
71 }
72 }
73
74 #[crate::test]
nested_or()75 async fn nested_or() {
76 let bar = Router::new().route("/bar", get(|| async { "bar" }));
77 let baz = Router::new().route("/baz", get(|| async { "baz" }));
78
79 let bar_or_baz = bar.merge(baz);
80
81 let client = TestClient::new(bar_or_baz.clone());
82 assert_eq!(client.get("/bar").send().await.text().await, "bar");
83 assert_eq!(client.get("/baz").send().await.text().await, "baz");
84
85 let client = TestClient::new(Router::new().nest("/foo", bar_or_baz));
86 assert_eq!(client.get("/foo/bar").send().await.text().await, "bar");
87 assert_eq!(client.get("/foo/baz").send().await.text().await, "baz");
88 }
89
90 #[crate::test]
or_with_route_following()91 async fn or_with_route_following() {
92 let one = Router::new().route("/one", get(|| async { "one" }));
93 let two = Router::new().route("/two", get(|| async { "two" }));
94 let app = one.merge(two).route("/three", get(|| async { "three" }));
95
96 let client = TestClient::new(app);
97
98 let res = client.get("/one").send().await;
99 assert_eq!(res.status(), StatusCode::OK);
100
101 let res = client.get("/two").send().await;
102 assert_eq!(res.status(), StatusCode::OK);
103
104 let res = client.get("/three").send().await;
105 assert_eq!(res.status(), StatusCode::OK);
106 }
107
108 #[crate::test]
layer()109 async fn layer() {
110 let one = Router::new().route("/foo", get(|| async {}));
111 let two = Router::new()
112 .route("/bar", get(|| async {}))
113 .layer(ConcurrencyLimitLayer::new(10));
114 let app = one.merge(two);
115
116 let client = TestClient::new(app);
117
118 let res = client.get("/foo").send().await;
119 assert_eq!(res.status(), StatusCode::OK);
120
121 let res = client.get("/bar").send().await;
122 assert_eq!(res.status(), StatusCode::OK);
123 }
124
125 #[crate::test]
layer_and_handle_error()126 async fn layer_and_handle_error() {
127 let one = Router::new().route("/foo", get(|| async {}));
128 let two = Router::new()
129 .route("/timeout", get(std::future::pending::<()>))
130 .layer(
131 ServiceBuilder::new()
132 .layer(HandleErrorLayer::new(|_| async {
133 StatusCode::REQUEST_TIMEOUT
134 }))
135 .layer(TimeoutLayer::new(Duration::from_millis(10))),
136 );
137 let app = one.merge(two);
138
139 let client = TestClient::new(app);
140
141 let res = client.get("/timeout").send().await;
142 assert_eq!(res.status(), StatusCode::REQUEST_TIMEOUT);
143 }
144
145 #[crate::test]
nesting()146 async fn nesting() {
147 let one = Router::new().route("/foo", get(|| async {}));
148 let two = Router::new().nest("/bar", Router::new().route("/baz", get(|| async {})));
149 let app = one.merge(two);
150
151 let client = TestClient::new(app);
152
153 let res = client.get("/bar/baz").send().await;
154 assert_eq!(res.status(), StatusCode::OK);
155 }
156
157 #[crate::test]
boxed()158 async fn boxed() {
159 let one = Router::new().route("/foo", get(|| async {}));
160 let two = Router::new().route("/bar", get(|| async {}));
161 let app = one.merge(two);
162
163 let client = TestClient::new(app);
164
165 let res = client.get("/bar").send().await;
166 assert_eq!(res.status(), StatusCode::OK);
167 }
168
169 #[crate::test]
many_ors()170 async fn many_ors() {
171 let app = Router::new()
172 .route("/r1", get(|| async {}))
173 .merge(Router::new().route("/r2", get(|| async {})))
174 .merge(Router::new().route("/r3", get(|| async {})))
175 .merge(Router::new().route("/r4", get(|| async {})))
176 .merge(Router::new().route("/r5", get(|| async {})))
177 .merge(Router::new().route("/r6", get(|| async {})))
178 .merge(Router::new().route("/r7", get(|| async {})));
179
180 let client = TestClient::new(app);
181
182 for n in 1..=7 {
183 let res = client.get(&format!("/r{n}")).send().await;
184 assert_eq!(res.status(), StatusCode::OK);
185 }
186
187 let res = client.get("/r8").send().await;
188 assert_eq!(res.status(), StatusCode::NOT_FOUND);
189 }
190
191 #[crate::test]
services()192 async fn services() {
193 use crate::routing::get_service;
194
195 let app = Router::new()
196 .route(
197 "/foo",
198 get_service(service_fn(|_: Request<Body>| async {
199 Ok::<_, Infallible>(Response::new(Body::empty()))
200 })),
201 )
202 .merge(Router::new().route(
203 "/bar",
204 get_service(service_fn(|_: Request<Body>| async {
205 Ok::<_, Infallible>(Response::new(Body::empty()))
206 })),
207 ));
208
209 let client = TestClient::new(app);
210
211 let res = client.get("/foo").send().await;
212 assert_eq!(res.status(), StatusCode::OK);
213
214 let res = client.get("/bar").send().await;
215 assert_eq!(res.status(), StatusCode::OK);
216 }
217
all_the_uris( uri: Uri, OriginalUri(original_uri): OriginalUri, req: Request<Body>, ) -> impl IntoResponse218 async fn all_the_uris(
219 uri: Uri,
220 OriginalUri(original_uri): OriginalUri,
221 req: Request<Body>,
222 ) -> impl IntoResponse {
223 Json(json!({
224 "uri": uri.to_string(),
225 "request_uri": req.uri().to_string(),
226 "original_uri": original_uri.to_string(),
227 }))
228 }
229
230 #[crate::test]
nesting_and_seeing_the_right_uri()231 async fn nesting_and_seeing_the_right_uri() {
232 let one = Router::new().nest("/foo/", Router::new().route("/bar", get(all_the_uris)));
233 let two = Router::new().route("/foo", get(all_the_uris));
234
235 let client = TestClient::new(one.merge(two));
236
237 let res = client.get("/foo/bar").send().await;
238 assert_eq!(res.status(), StatusCode::OK);
239 assert_eq!(
240 res.json::<Value>().await,
241 json!({
242 "uri": "/bar",
243 "request_uri": "/bar",
244 "original_uri": "/foo/bar",
245 })
246 );
247
248 let res = client.get("/foo").send().await;
249 assert_eq!(res.status(), StatusCode::OK);
250 assert_eq!(
251 res.json::<Value>().await,
252 json!({
253 "uri": "/foo",
254 "request_uri": "/foo",
255 "original_uri": "/foo",
256 })
257 );
258 }
259
260 #[crate::test]
nesting_and_seeing_the_right_uri_at_more_levels_of_nesting()261 async fn nesting_and_seeing_the_right_uri_at_more_levels_of_nesting() {
262 let one = Router::new().nest(
263 "/foo/",
264 Router::new().nest("/bar", Router::new().route("/baz", get(all_the_uris))),
265 );
266 let two = Router::new().route("/foo", get(all_the_uris));
267
268 let client = TestClient::new(one.merge(two));
269
270 let res = client.get("/foo/bar/baz").send().await;
271 assert_eq!(res.status(), StatusCode::OK);
272 assert_eq!(
273 res.json::<Value>().await,
274 json!({
275 "uri": "/baz",
276 "request_uri": "/baz",
277 "original_uri": "/foo/bar/baz",
278 })
279 );
280
281 let res = client.get("/foo").send().await;
282 assert_eq!(res.status(), StatusCode::OK);
283 assert_eq!(
284 res.json::<Value>().await,
285 json!({
286 "uri": "/foo",
287 "request_uri": "/foo",
288 "original_uri": "/foo",
289 })
290 );
291 }
292
293 #[crate::test]
nesting_and_seeing_the_right_uri_ors_with_nesting()294 async fn nesting_and_seeing_the_right_uri_ors_with_nesting() {
295 let one = Router::new().nest(
296 "/one",
297 Router::new().nest("/bar", Router::new().route("/baz", get(all_the_uris))),
298 );
299 let two = Router::new().nest("/two", Router::new().route("/qux", get(all_the_uris)));
300 let three = Router::new().route("/three", get(all_the_uris));
301
302 let client = TestClient::new(one.merge(two).merge(three));
303
304 let res = client.get("/one/bar/baz").send().await;
305 assert_eq!(res.status(), StatusCode::OK);
306 assert_eq!(
307 res.json::<Value>().await,
308 json!({
309 "uri": "/baz",
310 "request_uri": "/baz",
311 "original_uri": "/one/bar/baz",
312 })
313 );
314
315 let res = client.get("/two/qux").send().await;
316 assert_eq!(res.status(), StatusCode::OK);
317 assert_eq!(
318 res.json::<Value>().await,
319 json!({
320 "uri": "/qux",
321 "request_uri": "/qux",
322 "original_uri": "/two/qux",
323 })
324 );
325
326 let res = client.get("/three").send().await;
327 assert_eq!(res.status(), StatusCode::OK);
328 assert_eq!(
329 res.json::<Value>().await,
330 json!({
331 "uri": "/three",
332 "request_uri": "/three",
333 "original_uri": "/three",
334 })
335 );
336 }
337
338 #[crate::test]
nesting_and_seeing_the_right_uri_ors_with_multi_segment_uris()339 async fn nesting_and_seeing_the_right_uri_ors_with_multi_segment_uris() {
340 let one = Router::new().nest(
341 "/one",
342 Router::new().nest("/foo", Router::new().route("/bar", get(all_the_uris))),
343 );
344 let two = Router::new().route("/two/foo", get(all_the_uris));
345
346 let client = TestClient::new(one.merge(two));
347
348 let res = client.get("/one/foo/bar").send().await;
349 assert_eq!(res.status(), StatusCode::OK);
350 assert_eq!(
351 res.json::<Value>().await,
352 json!({
353 "uri": "/bar",
354 "request_uri": "/bar",
355 "original_uri": "/one/foo/bar",
356 })
357 );
358
359 let res = client.get("/two/foo").send().await;
360 assert_eq!(res.status(), StatusCode::OK);
361 assert_eq!(
362 res.json::<Value>().await,
363 json!({
364 "uri": "/two/foo",
365 "request_uri": "/two/foo",
366 "original_uri": "/two/foo",
367 })
368 );
369 }
370
371 #[crate::test]
middleware_that_return_early()372 async fn middleware_that_return_early() {
373 let private = Router::new()
374 .route("/", get(|| async {}))
375 .layer(ValidateRequestHeaderLayer::bearer("password"));
376
377 let public = Router::new().route("/public", get(|| async {}));
378
379 let client = TestClient::new(private.merge(public));
380
381 assert_eq!(
382 client.get("/").send().await.status(),
383 StatusCode::UNAUTHORIZED
384 );
385 assert_eq!(
386 client
387 .get("/")
388 .header("authorization", "Bearer password")
389 .send()
390 .await
391 .status(),
392 StatusCode::OK
393 );
394 assert_eq!(
395 client.get("/doesnt-exist").send().await.status(),
396 StatusCode::NOT_FOUND
397 );
398 assert_eq!(client.get("/public").send().await.status(), StatusCode::OK);
399 }
400