Commits

Luke Plant  committed d8c37a6

[1.2.X] Converted tests for contrib.auth.forms to unit tests.

Backport of [13701], needed in order to backport [13702]

  • Participants
  • Parent commits 8d7aa14
  • Branches releases/1.2.X

Comments (0)

Files changed (2)

File django/contrib/auth/tests/__init__.py

 from django.contrib.auth.tests.auth_backends import BackendTest, RowlevelBackendTest, AnonymousUserBackendTest, NoAnonymousUserBackendTest
 from django.contrib.auth.tests.basic import BASIC_TESTS
 from django.contrib.auth.tests.decorators import LoginRequiredTestCase
-from django.contrib.auth.tests.forms import FORM_TESTS
+from django.contrib.auth.tests.forms import UserCreationFormTest, AuthenticationFormTest, SetPasswordFormTest, PasswordChangeFormTest, UserChangeFormTest, PasswordResetFormTest
 from django.contrib.auth.tests.remote_user \
         import RemoteUserTest, RemoteUserNoCreateTest, RemoteUserCustomTest
 from django.contrib.auth.tests.models import ProfileTestCase
 
 __test__ = {
     'BASIC_TESTS': BASIC_TESTS,
-    'FORM_TESTS': FORM_TESTS,
     'TOKEN_GENERATOR_TESTS': TOKEN_GENERATOR_TESTS,
 }

File django/contrib/auth/tests/forms.py

+from django.contrib.auth.models import User
+from django.contrib.auth.forms import UserCreationForm, AuthenticationForm,  PasswordChangeForm, SetPasswordForm, UserChangeForm, PasswordResetForm
+from django.test import TestCase
 
-FORM_TESTS = """
->>> from django.contrib.auth.models import User
->>> from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
->>> from django.contrib.auth.forms import PasswordChangeForm, SetPasswordForm
 
-# The user already exists.
+class UserCreationFormTest(TestCase):
 
->>> user = User.objects.create_user("jsmith", "jsmith@example.com", "test123")
->>> data = {
-...     'username': 'jsmith',
-...     'password1': 'test123',
-...     'password2': 'test123',
-... }
->>> form = UserCreationForm(data)
->>> form.is_valid()
-False
->>> form["username"].errors
-[u'A user with that username already exists.']
+    fixtures = ['authtestdata.json']
 
-# The username contains invalid data.
+    def test_user_already_exists(self):
+        data = {
+            'username': 'testclient',
+            'password1': 'test123',
+            'password2': 'test123',
+            }
+        form = UserCreationForm(data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form["username"].errors,
+                         [u'A user with that username already exists.'])
 
->>> data = {
-...     'username': 'jsmith!',
-...     'password1': 'test123',
-...     'password2': 'test123',
-... }
->>> form = UserCreationForm(data)
->>> form.is_valid()
-False
->>> form["username"].errors
-[u'This value may contain only letters, numbers and @/./+/-/_ characters.']
+    def test_invalid_data(self):
+        data = {
+            'username': 'jsmith!',
+            'password1': 'test123',
+            'password2': 'test123',
+            }
+        form = UserCreationForm(data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form["username"].errors,
+                         [u'This value may contain only letters, numbers and @/./+/-/_ characters.'])
 
-# The verification password is incorrect.
 
->>> data = {
-...     'username': 'jsmith2',
-...     'password1': 'test123',
-...     'password2': 'test',
-... }
->>> form = UserCreationForm(data)
->>> form.is_valid()
-False
->>> form["password2"].errors
-[u"The two password fields didn't match."]
+    def test_password_verification(self):
+        # The verification password is incorrect.
+        data = {
+            'username': 'jsmith',
+            'password1': 'test123',
+            'password2': 'test',
+            }
+        form = UserCreationForm(data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form["password2"].errors,
+                         [u"The two password fields didn't match."])
 
-# One (or both) passwords weren't given
 
->>> data = {'username': 'jsmith2'}
->>> form = UserCreationForm(data)
->>> form.is_valid()
-False
->>> form['password1'].errors
-[u'This field is required.']
->>> form['password2'].errors
-[u'This field is required.']
+    def test_both_passwords(self):
+        # One (or both) passwords weren't given
+        data = {'username': 'jsmith'}
+        form = UserCreationForm(data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form['password1'].errors,
+                         [u'This field is required.'])
+        self.assertEqual(form['password2'].errors,
+                         [u'This field is required.'])
 
->>> data['password2'] = 'test123'
->>> form = UserCreationForm(data)
->>> form.is_valid()
-False
->>> form['password1'].errors
-[u'This field is required.']
 
-# The success case.
+        data['password2'] = 'test123'
+        form = UserCreationForm(data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form['password1'].errors,
+                         [u'This field is required.'])
 
->>> data = {
-...     'username': 'jsmith2@example.com',
-...     'password1': 'test123',
-...     'password2': 'test123',
-... }
->>> form = UserCreationForm(data)
->>> form.is_valid()
-True
->>> form.save()
-<User: jsmith2@example.com>
+    def test_success(self):
+        # The success case.
 
-# The user submits an invalid username.
+        data = {
+            'username': 'jsmith@example.com',
+            'password1': 'test123',
+            'password2': 'test123',
+            }
+        form = UserCreationForm(data)
+        self.assertTrue(form.is_valid())
+        u = form.save()
+        self.assertEqual(repr(u), '<User: jsmith@example.com>')
 
->>> data = {
-...     'username': 'jsmith_does_not_exist',
-...     'password': 'test123',
-... }
 
->>> form = AuthenticationForm(None, data)
->>> form.is_valid()
-False
->>> form.non_field_errors()
-[u'Please enter a correct username and password. Note that both fields are case-sensitive.']
+class AuthenticationFormTest(TestCase):
 
-# The user is inactive.
+    fixtures = ['authtestdata.json']
 
->>> data = {
-...     'username': 'jsmith',
-...     'password': 'test123',
-... }
->>> user.is_active = False
->>> user.save()
->>> form = AuthenticationForm(None, data)
->>> form.is_valid()
-False
->>> form.non_field_errors()
-[u'This account is inactive.']
+    def test_invalid_username(self):
+        # The user submits an invalid username.
 
->>> user.is_active = True
->>> user.save()
+        data = {
+            'username': 'jsmith_does_not_exist',
+            'password': 'test123',
+            }
+        form = AuthenticationForm(None, data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form.non_field_errors(),
+                         [u'Please enter a correct username and password. Note that both fields are case-sensitive.'])
 
-# The success case
+    def test_inactive_user(self):
+        # The user is inactive.
+        data = {
+            'username': 'inactive',
+            'password': 'password',
+            }
+        form = AuthenticationForm(None, data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form.non_field_errors(),
+                         [u'This account is inactive.'])
 
->>> form = AuthenticationForm(None, data)
->>> form.is_valid()
-True
->>> form.non_field_errors()
-[]
 
-### SetPasswordForm:
+    def test_success(self):
+        # The success case
+        data = {
+            'username': 'testclient',
+            'password': 'password',
+            }
+        form = AuthenticationForm(None, data)
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.non_field_errors(), [])
 
-# The two new passwords do not match.
 
->>> data = {
-...     'new_password1': 'abc123',
-...     'new_password2': 'abc',
-... }
->>> form = SetPasswordForm(user, data)
->>> form.is_valid()
-False
->>> form["new_password2"].errors
-[u"The two password fields didn't match."]
+class SetPasswordFormTest(TestCase):
 
-# The success case.
+    fixtures = ['authtestdata.json']
 
->>> data = {
-...     'new_password1': 'abc123',
-...     'new_password2': 'abc123',
-... }
->>> form = SetPasswordForm(user, data)
->>> form.is_valid()
-True
+    def test_password_verification(self):
+        # The two new passwords do not match.
+        user = User.objects.get(username='testclient')
+        data = {
+            'new_password1': 'abc123',
+            'new_password2': 'abc',
+            }
+        form = SetPasswordForm(user, data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form["new_password2"].errors,
+                         [u"The two password fields didn't match."])
 
-### PasswordChangeForm:
+    def test_success(self):
+        user = User.objects.get(username='testclient')
+        data = {
+            'new_password1': 'abc123',
+            'new_password2': 'abc123',
+            }
+        form = SetPasswordForm(user, data)
+        self.assertTrue(form.is_valid())
 
-The old password is incorrect.
 
->>> data = {
-...     'old_password': 'test',
-...     'new_password1': 'abc123',
-...     'new_password2': 'abc123',
-... }
->>> form = PasswordChangeForm(user, data)
->>> form.is_valid()
-False
->>> form["old_password"].errors
-[u'Your old password was entered incorrectly. Please enter it again.']
+class PasswordChangeFormTest(TestCase):
 
-# The two new passwords do not match.
+    fixtures = ['authtestdata.json']
 
->>> data = {
-...     'old_password': 'test123',
-...     'new_password1': 'abc123',
-...     'new_password2': 'abc',
-... }
->>> form = PasswordChangeForm(user, data)
->>> form.is_valid()
-False
->>> form["new_password2"].errors
-[u"The two password fields didn't match."]
+    def test_incorrect_password(self):
+        user = User.objects.get(username='testclient')
+        data = {
+            'old_password': 'test',
+            'new_password1': 'abc123',
+            'new_password2': 'abc123',
+            }
+        form = PasswordChangeForm(user, data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form["old_password"].errors,
+                         [u'Your old password was entered incorrectly. Please enter it again.'])
 
-# The success case.
 
->>> data = {
-...     'old_password': 'test123',
-...     'new_password1': 'abc123',
-...     'new_password2': 'abc123',
-... }
->>> form = PasswordChangeForm(user, data)
->>> form.is_valid()
-True
+    def test_password_verification(self):
+        # The two new passwords do not match.
+        user = User.objects.get(username='testclient')
+        data = {
+            'old_password': 'password',
+            'new_password1': 'abc123',
+            'new_password2': 'abc',
+            }
+        form = PasswordChangeForm(user, data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form["new_password2"].errors,
+                         [u"The two password fields didn't match."])
 
-# Regression test - check the order of fields:
 
->>> PasswordChangeForm(user, {}).fields.keys()
-['old_password', 'new_password1', 'new_password2']
+    def test_success(self):
+        # The success case.
+        user = User.objects.get(username='testclient')
+        data = {
+            'old_password': 'password',
+            'new_password1': 'abc123',
+            'new_password2': 'abc123',
+            }
+        form = PasswordChangeForm(user, data)
+        self.assertTrue(form.is_valid())
 
-### UserChangeForm
+    def test_field_order(self):
+        # Regression test - check the order of fields:
+        user = User.objects.get(username='testclient')
+        self.assertEqual(PasswordChangeForm(user, {}).fields.keys(),
+                         ['old_password', 'new_password1', 'new_password2'])
 
->>> from django.contrib.auth.forms import UserChangeForm
->>> data = {'username': 'not valid'}
->>> form = UserChangeForm(data, instance=user)
->>> form.is_valid()
-False
->>> form['username'].errors
-[u'This value may contain only letters, numbers and @/./+/-/_ characters.']
+class UserChangeFormTest(TestCase):
 
+    fixtures = ['authtestdata.json']
 
-### PasswordResetForm
+    def test_username_validity(self):
+        user = User.objects.get(username='testclient')
+        data = {'username': 'not valid'}
+        form = UserChangeForm(data, instance=user)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form['username'].errors,
+                         [u'This value may contain only letters, numbers and @/./+/-/_ characters.'])
 
->>> from django.contrib.auth.forms import PasswordResetForm
->>> data = {'email':'not valid'}
->>> form = PasswordResetForm(data)
->>> form.is_valid()
-False
->>> form['email'].errors
-[u'Enter a valid e-mail address.']
+class PasswordResetFormTest(TestCase):
 
-# Test nonexistant email address
->>> data = {'email':'foo@bar.com'}
->>> form = PasswordResetForm(data)
->>> form.is_valid()
-False
->>> form.errors
-{'email': [u"That e-mail address doesn't have an associated user account. Are you sure you've registered?"]}
+    fixtures = ['authtestdata.json']
 
-# Test cleaned_data bug fix
->>> user = User.objects.create_user("jsmith3", "jsmith3@example.com", "test123")
->>> data = {'email':'jsmith3@example.com'}
->>> form = PasswordResetForm(data)
->>> form.is_valid()
-True
->>> form.cleaned_data['email']
-u'jsmith3@example.com'
+    def test_invalid_email(self):
+        data = {'email':'not valid'}
+        form = PasswordResetForm(data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form['email'].errors,
+                         [u'Enter a valid e-mail address.'])
 
-# bug #5605, preserve the case of the user name (before the @ in the email address)
-# when creating a user.
->>> user = User.objects.create_user('forms_test2', 'tesT@EXAMple.com', 'test')
->>> user.email
-'tesT@example.com'
->>> user = User.objects.create_user('forms_test3', 'tesT', 'test')
->>> user.email
-'tesT'
+    def test_nonexistant_email(self):
+        # Test nonexistant email address
+        data = {'email':'foo@bar.com'}
+        form = PasswordResetForm(data)
+        self.assertFalse(form.is_valid())
+        self.assertEqual(form.errors,
+                         {'email': [u"That e-mail address doesn't have an associated user account. Are you sure you've registered?"]})
 
-"""
+    def test_cleaned_data(self):
+        # Regression test
+        user = User.objects.create_user("jsmith3", "jsmith3@example.com", "test123")
+        data = {'email':'jsmith3@example.com'}
+        form = PasswordResetForm(data)
+        self.assertTrue(form.is_valid())
+        self.assertEqual(form.cleaned_data['email'], u'jsmith3@example.com')
+
+
+    def test_bug_5605(self):
+        # bug #5605, preserve the case of the user name (before the @ in the
+        # email address) when creating a user.
+        user = User.objects.create_user('forms_test2', 'tesT@EXAMple.com', 'test')
+        self.assertEqual(user.email, 'tesT@example.com')
+        user = User.objects.create_user('forms_test3', 'tesT', 'test')
+        self.assertEqual(user.email, 'tesT')