コード例 #1
0
    def register(self, request, **cleaned_data):
        username, email, password = cleaned_data['username'], cleaned_data['email'], cleaned_data['password1']
        get_user_model().objects.create_user(username, email, password)

        new_user = authenticate(username=username, password=password)
        login(request, new_user)
        signals.user_registered.send(sender=self.__class__,
                                     user=new_user,
                                     request=request)
        return new_user
コード例 #2
0
    def test_activation_form(self):
        """
        Test that ``ActivationForm`` enforces username constraints
        and matching passwords.

        """
        User = get_user_model()
        # Create a user so we can verify that duplicate usernames aren't
        # permitted.
        User.objects.create_user('alice', '*****@*****.**', 'secret')

        invalid_data_dicts = [
            # Mismatched passwords.
            {'data': {'password1': 'foo',
                      'password2': 'bar'},
            'error': ('__all__', [u"The two password fields didn't match."])},
            ]

        for invalid_dict in invalid_data_dicts:
            form = forms.ActivationForm(data=invalid_dict['data'])
            self.failIf(form.is_valid())
            self.assertEqual(form.errors[invalid_dict['error'][0]],
                             invalid_dict['error'][1])

        form = forms.ActivationForm(data={'password1': 'foo',
                                            'password2': 'foo'})
        self.failUnless(form.is_valid())
コード例 #3
0
    def test_registration_form_unique_email(self):
        """
        Test that ``RegistrationFormUniqueEmail`` validates uniqueness
        of email addresses.

        """
        User = get_user_model()
        # Create a user so we can verify that duplicate addresses
        # aren't permitted.
        User.objects.create_user('alice', '*****@*****.**', 'secret')

        form = forms.RegistrationFormUniqueEmail(
            data={
                'username': '******',
                'email1': '*****@*****.**',
                'email2': '*****@*****.**'
            })
        self.failIf(form.is_valid())
        self.assertEqual(form.errors['email1'], [
            "This email address is already in use. Please supply a different email address."
        ])

        form = forms.RegistrationFormUniqueEmail(
            data={
                'username': '******',
                'email1': '*****@*****.**',
                'email2': '*****@*****.**'
            })
        self.failUnless(form.is_valid())
コード例 #4
0
ファイル: models.py プロジェクト: sogimu/ariadna_services
    def register(self, username, email, site, send_email=True):
        """register new user with ``username`` and ``email``

        Create a new, inactive ``User``, generate a ``RegistrationProfile``
        and email notification to the ``User``, returning the new ``User``.

        By default, a registration email will be sent to the new user. To
        disable this, pass ``send_email=False``. A registration email will be
        generated by ``registration/registration_email.txt`` and
        ``registration/registration_email_subject.txt``.

        The user created by this method has no usable password and it will
        be set after activation.

        This method is transactional. Thus if some exception has occur in this
        method, the newly created user will be rollbacked.

        """
        User = get_user_model()
        new_user = User.objects.create_user(username, email, 'password')
        new_user.set_unusable_password()
        new_user.is_active = False
        new_user.save()

        profile = self.create(user=new_user)

        if send_email:
            profile.send_registration_email(site)

        return new_user
コード例 #5
0
ファイル: test_forms.py プロジェクト: sogimu/ariadna_services
    def test_activation_form(self):
        """
        Test that ``ActivationForm`` enforces username constraints
        and matching passwords.

        """
        User = get_user_model()
        # Create a user so we can verify that duplicate usernames aren't
        # permitted.
        User.objects.create_user("alice", "*****@*****.**", "secret")

        invalid_data_dicts = [
            # Mismatched passwords.
            {
                "data": {"password1": "foo", "password2": "bar"},
                "error": ("__all__", ["The two password fields didn't match."]),
            }
        ]

        for invalid_dict in invalid_data_dicts:
            form = forms.ActivationForm(data=invalid_dict["data"])
            self.failIf(form.is_valid())
            self.assertEqual(form.errors[invalid_dict["error"][0]], invalid_dict["error"][1])

        form = forms.ActivationForm(data={"password1": "foo", "password2": "foo"})
        self.failUnless(form.is_valid())
コード例 #6
0
ファイル: models.py プロジェクト: kushtaneja/SangramDjango
    def register(self, username, email, site, send_email=True):
        """register new user with ``username`` and ``email``

        Create a new, inactive ``User``, generate a ``RegistrationProfile``
        and email notification to the ``User``, returning the new ``User``.

        By default, a registration email will be sent to the new user. To
        disable this, pass ``send_email=False``. A registration email will be
        generated by ``registration/registration_email.txt`` and
        ``registration/registration_email_subject.txt``.

        The user created by this method has no usable password and it will
        be set after activation.

        This method is transactional. Thus if some exception has occur in this
        method, the newly created user will be rollbacked.

        """
        User = get_user_model()
        new_user = User.objects.create_user(username, email, 'password')
        new_user.set_unusable_password()
        new_user.is_active = False
        new_user.save()

        profile = self.create(user=new_user)

        if send_email:
            profile.send_registration_email(site)

        return new_user
コード例 #7
0
    def test_activation_form(self):
        """
        Test that ``ActivationForm`` enforces username constraints
        and matching passwords.

        """
        User = get_user_model()
        # Create a user so we can verify that duplicate usernames aren't
        # permitted.
        User.objects.create_user('alice', '*****@*****.**', 'secret')

        invalid_data_dicts = [
            # Mismatched passwords.
            {
                'data': {
                    'password1': 'foo',
                    'password2': 'bar'
                },
                'error': ('__all__', ["The two password fields didn't match."])
            },
        ]

        for invalid_dict in invalid_data_dicts:
            form = forms.ActivationForm(data=invalid_dict['data'])
            self.failIf(form.is_valid())
            self.assertEqual(form.errors[invalid_dict['error'][0]],
                             invalid_dict['error'][1])

        form = forms.ActivationForm(data={
            'password1': 'foo',
            'password2': 'foo'
        })
        self.failUnless(form.is_valid())
コード例 #8
0
    def test_activation_view_post_success(self):
        """
        A ``POST`` to the ``ActivationView`` view with valid data properly
        handles a valid activation

        """
        User = get_user_model()
        new_user = self.backend.register(username='******',
                                         email='*****@*****.**',
                                         request=self.mock_request)
        new_user = self.backend.accept(new_user.registration_profile,
                                       request=self.mock_request)

        activation_url = reverse(
            'registration_activate',
            kwargs={
                'activation_key': new_user.registration_profile.activation_key
            })

        response = self.client.post(activation_url, {
            'password1': 'swordfish',
            'password2': 'swordfish'
        })

        success_redirect = reverse('registration_activation_complete')
        if django.VERSION < (2, 0):
            success_redirect = 'http://testserver%s' % success_redirect
        self.assertRedirects(response, success_redirect)
        # RegistrationProfile should be removed with activation
        self.assertEqual(RegistrationProfile.objects.count(), 0)
        # registration, acceptance and activation
        self.assertEqual(len(mail.outbox), 3)
        self.failUnless(User.objects.get(username='******').is_active)
コード例 #9
0
    def create_inactive_user(self,
                             username,
                             email,
                             password,
                             site,
                             send_email=True):
        """
        Create a new, inactive ``User``, generate a
        ``RegistrationProfile`` and email its activation key to the
        ``User``, returning the new ``User``.

        By default, an activation email will be sent to the new
        user. To disable this, pass ``send_email=False``.
        
        """
        new_user = get_user_model().objects.create_user(
            username, email, password)
        new_user.is_active = False
        new_user.save()

        registration_profile = self.create_profile(new_user)

        if send_email:
            registration_profile.send_activation_email(site)

        return new_user
コード例 #10
0
ファイル: forms.py プロジェクト: langcog/web-cdi
 def clean_email1(self):
     """Validate that the supplied email address is unique for the site."""
     User = get_user_model()
     if User.objects.filter(email__iexact=self.cleaned_data['email1']):
         raise forms.ValidationError(
             _("This email address is already in use. "
               "Please supply a different email address."))
     return self.cleaned_data['email1']
コード例 #11
0
 def clean_email1(self):
     """Validate that the supplied email address is unique for the site."""
     User = get_user_model()
     if User.objects.filter(email__iexact=self.cleaned_data['email1']):
         raise forms.ValidationError(_(
             "This email address is already in use. "
             "Please supply a different email address."))
     return self.cleaned_data['email1']
コード例 #12
0
    def test_registration_form(self):
        """
        Test that ``RegistrationForm`` enforces username constraints
        and matching passwords.

        """
        User = get_user_model()
        # Create a user so we can verify that duplicate usernames aren't
        # permitted.
        User.objects.create_user('alice', '*****@*****.**', 'secret')

        invalid_data_dicts = [
            # Non-alphanumeric username.
            {
                'data': {
                    'username': '******',
                    'email1': '*****@*****.**',
                    'email2': '*****@*****.**'
                },
                'error': ('username', [
                    "This value must contain only letters, numbers and underscores."
                ])
            },
            # Already-existing username.
            {
                'data': {
                    'username': '******',
                    'email1': '*****@*****.**',
                    'email2': '*****@*****.**'
                },
                'error':
                ('username', ["A user with that username already exists."])
            },
            # Mismatched email.
            {
                'data': {
                    'username': '******',
                    'email1': '*****@*****.**',
                    'email2': '*****@*****.**'
                },
                'error': ('__all__', ["The two email 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': '******',
                'email1': '*****@*****.**',
                'email2': '*****@*****.**'
            })
        self.failUnless(form.is_valid())
コード例 #13
0
    def setUp(self):
        User = get_user_model()
        self.backend = DefaultRegistrationBackend()
        self.mock_request = mock_request()
        self.admin = User.objects.create_superuser(username='******',
                                                   email='*****@*****.**',
                                                   password='******')

        self.client.login(username='******', password='******')
        self.admin_url = reverse('admin:index')
コード例 #14
0
    def setUp(self):
        User = get_user_model()
        self.backend = DefaultRegistrationBackend()
        self.mock_request = mock_request()
        self.admin = User.objects.create_superuser(
            username='******', email='*****@*****.**',
            password='******')

        self.client.login(username='******', password='******')
        self.admin_url = reverse('admin:index')
コード例 #15
0
    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.
        get_user_model().objects.create_user('alice', '*****@*****.**', 'secret')

        invalid_data_dicts = [
            # Non-alphanumeric username.
            {'data': {'username': '******',
                      'email': '*****@*****.**',
                      'password1': 'foo',
                      'password2': 'foo'},
            'error': ('username', [u"This value may contain only letters, numbers and @/./+/-/_ characters."])},
            # Already-existing username.
            {'data': {'username': '******',
                      'email': '*****@*****.**',
                      'password1': 'secret',
                      'password2': 'secret'},
            'error': ('username', [u"A user with that username already exists."])},
            # Mismatched passwords.
            {'data': {'username': '******',
                      'email': '*****@*****.**',
                      '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': '******',
                                            'email': '*****@*****.**',
                                            'password1': 'foo',
                                            'password2': 'foo'})
        self.failUnless(form.is_valid())
コード例 #16
0
ファイル: forms.py プロジェクト: langcog/web-cdi
 def clean_username(self):
     """
     Validate that the username is alphanumeric and is not already in use.
     """
     User = get_user_model()
     try:
         User.objects.get(username__iexact=self.cleaned_data['username'])
     except User.DoesNotExist:
         return self.cleaned_data['username']
     raise forms.ValidationError(
         _("A user with that username already exists."))
コード例 #17
0
    def test_activation_email(self):
        """
        ``RegistrationProfile.send_activation_email`` sends an
        email.

        """
        new_user = get_user_model().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']])
コード例 #18
0
 def clean_username(self):
     """
     Validate that the username is alphanumeric and is not already in use.
     """
     User = get_user_model()
     try:
         User.objects.get(username__iexact=self.cleaned_data['username'])
     except User.DoesNotExist:
         return self.cleaned_data['username']
     raise forms.ValidationError(_(
         "A user with that username already exists."))
コード例 #19
0
    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.
        get_user_model().objects.create_user('alice', '*****@*****.**', 'secret')

        form = forms.RegistrationFormUniqueEmail(data={'username': '******',
                                                       'email': '*****@*****.**',
                                                       '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': '******',
                                                       'email': '*****@*****.**',
                                                       'password1': 'foo',
                                                       'password2': 'foo'})
        self.failUnless(form.is_valid())
コード例 #20
0
 def delete_expired_users(self):
     """
     Remove expired instances of ``RegistrationProfile`` and their
     associated ``User``s.
     
     Accounts to be deleted are identified by searching for
     instances of ``RegistrationProfile`` with expired activation
     keys, and then checking to see if their associated ``User``
     instances have the field ``is_active`` set to ``False``; any
     ``User`` who is both inactive and has an expired activation
     key will be deleted.
     
     It is recommended that this method be executed regularly as
     part of your routine site maintenance; this application
     provides a custom management command which will call this
     method, accessible as ``manage.py cleanupregistration``.
     
     Regularly clearing out accounts which have never been
     activated serves two useful purposes:
     
     1. It alleviates the ocasional need to reset a
        ``RegistrationProfile`` and/or re-send an activation email
        when a user does not receive or does not act upon the
        initial activation email; since the account will be
        deleted, the user will be able to simply re-register and
        receive a new activation key.
     
     2. It prevents the possibility of a malicious user registering
        one or more accounts and never activating them (thus
        denying the use of those usernames to anyone else); since
        those accounts will be deleted, the usernames will become
        available for use again.
     
     If you have a troublesome ``User`` and wish to disable their
     account while keeping it in the database, simply delete the
     associated ``RegistrationProfile``; an inactive ``User`` which
     does not have an associated ``RegistrationProfile`` will not
     be deleted.
     
     """
     for profile in self.all():
         try:
             if profile.activation_key_expired():
                 user = profile.user
                 if not user.is_active:
                     user.delete()
                     profile.delete()
         except get_user_model().DoesNotExist:
             profile.delete()
コード例 #21
0
 def delete_expired_users(self):
     """
     Remove expired instances of ``RegistrationProfile`` and their
     associated ``User``s.
     
     Accounts to be deleted are identified by searching for
     instances of ``RegistrationProfile`` with expired activation
     keys, and then checking to see if their associated ``User``
     instances have the field ``is_active`` set to ``False``; any
     ``User`` who is both inactive and has an expired activation
     key will be deleted.
     
     It is recommended that this method be executed regularly as
     part of your routine site maintenance; this application
     provides a custom management command which will call this
     method, accessible as ``manage.py cleanupregistration``.
     
     Regularly clearing out accounts which have never been
     activated serves two useful purposes:
     
     1. It alleviates the ocasional need to reset a
        ``RegistrationProfile`` and/or re-send an activation email
        when a user does not receive or does not act upon the
        initial activation email; since the account will be
        deleted, the user will be able to simply re-register and
        receive a new activation key.
     
     2. It prevents the possibility of a malicious user registering
        one or more accounts and never activating them (thus
        denying the use of those usernames to anyone else); since
        those accounts will be deleted, the usernames will become
        available for use again.
     
     If you have a troublesome ``User`` and wish to disable their
     account while keeping it in the database, simply delete the
     associated ``RegistrationProfile``; an inactive ``User`` which
     does not have an associated ``RegistrationProfile`` will not
     be deleted.
     
     """
     for profile in self.all():
         try:
             if profile.activation_key_expired():
                 user = profile.user
                 if not user.is_active:
                     user.delete()
                     profile.delete()
         except get_user_model().DoesNotExist:
             profile.delete()
コード例 #22
0
    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 = get_user_model().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")
コード例 #23
0
    def test_untreated_activation(self):
        User = get_user_model()
        new_user = self.backend.register(username='******',
                                         email='*****@*****.**',
                                         request=self.mock_request)

        profile = new_user.registration_profile
        activated_user = self.backend.activate(
            activation_key=profile.activation_key,
            request=self.mock_request,
            password='******')

        self.failIf(activated_user)
        new_user = User.objects.get(pk=new_user.pk)
        self.failIf(new_user.is_active)
        self.failIf(new_user.has_usable_password())
コード例 #24
0
    def test_untreated_activation(self):
        User = get_user_model()
        new_user = self.backend.register(
                username='******', email='*****@*****.**',
                request=self.mock_request)

        profile = new_user.registration_profile
        activated_user = self.backend.activate(
                activation_key=profile.activation_key,
                request=self.mock_request,
                password='******')

        self.failIf(activated_user)
        new_user = User.objects.get(pk=new_user.pk)
        self.failIf(new_user.is_active)
        self.failIf(new_user.has_usable_password())
コード例 #25
0
    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='******',
                                                                        password='******',
                                                                        email='*****@*****.**')
        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, get_user_model().objects.get, username='******')
コード例 #26
0
    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='******',
                                                                        password='******',
                                                                        email='*****@*****.**')
        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, get_user_model().objects.get, username='******')
コード例 #27
0
    def test_expired_activation(self):
        User = get_user_model()
        expired_user = self.backend.register(
                username='******', email='*****@*****.**',
                request=self.mock_request)

        profile = expired_user.registration_profile
        self.backend.accept(profile, request=self.mock_request)

        expired_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS+1)
        expired_user.save()

        activated_user = self.backend.activate(
                activation_key=profile.activation_key,
                request=self.mock_request,
                password='******')

        self.failIf(activated_user)
        expired_user = User.objects.get(pk=expired_user.pk)
        self.failIf(expired_user.is_active)
        self.failIf(expired_user.has_usable_password())
コード例 #28
0
    def create_inactive_user(self, username, email, password,
                             site, send_email=True):
        """
        Create a new, inactive ``User``, generate a
        ``RegistrationProfile`` and email its activation key to the
        ``User``, returning the new ``User``.

        By default, an activation email will be sent to the new
        user. To disable this, pass ``send_email=False``.
        
        """
        new_user = get_user_model().objects.create_user(username, email, password)
        new_user.is_active = False
        new_user.save()

        registration_profile = self.create_profile(new_user)

        if send_email:
            registration_profile.send_activation_email(site)

        return new_user
コード例 #29
0
    def test_expired_activation(self):
        User = get_user_model()
        expired_user = self.backend.register(username='******',
                                             email='*****@*****.**',
                                             request=self.mock_request)

        profile = expired_user.registration_profile
        self.backend.accept(profile, request=self.mock_request)

        expired_user.date_joined -= datetime.timedelta(
            days=settings.ACCOUNT_ACTIVATION_DAYS + 1)
        expired_user.save()

        activated_user = self.backend.activate(
            activation_key=profile.activation_key,
            request=self.mock_request,
            password='******')

        self.failIf(activated_user)
        expired_user = User.objects.get(pk=expired_user.pk)
        self.failIf(expired_user.is_active)
        self.failIf(expired_user.has_usable_password())
コード例 #30
0
    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 = get_user_model().objects.get(username='******')
        self.failIf(new_user.is_active)

        profile = RegistrationProfile.objects.get(user=new_user)
        self.assertNotEqual(profile.activation_key, RegistrationProfile.ACTIVATED)
コード例 #31
0
ファイル: test_forms.py プロジェクト: sogimu/ariadna_services
    def test_registration_form(self):
        """
        Test that ``RegistrationForm`` enforces username constraints
        and matching passwords.

        """
        User = get_user_model()
        # Create a user so we can verify that duplicate usernames aren't
        # permitted.
        User.objects.create_user("alice", "*****@*****.**", "secret")

        invalid_data_dicts = [
            # Non-alphanumeric username.
            {
                "data": {"username": "******", "email1": "*****@*****.**", "email2": "*****@*****.**"},
                "error": ("username", ["This value must contain only letters, numbers and underscores."]),
            },
            # Already-existing username.
            {
                "data": {"username": "******", "email1": "*****@*****.**", "email2": "*****@*****.**"},
                "error": ("username", ["A user with that username already exists."]),
            },
            # Mismatched email.
            {
                "data": {"username": "******", "email1": "*****@*****.**", "email2": "*****@*****.**"},
                "error": ("__all__", ["The two email 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": "******", "email1": "*****@*****.**", "email2": "*****@*****.**"}
        )
        self.failUnless(form.is_valid())
コード例 #32
0
ファイル: test_forms.py プロジェクト: sogimu/ariadna_services
    def test_registration_form_unique_email(self):
        """
        Test that ``RegistrationFormUniqueEmail`` validates uniqueness
        of email addresses.

        """
        User = get_user_model()
        # Create a user so we can verify that duplicate addresses
        # aren't permitted.
        User.objects.create_user("alice", "*****@*****.**", "secret")

        form = forms.RegistrationFormUniqueEmail(
            data={"username": "******", "email1": "*****@*****.**", "email2": "*****@*****.**"}
        )
        self.failIf(form.is_valid())
        self.assertEqual(
            form.errors["email1"], ["This email address is already in use. Please supply a different email address."]
        )

        form = forms.RegistrationFormUniqueEmail(
            data={"username": "******", "email1": "*****@*****.**", "email2": "*****@*****.**"}
        )
        self.failUnless(form.is_valid())
コード例 #33
0
    def test_activation_view_post_success(self):
        """
        A ``POST`` to the ``ActivationView`` view with valid data properly
        handles a valid activation

        """
        User = get_user_model()
        new_user = self.backend.register(username='******', email='*****@*****.**', request=self.mock_request)
        new_user = self.backend.accept(new_user.registration_profile, request=self.mock_request)
    
        activation_url = reverse('registration_activate', kwargs={
            'activation_key': new_user.registration_profile.activation_key})

        response = self.client.post(activation_url,{
            'password1': 'swordfish',
            'password2': 'swordfish'})

        success_redirect = 'http://testserver%s' % reverse('registration_activation_complete')
        self.assertRedirects(response, success_redirect)
        # RegistrationProfile should be removed with activation
        self.assertEqual(RegistrationProfile.objects.count(), 0)
        # registration, acceptance and activation
        self.assertEqual(len(mail.outbox), 3)
        self.failUnless(User.objects.get(username='******').is_active)
コード例 #34
0
    def test_registration(self):
        """
        Registration creates a new account and logs the user in.

        """
        resp = self.client.post(reverse('registration_register'),
                                data={'username': '******',
                                      'email': '*****@*****.**',
                                      'password1': 'secret',
                                      'password2': 'secret'})

        new_user = get_user_model().objects.get(username='******')
        self.assertEqual(302, resp.status_code)
        self.failUnless(new_user.get_absolute_url() in resp['Location'])

        self.failUnless(new_user.check_password('secret'))
        self.assertEqual(new_user.email, '*****@*****.**')

        # New user must be active.
        self.failUnless(new_user.is_active)

        # New user must be logged in.
        resp = self.client.get(reverse('registration_register'))
        self.failUnless(resp.context['user'].is_authenticated())
コード例 #35
0
 def test_get_activation_complete_url(self):
     User = get_user_model()
     fake_user = User()
     url = self.backend.get_activation_complete_url(fake_user)
     self.assertEqual(url, reverse('registration_activation_complete'))
コード例 #36
0
 def test_get_activation_complete_url(self):
     User = get_user_model()
     fake_user = User()
     url = self.backend.get_activation_complete_url(fake_user)
     self.assertEqual(url, reverse('registration_activation_complete'))
コード例 #37
0
    def test_management_command_cleanupregistration(self):
        RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        new_accepted_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        new_rejected_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        expired_untreated_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        expired_accepted_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        expired_rejected_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )

        RegistrationProfile.objects.accept_registration(
            new_accepted_user.registration_profile,
            site=self.mock_site,
        )
        RegistrationProfile.objects.reject_registration(
            new_rejected_user.registration_profile,
            site=self.mock_site,
        )
        RegistrationProfile.objects.accept_registration(
            expired_accepted_user.registration_profile,
            site=self.mock_site,
        )
        RegistrationProfile.objects.reject_registration(
            expired_rejected_user.registration_profile,
            site=self.mock_site,
        )

        delta = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)

        expired_untreated_user.date_joined -= delta
        expired_untreated_user.save()
        expired_accepted_user.date_joined -= delta
        expired_accepted_user.save()
        expired_rejected_user.date_joined -= delta
        expired_rejected_user.save()

        # django-registration compatibility
        management.call_command('cleanupregistration')
        # new_rejected_user, expired rejected_user and expired_accepted_user
        # are deleted
        User = get_user_model()
        self.assertEqual(RegistrationProfile.objects.count(), 3)
        self.assertRaises(User.DoesNotExist,
                          User.objects.get,
                          username='******')
        self.assertRaises(User.DoesNotExist,
                          User.objects.get,
                          username='******')
        self.assertRaises(User.DoesNotExist,
                          User.objects.get,
                          username='******')
コード例 #38
0
    def test_rejected_user_deletion(self):
        RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        new_accepted_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        new_rejected_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        expired_untreated_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        expired_accepted_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )
        expired_rejected_user = RegistrationProfile.objects.register(
            username='******',
            email='*****@*****.**',
            site=self.mock_site,
        )

        RegistrationProfile.objects.accept_registration(
            new_accepted_user.registration_profile,
            site=self.mock_site,
        )
        RegistrationProfile.objects.reject_registration(
            new_rejected_user.registration_profile,
            site=self.mock_site,
        )
        RegistrationProfile.objects.accept_registration(
            expired_accepted_user.registration_profile,
            site=self.mock_site,
        )
        RegistrationProfile.objects.reject_registration(
            expired_rejected_user.registration_profile,
            site=self.mock_site,
        )

        delta = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS + 1)

        expired_untreated_user.date_joined -= delta
        expired_untreated_user.save()
        expired_accepted_user.date_joined -= delta
        expired_accepted_user.save()
        expired_rejected_user.date_joined -= delta
        expired_rejected_user.save()

        RegistrationProfile.objects.delete_rejected_users()
        # new_rejected_user and expired_rejected_user are deleted
        User = get_user_model()
        self.assertEqual(RegistrationProfile.objects.count(), 4)
        self.assertRaises(User.DoesNotExist,
                          User.objects.get,
                          username='******')
        self.assertRaises(User.DoesNotExist,
                          User.objects.get,
                          username='******')
コード例 #39
0
 def create_inactive_user(self):
     User = get_user_model()
     new_user = User.objects.create_user(**self.user_info)
     new_user.set_unusable_password()
     new_user.is_active = False
     return new_user
コード例 #40
0
    def test_expired_user_deletion(self):
        RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        new_accepted_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        new_rejected_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        expired_untreated_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        expired_accepted_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        expired_rejected_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )

        RegistrationProfile.objects.accept_registration(
                new_accepted_user.registration_profile,
                site=self.mock_site,
            )
        RegistrationProfile.objects.reject_registration(
                new_rejected_user.registration_profile,
                site=self.mock_site,
            )
        RegistrationProfile.objects.accept_registration(
                expired_accepted_user.registration_profile,
                site=self.mock_site,
            )
        RegistrationProfile.objects.reject_registration(
                expired_rejected_user.registration_profile,
                site=self.mock_site,
            )

        delta = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS+1)

        expired_untreated_user.date_joined -= delta
        expired_untreated_user.save()
        expired_accepted_user.date_joined -= delta
        expired_accepted_user.save()
        expired_rejected_user.date_joined -= delta
        expired_rejected_user.save()

        RegistrationProfile.objects.delete_expired_users()
        # Only expired accepted user is deleted
        User = get_user_model()
        self.assertEqual(RegistrationProfile.objects.count(), 5)
        self.assertRaises(User.DoesNotExist, User.objects.get, 
                          username='******')
コード例 #41
0
    def test_management_command_cleanupregistration(self):
        RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        new_accepted_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        new_rejected_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        expired_untreated_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        expired_accepted_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )
        expired_rejected_user = RegistrationProfile.objects.register(
                username='******',
                email='*****@*****.**',
                site=self.mock_site,
            )

        RegistrationProfile.objects.accept_registration(
                new_accepted_user.registration_profile,
                site=self.mock_site,
            )
        RegistrationProfile.objects.reject_registration(
                new_rejected_user.registration_profile,
                site=self.mock_site,
            )
        RegistrationProfile.objects.accept_registration(
                expired_accepted_user.registration_profile,
                site=self.mock_site,
            )
        RegistrationProfile.objects.reject_registration(
                expired_rejected_user.registration_profile,
                site=self.mock_site,
            )

        delta = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS+1)

        expired_untreated_user.date_joined -= delta
        expired_untreated_user.save()
        expired_accepted_user.date_joined -= delta
        expired_accepted_user.save()
        expired_rejected_user.date_joined -= delta
        expired_rejected_user.save()

        # django-registration compatibility
        management.call_command('cleanupregistration')
        # new_rejected_user, expired rejected_user and expired_accepted_user are deleted
        User = get_user_model()
        self.assertEqual(RegistrationProfile.objects.count(), 3)
        self.assertRaises(User.DoesNotExist, User.objects.get, 
                          username='******')
        self.assertRaises(User.DoesNotExist, User.objects.get, 
                          username='******')
        self.assertRaises(User.DoesNotExist, User.objects.get, 
                          username='******')
コード例 #42
0
 def create_inactive_user(self):
     User = get_user_model()
     new_user = User.objects.create_user(**self.user_info)
     new_user.set_unusable_password()
     new_user.is_active = False
     return new_user