Coverage for test\test_routing.py: 99%

1 from nexios import get_application, NexiosApp

2 import pytest

3 from nexios.testing import Client

4 from nexios.http import Request, Response

5 from nexios.routing import Router, Routes

6

7

8@pytest.fixture

9 async def async_client():

10 app = get_application() # Fresh app instance for each test

11 async with Client(app, log_requests=True) as c:

12 yield c, app

13

14

15 async def test_route_decorator(async_client):

16 client, app = async_client # Extract client and app

17

18 @app.get("/get")

19 async def handle_get(req: Request, res: Response):

20 return res.json({"method": req.method})

21

22 @app.post("/post")

23 async def handle_post(req: Request, res: Response):

24 return res.json({"method": req.method})

25

26 # Test GET request

27 get_response = await client.get("/get")

28 assert get_response.status_code == 200

29 assert get_response.json() == {"method": "GET"}

30

31 # Test POST request

32 post_response = await client.post("/post")

33 assert post_response.status_code == 200

34 assert post_response.json() == {"method": "POST"}

35

36

37 async def test_add_route_method(async_client):

38 client, app = async_client # Extract client and app

39

40 async def handle_get(req: Request, res: Response):

41 return res.json({"method": req.method})

42

43 async def handle_post(req: Request, res: Response):

44 return res.json({"method": req.method})

45

46 # Add routes

47 app.add_route(Routes("/get", handle_get, methods=["GET"]))

48 app.add_route(Routes("/post", handle_post, methods=["POST"]))

49

50 # Test GET request

51 get_response = await client.get("/get")

52 assert get_response.status_code == 200

53 assert get_response.json() == {"method": "GET"}

54

55 # Test POST request

56 post_response = await client.post("/post")

57 assert post_response.status_code == 200

58 assert post_response.json() == {"method": "POST"}

59

60

61 async def test_routers_no_prefix(async_client):

62 client, app = async_client

63

64 router = Router()

65

66 @router.get("/")

67 async def handle_get(req: Request, res: Response):

68 return res.text("i love you")

69

70 app.mount_router(router)

71

72 response = await client.get("/")

73 assert response.status_code == 200

74

75

76 async def test_url_for_with_params(async_client):

77 client, app = async_client

78

79 @app.get("/get/name/{age}", name="name")

80 async def get(req: Request, res: Response): ...

81

82 url = app.url_for("name", age=0)

83 assert url == "/get/name/0"

84

85

86 async def test_url_for_with_request(async_client):

87 client, app = async_client

88

89 @app.get("/get/name/{age}", name="name")

90 async def get(req: Request, res: Response):

91

92 return res.json({"name": req.url_for("name", age=0)})

93

94 response = await client.get("/get/name/0")

95 data = response.json()

96 assert data["name"] == "/get/name/0"

97

98

99 async def test_url_parameters(async_client):

100 client, app = async_client

101

102 @app.get("/user/{user_id}")

103 async def handle_user(req: Request, res: Response):

104 user_id = req.path_params["user_id"]

105 return res.json({"user_id": user_id})

106

107 # Test with a specific user ID

108 response = await client.get("/user/123")

109 assert response.status_code == 200

110 assert response.json() == {"user_id": "123"}

111

112

113 async def test_route_prefixes(async_client):

114 client, app = async_client

115

116 # Create a router with a prefix

117 router = Router(prefix="/api")

118

119 @router.get("/users")

120 async def handle_users(req: Request, res: Response):

121 return res.json({"message": "Users Route"})

122

123 @router.post("/posts")

124 async def handle_posts(req: Request, res: Response):

125 return res.json({"message": "Posts Route"})

126

127 # Mount the router under the app

128 app.mount_router(router)

129

130 # Test the prefixed routes

131 users_response = await client.get("/api/users")

132 assert users_response.status_code == 200

133 assert users_response.json() == {"message": "Users Route"}

134

135 posts_response = await client.post("/api/posts")

136 assert posts_response.status_code == 200

137 assert posts_response.json() == {"message": "Posts Route"}

138

139

140 async def test_invalid_routes(async_client):

141 client, app = async_client

142

143 # Define a valid route

144 @app.get("/valid")

145 async def handle_valid(req: Request, res: Response):

146 return res.text("Valid Route")

147

148 # Test an invalid route

149 invalid_response = await client.get("/invalid")

150

151

152 async def test_nested_routers(async_client):

153 client, app = async_client

154

155 # Create a parent router

156 parent_router = Router(prefix="/parent")

157

158 # Create a child router

159 child_router = Router(prefix="/child")

160

161 @child_router.get("/nested")

162 async def handle_nested(req: Request, res: Response):

163 return res.text("Nested Router Works")

164

165 # Mount the child router under the parent router

166 parent_router.mount_router(child_router)

167

168 # Mount the parent router under the app

169 app.mount_router(parent_router)

170

171 # Test the nested route

172 response = await client.get("/parent/child/nested")

173 assert response.status_code == 200

174 assert response.text == "Nested Router Works"

175

176

177 async def test_handler_args(async_client):

178 client, app = async_client

179

180 @app.get("/user/{user_id}")

181 async def handle_user(req: Request, res: Response, user_id: str):

182 return res.json({"user_id": user_id})

183

184 # Test with a specific user ID

185 response = await client.get("/user/123")

186 assert response.status_code == 200

187 assert response.json() == {"user_id": "123"}