Debian Codegraph @

tests/auth_tests/test_forms.py

raw
1 import datetime
2 import re
3 import sys
4 import urllib.parse
5 from unittest import mock
6
7 from django import forms
8 from django.contrib.auth.forms import (
9 AdminPasswordChangeForm,
10 AdminUserCreationForm,
11 AuthenticationForm,
12 BaseUserCreationForm,
13 PasswordChangeForm,
14 PasswordResetForm,
15 ReadOnlyPasswordHashField,
16 ReadOnlyPasswordHashWidget,
17 SetPasswordForm,
18 SetPasswordMixin,
19 UserChangeForm,
20 UserCreationForm,
21 UsernameField,
22 )
23 from django.contrib.auth.hashers import make_password
24 from django.contrib.auth.models import User
25 from django.contrib.auth.signals import user_login_failed
26 from django.contrib.sites.models import Site
27 from django.core import mail
28 from django.core.exceptions import ValidationError
29 from django.core.mail import EmailMultiAlternatives
30 from django.forms.fields import CharField, Field, IntegerField
31 from django.test import RequestFactory, SimpleTestCase, TestCase, override_settings
32 from django.urls import reverse
33 from django.utils import translation
34 from django.utils.text import capfirst
35 from django.utils.translation import gettext as _
36 from django.views.debug import technical_500_response
37 from django.views.decorators.debug import sensitive_variables
38
39 from .models.custom_user import (
40 CustomUser,
41 CustomUserWithoutIsActiveField,
42 ExtensionUser,
43 )
44 from .models.with_custom_email_field import CustomEmailField
45 from .models.with_integer_username import IntegerUsernameUser
46 from .models.with_many_to_many import CustomUserWithM2M, Organization
47 from .settings import AUTH_TEMPLATES
48
49
50 class TestDataMixin:
51 @classmethod
52 def setUpTestData(cls):
53 cls.u1 = User.objects.create_user(
54 username="testclient", password="password", email="[email protected]"
55 )
56 cls.u2 = User.objects.create_user(
57 username="inactive", password="password", is_active=False
58 )
59 cls.u3 = User.objects.create_user(username="staff", password="password")
60 cls.u4 = User.objects.create(username="empty_password", password="")
61 cls.u5 = User.objects.create(username="unmanageable_password", password="$")
62 cls.u6 = User.objects.create(username="unknown_password", password="foo$bar")
63 cls.u7 = User.objects.create(
64 username="unusable_password", password=make_password(None)
65 )
66
67
68 class ExtraValidationFormMixin:
69 def __init__(self, *args, failing_fields=None, **kwargs):
70 super().__init__(*args, **kwargs)
71 self.failing_fields = failing_fields or {}
72
73 def failing_helper(self, field_name):
74 if field_name in self.failing_fields:
75 errors = [
76 ValidationError(error, code="invalid")
77 for error in self.failing_fields[field_name]
78 ]
79 raise ValidationError(errors)
80 return self.cleaned_data[field_name]
81
82
83 class BaseUserCreationFormTest(TestDataMixin, TestCase):
84
85 form_class = BaseUserCreationForm
86
87 def test_form_fields(self):
88 form = self.form_class()
89 self.assertEqual(
90 list(form.fields.keys()), ["username", "password1", "password2"]
91 )
92
93 def test_user_already_exists(self):
94 data = {
95 "username": "testclient",
96 "password1": "test123",
97 "password2": "test123",
98 }
99 form = self.form_class(data)
100 self.assertFalse(form.is_valid())
101 self.assertEqual(
102 form["username"].errors,
103 [str(User._meta.get_field("username").error_messages["unique"])],
104 )
105
106 def test_invalid_data(self):
107 data = {
108 "username": "jsmith!",
109 "password1": "test123",
110 "password2": "test123",
111 }
112 form = self.form_class(data)
113 self.assertFalse(form.is_valid())
114 validator = next(
115 v
116 for v in User._meta.get_field("username").validators
117 if v.code == "invalid"
118 )
119 self.assertEqual(form["username"].errors, [str(validator.message)])
120
121 def test_password_verification(self):
122 # The verification password is incorrect.
123 data = {
124 "username": "jsmith",
125 "password1": "test123",
126 "password2": "test",
127 }
128 form = self.form_class(data)
129 self.assertFalse(form.is_valid())
130 self.assertEqual(
131 form["password2"].errors, [str(form.error_messages["password_mismatch"])]
132 )
133
134 def test_both_passwords(self):
135 # One (or both) passwords weren't given
136 data = {"username": "jsmith"}
137 form = self.form_class(data)
138 required_error = [str(Field.default_error_messages["required"])]
139 self.assertFalse(form.is_valid())
140 self.assertEqual(form["password1"].errors, required_error)
141 self.assertEqual(form["password2"].errors, required_error)
142
143 data["password2"] = "test123"
144 form = self.form_class(data)
145 self.assertFalse(form.is_valid())
146 self.assertEqual(form["password1"].errors, required_error)
147 self.assertEqual(form["password2"].errors, [])
148
149 @mock.patch("django.contrib.auth.password_validation.password_changed")
150 def test_success(self, password_changed):
151 # The success case.
152 data = {
153 "username": "[email protected]",
154 "password1": "test123",
155 "password2": "test123",
156 }
157 form = self.form_class(data)
158 self.assertTrue(form.is_valid())
159 form.save(commit=False)
160 self.assertEqual(password_changed.call_count, 0)
161 u = form.save()
162 self.assertEqual(password_changed.call_count, 1)
163 self.assertEqual(repr(u), "<User: [email protected]>")
164
165 def test_unicode_username(self):
166 data = {
167 "username": "宝",
168 "password1": "test123",
169 "password2": "test123",
170 }
171 form = self.form_class(data)
172 self.assertTrue(form.is_valid())
173 u = form.save()
174 self.assertEqual(u.username, "宝")
175
176 def test_normalize_username(self):
177 # The normalization happens in AbstractBaseUser.clean() and ModelForm
178 # validation calls Model.clean().
179 ohm_username = "testΩ" # U+2126 OHM SIGN
180 data = {
181 "username": ohm_username,
182 "password1": "pwd2",
183 "password2": "pwd2",
184 }
185 form = self.form_class(data)
186 self.assertTrue(form.is_valid())
187 user = form.save()
188 self.assertNotEqual(user.username, ohm_username)
189 self.assertEqual(user.username, "testΩ") # U+03A9 GREEK CAPITAL LETTER OMEGA
190
191 def test_invalid_username_no_normalize(self):
192 field = UsernameField(max_length=254)
193 # Usernames are not normalized if they are too long.
194 self.assertEqual(field.to_python("½" * 255), "½" * 255)
195 self.assertEqual(field.to_python("ff" * 254), "ff" * 254)
196
197 def test_duplicate_normalized_unicode(self):
198 """
199 To prevent almost identical usernames, visually identical but differing
200 by their unicode code points only, Unicode NFKC normalization should
201 make appear them equal to Django.
202 """
203 omega_username = "iamtheΩ" # U+03A9 GREEK CAPITAL LETTER OMEGA
204 ohm_username = "iamtheΩ" # U+2126 OHM SIGN
205 self.assertNotEqual(omega_username, ohm_username)
206 User.objects.create_user(username=omega_username, password="pwd")
207 data = {
208 "username": ohm_username,
209 "password1": "pwd2",
210 "password2": "pwd2",
211 }
212 form = self.form_class(data)
213 self.assertFalse(form.is_valid())
214 self.assertEqual(
215 form.errors["username"], ["A user with that username already exists."]
216 )
217
218 @override_settings(
219 AUTH_PASSWORD_VALIDATORS=[
220 {
221 "NAME": (
222 "django.contrib.auth.password_validation."
223 "UserAttributeSimilarityValidator"
224 )
225 },
226 {
227 "NAME": (
228 "django.contrib.auth.password_validation.MinimumLengthValidator"
229 ),
230 "OPTIONS": {
231 "min_length": 12,
232 },
233 },
234 ]
235 )
236 def test_validates_password(self):
237 data = {
238 "username": "otherclient",
239 "password1": "otherclient",
240 "password2": "otherclient",
241 }
242 form = self.form_class(data)
243 self.assertFalse(form.is_valid())
244 self.assertEqual(len(form["password2"].errors), 2)
245 self.assertIn(
246 "The password is too similar to the username.", form["password2"].errors
247 )
248 self.assertIn(
249 "This password is too short. It must contain at least 12 characters.",
250 form["password2"].errors,
251 )
252
253 def test_password_whitespace_not_stripped(self):
254 data = {
255 "username": "testuser",
256 "password1": " testpassword ",
257 "password2": " testpassword ",
258 }
259 form = self.form_class(data)
260 self.assertTrue(form.is_valid())
261 self.assertEqual(form.cleaned_data["password1"], data["password1"])
262 self.assertEqual(form.cleaned_data["password2"], data["password2"])
263
264 @override_settings(
265 AUTH_PASSWORD_VALIDATORS=[
266 {
267 "NAME": (
268 "django.contrib.auth.password_validation."
269 "UserAttributeSimilarityValidator"
270 )
271 },
272 ]
273 )
274 def test_password_help_text(self):
275 form = self.form_class()
276 self.assertEqual(
277 form.fields["password1"].help_text,
278 "<ul><li>"
279 "Your password can’t be too similar to your other personal information."
280 "</li></ul>",
281 )
282
283 def test_password_extra_validations(self):
284 class ExtraValidationForm(ExtraValidationFormMixin, self.form_class):
285 def clean_password1(self):
286 return self.failing_helper("password1")
287
288 def clean_password2(self):
289 return self.failing_helper("password2")
290
291 data = {"username": "extra", "password1": "abc", "password2": "abc"}
292 for fields in (["password1"], ["password2"], ["password1", "password2"]):
293 with self.subTest(fields=fields):
294 errors = {field: [f"Extra validation for {field}."] for field in fields}
295 form = ExtraValidationForm(data, failing_fields=errors)
296 self.assertIs(form.is_valid(), False)
297 self.assertDictEqual(form.errors, errors)
298
299 @override_settings(
300 AUTH_PASSWORD_VALIDATORS=[
301 {
302 "NAME": (
303 "django.contrib.auth.password_validation."
304 "UserAttributeSimilarityValidator"
305 )
306 },
307 ]
308 )
309 def test_user_create_form_validates_password_with_all_data(self):
310 """
311 BaseUserCreationForm password validation uses all of the form's data.
312 """
313
314 class CustomUserCreationForm(self.form_class):
315 class Meta(self.form_class.Meta):
316 model = User
317 fields = ("username", "email", "first_name", "last_name")
318
319 form = CustomUserCreationForm(
320 {
321 "username": "testuser",
322 "password1": "testpassword",
323 "password2": "testpassword",
324 "first_name": "testpassword",
325 "last_name": "lastname",
326 }
327 )
328 self.assertFalse(form.is_valid())
329 self.assertEqual(
330 form.errors["password2"],
331 ["The password is too similar to the first name."],
332 )
333
334 def test_username_field_autocapitalize_none(self):
335 form = self.form_class()
336 self.assertEqual(
337 form.fields["username"].widget.attrs.get("autocapitalize"), "none"
338 )
339
340 def test_html_autocomplete_attributes(self):
341 form = self.form_class()
342 tests = (
343 ("username", "username"),
344 ("password1", "new-password"),
345 ("password2", "new-password"),
346 )
347 for field_name, autocomplete in tests:
348 with self.subTest(field_name=field_name, autocomplete=autocomplete):
349 self.assertEqual(
350 form.fields[field_name].widget.attrs["autocomplete"], autocomplete
351 )
352
353
354 class CustomUserCreationFormTest(TestDataMixin, TestCase):
355
356 def test_custom_form(self):
357 class CustomUserCreationForm(BaseUserCreationForm):
358 class Meta(BaseUserCreationForm.Meta):
359 model = ExtensionUser
360 fields = UserCreationForm.Meta.fields + ("date_of_birth",)
361
362 data = {
363 "username": "testclient",
364 "password1": "testclient",
365 "password2": "testclient",
366 "date_of_birth": "1988-02-24",
367 }
368 form = CustomUserCreationForm(data)
369 self.assertTrue(form.is_valid())
370
371 def test_custom_form_with_different_username_field(self):
372 class CustomUserCreationForm(BaseUserCreationForm):
373 class Meta(BaseUserCreationForm.Meta):
374 model = CustomUser
375 fields = ("email", "date_of_birth")
376
377 data = {
378 "email": "[email protected]",
379 "password1": "testclient",
380 "password2": "testclient",
381 "date_of_birth": "1988-02-24",
382 }
383 form = CustomUserCreationForm(data)
384 self.assertTrue(form.is_valid())
385
386 def test_custom_form_hidden_username_field(self):
387 class CustomUserCreationForm(BaseUserCreationForm):
388 class Meta(BaseUserCreationForm.Meta):
389 model = CustomUserWithoutIsActiveField
390 fields = ("email",) # without USERNAME_FIELD
391
392 data = {
393 "email": "[email protected]",
394 "password1": "testclient",
395 "password2": "testclient",
396 }
397 form = CustomUserCreationForm(data)
398 self.assertTrue(form.is_valid())
399
400 def test_custom_form_saves_many_to_many_field(self):
401 class CustomUserCreationForm(BaseUserCreationForm):
402 class Meta(BaseUserCreationForm.Meta):
403 model = CustomUserWithM2M
404 fields = UserCreationForm.Meta.fields + ("orgs",)
405
406 organization = Organization.objects.create(name="organization 1")
407
408 data = {
409 "username": "[email protected]",
410 "password1": "testclient",
411 "password2": "testclient",
412 "orgs": [str(organization.pk)],
413 }
414 form = CustomUserCreationForm(data)
415 self.assertIs(form.is_valid(), True)
416 user = form.save(commit=True)
417 self.assertSequenceEqual(user.orgs.all(), [organization])
418
419 def test_custom_form_with_non_required_password(self):
420 class CustomUserCreationForm(BaseUserCreationForm):
421 password1 = forms.CharField(required=False)
422 password2 = forms.CharField(required=False)
423 another_field = forms.CharField(required=True)
424
425 data = {
426 "username": "testclientnew",
427 "another_field": "Content",
428 }
429 form = CustomUserCreationForm(data)
430 self.assertIs(form.is_valid(), True, form.errors)
431
432
433 class UserCreationFormTest(BaseUserCreationFormTest):
434
435 form_class = UserCreationForm
436
437 def test_case_insensitive_username(self):
438 data = {
439 "username": "TeStClIeNt",
440 "password1": "test123",
441 "password2": "test123",
442 }
443 form = UserCreationForm(data)
444 self.assertFalse(form.is_valid())
445 self.assertEqual(
446 form["username"].errors,
447 ["A user with that username already exists."],
448 )
449
450 @override_settings(AUTH_USER_MODEL="auth_tests.ExtensionUser")
451 def test_case_insensitive_username_custom_user_and_error_message(self):
452 class CustomUserCreationForm(UserCreationForm):
453 class Meta(UserCreationForm.Meta):
454 model = ExtensionUser
455 fields = UserCreationForm.Meta.fields + ("date_of_birth",)
456 error_messages = {
457 "username": {"unique": "This username has already been taken."}
458 }
459
460 ExtensionUser.objects.create_user(
461 username="testclient",
462 password="password",
463 email="[email protected]",
464 date_of_birth=datetime.date(1984, 3, 5),
465 )
466 data = {
467 "username": "TeStClIeNt",
468 "password1": "test123",
469 "password2": "test123",
470 "date_of_birth": "1980-01-01",
471 }
472 form = CustomUserCreationForm(data)
473 self.assertIs(form.is_valid(), False)
474 self.assertEqual(
475 form["username"].errors,
476 ["This username has already been taken."],
477 )
478
479
480 # To verify that the login form rejects inactive users, use an authentication
481 # backend that allows them.
482 @override_settings(
483 AUTHENTICATION_BACKENDS=["django.contrib.auth.backends.AllowAllUsersModelBackend"]
484 )
485 class AuthenticationFormTest(TestDataMixin, TestCase):
486 def test_invalid_username(self):
487 # The user submits an invalid username.
488
489 data = {
490 "username": "jsmith_does_not_exist",
491 "password": "test123",
492 }
493 form = AuthenticationForm(None, data)
494 self.assertFalse(form.is_valid())
495 self.assertEqual(
496 form.non_field_errors(),
497 [
498 form.error_messages["invalid_login"]
499 % {"username": User._meta.get_field("username").verbose_name}
500 ],
501 )
502
503 def test_inactive_user(self):
504 # The user is inactive.
505 data = {
506 "username": "inactive",
507 "password": "password",
508 }
509 form = AuthenticationForm(None, data)
510 self.assertFalse(form.is_valid())
511 self.assertEqual(
512 form.non_field_errors(), [str(form.error_messages["inactive"])]
513 )
514
515 # Use an authentication backend that rejects inactive users.
516 @override_settings(
517 AUTHENTICATION_BACKENDS=["django.contrib.auth.backends.ModelBackend"]
518 )
519 def test_inactive_user_incorrect_password(self):
520 """An invalid login doesn't leak the inactive status of a user."""
521 data = {
522 "username": "inactive",
523 "password": "incorrect",
524 }
525 form = AuthenticationForm(None, data)
526 self.assertFalse(form.is_valid())
527 self.assertEqual(
528 form.non_field_errors(),
529 [
530 form.error_messages["invalid_login"]
531 % {"username": User._meta.get_field("username").verbose_name}
532 ],
533 )
534
535 def test_login_failed(self):
536 signal_calls = []
537
538 def signal_handler(**kwargs):
539 signal_calls.append(kwargs)
540
541 user_login_failed.connect(signal_handler)
542 fake_request = object()
543 try:
544 form = AuthenticationForm(
545 fake_request,
546 {
547 "username": "testclient",
548 "password": "incorrect",
549 },
550 )
551 self.assertFalse(form.is_valid())
552 self.assertIs(signal_calls[0]["request"], fake_request)
553 finally:
554 user_login_failed.disconnect(signal_handler)
555
556 def test_inactive_user_i18n(self):
557 with (
558 self.settings(USE_I18N=True),
559 translation.override("pt-br", deactivate=True),
560 ):
561 # The user is inactive.
562 data = {
563 "username": "inactive",
564 "password": "password",
565 }
566 form = AuthenticationForm(None, data)
567 self.assertFalse(form.is_valid())
568 self.assertEqual(
569 form.non_field_errors(), [str(form.error_messages["inactive"])]
570 )
571
572 # Use an authentication backend that allows inactive users.
573 @override_settings(
574 AUTHENTICATION_BACKENDS=[
575 "django.contrib.auth.backends.AllowAllUsersModelBackend"
576 ]
577 )
578 def test_custom_login_allowed_policy(self):
579 # The user is inactive, but our custom form policy allows them to log in.
580 data = {
581 "username": "inactive",
582 "password": "password",
583 }
584
585 class AuthenticationFormWithInactiveUsersOkay(AuthenticationForm):
586 def confirm_login_allowed(self, user):
587 pass
588
589 form = AuthenticationFormWithInactiveUsersOkay(None, data)
590 self.assertTrue(form.is_valid())
591
592 # Raise a ValidationError in the form to disallow some logins according
593 # to custom logic.
594 class PickyAuthenticationForm(AuthenticationForm):
595 def confirm_login_allowed(self, user):
596 if user.username == "inactive":
597 raise ValidationError("This user is disallowed.")
598 raise ValidationError("Sorry, nobody's allowed in.")
599
600 form = PickyAuthenticationForm(None, data)
601 self.assertFalse(form.is_valid())
602 self.assertEqual(form.non_field_errors(), ["This user is disallowed."])
603
604 data = {
605 "username": "testclient",
606 "password": "password",
607 }
608 form = PickyAuthenticationForm(None, data)
609 self.assertFalse(form.is_valid())
610 self.assertEqual(form.non_field_errors(), ["Sorry, nobody's allowed in."])
611
612 def test_success(self):
613 # The success case
614 data = {
615 "username": "testclient",
616 "password": "password",
617 }
618 form = AuthenticationForm(None, data)
619 self.assertTrue(form.is_valid())
620 self.assertEqual(form.non_field_errors(), [])
621
622 def test_unicode_username(self):
623 User.objects.create_user(username="Σαρα", password="pwd")
624 data = {
625 "username": "Σαρα",
626 "password": "pwd",
627 }
628 form = AuthenticationForm(None, data)
629 self.assertTrue(form.is_valid())
630 self.assertEqual(form.non_field_errors(), [])
631
632 @override_settings(AUTH_USER_MODEL="auth_tests.CustomEmailField")
633 def test_username_field_max_length_matches_user_model(self):
634 self.assertEqual(CustomEmailField._meta.get_field("username").max_length, 255)
635 data = {
636 "username": "u" * 255,
637 "password": "pwd",
638 "email": "[email protected]",
639 }
640 CustomEmailField.objects.create_user(**data)
641 form = AuthenticationForm(None, data)
642 self.assertEqual(form.fields["username"].max_length, 255)
643 self.assertEqual(form.fields["username"].widget.attrs.get("maxlength"), 255)
644 self.assertEqual(form.errors, {})
645
646 @override_settings(AUTH_USER_MODEL="auth_tests.IntegerUsernameUser")
647 def test_username_field_max_length_defaults_to_254(self):
648 self.assertIsNone(IntegerUsernameUser._meta.get_field("username").max_length)
649 data = {
650 "username": "0123456",
651 "password": "password",
652 }
653 IntegerUsernameUser.objects.create_user(**data)
654 form = AuthenticationForm(None, data)
655 self.assertEqual(form.fields["username"].max_length, 254)
656 self.assertEqual(form.fields["username"].widget.attrs.get("maxlength"), 254)
657 self.assertEqual(form.errors, {})
658
659 def test_username_field_label(self):
660 class CustomAuthenticationForm(AuthenticationForm):
661 username = CharField(label="Name", max_length=75)
662
663 form = CustomAuthenticationForm()
664 self.assertEqual(form["username"].label, "Name")
665
666 def test_username_field_label_not_set(self):
667 class CustomAuthenticationForm(AuthenticationForm):
668 username = CharField()
669
670 form = CustomAuthenticationForm()
671 username_field = User._meta.get_field(User.USERNAME_FIELD)
672 self.assertEqual(
673 form.fields["username"].label, capfirst(username_field.verbose_name)
674 )
675
676 def test_username_field_autocapitalize_none(self):
677 form = AuthenticationForm()
678 self.assertEqual(
679 form.fields["username"].widget.attrs.get("autocapitalize"), "none"
680 )
681
682 def test_username_field_label_empty_string(self):
683 class CustomAuthenticationForm(AuthenticationForm):
684 username = CharField(label="")
685
686 form = CustomAuthenticationForm()
687 self.assertEqual(form.fields["username"].label, "")
688
689 def test_password_whitespace_not_stripped(self):
690 data = {
691 "username": "testuser",
692 "password": " pass ",
693 }
694 form = AuthenticationForm(None, data)
695 form.is_valid() # Not necessary to have valid credentails for the test.
696 self.assertEqual(form.cleaned_data["password"], data["password"])
697
698 @override_settings(AUTH_USER_MODEL="auth_tests.IntegerUsernameUser")
699 def test_integer_username(self):
700 class CustomAuthenticationForm(AuthenticationForm):
701 username = IntegerField()
702
703 user = IntegerUsernameUser.objects.create_user(username=0, password="pwd")
704 data = {
705 "username": 0,
706 "password": "pwd",
707 }
708 form = CustomAuthenticationForm(None, data)
709 self.assertTrue(form.is_valid())
710 self.assertEqual(form.cleaned_data["username"], data["username"])
711 self.assertEqual(form.cleaned_data["password"], data["password"])
712 self.assertEqual(form.errors, {})
713 self.assertEqual(form.user_cache, user)
714
715 def test_get_invalid_login_error(self):
716 error = AuthenticationForm().get_invalid_login_error()
717 self.assertIsInstance(error, ValidationError)
718 self.assertEqual(
719 error.message,
720 "Please enter a correct %(username)s and password. Note that both "
721 "fields may be case-sensitive.",
722 )
723 self.assertEqual(error.code, "invalid_login")
724 self.assertEqual(error.params, {"username": "username"})
725
726 def test_html_autocomplete_attributes(self):
727 form = AuthenticationForm()
728 tests = (
729 ("username", "username"),
730 ("password", "current-password"),
731 )
732 for field_name, autocomplete in tests:
733 with self.subTest(field_name=field_name, autocomplete=autocomplete):
734 self.assertEqual(
735 form.fields[field_name].widget.attrs["autocomplete"], autocomplete
736 )
737
738 def test_no_password(self):
739 data = {"username": "username"}
740 form = AuthenticationForm(None, data)
741 self.assertIs(form.is_valid(), False)
742 self.assertEqual(
743 form["password"].errors, [Field.default_error_messages["required"]]
744 )
745
746
747 class SetPasswordFormTest(TestDataMixin, TestCase):
748 def test_password_verification(self):
749 # The two new passwords do not match.
750 user = User.objects.get(username="testclient")
751 data = {
752 "new_password1": "abc123",
753 "new_password2": "abc",
754 }
755 form = SetPasswordForm(user, data)
756 self.assertFalse(form.is_valid())
757 self.assertEqual(
758 form["new_password2"].errors,
759 [str(form.error_messages["password_mismatch"])],
760 )
761
762 @mock.patch("django.contrib.auth.password_validation.password_changed")
763 def test_success(self, password_changed):
764 user = User.objects.get(username="testclient")
765 data = {
766 "new_password1": "abc123",
767 "new_password2": "abc123",
768 }
769 form = SetPasswordForm(user, data)
770 self.assertTrue(form.is_valid())
771 form.save(commit=False)
772 self.assertEqual(password_changed.call_count, 0)
773 form.save()
774 self.assertEqual(password_changed.call_count, 1)
775
776 @override_settings(
777 AUTH_PASSWORD_VALIDATORS=[
778 {
779 "NAME": (
780 "django.contrib.auth.password_validation."
781 "UserAttributeSimilarityValidator"
782 )
783 },
784 {
785 "NAME": (
786 "django.contrib.auth.password_validation.MinimumLengthValidator"
787 ),
788 "OPTIONS": {
789 "min_length": 12,
790 },
791 },
792 ]
793 )
794 def test_validates_password(self):
795 user = User.objects.get(username="testclient")
796 data = {
797 "new_password1": "testclient",
798 "new_password2": "testclient",
799 }
800 form = SetPasswordForm(user, data)
801 self.assertFalse(form.is_valid())
802 self.assertEqual(len(form["new_password2"].errors), 2)
803 self.assertIn(
804 "The password is too similar to the username.", form["new_password2"].errors
805 )
806 self.assertIn(
807 "This password is too short. It must contain at least 12 characters.",
808 form["new_password2"].errors,
809 )
810
811 # SetPasswordForm does not consider usable_password for form validation
812 data = {
813 "new_password1": "testclient",
814 "new_password2": "testclient",
815 "usable_password": "false",
816 }
817 form = SetPasswordForm(user, data)
818 self.assertFalse(form.is_valid())
819 self.assertEqual(len(form["new_password2"].errors), 2)
820 self.assertIn(
821 "The password is too similar to the username.", form["new_password2"].errors
822 )
823 self.assertIn(
824 "This password is too short. It must contain at least 12 characters.",
825 form["new_password2"].errors,
826 )
827
828 def test_no_password(self):
829 user = User.objects.get(username="testclient")
830 data = {"new_password1": "new-password"}
831 form = SetPasswordForm(user, data)
832 self.assertIs(form.is_valid(), False)
833 self.assertEqual(
834 form["new_password2"].errors, [Field.default_error_messages["required"]]
835 )
836 form = SetPasswordForm(user, {})
837 self.assertIs(form.is_valid(), False)
838 self.assertEqual(
839 form["new_password1"].errors, [Field.default_error_messages["required"]]
840 )
841 self.assertEqual(
842 form["new_password2"].errors, [Field.default_error_messages["required"]]
843 )
844
845 def test_password_whitespace_not_stripped(self):
846 user = User.objects.get(username="testclient")
847 data = {
848 "new_password1": " password ",
849 "new_password2": " password ",
850 }
851 form = SetPasswordForm(user, data)
852 self.assertTrue(form.is_valid())
853 self.assertEqual(form.cleaned_data["new_password1"], data["new_password1"])
854 self.assertEqual(form.cleaned_data["new_password2"], data["new_password2"])
855
856 @override_settings(
857 AUTH_PASSWORD_VALIDATORS=[
858 {
859 "NAME": (
860 "django.contrib.auth.password_validation."
861 "UserAttributeSimilarityValidator"
862 )
863 },
864 {
865 "NAME": (
866 "django.contrib.auth.password_validation.MinimumLengthValidator"
867 ),
868 "OPTIONS": {
869 "min_length": 12,
870 },
871 },
872 ]
873 )
874 def test_help_text_translation(self):
875 french_help_texts = [
876 "Votre mot de passe ne peut pas trop ressembler à vos autres informations "
877 "personnelles.",
878 "Votre mot de passe doit contenir au minimum 12 caractères.",
879 ]
880 form = SetPasswordForm(self.u1)
881 with translation.override("fr"):
882 html = form.as_p()
883 for french_text in french_help_texts:
884 self.assertIn(french_text, html)
885
886 def test_html_autocomplete_attributes(self):
887 form = SetPasswordForm(self.u1)
888 tests = (
889 ("new_password1", "new-password"),
890 ("new_password2", "new-password"),
891 )
892 for field_name, autocomplete in tests:
893 with self.subTest(field_name=field_name, autocomplete=autocomplete):
894 self.assertEqual(
895 form.fields[field_name].widget.attrs["autocomplete"], autocomplete
896 )
897
898 def test_password_extra_validations(self):
899 class ExtraValidationForm(ExtraValidationFormMixin, SetPasswordForm):
900 def clean_new_password1(self):
901 return self.failing_helper("new_password1")
902
903 def clean_new_password2(self):
904 return self.failing_helper("new_password2")
905
906 user = User.objects.get(username="testclient")
907 data = {"new_password1": "abc", "new_password2": "abc"}
908 for fields in (
909 ["new_password1"],
910 ["new_password2"],
911 ["new_password1", "new_password2"],
912 ):
913 with self.subTest(fields=fields):
914 errors = {field: [f"Extra validation for {field}."] for field in fields}
915 form = ExtraValidationForm(user, data, failing_fields=errors)
916 self.assertIs(form.is_valid(), False)
917 self.assertDictEqual(form.errors, errors)
918
919
920 class PasswordChangeFormTest(TestDataMixin, TestCase):
921 def test_incorrect_password(self):
922 user = User.objects.get(username="testclient")
923 data = {
924 "old_password": "test",
925 "new_password1": "abc123",
926 "new_password2": "abc123",
927 }
928 form = PasswordChangeForm(user, data)
929 self.assertFalse(form.is_valid())
930 self.assertEqual(
931 form["old_password"].errors,
932 [str(form.error_messages["password_incorrect"])],
933 )
934
935 def test_password_verification(self):
936 # The two new passwords do not match.
937 user = User.objects.get(username="testclient")
938 data = {
939 "old_password": "password",
940 "new_password1": "abc123",
941 "new_password2": "abc",
942 }
943 form = PasswordChangeForm(user, data)
944 self.assertFalse(form.is_valid())
945 self.assertEqual(
946 form["new_password2"].errors,
947 [str(form.error_messages["password_mismatch"])],
948 )
949
950 @mock.patch("django.contrib.auth.password_validation.password_changed")
951 def test_success(self, password_changed):
952 # The success case.
953 user = User.objects.get(username="testclient")
954 data = {
955 "old_password": "password",
956 "new_password1": "abc123",
957 "new_password2": "abc123",
958 }
959 form = PasswordChangeForm(user, data)
960 self.assertTrue(form.is_valid())
961 form.save(commit=False)
962 self.assertEqual(password_changed.call_count, 0)
963 form.save()
964 self.assertEqual(password_changed.call_count, 1)
965
966 def test_field_order(self):
967 # Regression test - check the order of fields:
968 user = User.objects.get(username="testclient")
969 self.assertEqual(
970 list(PasswordChangeForm(user, {}).fields),
971 ["old_password", "new_password1", "new_password2"],
972 )
973
974 def test_password_whitespace_not_stripped(self):
975 user = User.objects.get(username="testclient")
976 user.set_password(" oldpassword ")
977 data = {
978 "old_password": " oldpassword ",
979 "new_password1": " pass ",
980 "new_password2": " pass ",
981 }
982 form = PasswordChangeForm(user, data)
983 self.assertTrue(form.is_valid())
984 self.assertEqual(form.cleaned_data["old_password"], data["old_password"])
985 self.assertEqual(form.cleaned_data["new_password1"], data["new_password1"])
986 self.assertEqual(form.cleaned_data["new_password2"], data["new_password2"])
987
988 def test_html_autocomplete_attributes(self):
989 user = User.objects.get(username="testclient")
990 form = PasswordChangeForm(user)
991 self.assertEqual(
992 form.fields["old_password"].widget.attrs["autocomplete"], "current-password"
993 )
994
995
996 class UserChangeFormTest(TestDataMixin, TestCase):
997 def test_username_validity(self):
998 user = User.objects.get(username="testclient")
999 data = {"username": "not valid"}
1000 form = UserChangeForm(data, instance=user)
1001 self.assertFalse(form.is_valid())
1002 validator = next(
1003 v
1004 for v in User._meta.get_field("username").validators
1005 if v.code == "invalid"
1006 )
1007 self.assertEqual(form["username"].errors, [str(validator.message)])
1008
1009 def test_bug_14242(self):
1010 # A regression test, introduce by adding an optimization for the
1011 # UserChangeForm.
1012
1013 class MyUserForm(UserChangeForm):
1014 def __init__(self, *args, **kwargs):
1015 super().__init__(*args, **kwargs)
1016 self.fields["groups"].help_text = (
1017 "These groups give users different permissions"
1018 )
1019
1020 class Meta(UserChangeForm.Meta):
1021 fields = ("groups",)
1022
1023 # Just check we can create it
1024 MyUserForm({})
1025
1026 def test_unusable_password(self):
1027 user = User.objects.get(username="unusable_password")
1028 form = UserChangeForm(instance=user)
1029 self.assertIn(_("No password set."), form.as_table())
1030
1031 def test_bug_17944_empty_password(self):
1032 user = User.objects.get(username="empty_password")
1033 form = UserChangeForm(instance=user)
1034 self.assertIn(_("No password set."), form.as_table())
1035
1036 def test_bug_17944_unmanageable_password(self):
1037 user = User.objects.get(username="unmanageable_password")
1038 form = UserChangeForm(instance=user)
1039 self.assertIn(
1040 _("Invalid password format or unknown hashing algorithm."), form.as_table()
1041 )
1042
1043 def test_bug_17944_unknown_password_algorithm(self):
1044 user = User.objects.get(username="unknown_password")
1045 form = UserChangeForm(instance=user)
1046 self.assertIn(
1047 _("Invalid password format or unknown hashing algorithm."), form.as_table()
1048 )
1049
1050 def test_bug_19133(self):
1051 "The change form does not return the password value"
1052 # Use the form to construct the POST data
1053 user = User.objects.get(username="testclient")
1054 form_for_data = UserChangeForm(instance=user)
1055 post_data = form_for_data.initial
1056
1057 # The password field should be readonly, so anything
1058 # posted here should be ignored; the form will be
1059 # valid, and give back the 'initial' value for the
1060 # password field.
1061 post_data["password"] = "new password"
1062 form = UserChangeForm(instance=user, data=post_data)
1063
1064 self.assertTrue(form.is_valid())
1065 # original hashed password contains $
1066 self.assertIn("$", form.cleaned_data["password"])
1067
1068 def test_bug_19349_bound_password_field(self):
1069 user = User.objects.get(username="testclient")
1070 form = UserChangeForm(data={}, instance=user)
1071 # When rendering the bound password field,
1072 # ReadOnlyPasswordHashWidget needs the initial
1073 # value to render correctly
1074 self.assertEqual(form.initial["password"], form["password"].value())
1075
1076 @override_settings(ROOT_URLCONF="auth_tests.urls_admin")
1077 def test_link_to_password_reset_in_user_change_form(self):
1078 cases = [
1079 (
1080 "testclient",
1081 "Raw passwords are not stored, so there is no way to see "
1082 "the user’s password.",
1083 "Reset password",
1084 ),
1085 (
1086 "unusable_password",
1087 "Enable password-based authentication for this user by setting a "
1088 "password.",
1089 "Set password",
1090 ),
1091 ]
1092 password_reset_link = r'<a class="button" href="([^"]*)">([^<]*)</a>'
1093 for username, expected_help_text, expected_button_label in cases:
1094 with self.subTest(username=username):
1095 user = User.objects.get(username=username)
1096 form = UserChangeForm(data={}, instance=user)
1097 password_help_text = form.fields["password"].help_text
1098 self.assertEqual(password_help_text, expected_help_text)
1099
1100 matches = re.search(password_reset_link, form.as_p())
1101 self.assertIsNotNone(matches)
1102 self.assertEqual(len(matches.groups()), 2)
1103 url_prefix = f"admin:{user._meta.app_label}_{user._meta.model_name}"
1104 # URL to UserChangeForm in admin via to_field (instead of pk).
1105 user_change_url = reverse(f"{url_prefix}_change", args=(user.pk,))
1106 joined_url = urllib.parse.urljoin(user_change_url, matches.group(1))
1107
1108 pw_change_url = reverse(
1109 f"{url_prefix}_password_change", args=(user.pk,)
1110 )
1111 self.assertEqual(joined_url, pw_change_url)
1112 self.assertEqual(matches.group(2), expected_button_label)
1113
1114 def test_custom_form(self):
1115 class CustomUserChangeForm(UserChangeForm):
1116 class Meta(UserChangeForm.Meta):
1117 model = ExtensionUser
1118 fields = (
1119 "username",
1120 "password",
1121 "date_of_birth",
1122 )
1123
1124 user = User.objects.get(username="testclient")
1125 data = {
1126 "username": "testclient",
1127 "password": "testclient",
1128 "date_of_birth": "1998-02-24",
1129 }
1130 form = CustomUserChangeForm(data, instance=user)
1131 self.assertTrue(form.is_valid())
1132 form.save()
1133 self.assertEqual(form.cleaned_data["username"], "testclient")
1134 self.assertEqual(form.cleaned_data["date_of_birth"], datetime.date(1998, 2, 24))
1135
1136 def test_password_excluded(self):
1137 class UserChangeFormWithoutPassword(UserChangeForm):
1138 password = None
1139
1140 class Meta:
1141 model = User
1142 exclude = ["password"]
1143
1144 form = UserChangeFormWithoutPassword()
1145 self.assertNotIn("password", form.fields)
1146
1147 def test_username_field_autocapitalize_none(self):
1148 form = UserChangeForm()
1149 self.assertEqual(
1150 form.fields["username"].widget.attrs.get("autocapitalize"), "none"
1151 )
1152
1153
1154 @override_settings(TEMPLATES=AUTH_TEMPLATES)
1155 class PasswordResetFormTest(TestDataMixin, TestCase):
1156 @classmethod
1157 def setUpClass(cls):
1158 super().setUpClass()
1159 # This cleanup is necessary because contrib.sites cache
1160 # makes tests interfere with each other, see #11505
1161 Site.objects.clear_cache()
1162
1163 def assertEmailMessageSent(self, **kwargs):
1164 self.assertEqual(len(mail.outbox), 1)
1165 msg = mail.outbox[0]
1166 for attr, expected in kwargs.items():
1167 with self.subTest(attr=attr):
1168 self.assertEqual(getattr(msg, attr), expected)
1169 return msg
1170
1171 def create_dummy_user(self):
1172 """
1173 Create a user and return a tuple (user_object, username, email).
1174 """
1175 username = "jsmith"
1176 email = "[email protected]"
1177 user = User.objects.create_user(username, email, "test123")
1178 return (user, username, email)
1179
1180 def test_invalid_email(self):
1181 data = {"email": "not valid"}
1182 form = PasswordResetForm(data)
1183 self.assertFalse(form.is_valid())
1184 self.assertEqual(form["email"].errors, [_("Enter a valid email address.")])
1185
1186 def test_user_email_unicode_collision(self):
1187 User.objects.create_user("mike123", "[email protected]", "test123")
1188 User.objects.create_user("mike456", "mı[email protected]", "test123")
1189 data = {"email": "mı[email protected]"}
1190 form = PasswordResetForm(data)
1191 self.assertTrue(form.is_valid())
1192 form.save()
1193 self.assertEmailMessageSent(to=["mı[email protected]"])
1194
1195 def test_user_email_domain_unicode_collision(self):
1196 User.objects.create_user("mike123", "[email protected]", "test123")
1197 User.objects.create_user("mike456", "mike@ıxample.org", "test123")
1198 data = {"email": "mike@ıxample.org"}
1199 form = PasswordResetForm(data)
1200 self.assertTrue(form.is_valid())
1201 form.save()
1202 self.assertEmailMessageSent(to=["mike@ıxample.org"])
1203
1204 def test_user_email_unicode_collision_nonexistent(self):
1205 User.objects.create_user("mike123", "[email protected]", "test123")
1206 data = {"email": "mı[email protected]"}
1207 form = PasswordResetForm(data)
1208 self.assertTrue(form.is_valid())
1209 form.save()
1210 self.assertEqual(len(mail.outbox), 0)
1211
1212 def test_user_email_domain_unicode_collision_nonexistent(self):
1213 User.objects.create_user("mike123", "[email protected]", "test123")
1214 data = {"email": "mike@ıxample.org"}
1215 form = PasswordResetForm(data)
1216 self.assertTrue(form.is_valid())
1217 form.save()
1218 self.assertEqual(len(mail.outbox), 0)
1219
1220 def test_nonexistent_email(self):
1221 """
1222 Test nonexistent email address. This should not fail because it would
1223 expose information about registered users.
1224 """
1225 data = {"email": "[email protected]"}
1226 form = PasswordResetForm(data)
1227 self.assertTrue(form.is_valid())
1228 self.assertEqual(len(mail.outbox), 0)
1229
1230 def test_cleaned_data(self):
1231 user, username, email = self.create_dummy_user()
1232 data = {"email": email}
1233 form = PasswordResetForm(data)
1234 self.assertTrue(form.is_valid())
1235 form.save(domain_override="example.com")
1236 self.assertEqual(form.cleaned_data["email"], email)
1237 self.assertEmailMessageSent()
1238
1239 def test_custom_email_subject(self):
1240 data = {"email": "[email protected]"}
1241 form = PasswordResetForm(data)
1242 self.assertTrue(form.is_valid())
1243 # Since we're not providing a request object, we must provide a
1244 # domain_override to prevent the save operation from failing in the
1245 # potential case where contrib.sites is not installed. Refs #16412.
1246 form.save(domain_override="example.com")
1247 self.assertEmailMessageSent(subject="Custom password reset on example.com")
1248
1249 def test_custom_email_constructor(self):
1250 data = {"email": "[email protected]"}
1251
1252 class CustomEmailPasswordResetForm(PasswordResetForm):
1253 def send_mail(
1254 self,
1255 subject_template_name,
1256 email_template_name,
1257 context,
1258 from_email,
1259 to_email,
1260 html_email_template_name=None,
1261 ):
1262 EmailMultiAlternatives(
1263 "Forgot your password?",
1264 "Sorry to hear you forgot your password.",
1265 None,
1266 [to_email],
1267 ["[email protected]"],
1268 headers={"Reply-To": "[email protected]"},
1269 alternatives=[
1270 ("Really sorry to hear you forgot your password.", "text/html")
1271 ],
1272 ).send()
1273
1274 form = CustomEmailPasswordResetForm(data)
1275 self.assertTrue(form.is_valid())
1276 # Since we're not providing a request object, we must provide a
1277 # domain_override to prevent the save operation from failing in the
1278 # potential case where contrib.sites is not installed. Refs #16412.
1279 form.save(domain_override="example.com")
1280 self.assertEmailMessageSent(
1281 subject="Forgot your password?",
1282 bcc=["[email protected]"],
1283 content_subtype="plain",
1284 )
1285
1286 def test_preserve_username_case(self):
1287 """
1288 Preserve the case of the user name (before the @ in the email address)
1289 when creating a user (#5605).
1290 """
1291 user = User.objects.create_user("forms_test2", "[email protected]", "test")
1292 self.assertEqual(user.email, "[email protected]")
1293 user = User.objects.create_user("forms_test3", "tesT", "test")
1294 self.assertEqual(user.email, "tesT")
1295
1296 def test_inactive_user(self):
1297 """
1298 Inactive user cannot receive password reset email.
1299 """
1300 user, username, email = self.create_dummy_user()
1301 user.is_active = False
1302 user.save()
1303 form = PasswordResetForm({"email": email})
1304 self.assertTrue(form.is_valid())
1305 form.save()
1306 self.assertEqual(len(mail.outbox), 0)
1307
1308 def test_unusable_password(self):
1309 user = User.objects.create_user("testuser", "[email protected]", "test")
1310 data = {"email": "[email protected]"}
1311 form = PasswordResetForm(data)
1312 self.assertTrue(form.is_valid())
1313 user.set_unusable_password()
1314 user.save()
1315 form = PasswordResetForm(data)
1316 # The form itself is valid, but no email is sent
1317 self.assertTrue(form.is_valid())
1318 form.save()
1319 self.assertEqual(len(mail.outbox), 0)
1320
1321 def test_save_plaintext_email(self):
1322 """
1323 Test the PasswordResetForm.save() method with no html_email_template_name
1324 parameter passed in.
1325 Test to ensure original behavior is unchanged after the parameter was added.
1326 """
1327 user, username, email = self.create_dummy_user()
1328 form = PasswordResetForm({"email": email})
1329 self.assertTrue(form.is_valid())
1330 form.save()
1331 msg = self.assertEmailMessageSent()
1332 self.assertEqual(len(msg.alternatives), 0)
1333 message = msg.message()
1334 self.assertFalse(message.is_multipart())
1335 self.assertEqual(message.get_content_type(), "text/plain")
1336 self.assertEqual(message.get("subject"), "Custom password reset on example.com")
1337 self.assertEqual(message.get_all("to"), [email])
1338 self.assertTrue(
1339 re.match(r"^http://example.com/reset/[\w+/-]", message.get_payload())
1340 )
1341
1342 def test_save_html_email_template_name(self):
1343 """
1344 Test the PasswordResetForm.save() method with html_email_template_name
1345 parameter specified.
1346 Test to ensure that a multipart email is sent with both text/plain
1347 and text/html parts.
1348 """
1349 user, username, email = self.create_dummy_user()
1350 form = PasswordResetForm({"email": email})
1351 self.assertTrue(form.is_valid())
1352 form.save(
1353 html_email_template_name="registration/html_password_reset_email.html"
1354 )
1355 msg = self.assertEmailMessageSent()
1356 self.assertEqual(len(msg.alternatives), 1)
1357 message = msg.message()
1358 self.assertEqual(message.get("subject"), "Custom password reset on example.com")
1359 self.assertEqual(len(message.get_payload()), 2)
1360 self.assertTrue(message.is_multipart())
1361 self.assertEqual(message.get_payload(0).get_content_type(), "text/plain")
1362 self.assertEqual(message.get_payload(1).get_content_type(), "text/html")
1363 self.assertEqual(message.get_all("to"), [email])
1364 self.assertTrue(
1365 re.match(
1366 r"^http://example.com/reset/[\w/-]+",
1367 message.get_payload(0).get_payload(),
1368 )
1369 )
1370 self.assertTrue(
1371 re.match(
1372 r'^<html><a href="http://example.com/reset/[\w/-]+/">Link</a></html>$',
1373 message.get_payload(1).get_payload(),
1374 )
1375 )
1376
1377 @override_settings(EMAIL_BACKEND="mail.custombackend.FailingEmailBackend")
1378 def test_save_send_email_exceptions_are_catched_and_logged(self):
1379 user, username, email = self.create_dummy_user()
1380 form = PasswordResetForm({"email": email})
1381 self.assertTrue(form.is_valid())
1382
1383 with self.assertLogs("django.contrib.auth", level=0) as cm:
1384 form.save()
1385
1386 self.assertEqual(len(mail.outbox), 0)
1387 self.assertEqual(len(cm.output), 1)
1388 errors = cm.output[0].split("\n")
1389 pk = user.pk
1390 self.assertEqual(
1391 errors[0],
1392 f"ERROR:django.contrib.auth:Failed to send password reset email to {pk}",
1393 )
1394 self.assertEqual(
1395 errors[-1], "ValueError: FailingEmailBackend is doomed to fail."
1396 )
1397
1398 @override_settings(AUTH_USER_MODEL="auth_tests.CustomEmailField")
1399 def test_custom_email_field(self):
1400 email = "[email protected]"
1401 CustomEmailField.objects.create_user("test name", "test password", email)
1402 form = PasswordResetForm({"email": email})
1403 self.assertTrue(form.is_valid())
1404 form.save()
1405 self.assertEqual(form.cleaned_data["email"], email)
1406 self.assertEqual(len(mail.outbox), 1)
1407 self.assertEqual(mail.outbox[0].to, [email])
1408
1409 def test_html_autocomplete_attributes(self):
1410 form = PasswordResetForm()
1411 self.assertEqual(form.fields["email"].widget.attrs["autocomplete"], "email")
1412
1413
1414 class ReadOnlyPasswordHashTest(SimpleTestCase):
1415 def test_bug_19349_render_with_none_value(self):
1416 # Rendering the widget with value set to None
1417 # mustn't raise an exception.
1418 widget = ReadOnlyPasswordHashWidget()
1419 html = widget.render(name="password", value=None, attrs={})
1420 self.assertIn(_("No password set."), html)
1421
1422 @override_settings(
1423 PASSWORD_HASHERS=["django.contrib.auth.hashers.PBKDF2PasswordHasher"]
1424 )
1425 def test_render(self):
1426 widget = ReadOnlyPasswordHashWidget()
1427 value = (
1428 "pbkdf2_sha256$100000$a6Pucb1qSFcD$WmCkn9Hqidj48NVe5x0FEM6A9YiOqQcl/83m2Z5u"
1429 "dm0="
1430 )
1431 self.assertHTMLEqual(
1432 widget.render("name", value, {"id": "id_password"}),
1433 '<div id="id_password">'
1434 " <p>"
1435 " <strong>algorithm</strong>: <bdi>pbkdf2_sha256</bdi>"
1436 " <strong>iterations</strong>: <bdi>100000</bdi>"
1437 " <strong>salt</strong>: <bdi>a6Pucb******</bdi>"
1438 " <strong>hash</strong>: "
1439 " <bdi>WmCkn9**************************************</bdi>"
1440 " </p>"
1441 ' <p><a class="button" href="../password/">Reset password</a></p>'
1442 "</div>",
1443 )
1444
1445 def test_readonly_field_has_changed(self):
1446 field = ReadOnlyPasswordHashField()
1447 self.assertIs(field.disabled, True)
1448 self.assertFalse(field.has_changed("aaa", "bbb"))
1449
1450 def test_label(self):
1451 """
1452 ReadOnlyPasswordHashWidget doesn't contain a for attribute in the
1453 <label> because it doesn't have any labelable elements.
1454 """
1455
1456 class TestForm(forms.Form):
1457 hash_field = ReadOnlyPasswordHashField()
1458
1459 bound_field = TestForm()["hash_field"]
1460 self.assertIsNone(bound_field.field.widget.id_for_label("id"))
1461 self.assertEqual(bound_field.label_tag(), "<label>Hash field:</label>")
1462
1463
1464 class AdminPasswordChangeFormTest(TestDataMixin, TestCase):
1465 @mock.patch("django.contrib.auth.password_validation.password_changed")
1466 def test_success(self, password_changed):
1467 user = User.objects.get(username="testclient")
1468 data = {
1469 "password1": "test123",
1470 "password2": "test123",
1471 }
1472 form = AdminPasswordChangeForm(user, data)
1473 self.assertTrue(form.is_valid())
1474 form.save(commit=False)
1475 self.assertEqual(password_changed.call_count, 0)
1476 form.save()
1477 self.assertEqual(password_changed.call_count, 1)
1478 self.assertEqual(form.changed_data, ["password"])
1479
1480 @override_settings(
1481 AUTH_PASSWORD_VALIDATORS=[
1482 {
1483 "NAME": (
1484 "django.contrib.auth.password_validation."
1485 "UserAttributeSimilarityValidator"
1486 )
1487 },
1488 {
1489 "NAME": (
1490 "django.contrib.auth.password_validation.MinimumLengthValidator"
1491 ),
1492 "OPTIONS": {
1493 "min_length": 12,
1494 },
1495 },
1496 ]
1497 )
1498 def test_validates_password(self):
1499 user = User.objects.get(username="testclient")
1500 data = {
1501 "password1": "testclient",
1502 "password2": "testclient",
1503 }
1504 form = AdminPasswordChangeForm(user, data)
1505 self.assertFalse(form.is_valid())
1506 self.assertEqual(len(form["password2"].errors), 2)
1507 self.assertIn(
1508 "The password is too similar to the username.",
1509 form["password2"].errors,
1510 )
1511 self.assertIn(
1512 "This password is too short. It must contain at least 12 characters.",
1513 form["password2"].errors,
1514 )
1515
1516 # passwords are not validated if `usable_password` is unset
1517 data = {
1518 "password1": "testclient",
1519 "password2": "testclient",
1520 "usable_password": "false",
1521 }
1522 form = AdminPasswordChangeForm(user, data)
1523 self.assertIs(form.is_valid(), True, form.errors)
1524
1525 def test_password_whitespace_not_stripped(self):
1526 user = User.objects.get(username="testclient")
1527 data = {
1528 "password1": " pass ",
1529 "password2": " pass ",
1530 }
1531 form = AdminPasswordChangeForm(user, data)
1532 self.assertTrue(form.is_valid())
1533 self.assertEqual(form.cleaned_data["password1"], data["password1"])
1534 self.assertEqual(form.cleaned_data["password2"], data["password2"])
1535 self.assertEqual(form.changed_data, ["password"])
1536
1537 def test_password_extra_validations(self):
1538 class ExtraValidationForm(ExtraValidationFormMixin, AdminPasswordChangeForm):
1539 def clean_password1(self):
1540 return self.failing_helper("password1")
1541
1542 def clean_password2(self):
1543 return self.failing_helper("password2")
1544
1545 user = User.objects.get(username="testclient")
1546 data = {"username": "extra", "password1": "abc", "password2": "abc"}
1547 for fields in (["password1"], ["password2"], ["password1", "password2"]):
1548 with self.subTest(fields=fields):
1549 errors = {field: [f"Extra validation for {field}."] for field in fields}
1550 form = ExtraValidationForm(user, data, failing_fields=errors)
1551 self.assertIs(form.is_valid(), False)
1552 self.assertDictEqual(form.errors, errors)
1553
1554 def test_non_matching_passwords(self):
1555 user = User.objects.get(username="testclient")
1556 data = {"password1": "password1", "password2": "password2"}
1557 form = AdminPasswordChangeForm(user, data)
1558 self.assertEqual(
1559 form.errors["password2"], [form.error_messages["password_mismatch"]]
1560 )
1561 self.assertEqual(form.changed_data, ["password"])
1562
1563 def test_missing_passwords(self):
1564 user = User.objects.get(username="testclient")
1565 data = {"password1": "", "password2": ""}
1566 form = AdminPasswordChangeForm(user, data)
1567 required_error = [Field.default_error_messages["required"]]
1568 self.assertEqual(form.errors["password1"], required_error)
1569 self.assertEqual(form.errors["password2"], required_error)
1570 self.assertEqual(form.changed_data, [])
1571
1572 def test_one_password(self):
1573 user = User.objects.get(username="testclient")
1574 form1 = AdminPasswordChangeForm(user, {"password1": "", "password2": "test"})
1575 required_error = [Field.default_error_messages["required"]]
1576 self.assertEqual(form1.errors["password1"], required_error)
1577 self.assertNotIn("password2", form1.errors)
1578 self.assertEqual(form1.changed_data, [])
1579 form2 = AdminPasswordChangeForm(user, {"password1": "test", "password2": ""})
1580 self.assertEqual(form2.errors["password2"], required_error)
1581 self.assertNotIn("password1", form2.errors)
1582 self.assertEqual(form2.changed_data, [])
1583
1584 def test_html_autocomplete_attributes(self):
1585 user = User.objects.get(username="testclient")
1586 form = AdminPasswordChangeForm(user)
1587 tests = (
1588 ("password1", "new-password"),
1589 ("password2", "new-password"),
1590 )
1591 for field_name, autocomplete in tests:
1592 with self.subTest(field_name=field_name, autocomplete=autocomplete):
1593 self.assertEqual(
1594 form.fields[field_name].widget.attrs["autocomplete"], autocomplete
1595 )
1596
1597 def test_enable_password_authentication(self):
1598 user = User.objects.get(username="unusable_password")
1599 form = AdminPasswordChangeForm(
1600 user,
1601 {"password1": "complexpassword", "password2": "complexpassword"},
1602 )
1603 self.assertNotIn("usable_password", form.fields)
1604 self.assertIs(form.is_valid(), True)
1605 user = form.save(commit=True)
1606 self.assertIs(user.has_usable_password(), True)
1607
1608 def test_disable_password_authentication(self):
1609 user = User.objects.get(username="testclient")
1610 form = AdminPasswordChangeForm(
1611 user,
1612 {"usable_password": "false", "password1": "", "password2": "test"},
1613 )
1614 self.assertIn("usable_password", form.fields)
1615 self.assertIn(
1616 "If disabled, the current password for this user will be lost.",
1617 form.fields["usable_password"].help_text,
1618 )
1619 self.assertIs(form.is_valid(), True) # Valid despite password empty/mismatch.
1620 user = form.save(commit=True)
1621 self.assertIs(user.has_usable_password(), False)
1622
1623
1624 class AdminUserCreationFormTest(BaseUserCreationFormTest):
1625
1626 form_class = AdminUserCreationForm
1627
1628 def test_form_fields(self):
1629 form = self.form_class()
1630 self.assertEqual(
1631 list(form.fields.keys()),
1632 ["username", "password1", "password2", "usable_password"],
1633 )
1634
1635 @override_settings(
1636 AUTH_PASSWORD_VALIDATORS=[
1637 {
1638 "NAME": (
1639 "django.contrib.auth.password_validation."
1640 "UserAttributeSimilarityValidator"
1641 )
1642 },
1643 {
1644 "NAME": (
1645 "django.contrib.auth.password_validation.MinimumLengthValidator"
1646 ),
1647 "OPTIONS": {
1648 "min_length": 12,
1649 },
1650 },
1651 ]
1652 )
1653 def test_no_password_validation_if_unusable_password_set(self):
1654 data = {
1655 "username": "otherclient",
1656 "password1": "otherclient",
1657 "password2": "otherclient",
1658 "usable_password": "false",
1659 }
1660 form = self.form_class(data)
1661 # Passwords are not validated if `usable_password` is unset.
1662 self.assertIs(form.is_valid(), True, form.errors)
1663
1664 class CustomUserCreationForm(self.form_class):
1665 class Meta(self.form_class.Meta):
1666 model = User
1667 fields = ("username", "email", "first_name", "last_name")
1668
1669 form = CustomUserCreationForm(
1670 {
1671 "username": "testuser",
1672 "password1": "testpassword",
1673 "password2": "testpassword",
1674 "first_name": "testpassword",
1675 "last_name": "lastname",
1676 "usable_password": "false",
1677 }
1678 )
1679 self.assertIs(form.is_valid(), True, form.errors)
1680
1681 def test_unusable_password(self):
1682 data = {
1683 "username": "new-user-which-does-not-exist",
1684 "usable_password": "false",
1685 }
1686 form = self.form_class(data)
1687 self.assertIs(form.is_valid(), True, form.errors)
1688 u = form.save()
1689 self.assertEqual(u.username, data["username"])
1690 self.assertFalse(u.has_usable_password())
1691
1692
1693 class SensitiveVariablesTest(TestDataMixin, TestCase):
1694 @sensitive_variables("data")
1695 def test_passwords_marked_as_sensitive_in_admin_forms(self):
1696 data = {
1697 "password1": "passwordsensitive",
1698 "password2": "sensitivepassword",
1699 "usable_password": "true",
1700 }
1701 forms = [
1702 AdminUserCreationForm({**data, "username": "newusername"}),
1703 AdminPasswordChangeForm(self.u1, data),
1704 ]
1705
1706 password1_fragment = """
1707 <td>password1</td>
1708 <td class="code"><pre>&#x27;********************&#x27;</pre></td>
1709 """
1710 password2_fragment = """
1711 <td>password2</td>
1712 <td class="code"><pre>&#x27;********************&#x27;</pre></td>
1713 """
1714 error = ValueError("Forced error")
1715 for form in forms:
1716 with self.subTest(form=form):
1717 with mock.patch.object(
1718 SetPasswordMixin, "validate_passwords", side_effect=error
1719 ):
1720 try:
1721 form.is_valid()
1722 except ValueError:
1723 exc_info = sys.exc_info()
1724 else:
1725 self.fail("Form validation should have failed.")
1726
1727 response = technical_500_response(RequestFactory().get("/"), *exc_info)
1728
1729 self.assertNotContains(response, "sensitivepassword", status_code=500)
1730 self.assertNotContains(response, "passwordsensitive", status_code=500)
1731 self.assertContains(response, str(error), status_code=500)
1732 self.assertContains(
1733 response, password1_fragment, html=True, status_code=500
1734 )
1735 self.assertContains(
1736 response, password2_fragment, html=True, status_code=500
1737 )