def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save()
class InvitationTests(TestCase): fixtures = ['users.json', 'orgs.json'] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import invitation_backend self.assertTrue(isinstance(invitation_backend(), InvitationBackend)) def test_create_user(self): invited = InvitationBackend().invite_by_email("*****@*****.**") self.assertTrue(isinstance(invited, User)) self.assertFalse(invited.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): invited = InvitationBackend().invite_by_email(self.user.email) self.assertEqual(self.user, invited) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): InvitationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) InvitationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): """Ensure no error is raised""" reverse('invitations_register', kwargs={ 'user_id': self.pending_user.id, 'token': self.tokenizer.make_token(self.pending_user) }) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): InvitationBackend().activate_view( request, self.user.id, self.tokenizer.make_token(self.user)) self.assertEqual( 200, InvitationBackend().activate_view( request, self.pending_user.id, self.tokenizer.make_token(self.pending_user)).status_code)
class InvitationTests(TestCase): fixtures = ['users.json', 'orgs.json'] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import invitation_backend self.assertTrue(isinstance(invitation_backend(), InvitationBackend)) def test_create_user(self): invited = InvitationBackend().invite_by_email("*****@*****.**") self.assertTrue(isinstance(invited, User)) self.assertFalse(invited.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): invited = InvitationBackend().invite_by_email(self.user.email) self.assertEqual(self.user, invited) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): InvitationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) InvitationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): """Ensure no error is raised""" reverse('invitations_register', kwargs={ 'user_id': self.pending_user.id, 'token': self.tokenizer.make_token(self.pending_user)}) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): InvitationBackend().activate_view(request, self.user.id, self.tokenizer.make_token(self.user)) self.assertEqual(200, InvitationBackend().activate_view(request, self.pending_user.id, self.tokenizer.make_token( self.pending_user)).status_code)
def activate_view(self, request, user_id, token): """ View function that activates the given User by setting `is_active` to true if the provided information is verified. """ try: user = self.user_model.objects.get(id=user_id, is_active=False) except self.user_model.DoesNotExist: raise Http404(_("Your URL may have expired.")) if not RegistrationTokenGenerator().check_token(user, token): raise Http404(_("Your URL may have expired.")) form = self.get_form(data=request.POST or None, files=request.FILES or None, instance=user) if form.is_valid(): form.instance.is_active = True user = form.save() user.set_password(form.cleaned_data["password"]) user.save() self.activate_organizations(user) user = authenticate( username=form.cleaned_data["username"], password=form.cleaned_data["password"], ) login(request, user) return redirect(self.get_success_url()) return render(request, self.registration_form_template, {"form": form})
def activate_view(self, request, user_id, token): """ Activates the given User by setting `is_active` to true if the provided information is verified. """ try: user = self.user_model.objects.get(id=user_id, is_active=False) except self.user_model.DoesNotExist: raise Http404(_("Your URL may have expired.")) if not RegistrationTokenGenerator().check_token(user, token): raise Http404(_("Your URL may have expired.")) form = self.get_form(data=request.POST or None, instance=user) if form.is_valid(): form.instance.is_active = True user = form.save() user.set_password(form.cleaned_data['password']) user.save() for org in user.organization_set.filter(is_active=False): org.is_active = True org.save() user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password']) login(request, user) return redirect(self.get_success_url()) return render(request, 'organizations/register_form.html', {'form': form})
def send_reminder(self, user, sender=None, **kwargs): """Sends a reminder email to the specified user""" if user.is_active: return False token = RegistrationTokenGenerator().make_token(user) kwargs.update({'token': token}) self.email_message(user, self.reminder_subject, self.reminder_body, sender, **kwargs).send()
def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save()
class SignupActivateView(SignupMixin, TemplateView): template_name = "aristotle_mdr/users_management/self_invite.html" admin_notification_subject = 'aristotle_mdr/users_management/newuser/email/admin_notification_subject.txt' admin_notification_body = 'aristotle_mdr/users_management/newuser/email/admin_notification_body.html' def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.token_generator = RegistrationTokenGenerator() self.user_model = get_user_model() self.success_redirect = reverse('friendly_login') + '?welcome=true' self.users_to_notify = self.user_model.objects.filter( is_superuser=True) def dispatch(self, request, *args, **kwargs): self.get_signup_settings(request) if not self.signup_enabled: return self.signup_disabled_message() return super().dispatch(request, *args, **kwargs) def signup_disabled_message(self): return self.render_to_response( {'error_message': 'Self Signup is not enabled'}) def signup_error_message(self): return self.render_to_response({ 'error_message': 'Account could not be activated', 'resend_button': True }) def notify_of_activation(self, user_email): for user in self.users_to_notify: self.registration_backend.email_message( user, self.admin_notification_subject, self.admin_notification_body, user_email=user_email, config=fetch_aristotle_settings(), ).send() def get(self, request, *args, **kwargs): user_id = self.kwargs.get('user_id', None) token = self.kwargs.get('token', None) if not user_id or not token: return self.signup_error_message() try: user = self.user_model.objects.get(id=user_id, is_active=False) except self.user_model.DoesNotExist: return self.signup_error_message() if self.token_generator.check_token(user, token): user.is_active = True user.save() self.notify_of_activation(user.email) return HttpResponseRedirect(self.success_redirect) return self.signup_error_message()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.token_generator = RegistrationTokenGenerator() self.user_model = get_user_model() self.success_redirect = reverse('friendly_login') + '?welcome=true' self.users_to_notify = self.user_model.objects.filter(is_superuser=True)
class InvitationTests(TestCase): fixtures = ["users.json", "orgs.json"] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import invitation_backend self.assertTrue(isinstance(invitation_backend(), InvitationBackend)) def test_create_user(self): invited = InvitationBackend().invite_by_email("*****@*****.**") self.assertTrue(isinstance(invited, User)) self.assertFalse(invited.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): invited = InvitationBackend().invite_by_email(self.user.email) self.assertEqual(self.user, invited) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): InvitationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) InvitationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): """Ensure no error is raised""" reverse( "invitations_register", kwargs={ "user_id": self.pending_user.pk, "token": self.tokenizer.make_token(self.pending_user), }, ) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): InvitationBackend().activate_view( request, self.user.pk, self.tokenizer.make_token(self.user)) self.assertEqual( 200, InvitationBackend().activate_view( request, self.pending_user.pk, self.tokenizer.make_token(self.pending_user), ).status_code, ) def test_send_notification_inactive_user(self): """ This test verifies that calling the send_notification function from the OrganizationsCoreInvitationBackend with an inactive Django user causes the function to return False without sending an email. """ org = Organization.objects.create(name="Test Organization") result = InvitationBackend().send_notification(self.pending_user, domain="example.com", organization=org, sender=self.user) self.assertEqual(result, False) self.assertEquals(0, len(mail.outbox)) def test_send_notification_active_user(self): """ This test verifies that calling the send_notification function from the OrganizationsCoreInvitationBackend with an active Django user causes the function send an email to that user. """ org = Organization.objects.create(name="Test Organization") InvitationBackend().send_notification(self.user, domain="example.com", organization=org, sender=self.pending_user) self.assertEquals(1, len(mail.outbox)) self.assertEquals(mail.outbox[0].subject, u"You've been added to an organization")
class InvitationTests(TestCase): fixtures = ['users.json', 'orgs.json'] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import invitation_backend self.assertTrue(isinstance(invitation_backend(), InvitationBackend)) def test_create_user(self): invited = InvitationBackend().invite_by_email("*****@*****.**") self.assertTrue(isinstance(invited, User)) self.assertFalse(invited.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): invited = InvitationBackend().invite_by_email(self.user.email) self.assertEqual(self.user, invited) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): InvitationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) InvitationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): """Ensure no error is raised""" reverse('invitations_register', kwargs={ 'user_id': self.pending_user.id, 'token': self.tokenizer.make_token(self.pending_user)}) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): InvitationBackend().activate_view(request, self.user.id, self.tokenizer.make_token(self.user)) self.assertEqual(200, InvitationBackend().activate_view(request, self.pending_user.id, self.tokenizer.make_token(self.pending_user)).status_code) def test_send_notification_inactive_user(self): """ This test verifies that calling the send_notification function from the OrganizationsCoreInvitationBackend with an inactive Django user causes the function to return False without sending an email. """ org = Organization.objects.create(name="Test Organization") result = InvitationBackend().send_notification( self.pending_user, domain='example.com', organization=org, sender=self.user) self.assertEqual(result, False) self.assertEquals(0, len(mail.outbox)) def test_send_notification_active_user(self): """ This test verifies that calling the send_notification function from the OrganizationsCoreInvitationBackend with an active Django user causes the function send an email to that user. """ org = Organization.objects.create(name="Test Organization") InvitationBackend().send_notification( self.user, domain='example.com', organization=org, sender=self.pending_user) self.assertEquals(1, len(mail.outbox)) self.assertEquals( mail.outbox[0].subject, u"You've been added to an organization")
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.token_generator = RegistrationTokenGenerator() self.user_model = get_user_model() self.success_redirect = reverse('friendly_login') + '?welcome=true' self.users_to_notify = self.user_model.objects.filter(is_superuser=True)
class SignupActivateView(SignupMixin, TemplateView): template_name = "aristotle_mdr/users_management/self_invite.html" admin_notification_subject = 'aristotle_mdr/users_management/newuser/email/admin_notification_subject.txt' admin_notification_body = 'aristotle_mdr/users_management/newuser/email/admin_notification_body.html' def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.token_generator = RegistrationTokenGenerator() self.user_model = get_user_model() self.success_redirect = reverse('friendly_login') + '?welcome=true' self.users_to_notify = self.user_model.objects.filter(is_superuser=True) def dispatch(self, request, *args, **kwargs): self.get_signup_settings(request) if not self.signup_enabled: return self.signup_disabled_message() return super().dispatch(request, *args, **kwargs) def signup_disabled_message(self): return self.render_to_response({'error_message': 'Self Signup is not enabled'}) def signup_error_message(self): return self.render_to_response({ 'error_message': 'Account could not be activated', 'resend_button': True }) def notify_of_activation(self, user_email): for user in self.users_to_notify: self.registration_backend.email_message( user, self.admin_notification_subject, self.admin_notification_body, user_email=user_email, config=fetch_aristotle_settings(), ).send() def get(self, request, *args, **kwargs): user_id = self.kwargs.get('user_id', None) token = self.kwargs.get('token', None) if not user_id or not token: return self.signup_error_message() try: user = self.user_model.objects.get(id=user_id, is_active=False) except self.user_model.DoesNotExist: return self.signup_error_message() if self.token_generator.check_token(user, token): user.is_active = True user.save() self.notify_of_activation(user.email) return HttpResponseRedirect(self.success_redirect) return self.signup_error_message()
class RegistrationTests(TestCase): fixtures = ['users.json', 'orgs.json'] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import registration_backend self.assertTrue(isinstance(registration_backend(), RegistrationBackend)) def test_register_authenticated(self): """Ensure an already authenticated user is redirected""" backend = RegistrationBackend() request = request_factory_login(self.factory, self.user) self.assertEqual(302, backend.create_view(request).status_code) def test_register_existing(self): """Ensure that an existing user is redirected to login""" backend = RegistrationBackend() request = request_factory_login(self.factory) request.POST = QueryDict( "name=Mudhoney&slug=mudhoney&[email protected]") self.assertEqual(302, backend.create_view(request).status_code) def test_create_user(self): registered = RegistrationBackend().register_by_email( "*****@*****.**") self.assertTrue(isinstance(registered, User)) self.assertFalse(registered.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): registered = RegistrationBackend().register_by_email(self.user.email) self.assertEqual(self.user, registered) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): RegistrationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) RegistrationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): reverse('registration_register', kwargs={ 'user_id': self.pending_user.id, 'token': self.tokenizer.make_token(self.pending_user) }) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): RegistrationBackend().activate_view( request, self.user.id, self.tokenizer.make_token(self.user)) self.assertEqual( 200, RegistrationBackend().activate_view( request, self.pending_user.id, self.tokenizer.make_token(self.pending_user)).status_code)
class RegistrationTests(TestCase): fixtures = ['users.json', 'orgs.json'] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import registration_backend self.assertTrue(isinstance(registration_backend(), RegistrationBackend)) def test_register_authenticated(self): """Ensure an already authenticated user is redirected""" backend = RegistrationBackend() request = request_factory_login(self.factory, self.user) self.assertEqual(302, backend.create_view(request).status_code) def test_register_existing(self): """Ensure that an existing user is redirected to login""" backend = RegistrationBackend() request = request_factory_login(self.factory) request.POST = QueryDict("name=Mudhoney&slug=mudhoney&[email protected]") self.assertEqual(302, backend.create_view(request).status_code) def test_create_user(self): registered = RegistrationBackend().register_by_email("*****@*****.**") self.assertTrue(isinstance(registered, User)) self.assertFalse(registered.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): registered = RegistrationBackend().register_by_email(self.user.email) self.assertEqual(self.user, registered) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): RegistrationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) RegistrationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): reverse('registration_register', kwargs={ 'user_id': self.pending_user.id, 'token': self.tokenizer.make_token(self.pending_user)}) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): RegistrationBackend().activate_view(request, self.user.id, self.tokenizer.make_token(self.user)) self.assertEqual(200, RegistrationBackend().activate_view(request, self.pending_user.id, self.tokenizer.make_token(self.pending_user)).status_code)
def activate_user(self, token): # token format: <user_id>-<user_token> (ex: 24-5ev-90e516079f1b118c410bh) # user_id: 24 # user_token: 5ev-90e516079f1b118c410bh # Check token format try: user_id = token.split('-')[0] user_token = "-".join(token.split('-')[1:]) except Exception: raise Http404(_("Bad Token")) # Check user and token validity try: user = get_user_model().objects.get(id=user_id, is_active=False) except get_user_model().DoesNotExist: raise Http404(_("Your URL may have expired.")) if not RegistrationTokenGenerator().check_token(user, user_token): raise Http404(_("Your URL may have expired.")) # Collect data from form data = self.data # Override static values data.update({ 'email': user.email, 'profile': user.profile, 'type': user.type, 'created_at': user.created_at, 'updated_at': timezone.now(), }) form = InvitationBackend().get_form( data=data or None, # files=self.FILES or None, instance=user) if form.is_valid(): try: form.instance.is_active = True user = form.save() user.set_password(form.cleaned_data['password']) user.save() InvitationBackend().activate_organizations(user) # Create a personal organization, organization user & owner personal_org = Organization.objects.create(is_active=True, name="Private") personal_org.save() personal_org.slug = "{}-{}".format(personal_org.slug, user.email) personal_org.save() personal_org_user = OrganizationUser.objects.create( user=user, organization=personal_org, is_admin=True) personal_org_user.save() personal_org_owner = OrganizationOwner.objects.create( organization=personal_org, organization_user=personal_org_user) personal_org_owner.save() return JsonResponse({'status': 'success'}, safe=False) except Exception as e: return JsonResponse({ 'status': 'error', 'reason': str(e) }, safe=False) return JsonResponse({'status': 'valid', 'email': user.email}, safe=False)
class RegistrationTests(TestCase): fixtures = ["users.json", "orgs.json"] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user(username="******", email="*****@*****.**", password="******") self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import registration_backend self.assertTrue(isinstance(registration_backend(), RegistrationBackend)) def test_register_authenticated(self): """Ensure an already authenticated user is redirected""" backend = RegistrationBackend() request = request_factory_login(self.factory, self.user) self.assertEqual(302, backend.create_view(request).status_code) def test_register_existing(self): """Ensure that an existing user is redirected to login""" backend = RegistrationBackend() request = request_factory_login(self.factory) request.POST = QueryDict( "name=Mudhoney&slug=mudhoney&[email protected]") self.assertEqual(302, backend.create_view(request).status_code) def test_create_user(self): registered = RegistrationBackend().register_by_email( "*****@*****.**") self.assertTrue(isinstance(registered, User)) self.assertFalse(registered.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): registered = RegistrationBackend().register_by_email(self.user.email) self.assertEqual(self.user, registered) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): RegistrationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) RegistrationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): reverse( "registration_register", kwargs={ "user_id": self.pending_user.pk, "token": self.tokenizer.make_token(self.pending_user), }, ) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): RegistrationBackend().activate_view( request, self.user.pk, self.tokenizer.make_token(self.user)) self.assertEqual( 200, RegistrationBackend().activate_view( request, self.pending_user.pk, self.tokenizer.make_token(self.pending_user), ).status_code, ) def test_activate_orgs(self): """Ensure method activates organizations and w/o specified org_model""" org = Organization.objects.create(name="Test", slug="kjadkjkaj", is_active=False) org.add_user(self.user) self.assertFalse(org.is_active) backend = InvitationBackend() backend.activate_organizations(self.user) refreshed_org = Organization.objects.get(pk=org.pk) self.assertTrue(refreshed_org.is_active)
def get_token(self, user, **kwargs): """Returns a unique token for the given user""" return RegistrationTokenGenerator().make_token(user)
class RegistrationTests(TestCase): fixtures = ["users.json", "orgs.json"] def setUp(self): mail.outbox = [] self.factory = RequestFactory() self.tokenizer = RegistrationTokenGenerator() self.user = User.objects.get(username="******") self.pending_user = User.objects.create_user( username="******", email="*****@*****.**", password="******" ) self.pending_user.is_active = False self.pending_user.save() def test_backend_definition(self): from organizations.backends import registration_backend self.assertTrue(isinstance(registration_backend(), RegistrationBackend)) def test_register_authenticated(self): """Ensure an already authenticated user is redirected""" backend = RegistrationBackend() request = request_factory_login(self.factory, self.user) self.assertEqual(302, backend.create_view(request).status_code) def test_register_existing(self): """Ensure that an existing user is redirected to login""" backend = RegistrationBackend() request = request_factory_login(self.factory) request.POST = QueryDict("name=Mudhoney&slug=mudhoney&[email protected]") self.assertEqual(302, backend.create_view(request).status_code) def test_create_user(self): registered = RegistrationBackend().register_by_email("*****@*****.**") self.assertTrue(isinstance(registered, User)) self.assertFalse(registered.is_active) self.assertEqual(1, len(mail.outbox)) mail.outbox = [] def test_create_existing_user(self): registered = RegistrationBackend().register_by_email(self.user.email) self.assertEqual(self.user, registered) self.assertEqual(0, len(mail.outbox)) # User is active def test_send_reminder(self): RegistrationBackend().send_reminder(self.pending_user) self.assertEqual(1, len(mail.outbox)) RegistrationBackend().send_reminder(self.user) self.assertEqual(1, len(mail.outbox)) # User is active mail.outbox = [] def test_urls(self): reverse( "registration_register", kwargs={ "user_id": self.pending_user.pk, "token": self.tokenizer.make_token(self.pending_user), }, ) def test_activate_user(self): request = self.factory.request() with self.assertRaises(Http404): RegistrationBackend().activate_view( request, self.user.pk, self.tokenizer.make_token(self.user) ) self.assertEqual( 200, RegistrationBackend().activate_view( request, self.pending_user.pk, self.tokenizer.make_token(self.pending_user), ).status_code, ) def test_activate_orgs(self): """Ensure method activates organizations and w/o specified org_model""" org = Organization.objects.create( name="Test", slug="kjadkjkaj", is_active=False ) org.add_user(self.user) self.assertFalse(org.is_active) backend = InvitationBackend() backend.activate_organizations(self.user) refreshed_org = Organization.objects.get(pk=org.pk) self.assertTrue(refreshed_org.is_active)