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)
