Commits

Anonymous committed c628494

Getting the tests to pass.

  • Participants
  • Parent commits 707ed72

Comments (0)

Files changed (14)

     public_description = models.CharField(max_length=100, default="no public description", blank=True, null=True, help_text="So people can identify your house.  Visible to the whole world")
     peeps = models.ManyToManyField(User, through='HouseAccess')
     geolat = models.FloatField( null = False )
-    geolong = models.FloatField( blank = False )
+    geolong = models.FloatField( null = False )
 
     def __str__(self):
         return self.name
             for numhouse in range(0,repeat*2):
                 # Create houses and connections
                 house = House()
+                # Just set the location to something.
+                house.geolat=-1
+                house.geolong=-1
+
                 house.save()
                 ha = HouseAccess(user = u, house = house, access_type='I') 
                 ha.save()

registration/broken-tests/__init__.py

+from django.test import TestCase
+
+import registration
+
+from registration.tests.backends import *
+from registration.tests.forms import *
+from registration.tests.models import *
+from registration.tests.views import *
+
+
+class RegistrationVersionInfoTests(TestCase):
+    """
+    Test django-registration's internal version-reporting
+    infrastructure.
+    
+    """
+    def setUp(self):
+        self.version = registration.VERSION
+
+    def tearDown(self):
+        registration.VERSION = self.version
+    
+    def test_get_version(self):
+        """
+        Test the version-info reporting.
+        
+        """
+        versions = [
+            {'version': (1, 0, 0, 'alpha', 0),
+             'expected': "1.0 pre-alpha"},
+            {'version': (1, 0, 1, 'alpha', 1),
+             'expected': "1.0.1 alpha 1"},
+            {'version': (1, 1, 0, 'beta', 2),
+             'expected': "1.1 beta 2"},
+            {'version': (1, 2, 1, 'rc', 3),
+             'expected': "1.2.1 rc 3"},
+            {'version': (1, 3, 0, 'final', 0),
+             'expected': "1.3"},
+            {'version': (1, 4, 1, 'beta', 0),
+             'expected': "1.4.1 beta"},
+            ]
+        
+        for version_dict in versions:
+            registration.VERSION = version_dict['version']
+            self.assertEqual(registration.get_version(), version_dict['expected'])

registration/broken-tests/backends.py

+import datetime
+
+from django.conf import settings
+from django.contrib import admin
+from django.contrib.auth.models import User
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.contrib.sites.models import Site
+from django.core import mail
+from django.core.exceptions import ImproperlyConfigured
+from django.core.handlers.wsgi import WSGIRequest
+from django.test import Client
+from django.test import TestCase
+
+from registration import forms
+from registration import signals
+from registration.admin import RegistrationAdmin
+from registration.backends import get_backend
+from registration.backends.default import DefaultBackend
+from registration.backends.simple import SimpleBackend
+from registration.models import RegistrationProfile
+
+
+class _MockRequestClient(Client):
+    """
+    A ``django.test.Client`` subclass which can return mock
+    ``HttpRequest`` objects.
+    
+    """
+    def request(self, **request):
+        """
+        Rather than issuing a request and returning the response, this
+        simply constructs an ``HttpRequest`` object and returns it.
+        
+        """
+        environ = {
+            'HTTP_COOKIE':      self.cookies,
+            'PATH_INFO':         '/',
+            'QUERY_STRING':      '',
+            'REMOTE_ADDR':       '127.0.0.1',
+            'REQUEST_METHOD':    'GET',
+            'SCRIPT_NAME':       '',
+            'SERVER_NAME':       'testserver',
+            'SERVER_PORT':       '80',
+            'SERVER_PROTOCOL':   'HTTP/1.1',
+            'wsgi.version':      (1,0),
+            'wsgi.url_scheme':   'http',
+            'wsgi.errors':       self.errors,
+            'wsgi.multiprocess': True,
+            'wsgi.multithread':  False,
+            'wsgi.run_once':     False,
+            }
+        environ.update(self.defaults)
+        environ.update(request)
+        request = WSGIRequest(environ)
+
+        # We have to manually add a session since we'll be bypassing
+        # the middleware chain.
+        session_middleware = SessionMiddleware()
+        session_middleware.process_request(request)
+        return request
+
+
+def _mock_request():
+    """
+    Construct and return a mock ``HttpRequest`` object; this is used
+    in testing backend methods which expect an ``HttpRequest`` but
+    which are not being called from views.
+    
+    """
+    return _MockRequestClient().request()
+
+
+class BackendRetrievalTests(TestCase):
+    """
+    Test that utilities for retrieving the active backend work
+    properly.
+
+    """
+    def test_get_backend(self):
+        """
+        Verify that ``get_backend()`` returns the correct value when
+        passed a valid backend.
+
+        """
+        self.failUnless(isinstance(get_backend('registration.backends.default.DefaultBackend'),
+                                   DefaultBackend))
+
+    def test_backend_error_invalid(self):
+        """
+        Test that a nonexistent/unimportable backend raises the
+        correct exception.
+
+        """
+        self.assertRaises(ImproperlyConfigured, get_backend,
+                          'registration.backends.doesnotexist.NonExistentBackend')
+
+    def test_backend_attribute_error(self):
+        """
+        Test that a backend module which exists but does not have a
+        class of the specified name raises the correct exception.
+        
+        """
+        self.assertRaises(ImproperlyConfigured, get_backend,
+                          'registration.backends.default.NonexistentBackend')
+
+
+class DefaultRegistrationBackendTests(TestCase):
+    """
+    Test the default registration backend.
+
+    Running these tests successfull will require two templates to be
+    created for the sending of activation emails; details on these
+    templates and their contexts may be found in the documentation for
+    the default backend.
+
+    """
+    backend = DefaultBackend()
+    
+    def setUp(self):
+        """
+        Create an instance of the default backend for use in testing,
+        and set ``ACCOUNT_ACTIVATION_DAYS`` if it's not set already.
+
+        """
+        self.old_activation = getattr(settings, 'ACCOUNT_ACTIVATION_DAYS', None)
+        if self.old_activation is None:
+            settings.ACCOUNT_ACTIVATION_DAYS = 7
+
+    def tearDown(self):
+        """
+        Yank out ``ACCOUNT_ACTIVATION_DAYS`` back out if it wasn't
+        originally set.
+
+        """
+        if self.old_activation is None:
+            settings.ACCOUNT_ACTIVATION_DAYS = self.old_activation
+
+    def test_registration(self):
+        """
+        Test the registration process: registration creates a new
+        inactive account and a new profile with activation key,
+        populates the correct account data and sends an activation
+        email.
+
+        """
+        new_user = self.backend.register(_mock_request(),
+                                         username='bob',
+                                         email='bob@example.com',
+                                         password1='secret')
+
+        # Details of the returned user must match what went in.
+        self.assertEqual(new_user.username, 'bob')
+        self.failUnless(new_user.check_password('secret'))
+        self.assertEqual(new_user.email, 'bob@example.com')
+
+        # New user must not be active.
+        self.failIf(new_user.is_active)
+
+        # A registration profile was created, and an activation email
+        # was sent.
+        self.assertEqual(RegistrationProfile.objects.count(), 1)
+        self.assertEqual(len(mail.outbox), 1)
+
+    def test_registration_no_sites(self):
+        """
+        Test that registration still functions properly when
+        ``django.contrib.sites`` is not installed; the fallback will
+        be a ``RequestSite`` instance.
+        
+        """
+        Site._meta.installed = False
+
+        new_user = self.backend.register(_mock_request(),
+                                         username='bob',
+                                         email='bob@example.com',
+                                         password1='secret')
+
+        self.assertEqual(new_user.username, 'bob')
+        self.failUnless(new_user.check_password('secret'))
+        self.assertEqual(new_user.email, 'bob@example.com')
+
+        self.failIf(new_user.is_active)
+
+        self.assertEqual(RegistrationProfile.objects.count(), 1)
+        self.assertEqual(len(mail.outbox), 1)
+        
+        Site._meta.installed = True
+
+    def test_valid_activation(self):
+        """
+        Test the activation process: activating within the permitted
+        window sets the account's ``is_active`` field to ``True`` and
+        resets the activation key.
+
+        """
+        valid_user = self.backend.register(_mock_request(),
+                                           username='alice',
+                                           email='alice@example.com',
+                                           password1='swordfish')
+
+        valid_profile = RegistrationProfile.objects.get(user=valid_user)
+        activated = self.backend.activate(_mock_request(),
+                                          valid_profile.activation_key)
+        self.assertEqual(activated.username, valid_user.username)
+        self.failUnless(activated.is_active)
+
+        # Fetch the profile again to verify its activation key has
+        # been reset.
+        valid_profile = RegistrationProfile.objects.get(user=valid_user)
+        self.assertEqual(valid_profile.activation_key,
+                         RegistrationProfile.ACTIVATED)
+
+    def test_invalid_activation(self):
+        """
+        Test the activation process: trying to activate outside the
+        permitted window fails, and leaves the account inactive.
+
+        """
+        expired_user = self.backend.register(_mock_request(),
+                                             username='bob',
+                                             email='bob@example.com',
+                                             password1='secret')
+
+        expired_user.date_joined = expired_user.date_joined - datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)
+        expired_user.save()
+        expired_profile = RegistrationProfile.objects.get(user=expired_user)
+        self.failIf(self.backend.activate(_mock_request(),
+                                          expired_profile.activation_key))
+        self.failUnless(expired_profile.activation_key_expired())
+
+    def test_allow(self):
+        """
+        Test that the setting ``REGISTRATION_OPEN`` appropriately
+        controls whether registration is permitted.
+
+        """
+        old_allowed = getattr(settings, 'REGISTRATION_OPEN', True)
+        settings.REGISTRATION_OPEN = True
+        self.failUnless(self.backend.registration_allowed(_mock_request()))
+
+        settings.REGISTRATION_OPEN = False
+        self.failIf(self.backend.registration_allowed(_mock_request()))
+        settings.REGISTRATION_OPEN = old_allowed
+
+    def test_form_class(self):
+        """
+        Test that the default form class returned is
+        ``registration.forms.RegistrationForm``.
+
+        """
+        self.failUnless(self.backend.get_form_class(_mock_request()) is forms.RegistrationForm)
+
+    def test_post_registration_redirect(self):
+        """
+        Test that the default post-registration redirect is the named
+        pattern ``registration_complete``.
+
+        """
+        self.assertEqual(self.backend.post_registration_redirect(_mock_request(), User()),
+                         ('registration_complete', (), {}))
+
+    def test_registration_signal(self):
+        """
+        Test that registering a user sends the ``user_registered``
+        signal.
+        
+        """
+        def receiver(sender, **kwargs):
+            self.failUnless('user' in kwargs)
+            self.assertEqual(kwargs['user'].username, 'bob')
+            self.failUnless('request' in kwargs)
+            self.failUnless(isinstance(kwargs['request'], WSGIRequest))
+            received_signals.append(kwargs.get('signal'))
+
+        received_signals = []
+        signals.user_registered.connect(receiver, sender=self.backend.__class__)
+
+        self.backend.register(_mock_request(),
+                              username='bob',
+                              email='bob@example.com',
+                              password1='secret')
+
+        self.assertEqual(len(received_signals), 1)
+        self.assertEqual(received_signals, [signals.user_registered])
+
+    def test_activation_signal_success(self):
+        """
+        Test that successfully activating a user sends the
+        ``user_activated`` signal.
+        
+        """
+        def receiver(sender, **kwargs):
+            self.failUnless('user' in kwargs)
+            self.assertEqual(kwargs['user'].username, 'bob')
+            self.failUnless('request' in kwargs)
+            self.failUnless(isinstance(kwargs['request'], WSGIRequest))
+            received_signals.append(kwargs.get('signal'))
+
+        received_signals = []
+        signals.user_activated.connect(receiver, sender=self.backend.__class__)
+
+        new_user = self.backend.register(_mock_request(),
+                                         username='bob',
+                                         email='bob@example.com',
+                                         password1='secret')
+        profile = RegistrationProfile.objects.get(user=new_user)
+        self.backend.activate(_mock_request(), profile.activation_key)
+
+        self.assertEqual(len(received_signals), 1)
+        self.assertEqual(received_signals, [signals.user_activated])
+
+    def test_activation_signal_failure(self):
+        """
+        Test that an unsuccessful activation attempt does not send the
+        ``user_activated`` signal.
+        
+        """
+        receiver = lambda sender, **kwargs: received_signals.append(kwargs.get('signal'))
+
+        received_signals = []
+        signals.user_activated.connect(receiver, sender=self.backend.__class__)
+
+        new_user = self.backend.register(_mock_request(),
+                                         username='bob',
+                                         email='bob@example.com',
+                                         password1='secret')
+        new_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)
+        new_user.save()
+        profile = RegistrationProfile.objects.get(user=new_user)
+        self.backend.activate(_mock_request(), profile.activation_key)
+
+        self.assertEqual(len(received_signals), 0)
+
+    def test_email_send_action(self):
+        """
+        Test re-sending of activation emails via admin action.
+        
+        """
+        admin_class = RegistrationAdmin(RegistrationProfile, admin.site)
+        
+        alice = self.backend.register(_mock_request(),
+                                      username='alice',
+                                      email='alice@example.com',
+                                      password1='swordfish')
+        
+        admin_class.resend_activation_email(_mock_request(),
+                                            RegistrationProfile.objects.all())
+        self.assertEqual(len(mail.outbox), 2) # One on registering, one more on the resend.
+        
+        RegistrationProfile.objects.filter(user=alice).update(activation_key=RegistrationProfile.ACTIVATED)
+        admin_class.resend_activation_email(_mock_request(),
+                                            RegistrationProfile.objects.all())
+        self.assertEqual(len(mail.outbox), 2) # No additional email because the account has activated.
+
+    def test_activation_action(self):
+        """
+        Test manual activation of users view admin action.
+        
+        """
+        admin_class = RegistrationAdmin(RegistrationProfile, admin.site)
+
+        alice = self.backend.register(_mock_request(),
+                                      username='alice',
+                                      email='alice@example.com',
+                                      password1='swordfish')
+
+        admin_class.activate_users(_mock_request(),
+                                   RegistrationProfile.objects.all())
+        self.failUnless(User.objects.get(username='alice').is_active)
+
+
+class SimpleRegistrationBackendTests(TestCase):
+    """
+    Test the simple registration backend, which does signup and
+    immediate activation.
+    
+    """
+    backend = SimpleBackend()
+    
+    def test_registration(self):
+        """
+        Test the registration process: registration creates a new
+        inactive account and a new profile with activation key,
+        populates the correct account data and sends an activation
+        email.
+
+        """
+        new_user = self.backend.register(_mock_request(),
+                                         username='bob',
+                                         email='bob@example.com',
+                                         password1='secret')
+
+        # Details of the returned user must match what went in.
+        self.assertEqual(new_user.username, 'bob')
+        self.failUnless(new_user.check_password('secret'))
+        self.assertEqual(new_user.email, 'bob@example.com')
+
+        # New user must not be active.
+        self.failUnless(new_user.is_active)
+
+    def test_allow(self):
+        """
+        Test that the setting ``REGISTRATION_OPEN`` appropriately
+        controls whether registration is permitted.
+
+        """
+        old_allowed = getattr(settings, 'REGISTRATION_OPEN', True)
+        settings.REGISTRATION_OPEN = True
+        self.failUnless(self.backend.registration_allowed(_mock_request()))
+
+        settings.REGISTRATION_OPEN = False
+        self.failIf(self.backend.registration_allowed(_mock_request()))
+        settings.REGISTRATION_OPEN = old_allowed
+
+    def test_form_class(self):
+        """
+        Test that the default form class returned is
+        ``registration.forms.RegistrationForm``.
+
+        """
+        self.failUnless(self.backend.get_form_class(_mock_request()) is forms.RegistrationForm)
+
+    def test_post_registration_redirect(self):
+        """
+        Test that the default post-registration redirect is the public
+        URL of the new user account.
+
+        """
+        new_user = self.backend.register(_mock_request(),
+                                         username='bob',
+                                         email='bob@example.com',
+                                         password1='secret')
+        
+        self.assertEqual(self.backend.post_registration_redirect(_mock_request(), new_user),
+                         (new_user.get_absolute_url(), (), {}))
+
+    def test_registration_signal(self):
+        """
+        Test that registering a user sends the ``user_registered``
+        signal.
+        
+        """
+        def receiver(sender, **kwargs):
+            self.failUnless('user' in kwargs)
+            self.assertEqual(kwargs['user'].username, 'bob')
+            self.failUnless('request' in kwargs)
+            self.failUnless(isinstance(kwargs['request'], WSGIRequest))
+            received_signals.append(kwargs.get('signal'))
+
+        received_signals = []
+        signals.user_registered.connect(receiver, sender=self.backend.__class__)
+
+        self.backend.register(_mock_request(),
+                              username='bob',
+                              email='bob@example.com',
+                              password1='secret')
+
+        self.assertEqual(len(received_signals), 1)
+        self.assertEqual(received_signals, [signals.user_registered])
+
+    def test_activation(self):
+        """
+        Test that activating against this backend is an error.
+        
+        """
+        self.assertRaises(NotImplementedError, self.backend.activate,
+                          request=_mock_request())
+
+    def test_post_activation_redirect(self):
+        """
+        Test that asking for a post-activation redirect from this
+        backend is an error.
+        
+        """
+        self.assertRaises(NotImplementedError, self.backend.post_activation_redirect,
+                          request=_mock_request(), user=User())

registration/broken-tests/forms.py

+from django.contrib.auth.models import User
+from django.test import TestCase
+
+from registration import forms
+
+
+class RegistrationFormTests(TestCase):
+    """
+    Test the default registration forms.
+
+    """
+    def test_registration_form(self):
+        """
+        Test that ``RegistrationForm`` enforces username constraints
+        and matching passwords.
+
+        """
+        # Create a user so we can verify that duplicate usernames aren't
+        # permitted.
+        User.objects.create_user('alice', 'alice@example.com', 'secret')
+
+        invalid_data_dicts = [
+            # Non-alphanumeric username.
+            {'data': {'username': 'foo/bar',
+                      'email': 'foo@example.com',
+                      'password1': 'foo',
+                      'password2': 'foo'},
+            'error': ('username', [u"This value must contain only letters, numbers and underscores."])},
+            # Already-existing username.
+            {'data': {'username': 'alice',
+                      'email': 'alice@example.com',
+                      'password1': 'secret',
+                      'password2': 'secret'},
+            'error': ('username', [u"A user with that username already exists."])},
+            # Mismatched passwords.
+            {'data': {'username': 'foo',
+                      'email': 'foo@example.com',
+                      'password1': 'foo',
+                      'password2': 'bar'},
+            'error': ('__all__', [u"The two password fields didn't match."])},
+            ]
+
+        for invalid_dict in invalid_data_dicts:
+            form = forms.RegistrationForm(data=invalid_dict['data'])
+            self.failIf(form.is_valid())
+            self.assertEqual(form.errors[invalid_dict['error'][0]],
+                             invalid_dict['error'][1])
+
+        form = forms.RegistrationForm(data={'username': 'foo',
+                                            'email': 'foo@example.com',
+                                            'password1': 'foo',
+                                            'password2': 'foo'})
+        self.failUnless(form.is_valid())
+
+    def test_registration_form_tos(self):
+        """
+        Test that ``RegistrationFormTermsOfService`` requires
+        agreement to the terms of service.
+
+        """
+        form = forms.RegistrationFormTermsOfService(data={'username': 'foo',
+                                                          'email': 'foo@example.com',
+                                                          'password1': 'foo',
+                                                          'password2': 'foo'})
+        self.failIf(form.is_valid())
+        self.assertEqual(form.errors['tos'],
+                         [u"You must agree to the terms to register"])
+
+        form = forms.RegistrationFormTermsOfService(data={'username': 'foo',
+                                                          'email': 'foo@example.com',
+                                                          'password1': 'foo',
+                                                          'password2': 'foo',
+                                                          'tos': 'on'})
+        self.failUnless(form.is_valid())
+
+    def test_registration_form_unique_email(self):
+        """
+        Test that ``RegistrationFormUniqueEmail`` validates uniqueness
+        of email addresses.
+
+        """
+        # Create a user so we can verify that duplicate addresses
+        # aren't permitted.
+        User.objects.create_user('alice', 'alice@example.com', 'secret')
+
+        form = forms.RegistrationFormUniqueEmail(data={'username': 'foo',
+                                                       'email': 'alice@example.com',
+                                                       'password1': 'foo',
+                                                       'password2': 'foo'})
+        self.failIf(form.is_valid())
+        self.assertEqual(form.errors['email'],
+                         [u"This email address is already in use. Please supply a different email address."])
+
+        form = forms.RegistrationFormUniqueEmail(data={'username': 'foo',
+                                                       'email': 'foo@example.com',
+                                                       'password1': 'foo',
+                                                       'password2': 'foo'})
+        self.failUnless(form.is_valid())
+
+    def test_registration_form_no_free_email(self):
+        """
+        Test that ``RegistrationFormNoFreeEmail`` disallows
+        registration with free email addresses.
+
+        """
+        base_data = {'username': 'foo',
+                     'password1': 'foo',
+                     'password2': 'foo'}
+        for domain in forms.RegistrationFormNoFreeEmail.bad_domains:
+            invalid_data = base_data.copy()
+            invalid_data['email'] = u"foo@%s" % domain
+            form = forms.RegistrationFormNoFreeEmail(data=invalid_data)
+            self.failIf(form.is_valid())
+            self.assertEqual(form.errors['email'],
+                             [u"Registration using free email addresses is prohibited. Please supply a different email address."])
+
+        base_data['email'] = 'foo@example.com'
+        form = forms.RegistrationFormNoFreeEmail(data=base_data)
+        self.failUnless(form.is_valid())

registration/broken-tests/models.py

+import datetime
+import re
+
+from django.conf import settings
+from django.contrib.auth.models import User
+from django.contrib.sites.models import Site
+from django.core import mail
+from django.core import management
+from django.test import TestCase
+from django.utils.hashcompat import sha_constructor
+
+from registration.models import RegistrationProfile
+
+
+class RegistrationModelTests(TestCase):
+    """
+    Test the model and manager used in the default backend.
+    
+    """
+    user_info = {'username': 'alice',
+                 'password': 'swordfish',
+                 'email': 'alice@example.com'}
+    
+    def setUp(self):
+        self.old_activation = getattr(settings, 'ACCOUNT_ACTIVATION_DAYS', None)
+        settings.ACCOUNT_ACTIVATION_DAYS = 7
+
+    def tearDown(self):
+        settings.ACCOUNT_ACTIVATION_DAYS = self.old_activation
+
+    def test_profile_creation(self):
+        """
+        Creating a registration profile for a user populates the
+        profile with the correct user and a SHA1 hash to use as
+        activation key.
+        
+        """
+        new_user = User.objects.create_user(**self.user_info)
+        profile = RegistrationProfile.objects.create_profile(new_user)
+
+        self.assertEqual(RegistrationProfile.objects.count(), 1)
+        self.assertEqual(profile.user.id, new_user.id)
+        self.failUnless(re.match('^[a-f0-9]{40}$', profile.activation_key))
+        self.assertEqual(unicode(profile),
+                         "Registration information for alice")
+
+    def test_activation_email(self):
+        """
+        ``RegistrationProfile.send_activation_email`` sends an
+        email.
+        
+        """
+        new_user = User.objects.create_user(**self.user_info)
+        profile = RegistrationProfile.objects.create_profile(new_user)
+        profile.send_activation_email(Site.objects.get_current())
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertEqual(mail.outbox[0].to, [self.user_info['email']])
+
+    def test_user_creation(self):
+        """
+        Creating a new user populates the correct data, and sets the
+        user's account inactive.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        self.assertEqual(new_user.username, 'alice')
+        self.assertEqual(new_user.email, 'alice@example.com')
+        self.failUnless(new_user.check_password('swordfish'))
+        self.failIf(new_user.is_active)
+
+    def test_user_creation_email(self):
+        """
+        By default, creating a new user sends an activation email.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        self.assertEqual(len(mail.outbox), 1)
+
+    def test_user_creation_no_email(self):
+        """
+        Passing ``send_email=False`` when creating a new user will not
+        send an activation email.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    send_email=False,
+                                                                    **self.user_info)
+        self.assertEqual(len(mail.outbox), 0)
+
+    def test_unexpired_account(self):
+        """
+        ``RegistrationProfile.activation_key_expired()`` is ``False``
+        within the activation window.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        profile = RegistrationProfile.objects.get(user=new_user)
+        self.failIf(profile.activation_key_expired())
+
+    def test_expired_account(self):
+        """
+        ``RegistrationProfile.activation_key_expired()`` is ``True``
+        outside the activation window.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        new_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)
+        new_user.save()
+        profile = RegistrationProfile.objects.get(user=new_user)
+        self.failUnless(profile.activation_key_expired())
+
+    def test_valid_activation(self):
+        """
+        Activating a user within the permitted window makes the
+        account active, and resets the activation key.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        profile = RegistrationProfile.objects.get(user=new_user)
+        activated = RegistrationProfile.objects.activate_user(profile.activation_key)
+
+        self.failUnless(isinstance(activated, User))
+        self.assertEqual(activated.id, new_user.id)
+        self.failUnless(activated.is_active)
+
+        profile = RegistrationProfile.objects.get(user=new_user)
+        self.assertEqual(profile.activation_key, RegistrationProfile.ACTIVATED)
+
+    def test_expired_activation(self):
+        """
+        Attempting to activate outside the permitted window does not
+        activate the account.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        new_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)
+        new_user.save()
+
+        profile = RegistrationProfile.objects.get(user=new_user)
+        activated = RegistrationProfile.objects.activate_user(profile.activation_key)
+
+        self.failIf(isinstance(activated, User))
+        self.failIf(activated)
+
+        new_user = User.objects.get(username='alice')
+        self.failIf(new_user.is_active)
+
+        profile = RegistrationProfile.objects.get(user=new_user)
+        self.assertNotEqual(profile.activation_key, RegistrationProfile.ACTIVATED)
+
+    def test_activation_invalid_key(self):
+        """
+        Attempting to activate with a key which is not a SHA1 hash
+        fails.
+        
+        """
+        self.failIf(RegistrationProfile.objects.activate_user('foo'))
+
+    def test_activation_already_activated(self):
+        """
+        Attempting to re-activate an already-activated account fails.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        profile = RegistrationProfile.objects.get(user=new_user)
+        RegistrationProfile.objects.activate_user(profile.activation_key)
+
+        profile = RegistrationProfile.objects.get(user=new_user)
+        self.failIf(RegistrationProfile.objects.activate_user(profile.activation_key))
+
+    def test_activation_nonexistent_key(self):
+        """
+        Attempting to activate with a non-existent key (i.e., one not
+        associated with any account) fails.
+        
+        """
+        # Due to the way activation keys are constructed during
+        # registration, this will never be a valid key.
+        invalid_key = sha_constructor('foo').hexdigest()
+        self.failIf(RegistrationProfile.objects.activate_user(invalid_key))
+
+    def test_expired_user_deletion(self):
+        """
+        ``RegistrationProfile.objects.delete_expired_users()`` only
+        deletes inactive users whose activation window has expired.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        expired_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                        username='bob',
+                                                                        password='secret',
+                                                                        email='bob@example.com')
+        expired_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)
+        expired_user.save()
+
+        RegistrationProfile.objects.delete_expired_users()
+        self.assertEqual(RegistrationProfile.objects.count(), 1)
+        self.assertRaises(User.DoesNotExist, User.objects.get, username='bob')
+
+    def test_management_command(self):
+        """
+        The ``cleanupregistration`` management command properly
+        deletes expired accounts.
+        
+        """
+        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                    **self.user_info)
+        expired_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
+                                                                        username='bob',
+                                                                        password='secret',
+                                                                        email='bob@example.com')
+        expired_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)
+        expired_user.save()
+
+        management.call_command('cleanupregistration')
+        self.assertEqual(RegistrationProfile.objects.count(), 1)
+        self.assertRaises(User.DoesNotExist, User.objects.get, username='bob')

registration/broken-tests/urls.py

+"""
+URLs used in the unit tests for django-registration.
+
+You should not attempt to use these URLs in any sort of real or
+development environment; instead, use
+``registration/backends/default/urls.py``. This URLconf includes those
+URLs, and also adds several additional URLs which serve no purpose
+other than to test that optional keyword arguments are properly
+handled.
+
+"""
+
+from django.conf.urls.defaults import *
+from django.views.generic.simple import direct_to_template
+
+from registration.views import activate
+from registration.views import register
+
+
+urlpatterns = patterns('',
+                       # Test the 'activate' view with custom template
+                       # name.
+                       url(r'^activate-with-template-name/(?P<activation_key>\w+)/$',
+                           activate,
+                           {'template_name': 'registration/test_template_name.html',
+                            'backend': 'registration.backends.default.DefaultBackend'},
+                           name='registration_test_activate_template_name'),
+                       # Test the 'activate' view with
+                       # extra_context_argument.
+                       url(r'^activate-extra-context/(?P<activation_key>\w+)/$',
+                           activate,
+                           {'extra_context': {'foo': 'bar', 'callable': lambda: 'called'},
+                            'backend': 'registration.backends.default.DefaultBackend'},
+                           name='registration_test_activate_extra_context'),
+                       # Test the 'activate' view with success_url argument.
+                       url(r'^activate-with-success-url/(?P<activation_key>\w+)/$',
+                           activate,
+                           {'success_url': 'registration_test_custom_success_url',
+                            'backend': 'registration.backends.default.DefaultBackend'},
+                           name='registration_test_activate_success_url'),
+                       # Test the 'register' view with custom template
+                       # name.
+                       url(r'^register-with-template-name/$',
+                           register,
+                           {'template_name': 'registration/test_template_name.html',
+                            'backend': 'registration.backends.default.DefaultBackend'},
+                           name='registration_test_register_template_name'),
+                       # Test the'register' view with extra_context
+                       # argument.
+                       url(r'^register-extra-context/$',
+                           register,
+                           {'extra_context': {'foo': 'bar', 'callable': lambda: 'called'},
+                            'backend': 'registration.backends.default.DefaultBackend'},
+                           name='registration_test_register_extra_context'),
+                       # Test the 'register' view with custom URL for
+                       # closed registration.
+                       url(r'^register-with-disallowed-url/$',
+                           register,
+                           {'disallowed_url': 'registration_test_custom_disallowed',
+                            'backend': 'registration.backends.default.DefaultBackend'},
+                           name='registration_test_register_disallowed_url'),
+                       # Set up a pattern which will correspond to the
+                       # custom 'disallowed_url' above.
+                       url(r'^custom-disallowed/$',
+                           direct_to_template,
+                           {'template': 'registration/registration_closed.html'},
+                           name='registration_test_custom_disallowed'),
+                       # Test the 'register' view with custom redirect
+                       # on successful registration.
+                       url(r'^register-with-success_url/$',
+                           register,
+                           {'success_url': 'registration_test_custom_success_url',
+                            'backend': 'registration.backends.default.DefaultBackend'},
+                           name='registration_test_register_success_url'
+                           ),
+                       # Pattern for custom redirect set above.
+                       url(r'^custom-success/$',
+                           direct_to_template,
+                           {'template': 'registration/test_template_name.html'},
+                           name='registration_test_custom_success_url'),
+                       (r'', include('registration.backends.default.urls')),
+                       )

registration/broken-tests/views.py

+import datetime
+
+from django.conf import settings
+from django.contrib.auth.models import User
+from django.core import mail
+from django.core.urlresolvers import reverse
+from django.test import TestCase
+
+from registration import forms
+from registration.models import RegistrationProfile
+
+
+class RegistrationViewTests(TestCase):
+    """
+    Test the registration views.
+
+    """
+    urls = 'registration.tests.urls'
+
+    def setUp(self):
+        """
+        These tests use the default backend, since we know it's
+        available; that needs to have ``ACCOUNT_ACTIVATION_DAYS`` set.
+
+        """
+        self.old_activation = getattr(settings, 'ACCOUNT_ACTIVATION_DAYS', None)
+        if self.old_activation is None:
+            settings.ACCOUNT_ACTIVATION_DAYS = 7
+
+    def tearDown(self):
+        """
+        Yank ``ACCOUNT_ACTIVATION_DAYS`` back out if it wasn't
+        originally set.
+
+        """
+        if self.old_activation is None:
+            settings.ACCOUNT_ACTIVATION_DAYS = self.old_activation
+
+    def test_registration_view_initial(self):
+        """
+        A ``GET`` to the ``register`` view uses the appropriate
+        template and populates the registration form into the context.
+
+        """
+        response = self.client.get(reverse('registration_register'))
+        self.assertEqual(response.status_code, 200)
+        self.assertTemplateUsed(response,
+                                'registration/registration_form.html')
+        self.failUnless(isinstance(response.context['form'],
+                                   forms.RegistrationForm))
+
+    def test_registration_view_success(self):
+        """
+        A ``POST`` to the ``register`` view with valid data properly
+        creates a new user and issues a redirect.
+
+        """
+        response = self.client.post(reverse('registration_register'),
+                                    data={'username': 'alice',
+                                          'email': 'alice@example.com',
+                                          'password1': 'swordfish',
+                                          'password2': 'swordfish'})
+        self.assertRedirects(response,
+                             'http://testserver%s' % reverse('registration_complete'))
+        self.assertEqual(RegistrationProfile.objects.count(), 1)
+        self.assertEqual(len(mail.outbox), 1)
+
+    def test_registration_view_failure(self):
+        """
+        A ``POST`` to the ``register`` view with invalid data does not
+        create a user, and displays appropriate error messages.
+
+        """
+        response = self.client.post(reverse('registration_register'),
+                                    data={'username': 'bob',
+                                          'email': 'bobe@example.com',
+                                          'password1': 'foo',
+                                          'password2': 'bar'})
+        self.assertEqual(response.status_code, 200)
+        self.failIf(response.context['form'].is_valid())
+        self.assertFormError(response, 'form', field=None,
+                             errors=u"The two password fields didn't match.")
+        self.assertEqual(len(mail.outbox), 0)
+
+    def test_registration_view_closed(self):
+        """
+        Any attempt to access the ``register`` view when registration
+        is closed fails and redirects.
+
+        """
+        old_allowed = getattr(settings, 'REGISTRATION_OPEN', True)
+        settings.REGISTRATION_OPEN = False
+
+        closed_redirect = 'http://testserver%s' % reverse('registration_disallowed')
+
+        response = self.client.get(reverse('registration_register'))
+        self.assertRedirects(response, closed_redirect)
+
+        # Even if valid data is posted, it still shouldn't work.
+        response = self.client.post(reverse('registration_register'),
+                                    data={'username': 'alice',
+                                          'email': 'alice@example.com',
+                                          'password1': 'swordfish',
+                                          'password2': 'swordfish'})
+        self.assertRedirects(response, closed_redirect)
+        self.assertEqual(RegistrationProfile.objects.count(), 0)
+
+        settings.REGISTRATION_OPEN = old_allowed
+
+    def test_registration_template_name(self):
+        """
+        Passing ``template_name`` to the ``register`` view will result
+        in that template being used.
+
+        """
+        response = self.client.get(reverse('registration_test_register_template_name'))
+        self.assertTemplateUsed(response,
+                                'registration/test_template_name.html')
+
+    def test_registration_extra_context(self):
+        """
+        Passing ``extra_context`` to the ``register`` view will
+        correctly populate the context.
+
+        """
+        response = self.client.get(reverse('registration_test_register_extra_context'))
+        self.assertEqual(response.context['foo'], 'bar')
+        # Callables in extra_context are called to obtain the value.
+        self.assertEqual(response.context['callable'], 'called')
+
+    def test_registration_disallowed_url(self):
+        """
+        Passing ``disallowed_url`` to the ``register`` view will
+        result in a redirect to that URL when registration is closed.
+
+        """
+        old_allowed = getattr(settings, 'REGISTRATION_OPEN', True)
+        settings.REGISTRATION_OPEN = False
+
+        closed_redirect = 'http://testserver%s' % reverse('registration_test_custom_disallowed')
+
+        response = self.client.get(reverse('registration_test_register_disallowed_url'))
+        self.assertRedirects(response, closed_redirect)
+
+        settings.REGISTRATION_OPEN = old_allowed
+
+    def test_registration_success_url(self):
+        """
+        Passing ``success_url`` to the ``register`` view will result
+        in a redirect to that URL when registration is successful.
+        
+        """
+        success_redirect = 'http://testserver%s' % reverse('registration_test_custom_success_url')
+        response = self.client.post(reverse('registration_test_register_success_url'),
+                                    data={'username': 'alice',
+                                          'email': 'alice@example.com',
+                                          'password1': 'swordfish',
+                                          'password2': 'swordfish'})
+        self.assertRedirects(response, success_redirect)
+
+    def test_valid_activation(self):
+        """
+        Test that the ``activate`` view properly handles a valid
+        activation (in this case, based on the default backend's
+        activation window).
+
+        """
+        success_redirect = 'http://testserver%s' % reverse('registration_activation_complete')
+        
+        # First, register an account.
+        self.client.post(reverse('registration_register'),
+                         data={'username': 'alice',
+                               'email': 'alice@example.com',
+                               'password1': 'swordfish',
+                               'password2': 'swordfish'})
+        profile = RegistrationProfile.objects.get(user__username='alice')
+        response = self.client.get(reverse('registration_activate',
+                                           kwargs={'activation_key': profile.activation_key}))
+        self.assertRedirects(response, success_redirect)
+        self.failUnless(User.objects.get(username='alice').is_active)
+
+    def test_invalid_activation(self):
+        """
+        Test that the ``activate`` view properly handles an invalid
+        activation (in this case, based on the default backend's
+        activation window).
+
+        """
+        # Register an account and reset its date_joined to be outside
+        # the activation window.
+        self.client.post(reverse('registration_register'),
+                         data={'username': 'bob',
+                               'email': 'bob@example.com',
+                               'password1': 'secret',
+                               'password2': 'secret'})
+        expired_user = User.objects.get(username='bob')
+        expired_user.date_joined = expired_user.date_joined - datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)
+        expired_user.save()
+
+        expired_profile = RegistrationProfile.objects.get(user=expired_user)
+        response = self.client.get(reverse('registration_activate',
+                                           kwargs={'activation_key': expired_profile.activation_key}))
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context['activation_key'],
+                         expired_profile.activation_key)
+        self.failIf(User.objects.get(username='bob').is_active)
+
+    def test_activation_success_url(self):
+        """
+        Passing ``success_url`` to the ``activate`` view and
+        successfully activating will result in that URL being used for
+        the redirect.
+        
+        """
+        success_redirect = 'http://testserver%s' % reverse('registration_test_custom_success_url')
+        self.client.post(reverse('registration_register'),
+                         data={'username': 'alice',
+                               'email': 'alice@example.com',
+                               'password1': 'swordfish',
+                               'password2': 'swordfish'})
+        profile = RegistrationProfile.objects.get(user__username='alice')
+        response = self.client.get(reverse('registration_test_activate_success_url',
+                                           kwargs={'activation_key': profile.activation_key}))
+        self.assertRedirects(response, success_redirect)
+        
+    def test_activation_template_name(self):
+        """
+        Passing ``template_name`` to the ``activate`` view will result
+        in that template being used.
+
+        """
+        response = self.client.get(reverse('registration_test_activate_template_name',
+                                   kwargs={'activation_key': 'foo'}))
+        self.assertTemplateUsed(response, 'registration/test_template_name.html')
+
+    def test_activation_extra_context(self):
+        """
+        Passing ``extra_context`` to the ``activate`` view will
+        correctly populate the context.
+
+        """
+        response = self.client.get(reverse('registration_test_activate_extra_context',
+                                           kwargs={'activation_key': 'foo'}))
+        self.assertEqual(response.context['foo'], 'bar')
+        # Callables in extra_context are called to obtain the value.
+        self.assertEqual(response.context['callable'], 'called')

registration/tests/__init__.py

-from django.test import TestCase
-
-import registration
-
-from registration.tests.backends import *
-from registration.tests.forms import *
-from registration.tests.models import *
-from registration.tests.views import *
-
-
-class RegistrationVersionInfoTests(TestCase):
-    """
-    Test django-registration's internal version-reporting
-    infrastructure.
-    
-    """
-    def setUp(self):
-        self.version = registration.VERSION
-
-    def tearDown(self):
-        registration.VERSION = self.version
-    
-    def test_get_version(self):
-        """
-        Test the version-info reporting.
-        
-        """
-        versions = [
-            {'version': (1, 0, 0, 'alpha', 0),
-             'expected': "1.0 pre-alpha"},
-            {'version': (1, 0, 1, 'alpha', 1),
-             'expected': "1.0.1 alpha 1"},
-            {'version': (1, 1, 0, 'beta', 2),
-             'expected': "1.1 beta 2"},
-            {'version': (1, 2, 1, 'rc', 3),
-             'expected': "1.2.1 rc 3"},
-            {'version': (1, 3, 0, 'final', 0),
-             'expected': "1.3"},
-            {'version': (1, 4, 1, 'beta', 0),
-             'expected': "1.4.1 beta"},
-            ]
-        
-        for version_dict in versions:
-            registration.VERSION = version_dict['version']
-            self.assertEqual(registration.get_version(), version_dict['expected'])

registration/tests/backends.py

-import datetime
-
-from django.conf import settings
-from django.contrib import admin
-from django.contrib.auth.models import User
-from django.contrib.sessions.middleware import SessionMiddleware
-from django.contrib.sites.models import Site
-from django.core import mail
-from django.core.exceptions import ImproperlyConfigured
-from django.core.handlers.wsgi import WSGIRequest
-from django.test import Client
-from django.test import TestCase
-
-from registration import forms
-from registration import signals
-from registration.admin import RegistrationAdmin
-from registration.backends import get_backend
-from registration.backends.default import DefaultBackend
-from registration.backends.simple import SimpleBackend
-from registration.models import RegistrationProfile
-
-
-class _MockRequestClient(Client):
-    """
-    A ``django.test.Client`` subclass which can return mock
-    ``HttpRequest`` objects.
-    
-    """
-    def request(self, **request):
-        """
-        Rather than issuing a request and returning the response, this
-        simply constructs an ``HttpRequest`` object and returns it.
-        
-        """
-        environ = {
-            'HTTP_COOKIE':      self.cookies,
-            'PATH_INFO':         '/',
-            'QUERY_STRING':      '',
-            'REMOTE_ADDR':       '127.0.0.1',
-            'REQUEST_METHOD':    'GET',
-            'SCRIPT_NAME':       '',
-            'SERVER_NAME':       'testserver',
-            'SERVER_PORT':       '80',
-            'SERVER_PROTOCOL':   'HTTP/1.1',
-            'wsgi.version':      (1,0),
-            'wsgi.url_scheme':   'http',
-            'wsgi.errors':       self.errors,
-            'wsgi.multiprocess': True,
-            'wsgi.multithread':  False,
-            'wsgi.run_once':     False,
-            }
-        environ.update(self.defaults)
-        environ.update(request)
-        request = WSGIRequest(environ)
-
-        # We have to manually add a session since we'll be bypassing
-        # the middleware chain.
-        session_middleware = SessionMiddleware()
-        session_middleware.process_request(request)
-        return request
-
-
-def _mock_request():
-    """
-    Construct and return a mock ``HttpRequest`` object; this is used
-    in testing backend methods which expect an ``HttpRequest`` but
-    which are not being called from views.
-    
-    """
-    return _MockRequestClient().request()
-
-
-class BackendRetrievalTests(TestCase):
-    """
-    Test that utilities for retrieving the active backend work
-    properly.
-
-    """
-    def test_get_backend(self):
-        """
-        Verify that ``get_backend()`` returns the correct value when
-        passed a valid backend.
-
-        """
-        self.failUnless(isinstance(get_backend('registration.backends.default.DefaultBackend'),
-                                   DefaultBackend))
-
-    def test_backend_error_invalid(self):
-        """
-        Test that a nonexistent/unimportable backend raises the
-        correct exception.
-
-        """
-        self.assertRaises(ImproperlyConfigured, get_backend,
-                          'registration.backends.doesnotexist.NonExistentBackend')
-
-    def test_backend_attribute_error(self):
-        """
-        Test that a backend module which exists but does not have a
-        class of the specified name raises the correct exception.
-        
-        """
-        self.assertRaises(ImproperlyConfigured, get_backend,
-                          'registration.backends.default.NonexistentBackend')
-
-
-class DefaultRegistrationBackendTests(TestCase):
-    """
-    Test the default registration backend.
-
-    Running these tests successfull will require two templates to be
-    created for the sending of activation emails; details on these
-    templates and their contexts may be found in the documentation for
-    the default backend.
-
-    """
-    backend = DefaultBackend()
-    
-    def setUp(self):
-        """
-        Create an instance of the default backend for use in testing,
-        and set ``ACCOUNT_ACTIVATION_DAYS`` if it's not set already.
-
-        """
-        self.old_activation = getattr(settings, 'ACCOUNT_ACTIVATION_DAYS', None)
-        if self.old_activation is None:
-            settings.ACCOUNT_ACTIVATION_DAYS = 7
-
-    def tearDown(self):
-        """
-        Yank out ``ACCOUNT_ACTIVATION_DAYS`` back out if it wasn't
-        originally set.
-
-        """
-        if self.old_activation is None:
-            settings.ACCOUNT_ACTIVATION_DAYS = self.old_activation
-
-    def test_registration(self):
-        """
-        Test the registration process: registration creates a new
-        inactive account and a new profile with activation key,
-        populates the correct account data and sends an activation
-        email.
-
-        """
-        new_user = self.backend.register(_mock_request(),
-                                         username='bob',
-                                         email='bob@example.com',
-                                         password1='secret')
-
-        # Details of the returned user must match what went in.
-        self.assertEqual(new_user.username, 'bob')
-        self.failUnless(new_user.check_password('secret'))
-        self.assertEqual(new_user.email, 'bob@example.com')
-
-        # New user must not be active.
-        self.failIf(new_user.is_active)
-
-        # A registration profile was created, and an activation email
-        # was sent.
-        self.assertEqual(RegistrationProfile.objects.count(), 1)
-        self.assertEqual(len(mail.outbox), 1)
-
-    def test_registration_no_sites(self):
-        """
-        Test that registration still functions properly when
-        ``django.contrib.sites`` is not installed; the fallback will
-        be a ``RequestSite`` instance.
-        
-        """
-        Site._meta.installed = False
-
-        new_user = self.backend.register(_mock_request(),
-                                         username='bob',
-                                         email='bob@example.com',
-                                         password1='secret')
-
-        self.assertEqual(new_user.username, 'bob')
-        self.failUnless(new_user.check_password('secret'))
-        self.assertEqual(new_user.email, 'bob@example.com')
-
-        self.failIf(new_user.is_active)
-
-        self.assertEqual(RegistrationProfile.objects.count(), 1)
-        self.assertEqual(len(mail.outbox), 1)
-        
-        Site._meta.installed = True
-
-    def test_valid_activation(self):
-        """
-        Test the activation process: activating within the permitted
-        window sets the account's ``is_active`` field to ``True`` and
-        resets the activation key.
-
-        """
-        valid_user = self.backend.register(_mock_request(),
-                                           username='alice',
-                                           email='alice@example.com',
-                                           password1='swordfish')
-
-        valid_profile = RegistrationProfile.objects.get(user=valid_user)
-        activated = self.backend.activate(_mock_request(),
-                                          valid_profile.activation_key)
-        self.assertEqual(activated.username, valid_user.username)
-        self.failUnless(activated.is_active)
-
-        # Fetch the profile again to verify its activation key has
-        # been reset.
-        valid_profile = RegistrationProfile.objects.get(user=valid_user)
-        self.assertEqual(valid_profile.activation_key,
-                         RegistrationProfile.ACTIVATED)
-
-    def test_invalid_activation(self):
-        """
-        Test the activation process: trying to activate outside the
-        permitted window fails, and leaves the account inactive.
-
-        """
-        expired_user = self.backend.register(_mock_request(),
-                                             username='bob',
-                                             email='bob@example.com',
-                                             password1='secret')
-
-        expired_user.date_joined = expired_user.date_joined - datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)
-        expired_user.save()
-        expired_profile = RegistrationProfile.objects.get(user=expired_user)
-        self.failIf(self.backend.activate(_mock_request(),
-                                          expired_profile.activation_key))
-        self.failUnless(expired_profile.activation_key_expired())
-
-    def test_allow(self):
-        """
-        Test that the setting ``REGISTRATION_OPEN`` appropriately
-        controls whether registration is permitted.
-
-        """
-        old_allowed = getattr(settings, 'REGISTRATION_OPEN', True)
-        settings.REGISTRATION_OPEN = True
-        self.failUnless(self.backend.registration_allowed(_mock_request()))
-
-        settings.REGISTRATION_OPEN = False
-        self.failIf(self.backend.registration_allowed(_mock_request()))
-        settings.REGISTRATION_OPEN = old_allowed
-
-    def test_form_class(self):
-        """
-        Test that the default form class returned is
-        ``registration.forms.RegistrationForm``.
-
-        """
-        self.failUnless(self.backend.get_form_class(_mock_request()) is forms.RegistrationForm)
-
-    def test_post_registration_redirect(self):
-        """
-        Test that the default post-registration redirect is the named
-        pattern ``registration_complete``.
-
-        """
-        self.assertEqual(self.backend.post_registration_redirect(_mock_request(), User()),
-                         ('registration_complete', (), {}))
-
-    def test_registration_signal(self):
-        """
-        Test that registering a user sends the ``user_registered``
-        signal.
-        
-        """
-        def receiver(sender, **kwargs):
-            self.failUnless('user' in kwargs)
-            self.assertEqual(kwargs['user'].username, 'bob')
-            self.failUnless('request' in kwargs)
-            self.failUnless(isinstance(kwargs['request'], WSGIRequest))
-            received_signals.append(kwargs.get('signal'))
-
-        received_signals = []
-        signals.user_registered.connect(receiver, sender=self.backend.__class__)
-
-        self.backend.register(_mock_request(),
-                              username='bob',
-                              email='bob@example.com',
-                              password1='secret')
-
-        self.assertEqual(len(received_signals), 1)
-        self.assertEqual(received_signals, [signals.user_registered])
-
-    def test_activation_signal_success(self):
-        """
-        Test that successfully activating a user sends the
-        ``user_activated`` signal.
-        
-        """
-        def receiver(sender, **kwargs):
-            self.failUnless('user' in kwargs)
-            self.assertEqual(kwargs['user'].username, 'bob')
-            self.failUnless('request' in kwargs)
-            self.failUnless(isinstance(kwargs['request'], WSGIRequest))
-            received_signals.append(kwargs.get('signal'))
-
-        received_signals = []
-        signals.user_activated.connect(receiver, sender=self.backend.__class__)
-
-        new_user = self.backend.register(_mock_request(),
-                                         username='bob',
-                                         email='bob@example.com',
-                                         password1='secret')
-        profile = RegistrationProfile.objects.get(user=new_user)
-        self.backend.activate(_mock_request(), profile.activation_key)
-
-        self.assertEqual(len(received_signals), 1)
-        self.assertEqual(received_signals, [signals.user_activated])
-
-    def test_activation_signal_failure(self):
-        """
-        Test that an unsuccessful activation attempt does not send the
-        ``user_activated`` signal.
-        
-        """
-        receiver = lambda sender, **kwargs: received_signals.append(kwargs.get('signal'))
-
-        received_signals = []
-        signals.user_activated.connect(receiver, sender=self.backend.__class__)
-
-        new_user = self.backend.register(_mock_request(),
-                                         username='bob',
-                                         email='bob@example.com',
-                                         password1='secret')
-        new_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)
-        new_user.save()
-        profile = RegistrationProfile.objects.get(user=new_user)
-        self.backend.activate(_mock_request(), profile.activation_key)
-
-        self.assertEqual(len(received_signals), 0)
-
-    def test_email_send_action(self):
-        """
-        Test re-sending of activation emails via admin action.
-        
-        """
-        admin_class = RegistrationAdmin(RegistrationProfile, admin.site)
-        
-        alice = self.backend.register(_mock_request(),
-                                      username='alice',
-                                      email='alice@example.com',
-                                      password1='swordfish')
-        
-        admin_class.resend_activation_email(_mock_request(),
-                                            RegistrationProfile.objects.all())
-        self.assertEqual(len(mail.outbox), 2) # One on registering, one more on the resend.
-        
-        RegistrationProfile.objects.filter(user=alice).update(activation_key=RegistrationProfile.ACTIVATED)
-        admin_class.resend_activation_email(_mock_request(),
-                                            RegistrationProfile.objects.all())
-        self.assertEqual(len(mail.outbox), 2) # No additional email because the account has activated.
-
-    def test_activation_action(self):
-        """
-        Test manual activation of users view admin action.
-        
-        """
-        admin_class = RegistrationAdmin(RegistrationProfile, admin.site)
-
-        alice = self.backend.register(_mock_request(),
-                                      username='alice',
-                                      email='alice@example.com',
-                                      password1='swordfish')
-
-        admin_class.activate_users(_mock_request(),
-                                   RegistrationProfile.objects.all())
-        self.failUnless(User.objects.get(username='alice').is_active)
-
-
-class SimpleRegistrationBackendTests(TestCase):
-    """
-    Test the simple registration backend, which does signup and
-    immediate activation.
-    
-    """
-    backend = SimpleBackend()
-    
-    def test_registration(self):
-        """
-        Test the registration process: registration creates a new
-        inactive account and a new profile with activation key,
-        populates the correct account data and sends an activation
-        email.
-
-        """
-        new_user = self.backend.register(_mock_request(),
-                                         username='bob',
-                                         email='bob@example.com',
-                                         password1='secret')
-
-        # Details of the returned user must match what went in.
-        self.assertEqual(new_user.username, 'bob')
-        self.failUnless(new_user.check_password('secret'))
-        self.assertEqual(new_user.email, 'bob@example.com')
-
-        # New user must not be active.
-        self.failUnless(new_user.is_active)
-
-    def test_allow(self):
-        """
-        Test that the setting ``REGISTRATION_OPEN`` appropriately
-        controls whether registration is permitted.
-
-        """
-        old_allowed = getattr(settings, 'REGISTRATION_OPEN', True)
-        settings.REGISTRATION_OPEN = True
-        self.failUnless(self.backend.registration_allowed(_mock_request()))
-
-        settings.REGISTRATION_OPEN = False
-        self.failIf(self.backend.registration_allowed(_mock_request()))
-        settings.REGISTRATION_OPEN = old_allowed
-
-    def test_form_class(self):
-        """
-        Test that the default form class returned is
-        ``registration.forms.RegistrationForm``.
-
-        """
-        self.failUnless(self.backend.get_form_class(_mock_request()) is forms.RegistrationForm)
-
-    def test_post_registration_redirect(self):
-        """
-        Test that the default post-registration redirect is the public
-        URL of the new user account.
-
-        """
-        new_user = self.backend.register(_mock_request(),
-                                         username='bob',
-                                         email='bob@example.com',
-                                         password1='secret')
-        
-        self.assertEqual(self.backend.post_registration_redirect(_mock_request(), new_user),
-                         (new_user.get_absolute_url(), (), {}))
-
-    def test_registration_signal(self):
-        """
-        Test that registering a user sends the ``user_registered``
-        signal.
-        
-        """
-        def receiver(sender, **kwargs):
-            self.failUnless('user' in kwargs)
-            self.assertEqual(kwargs['user'].username, 'bob')
-            self.failUnless('request' in kwargs)
-            self.failUnless(isinstance(kwargs['request'], WSGIRequest))
-            received_signals.append(kwargs.get('signal'))
-
-        received_signals = []
-        signals.user_registered.connect(receiver, sender=self.backend.__class__)
-
-        self.backend.register(_mock_request(),
-                              username='bob',
-                              email='bob@example.com',
-                              password1='secret')
-
-        self.assertEqual(len(received_signals), 1)
-        self.assertEqual(received_signals, [signals.user_registered])
-
-    def test_activation(self):
-        """
-        Test that activating against this backend is an error.
-        
-        """
-        self.assertRaises(NotImplementedError, self.backend.activate,
-                          request=_mock_request())
-
-    def test_post_activation_redirect(self):
-        """
-        Test that asking for a post-activation redirect from this
-        backend is an error.
-        
-        """
-        self.assertRaises(NotImplementedError, self.backend.post_activation_redirect,
-                          request=_mock_request(), user=User())

registration/tests/forms.py

-from django.contrib.auth.models import User
-from django.test import TestCase
-
-from registration import forms
-
-
-class RegistrationFormTests(TestCase):
-    """
-    Test the default registration forms.
-
-    """
-    def test_registration_form(self):
-        """
-        Test that ``RegistrationForm`` enforces username constraints
-        and matching passwords.
-
-        """
-        # Create a user so we can verify that duplicate usernames aren't
-        # permitted.
-        User.objects.create_user('alice', 'alice@example.com', 'secret')
-
-        invalid_data_dicts = [
-            # Non-alphanumeric username.
-            {'data': {'username': 'foo/bar',
-                      'email': 'foo@example.com',
-                      'password1': 'foo',
-                      'password2': 'foo'},
-            'error': ('username', [u"This value must contain only letters, numbers and underscores."])},
-            # Already-existing username.
-            {'data': {'username': 'alice',
-                      'email': 'alice@example.com',
-                      'password1': 'secret',
-                      'password2': 'secret'},
-            'error': ('username', [u"A user with that username already exists."])},
-            # Mismatched passwords.
-            {'data': {'username': 'foo',
-                      'email': 'foo@example.com',
-                      'password1': 'foo',
-                      'password2': 'bar'},
-            'error': ('__all__', [u"The two password fields didn't match."])},
-            ]
-
-        for invalid_dict in invalid_data_dicts:
-            form = forms.RegistrationForm(data=invalid_dict['data'])
-            self.failIf(form.is_valid())
-            self.assertEqual(form.errors[invalid_dict['error'][0]],
-                             invalid_dict['error'][1])
-
-        form = forms.RegistrationForm(data={'username': 'foo',
-                                            'email': 'foo@example.com',
-                                            'password1': 'foo',
-                                            'password2': 'foo'})
-        self.failUnless(form.is_valid())
-
-    def test_registration_form_tos(self):
-        """
-        Test that ``RegistrationFormTermsOfService`` requires
-        agreement to the terms of service.
-
-        """
-        form = forms.RegistrationFormTermsOfService(data={'username': 'foo',
-                                                          'email': 'foo@example.com',
-                                                          'password1': 'foo',
-                                                          'password2': 'foo'})
-        self.failIf(form.is_valid())
-        self.assertEqual(form.errors['tos'],
-                         [u"You must agree to the terms to register"])
-
-        form = forms.RegistrationFormTermsOfService(data={'username': 'foo',
-                                                          'email': 'foo@example.com',
-                                                          'password1': 'foo',
-                                                          'password2': 'foo',
-                                                          'tos': 'on'})
-        self.failUnless(form.is_valid())
-
-    def test_registration_form_unique_email(self):
-        """
-        Test that ``RegistrationFormUniqueEmail`` validates uniqueness
-        of email addresses.
-
-        """
-        # Create a user so we can verify that duplicate addresses
-        # aren't permitted.
-        User.objects.create_user('alice', 'alice@example.com', 'secret')
-
-        form = forms.RegistrationFormUniqueEmail(data={'username': 'foo',
-                                                       'email': 'alice@example.com',
-                                                       'password1': 'foo',
-                                                       'password2': 'foo'})
-        self.failIf(form.is_valid())
-        self.assertEqual(form.errors['email'],
-                         [u"This email address is already in use. Please supply a different email address."])
-
-        form = forms.RegistrationFormUniqueEmail(data={'username': 'foo',
-                                                       'email': 'foo@example.com',
-                                                       'password1': 'foo',
-                                                       'password2': 'foo'})
-        self.failUnless(form.is_valid())
-
-    def test_registration_form_no_free_email(self):
-        """
-        Test that ``RegistrationFormNoFreeEmail`` disallows
-        registration with free email addresses.
-
-        """
-        base_data = {'username': 'foo',
-                     'password1': 'foo',
-                     'password2': 'foo'}
-        for domain in forms.RegistrationFormNoFreeEmail.bad_domains:
-            invalid_data = base_data.copy()
-            invalid_data['email'] = u"foo@%s" % domain
-            form = forms.RegistrationFormNoFreeEmail(data=invalid_data)
-            self.failIf(form.is_valid())
-            self.assertEqual(form.errors['email'],
-                             [u"Registration using free email addresses is prohibited. Please supply a different email address."])
-
-        base_data['email'] = 'foo@example.com'
-        form = forms.RegistrationFormNoFreeEmail(data=base_data)
-        self.failUnless(form.is_valid())

registration/tests/models.py

-import datetime
-import re
-
-from django.conf import settings
-from django.contrib.auth.models import User
-from django.contrib.sites.models import Site
-from django.core import mail
-from django.core import management
-from django.test import TestCase
-from django.utils.hashcompat import sha_constructor
-
-from registration.models import RegistrationProfile
-
-
-class RegistrationModelTests(TestCase):
-    """
-    Test the model and manager used in the default backend.
-    
-    """
-    user_info = {'username': 'alice',
-                 'password': 'swordfish',
-                 'email': 'alice@example.com'}
-    
-    def setUp(self):
-        self.old_activation = getattr(settings, 'ACCOUNT_ACTIVATION_DAYS', None)
-        settings.ACCOUNT_ACTIVATION_DAYS = 7
-
-    def tearDown(self):
-        settings.ACCOUNT_ACTIVATION_DAYS = self.old_activation
-
-    def test_profile_creation(self):
-        """
-        Creating a registration profile for a user populates the
-        profile with the correct user and a SHA1 hash to use as
-        activation key.
-        
-        """
-        new_user = User.objects.create_user(**self.user_info)
-        profile = RegistrationProfile.objects.create_profile(new_user)
-
-        self.assertEqual(RegistrationProfile.objects.count(), 1)
-        self.assertEqual(profile.user.id, new_user.id)
-        self.failUnless(re.match('^[a-f0-9]{40}$', profile.activation_key))
-        self.assertEqual(unicode(profile),
-                         "Registration information for alice")
-
-    def test_activation_email(self):
-        """
-        ``RegistrationProfile.send_activation_email`` sends an
-        email.
-        
-        """
-        new_user = User.objects.create_user(**self.user_info)
-        profile = RegistrationProfile.objects.create_profile(new_user)
-        profile.send_activation_email(Site.objects.get_current())
-        self.assertEqual(len(mail.outbox), 1)
-        self.assertEqual(mail.outbox[0].to, [self.user_info['email']])
-
-    def test_user_creation(self):
-        """
-        Creating a new user populates the correct data, and sets the
-        user's account inactive.
-        
-        """
-        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
-                                                                    **self.user_info)
-        self.assertEqual(new_user.username, 'alice')
-        self.assertEqual(new_user.email, 'alice@example.com')
-        self.failUnless(new_user.check_password('swordfish'))
-        self.failIf(new_user.is_active)
-
-    def test_user_creation_email(self):
-        """
-        By default, creating a new user sends an activation email.
-        
-        """
-        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
-                                                                    **self.user_info)
-        self.assertEqual(len(mail.outbox), 1)
-
-    def test_user_creation_no_email(self):
-        """
-        Passing ``send_email=False`` when creating a new user will not
-        send an activation email.
-        
-        """
-        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
-                                                                    send_email=False,
-                                                                    **self.user_info)
-        self.assertEqual(len(mail.outbox), 0)
-
-    def test_unexpired_account(self):
-        """
-        ``RegistrationProfile.activation_key_expired()`` is ``False``
-        within the activation window.
-        
-        """
-        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
-                                                                    **self.user_info)
-        profile = RegistrationProfile.objects.get(user=new_user)
-        self.failIf(profile.activation_key_expired())
-
-    def test_expired_account(self):
-        """
-        ``RegistrationProfile.activation_key_expired()`` is ``True``
-        outside the activation window.
-        
-        """
-        new_user = RegistrationProfile.objects.create_inactive_user(site=Site.objects.get_current(),
-                                                                    **self.user_info)
</