Debian Codegraph @

tests/auth_tests/test_decorators.py

raw
1 from asgiref.sync import iscoroutinefunction
2
3 from django.conf import settings
4 from django.contrib.auth import models
5 from django.contrib.auth.decorators import (
6 login_not_required,
7 login_required,
8 permission_required,
9 user_passes_test,
10 )
11 from django.core.exceptions import PermissionDenied
12 from django.http import HttpResponse
13 from django.test import TestCase, override_settings
14 from django.test.client import RequestFactory
15
16 from .test_views import AuthViewsTestCase
17
18
19 @override_settings(ROOT_URLCONF="auth_tests.urls")
20 class LoginRequiredTestCase(AuthViewsTestCase):
21 """
22 Tests the login_required decorators
23 """
24
25 factory = RequestFactory()
26
27 def test_wrapped_sync_function_is_not_coroutine_function(self):
28 def sync_view(request):
29 return HttpResponse()
30
31 wrapped_view = login_required(sync_view)
32 self.assertIs(iscoroutinefunction(wrapped_view), False)
33
34 def test_wrapped_async_function_is_coroutine_function(self):
35 async def async_view(request):
36 return HttpResponse()
37
38 wrapped_view = login_required(async_view)
39 self.assertIs(iscoroutinefunction(wrapped_view), True)
40
41 def test_callable(self):
42 """
43 login_required is assignable to callable objects.
44 """
45
46 class CallableView:
47 def __call__(self, *args, **kwargs):
48 pass
49
50 login_required(CallableView())
51
52 def test_view(self):
53 """
54 login_required is assignable to normal views.
55 """
56
57 def normal_view(request):
58 pass
59
60 login_required(normal_view)
61
62 def test_login_required(self, view_url="/login_required/", login_url=None):
63 """
64 login_required works on a simple view wrapped in a login_required
65 decorator.
66 """
67 if login_url is None:
68 login_url = settings.LOGIN_URL
69 response = self.client.get(view_url)
70 self.assertEqual(response.status_code, 302)
71 self.assertIn(login_url, response.url)
72 self.login()
73 response = self.client.get(view_url)
74 self.assertEqual(response.status_code, 200)
75
76 def test_login_required_next_url(self):
77 """
78 login_required works on a simple view wrapped in a login_required
79 decorator with a login_url set.
80 """
81 self.test_login_required(
82 view_url="/login_required_login_url/", login_url="/somewhere/"
83 )
84
85 async def test_login_required_async_view(self, login_url=None):
86 async def async_view(request):
87 return HttpResponse()
88
89 async def auser_anonymous():
90 return models.AnonymousUser()
91
92 async def auser():
93 return self.u1
94
95 if login_url is None:
96 async_view = login_required(async_view)
97 login_url = settings.LOGIN_URL
98 else:
99 async_view = login_required(async_view, login_url=login_url)
100
101 request = self.factory.get("/rand")
102 request.auser = auser_anonymous
103 response = await async_view(request)
104 self.assertEqual(response.status_code, 302)
105 self.assertIn(login_url, response.url)
106
107 request.auser = auser
108 response = await async_view(request)
109 self.assertEqual(response.status_code, 200)
110
111 async def test_login_required_next_url_async_view(self):
112 await self.test_login_required_async_view(login_url="/somewhere/")
113
114
115 class LoginNotRequiredTestCase(TestCase):
116 """
117 Tests the login_not_required decorators
118 """
119
120 def test_callable(self):
121 """
122 login_not_required is assignable to callable objects.
123 """
124
125 class CallableView:
126 def __call__(self, *args, **kwargs):
127 pass
128
129 login_not_required(CallableView())
130
131 def test_view(self):
132 """
133 login_not_required is assignable to normal views.
134 """
135
136 def normal_view(request):
137 pass
138
139 login_not_required(normal_view)
140
141 def test_decorator_marks_view_as_login_not_required(self):
142 @login_not_required
143 def view(request):
144 return HttpResponse()
145
146 self.assertFalse(view.login_required)
147
148
149 class PermissionsRequiredDecoratorTest(TestCase):
150 """
151 Tests for the permission_required decorator
152 """
153
154 factory = RequestFactory()
155
156 @classmethod
157 def setUpTestData(cls):
158 cls.user = models.User.objects.create(username="joe", password="qwerty")
159 # Add permissions auth.add_customuser and auth.change_customuser
160 perms = models.Permission.objects.filter(
161 codename__in=("add_customuser", "change_customuser")
162 )
163 cls.user.user_permissions.add(*perms)
164
165 @classmethod
166 async def auser(cls):
167 return cls.user
168
169 def test_wrapped_sync_function_is_not_coroutine_function(self):
170 def sync_view(request):
171 return HttpResponse()
172
173 wrapped_view = permission_required([])(sync_view)
174 self.assertIs(iscoroutinefunction(wrapped_view), False)
175
176 def test_wrapped_async_function_is_coroutine_function(self):
177 async def async_view(request):
178 return HttpResponse()
179
180 wrapped_view = permission_required([])(async_view)
181 self.assertIs(iscoroutinefunction(wrapped_view), True)
182
183 def test_many_permissions_pass(self):
184 @permission_required(
185 ["auth_tests.add_customuser", "auth_tests.change_customuser"]
186 )
187 def a_view(request):
188 return HttpResponse()
189
190 request = self.factory.get("/rand")
191 request.user = self.user
192 resp = a_view(request)
193 self.assertEqual(resp.status_code, 200)
194
195 def test_many_permissions_in_set_pass(self):
196 @permission_required(
197 {"auth_tests.add_customuser", "auth_tests.change_customuser"}
198 )
199 def a_view(request):
200 return HttpResponse()
201
202 request = self.factory.get("/rand")
203 request.user = self.user
204 resp = a_view(request)
205 self.assertEqual(resp.status_code, 200)
206
207 def test_single_permission_pass(self):
208 @permission_required("auth_tests.add_customuser")
209 def a_view(request):
210 return HttpResponse()
211
212 request = self.factory.get("/rand")
213 request.user = self.user
214 resp = a_view(request)
215 self.assertEqual(resp.status_code, 200)
216
217 def test_permissioned_denied_redirect(self):
218 @permission_required(
219 [
220 "auth_tests.add_customuser",
221 "auth_tests.change_customuser",
222 "nonexistent-permission",
223 ]
224 )
225 def a_view(request):
226 return HttpResponse()
227
228 request = self.factory.get("/rand")
229 request.user = self.user
230 resp = a_view(request)
231 self.assertEqual(resp.status_code, 302)
232
233 def test_permissioned_denied_exception_raised(self):
234 @permission_required(
235 [
236 "auth_tests.add_customuser",
237 "auth_tests.change_customuser",
238 "nonexistent-permission",
239 ],
240 raise_exception=True,
241 )
242 def a_view(request):
243 return HttpResponse()
244
245 request = self.factory.get("/rand")
246 request.user = self.user
247 with self.assertRaises(PermissionDenied):
248 a_view(request)
249
250 async def test_many_permissions_pass_async_view(self):
251 @permission_required(
252 ["auth_tests.add_customuser", "auth_tests.change_customuser"]
253 )
254 async def async_view(request):
255 return HttpResponse()
256
257 request = self.factory.get("/rand")
258 request.auser = self.auser
259 response = await async_view(request)
260 self.assertEqual(response.status_code, 200)
261
262 async def test_many_permissions_in_set_pass_async_view(self):
263 @permission_required(
264 {"auth_tests.add_customuser", "auth_tests.change_customuser"}
265 )
266 async def async_view(request):
267 return HttpResponse()
268
269 request = self.factory.get("/rand")
270 request.auser = self.auser
271 response = await async_view(request)
272 self.assertEqual(response.status_code, 200)
273
274 async def test_single_permission_pass_async_view(self):
275 @permission_required("auth_tests.add_customuser")
276 async def async_view(request):
277 return HttpResponse()
278
279 request = self.factory.get("/rand")
280 request.auser = self.auser
281 response = await async_view(request)
282 self.assertEqual(response.status_code, 200)
283
284 async def test_permissioned_denied_redirect_async_view(self):
285 @permission_required(
286 [
287 "auth_tests.add_customuser",
288 "auth_tests.change_customuser",
289 "nonexistent-permission",
290 ]
291 )
292 async def async_view(request):
293 return HttpResponse()
294
295 request = self.factory.get("/rand")
296 request.auser = self.auser
297 response = await async_view(request)
298 self.assertEqual(response.status_code, 302)
299
300 async def test_permissioned_denied_exception_raised_async_view(self):
301 @permission_required(
302 [
303 "auth_tests.add_customuser",
304 "auth_tests.change_customuser",
305 "nonexistent-permission",
306 ],
307 raise_exception=True,
308 )
309 async def async_view(request):
310 return HttpResponse()
311
312 request = self.factory.get("/rand")
313 request.auser = self.auser
314 with self.assertRaises(PermissionDenied):
315 await async_view(request)
316
317
318 class UserPassesTestDecoratorTest(TestCase):
319 factory = RequestFactory()
320
321 @classmethod
322 def setUpTestData(cls):
323 cls.user_pass = models.User.objects.create(username="joe", password="qwerty")
324 cls.user_deny = models.User.objects.create(username="jim", password="qwerty")
325 models.Group.objects.create(name="Joe group")
326 # Add permissions auth.add_customuser and auth.change_customuser
327 perms = models.Permission.objects.filter(
328 codename__in=("add_customuser", "change_customuser")
329 )
330 cls.user_pass.user_permissions.add(*perms)
331
332 @classmethod
333 async def auser_pass(cls):
334 return cls.user_pass
335
336 @classmethod
337 async def auser_deny(cls):
338 return cls.user_deny
339
340 def test_wrapped_sync_function_is_not_coroutine_function(self):
341 def sync_view(request):
342 return HttpResponse()
343
344 wrapped_view = user_passes_test(lambda user: True)(sync_view)
345 self.assertIs(iscoroutinefunction(wrapped_view), False)
346
347 def test_wrapped_async_function_is_coroutine_function(self):
348 async def async_view(request):
349 return HttpResponse()
350
351 wrapped_view = user_passes_test(lambda user: True)(async_view)
352 self.assertIs(iscoroutinefunction(wrapped_view), True)
353
354 def test_decorator(self):
355 def sync_test_func(user):
356 return bool(
357 models.Group.objects.filter(name__istartswith=user.username).exists()
358 )
359
360 @user_passes_test(sync_test_func)
361 def sync_view(request):
362 return HttpResponse()
363
364 request = self.factory.get("/rand")
365 request.user = self.user_pass
366 response = sync_view(request)
367 self.assertEqual(response.status_code, 200)
368
369 request.user = self.user_deny
370 response = sync_view(request)
371 self.assertEqual(response.status_code, 302)
372
373 def test_decorator_async_test_func(self):
374 async def async_test_func(user):
375 return await user.ahas_perms(["auth_tests.add_customuser"])
376
377 @user_passes_test(async_test_func)
378 def sync_view(request):
379 return HttpResponse()
380
381 request = self.factory.get("/rand")
382 request.user = self.user_pass
383 response = sync_view(request)
384 self.assertEqual(response.status_code, 200)
385
386 request.user = self.user_deny
387 response = sync_view(request)
388 self.assertEqual(response.status_code, 302)
389
390 async def test_decorator_async_view(self):
391 def sync_test_func(user):
392 return bool(
393 models.Group.objects.filter(name__istartswith=user.username).exists()
394 )
395
396 @user_passes_test(sync_test_func)
397 async def async_view(request):
398 return HttpResponse()
399
400 request = self.factory.get("/rand")
401 request.auser = self.auser_pass
402 response = await async_view(request)
403 self.assertEqual(response.status_code, 200)
404
405 request.auser = self.auser_deny
406 response = await async_view(request)
407 self.assertEqual(response.status_code, 302)
408
409 async def test_decorator_async_view_async_test_func(self):
410 async def async_test_func(user):
411 return await user.ahas_perms(["auth_tests.add_customuser"])
412
413 @user_passes_test(async_test_func)
414 async def async_view(request):
415 return HttpResponse()
416
417 request = self.factory.get("/rand")
418 request.auser = self.auser_pass
419 response = await async_view(request)
420 self.assertEqual(response.status_code, 200)
421
422 request.auser = self.auser_deny
423 response = await async_view(request)
424 self.assertEqual(response.status_code, 302)