diff --git a/mayan/apps/acls/tests/mixins.py b/mayan/apps/acls/tests/mixins.py index ff8b2193e7..79a79fae20 100644 --- a/mayan/apps/acls/tests/mixins.py +++ b/mayan/apps/acls/tests/mixins.py @@ -1,37 +1,41 @@ from __future__ import unicode_literals -from django.contrib.auth import get_user_model -from django.contrib.auth.models import Group +from django.core.exceptions import ImproperlyConfigured from mayan.apps.acls.models import AccessControlList -from mayan.apps.permissions.models import Role -from mayan.apps.permissions.tests.literals import TEST_ROLE_LABEL -from mayan.apps.permissions.tests.mixins import RoleTestCaseMixin -from mayan.apps.user_management.tests.literals import ( - TEST_ADMIN_PASSWORD, TEST_ADMIN_USERNAME, TEST_ADMIN_EMAIL, - TEST_GROUP_NAME, TEST_USER_EMAIL, TEST_USER_USERNAME, TEST_USER_PASSWORD +from mayan.apps.permissions.tests.mixins import ( + PermissionTestMixin, RoleTestCaseMixin, RoleTestMixin ) +from mayan.apps.user_management.tests.mixins import UserTestCaseMixin -class ACLTestCaseMixin(RoleTestCaseMixin): +class ACLTestCaseMixin(RoleTestCaseMixin, UserTestCaseMixin): def setUp(self): super(ACLTestCaseMixin, self).setUp() - self.admin_user = get_user_model().objects.create_superuser( - username=TEST_ADMIN_USERNAME, email=TEST_ADMIN_EMAIL, - password=TEST_ADMIN_PASSWORD + if hasattr(self, '_test_case_user'): + self._test_case_role.groups.add(self._test_case_group) + + def grant_access(self, obj, permission): + if not hasattr(self, '_test_case_role'): + raise ImproperlyConfigured( + 'Enable the creation of the test case user, group, and role ' + 'in order to enable the usage of ACLs in tests.' + ) + + self._test_case_acl = AccessControlList.objects.grant( + obj=obj, permission=permission, role=self._test_case_role ) - self.user = get_user_model().objects.create_user( - username=TEST_USER_USERNAME, email=TEST_USER_EMAIL, - password=TEST_USER_PASSWORD + +class ACLTestMixin(PermissionTestMixin, RoleTestMixin): + auto_create_test_role = True + + def _create_test_acl(self): + self.test_acl = AccessControlList.objects.create( + content_object=self.test_object, role=self.test_role ) - self.group = Group.objects.create(name=TEST_GROUP_NAME) - self.role = Role.objects.create(label=TEST_ROLE_LABEL) - self.group.user_set.add(self.user) - self.role.groups.add(self.group) - - def grant_access(self, permission, obj): - AccessControlList.objects.grant( - permission=permission, role=self.role, obj=obj - ) + def setUp(self): + super(ACLTestMixin, self).setUp() + if self.auto_create_test_role: + self._create_test_role() diff --git a/mayan/apps/acls/tests/test_actions.py b/mayan/apps/acls/tests/test_actions.py index 9a43ed70ba..62e7fddd41 100644 --- a/mayan/apps/acls/tests/test_actions.py +++ b/mayan/apps/acls/tests/test_actions.py @@ -9,15 +9,14 @@ from ..workflow_actions import GrantAccessAction, RevokeAccessAction class ACLActionTestCase(ActionTestCase): - def setUp(self): - super(ACLActionTestCase, self).setUp() - def test_grant_access_action(self): action = GrantAccessAction( form_data={ - 'content_type': ContentType.objects.get_for_model(model=self.document).pk, + 'content_type': ContentType.objects.get_for_model( + model=self.test_document + ).pk, 'object_id': self.document.pk, - 'roles': [self.role.pk], + 'roles': [self._test_case_role.pk], 'permissions': [permission_document_view.pk], } ) @@ -28,7 +27,7 @@ class ACLActionTestCase(ActionTestCase): list(self.document.acls.first().permissions.all()), [permission_document_view.stored_permission] ) - self.assertEqual(self.document.acls.first().role, self.role) + self.assertEqual(self.document.acls.first().role, self._test_case_role) def test_revoke_access_action(self): self.grant_access( @@ -37,9 +36,11 @@ class ACLActionTestCase(ActionTestCase): action = RevokeAccessAction( form_data={ - 'content_type': ContentType.objects.get_for_model(model=self.document).pk, + 'content_type': ContentType.objects.get_for_model( + model=self.document + ).pk, 'object_id': self.document.pk, - 'roles': [self.role.pk], + 'roles': [self._test_case_role.pk], 'permissions': [permission_document_view.pk], } ) diff --git a/mayan/apps/acls/tests/test_api.py b/mayan/apps/acls/tests/test_api.py index 49e8cd53d2..b332f56c27 100644 --- a/mayan/apps/acls/tests/test_api.py +++ b/mayan/apps/acls/tests/test_api.py @@ -1,7 +1,6 @@ from __future__ import absolute_import, unicode_literals from django.contrib.contenttypes.models import ContentType -from django.test import override_settings from rest_framework import status @@ -13,75 +12,69 @@ from mayan.apps.rest_api.tests import BaseAPITestCase from ..models import AccessControlList from ..permissions import permission_acl_view +from .mixins import ACLTestMixin -@override_settings(OCR_AUTO_OCR=False) -class ACLAPITestCase(DocumentTestMixin, BaseAPITestCase): + +class ACLAPITestCase(ACLTestMixin, DocumentTestMixin, BaseAPITestCase): def setUp(self): super(ACLAPITestCase, self).setUp() - self.login_admin_user() - - self.document_content_type = ContentType.objects.get_for_model( - self.document + self.test_document_content_type = ContentType.objects.get_for_model( + self.test_document ) - - def _create_acl(self): - self.acl = AccessControlList.objects.create( - content_object=self.document, - role=self.role - ) - - self.acl.permissions.add(permission_document_view.stored_permission) + self.test_object = self.test_document def test_object_acl_list_view(self): - self._create_acl() + self._create_test_acl() + + self.grant_access(obj=self.test_object, permission=permission_acl_view) response = self.get( viewname='rest_api:accesscontrollist-list', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk ) ) - + self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( response.data['results'][0]['content_type']['app_label'], - self.document_content_type.app_label + self.test_object_content_type.app_label ) self.assertEqual( - response.data['results'][0]['role']['label'], TEST_ROLE_LABEL + response.data['results'][0]['role']['label'], + self.test_acl.role.label ) def test_object_acl_delete_view(self): self.expected_content_type = None - self._create_acl() + self._create_test_acl() response = self.delete( viewname='rest_api:accesscontrollist-detail', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk, self.acl.pk + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk, self.test_acl.pk ) ) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(AccessControlList.objects.count(), 0) def test_object_acl_detail_view(self): - self._create_acl() + self._create_test_acl() response = self.get( viewname='rest_api:accesscontrollist-detail', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk, self.acl.pk + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk, self.test_acl.pk ) ) self.assertEqual( response.data['content_type']['app_label'], - self.document_content_type.app_label + self.test_document_content_type.app_label ) self.assertEqual( response.data['role']['label'], TEST_ROLE_LABEL @@ -89,71 +82,70 @@ class ACLAPITestCase(DocumentTestMixin, BaseAPITestCase): def test_object_acl_permission_delete_view(self): self.expected_content_type = None - self._create_acl() - permission = self.acl.permissions.first() + self._create_test_acl() + self.test_acls.grant_permission(permission=permission_document_view) + permission = self.test_acl.permissions.first() response = self.delete( viewname='rest_api:accesscontrollist-permission-detail', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk, self.acl.pk, + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk, self.test_acl.pk, permission.pk ) ) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - self.assertEqual(self.acl.permissions.count(), 0) + self.assertEqual(self.test_acl.permissions.count(), 0) def test_object_acl_permission_detail_view(self): - self._create_acl() - permission = self.acl.permissions.first() + self._create_test_acl() + permission = self.test_acl.permissions.first() response = self.get( viewname='rest_api:accesscontrollist-permission-detail', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk, self.acl.pk, + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk, self.test_acl.pk, permission.pk ) ) - self.assertEqual( response.data['pk'], permission_document_view.pk ) def test_object_acl_permission_list_view(self): - self._create_acl() + self._create_test_acl() response = self.get( viewname='rest_api:accesscontrollist-permission-list', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk, self.acl.pk + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk, self.test_acl.pk ) ) - self.assertEqual( response.data['results'][0]['pk'], permission_document_view.pk ) def test_object_acl_permission_list_post_view(self): - self._create_acl() + self._create_test_acl() response = self.post( viewname='rest_api:accesscontrollist-permission-list', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk, self.acl.pk + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk, self.test_acl.pk ), data={'permission_pk': permission_acl_view.pk} ) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self.assertQuerysetEqual( - ordered=False, qs=self.acl.permissions.all(), values=( + ordered=False, qs=self.test_acl.permissions.all(), values=( repr(permission_document_view.stored_permission), repr(permission_acl_view.stored_permission) ) @@ -163,45 +155,45 @@ class ACLAPITestCase(DocumentTestMixin, BaseAPITestCase): response = self.post( viewname='rest_api:accesscontrollist-list', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk - ), data={'role_pk': self.role.pk} + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk + ), data={'role_pk': self.test_role.pk} ) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self.assertEqual( - self.document.acls.first().role, self.role + self.test_document.acls.first().role, self.test_role ) self.assertEqual( - self.document.acls.first().content_object, self.document + self.test_document.acls.first().content_object, self.test_document ) self.assertEqual( - self.document.acls.first().permissions.count(), 0 + self.test_document.acls.first().permissions.count(), 0 ) def test_object_acl_post_with_permissions_added_view(self): response = self.post( viewname='rest_api:accesscontrollist-list', args=( - self.document_content_type.app_label, - self.document_content_type.model, - self.document.pk + self.test_document_content_type.app_label, + self.test_document_content_type.model, + self.test_document.pk ), data={ 'role_pk': self.role.pk, 'permissions_pk_list': permission_acl_view.pk } ) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self.assertEqual( - self.document.acls.first().content_object, self.document + self.test_document.acls.first().content_object, self.test_document ) self.assertEqual( - self.document.acls.first().role, self.role + self.test_document.acls.first().role, self.role ) self.assertEqual( - self.document.acls.first().permissions.first(), + self.test_document.acls.first().permissions.first(), permission_acl_view.stored_permission ) diff --git a/mayan/apps/acls/tests/test_links.py b/mayan/apps/acls/tests/test_links.py index 52d12facdd..e5016bd497 100644 --- a/mayan/apps/acls/tests/test_links.py +++ b/mayan/apps/acls/tests/test_links.py @@ -8,29 +8,28 @@ from mayan.apps.documents.tests import GenericDocumentViewTestCase from ..links import ( link_acl_delete, link_acl_list, link_acl_create, link_acl_permissions ) -from ..models import AccessControlList from ..permissions import permission_acl_edit, permission_acl_view +from .mixins import ACLTestMixin -class ACLsLinksTestCase(GenericDocumentViewTestCase): + +class ACLsLinksTestCase(ACLTestMixin, GenericDocumentViewTestCase): def setUp(self): super(ACLsLinksTestCase, self).setUp() - self.login_user() + self.test_object = self.test_document def test_document_acl_create_link(self): - acl = AccessControlList.objects.create( - content_object=self.document, role=self.role + self.grant_access( + obj=self.test_document, permission=permission_acl_edit ) - acl.permissions.add(permission_acl_edit.stored_permission) - self.add_test_view(test_object=self.document) context = self.get_test_view() resolved_link = link_acl_create.resolve(context=context) self.assertNotEqual(resolved_link, None) - content_type = ContentType.objects.get_for_model(self.document) + content_type = ContentType.objects.get_for_model(self.test_document) kwargs = { 'app_label': content_type.app_label, 'model': content_type.model, @@ -38,63 +37,69 @@ class ACLsLinksTestCase(GenericDocumentViewTestCase): } self.assertEqual( - resolved_link.url, reverse('acls:acl_create', kwargs=kwargs) + resolved_link.url, reverse( + viewname=link_acl_create.view, kwargs=kwargs + ) ) def test_document_acl_delete_link(self): - acl = AccessControlList.objects.create( - content_object=self.document, role=self.role + self._create_test_acl() + + self.grant_access( + obj=self.test_document, permission=permission_acl_edit ) - acl.permissions.add(permission_acl_edit.stored_permission) - - self.add_test_view(test_object=acl) + self.add_test_view(test_object=self.test_acl) context = self.get_test_view() resolved_link = link_acl_delete.resolve(context=context) self.assertNotEqual(resolved_link, None) self.assertEqual( - resolved_link.url, reverse('acls:acl_delete', args=(acl.pk,)) + resolved_link.url, reverse( + viewname=link_acl_delete.view, args=(self.test_acl.pk,) + ) ) def test_document_acl_edit_link(self): - acl = AccessControlList.objects.create( - content_object=self.document, role=self.role + self._create_test_acl() + + self.grant_access( + obj=self.test_document, permission=permission_acl_edit ) - acl.permissions.add(permission_acl_edit.stored_permission) - - self.add_test_view(test_object=acl) + self.add_test_view(test_object=self.test_acl) context = self.get_test_view() resolved_link = link_acl_permissions.resolve(context=context) self.assertNotEqual(resolved_link, None) self.assertEqual( - resolved_link.url, reverse('acls:acl_permissions', args=(acl.pk,)) + resolved_link.url, reverse( + viewname=link_acl_permissions.view, + args=(self.test_acl.pk,) + ) ) def test_document_acl_list_link(self): - acl = AccessControlList.objects.create( - content_object=self.document, role=self.role + self.grant_access( + obj=self.test_document, permission=permission_acl_view ) - acl.permissions.add(permission_acl_view.stored_permission) - - self.add_test_view(test_object=self.document) + self.add_test_view(test_object=self.test_document) context = self.get_test_view() resolved_link = link_acl_list.resolve(context=context) - self.assertNotEqual(resolved_link, None) - content_type = ContentType.objects.get_for_model(self.document) + content_type = ContentType.objects.get_for_model(self.test_document) kwargs = { 'app_label': content_type.app_label, 'model': content_type.model, - 'object_id': self.document.pk + 'object_id': self.test_document.pk } self.assertEqual( - resolved_link.url, reverse('acls:acl_list', kwargs=kwargs) + resolved_link.url, reverse( + viewname=link_acl_list.view, kwargs=kwargs + ) ) diff --git a/mayan/apps/acls/tests/test_models.py b/mayan/apps/acls/tests/test_models.py index 1f5e0beaf2..70ebb39b5e 100644 --- a/mayan/apps/acls/tests/test_models.py +++ b/mayan/apps/acls/tests/test_models.py @@ -1,7 +1,6 @@ from __future__ import absolute_import, unicode_literals from django.core.exceptions import PermissionDenied -from django.test import override_settings from mayan.apps.common.tests import BaseTestCase from mayan.apps.documents.models import Document, DocumentType @@ -13,9 +12,10 @@ from mayan.apps.documents.tests import ( from ..models import AccessControlList +from .mixins import ACLTestMixin -@override_settings(OCR_AUTO_OCR=False) -class PermissionTestCase(BaseTestCase): + +class PermissionTestCase(ACLTestMixin, BaseTestCase): def setUp(self): super(PermissionTestCase, self).setUp() self.document_type_1 = DocumentType.objects.create( @@ -50,86 +50,79 @@ class PermissionTestCase(BaseTestCase): with self.assertRaises(PermissionDenied): AccessControlList.objects.check_access( permissions=(permission_document_view,), - user=self.user, obj=self.document_1 + user=self._test_case_user, obj=self.document_1 ) def test_filtering_without_permissions(self): self.assertQuerysetEqual( AccessControlList.objects.filter_by_access( - permission=permission_document_view, user=self.user, + permission=permission_document_view, user=self._test_case_user, queryset=Document.objects.all() ), [] ) def test_check_access_with_acl(self): - acl = AccessControlList.objects.create( - content_object=self.document_1, role=self.role + self.grant_access( + obj=self.document_1, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) try: AccessControlList.objects.check_access( - permissions=(permission_document_view,), user=self.user, - obj=self.document_1 + obj=self.document_1, permissions=(permission_document_view,), + user=self._test_case_user, ) except PermissionDenied: self.fail('PermissionDenied exception was not expected.') def test_filtering_with_permissions(self): - acl = AccessControlList.objects.create( - content_object=self.document_1, role=self.role + self.grant_access( + obj=self.document_1, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) self.assertQuerysetEqual( AccessControlList.objects.filter_by_access( - permission=permission_document_view, user=self.user, - queryset=Document.objects.all() + permission=permission_document_view, + queryset=Document.objects.all(), user=self._test_case_user ), (repr(self.document_1),) ) def test_check_access_with_inherited_acl(self): - acl = AccessControlList.objects.create( - content_object=self.document_type_1, role=self.role + self.grant_access( + obj=self.document_type_1, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) try: AccessControlList.objects.check_access( - permissions=(permission_document_view,), user=self.user, - obj=self.document_1 + obj=self.document_1, permissions=(permission_document_view,), + user=self._test_case_user ) except PermissionDenied: self.fail('PermissionDenied exception was not expected.') def test_check_access_with_inherited_acl_and_local_acl(self): - acl = AccessControlList.objects.create( - content_object=self.document_type_1, role=self.role + self.grant_access( + obj=self.document_type_1, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) - - acl = AccessControlList.objects.create( - content_object=self.document_3, role=self.role + self.grant_access( + obj=self.document_3, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) try: AccessControlList.objects.check_access( - permissions=(permission_document_view,), user=self.user, - obj=self.document_3 + obj=self.document_3, permissions=(permission_document_view,), + user=self._test_case_user ) except PermissionDenied: self.fail('PermissionDenied exception was not expected.') def test_filtering_with_inherited_permissions(self): - acl = AccessControlList.objects.create( - content_object=self.document_type_1, role=self.role + self.grant_access( + obj=self.document_type_1, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) result = AccessControlList.objects.filter_by_access( - permission=permission_document_view, user=self.user, - queryset=Document.objects.all() + permission=permission_document_view, + queryset=Document.objects.all(), user=self._test_case_user ) # Since document_1 and document_2 are of document_type_1 @@ -140,21 +133,17 @@ class PermissionTestCase(BaseTestCase): self.assertTrue(self.document_3 not in result) def test_filtering_with_inherited_permissions_and_local_acl(self): - self.role.permissions.add(permission_document_view.stored_permission) - - acl = AccessControlList.objects.create( - content_object=self.document_type_1, role=self.role + self.grant_permission(permission=permission_document_view) + self.grant_access( + obj=self.document_type_1, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) - - acl = AccessControlList.objects.create( - content_object=self.document_3, role=self.role + self.grant_access( + obj=self.document_3, permission=permission_document_view ) - acl.permissions.add(permission_document_view.stored_permission) result = AccessControlList.objects.filter_by_access( - permission=permission_document_view, user=self.user, - queryset=Document.objects.all() + permission=permission_document_view, + queryset=Document.objects.all(), user=self._test_case_user, ) self.assertTrue(self.document_1 in result) self.assertTrue(self.document_2 in result) diff --git a/mayan/apps/acls/tests/test_views.py b/mayan/apps/acls/tests/test_views.py index 031f7475a3..3e56940acc 100644 --- a/mayan/apps/acls/tests/test_views.py +++ b/mayan/apps/acls/tests/test_views.py @@ -7,79 +7,87 @@ from mayan.apps.documents.tests import GenericDocumentViewTestCase from ..models import AccessControlList from ..permissions import permission_acl_edit, permission_acl_view +from .mixins import ACLTestMixin -class AccessControlListViewTestCase(GenericDocumentViewTestCase): + +class AccessControlListViewTestCase(ACLTestMixin, GenericDocumentViewTestCase): def setUp(self): super(AccessControlListViewTestCase, self).setUp() - content_type = ContentType.objects.get_for_model(self.document) + content_type = ContentType.objects.get_for_model(self.test_document) self.view_arguments = { 'app_label': content_type.app_label, 'model': content_type.model, - 'object_id': self.document.pk + 'object_id': self.test_document.pk } - self.login_user() - def test_acl_create_view_no_permission(self): - response = self.get( + self.test_object = self.test_document + + def _request_test_acl_create_get_view(self): + return self.get( viewname='acls:acl_create', kwargs=self.view_arguments, data={ - 'role': self.role.pk - } - ) - - self.assertEquals(response.status_code, 403) - self.assertEqual(AccessControlList.objects.count(), 0) - - def test_acl_create_view_with_permission(self): - self.role.permissions.add( - permission_acl_edit.stored_permission - ) - - response = self.get( - viewname='acls:acl_create', kwargs=self.view_arguments, data={ - 'role': self.role.pk + 'role': self.test_role.pk }, follow=True ) + def test_acl_create_get_view_no_permission(self): + acl_count = AccessControlList.objects.count() + + response = self._request_test_acl_create_get_view() + self.assertEquals(response.status_code, 403) + + self.assertEqual(AccessControlList.objects.count(), acl_count) + + def test_acl_create_get_view_with_access(self): + self.grant_access( + obj=self.test_document, permission=permission_acl_edit + ) + acl_count = AccessControlList.objects.count() + + response = self._request_test_acl_create_get_view() self.assertContains( - response, text=self.document.label, status_code=200 + response=response, text=self.test_document.label, status_code=200 + ) + + self.assertEqual(AccessControlList.objects.count(), acl_count) + + def _request_test_acl_create_post_view(self): + return self.post( + viewname='acls:acl_create', kwargs=self.view_arguments, data={ + 'role': self.test_role.pk + }, follow=True ) def test_acl_create_view_post_no_permission(self): - response = self.post( - viewname='acls:acl_create', kwargs=self.view_arguments, data={ - 'role': self.role.pk - } - ) + acl_count = AccessControlList.objects.count() + response = self._request_test_acl_create_post_view() self.assertEquals(response.status_code, 403) - self.assertEqual(AccessControlList.objects.count(), 0) - def test_acl_create_view_with_post_permission(self): - self.role.permissions.add( - permission_acl_edit.stored_permission + self.assertEqual(AccessControlList.objects.count(), acl_count) + + def test_acl_create_view_post_with_access(self): + self.grant_access( + obj=self.test_document, permission=permission_acl_edit ) - response = self.post( - viewname='acls:acl_create', kwargs=self.view_arguments, data={ - 'role': self.role.pk - }, follow=True - ) + acl_count = AccessControlList.objects.count() - self.assertContains(response, text='created', status_code=200) - self.assertEqual(AccessControlList.objects.count(), 1) + response = self._request_test_acl_create_post_view() + self.assertContains(response=response, text='created', status_code=200) + self.assertEqual(AccessControlList.objects.count(), acl_count + 1) def test_orphan_acl_create_view_with_permission(self): """ Test creating an ACL entry for an object with no model permissions. Result: Should display a blank permissions list (not optgroup) """ - self.role.permissions.add( - permission_acl_edit.stored_permission - ) + self.grant_permission(permission=permission_acl_edit) - recent_entry = self.document.add_as_recent_document_for_user(self.user) + recent_entry = self.test_document.add_as_recent_document_for_user( + self._test_case_user + ) content_type = ContentType.objects.get_for_model(recent_entry) @@ -91,61 +99,34 @@ class AccessControlListViewTestCase(GenericDocumentViewTestCase): response = self.post( viewname='acls:acl_create', kwargs=view_arguments, data={ - 'role': self.role.pk + 'role': self.test_role.pk }, follow=True ) - self.assertNotContains(response, text='optgroup', status_code=200) self.assertEqual(AccessControlList.objects.count(), 1) def test_acl_list_view_no_permission(self): - document = self.document.add_as_recent_document_for_user( - self.user - ).document - - acl = AccessControlList.objects.create( - content_object=document, role=self.role - ) - acl.permissions.add(permission_acl_edit.stored_permission) - - content_type = ContentType.objects.get_for_model(document) - - view_arguments = { - 'app_label': content_type.app_label, - 'model': content_type.model, - 'object_id': document.pk - } + self._create_test_acl() response = self.get( - viewname='acls:acl_list', kwargs=view_arguments + viewname='acls:acl_list', kwargs=self.view_arguments ) - self.assertNotContains(response, text=document.label, status_code=403) - self.assertNotContains(response, text='otal: 1', status_code=403) + self.assertNotContains( + response=response, text=self.document.label, status_code=403 + ) + self.assertNotContains( + response=response, text='otal: 1', status_code=403 + ) def test_acl_list_view_with_permission(self): - self.role.permissions.add( - permission_acl_view.stored_permission + self.grant_access( + obj=self.test_document, permission=permission_acl_view ) - document = self.document.add_as_recent_document_for_user( - self.user - ).document - - acl = AccessControlList.objects.create( - content_object=document, role=self.role - ) - acl.permissions.add(permission_acl_view.stored_permission) - - content_type = ContentType.objects.get_for_model(document) - - view_arguments = { - 'app_label': content_type.app_label, - 'model': content_type.model, - 'object_id': document.pk - } - response = self.get( - viewname='acls:acl_list', kwargs=view_arguments + viewname='acls:acl_list', kwargs=self.view_arguments + ) + self.assertContains( + response=response, text=self.test_document.label, status_code=200 ) - self.assertContains(response, text=document.label, status_code=200) diff --git a/mayan/apps/authentication/tests/test_views.py b/mayan/apps/authentication/tests/test_views.py index 34540e30e3..01ce98a394 100644 --- a/mayan/apps/authentication/tests/test_views.py +++ b/mayan/apps/authentication/tests/test_views.py @@ -10,9 +10,6 @@ from django.utils.http import urlunquote_plus from mayan.apps.common.tests import GenericViewTestCase from mayan.apps.smart_settings.classes import Namespace -from mayan.apps.user_management.tests.literals import ( - TEST_ADMIN_EMAIL, TEST_ADMIN_PASSWORD, TEST_ADMIN_USERNAME -) from ..settings import setting_maximum_session_length @@ -35,6 +32,7 @@ class UserLoginTestCase(GenericViewTestCase): ).tostr() ) auto_login_user = False + create_test_case_superuser = True def setUp(self): super(UserLoginTestCase, self).setUp() @@ -53,7 +51,8 @@ class UserLoginTestCase(GenericViewTestCase): @override_settings(AUTHENTICATION_LOGIN_METHOD='username') def test_username_login(self): logged_in = self.login( - username=TEST_ADMIN_USERNAME, password=TEST_ADMIN_PASSWORD + username=self._test_case_superuser.username, + password=self._test_case_superuser.cleartext_password ) self.assertTrue(logged_in) response = self._request_authenticated_view() @@ -64,12 +63,14 @@ class UserLoginTestCase(GenericViewTestCase): def test_email_login(self): with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)): logged_in = self.login( - username=TEST_ADMIN_USERNAME, password=TEST_ADMIN_PASSWORD + username=self._test_case_superuser.username, + password=self._test_case_superuser.cleartext_password ) self.assertFalse(logged_in) logged_in = self.login( - email=TEST_ADMIN_EMAIL, password=TEST_ADMIN_PASSWORD + email=self._test_case_superuser.email, + password=self._test_case_superuser.cleartext_password ) self.assertTrue(logged_in) @@ -86,8 +87,8 @@ class UserLoginTestCase(GenericViewTestCase): response = self.post( viewname=settings.LOGIN_URL, data={ - 'username': TEST_ADMIN_USERNAME, - 'password': TEST_ADMIN_PASSWORD + 'username': self._test_case_superuser.username, + 'password': self._test_case_superuser.cleartext_password } ) response = self._request_authenticated_view() @@ -104,7 +105,8 @@ class UserLoginTestCase(GenericViewTestCase): response = self.post( viewname=settings.LOGIN_URL, data={ - 'email': TEST_ADMIN_EMAIL, 'password': TEST_ADMIN_PASSWORD + 'email': self._test_case_superuser.email, + 'password': self._test_case_superuser.cleartext_password }, follow=True ) self.assertEqual(response.status_code, 200) @@ -117,8 +119,8 @@ class UserLoginTestCase(GenericViewTestCase): def test_username_remember_me(self): response = self.post( viewname=settings.LOGIN_URL, data={ - 'username': TEST_ADMIN_USERNAME, - 'password': TEST_ADMIN_PASSWORD, + 'username': self._test_case_superuser.username, + 'password': self._test_case_superuser.cleartext_password, 'remember_me': True }, follow=True ) @@ -136,8 +138,8 @@ class UserLoginTestCase(GenericViewTestCase): def test_username_dont_remember_me(self): response = self.post( viewname=settings.LOGIN_URL, data={ - 'username': TEST_ADMIN_USERNAME, - 'password': TEST_ADMIN_PASSWORD, + 'username': self._test_case_superuser.username, + 'password': self._test_case_superuser.cleartext_password, 'remember_me': False }, follow=True ) @@ -152,8 +154,8 @@ class UserLoginTestCase(GenericViewTestCase): with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)): response = self.post( viewname=settings.LOGIN_URL, data={ - 'email': TEST_ADMIN_EMAIL, - 'password': TEST_ADMIN_PASSWORD, + 'email': self._test_case_superuser.email, + 'password': self._test_case_superuser.cleartext_password, 'remember_me': True }, follow=True ) @@ -172,8 +174,8 @@ class UserLoginTestCase(GenericViewTestCase): with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)): response = self.post( viewname=settings.LOGIN_URL, data={ - 'email': TEST_ADMIN_EMAIL, - 'password': TEST_ADMIN_PASSWORD, + 'email': self._test_case_superuser.email, + 'password': self._test_case_superuser.cleartext_password, 'remember_me': False } ) @@ -187,28 +189,31 @@ class UserLoginTestCase(GenericViewTestCase): def test_password_reset(self): response = self.post( viewname='authentication:password_reset_view', data={ - 'email': TEST_ADMIN_EMAIL, + 'email': self._test_case_superuser.email, } ) self.assertEqual(response.status_code, 302) self.assertEqual(len(mail.outbox), 1) - uid_token = mail.outbox[0].body.replace('\n', '').split('/') + email_parts = mail.outbox[0].body.replace('\n', '').split('/') + uidb64 = email_parts[-3] + token = email_parts[-2] + new_password = 'new_password_123' response = self.post( viewname='authentication:password_reset_confirm_view', - args=uid_token[-3:-1], data={ - 'new_password1': TEST_ADMIN_PASSWORD, - 'new_password2': TEST_ADMIN_PASSWORD, + kwargs={'uidb64': uidb64, 'token': token}, data={ + 'new_password1': new_password, + 'new_password2': new_password } ) - self.assertEqual(response.status_code, 302) - self.login( - username=TEST_ADMIN_USERNAME, password=TEST_ADMIN_PASSWORD + logged_in = self.login( + username=self._test_case_superuser.username, password=new_password ) + self.assertTrue(logged_in) response = self._request_authenticated_view() self.assertEqual(response.status_code, 200) @@ -220,8 +225,8 @@ class UserLoginTestCase(GenericViewTestCase): path='{}?next={}'.format( reverse(settings.LOGIN_URL), TEST_REDIRECT_URL ), data={ - 'username': TEST_ADMIN_USERNAME, - 'password': TEST_ADMIN_PASSWORD, + 'username': self._test_case_superuser.username, + 'password': self._test_case_superuser.cleartext_password, 'remember_me': False }, follow=True ) diff --git a/mayan/apps/cabinets/tests/test_api.py b/mayan/apps/cabinets/tests/test_api.py index f9d51bf713..102ad11f7d 100644 --- a/mayan/apps/cabinets/tests/test_api.py +++ b/mayan/apps/cabinets/tests/test_api.py @@ -1,17 +1,18 @@ from __future__ import unicode_literals -from django.test import override_settings from django.utils.encoding import force_text from rest_framework import status +from mayan.apps.documents.permissions import permission_document_view from mayan.apps.documents.tests import DocumentTestMixin from mayan.apps.rest_api.tests import BaseAPITestCase from ..models import Cabinet from ..permissions import ( - permission_cabinet_create, permission_cabinet_delete, - permission_cabinet_edit, permission_cabinet_view + permission_cabinet_add_document, permission_cabinet_create, + permission_cabinet_delete, permission_cabinet_edit, + permission_cabinet_remove_document, permission_cabinet_view ) from .literals import TEST_CABINET_EDITED_LABEL, TEST_CABINET_LABEL @@ -19,10 +20,6 @@ from .mixins import CabinetTestMixin class CabinetAPITestCase(CabinetTestMixin, BaseAPITestCase): - def setUp(self): - super(CabinetAPITestCase, self).setUp() - self.login_user() - def _request_cabinet_create_api_view(self): return self.post( viewname='rest_api:cabinet-list', data={ @@ -174,21 +171,26 @@ class CabinetAPITestCase(CabinetTestMixin, BaseAPITestCase): ) -@override_settings(OCR_AUTO_OCR=False) class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITestCase): auto_upload_document = False - def setUp(self): - super(CabinetDocumentAPITestCase, self).setUp() - self.login_admin_user() + def _request_test_cabinet_create_api_view(self, extra_data=None): + data = {'label': TEST_CABINET_LABEL} + + if extra_data: + data.update(extra_data) + + return self.post(viewname='rest_api:cabinet-list', data=data) def test_cabinet_create_with_single_document(self): - self.document = self.upload_document() + self.upload_document() - response = self.post( - viewname='rest_api:cabinet-list', data={ - 'label': TEST_CABINET_LABEL, 'documents_pk_list': '{}'.format( - self.document.pk + self.grant_permission(permission=permission_cabinet_create) + + response = self._request_test_cabinet_create_api_view( + extra_data={ + 'documents_pk_list': '{}'.format( + self.test_document.pk ) } ) @@ -200,19 +202,20 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes self.assertEqual(response.data['label'], TEST_CABINET_LABEL) self.assertQuerysetEqual( - cabinet.documents.all(), (repr(self.document),) + cabinet.documents.all(), (repr(self.test_document),) ) self.assertEqual(cabinet.label, TEST_CABINET_LABEL) def test_cabinet_create_with_multiple_documents(self): - self.document = self.upload_document() - self.document_2 = self.upload_document() + self.upload_document() + self.test_document_2 = self.upload_document() - response = self.post( - viewname='rest_api:cabinet-list', data={ - 'label': TEST_CABINET_LABEL, + self.grant_permission(permission=permission_cabinet_create) + + response = self._request_test_cabinet_create_api_view( + extra_data={ 'documents_pk_list': '{},{}'.format( - self.document.pk, self.document_2.pk + self.test_document.pk, self.test_document_2.pk ) } ) @@ -229,49 +232,65 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes self.assertQuerysetEqual( cabinet.documents.all(), map( - repr, (self.document, self.document_2) + repr, (self.test_document, self.test_document_2) ) ) - def test_cabinet_document_delete(self): - self.document = self.upload_document() - - self._create_test_cabinet() - self.test_cabinet.documents.add(self.document) - - response = self.delete( + def _request_test_cabinet_document_remove_api_view(self): + return self.delete( viewname='rest_api:cabinet-document', kwargs={ - 'pk': self.test_cabinet.pk, 'document_pk': self.document.pk + 'pk': self.test_cabinet.pk, 'document_pk': self.test_document.pk } ) + + def test_cabinet_document_remove_api_view(self): + self.upload_document() + + self._create_test_cabinet() + self.test_cabinet.documents.add(self.test_document) + + self.grant_permission( + permission=permission_cabinet_remove_document + ) + + response = self._request_test_cabinet_document_remove_api_view() self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(self.test_cabinet.documents.count(), 0) - def test_cabinet_document_detail(self): - self.document = self.upload_document() + def test_cabinet_document_detail_api_view(self): + self.upload_document() self._create_test_cabinet() - self.test_cabinet.documents.add(self.document) + self.test_cabinet.documents.add(self.test_document) + self.grant_permission( + permission=permission_cabinet_view + ) + self.grant_permission( + permission=permission_document_view + ) response = self.get( viewname='rest_api:cabinet-document', kwargs={ - 'pk': self.test_cabinet.pk, 'document_pk': self.document.pk + 'pk': self.test_cabinet.pk, 'document_pk': self.test_document.pk } ) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( - response.data['uuid'], force_text(self.document.uuid) + response.data['uuid'], force_text(self.test_document.uuid) ) - def test_cabinet_document_list(self): - self.document = self.upload_document() + def test_cabinet_document_list_api_view(self): + self.upload_document() self._create_test_cabinet() - self.test_cabinet.documents.add(self.document) + self.test_cabinet.documents.add(self.test_document) + + self.grant_permission(permission=permission_cabinet_view) + self.grant_permission(permission=permission_document_view) response = self.get( viewname='rest_api:cabinet-document-list', kwargs={ @@ -281,32 +300,17 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual( - response.data['results'][0]['uuid'], force_text(self.document.uuid) + response.data['results'][0]['uuid'], force_text(self.test_document.uuid) ) - def test_cabinet_remove_document(self): - self.document = self.upload_document() - - self._create_test_cabinet() - - self.test_cabinet.documents.add(self.document) - - response = self.delete( - viewname='rest_api:cabinet-document', kwargs={ - 'pk': self.test_cabinet.pk, 'document_pk': self.document.pk - } - ) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - self.assertEqual(self.test_cabinet.documents.count(), 0) - - def test_cabinet_add_document(self): - self.document = self.upload_document() + def test_cabinet_add_document_api_view(self): + self.upload_document() self._create_test_cabinet() response = self.post( data={ - 'documents_pk_list': '{}'.format(self.document.pk) + 'documents_pk_list': '{}'.format(self.test_document.pk) }, kwargs={ 'pk': self.test_cabinet.pk }, viewname='rest_api:cabinet-document-list' @@ -314,19 +318,20 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertQuerysetEqual( - self.test_cabinet.documents.all(), (repr(self.document),) + self.test_cabinet.documents.all(), (repr(self.test_document),) ) - def test_cabinet_add_multiple_documents(self): - self.document = self.upload_document() - self.document_2 = self.upload_document() + def test_cabinet_add_multiple_documents_api_view(self): + self.upload_document() + self.test_document_2 = self.upload_document() self._create_test_cabinet() + self.grant_permission(permission=permission_cabinet_add_document) response = self.post( data={ 'documents_pk_list': '{},{}'.format( - self.document.pk, self.document_2.pk + self.test_document.pk, self.test_document_2.pk ), }, kwargs={ 'pk': self.test_cabinet.pk @@ -336,6 +341,6 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes self.assertQuerysetEqual( self.test_cabinet.documents.all(), map( - repr, (self.document, self.document_2) + repr, (self.test_document, self.test_document_2) ) ) diff --git a/mayan/apps/cabinets/tests/test_events.py b/mayan/apps/cabinets/tests/test_events.py index 08778b8330..5f0b22add5 100644 --- a/mayan/apps/cabinets/tests/test_events.py +++ b/mayan/apps/cabinets/tests/test_events.py @@ -7,35 +7,31 @@ from mayan.apps.documents.tests.test_models import GenericDocumentTestCase from ..events import ( event_cabinets_add_document, event_cabinets_remove_document ) -from ..models import Cabinet -from .literals import TEST_CABINET_LABEL +from .mixins import CabinetTestMixin -class CabinetsEventsTestCase(GenericDocumentTestCase): +class CabinetsEventsTestCase(CabinetTestMixin, GenericDocumentTestCase): def setUp(self): super(CabinetsEventsTestCase, self).setUp() - self._create_cabinet() - - def _create_cabinet(self): - self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) + self._create_test_cabinet() def test_document_cabinet_add_event(self): Action.objects.all().delete() - self.cabinet.add_document(document=self.document) + self.test_cabinet.add_document(document=self.test_document) - self.assertEqual(Action.objects.last().target, self.document) + self.assertEqual(Action.objects.last().target, self.test_document) self.assertEqual( Action.objects.last().verb, event_cabinets_add_document.id ) def test_document_cabinet_remove_event(self): - self.cabinet.add_document(document=self.document) + self.test_cabinet.add_document(document=self.test_document) Action.objects.all().delete() - self.cabinet.remove_document(document=self.document) + self.test_cabinet.remove_document(document=self.test_document) - self.assertEqual(Action.objects.first().target, self.document) + self.assertEqual(Action.objects.first().target, self.test_document) self.assertEqual( Action.objects.first().verb, event_cabinets_remove_document.id diff --git a/mayan/apps/cabinets/tests/test_models.py b/mayan/apps/cabinets/tests/test_models.py index 44ba3ac4df..1dc8300aad 100644 --- a/mayan/apps/cabinets/tests/test_models.py +++ b/mayan/apps/cabinets/tests/test_models.py @@ -1,7 +1,6 @@ from __future__ import unicode_literals from django.core.exceptions import ValidationError -from django.test import override_settings from mayan.apps.common.tests import BaseTestCase from mayan.apps.documents.tests import DocumentTestMixin @@ -9,18 +8,18 @@ from mayan.apps.documents.tests import DocumentTestMixin from ..models import Cabinet from .literals import TEST_CABINET_LABEL +from .mixins import CabinetTestMixin -@override_settings(OCR_AUTO_OCR=False) -class CabinetTestCase(DocumentTestMixin, BaseTestCase): +class CabinetTestCase(CabinetTestMixin, DocumentTestMixin, BaseTestCase): def test_cabinet_creation(self): - cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) + self._create_test_cabinet() self.assertEqual(Cabinet.objects.all().count(), 1) - self.assertQuerysetEqual(Cabinet.objects.all(), (repr(cabinet),)) + self.assertQuerysetEqual(Cabinet.objects.all(), (repr(self.test_cabinet),)) def test_cabinet_duplicate_creation(self): - cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) + self._create_test_cabinet() with self.assertRaises(ValidationError): cabinet_2 = Cabinet(label=TEST_CABINET_LABEL) @@ -28,39 +27,39 @@ class CabinetTestCase(DocumentTestMixin, BaseTestCase): cabinet_2.save() self.assertEqual(Cabinet.objects.all().count(), 1) - self.assertQuerysetEqual(Cabinet.objects.all(), (repr(cabinet),)) + self.assertQuerysetEqual(Cabinet.objects.all(), (repr(self.test_cabinet),)) def test_inner_cabinet_creation(self): - cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) + self._create_test_cabinet() inner_cabinet = Cabinet.objects.create( - parent=cabinet, label=TEST_CABINET_LABEL + parent=self.test_cabinet, label=TEST_CABINET_LABEL ) self.assertEqual(Cabinet.objects.all().count(), 2) self.assertQuerysetEqual( - Cabinet.objects.all(), map(repr, (cabinet, inner_cabinet)) + Cabinet.objects.all(), map(repr, (self.test_cabinet, inner_cabinet)) ) def test_addition_of_documents(self): - cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) - cabinet.documents.add(self.document) + self._create_test_cabinet() + self.test_cabinet.documents.add(self.test_document) - self.assertEqual(cabinet.documents.count(), 1) + self.assertEqual(self.test_cabinet.documents.count(), 1) self.assertQuerysetEqual( - cabinet.documents.all(), (repr(self.document),) + self.test_cabinet.documents.all(), (repr(self.test_document),) ) def test_addition_and_deletion_of_documents(self): - cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) - cabinet.documents.add(self.document) + self._create_test_cabinet() + self.test_cabinet.documents.add(self.test_document) - self.assertEqual(cabinet.documents.count(), 1) + self.assertEqual(self.test_cabinet.documents.count(), 1) self.assertQuerysetEqual( - cabinet.documents.all(), (repr(self.document),) + self.test_cabinet.documents.all(), (repr(self.test_document),) ) - cabinet.documents.remove(self.document) + self.test_cabinet.documents.remove(self.test_document) - self.assertEqual(cabinet.documents.count(), 0) - self.assertQuerysetEqual(cabinet.documents.all(), ()) + self.assertEqual(self.test_cabinet.documents.count(), 0) + self.assertQuerysetEqual(self.test_cabinet.documents.all(), ()) diff --git a/mayan/apps/cabinets/tests/test_views.py b/mayan/apps/cabinets/tests/test_views.py index abe574ca07..f9c1c00542 100644 --- a/mayan/apps/cabinets/tests/test_views.py +++ b/mayan/apps/cabinets/tests/test_views.py @@ -1,5 +1,6 @@ from __future__ import absolute_import, unicode_literals +from mayan.apps.common.tests import GenericViewTestCase from mayan.apps.documents.tests import GenericDocumentViewTestCase from ..models import Cabinet @@ -9,16 +10,10 @@ from ..permissions import ( permission_cabinet_remove_document, permission_cabinet_view ) from .literals import TEST_CABINET_LABEL, TEST_CABINET_EDITED_LABEL +from .mixins import CabinetTestMixin -class CabinetViewTestCase(GenericDocumentViewTestCase): - def setUp(self): - super(CabinetViewTestCase, self).setUp() - self.login_user() - - def _create_cabinet(self): - self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) - +class CabinetViewTestCase(CabinetTestMixin, GenericViewTestCase): def _request_create_cabinet(self, label): return self.post( 'cabinets:cabinet_create', data={ @@ -28,209 +23,222 @@ class CabinetViewTestCase(GenericDocumentViewTestCase): def test_cabinet_create_view_no_permission(self): response = self._request_create_cabinet(label=TEST_CABINET_LABEL) - self.assertEquals(response.status_code, 403) + self.assertEqual(Cabinet.objects.count(), 0) def test_cabinet_create_view_with_permission(self): self.grant_permission(permission=permission_cabinet_create) response = self._request_create_cabinet(label=TEST_CABINET_LABEL) - self.assertEqual(response.status_code, 302) + self.assertEqual(Cabinet.objects.count(), 1) self.assertEqual(Cabinet.objects.first().label, TEST_CABINET_LABEL) def test_cabinet_create_duplicate_view_with_permission(self): - self._create_cabinet() + self._create_test_cabinet() self.grant_permission(permission=permission_cabinet_create) - response = self._request_create_cabinet(label=TEST_CABINET_LABEL) + response = self._request_create_cabinet(label=TEST_CABINET_LABEL) # HTTP 200 with error message self.assertEqual(response.status_code, 200) + self.assertEqual(Cabinet.objects.count(), 1) - self.assertEqual(Cabinet.objects.first().pk, self.cabinet.pk) + self.assertEqual(Cabinet.objects.first().pk, self.test_cabinet.pk) def _request_delete_cabinet(self): - return self.post('cabinets:cabinet_delete', args=(self.cabinet.pk,)) + return self.post( + viewname='cabinets:cabinet_delete', kwargs={ + 'pk': self.test_cabinet.pk + } + ) def test_cabinet_delete_view_no_permission(self): - self._create_cabinet() + self._create_test_cabinet() response = self._request_delete_cabinet() self.assertEqual(response.status_code, 403) + self.assertEqual(Cabinet.objects.count(), 1) def test_cabinet_delete_view_with_access(self): - self._create_cabinet() - self.grant_access(obj=self.cabinet, permission=permission_cabinet_delete) + self._create_test_cabinet() + self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_delete) response = self._request_delete_cabinet() - self.assertEqual(response.status_code, 302) + self.assertEqual(Cabinet.objects.count(), 0) def _request_edit_cabinet(self): return self.post( - 'cabinets:cabinet_edit', args=(self.cabinet.pk,), data={ + viewname='cabinets:cabinet_edit', kwargs={ + 'pk': self.test_cabinet.pk + }, data={ 'label': TEST_CABINET_EDITED_LABEL } ) def test_cabinet_edit_view_no_permission(self): - self._create_cabinet() + self._create_test_cabinet() response = self._request_edit_cabinet() self.assertEqual(response.status_code, 403) - self.cabinet.refresh_from_db() - self.assertEqual(self.cabinet.label, TEST_CABINET_LABEL) + + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.label, TEST_CABINET_LABEL) def test_cabinet_edit_view_with_access(self): - self._create_cabinet() + self._create_test_cabinet() - self.grant_access(obj=self.cabinet, permission=permission_cabinet_edit) + self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_edit) response = self._request_edit_cabinet() - self.assertEqual(response.status_code, 302) - self.cabinet.refresh_from_db() - self.assertEqual(self.cabinet.label, TEST_CABINET_EDITED_LABEL) + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.label, TEST_CABINET_EDITED_LABEL) + + +class CabinetDocumentViewTestCase(CabinetTestMixin, GenericDocumentViewTestCase): def _add_document_to_cabinet(self): return self.post( - 'cabinets:cabinet_add_document', args=(self.document.pk,), data={ - 'cabinets': self.cabinet.pk + viewname='cabinets:cabinet_add_document', kwargs={ + 'pk': self.test_document.pk + }, data={ + 'cabinets': self.test_cabinet.pk } ) def test_cabinet_add_document_view_no_permission(self): - self._create_cabinet() + self._create_test_cabinet() self.grant_permission(permission=permission_cabinet_view) response = self._add_document_to_cabinet() - self.assertContains( - response, text='Select a valid choice.', status_code=200 + response=response, text='Select a valid choice.', status_code=200 ) - self.cabinet.refresh_from_db() - self.assertEqual(self.cabinet.documents.count(), 0) + + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.documents.count(), 0) def test_cabinet_add_document_view_with_access(self): - self._create_cabinet() + self._create_test_cabinet() - self.grant_access(obj=self.cabinet, permission=permission_cabinet_view) + self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_view) self.grant_access( - obj=self.cabinet, permission=permission_cabinet_add_document + obj=self.test_cabinet, permission=permission_cabinet_add_document ) self.grant_access( - obj=self.document, permission=permission_cabinet_add_document + obj=self.test_document, permission=permission_cabinet_add_document ) response = self._add_document_to_cabinet() - - self.cabinet.refresh_from_db() - self.assertEqual(response.status_code, 302) - self.assertEqual(self.cabinet.documents.count(), 1) + + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.documents.count(), 1) self.assertQuerysetEqual( - self.cabinet.documents.all(), (repr(self.document),) + self.test_cabinet.documents.all(), (repr(self.test_document),) ) def _request_add_multiple_documents_to_cabinet(self): return self.post( - 'cabinets:cabinet_add_multiple_documents', data={ - 'id_list': (self.document.pk,), 'cabinets': self.cabinet.pk + viewname='cabinets:cabinet_add_multiple_documents', data={ + 'id_list': (self.test_document.pk,), 'cabinets': self.test_cabinet.pk } ) def test_cabinet_add_multiple_documents_view_no_permission(self): - self._create_cabinet() + self._create_test_cabinet() self.grant_permission(permission=permission_cabinet_view) response = self._request_add_multiple_documents_to_cabinet() - self.assertContains( - response, text='Select a valid choice', status_code=200 + response=response, text='Select a valid choice', status_code=200 ) - self.cabinet.refresh_from_db() - self.assertEqual(self.cabinet.documents.count(), 0) + + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.documents.count(), 0) def test_cabinet_add_multiple_documents_view_with_access(self): - self._create_cabinet() + self._create_test_cabinet() self.grant_access( - obj=self.cabinet, permission=permission_cabinet_add_document + obj=self.test_cabinet, permission=permission_cabinet_add_document ) self.grant_access( - obj=self.document, permission=permission_cabinet_add_document + obj=self.test_document, permission=permission_cabinet_add_document ) response = self._request_add_multiple_documents_to_cabinet() - self.assertEqual(response.status_code, 302) - self.cabinet.refresh_from_db() - self.assertEqual(self.cabinet.documents.count(), 1) + + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.documents.count(), 1) self.assertQuerysetEqual( - self.cabinet.documents.all(), (repr(self.document),) + self.test_cabinet.documents.all(), (repr(self.test_document),) ) def _request_remove_document_from_cabinet(self): return self.post( - 'cabinets:document_cabinet_remove', args=(self.document.pk,), - data={ - 'cabinets': (self.cabinet.pk,), + viewname='cabinets:document_cabinet_remove', kwargs={ + 'pk': self.test_document.pk + }, data={ + 'cabinets': (self.test_cabinet.pk,), } ) def test_cabinet_remove_document_view_no_permission(self): - self._create_cabinet() + self._create_test_cabinet() - self.cabinet.documents.add(self.document) + self.test_cabinet.documents.add(self.test_document) response = self._request_remove_document_from_cabinet() - self.assertContains( - response, text='Select a valid choice', status_code=200 + response=response, text='Select a valid choice', status_code=200 ) - self.cabinet.refresh_from_db() - self.assertEqual(self.cabinet.documents.count(), 1) + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.documents.count(), 1) def test_cabinet_remove_document_view_with_access(self): - self._create_cabinet() + self._create_test_cabinet() - self.cabinet.documents.add(self.document) + self.test_cabinet.documents.add(self.test_document) self.grant_access( - obj=self.cabinet, permission=permission_cabinet_remove_document + obj=self.test_cabinet, permission=permission_cabinet_remove_document ) self.grant_access( - obj=self.document, permission=permission_cabinet_remove_document + obj=self.test_document, permission=permission_cabinet_remove_document ) response = self._request_remove_document_from_cabinet() - self.assertEqual(response.status_code, 302) - self.cabinet.refresh_from_db() - self.assertEqual(self.cabinet.documents.count(), 0) + + self.test_cabinet.refresh_from_db() + self.assertEqual(self.test_cabinet.documents.count(), 0) def _request_cabinet_list(self): - return self.get('cabinets:cabinet_list') + return self.get(viewname='cabinets:cabinet_list') def test_cabinet_list_view_no_permission(self): - self._create_cabinet() + self._create_test_cabinet() + response = self._request_cabinet_list() self.assertNotContains( - response, text=self.cabinet.label, status_code=200 + response, text=self.test_cabinet.label, status_code=200 ) def test_cabinet_list_view_with_access(self): - self._create_cabinet() - self.grant_access(obj=self.cabinet, permission=permission_cabinet_view) - response = self._request_cabinet_list() + self._create_test_cabinet() + self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_view) + response = self._request_cabinet_list() self.assertContains( - response, text=self.cabinet.label, status_code=200 + response, text=self.test_cabinet.label, status_code=200 ) diff --git a/mayan/apps/cabinets/tests/test_wizard_steps.py b/mayan/apps/cabinets/tests/test_wizard_steps.py index a36f5ae9d9..058579f1d9 100644 --- a/mayan/apps/cabinets/tests/test_wizard_steps.py +++ b/mayan/apps/cabinets/tests/test_wizard_steps.py @@ -11,23 +11,21 @@ from mayan.apps.sources.tests.literals import ( ) from mayan.apps.sources.wizards import WizardStep -from ..models import Cabinet from ..wizard_steps import WizardStepCabinets -from .literals import TEST_CABINET_LABEL +from .mixins import CabinetTestMixin -class CabinetDocumentUploadTestCase(GenericDocumentViewTestCase): +class CabinetDocumentUploadTestCase(CabinetTestMixin, GenericDocumentViewTestCase): + auto_upload_document = False + def setUp(self): super(CabinetDocumentUploadTestCase, self).setUp() - self.login_user() - self.source = WebFormSource.objects.create( + self.test_source = WebFormSource.objects.create( enabled=True, label=TEST_SOURCE_LABEL, uncompress=TEST_SOURCE_UNCOMPRESS_N ) - self.document.delete() - def tearDown(self): super(CabinetDocumentUploadTestCase, self).tearDown() WizardStep.reregister_all() @@ -35,26 +33,24 @@ class CabinetDocumentUploadTestCase(GenericDocumentViewTestCase): def _request_upload_interactive_document_create_view(self): with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object: return self.post( - viewname='sources:upload_interactive', args=(self.source.pk,), - data={ - 'document_type_id': self.document_type.pk, + viewname='sources:upload_interactive', kwargs={ + 'source_id': self.test_source.pk + }, data={ + 'document_type_id': self.test_document_type.pk, 'source-file': file_object, - 'cabinets': self.cabinet.pk + 'cabinets': self.test_cabinet.pk } ) - def _create_cabinet(self): - self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL) - def test_upload_interactive_view_with_access(self): - self._create_cabinet() + self._create_test_cabinet() self.grant_access( permission=permission_document_create, obj=self.document_type ) response = self._request_upload_interactive_document_create_view() self.assertEqual(response.status_code, 302) - self.assertTrue(self.cabinet in Document.objects.first().cabinets.all()) + self.assertTrue(self.test_cabinet in Document.objects.first().cabinets.all()) def _request_wizard_view(self): return self.get(viewname='sources:document_create_multiple') @@ -63,9 +59,10 @@ class CabinetDocumentUploadTestCase(GenericDocumentViewTestCase): WizardStep.deregister_all() WizardStep.reregister(name=WizardStepCabinets.name) - self._create_cabinet() + self._create_test_cabinet() self.grant_access( permission=permission_document_create, obj=self.document_type + ) response = self._request_wizard_view() self.assertEqual(response.status_code, 200) diff --git a/mayan/apps/checkouts/tests/mixins.py b/mayan/apps/checkouts/tests/mixins.py index ee75997ff6..e73b941d12 100644 --- a/mayan/apps/checkouts/tests/mixins.py +++ b/mayan/apps/checkouts/tests/mixins.py @@ -8,13 +8,18 @@ from ..models import DocumentCheckout class DocumentCheckoutTestMixin(object): - def _check_out_document(self, user=None): - if not user: - user = self.user + _test_document_check_out_seconds = 0.1 - expiration_datetime = now() + datetime.timedelta(days=1) + def _check_out_test_document(self, user=None): + if not user: + user = self._test_case_user + + self._check_out_expiration_datetime = now() + datetime.timedelta( + seconds=self._test_document_check_out_seconds + ) self.test_check_out = DocumentCheckout.objects.check_out_document( - document=self.document, expiration_datetime=expiration_datetime, - user=user, block_new_version=True + document=self.test_document, + expiration_datetime=self._check_out_expiration_datetime, + block_new_version=True, user=user ) diff --git a/mayan/apps/checkouts/tests/test_api.py b/mayan/apps/checkouts/tests/test_api.py index 5d2466e102..71ec5ea536 100644 --- a/mayan/apps/checkouts/tests/test_api.py +++ b/mayan/apps/checkouts/tests/test_api.py @@ -1,6 +1,5 @@ from __future__ import unicode_literals -from django.test import override_settings from django.utils.encoding import force_text from rest_framework import status @@ -17,107 +16,121 @@ from ..permissions import ( from .mixins import DocumentCheckoutTestMixin -@override_settings(OCR_AUTO_OCR=False) class CheckoutsAPITestCase(DocumentCheckoutTestMixin, DocumentTestMixin, BaseAPITestCase): - def setUp(self): - super(CheckoutsAPITestCase, self).setUp() - self.login_user() - def _request_checkedout_document_view(self): return self.get( viewname='rest_api:checkedout-document-view', - args=(self.test_check_out.pk,) + kwargs={'pk': self.test_check_out.pk} ) def test_checkedout_document_view_no_access(self): - self._check_out_document() + self._check_out_test_document() + response = self._request_checkedout_document_view() self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_checkedout_document_view_with_checkout_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - permission=permission_document_check_out_detail_view, obj=self.document + obj=self.test_document, + permission=permission_document_check_out_detail_view ) + response = self._request_checkedout_document_view() self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_checkedout_document_view_with_document_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - permission=permission_document_view, obj=self.document + obj=self.test_document, permission=permission_document_view ) + response = self._request_checkedout_document_view() self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_checkedout_document_view_with_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - permission=permission_document_view, obj=self.document + obj=self.test_document, permission=permission_document_view ) self.grant_access( - permission=permission_document_check_out_detail_view, obj=self.document + obj=self.test_document, + permission=permission_document_check_out_detail_view ) + response = self._request_checkedout_document_view() self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data['document']['uuid'], force_text(self.document.uuid)) + self.assertEqual( + response.data['document']['uuid'], + force_text(self.test_document.uuid) + ) def _request_document_checkout_view(self): return self.post( viewname='rest_api:checkout-document-list', data={ - 'document_pk': self.document.pk, + 'document_pk': self.test_document.pk, 'expiration_datetime': '2099-01-01T12:00' } ) def test_document_checkout_no_access(self): response = self._request_document_checkout_view() + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(DocumentCheckout.objects.count(), 0) def test_document_checkout_with_access(self): - self.grant_access(permission=permission_document_check_out, obj=self.document) + self.grant_access(permission=permission_document_check_out, obj=self.test_document) + response = self._request_document_checkout_view() self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self.assertEqual( - DocumentCheckout.objects.first().document, self.document + DocumentCheckout.objects.first().document, self.test_document ) def _request_checkout_list_view(self): return self.get(viewname='rest_api:checkout-document-list') def test_checkout_list_view_no_access(self): - self._check_out_document() + self._check_out_test_document() + response = self._request_checkout_list_view() self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertNotContains(response=response, text=self.document.uuid) + self.assertNotContains(response=response, text=self.test_document.uuid) def test_checkout_list_view_with_document_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - permission=permission_document_view, obj=self.document + permission=permission_document_view, obj=self.test_document ) + response = self._request_checkout_list_view() self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertNotContains(response=response, text=self.document.uuid) + self.assertNotContains(response=response, text=self.test_document.uuid) def test_checkout_list_view_with_checkout_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - permission=permission_document_check_out_detail_view, obj=self.document + obj=self.test_document, + permission=permission_document_check_out_detail_view ) + response = self._request_checkout_list_view() self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertNotContains(response=response, text=self.document.uuid) + self.assertNotContains(response=response, text=self.test_document.uuid) def test_checkout_list_view_with_access(self): - self._check_out_document() + self._check_out_test_document() + self.grant_access( - permission=permission_document_view, obj=self.document + permission=permission_document_view, obj=self.test_document ) self.grant_access( - permission=permission_document_check_out_detail_view, obj=self.document + obj=self.test_document, + permission=permission_document_check_out_detail_view ) + response = self._request_checkout_list_view() self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertContains(response=response, text=self.document.uuid) + self.assertContains(response=response, text=self.test_document.uuid) diff --git a/mayan/apps/checkouts/tests/test_links.py b/mayan/apps/checkouts/tests/test_links.py index ba8b5de4d2..a6d1475d65 100644 --- a/mayan/apps/checkouts/tests/test_links.py +++ b/mayan/apps/checkouts/tests/test_links.py @@ -11,14 +11,10 @@ from .mixins import DocumentCheckoutTestMixin class CheckoutLinksTestCase(DocumentCheckoutTestMixin, GenericDocumentViewTestCase): - def setUp(self): - super(CheckoutLinksTestCase, self).setUp() - self.login_user() - def _resolve_checkout_link(self): - self.add_test_view(test_object=self.document) + self.add_test_view(test_object=self.test_document) context = self.get_test_view() - context['user'] = self.user + context['user'] = self._test_case_user return link_check_out_document.resolve(context=context) def test_checkout_link_no_access(self): @@ -27,15 +23,15 @@ class CheckoutLinksTestCase(DocumentCheckoutTestMixin, GenericDocumentViewTestCa def test_checkout_link_with_access(self): self.grant_access( - obj=self.document, permission=permission_document_check_out + obj=self.test_document, permission=permission_document_check_out ) resolved_link = self._resolve_checkout_link() self.assertNotEqual(resolved_link, None) def _resolve_checkout_info_link(self): - self.add_test_view(test_object=self.document) + self.add_test_view(test_object=self.test_document) context = self.get_test_view() - context['user'] = self.user + context['user'] = self._test_case_user return link_check_out_info.resolve(context=context) def test_checkout_info_link_no_access(self): @@ -44,7 +40,8 @@ class CheckoutLinksTestCase(DocumentCheckoutTestMixin, GenericDocumentViewTestCa def test_checkout_info_link_with_access(self): self.grant_access( - obj=self.document, permission=permission_document_check_out_detail_view + obj=self.test_document, + permission=permission_document_check_out_detail_view ) resolved_link = self._resolve_checkout_info_link() self.assertNotEqual(resolved_link, None) diff --git a/mayan/apps/checkouts/tests/test_models.py b/mayan/apps/checkouts/tests/test_models.py index d07b588bfa..4186a98fb6 100644 --- a/mayan/apps/checkouts/tests/test_models.py +++ b/mayan/apps/checkouts/tests/test_models.py @@ -1,14 +1,9 @@ from __future__ import unicode_literals -import datetime -import logging import time -from django.test import override_settings -from django.utils.timezone import now - from mayan.apps.common.tests import BaseTestCase -from mayan.apps.documents.tests import DocumentTestMixin +from mayan.apps.documents.tests import GenericDocumentTestCase, DocumentTestMixin from mayan.apps.documents.tests.literals import TEST_SMALL_DOCUMENT_PATH from ..exceptions import ( @@ -17,126 +12,107 @@ from ..exceptions import ( ) from ..models import DocumentCheckout, NewVersionBlock +from .mixins import DocumentCheckoutTestMixin + + +class DocumentCheckoutTestCase(DocumentCheckoutTestMixin, GenericDocumentTestCase): + # auto -@override_settings(OCR_AUTO_OCR=False) -class DocumentCheckoutTestCase(DocumentTestMixin, BaseTestCase): def test_document_check_out(self): - expiration_datetime = now() + datetime.timedelta(days=1) + self._check_out_test_document() - DocumentCheckout.objects.check_out_document( - document=self.document, expiration_datetime=expiration_datetime, - user=self.admin_user, block_new_version=True - ) - - self.assertTrue(self.document.is_checked_out()) self.assertTrue( DocumentCheckout.objects.is_checked_out( - document=self.document + document=self.test_document ) ) def test_checkin_in(self): - expiration_datetime = now() + datetime.timedelta(days=1) + self._check_out_test_document() - DocumentCheckout.objects.check_out_document( - document=self.document, expiration_datetime=expiration_datetime, - user=self.admin_user, block_new_version=True - ) + self.test_document.check_in() - self.document.check_in() - - self.assertFalse(self.document.is_checked_out()) + self.assertFalse(self.test_document.is_checked_out()) self.assertFalse( DocumentCheckout.objects.is_checked_out( - document=self.document + document=self.test_document ) ) def test_double_check_out(self): - expiration_datetime = now() + datetime.timedelta(days=1) - - DocumentCheckout.objects.check_out_document( - document=self.document, expiration_datetime=expiration_datetime, - user=self.admin_user, block_new_version=True - ) + self._create_test_case_superuser() + self._check_out_test_document() with self.assertRaises(DocumentAlreadyCheckedOut): DocumentCheckout.objects.check_out_document( - document=self.document, - expiration_datetime=expiration_datetime, user=self.admin_user, + document=self.test_document, + expiration_datetime=self._check_out_expiration_datetime, + user=self._test_case_superuser, block_new_version=True ) def test_checkin_without_checkout(self): with self.assertRaises(DocumentNotCheckedOut): - self.document.check_in() + self.test_document.check_in() def test_auto_check_in(self): - expiration_datetime = now() + datetime.timedelta(seconds=.1) + self._check_out_test_document() - DocumentCheckout.objects.check_out_document( - document=self.document, expiration_datetime=expiration_datetime, - user=self.admin_user, block_new_version=True - ) - - time.sleep(.11) + # Ensure we wait from longer than the document check out expiration + time.sleep(self._test_document_check_out_seconds + 0.1) DocumentCheckout.objects.check_in_expired_check_outs() - self.assertFalse(self.document.is_checked_out()) + self.assertFalse(self.test_document.is_checked_out()) -@override_settings(OCR_AUTO_OCR=False) -class NewVersionBlockTestCase(DocumentTestMixin, BaseTestCase): +class NewVersionBlockTestCase(DocumentCheckoutTestMixin, DocumentTestMixin, BaseTestCase): def test_blocking(self): - NewVersionBlock.objects.block(document=self.document) + NewVersionBlock.objects.block(document=self.test_document) self.assertEqual(NewVersionBlock.objects.count(), 1) self.assertEqual( - NewVersionBlock.objects.first().document, self.document + NewVersionBlock.objects.first().document, self.test_document ) def test_blocking_new_versions(self): # Silence unrelated logging - logging.getLogger('documents.models').setLevel(logging.CRITICAL) + self._silence_logger(name='mayan.apps.documents.models') - NewVersionBlock.objects.block(document=self.document) + NewVersionBlock.objects.block(document=self.test_document) with self.assertRaises(NewDocumentVersionNotAllowed): with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object: - self.document.new_version(file_object=file_object) + self.test_document.new_version(file_object=file_object) def test_unblocking(self): - NewVersionBlock.objects.create(document=self.document) + NewVersionBlock.objects.create(document=self.test_document) - NewVersionBlock.objects.unblock(document=self.document) + NewVersionBlock.objects.unblock(document=self.test_document) self.assertEqual(NewVersionBlock.objects.count(), 0) def test_is_blocked(self): - NewVersionBlock.objects.create(document=self.document) + NewVersionBlock.objects.create(document=self.test_document) self.assertTrue( - NewVersionBlock.objects.is_blocked(document=self.document) + NewVersionBlock.objects.is_blocked(document=self.test_document) ) NewVersionBlock.objects.all().delete() self.assertFalse( - NewVersionBlock.objects.is_blocked(document=self.document) + NewVersionBlock.objects.is_blocked(document=self.test_document) ) def test_version_creation_blocking(self): # Silence unrelated logging - logging.getLogger('documents.models').setLevel(logging.CRITICAL) + self._silence_logger(name='mayan.apps.documents.models') - expiration_datetime = now() + datetime.timedelta(days=1) + self._create_test_case_superuser() - DocumentCheckout.objects.check_out_document( - document=self.document, expiration_datetime=expiration_datetime, - user=self.admin_user, block_new_version=True - ) + self._check_out_test_document() with self.assertRaises(NewDocumentVersionNotAllowed): with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object: - self.document.new_version(file_object=file_object) + self.test_document.new_version(file_object=file_object) diff --git a/mayan/apps/checkouts/tests/test_views.py b/mayan/apps/checkouts/tests/test_views.py index 8e29c1e95a..f41ad311c9 100644 --- a/mayan/apps/checkouts/tests/test_views.py +++ b/mayan/apps/checkouts/tests/test_views.py @@ -1,7 +1,5 @@ from __future__ import unicode_literals -import logging - from mayan.apps.common.literals import TIME_DELTA_UNIT_DAYS from mayan.apps.documents.permissions import permission_document_view from mayan.apps.documents.tests import GenericDocumentViewTestCase @@ -18,73 +16,74 @@ from .mixins import DocumentCheckoutTestMixin class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentViewTestCase): - def setUp(self): - super(DocumentCheckoutViewTestCase, self).setUp() - self.login_user() - def _request_document_check_in_get_view(self): return self.get( - viewname='checkouts:check_in_document', args=(self.document.pk,), + viewname='checkouts:check_in_document', kwargs={ + 'pk': self.test_document.pk + } ) def test_check_in_document_get_view_no_permission(self): - self._check_out_document() + self._check_out_test_document() response = self._request_document_check_in_get_view() self.assertContains( - response=response, text=self.document.label, status_code=200 + response=response, text=self.test_document.label, status_code=200 ) - self.assertTrue(self.document.is_checked_out()) + self.assertTrue(self.test_document.is_checked_out()) def test_check_in_document_get_view_with_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - obj=self.document, permission=permission_document_check_in + obj=self.test_document, permission=permission_document_check_in ) response = self._request_document_check_in_get_view() self.assertContains( - response=response, text=self.document.label, status_code=200 + response=response, text=self.test_document.label, status_code=200 ) - self.assertTrue(self.document.is_checked_out()) + self.assertTrue(self.test_document.is_checked_out()) def _request_document_check_in_post_view(self): return self.post( - viewname='checkouts:check_in_document', args=(self.document.pk,), + viewname='checkouts:check_in_document', kwargs={ + 'pk': self.test_document.pk + } ) def test_check_in_document_post_view_no_permission(self): - self._check_out_document() + self._check_out_test_document() response = self._request_document_check_in_post_view() self.assertEquals(response.status_code, 403) - self.assertTrue(self.document.is_checked_out()) + self.assertTrue(self.test_document.is_checked_out()) def test_check_in_document_post_view_with_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - obj=self.document, permission=permission_document_check_in + obj=self.test_document, permission=permission_document_check_in ) response = self._request_document_check_in_post_view() self.assertEquals(response.status_code, 302) - self.assertFalse(self.document.is_checked_out()) + self.assertFalse(self.test_document.is_checked_out()) self.assertFalse( DocumentCheckout.objects.is_checked_out( - document=self.document + document=self.test_document ) ) def _request_document_checkout_view(self): return self.post( - viewname='checkouts:check_out_document', args=(self.document.pk,), - data={ + viewname='checkouts:check_out_document', kwargs={ + 'pk': self.test_document.pk + }, data={ 'expiration_datetime_0': 2, 'expiration_datetime_1': TIME_DELTA_UNIT_DAYS, 'block_new_version': True @@ -94,49 +93,51 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie def test_check_out_document_view_no_permission(self): response = self._request_document_checkout_view() self.assertEquals(response.status_code, 403) - self.assertFalse(self.document.is_checked_out()) + + self.assertFalse(self.test_document.is_checked_out()) def test_check_out_document_view_with_access(self): self.grant_access( - obj=self.document, permission=permission_document_check_out + obj=self.test_document, permission=permission_document_check_out ) self.grant_access( - obj=self.document, + obj=self.test_document, permission=permission_document_check_out_detail_view ) response = self._request_document_checkout_view() self.assertEquals(response.status_code, 302) - self.assertTrue(self.document.is_checked_out()) + + self.assertTrue(self.test_document.is_checked_out()) def _request_check_out_detail_view(self): return self.get( - viewname='checkouts:check_out_info', args=(self.document.pk,), + viewname='checkouts:check_out_info', kwargs={ + 'pk': self.test_document.pk + } ) def test_checkout_detail_view_no_permission(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - obj=self.document, + obj=self.test_document, permission=permission_document_check_out ) response = self._request_check_out_detail_view() - self.assertNotContains( response, text=STATE_LABELS[STATE_CHECKED_OUT], status_code=403 ) def test_checkout_detail_view_with_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - obj=self.document, + obj=self.test_document, permission=permission_document_check_out_detail_view ) response = self._request_check_out_detail_view() - self.assertContains( response, text=STATE_LABELS[STATE_CHECKED_OUT], status_code=200 ) @@ -145,36 +146,33 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie return self.get(viewname='checkouts:check_out_list') def test_checkout_list_view_no_permission(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - obj=self.document, + obj=self.test_document, permission=permission_document_view ) response = self._request_check_out_list_view() - self.assertNotContains( - response=response, text=self.document.label, status_code=200 + response=response, text=self.test_document.label, status_code=200 ) def test_checkout_list_view_with_access(self): - self._check_out_document() + self._check_out_test_document() self.grant_access( - obj=self.document, + obj=self.test_document, permission=permission_document_check_out_detail_view ) - self.grant_access( - obj=self.document, + obj=self.test_document, permission=permission_document_view ) response = self._request_check_out_list_view() - self.assertContains( - response=response, text=self.document.label, status_code=200 + response=response, text=self.test_document.label, status_code=200 ) def test_document_new_version_after_check_out(self): @@ -187,23 +185,25 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie - Link to upload version view should not resolve - Upload version view should reject request """ - self._check_out_document() - - self.login_admin_user() + self._create_test_case_superuser() + self._check_out_test_document() + self.login_superuser() response = self.post( - 'sources:upload_version', args=(self.document.pk,), - follow=True + viewname='sources:upload_version', kwargs={ + 'document_pk': self.test_document.pk + }, follow=True ) self.assertContains( - response, text='blocked from uploading', + response=response, text='blocked from uploading', status_code=200 ) response = self.get( - 'documents:document_version_list', args=(self.document.pk,), - follow=True + viewname='documents:document_version_list', kwargs={ + 'pk': self.test_document.pk + }, follow=True ) # Needed by the url view resolver @@ -217,37 +217,40 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie # Forcefully checking in a document by a user without adequate # permissions throws out an error - # Silence unrelated logging - logging.getLogger('navigation.classes').setLevel(logging.CRITICAL) - - self._check_out_document(user=self.admin_user) + self._create_test_case_superuser() + self._check_out_test_document(user=self._test_case_superuser) self.grant_access( - obj=self.document, permission=permission_document_check_in + obj=self.test_document, permission=permission_document_check_in ) response = self.post( - 'checkouts:check_in_document', args=(self.document.pk,) + viewname='checkouts:check_in_document', kwargs={ + 'pk': self.test_document.pk + } ) self.assertContains( - response, text='Insufficient permissions', status_code=403 + response=response, text='Insufficient permissions', status_code=403 ) - self.assertTrue(self.document.is_checked_out()) + self.assertTrue(self.test_document.is_checked_out()) def test_forcefull_check_in_document_view_with_permission(self): - self._check_out_document(user=self.admin_user) + self._create_test_case_superuser() + self._check_out_test_document(user=self._test_case_superuser) self.grant_access( - obj=self.document, permission=permission_document_check_in + obj=self.test_document, permission=permission_document_check_in ) self.grant_access( - obj=self.document, permission=permission_document_check_in_override + obj=self.test_document, permission=permission_document_check_in_override ) response = self.post( - 'checkouts:check_in_document', args=(self.document.pk,) + viewname='checkouts:check_in_document', kwargs={ + 'pk': self.test_document.pk + } ) self.assertEqual(response.status_code, 302) - self.assertFalse(self.document.is_checked_out()) + self.assertFalse(self.test_document.is_checked_out()) diff --git a/mayan/apps/common/tests/base.py b/mayan/apps/common/tests/base.py index ecf9ac2b17..1d005a2769 100644 --- a/mayan/apps/common/tests/base.py +++ b/mayan/apps/common/tests/base.py @@ -7,7 +7,6 @@ from django_downloadview import assert_download_response from mayan.apps.acls.tests.mixins import ACLTestCaseMixin from mayan.apps.permissions.classes import Permission from mayan.apps.smart_settings.classes import Namespace -from mayan.apps.user_management.tests.mixins import UserTestCaseMixin from .mixins import ( ClientMethodsTestCaseMixin, ContentTypeCheckTestCaseMixin, @@ -29,7 +28,7 @@ class BaseTestCase(SilenceLoggerTestCaseMixin, RandomPrimaryKeyModelMonkeyPatchM Permission.invalidate_cache() -class GenericViewTestCase(ClientMethodsTestCaseMixin, ContentTypeCheckTestCaseMixin, TestViewTestCaseMixin, UserTestCaseMixin, BaseTestCase): +class GenericViewTestCase(ClientMethodsTestCaseMixin, ContentTypeCheckTestCaseMixin, TestViewTestCaseMixin, BaseTestCase): """ A generic view test case built on top of the base test case providing a single, user customizable view to test object resolution and shorthand diff --git a/mayan/apps/common/tests/mixins.py b/mayan/apps/common/tests/mixins.py index ebc3df4dca..c9a1a66a15 100644 --- a/mayan/apps/common/tests/mixins.py +++ b/mayan/apps/common/tests/mixins.py @@ -8,12 +8,10 @@ import random from furl import furl -from django.apps import apps from django.conf import settings from django.conf.urls import url -from django.contrib.contenttypes.models import ContentType from django.core import management -from django.db import connection, models +from django.db import models from django.db.models.signals import post_save, pre_save from django.http import HttpResponse from django.template import Context, Template diff --git a/mayan/apps/common/tests/test_api.py b/mayan/apps/common/tests/test_api.py index 4ed43c7036..8484f565b4 100644 --- a/mayan/apps/common/tests/test_api.py +++ b/mayan/apps/common/tests/test_api.py @@ -10,23 +10,29 @@ TEST_TEMPLATE_RESULT = '\d+)/edit/$', view=UserEditView.as_view(), - name='user_edit' - ), url( regex=r'^users/(?P\d+)/delete/$', view=UserDeleteView.as_view(), name='user_delete' @@ -64,6 +60,18 @@ urlpatterns_users = [ regex=r'^users/multiple/delete/$', view=UserDeleteView.as_view(), name='user_multiple_delete' ), + url( + regex=r'^users/(?P\d+)/$', view=UserDetailsView.as_view(), + name='user_details' + ), + url( + regex=r'^users/(?P\d+)/edit/$', view=UserEditView.as_view(), + name='user_edit' + ), + url( + regex=r'^users/(?P\d+)/groups/$', view=UserGroupsView.as_view(), + name='user_groups' + ), url( regex=r'^users/(?P\d+)/set_password/$', view=UserSetPasswordView.as_view(), name='user_set_password' @@ -72,10 +80,6 @@ urlpatterns_users = [ regex=r'^users/multiple/set_password/$', view=UserSetPasswordView.as_view(), name='user_multiple_set_password' ), - url( - regex=r'^users/(?P\d+)/groups/$', view=UserGroupsView.as_view(), - name='user_groups' - ), url( regex=r'^users/(?P\d+)/options/$', view=UserOptionsEditView.as_view(), name='user_options' diff --git a/mayan/apps/user_management/views.py b/mayan/apps/user_management/views.py index 9fb874448f..74993cf3c5 100644 --- a/mayan/apps/user_management/views.py +++ b/mayan/apps/user_management/views.py @@ -256,6 +256,24 @@ class UserDeleteView(MultipleObjectConfirmActionView): ) +class UserDetailsView(SingleObjectDetailView): + fields = ( + 'username', 'first_name', 'last_name', 'email', 'last_login', + 'date_joined', 'groups', + ) + object_permission = permission_user_view + pk_url_kwarg = 'pk' + queryset = get_user_model().objects.filter( + is_superuser=False, is_staff=False + ) + + def get_extra_context(self, **kwargs): + return { + 'object': self.get_object(), + 'title': _('Details of user: %s') % self.get_object() + } + + class UserEditView(SingleObjectEditView): fields = ('username', 'first_name', 'last_name', 'email', 'is_active',) object_permission = permission_user_edit @@ -295,14 +313,20 @@ class UserGroupsView(AssignRemoveView): ), pk=self.kwargs['pk'] ) + def get_choices_queryset(self): + return AccessControlList.objects.filter_by_access( + queryset=Group.objects.filter(user=self.get_object()), + permission=permission_group_edit, user=self.request.user + ) + def left_list(self): return AssignRemoveView.generate_choices( - Group.objects.exclude(user=self.get_object()) + self.get_choices_queryset().exclude(user=self.get_object()) ) def right_list(self): return AssignRemoveView.generate_choices( - Group.objects.filter(user=self.get_object()) + self.get_choices_queryset().filter(user=self.get_object()) ) def remove(self, item): diff --git a/mayan/settings/testing/base.py b/mayan/settings/testing/base.py index 0b89bf6e0a..54e96fb193 100644 --- a/mayan/settings/testing/base.py +++ b/mayan/settings/testing/base.py @@ -2,20 +2,42 @@ from __future__ import absolute_import, unicode_literals from .. import * # NOQA +CELERY_ALWAYS_EAGER = True +CELERY_EAGER_PROPAGATES_EXCEPTIONS = True +BROKER_BACKEND = 'memory' + +COMMON_PRODUCTION_ERROR_LOG_PATH = '/tmp/mayan-errors.log' + +DOCUMENT_PARSING_AUTO_PARSING = False + INSTALLED_APPS += ('test_without_migrations',) INSTALLED_APPS = [ cls for cls in INSTALLED_APPS if cls != 'whitenoise.runserver_nostatic' ] -COMMON_PRODUCTION_ERROR_LOG_PATH = '/tmp/mayan-errors.log' - # Remove whitenoise from middlewares. Causes out of memory errors during test # suit MIDDLEWARE = [ cls for cls in MIDDLEWARE if cls != 'whitenoise.middleware.WhiteNoiseMiddleware' ] +# Remove middlewares not used for tests +MIDDLEWARE = [ + cls for cls in MIDDLEWARE if cls not in [ + 'common.middleware.error_logging.ErrorLoggingMiddleware', + 'django.middleware.security.SecurityMiddleware', + 'corsheaders.middleware.CorsMiddleware', + 'django.middleware.csrf.CsrfViewMiddleware', + 'django.middleware.clickjacking.XFrameOptionsMiddleware', + 'django.middleware.locale.LocaleMiddleware', + 'common.middleware.timezone.TimezoneMiddleware', + 'common.middleware.ajax_redirect.AjaxRedirect', + ] +] + +OCR_AUTO_OCR = False + # User a simpler password hasher PASSWORD_HASHERS = ( 'django.contrib.auth.hashers.MD5PasswordHasher', @@ -32,21 +54,3 @@ TEMPLATES[0]['OPTIONS']['loaders'] = ( ) ), ) - -CELERY_ALWAYS_EAGER = True -CELERY_EAGER_PROPAGATES_EXCEPTIONS = True -BROKER_BACKEND = 'memory' - -# Remove middlewares not used for tests -MIDDLEWARE = [ - cls for cls in MIDDLEWARE if cls not in [ - 'common.middleware.error_logging.ErrorLoggingMiddleware', - 'django.middleware.security.SecurityMiddleware', - 'corsheaders.middleware.CorsMiddleware', - 'django.middleware.csrf.CsrfViewMiddleware', - 'django.middleware.clickjacking.XFrameOptionsMiddleware', - 'django.middleware.locale.LocaleMiddleware', - 'common.middleware.timezone.TimezoneMiddleware', - 'common.middleware.ajax_redirect.AjaxRedirect', - ] -]