Debian Codegraph @

tests/auth_tests/test_remote_user.py

raw
1 from datetime import datetime, timezone
2
3 from django.conf import settings
4 from django.contrib.auth import aauthenticate, authenticate
5 from django.contrib.auth.backends import RemoteUserBackend
6 from django.contrib.auth.middleware import RemoteUserMiddleware
7 from django.contrib.auth.models import User
8 from django.middleware.csrf import _get_new_csrf_string, _mask_cipher_secret
9 from django.test import (
10 AsyncClient,
11 Client,
12 TestCase,
13 modify_settings,
14 override_settings,
15 )
16 from django.utils.deprecation import RemovedInDjango61Warning
17
18
19 @override_settings(ROOT_URLCONF="auth_tests.urls")
20 class RemoteUserTest(TestCase):
21 middleware = "django.contrib.auth.middleware.RemoteUserMiddleware"
22 backend = "django.contrib.auth.backends.RemoteUserBackend"
23 header = "REMOTE_USER"
24 email_header = "REMOTE_EMAIL"
25
26 # Usernames to be passed in REMOTE_USER for the test_known_user test case.
27 known_user = "knownuser"
28 known_user2 = "knownuser2"
29
30 @classmethod
31 def setUpClass(cls):
32 cls.enterClassContext(
33 modify_settings(
34 AUTHENTICATION_BACKENDS={"append": cls.backend},
35 MIDDLEWARE={"append": cls.middleware},
36 )
37 )
38 super().setUpClass()
39
40 def test_passing_explicit_none(self):
41 msg = "get_response must be provided."
42 with self.assertRaisesMessage(ValueError, msg):
43 RemoteUserMiddleware(None)
44
45 def test_no_remote_user(self):
46 """Users are not created when remote user is not specified."""
47 num_users = User.objects.count()
48
49 response = self.client.get("/remote_user/")
50 self.assertTrue(response.context["user"].is_anonymous)
51 self.assertEqual(User.objects.count(), num_users)
52
53 response = self.client.get("/remote_user/", **{self.header: None})
54 self.assertTrue(response.context["user"].is_anonymous)
55 self.assertEqual(User.objects.count(), num_users)
56
57 response = self.client.get("/remote_user/", **{self.header: ""})
58 self.assertTrue(response.context["user"].is_anonymous)
59 self.assertEqual(User.objects.count(), num_users)
60
61 async def test_no_remote_user_async(self):
62 """See test_no_remote_user."""
63 num_users = await User.objects.acount()
64
65 response = await self.async_client.get("/remote_user/")
66 self.assertTrue(response.context["user"].is_anonymous)
67 self.assertEqual(await User.objects.acount(), num_users)
68
69 response = await self.async_client.get("/remote_user/", **{self.header: ""})
70 self.assertTrue(response.context["user"].is_anonymous)
71 self.assertEqual(await User.objects.acount(), num_users)
72
73 def test_csrf_validation_passes_after_process_request_login(self):
74 """
75 CSRF check must access the CSRF token from the session or cookie,
76 rather than the request, as rotate_token() may have been called by an
77 authentication middleware during the process_request() phase.
78 """
79 csrf_client = Client(enforce_csrf_checks=True)
80 csrf_secret = _get_new_csrf_string()
81 csrf_token = _mask_cipher_secret(csrf_secret)
82 csrf_token_form = _mask_cipher_secret(csrf_secret)
83 headers = {self.header: "fakeuser"}
84 data = {"csrfmiddlewaretoken": csrf_token_form}
85
86 # Verify that CSRF is configured for the view
87 csrf_client.cookies.load({settings.CSRF_COOKIE_NAME: csrf_token})
88 response = csrf_client.post("/remote_user/", **headers)
89 self.assertEqual(response.status_code, 403)
90 self.assertIn(b"CSRF verification failed.", response.content)
91
92 # This request will call django.contrib.auth.login() which will call
93 # django.middleware.csrf.rotate_token() thus changing the value of
94 # request.META['CSRF_COOKIE'] from the user submitted value set by
95 # CsrfViewMiddleware.process_request() to the new csrftoken value set
96 # by rotate_token(). Csrf validation should still pass when the view is
97 # later processed by CsrfViewMiddleware.process_view()
98 csrf_client.cookies.load({settings.CSRF_COOKIE_NAME: csrf_token})
99 response = csrf_client.post("/remote_user/", data, **headers)
100 self.assertEqual(response.status_code, 200)
101
102 async def test_csrf_validation_passes_after_process_request_login_async(self):
103 """See test_csrf_validation_passes_after_process_request_login."""
104 csrf_client = AsyncClient(enforce_csrf_checks=True)
105 csrf_secret = _get_new_csrf_string()
106 csrf_token = _mask_cipher_secret(csrf_secret)
107 csrf_token_form = _mask_cipher_secret(csrf_secret)
108 headers = {self.header: "fakeuser"}
109 data = {"csrfmiddlewaretoken": csrf_token_form}
110
111 # Verify that CSRF is configured for the view
112 csrf_client.cookies.load({settings.CSRF_COOKIE_NAME: csrf_token})
113 response = await csrf_client.post("/remote_user/", **headers)
114 self.assertEqual(response.status_code, 403)
115 self.assertIn(b"CSRF verification failed.", response.content)
116
117 # This request will call django.contrib.auth.alogin() which will call
118 # django.middleware.csrf.rotate_token() thus changing the value of
119 # request.META['CSRF_COOKIE'] from the user submitted value set by
120 # CsrfViewMiddleware.process_request() to the new csrftoken value set
121 # by rotate_token(). Csrf validation should still pass when the view is
122 # later processed by CsrfViewMiddleware.process_view()
123 csrf_client.cookies.load({settings.CSRF_COOKIE_NAME: csrf_token})
124 response = await csrf_client.post("/remote_user/", data, **headers)
125 self.assertEqual(response.status_code, 200)
126
127 def test_unknown_user(self):
128 """
129 Tests the case where the username passed in the header does not exist
130 as a User.
131 """
132 num_users = User.objects.count()
133 response = self.client.get("/remote_user/", **{self.header: "newuser"})
134 self.assertEqual(response.context["user"].username, "newuser")
135 self.assertEqual(User.objects.count(), num_users + 1)
136 User.objects.get(username="newuser")
137
138 # Another request with same user should not create any new users.
139 response = self.client.get("/remote_user/", **{self.header: "newuser"})
140 self.assertEqual(User.objects.count(), num_users + 1)
141
142 async def test_unknown_user_async(self):
143 """See test_unknown_user."""
144 num_users = await User.objects.acount()
145 response = await self.async_client.get(
146 "/remote_user/", **{self.header: "newuser"}
147 )
148 self.assertEqual(response.context["user"].username, "newuser")
149 self.assertEqual(await User.objects.acount(), num_users + 1)
150 await User.objects.aget(username="newuser")
151
152 # Another request with same user should not create any new users.
153 response = await self.async_client.get(
154 "/remote_user/", **{self.header: "newuser"}
155 )
156 self.assertEqual(await User.objects.acount(), num_users + 1)
157
158 def test_known_user(self):
159 """
160 Tests the case where the username passed in the header is a valid User.
161 """
162 User.objects.create(username="knownuser")
163 User.objects.create(username="knownuser2")
164 num_users = User.objects.count()
165 response = self.client.get("/remote_user/", **{self.header: self.known_user})
166 self.assertEqual(response.context["user"].username, "knownuser")
167 self.assertEqual(User.objects.count(), num_users)
168 # A different user passed in the headers causes the new user
169 # to be logged in.
170 response = self.client.get("/remote_user/", **{self.header: self.known_user2})
171 self.assertEqual(response.context["user"].username, "knownuser2")
172 self.assertEqual(User.objects.count(), num_users)
173
174 async def test_known_user_async(self):
175 """See test_known_user."""
176 await User.objects.acreate(username="knownuser")
177 await User.objects.acreate(username="knownuser2")
178 num_users = await User.objects.acount()
179 response = await self.async_client.get(
180 "/remote_user/", **{self.header: self.known_user}
181 )
182 self.assertEqual(response.context["user"].username, "knownuser")
183 self.assertEqual(await User.objects.acount(), num_users)
184 # A different user passed in the headers causes the new user
185 # to be logged in.
186 response = await self.async_client.get(
187 "/remote_user/", **{self.header: self.known_user2}
188 )
189 self.assertEqual(response.context["user"].username, "knownuser2")
190 self.assertEqual(await User.objects.acount(), num_users)
191
192 def test_last_login(self):
193 """
194 A user's last_login is set the first time they make a
195 request but not updated in subsequent requests with the same session.
196 """
197 user = User.objects.create(username="knownuser")
198 # Set last_login to something so we can determine if it changes.
199 default_login = datetime(2000, 1, 1)
200 if settings.USE_TZ:
201 default_login = default_login.replace(tzinfo=timezone.utc)
202 user.last_login = default_login
203 user.save()
204
205 response = self.client.get("/remote_user/", **{self.header: self.known_user})
206 self.assertNotEqual(default_login, response.context["user"].last_login)
207
208 user = User.objects.get(username="knownuser")
209 user.last_login = default_login
210 user.save()
211 response = self.client.get("/remote_user/", **{self.header: self.known_user})
212 self.assertEqual(default_login, response.context["user"].last_login)
213
214 async def test_last_login_async(self):
215 """See test_last_login."""
216 user = await User.objects.acreate(username="knownuser")
217 # Set last_login to something so we can determine if it changes.
218 default_login = datetime(2000, 1, 1)
219 if settings.USE_TZ:
220 default_login = default_login.replace(tzinfo=timezone.utc)
221 user.last_login = default_login
222 await user.asave()
223
224 response = await self.async_client.get(
225 "/remote_user/", **{self.header: self.known_user}
226 )
227 self.assertNotEqual(default_login, response.context["user"].last_login)
228
229 user = await User.objects.aget(username="knownuser")
230 user.last_login = default_login
231 await user.asave()
232 response = await self.async_client.get(
233 "/remote_user/", **{self.header: self.known_user}
234 )
235 self.assertEqual(default_login, response.context["user"].last_login)
236
237 def test_header_disappears(self):
238 """
239 A logged in user is logged out automatically when
240 the REMOTE_USER header disappears during the same browser session.
241 """
242 User.objects.create(username="knownuser")
243 # Known user authenticates
244 response = self.client.get("/remote_user/", **{self.header: self.known_user})
245 self.assertEqual(response.context["user"].username, "knownuser")
246 # During the session, the REMOTE_USER header disappears. Should trigger logout.
247 response = self.client.get("/remote_user/")
248 self.assertTrue(response.context["user"].is_anonymous)
249 # verify the remoteuser middleware will not remove a user
250 # authenticated via another backend
251 User.objects.create_user(username="modeluser", password="foo")
252 self.client.login(username="modeluser", password="foo")
253 authenticate(username="modeluser", password="foo")
254 response = self.client.get("/remote_user/")
255 self.assertEqual(response.context["user"].username, "modeluser")
256
257 async def test_header_disappears_async(self):
258 """See test_header_disappears."""
259 await User.objects.acreate(username="knownuser")
260 # Known user authenticates
261 response = await self.async_client.get(
262 "/remote_user/", **{self.header: self.known_user}
263 )
264 self.assertEqual(response.context["user"].username, "knownuser")
265 # During the session, the REMOTE_USER header disappears. Should trigger logout.
266 response = await self.async_client.get("/remote_user/")
267 self.assertTrue(response.context["user"].is_anonymous)
268 # verify the remoteuser middleware will not remove a user
269 # authenticated via another backend
270 await User.objects.acreate_user(username="modeluser", password="foo")
271 await self.async_client.alogin(username="modeluser", password="foo")
272 await aauthenticate(username="modeluser", password="foo")
273 response = await self.async_client.get("/remote_user/")
274 self.assertEqual(response.context["user"].username, "modeluser")
275
276 def test_user_switch_forces_new_login(self):
277 """
278 If the username in the header changes between requests
279 that the original user is logged out
280 """
281 User.objects.create(username="knownuser")
282 # Known user authenticates
283 response = self.client.get("/remote_user/", **{self.header: self.known_user})
284 self.assertEqual(response.context["user"].username, "knownuser")
285 # During the session, the REMOTE_USER changes to a different user.
286 response = self.client.get("/remote_user/", **{self.header: "newnewuser"})
287 # The current user is not the prior remote_user.
288 # In backends that create a new user, username is "newnewuser"
289 # In backends that do not create new users, it is '' (anonymous user)
290 self.assertNotEqual(response.context["user"].username, "knownuser")
291
292 async def test_user_switch_forces_new_login_async(self):
293 """See test_user_switch_forces_new_login."""
294 await User.objects.acreate(username="knownuser")
295 # Known user authenticates
296 response = await self.async_client.get(
297 "/remote_user/", **{self.header: self.known_user}
298 )
299 self.assertEqual(response.context["user"].username, "knownuser")
300 # During the session, the REMOTE_USER changes to a different user.
301 response = await self.async_client.get(
302 "/remote_user/", **{self.header: "newnewuser"}
303 )
304 # The current user is not the prior remote_user.
305 # In backends that create a new user, username is "newnewuser"
306 # In backends that do not create new users, it is '' (anonymous user)
307 self.assertNotEqual(response.context["user"].username, "knownuser")
308
309 def test_inactive_user(self):
310 User.objects.create(username="knownuser", is_active=False)
311 response = self.client.get("/remote_user/", **{self.header: "knownuser"})
312 self.assertTrue(response.context["user"].is_anonymous)
313
314 async def test_inactive_user_async(self):
315 await User.objects.acreate(username="knownuser", is_active=False)
316 response = await self.async_client.get(
317 "/remote_user/", **{self.header: "knownuser"}
318 )
319 self.assertTrue(response.context["user"].is_anonymous)
320
321
322 class RemoteUserNoCreateBackend(RemoteUserBackend):
323 """Backend that doesn't create unknown users."""
324
325 create_unknown_user = False
326
327
328 class RemoteUserNoCreateTest(RemoteUserTest):
329 """
330 Contains the same tests as RemoteUserTest, but using a custom auth backend
331 class that doesn't create unknown users.
332 """
333
334 backend = "auth_tests.test_remote_user.RemoteUserNoCreateBackend"
335
336 def test_unknown_user(self):
337 num_users = User.objects.count()
338 response = self.client.get("/remote_user/", **{self.header: "newuser"})
339 self.assertTrue(response.context["user"].is_anonymous)
340 self.assertEqual(User.objects.count(), num_users)
341
342 async def test_unknown_user_async(self):
343 num_users = await User.objects.acount()
344 response = await self.async_client.get(
345 "/remote_user/", **{self.header: "newuser"}
346 )
347 self.assertTrue(response.context["user"].is_anonymous)
348 self.assertEqual(await User.objects.acount(), num_users)
349
350
351 class AllowAllUsersRemoteUserBackendTest(RemoteUserTest):
352 """Backend that allows inactive users."""
353
354 backend = "django.contrib.auth.backends.AllowAllUsersRemoteUserBackend"
355
356 def test_inactive_user(self):
357 user = User.objects.create(username="knownuser", is_active=False)
358 response = self.client.get("/remote_user/", **{self.header: self.known_user})
359 self.assertEqual(response.context["user"].username, user.username)
360
361 async def test_inactive_user_async(self):
362 user = await User.objects.acreate(username="knownuser", is_active=False)
363 response = await self.async_client.get(
364 "/remote_user/", **{self.header: self.known_user}
365 )
366 self.assertEqual(response.context["user"].username, user.username)
367
368
369 class CustomRemoteUserBackend(RemoteUserBackend):
370 """
371 Backend that overrides RemoteUserBackend methods.
372 """
373
374 def clean_username(self, username):
375 """
376 Grabs username before the @ character.
377 """
378 return username.split("@")[0]
379
380 def configure_user(self, request, user, created=True):
381 """
382 Sets user's email address using the email specified in an HTTP header.
383 Sets user's last name for existing users.
384 """
385 user.email = request.META.get(RemoteUserTest.email_header, "")
386 if not created:
387 user.last_name = user.username
388 user.save()
389 return user
390
391
392 class RemoteUserCustomTest(RemoteUserTest):
393 """
394 Tests a custom RemoteUserBackend subclass that overrides the clean_username
395 and configure_user methods.
396 """
397
398 backend = "auth_tests.test_remote_user.CustomRemoteUserBackend"
399 # REMOTE_USER strings with email addresses for the custom backend to
400 # clean.
401 known_user = "[email protected]"
402 known_user2 = "[email protected]"
403
404 def test_known_user(self):
405 """
406 The strings passed in REMOTE_USER should be cleaned and the known users
407 should not have been configured with an email address.
408 """
409 super().test_known_user()
410 knownuser = User.objects.get(username="knownuser")
411 knownuser2 = User.objects.get(username="knownuser2")
412 self.assertEqual(knownuser.email, "")
413 self.assertEqual(knownuser2.email, "")
414 self.assertEqual(knownuser.last_name, "knownuser")
415 self.assertEqual(knownuser2.last_name, "knownuser2")
416
417 def test_unknown_user(self):
418 """
419 The unknown user created should be configured with an email address
420 provided in the request header.
421 """
422 num_users = User.objects.count()
423 response = self.client.get(
424 "/remote_user/",
425 **{
426 self.header: "newuser",
427 self.email_header: "[email protected]",
428 },
429 )
430 self.assertEqual(response.context["user"].username, "newuser")
431 self.assertEqual(response.context["user"].email, "[email protected]")
432 self.assertEqual(response.context["user"].last_name, "")
433 self.assertEqual(User.objects.count(), num_users + 1)
434 newuser = User.objects.get(username="newuser")
435 self.assertEqual(newuser.email, "[email protected]")
436
437
438 class CustomHeaderMiddleware(RemoteUserMiddleware):
439 """
440 Middleware that overrides custom HTTP auth user header.
441 """
442
443 header = "HTTP_AUTHUSER"
444
445
446 class CustomHeaderRemoteUserTest(RemoteUserTest):
447 """
448 Tests a custom RemoteUserMiddleware subclass with custom HTTP auth user
449 header.
450 """
451
452 middleware = "auth_tests.test_remote_user.CustomHeaderMiddleware"
453 header = "HTTP_AUTHUSER"
454
455
456 class PersistentRemoteUserTest(RemoteUserTest):
457 """
458 PersistentRemoteUserMiddleware keeps the user logged in even if the
459 subsequent calls do not contain the header value.
460 """
461
462 middleware = "django.contrib.auth.middleware.PersistentRemoteUserMiddleware"
463 require_header = False
464
465 def test_header_disappears(self):
466 """
467 A logged in user is kept logged in even if the REMOTE_USER header
468 disappears during the same browser session.
469 """
470 User.objects.create(username="knownuser")
471 # Known user authenticates
472 response = self.client.get("/remote_user/", **{self.header: self.known_user})
473 self.assertEqual(response.context["user"].username, "knownuser")
474 # Should stay logged in if the REMOTE_USER header disappears.
475 response = self.client.get("/remote_user/")
476 self.assertFalse(response.context["user"].is_anonymous)
477 self.assertEqual(response.context["user"].username, "knownuser")
478
479 async def test_header_disappears_async(self):
480 """See test_header_disappears."""
481 await User.objects.acreate(username="knownuser")
482 # Known user authenticates
483 response = await self.async_client.get(
484 "/remote_user/", **{self.header: self.known_user}
485 )
486 self.assertEqual(response.context["user"].username, "knownuser")
487 # Should stay logged in if the REMOTE_USER header disappears.
488 response = await self.async_client.get("/remote_user/")
489 self.assertFalse(response.context["user"].is_anonymous)
490 self.assertEqual(response.context["user"].username, "knownuser")
491
492
493 # RemovedInDjango61Warning.
494 class CustomProcessRequestMiddlewareSyncOnly(RemoteUserMiddleware):
495 def process_request(self, request):
496 raise NotImplementedError("process_request has not been implemented.")
497
498
499 # RemovedInDjango61Warning.
500 class CustomProcessRequestMiddleware(RemoteUserMiddleware):
501 def process_request(self, request):
502 raise NotImplementedError("process_request has not been implemented.")
503
504 async def aprocess_request(self, request):
505 raise NotImplementedError("aprocess_request has not been implemented.")
506
507
508 # RemovedInDjango61Warning.
509 @override_settings(ROOT_URLCONF="auth_tests.urls")
510 class CustomProcessRequestMiddlewareTest(TestCase):
511 @modify_settings(
512 MIDDLEWARE={
513 "append": "auth_tests.test_remote_user."
514 "CustomProcessRequestMiddlewareSyncOnly"
515 }
516 )
517 async def test_async_warns_sync_only_middleware(self):
518 deprecation_msg = (
519 "Support for subclasses of RemoteUserMiddleware that override "
520 "process_request() without overriding aprocess_request() is "
521 "deprecated."
522 )
523 error_msg = "process_request has not been implemented."
524 with (
525 self.assertWarnsMessage(RemovedInDjango61Warning, deprecation_msg),
526 self.assertRaisesMessage(NotImplementedError, error_msg),
527 ):
528 await self.async_client.get("/remote_user/")
529
530 @modify_settings(
531 MIDDLEWARE={
532 "append": "auth_tests.test_remote_user.CustomProcessRequestMiddleware"
533 }
534 )
535 async def test_async_no_warning_sync_and_async_middleware(self):
536 error_msg = "aprocess_request has not been implemented."
537 with self.assertRaisesMessage(NotImplementedError, error_msg):
538 await self.async_client.get("/remote_user/")