DefaultRegistrationBackendTestCase - Code Metrics - lambdalisue/django-inspectional-registration - Measure and Improve Code Quality continuously with Scrutinizer

DefaultRegistrationBackendTestCase A
last analyzed 2016-11-13 15:56 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	311
Duplicated Lines	52.73 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	164
loc	311
rs	10
wmc	29

23 Methods

Rating	Name	Duplication	Size	Complexity
A	test_expired_activation()	21	21	1
A	test_rejected_activation()	17	17	1
A	test_activation_without_password()	15	15	1
A	test_rejection()	0	12	1
A	test_get_registration_closed_url()	0	3	1
A	test_rejection_signal()	15	15	2
A	setUp()	0	3	1
A	receiver()	0	4	1
A	test_rejection_signal_fail()	16	16	2
A	test_untreated_activation()	0	16	1
A	test_acceptance_signal_fail()	17	17	2
A	test_get_activation_form_class()	0	3	1
A	test_get_registration_complete_url()	0	5	1
A	test_get_activation_complete_url()	0	5	1
A	test_registration()	0	15	1
A	test_activation_with_password()	17	17	1
A	test_registration_signal()	0	13	2
A	test_acceptance_signal()	15	15	2
A	test_activation_signal()	0	17	2
A	test_allow()	0	8	1
A	test_acceptance()	0	12	1
A	test_get_registration_form_class()	0	3	1
B	test_registration_signal_with_supplement()	31	31	2

How to fix Duplicated Code

# -*- coding: utf-8 -*-
from __future__ import unicode_literals
"""
"""
__author__ = 'Alisue <[email protected]>'
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


class RegistrationBackendRetrievalTests(TestCase):

    def test_get_backend(self):
        backend = get_backend(
                'registration.backends.default.DefaultRegistrationBackend')
        self.failUnless(isinstance(backend, DefaultRegistrationBackend))

    def test_backend_error_invalid(self):
        self.assertRaises(ImproperlyConfigured, get_backend,
                'registration.backends.doesnotexist.NonExistenBackend')

    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'),
    )
class DefaultRegistrationBackendTestCase(TestCase):

    def setUp(self):
        self.backend = DefaultRegistrationBackend()
        self.mock_request = mock_request()


    def test_registration(self):
        new_user = self.backend.register(
                username='bob', email='[email protected]',
                request=self.mock_request)

        self.assertEqual(new_user.username, 'bob')
        self.assertEqual(new_user.email, '[email protected]')

        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)

    def test_acceptance(self):
        new_user = self.backend.register(
                username='bob', email='[email protected]',
                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)

    def test_rejection(self):
        new_user = self.backend.register(
                username='bob', email='[email protected]',
                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)

    def test_activation_with_password(self):

        new_user = self.backend.register(
                username='bob', email='[email protected]',
                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'))

    def test_activation_without_password(self):

        new_user = self.backend.register(
                username='bob', email='[email protected]',
                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())

    def test_untreated_activation(self):
        User = get_user_model()
        new_user = self.backend.register(
                username='bob', email='[email protected]',
                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())

    def test_rejected_activation(self):

        User = get_user_model()
        new_user = self.backend.register(
                username='bob', email='[email protected]',
                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())

    def test_expired_activation(self):

        User = get_user_model()
        expired_user = self.backend.register(
                username='bob', email='[email protected]',
                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())

    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

    def test_get_registration_form_class(self):
        form_class = self.backend.get_registration_form_class()
        self.failUnless(form_class is forms.RegistrationForm)

    def test_get_activation_form_class(self):
        form_class = self.backend.get_activation_form_class()
        self.failUnless(form_class is forms.ActivationForm)

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

    def test_get_registration_closed_url(self):
        url = self.backend.get_registration_closed_url()
        self.assertEqual(url, reverse('registration_disallowed'))

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

    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='[email protected]', 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'),
        )
    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='[email protected]',
            request=self.mock_request,
            supplement=supplement,
        )

        self.assertEqual(len(received_signals), 1)
        self.assertEqual(received_signals, [signals.user_registered])


    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='[email protected]', 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])

    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='[email protected]', 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)

    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='[email protected]', 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])

    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='[email protected]', 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)

    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='[email protected]', 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])



1		# -- coding: utf-8 --
2		from __future__ import unicode_literals
3		"""
4		"""
5		__author__ = 'Alisue <[email protected]>'
6		import datetime
7		from django.test import TestCase
8		from django.conf import settings
9		from django.core import mail
10		from django.core.urlresolvers import reverse
11		from django.core.exceptions import ImproperlyConfigured
12		from registration.compat import get_user_model
13		from registration import forms
14		from registration import signals
15		from registration.backends import get_backend
16		from registration.backends.default import DefaultRegistrationBackend
17		from registration.models import RegistrationProfile
18		from registration.tests.utils import with_apps
19		from registration.tests.mock import mock_request
20		from registration.tests.compat import override_settings
21
22
23		class RegistrationBackendRetrievalTests(TestCase):
24
25		def test_get_backend(self):
26		backend = get_backend(
27		'registration.backends.default.DefaultRegistrationBackend')
28		self.failUnless(isinstance(backend, DefaultRegistrationBackend))
29
30		def test_backend_error_invalid(self):
31		self.assertRaises(ImproperlyConfigured, get_backend,
32		'registration.backends.doesnotexist.NonExistenBackend')
33
34		def test_backend_attribute_error(self):
35		self.assertRaises(ImproperlyConfigured, get_backend,
36		'registration.backends.default.NonexistenBackend')
37
38		@override_settings(
39		ACCOUNT_ACTIVATION_DAYS=7,
40		REGISTRATION_OPEN=True,
41		REGISTRATION_SUPPLEMENT_CLASS=None,
42		REGISTRATION_BACKEND_CLASS=(
43		'registration.backends.default.DefaultRegistrationBackend'),
44		)
45		class DefaultRegistrationBackendTestCase(TestCase):
46
47		def setUp(self):
48		self.backend = DefaultRegistrationBackend()
49		self.mock_request = mock_request()
50
51
52		def test_registration(self):
53		new_user = self.backend.register(
54		username='bob', email='[email protected]',
55		request=self.mock_request)
56
57		self.assertEqual(new_user.username, 'bob')
58		self.assertEqual(new_user.email, '[email protected]')
59
60		self.failIf(new_user.is_active)
61		self.failIf(new_user.has_usable_password())
62
63		# A inspection profile was created, and an registration email
64		# was sent.
65		self.assertEqual(RegistrationProfile.objects.count(), 1)
66		self.assertEqual(len(mail.outbox), 1)
67
68		def test_acceptance(self):
69		new_user = self.backend.register(
70		username='bob', email='[email protected]',
71		request=self.mock_request)
72
73		profile = new_user.registration_profile
74		accepted_user = self.backend.accept(profile, request=self.mock_request)
75
76		self.failUnless(accepted_user)
77		self.assertEqual(profile, accepted_user.registration_profile)
78		self.assertEqual(profile.status, 'accepted')
79		self.assertNotEqual(profile.activation_key, None)
80
81		def test_rejection(self):
82		new_user = self.backend.register(
83		username='bob', email='[email protected]',
84		request=self.mock_request)
85
86		profile = new_user.registration_profile
87		rejected_user = self.backend.reject(profile, request=self.mock_request)
88
89		self.failUnless(rejected_user)
90		self.assertEqual(profile, rejected_user.registration_profile)
91		self.assertEqual(profile.status, 'rejected')
92		self.assertEqual(profile.activation_key, None)
93
94	View Code Duplication	def test_activation_with_password(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
95		new_user = self.backend.register(
96		username='bob', email='[email protected]',
97		request=self.mock_request)
98
99		profile = new_user.registration_profile
100		self.backend.accept(profile, request=self.mock_request)
101		activated_user = self.backend.activate(
102		activation_key=profile.activation_key,
103		request=self.mock_request,
104		password='swardfish')
105
106		self.failUnless(activated_user)
107		self.assertEqual(activated_user, new_user)
108		self.failUnless(activated_user.is_active)
109		self.failUnless(activated_user.has_usable_password())
110		self.failUnless(activated_user.check_password('swardfish'))
111
112	View Code Duplication	def test_activation_without_password(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
113		new_user = self.backend.register(
114		username='bob', email='[email protected]',
115		request=self.mock_request)
116
117		profile = new_user.registration_profile
118		self.backend.accept(profile, request=self.mock_request)
119		activated_user = self.backend.activate(
120		activation_key=profile.activation_key,
121		request=self.mock_request)
122
123		self.failUnless(activated_user)
124		self.assertEqual(activated_user, new_user)
125		self.failUnless(activated_user.is_active)
126		self.failUnless(activated_user.has_usable_password())
127
128		def test_untreated_activation(self):
129		User = get_user_model()
130		new_user = self.backend.register(
131		username='bob', email='[email protected]',
132		request=self.mock_request)
133
134		profile = new_user.registration_profile
135		activated_user = self.backend.activate(
136		activation_key=profile.activation_key,
137		request=self.mock_request,
138		password='swardfish')
139
140		self.failIf(activated_user)
141		new_user = User.objects.get(pk=new_user.pk)
142		self.failIf(new_user.is_active)
143		self.failIf(new_user.has_usable_password())
144
145	View Code Duplication	def test_rejected_activation(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
146		User = get_user_model()
147		new_user = self.backend.register(
148		username='bob', email='[email protected]',
149		request=self.mock_request)
150
151		profile = new_user.registration_profile
152		self.backend.reject(profile, request=self.mock_request)
153		activated_user = self.backend.activate(
154		activation_key=profile.activation_key,
155		request=self.mock_request,
156		password='swardfish')
157
158		self.failIf(activated_user)
159		new_user = User.objects.get(pk=new_user.pk)
160		self.failIf(new_user.is_active)
161		self.failIf(new_user.has_usable_password())
162
163	View Code Duplication	def test_expired_activation(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
164		User = get_user_model()
165		expired_user = self.backend.register(
166		username='bob', email='[email protected]',
167		request=self.mock_request)
168
169		profile = expired_user.registration_profile
170		self.backend.accept(profile, request=self.mock_request)
171
172		expired_user.date_joined -= datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS+1)
173		expired_user.save()
174
175		activated_user = self.backend.activate(
176		activation_key=profile.activation_key,
177		request=self.mock_request,
178		password='swardfish')
179
180		self.failIf(activated_user)
181		expired_user = User.objects.get(pk=expired_user.pk)
182		self.failIf(expired_user.is_active)
183		self.failIf(expired_user.has_usable_password())
184
185		def test_allow(self):
186		old_allowed = settings.REGISTRATION_OPEN
187		settings.REGISTRATION_OPEN = True
188		self.failUnless(self.backend.registration_allowed())
189
190		settings.REGISTRATION_OPEN = False
191		self.failIf(self.backend.registration_allowed())
192		settings.REGISTRATION_OPEN = old_allowed
193
194		def test_get_registration_form_class(self):
195		form_class = self.backend.get_registration_form_class()
196		self.failUnless(form_class is forms.RegistrationForm)
197
198		def test_get_activation_form_class(self):
199		form_class = self.backend.get_activation_form_class()
200		self.failUnless(form_class is forms.ActivationForm)
201
202		def test_get_registration_complete_url(self):
203		User = get_user_model()
204		fake_user = User()
205		url = self.backend.get_registration_complete_url(fake_user)
206		self.assertEqual(url, reverse('registration_complete'))
207
208		def test_get_registration_closed_url(self):
209		url = self.backend.get_registration_closed_url()
210		self.assertEqual(url, reverse('registration_disallowed'))
211
212		def test_get_activation_complete_url(self):
213		User = get_user_model()
214		fake_user = User()
215		url = self.backend.get_activation_complete_url(fake_user)
216		self.assertEqual(url, reverse('registration_activation_complete'))
217
218		def test_registration_signal(self):
219		def receiver(sender, user, profile, **kwargs):
220		self.assertEqual(user.username, 'bob')
221		self.assertEqual(user.registration_profile, profile)
222		received_signals.append(kwargs.get('signal'))
223
224		received_signals = []
225		signals.user_registered.connect(receiver, sender=self.backend.__class__)
226
227		self.backend.register(username='bob', email='[email protected]', request=self.mock_request)
228
229		self.assertEqual(len(received_signals), 1)
230		self.assertEqual(received_signals, [signals.user_registered])
231
232	View Code Duplication	@with_apps(
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
233		'django.contrib.contenttypes',
234		'registration.supplements.default'
235		)
236		@override_settings(
237		REGISTRATION_SUPPLEMENT_CLASS=(
238		'registration.supplements.default.models.DefaultRegistrationSupplement'),
239		)
240		def test_registration_signal_with_supplement(self):
241		from registration.supplements.default.models import DefaultRegistrationSupplement
242		supplement = DefaultRegistrationSupplement(remarks='foo')
243
244		def receiver(sender, user, profile, **kwargs):
245		self.assertEqual(user.username, 'bob')
246		self.assertEqual(user.registration_profile, profile)
247		self.assertEqual(user.registration_profile.supplement,
248		profile.supplement)
249		self.assertEqual(profile.supplement.remarks, 'foo')
250		received_signals.append(kwargs.get('signal'))
251
252		received_signals = []
253		signals.user_registered.connect(receiver, sender=self.backend.__class__)
254
255		self.backend.register(
256		username='bob', email='[email protected]',
257		request=self.mock_request,
258		supplement=supplement,
259		)
260
261		self.assertEqual(len(received_signals), 1)
262		self.assertEqual(received_signals, [signals.user_registered])
263
264
265	View Code Duplication	def test_acceptance_signal(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
266		def receiver(sender, user, profile, **kwargs):
267		self.assertEqual(user.username, 'bob')
268		self.assertEqual(user.registration_profile, profile)
269		received_signals.append(kwargs.get('signal'))
270
271		received_signals = []
272		signals.user_accepted.connect(receiver, sender=self.backend.__class__)
273
274		self.backend.register(username='bob', email='[email protected]', request=self.mock_request)
275		profile = RegistrationProfile.objects.get(user__username='bob')
276		self.backend.accept(profile, request=self.mock_request)
277
278		self.assertEqual(len(received_signals), 1)
279		self.assertEqual(received_signals, [signals.user_accepted])
280
281	View Code Duplication	def test_acceptance_signal_fail(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
282		def receiver(sender, user, profile, **kwargs):
283		self.assertEqual(user.username, 'bob')
284		self.assertEqual(user.registration_profile, profile)
285		received_signals.append(kwargs.get('signal'))
286
287		received_signals = []
288
289		self.backend.register(username='bob', email='[email protected]', request=self.mock_request)
290		profile = RegistrationProfile.objects.get(user__username='bob')
291		self.backend.accept(profile, request=self.mock_request)
292
293		signals.user_accepted.connect(receiver, sender=self.backend.__class__)
294		# accept -> accept is not allowed thus fail
295		self.backend.accept(profile, request=self.mock_request)
296
297		self.assertEqual(len(received_signals), 0)
298
299	View Code Duplication	def test_rejection_signal(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
300		def receiver(sender, user, profile, **kwargs):
301		self.assertEqual(user.username, 'bob')
302		self.assertEqual(user.registration_profile, profile)
303		received_signals.append(kwargs.get('signal'))
304
305		received_signals = []
306		signals.user_rejected.connect(receiver, sender=self.backend.__class__)
307
308		self.backend.register(username='bob', email='[email protected]', request=self.mock_request)
309		profile = RegistrationProfile.objects.get(user__username='bob')
310		self.backend.reject(profile, request=self.mock_request)
311
312		self.assertEqual(len(received_signals), 1)
313		self.assertEqual(received_signals, [signals.user_rejected])
314
315	View Code Duplication	def test_rejection_signal_fail(self):
		0 ignored issues – show Duplication introduced 2016-04-27 00:22 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
316		def receiver(sender, user, profile, **kwargs):
317		self.assertEqual(user.username, 'bob')
318		self.assertEqual(user.registration_profile, profile)
319		received_signals.append(kwargs.get('signal'))
320
321		received_signals = []
322		signals.user_rejected.connect(receiver, sender=self.backend.__class__)
323
324		self.backend.register(username='bob', email='[email protected]', request=self.mock_request)
325		profile = RegistrationProfile.objects.get(user__username='bob')
326		self.backend.accept(profile, request=self.mock_request)
327		# accept -> reject is not allowed
328		self.backend.reject(profile, request=self.mock_request)
329
330		self.assertEqual(len(received_signals), 0)
331
332		def test_activation_signal(self):
333		def receiver(sender, user, password, is_generated, **kwargs):
334		self.assertEqual(user.username, 'bob')
335		self.assertEqual(password, 'swordfish')
336		self.failIf(is_generated)
337		received_signals.append(kwargs.get('signal'))
338
339		received_signals = []
340		signals.user_activated.connect(receiver, sender=self.backend.__class__)
341
342		self.backend.register(username='bob', email='[email protected]', request=self.mock_request)
343		profile = RegistrationProfile.objects.get(user__username='bob')
344		self.backend.accept(profile, request=self.mock_request)
345		self.backend.activate(profile.activation_key, request=self.mock_request, password='swordfish')
346
347		self.assertEqual(len(received_signals), 1)
348		self.assertEqual(received_signals, [signals.user_activated])
349
350

lambdalisue / django-inspectional-registration

GitHub Access Token became invalid

DefaultRegistrationBackendTestCase A last analyzed 2016-11-13 15:56 UTC

Complexity

Size/Duplication

Importance

23 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like

DefaultRegistrationBackendTestCase A
last analyzed 2016-11-13 15:56 UTC