arc-reactor 0.2.4

Minimal, Asynchronous, 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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

pub mod recognizer;
mod routegroup;
mod router;
mod util;

pub(crate) use self::util::*;
pub use self::{routegroup::*, router::*};

#[cfg(test)]
#[cfg(feature = "unstable")]
mod tests {
	use core::{Request, Response};
	use futures::{prelude::async_block, Future};
	use hyper::{Method, StatusCode};
	use impl_service::*;
	use proto::ArcService;

	use super::*;

	#[service]
	fn AsyncService(_req: Request, res: Response) {
		let res = res
			.with_status(StatusCode::Ok)
			.with_body("Hello World".as_bytes());
		Result::Ok(res)
	}

	#[test]
	fn it_matches_the_correct_routes() {
		let router = Router::new().get("/hello", AsyncService);

		let shouldExist = router.matchRoute("/hello", &Method::Get);
		let shouldNotExist = router.matchRoute("/world", &Method::Get);

		assert!(shouldExist.is_some());
		assert!(shouldNotExist.is_none());
	}

	#[test]
	fn it_matches_nested_routes() {
		let routegroup = RouteGroup::new("admin")
			.get("/roles", AsyncService)
			.get("/", AsyncService);
		let router = Router::new().group(routegroup);

		let shouldExist = router.matchRoute("/admin/roles", &Method::Get);
		let shouldExist1 = router.matchRoute("/admin", &Method::Get);
		let shouldExist2 = router.matchRoute("/admin/roles/", &Method::Get);
		let shouldExist3 = router.matchRoute("/admin/", &Method::Get);

		assert!(shouldExist.is_some());
		assert!(shouldExist1.is_some());
		assert!(shouldExist2.is_some());
		assert!(shouldExist3.is_some());
	}

	#[test]
	fn it_matches_routes_with_params() {
		let router = Router::new().get("/hello/:name", AsyncService);

		let shouldExist = router.matchRoute("/hello/seun", &Method::Get);
		let shouldNotExist = router.matchRoute("/world/seun/lanlege", &Method::Get);

		assert!(shouldExist.is_some());
		let routeMatch = shouldExist.unwrap();
		assert_eq!(routeMatch.params["name"], "seun");
		assert_ne!(routeMatch.params["name"], "seunlanlege");
		assert!(shouldNotExist.is_none());
	}

	#[test]
	fn it_matches_deeply_nested_routes() {
		let subrouter = RouteGroup::new("users").get("/profile", AsyncService);

		let routegroup = RouteGroup::new("admin")
			.get("/roles", AsyncService)
			.group(subrouter);

		let router = Router::new().group(routegroup);

		let shouldExist = router.matchRoute("/admin/roles/", &Method::Get);
		let shouldExist1 = router.matchRoute("/admin/users/profile/", &Method::Get);

		assert!(shouldExist.is_some());
		assert!(shouldExist1.is_some());
	}

	#[test]
	fn it_matches_wildcards() {
		let subrouter = RouteGroup::new("users").get("/profile", AsyncService);

		let routegroup = RouteGroup::new("admin")
			.get("/roles", AsyncService)
			.group(subrouter);

		let router = Router::new().group(routegroup);

		let shouldExist = router.matchRoute("/admin/roles/", &Method::Get);
		let shouldExist1 = router.matchRoute("/admin/users/profile/", &Method::Get);
		let shouldExist2 = router.matchRoute("/admin/sdkjbksjdjds", &Method::Get);

		assert!(shouldExist.is_some());
		assert!(shouldExist1.is_some());
		// assert!(shouldExist2.is_some());
	}
}