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

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,

}

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.

>>> 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.']

# The username contains invalid data.

>>> 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.']

from django.contrib.auth.models import User

from django.contrib.auth.forms import UserCreationForm, AuthenticationForm,  PasswordChangeForm, SetPasswordForm, UserChangeForm, PasswordResetForm

from django.test import TestCase

class UserCreationFormTest(TestCase):

    fixtures = ['authtestdata.json']

    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.'])

    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.'])

    def test_password_verification(self):

        # 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."]

        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."])

    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)

        self.assertFalse(form.is_valid())

        self.assertEqual(form['password1'].errors,

                         [u'This field is required.'])

    def test_success(self):

        # The success case.

>>> 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.']

>>> data['password2'] = 'test123'

>>> form = UserCreationForm(data)

>>> form.is_valid()

False

>>> form['password1'].errors

[u'This field is required.']

        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>')

# The success case.

>>> data = {

...     'username': 'jsmith2@example.com',

...     'password1': 'test123',

...     'password2': 'test123',

... }

>>> form = UserCreationForm(data)

>>> form.is_valid()

True

>>> form.save()

<User: jsmith2@example.com>

class AuthenticationFormTest(TestCase):

# The user submits an invalid username.

    fixtures = ['authtestdata.json']

>>> data = {

...     'username': 'jsmith_does_not_exist',

...     'password': 'test123',

... }

    def test_invalid_username(self):

        # The user submits an invalid username.

>>> 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.']

        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.'])

    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.'])

>>> 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.']

>>> user.is_active = True

>>> user.save()

    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(), [])

>>> form = AuthenticationForm(None, data)

>>> form.is_valid()

True

>>> form.non_field_errors()

[]

### SetPasswordForm:

# 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.

>>> data = {

...     'new_password1': 'abc123',

...     'new_password2': 'abc123',

... }

>>> form = SetPasswordForm(user, data)

>>> form.is_valid()

True

### PasswordChangeForm:

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.']

    fixtures = ['authtestdata.json']

    def test_password_verification(self):

        # The two new passwords do not match.

>>> 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."]

        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."])

    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())

class PasswordChangeFormTest(TestCase):

    fixtures = ['authtestdata.json']

    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.'])

    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."])

    def test_success(self):

        # The success case.

>>> data = {

...     'old_password': 'test123',

...     'new_password1': 'abc123',

...     'new_password2': 'abc123',

... }

>>> form = PasswordChangeForm(user, data)

>>> form.is_valid()

True

        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())

    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'])

>>> PasswordChangeForm(user, {}).fields.keys()

['old_password', 'new_password1', 'new_password2']

class UserChangeFormTest(TestCase):

### UserChangeForm

    fixtures = ['authtestdata.json']

>>> 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.']

    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.'])

class PasswordResetFormTest(TestCase):

### PasswordResetForm

    fixtures = ['authtestdata.json']

>>> 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.']

    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.'])

    def test_nonexistant_email(self):

        # 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?"]}

# 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'

# 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'

"""

        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')