# -*- coding: utf-8 -*-
from __future__ import unicode_literals
"""
"""
__author__ = 'Alisue <lambdalisue@hashnote.net>'
import datetime
from django.test import TestCase
from django.conf import settings
from django.core import mail
from django.core.urlresolvers import reverse
from django.core.exceptions import ImproperlyConfigured
from registration.compat import get_user_model
from registration import forms
from registration import signals
from registration.backends import get_backend
from registration.backends.default import DefaultRegistrationBackend
from registration.models import RegistrationProfile
from registration.tests.utils import with_apps
from registration.tests.mock import mock_request
from registration.tests.compat import override_settings
[docs]class RegistrationBackendRetrievalTests(TestCase):
[docs] def test_get_backend(self):
backend = get_backend(
'registration.backends.default.DefaultRegistrationBackend')
self.failUnless(isinstance(backend, DefaultRegistrationBackend))
[docs] def test_backend_error_invalid(self):
self.assertRaises(ImproperlyConfigured, get_backend,
'registration.backends.doesnotexist.NonExistenBackend')
[docs] def test_backend_attribute_error(self):
self.assertRaises(ImproperlyConfigured, get_backend,
'registration.backends.default.NonexistenBackend')
@override_settings(
ACCOUNT_ACTIVATION_DAYS=7,
REGISTRATION_OPEN=True,
REGISTRATION_SUPPLEMENT_CLASS=None,
REGISTRATION_BACKEND_CLASS=(
'registration.backends.default.DefaultRegistrationBackend'),
)
[docs]class DefaultRegistrationBackendTestCase(TestCase):
[docs] def setUp(self):
self.backend = DefaultRegistrationBackend()
self.mock_request = mock_request()
[docs] def test_registration(self):
new_user = self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request)
self.assertEqual(new_user.username, 'bob')
self.assertEqual(new_user.email, 'bob@example.com')
self.failIf(new_user.is_active)
self.failIf(new_user.has_usable_password())
# A inspection profile was created, and an registration email
# was sent.
self.assertEqual(RegistrationProfile.objects.count(), 1)
self.assertEqual(len(mail.outbox), 1)
[docs] def test_acceptance(self):
new_user = self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request)
profile = new_user.registration_profile
accepted_user = self.backend.accept(profile, request=self.mock_request)
self.failUnless(accepted_user)
self.assertEqual(profile, accepted_user.registration_profile)
self.assertEqual(profile.status, 'accepted')
self.assertNotEqual(profile.activation_key, None)
[docs] def test_rejection(self):
new_user = self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request)
profile = new_user.registration_profile
rejected_user = self.backend.reject(profile, request=self.mock_request)
self.failUnless(rejected_user)
self.assertEqual(profile, rejected_user.registration_profile)
self.assertEqual(profile.status, 'rejected')
self.assertEqual(profile.activation_key, None)
[docs] def test_activation_with_password(self):
new_user = self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request)
profile = new_user.registration_profile
self.backend.accept(profile, request=self.mock_request)
activated_user = self.backend.activate(
activation_key=profile.activation_key,
request=self.mock_request,
password='swardfish')
self.failUnless(activated_user)
self.assertEqual(activated_user, new_user)
self.failUnless(activated_user.is_active)
self.failUnless(activated_user.has_usable_password())
self.failUnless(activated_user.check_password('swardfish'))
[docs] def test_activation_without_password(self):
new_user = self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request)
profile = new_user.registration_profile
self.backend.accept(profile, request=self.mock_request)
activated_user = self.backend.activate(
activation_key=profile.activation_key,
request=self.mock_request)
self.failUnless(activated_user)
self.assertEqual(activated_user, new_user)
self.failUnless(activated_user.is_active)
self.failUnless(activated_user.has_usable_password())
[docs] def test_untreated_activation(self):
User = get_user_model()
new_user = self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request)
profile = new_user.registration_profile
activated_user = self.backend.activate(
activation_key=profile.activation_key,
request=self.mock_request,
password='swardfish')
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())
[docs] def test_rejected_activation(self):
User = get_user_model()
new_user = self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request)
profile = new_user.registration_profile
self.backend.reject(profile, request=self.mock_request)
activated_user = self.backend.activate(
activation_key=profile.activation_key,
request=self.mock_request,
password='swardfish')
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())
[docs] def test_expired_activation(self):
User = get_user_model()
expired_user = self.backend.register(
username='bob', email='bob@example.com',
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='swardfish')
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())
[docs] def test_allow(self):
old_allowed = settings.REGISTRATION_OPEN
settings.REGISTRATION_OPEN = True
self.failUnless(self.backend.registration_allowed())
settings.REGISTRATION_OPEN = False
self.failIf(self.backend.registration_allowed())
settings.REGISTRATION_OPEN = old_allowed
[docs] def test_get_registration_complete_url(self):
User = get_user_model()
fake_user = User()
url = self.backend.get_registration_complete_url(fake_user)
self.assertEqual(url, reverse('registration_complete'))
[docs] def test_get_registration_closed_url(self):
url = self.backend.get_registration_closed_url()
self.assertEqual(url, reverse('registration_disallowed'))
[docs] 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'))
[docs] def test_registration_signal(self):
def receiver(sender, user, profile, **kwargs):
self.assertEqual(user.username, 'bob')
self.assertEqual(user.registration_profile, profile)
received_signals.append(kwargs.get('signal'))
received_signals = []
signals.user_registered.connect(receiver, sender=self.backend.__class__)
self.backend.register(username='bob', email='bob@example.com', request=self.mock_request)
self.assertEqual(len(received_signals), 1)
self.assertEqual(received_signals, [signals.user_registered])
@with_apps(
'django.contrib.contenttypes',
'registration.supplements.default'
)
@override_settings(
REGISTRATION_SUPPLEMENT_CLASS=(
'registration.supplements.default.models.DefaultRegistrationSupplement'),
)
[docs] def test_registration_signal_with_supplement(self):
from registration.supplements.default.models import DefaultRegistrationSupplement
supplement = DefaultRegistrationSupplement(remarks='foo')
def receiver(sender, user, profile, **kwargs):
self.assertEqual(user.username, 'bob')
self.assertEqual(user.registration_profile, profile)
self.assertEqual(user.registration_profile.supplement,
profile.supplement)
self.assertEqual(profile.supplement.remarks, 'foo')
received_signals.append(kwargs.get('signal'))
received_signals = []
signals.user_registered.connect(receiver, sender=self.backend.__class__)
self.backend.register(
username='bob', email='bob@example.com',
request=self.mock_request,
supplement=supplement,
)
self.assertEqual(len(received_signals), 1)
self.assertEqual(received_signals, [signals.user_registered])
[docs] def test_acceptance_signal(self):
def receiver(sender, user, profile, **kwargs):
self.assertEqual(user.username, 'bob')
self.assertEqual(user.registration_profile, profile)
received_signals.append(kwargs.get('signal'))
received_signals = []
signals.user_accepted.connect(receiver, sender=self.backend.__class__)
self.backend.register(username='bob', email='bob@example.com', request=self.mock_request)
profile = RegistrationProfile.objects.get(user__username='bob')
self.backend.accept(profile, request=self.mock_request)
self.assertEqual(len(received_signals), 1)
self.assertEqual(received_signals, [signals.user_accepted])
[docs] def test_acceptance_signal_fail(self):
def receiver(sender, user, profile, **kwargs):
self.assertEqual(user.username, 'bob')
self.assertEqual(user.registration_profile, profile)
received_signals.append(kwargs.get('signal'))
received_signals = []
self.backend.register(username='bob', email='bob@example.com', request=self.mock_request)
profile = RegistrationProfile.objects.get(user__username='bob')
self.backend.accept(profile, request=self.mock_request)
signals.user_accepted.connect(receiver, sender=self.backend.__class__)
# accept -> accept is not allowed thus fail
self.backend.accept(profile, request=self.mock_request)
self.assertEqual(len(received_signals), 0)
[docs] def test_rejection_signal(self):
def receiver(sender, user, profile, **kwargs):
self.assertEqual(user.username, 'bob')
self.assertEqual(user.registration_profile, profile)
received_signals.append(kwargs.get('signal'))
received_signals = []
signals.user_rejected.connect(receiver, sender=self.backend.__class__)
self.backend.register(username='bob', email='bob@example.com', request=self.mock_request)
profile = RegistrationProfile.objects.get(user__username='bob')
self.backend.reject(profile, request=self.mock_request)
self.assertEqual(len(received_signals), 1)
self.assertEqual(received_signals, [signals.user_rejected])
[docs] def test_rejection_signal_fail(self):
def receiver(sender, user, profile, **kwargs):
self.assertEqual(user.username, 'bob')
self.assertEqual(user.registration_profile, profile)
received_signals.append(kwargs.get('signal'))
received_signals = []
signals.user_rejected.connect(receiver, sender=self.backend.__class__)
self.backend.register(username='bob', email='bob@example.com', request=self.mock_request)
profile = RegistrationProfile.objects.get(user__username='bob')
self.backend.accept(profile, request=self.mock_request)
# accept -> reject is not allowed
self.backend.reject(profile, request=self.mock_request)
self.assertEqual(len(received_signals), 0)
[docs] def test_activation_signal(self):
def receiver(sender, user, password, is_generated, **kwargs):
self.assertEqual(user.username, 'bob')
self.assertEqual(password, 'swordfish')
self.failIf(is_generated)
received_signals.append(kwargs.get('signal'))
received_signals = []
signals.user_activated.connect(receiver, sender=self.backend.__class__)
self.backend.register(username='bob', email='bob@example.com', request=self.mock_request)
profile = RegistrationProfile.objects.get(user__username='bob')
self.backend.accept(profile, request=self.mock_request)
self.backend.activate(profile.activation_key, request=self.mock_request, password='swordfish')
self.assertEqual(len(received_signals), 1)
self.assertEqual(received_signals, [signals.user_activated])