python/lib/django_1_4/django/contrib/auth/tests/forms.py

   1 from __future__ import with_statement
   2 import os
   3 from django.contrib.auth.models import User
   4 from django.contrib.auth.forms import (UserCreationForm, AuthenticationForm,
   5     PasswordChangeForm, SetPasswordForm, UserChangeForm, PasswordResetForm)
   6 from django.core import mail
   7 from django.forms.fields import Field, EmailField
   8 from django.test import TestCase
   9 from django.test.utils import override_settings
  10 from django.utils.encoding import force_unicode
  11 from django.utils import translation
  12 from django.utils.translation import ugettext as _
  13
  14
  15 class UserCreationFormTest(TestCase):
  16
  17     fixtures = ['authtestdata.json']
  18
  19     def test_user_already_exists(self):
  20         data = {
  21             'username': 'testclient',
  22             'password1': 'test123',
  23             'password2': 'test123',
  24             }
  25         form = UserCreationForm(data)
  26         self.assertFalse(form.is_valid())
  27         self.assertEqual(form["username"].errors,
  28                          [force_unicode(form.error_messages['duplicate_username'])])
  29
  30     def test_invalid_data(self):
  31         data = {
  32             'username': 'jsmith!',
  33             'password1': 'test123',
  34             'password2': 'test123',
  35             }
  36         form = UserCreationForm(data)
  37         self.assertFalse(form.is_valid())
  38         self.assertEqual(form["username"].errors,
  39                          [force_unicode(form.fields['username'].error_messages['invalid'])])
  40
  41     def test_password_verification(self):
  42         # The verification password is incorrect.
  43         data = {
  44             'username': 'jsmith',
  45             'password1': 'test123',
  46             'password2': 'test',
  47             }
  48         form = UserCreationForm(data)
  49         self.assertFalse(form.is_valid())
  50         self.assertEqual(form["password2"].errors,
  51                          [force_unicode(form.error_messages['password_mismatch'])])
  52
  53     def test_both_passwords(self):
  54         # One (or both) passwords weren't given
  55         data = {'username': 'jsmith'}
  56         form = UserCreationForm(data)
  57         required_error = [force_unicode(Field.default_error_messages['required'])]
  58         self.assertFalse(form.is_valid())
  59         self.assertEqual(form['password1'].errors, required_error)
  60         self.assertEqual(form['password2'].errors, required_error)
  61
  62         data['password2'] = 'test123'
  63         form = UserCreationForm(data)
  64         self.assertFalse(form.is_valid())
  65         self.assertEqual(form['password1'].errors, required_error)
  66
  67     def test_success(self):
  68         # The success case.
  69         data = {
  70             'username': 'jsmith@example.com',
  71             'password1': 'test123',
  72             'password2': 'test123',
  73             }
  74         form = UserCreationForm(data)
  75         self.assertTrue(form.is_valid())
  76         u = form.save()
  77         self.assertEqual(repr(u), '<User: jsmith@example.com>')
  78
  79 UserCreationFormTest = override_settings(USE_TZ=False)(UserCreationFormTest)
  80
  81
  82 class AuthenticationFormTest(TestCase):
  83
  84     fixtures = ['authtestdata.json']
  85
  86     def test_invalid_username(self):
  87         # The user submits an invalid username.
  88
  89         data = {
  90             'username': 'jsmith_does_not_exist',
  91             'password': 'test123',
  92             }
  93         form = AuthenticationForm(None, data)
  94         self.assertFalse(form.is_valid())
  95         self.assertEqual(form.non_field_errors(),
  96                          [force_unicode(form.error_messages['invalid_login'])])
  97
  98     def test_inactive_user(self):
  99         # The user is inactive.
 100         data = {
 101             'username': 'inactive',
 102             'password': 'password',
 103             }
 104         form = AuthenticationForm(None, data)
 105         self.assertFalse(form.is_valid())
 106         self.assertEqual(form.non_field_errors(),
 107                          [force_unicode(form.error_messages['inactive'])])
 108
 109     def test_inactive_user_i18n(self):
 110         with self.settings(USE_I18N=True):
 111             with translation.override('pt-br', deactivate=True):
 112                 # The user is inactive.
 113                 data = {
 114                     'username': 'inactive',
 115                     'password': 'password',
 116                     }
 117                 form = AuthenticationForm(None, data)
 118                 self.assertFalse(form.is_valid())
 119                 self.assertEqual(form.non_field_errors(),
 120                                  [force_unicode(form.error_messages['inactive'])])
 121
 122     def test_success(self):
 123         # The success case
 124         data = {
 125             'username': 'testclient',
 126             'password': 'password',
 127             }
 128         form = AuthenticationForm(None, data)
 129         self.assertTrue(form.is_valid())
 130         self.assertEqual(form.non_field_errors(), [])
 131
 132 AuthenticationFormTest = override_settings(USE_TZ=False)(AuthenticationFormTest)
 133
 134
 135 class SetPasswordFormTest(TestCase):
 136
 137     fixtures = ['authtestdata.json']
 138
 139     def test_password_verification(self):
 140         # The two new passwords do not match.
 141         user = User.objects.get(username='testclient')
 142         data = {
 143             'new_password1': 'abc123',
 144             'new_password2': 'abc',
 145             }
 146         form = SetPasswordForm(user, data)
 147         self.assertFalse(form.is_valid())
 148         self.assertEqual(form["new_password2"].errors,
 149                          [force_unicode(form.error_messages['password_mismatch'])])
 150
 151     def test_success(self):
 152         user = User.objects.get(username='testclient')
 153         data = {
 154             'new_password1': 'abc123',
 155             'new_password2': 'abc123',
 156             }
 157         form = SetPasswordForm(user, data)
 158         self.assertTrue(form.is_valid())
 159
 160 SetPasswordFormTest = override_settings(USE_TZ=False)(SetPasswordFormTest)
 161
 162
 163 class PasswordChangeFormTest(TestCase):
 164
 165     fixtures = ['authtestdata.json']
 166
 167     def test_incorrect_password(self):
 168         user = User.objects.get(username='testclient')
 169         data = {
 170             'old_password': 'test',
 171             'new_password1': 'abc123',
 172             'new_password2': 'abc123',
 173             }
 174         form = PasswordChangeForm(user, data)
 175         self.assertFalse(form.is_valid())
 176         self.assertEqual(form["old_password"].errors,
 177                          [force_unicode(form.error_messages['password_incorrect'])])
 178
 179     def test_password_verification(self):
 180         # The two new passwords do not match.
 181         user = User.objects.get(username='testclient')
 182         data = {
 183             'old_password': 'password',
 184             'new_password1': 'abc123',
 185             'new_password2': 'abc',
 186             }
 187         form = PasswordChangeForm(user, data)
 188         self.assertFalse(form.is_valid())
 189         self.assertEqual(form["new_password2"].errors,
 190                          [force_unicode(form.error_messages['password_mismatch'])])
 191
 192     def test_success(self):
 193         # The success case.
 194         user = User.objects.get(username='testclient')
 195         data = {
 196             'old_password': 'password',
 197             'new_password1': 'abc123',
 198             'new_password2': 'abc123',
 199             }
 200         form = PasswordChangeForm(user, data)
 201         self.assertTrue(form.is_valid())
 202
 203     def test_field_order(self):
 204         # Regression test - check the order of fields:
 205         user = User.objects.get(username='testclient')
 206         self.assertEqual(PasswordChangeForm(user, {}).fields.keys(),
 207                          ['old_password', 'new_password1', 'new_password2'])
 208
 209 PasswordChangeFormTest = override_settings(USE_TZ=False)(PasswordChangeFormTest)
 210
 211
 212 class UserChangeFormTest(TestCase):
 213
 214     fixtures = ['authtestdata.json']
 215
 216     def test_username_validity(self):
 217         user = User.objects.get(username='testclient')
 218         data = {'username': 'not valid'}
 219         form = UserChangeForm(data, instance=user)
 220         self.assertFalse(form.is_valid())
 221         self.assertEqual(form['username'].errors,
 222                          [force_unicode(form.fields['username'].error_messages['invalid'])])
 223
 224     def test_bug_14242(self):
 225         # A regression test, introduce by adding an optimization for the
 226         # UserChangeForm.
 227
 228         class MyUserForm(UserChangeForm):
 229             def __init__(self, *args, **kwargs):
 230                 super(MyUserForm, self).__init__(*args, **kwargs)
 231                 self.fields['groups'].help_text = 'These groups give users different permissions'
 232
 233             class Meta(UserChangeForm.Meta):
 234                 fields = ('groups',)
 235
 236         # Just check we can create it
 237         form = MyUserForm({})
 238
 239     def test_bug_17944_empty_password(self):
 240         user = User.objects.get(username='empty_password')
 241         form = UserChangeForm(instance=user)
 242         # Just check that no error is raised.
 243         form.as_table()
 244
 245     def test_bug_17944_unmanageable_password(self):
 246         user = User.objects.get(username='unmanageable_password')
 247         form = UserChangeForm(instance=user)
 248         # Just check that no error is raised.
 249         form.as_table()
 250
 251     def test_bug_17944_unknown_password_algorithm(self):
 252         user = User.objects.get(username='unknown_password')
 253         form = UserChangeForm(instance=user)
 254         # Just check that no error is raised.
 255         form.as_table()
 256
 257
 258 UserChangeFormTest = override_settings(USE_TZ=False)(UserChangeFormTest)
 259
 260
 261 class PasswordResetFormTest(TestCase):
 262
 263     fixtures = ['authtestdata.json']
 264
 265     def create_dummy_user(self):
 266         """creates a user and returns a tuple
 267         (user_object, username, email)
 268         """
 269         username = 'jsmith'
 270         email = 'jsmith@example.com'
 271         user = User.objects.create_user(username, email, 'test123')
 272         return (user, username, email)
 273
 274     def test_invalid_email(self):
 275         data = {'email': 'not valid'}
 276         form = PasswordResetForm(data)
 277         self.assertFalse(form.is_valid())
 278         self.assertEqual(form['email'].errors,
 279                          [force_unicode(EmailField.default_error_messages['invalid'])])
 280
 281     def test_nonexistant_email(self):
 282         # Test nonexistant email address
 283         data = {'email': 'foo@bar.com'}
 284         form = PasswordResetForm(data)
 285         self.assertFalse(form.is_valid())
 286         self.assertEqual(form.errors,
 287                          {'email': [force_unicode(form.error_messages['unknown'])]})
 288
 289     def test_cleaned_data(self):
 290         # Regression test
 291         (user, username, email) = self.create_dummy_user()
 292         data = {'email': email}
 293         form = PasswordResetForm(data)
 294         self.assertTrue(form.is_valid())
 295         self.assertEqual(form.cleaned_data['email'], email)
 296
 297     def test_custom_email_subject(self):
 298         template_path = os.path.join(os.path.dirname(__file__), 'templates')
 299         with self.settings(TEMPLATE_DIRS=(template_path,)):
 300             data = {'email': 'testclient@example.com'}
 301             form = PasswordResetForm(data)
 302             self.assertTrue(form.is_valid())
 303             # Since we're not providing a request object, we must provide a
 304             # domain_override to prevent the save operation from failing in the
 305             # potential case where contrib.sites is not installed. Refs #16412.
 306             form.save(domain_override='example.com')
 307             self.assertEqual(len(mail.outbox), 1)
 308             self.assertEqual(mail.outbox[0].subject, u'Custom password reset on example.com')
 309
 310     def test_bug_5605(self):
 311         # bug #5605, preserve the case of the user name (before the @ in the
 312         # email address) when creating a user.
 313         user = User.objects.create_user('forms_test2', 'tesT@EXAMple.com', 'test')
 314         self.assertEqual(user.email, 'tesT@example.com')
 315         user = User.objects.create_user('forms_test3', 'tesT', 'test')
 316         self.assertEqual(user.email, 'tesT')
 317
 318     def test_inactive_user(self):
 319         #tests that inactive user cannot
 320         #receive password reset email
 321         (user, username, email) = self.create_dummy_user()
 322         user.is_active = False
 323         user.save()
 324         form = PasswordResetForm({'email': email})
 325         self.assertFalse(form.is_valid())
 326
 327     def test_unusable_password(self):
 328         user = User.objects.create_user('testuser', 'test@example.com', 'test')
 329         data = {"email": "test@example.com"}
 330         form = PasswordResetForm(data)
 331         self.assertTrue(form.is_valid())
 332         user.set_unusable_password()
 333         user.save()
 334         form = PasswordResetForm(data)
 335         self.assertFalse(form.is_valid())
 336         self.assertEqual(form["email"].errors,
 337                          [_(u"The user account associated with this e-mail address cannot reset the password.")])
 338
 339 PasswordResetFormTest = override_settings(USE_TZ=False)(PasswordResetFormTest)