def test_cannot_register_a_class_which_is_not_an_action(self):
# Setup
actions_count_before = len(actions.get_actions())
# Run & check
with pytest.raises(ImproperlyConfigured):
actions.register(type('BadClass'))
assert len(actions.get_actions()) == actions_count_before
def test_cannot_register_a_class_which_is_not_an_action(self):
# Setup
actions_count_before = len(actions.get_actions())
# Run & check
with pytest.raises(ImproperlyConfigured):
actions.register(type('BadClass'))
assert len(actions.get_actions()) == actions_count_before
def test_can_execute_the_action_after_consumption(self):
# Setup
actions.register(TestExecuteAction)
token = AccountActionTokenFactory.create(action='test-execute')
user = User.objects.create_user(
username='******', password='******', email='*****@*****.**')
# Run & check
token.consume(user)
assert execute_called
def test_triggers_the_appropriate_signal_on_consumption(self):
# Setup
user = User.objects.create_user(
username='******', password='******', email='*****@*****.**')
token = AccountActionTokenFactory.create(action='test-signal-action')
actions.register(TestSignalAction)
# Run & check
token.consume(user)
assert test_signal == 1
def test_can_register_simple_actions(self):
# Setup
actions_count_before = len(actions.get_actions())
# Run
actions.register(SimpleAction)
# Check
assert len(actions.get_actions()) == actions_count_before + 1
assert SimpleAction.name in actions._registry
assert isinstance(actions._registry[SimpleAction.name], SimpleAction)
def test_can_register_simple_actions(self):
# Setup
actions_count_before = len(actions.get_actions())
# Run
actions.register(SimpleAction)
# Check
assert len(actions.get_actions()) == actions_count_before + 1
assert SimpleAction.name in actions._registry
assert isinstance(actions._registry[SimpleAction.name], SimpleAction)
def test_triggers_the_appropriate_signal_on_consumption(self):
# Setup
user = User.objects.create_user(username='******',
password='******',
email='*****@*****.**')
token = AccountActionTokenFactory.create(action='test-signal-action')
actions.register(TestSignalAction)
# Run & check
token.consume(user)
assert test_signal == 1
def test_should_raise_if_an_action_is_registered_twice(self):
# Setup
actions_count_before = len(actions.get_actions())
actions.register(SimpleAction)
# Run & check
with pytest.raises(ActionAlreadyRegistered):
actions.register(SimpleAction)
actions.unregister_all()
actions_count_after = len(actions.get_actions())
assert actions_count_before == actions_count_after
def test_should_raise_if_an_action_is_registered_twice(self):
# Setup
actions_count_before = len(actions.get_actions())
actions.register(SimpleAction)
# Run & check
with pytest.raises(ActionAlreadyRegistered):
actions.register(SimpleAction)
actions.unregister_all()
actions_count_after = len(actions.get_actions())
assert actions_count_before == actions_count_after
def test_return_an_http_403_error_if_the_user_is_already_authenticated(self):
# Setup
actions.register(TestAction)
token = AccountActionTokenFactory.create(action='test-register')
self.client.login(username='******', password='******')
url = reverse('public:account_actions:register', kwargs={'key': token.key})
# Run
response = self.client.get(url)
# Check
self.assertEqual(response.status_code, 403)
def test_return_an_http_403_error_if_the_user_is_not_authenticated(self):
# Setup
actions.register(Action1)
token = AccountActionTokenFactory.create(action='action-1')
request = self.factory.post('/')
request.user = AnonymousUser()
view = AccountActionConsumeView.as_view()
# Run & check
with pytest.raises(PermissionDenied):
view(request, key=token.key)
def test_return_an_http_403_error_if_the_token_cannot_be_consumed(self):
# Setup
actions.register(TestAction)
token = AccountActionTokenFactory.create(action='test-register')
token.consume(self.user)
self.client.logout()
url = reverse('public:account_actions:register', kwargs={'key': token.key})
# Run
response = self.client.get(url)
# Check
self.assertEqual(response.status_code, 403)
def test_return_an_http_403_error_if_the_token_is_canceled(self):
# Setup
actions.register(Action1)
token = AccountActionTokenFactory.create(action='action-1', is_canceled=True)
user = User.objects.create_user(
username='******', password='******', email='*****@*****.**')
request = self.factory.post('/')
request.user = user
view = AccountActionConsumeView.as_view()
# Run & check
with pytest.raises(PermissionDenied):
view(request, key=token.key)
def test_can_properly_consume_the_token(self):
# Setup
actions.register(TestAction)
token = AccountActionTokenFactory.create(action='test-consumed')
form_data = {
'username': faker.simple_profile().get('username'),
'email': faker.email(),
'first_name': faker.first_name(),
'last_name': faker.last_name(),
'password1': 'not_secret',
'password2': 'not_secret',
}
# Run & check
form = AccountActionRegisterForm(form_data, token=token)
self.assertTrue(form.is_valid())
form.save()
global consumed
self.assertTrue(consumed)
def test_can_properly_consume_the_token(self):
# Setup
actions.register(TestAction)
token = AccountActionTokenFactory.create(action='test-consumed')
form_data = {
'username': faker.simple_profile().get('username'),
'email': faker.email(),
'first_name': faker.first_name(),
'last_name': faker.last_name(),
'password1': 'not_secret',
'password2': 'not_secret',
}
# Run & check
form = AccountActionRegisterForm(form_data, token=token)
self.assertTrue(form.is_valid())
form.save()
global consumed
self.assertTrue(consumed)
def test_can_use_the_template_specified_in_the_action_configuration(self):
# Setup
actions.register(Action2)
token = AccountActionTokenFactory.create(action='action-2')
user = User.objects.create_user(
username='******', password='******', email='*****@*****.**')
request = self.factory.get('/')
request.user = user
view = AccountActionLandingView.as_view()
# Run
response = view(request, key=token.key)
# Check
assert response.status_code == 200
assert response.template_name == ['action-2.html', ]
def test_embeds_the_action_configuration_into_the_context(self):
# Setup
actions.register(Action1)
token = AccountActionTokenFactory.create(action='action-1')
user = User.objects.create_user(
username='******', password='******', email='*****@*****.**')
request = self.factory.get('/')
request.user = user
view = AccountActionLandingView.as_view()
# Run
response = view(request, key=token.key)
# Check
assert response.status_code == 200
assert isinstance(response.context_data['action'], Action1)
def test_can_properly_create_a_new_user(self):
# Setup
actions.register(TestAction)
token = AccountActionTokenFactory.create(action='test-register')
post_data = {
'username': faker.simple_profile().get('username'),
'email': faker.email(),
'first_name': faker.first_name(),
'last_name': faker.last_name(),
'password1': 'not_secret',
'password2': 'not_secret',
}
self.client.logout()
url = reverse('public:account_actions:register', kwargs={'key': token.key})
# Run
response = self.client.post(url, post_data, follow=False)
# Check
self.assertEqual(response.status_code, 302)
self.assertTrue(User.objects.filter(username=post_data['username']))
def test_can_consume_an_action_token(self):
# Setup
actions.register(Action1)
token = AccountActionTokenFactory.create(action='action-1')
user = User.objects.create_user(
username='******', password='******', email='*****@*****.**')
session_middleware = SessionMiddleware()
message_middleware = MessageMiddleware()
request = self.factory.post('/')
session_middleware.process_request(request)
message_middleware.process_request(request)
request.user = user
view = AccountActionConsumeView.as_view()
# Run
response = view(request, key=token.key)
# Check
assert response.status_code == 302
token.refresh_from_db()
assert token.is_consumed
def test_can_send_a_notification_on_token_creation(self):
# Setup
actions.register(TestEmailNotificationAction)
# Run & check
AccountActionTokenFactory.create(action='test-email-notification')
assert email_sent
token.content_object.members.add(token.user)
def get_extra_context(self, token, user):
return {
'member_exists': self._member_exists(token, user),
}
def get_consumption_redirect_url(self, token):
return reverse('public:home')
def get_consumption_success_message(self, token):
return _('Votre êtes maintenant membre de cette organisation ({org})').format(
org=token.content_object.name)
def send_notification_email(self, token):
email = Email(
[token.email, ],
html_template='emails/organisation/new_member_content.html',
subject_template='emails/organisation/new_member_subject.html',
extra_context={'token': token})
email.send()
def _member_exists(self, token, user):
if user.is_authenticated():
return token.content_object.members.filter(pk=user.pk).exists()
else:
return False
actions.register(OrganisationMembershipAction)
def get_extra_context(self, token, user):
return {
'subscription_exists': self._subscription_exists(token, user),
}
def get_consumption_redirect_url(self, token):
return reverse('public:journal:journal_detail', kwargs={'code': token.content_object.code})
def get_consumption_success_message(self, token):
return _('Votre abonnement a bien été pris en compte')
def send_notification_email(self, token):
email = Email(
[token.email, ],
html_template='emails/subscription/journal/new_subscription_content.html',
subject_template='emails/subscription/journal/new_subscription_subject.html',
extra_context={'token': token})
email.send()
def _subscription_exists(self, token, user):
if user.is_authenticated():
# Computes a boolean indicating if a subscription already exists for the current user.
return JournalAccessSubscription.objects.filter(
user_id=user.id, journal_id=token.object_id).exists()
else:
return False
actions.register(IndividualSubscriptionAction)
def get_consumption_redirect_url(self, token):
return reverse('public:journal:journal_detail',
kwargs={'code': token.content_object.code})
def get_consumption_success_message(self, token):
return _('Votre abonnement a bien été pris en compte')
def send_notification_email(self, token):
email = Email(
[
token.email,
],
html_template=
'emails/subscription/journal/new_subscription_content.html',
subject_template=
'emails/subscription/journal/new_subscription_subject.html',
extra_context={'token': token})
email.send()
def _subscription_exists(self, token, user):
if user.is_authenticated():
# Computes a boolean indicating if a subscription already exists for the current user.
return JournalAccessSubscription.objects.filter(
user_id=user.id, journal_id=token.object_id).exists()
else:
return False
actions.register(IndividualSubscriptionAction)
