From 5aee0f01ba79f7d0fdded57068af5a5e49a16db5 Mon Sep 17 00:00:00 2001 From: Nick Smith Date: Tue, 8 Jul 2014 12:59:47 +0100 Subject: [PATCH] Add tests for group, permission and page-permission editing --- wagtail/wagtailusers/tests.py | 205 +++++++++++++++++++++++++++++++--- 1 file changed, 189 insertions(+), 16 deletions(-) diff --git a/wagtail/wagtailusers/tests.py b/wagtail/wagtailusers/tests.py index dd0ff00c7..1f7cce925 100644 --- a/wagtail/wagtailusers/tests.py +++ b/wagtail/wagtailusers/tests.py @@ -1,9 +1,11 @@ from django.test import TestCase from django.core.urlresolvers import reverse -from django.contrib.auth.models import User, Group +from django.contrib.auth.models import User, Group, Permission from wagtail.tests.utils import WagtailTestUtils +from wagtail.wagtailadmin import hooks from wagtail.wagtailusers.models import UserProfile +from wagtail.wagtailcore.models import Page, GroupPagePermission class TestUserIndexView(TestCase, WagtailTestUtils): @@ -180,10 +182,8 @@ class TestGroupCreateView(TestCase, WagtailTestUtils): self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'wagtailusers/groups/create.html') - def test_create(self): - response = self.post({ - 'name': "test group", - }) + def test_create_group(self): + response = self.post({'name': "test group"}) # Should redirect back to index self.assertRedirects(response, reverse('wagtailusers_groups_index')) @@ -192,11 +192,58 @@ class TestGroupCreateView(TestCase, WagtailTestUtils): groups = Group.objects.filter(name='test group') self.assertEqual(groups.count(), 1) + def test_group_create_adding_permissions(self): + response = self.post({ + 'name': "test group", + u'page_permissions-0-id': [u''], + u'page_permissions-0-page': [u'1'], + u'page_permissions-0-permission_type': [u'publish'], + u'page_permissions-1-id': [u''], + u'page_permissions-1-page': [u'1'], + u'page_permissions-1-permission_type': [u'edit'], + u'page_permissions-TOTAL_FORMS': [u'2'], + }) + + self.assertRedirects(response, reverse('wagtailusers_groups_index')) + # The test group now exists, with two page permissions + new_group = Group.objects.get(name='test group') + self.assertEqual(new_group.page_permissions.all().count(), 2) + + def test_duplicate_page_permissions_error(self): + # Try to submit duplicate page permission entries + response = self.post({ + 'name': "test group", + u'page_permissions-0-id': [u''], + u'page_permissions-0-page': [u'1'], + u'page_permissions-0-permission_type': [u'publish'], + u'page_permissions-1-id': [u''], + u'page_permissions-1-page': [u'1'], + u'page_permissions-1-permission_type': [u'publish'], + u'page_permissions-TOTAL_FORMS': [u'2'], + }) + + self.assertEqual(response.status_code, 200) + # the second form should have errors + self.assertEqual(bool(response.context['formset'].errors[0]), False) + self.assertEqual(bool(response.context['formset'].errors[1]), True) + class TestGroupEditView(TestCase, WagtailTestUtils): def setUp(self): # Create a group to edit self.test_group = Group.objects.create(name='test group') + self.root_page = Page.objects.get(id=1) + self.root_add_permission = GroupPagePermission.objects.create(page=self.root_page, + permission_type='add', + group=self.test_group) + # Get the hook-registered permissions, and add one to this group + self.registered_permissions = Permission.objects.none() + for fn in hooks.get_hooks('register_permissions'): + self.registered_permissions = self.registered_permissions | fn() + self.existing_permission = self.registered_permissions.order_by('pk')[0] + self.another_permission = self.registered_permissions.order_by('pk')[1] + + self.test_group.permissions.add(self.existing_permission) # Login self.login() @@ -207,26 +254,38 @@ class TestGroupEditView(TestCase, WagtailTestUtils): def post(self, post_data={}, group_id=None): post_defaults = { u'name': 'test group', - u'page_permissions-TOTAL_FORMS': [u'0'], + u'permissions': [self.existing_permission.id], + u'page_permissions-TOTAL_FORMS': [u'1'], u'page_permissions-MAX_NUM_FORMS': [u'1000'], - u'page_permissions-INITIAL_FORMS': [u'0'], + u'page_permissions-INITIAL_FORMS': [u'1'], # as we have one page permission already + u'page_permissions-0-id': [self.root_add_permission.id], + u'page_permissions-0-page': [self.root_add_permission.page.id], + u'page_permissions-0-permission_type': [self.root_add_permission.permission_type] } for k, v in post_defaults.iteritems(): post_data[k] = post_data.get(k, v) return self.client.post(reverse('wagtailusers_groups_edit', args=(group_id or self.test_group.id, )), post_data) + def add_non_registered_perm(self): + # Some groups may have django permissions assigned that are not + # hook-registered as part of the wagtail interface. We need to ensure + # that these permissions are not overwritten by our views. + # Tests that use this method are testing the aforementioned + # functionality. + self.non_registered_perms = Permission.objects.exclude(id__in=self.registered_permissions) + self.non_registered_perm = self.non_registered_perms[0] + self.test_group.permissions.add(self.non_registered_perm) + def test_simple(self): response = self.get() self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'wagtailusers/groups/edit.html') - def test_nonexistant_redirect(self): + def test_nonexistant_group_redirect(self): self.assertEqual(self.get(group_id=100000).status_code, 404) - def test_edit(self): - response = self.post({ - 'name': "test group edited", - }) + def test_group_edit(self): + response = self.post({'name': "test group edited"}) # Should redirect back to index self.assertRedirects(response, reverse('wagtailusers_groups_index')) @@ -235,11 +294,125 @@ class TestGroupEditView(TestCase, WagtailTestUtils): group = Group.objects.get(id=self.test_group.id) self.assertEqual(group.name, 'test group edited') - def test_edit_validation_error(self): + def test_group_edit_validation_error(self): # Leave "name" field blank. This should give a validation error - response = self.post({ - 'name': "", - }) + response = self.post({'name': ""}) # Should not redirect to index self.assertEqual(response.status_code, 200) + + def test_group_edit_adding_page_permissions(self): + # The test group has one page permission to begin with + self.assertEqual(self.test_group.page_permissions.count(), 1) + response = self.post({ + u'page_permissions-1-id': [u''], + u'page_permissions-1-page': [u'1'], + u'page_permissions-1-permission_type': [u'publish'], + u'page_permissions-2-id': [u''], + u'page_permissions-2-page': [u'1'], + u'page_permissions-2-permission_type': [u'edit'], + u'page_permissions-TOTAL_FORMS': [u'3'], + }) + + self.assertRedirects(response, reverse('wagtailusers_groups_index')) + # The test group now has three page permissions + self.assertEqual(self.test_group.page_permissions.count(), 3) + + def test_group_edit_deleting_page_permissions(self): + # The test group has one page permissions to begin with + self.assertEqual(self.test_group.page_permissions.count(), 1) + + response = self.post({ + u'page_permissions-0-DELETE': [u'1'], + }) + + self.assertRedirects(response, reverse('wagtailusers_groups_index')) + # The test group now has zero page permissions + self.assertEqual(self.test_group.page_permissions.count(), 0) + + def test_group_edit_loads_with_page_permissions_shown(self): + # The test group has one page permission to begin with + self.assertEqual(self.test_group.page_permissions.count(), 1) + + response = self.get() + + self.assertEqual(response.context['formset'].management_form['INITIAL_FORMS'].value(), 1) + self.assertEqual(response.context['formset'].forms[0].instance, self.root_add_permission) + + root_edit_perm = GroupPagePermission.objects.create(page=self.root_page, + permission_type='edit', + group=self.test_group) + + # The test group now has two page permissions + self.assertEqual(self.test_group.page_permissions.count(), 2) + + # Reload the page and check the form instances + response = self.get() + self.assertEqual(response.context['formset'].management_form['INITIAL_FORMS'].value(), 2) + self.assertEqual(response.context['formset'].forms[0].instance, self.root_add_permission) + self.assertEqual(response.context['formset'].forms[1].instance, root_edit_perm) + + def test_duplicate_page_permissions_error(self): + # Try to submit duplicate page permission entries + response = self.post({ + u'page_permissions-1-id': [u''], + u'page_permissions-1-page': [self.root_add_permission.page.id], + u'page_permissions-1-permission_type': [self.root_add_permission.permission_type], + u'page_permissions-TOTAL_FORMS': [u'2'], + }) + + self.assertEqual(response.status_code, 200) + # the second form should have errors + self.assertEqual(bool(response.context['formset'].errors[0]), False) + self.assertEqual(bool(response.context['formset'].errors[1]), True) + + def test_group_add_registered_django_permissions(self): + # The test group has one django permission to begin with + self.assertEqual(self.test_group.permissions.count(), 1) + response = self.post({ + 'permissions': [self.existing_permission.id, self.another_permission.id] + }) + self.assertRedirects(response, reverse('wagtailusers_groups_index')) + self.assertEqual(self.test_group.permissions.count(), 2) + + def test_group_form_includes_non_registered_permissions_in_initial_data(self): + self.add_non_registered_perm() + original_permissions = self.test_group.permissions.all() + self.assertEqual(original_permissions.count(), 2) + + response = self.get() + # See that the form is set up with the correct initial data + self.assertEqual(response.context['form'].initial.get('permissions'), list(original_permissions.values_list('id', flat=True))) + + def test_group_retains_non_registered_permissions_when_editing(self): + self.add_non_registered_perm() + original_permissions = list(self.test_group.permissions.all()) # list() to force evaluation + + # submit the form with no changes (only submitting the exsisting + # permission, as in the self.post function definition) + self.post() + + # See that the group has the same permissions as before + self.assertEqual(list(self.test_group.permissions.all()), original_permissions) + self.assertEqual(self.test_group.permissions.count(), 2) + + def test_group_retains_non_registered_permissions_when_adding(self): + self.add_non_registered_perm() + # Add a second registered permission + self.post({ + 'permissions': [self.existing_permission.id, self.another_permission.id] + }) + + # See that there are now three permissions in total + self.assertEqual(self.test_group.permissions.count(), 3) + # ...including the non-registered one + self.assertIn(self.non_registered_perm, self.test_group.permissions.all()) + + def test_group_retains_non_registered_permissions_when_deleting(self): + self.add_non_registered_perm() + # Delete all registered permissions + self.post({'permissions': []}) + + # See that the non-registered permission is still there + self.assertEqual(self.test_group.permissions.count(), 1) + self.assertEqual(self.test_group.permissions.all()[0], self.non_registered_perm)