Backport test improvements

Signed-off-by: Roberto Rosario <roberto.rosario.gonzalez@gmail.com>

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.core.exceptions import ImproperlyConfigured
-from django.contrib.auth.models import Group
 
 from mayan.apps.acls.models import AccessControlList
-from mayan.apps.permissions.models import Role
+from mayan.apps.permissions.tests.mixins import (
-from mayan.apps.permissions.tests.literals import TEST_ROLE_LABEL
+    PermissionTestMixin, RoleTestCaseMixin, RoleTestMixin
-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.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(
+        if hasattr(self, '_test_case_user'):
-            username=TEST_ADMIN_USERNAME, email=TEST_ADMIN_EMAIL,
+            self._test_case_role.groups.add(self._test_case_group)
-            password=TEST_ADMIN_PASSWORD
+
+    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,
+class ACLTestMixin(PermissionTestMixin, RoleTestMixin):
-            password=TEST_USER_PASSWORD
+    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)
+    def setUp(self):
-        self.role = Role.objects.create(label=TEST_ROLE_LABEL)
+        super(ACLTestMixin, self).setUp()
-        self.group.user_set.add(self.user)
+        if self.auto_create_test_role:
-        self.role.groups.add(self.group)
+            self._create_test_role()
-
-    def grant_access(self, permission, obj):
-        AccessControlList.objects.grant(
-            permission=permission, role=self.role, obj=obj
-        )

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],
             }
         )

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.test_document_content_type = ContentType.objects.get_for_model(
-
+            self.test_document
-        self.document_content_type = ContentType.objects.get_for_model(
-            self.document
         )
-
+        self.test_object = 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)
 
     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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk
+                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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk, self.acl.pk
+                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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk, self.acl.pk
+                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()
+        self._create_test_acl()
-        permission = self.acl.permissions.first()
+        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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk, self.acl.pk,
+                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()
+        self._create_test_acl()
-        permission = self.acl.permissions.first()
+        permission = self.test_acl.permissions.first()
 
         response = self.get(
             viewname='rest_api:accesscontrollist-permission-detail',
             args=(
-                self.document_content_type.app_label,
+                self.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk, self.acl.pk,
+                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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk, self.acl.pk
+                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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk, self.acl.pk
+                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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk
+                self.test_document.pk
-            ), data={'role_pk': self.role.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.test_document_content_type.app_label,
-                self.document_content_type.model,
+                self.test_document_content_type.model,
-                self.document.pk
+                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
         )

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(
+        self.grant_access(
-            content_object=self.document, role=self.role
+            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(
+        self._create_test_acl()
-            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.test_acl)
-
-        self.add_test_view(test_object=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(
+        self._create_test_acl()
-            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.test_acl)
-
-        self.add_test_view(test_object=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(
+        self.grant_access(
-            content_object=self.document, role=self.role
+            obj=self.test_document, permission=permission_acl_view
         )
 
-        acl.permissions.add(permission_acl_view.stored_permission)
+        self.add_test_view(test_object=self.test_document)
-
-        self.add_test_view(test_object=self.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
+            )
         )

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(
+        self.grant_access(
-            content_object=self.document_1, role=self.role
+            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, permissions=(permission_document_view,),
-                obj=self.document_1
+                user=self._test_case_user,
             )
         except PermissionDenied:
             self.fail('PermissionDenied exception was not expected.')
 
     def test_filtering_with_permissions(self):
-        acl = AccessControlList.objects.create(
+        self.grant_access(
-            content_object=self.document_1, role=self.role
+            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,
+                permission=permission_document_view,
-                queryset=Document.objects.all()
+                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(
+        self.grant_access(
-            content_object=self.document_type_1, role=self.role
+            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, permissions=(permission_document_view,),
-                obj=self.document_1
+                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(
+        self.grant_access(
-            content_object=self.document_type_1, role=self.role
+            obj=self.document_type_1, permission=permission_document_view
         )
-        acl.permissions.add(permission_document_view.stored_permission)
+        self.grant_access(
-
+            obj=self.document_3, permission=permission_document_view
-        acl = AccessControlList.objects.create(
-            content_object=self.document_3, role=self.role
         )
-        acl.permissions.add(permission_document_view.stored_permission)
 
         try:
             AccessControlList.objects.check_access(
-                permissions=(permission_document_view,), user=self.user,
+                obj=self.document_3, permissions=(permission_document_view,),
-                obj=self.document_3
+                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(
+        self.grant_access(
-            content_object=self.document_type_1, role=self.role
+            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,
+            permission=permission_document_view,
-            queryset=Document.objects.all()
+            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)
+        self.grant_permission(permission=permission_document_view)
-
+        self.grant_access(
-        acl = AccessControlList.objects.create(
+            obj=self.document_type_1, permission=permission_document_view
-            content_object=self.document_type_1, role=self.role
         )
-        acl.permissions.add(permission_document_view.stored_permission)
+        self.grant_access(
-
+            obj=self.document_3, permission=permission_document_view
-        acl = AccessControlList.objects.create(
-            content_object=self.document_3, role=self.role
         )
-        acl.permissions.add(permission_document_view.stored_permission)
 
         result = AccessControlList.objects.filter_by_access(
-            permission=permission_document_view, user=self.user,
+            permission=permission_document_view,
-            queryset=Document.objects.all()
+            queryset=Document.objects.all(), user=self._test_case_user,
         )
         self.assertTrue(self.document_1 in result)
         self.assertTrue(self.document_2 in result)

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):
+        self.test_object = self.test_document
-        response = self.get(
+
+    def _request_test_acl_create_get_view(self):
+        return self.get(
             viewname='acls:acl_create', kwargs=self.view_arguments, data={
-                'role': self.role.pk
+                'role': self.test_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
             }, 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(
+        acl_count = AccessControlList.objects.count()
-            viewname='acls:acl_create', kwargs=self.view_arguments, data={
-                'role': self.role.pk
-            }
-        )
 
+        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.assertEqual(AccessControlList.objects.count(), acl_count)
-        self.role.permissions.add(
+
-            permission_acl_edit.stored_permission
+    def test_acl_create_view_post_with_access(self):
+        self.grant_access(
+            obj=self.test_document, permission=permission_acl_edit
         )
 
-        response = self.post(
+        acl_count = AccessControlList.objects.count()
-            viewname='acls:acl_create', kwargs=self.view_arguments, data={
-                'role': self.role.pk
-            }, follow=True
-        )
 
-        self.assertContains(response, text='created', status_code=200)
+        response = self._request_test_acl_create_post_view()
-        self.assertEqual(AccessControlList.objects.count(), 1)
+        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(
+        self.grant_permission(permission=permission_acl_edit)
-            permission_acl_edit.stored_permission
-        )
 
-        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._create_test_acl()
-            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
-        }
 
         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(
-        self.assertNotContains(response, text='otal: 1', status_code=403)
+            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(
+        self.grant_access(
-            permission_acl_view.stored_permission
+            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)

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,
+                'username': self._test_case_superuser.username,
-                'password': TEST_ADMIN_PASSWORD
+                '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,
+                'username': self._test_case_superuser.username,
-                'password': TEST_ADMIN_PASSWORD,
+                '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,
+                'username': self._test_case_superuser.username,
-                'password': TEST_ADMIN_PASSWORD,
+                '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,
+                    'email': self._test_case_superuser.email,
-                    'password': TEST_ADMIN_PASSWORD,
+                    '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,
+                    'email': self._test_case_superuser.email,
-                    'password': TEST_ADMIN_PASSWORD,
+                    '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={
+            kwargs={'uidb64': uidb64, 'token': token}, data={
-                'new_password1': TEST_ADMIN_PASSWORD,
+                'new_password1': new_password,
-                'new_password2': TEST_ADMIN_PASSWORD,
+                'new_password2': new_password
             }
         )
-
         self.assertEqual(response.status_code, 302)
 
-        self.login(
+        logged_in = self.login(
-            username=TEST_ADMIN_USERNAME, password=TEST_ADMIN_PASSWORD
+            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,
+                'username': self._test_case_superuser.username,
-                'password': TEST_ADMIN_PASSWORD,
+                'password': self._test_case_superuser.cleartext_password,
                 'remember_me': False
             }, follow=True
         )

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_add_document, permission_cabinet_create,
-    permission_cabinet_edit, permission_cabinet_view
+    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):
+    def _request_test_cabinet_create_api_view(self, extra_data=None):
-        super(CabinetDocumentAPITestCase, self).setUp()
+        data = {'label': TEST_CABINET_LABEL}
-        self.login_admin_user()
+
+        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(
+        self.grant_permission(permission=permission_cabinet_create)
-            viewname='rest_api:cabinet-list', data={
+
-                'label': TEST_CABINET_LABEL, 'documents_pk_list': '{}'.format(
+        response = self._request_test_cabinet_create_api_view(
-                    self.document.pk
+            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.upload_document()
-        self.document_2 = self.upload_document()
+        self.test_document_2 = self.upload_document()
 
-        response = self.post(
+        self.grant_permission(permission=permission_cabinet_create)
-            viewname='rest_api:cabinet-list', data={
+
-                'label': TEST_CABINET_LABEL,
+        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):
+    def _request_test_cabinet_document_remove_api_view(self):
-        self.document = self.upload_document()
+        return self.delete(
-
-        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
+                '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):
+    def test_cabinet_document_detail_api_view(self):
-        self.document = self.upload_document()
+        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):
+    def test_cabinet_document_list_api_view(self):
-        self.document = self.upload_document()
+        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):
+    def test_cabinet_add_document_api_view(self):
-        self.document = self.upload_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()
 
         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):
+    def test_cabinet_add_multiple_documents_api_view(self):
-        self.document = self.upload_document()
+        self.upload_document()
-        self.document_2 = 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)
             )
         )

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()
+        self._create_test_cabinet()
-
-    def _create_cabinet(self):
-        self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
 
     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

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(CabinetTestMixin, DocumentTestMixin, BaseTestCase):
-class CabinetTestCase(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)
+        self._create_test_cabinet()
-        cabinet.documents.add(self.document)
+        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)
+        self._create_test_cabinet()
-        cabinet.documents.add(self.document)
+        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.assertEqual(self.test_cabinet.documents.count(), 0)
-        self.assertQuerysetEqual(cabinet.documents.all(), ())
+        self.assertQuerysetEqual(self.test_cabinet.documents.all(), ())

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):
+class CabinetViewTestCase(CabinetTestMixin, GenericViewTestCase):
-    def setUp(self):
-        super(CabinetViewTestCase, self).setUp()
-        self.login_user()
-
-    def _create_cabinet(self):
-        self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
-
     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._create_test_cabinet()
-        self.grant_access(obj=self.cabinet, permission=permission_cabinet_delete)
+        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={
+            viewname='cabinets:cabinet_add_document', kwargs={
-                'cabinets': self.cabinet.pk
+                '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={
+            viewname='cabinets:cabinet_add_multiple_documents', data={
-                'id_list': (self.document.pk,), 'cabinets': self.cabinet.pk
+                '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,),
+            viewname='cabinets:document_cabinet_remove', kwargs={
-            data={
+                'pk': self.test_document.pk
-                'cabinets': (self.cabinet.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.test_cabinet.refresh_from_db()
-        self.assertEqual(self.cabinet.documents.count(), 1)
+        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._create_test_cabinet()
-        self.grant_access(obj=self.cabinet, permission=permission_cabinet_view)
+        self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_view)
-        response = self._request_cabinet_list()
 
+        response = self._request_cabinet_list()
         self.assertContains(
-            response, text=self.cabinet.label, status_code=200
+            response, text=self.test_cabinet.label, status_code=200
         )

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.test_source = WebFormSource.objects.create(
-        self.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,),
+                viewname='sources:upload_interactive', kwargs={
-                data={
+                    'source_id': self.test_source.pk
-                    'document_type_id': self.document_type.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)

mayan/apps/checkouts/tests/mixins.py

@@ -8,13 +8,18 @@ from ..models import DocumentCheckout
 
 
 class DocumentCheckoutTestMixin(object):
-    def _check_out_document(self, user=None):
+    _test_document_check_out_seconds = 0.1
-        if not user:
-            user = self.user
 
-        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,
+            document=self.test_document,
-            user=user, block_new_version=True
+            expiration_datetime=self._check_out_expiration_datetime,
+            block_new_version=True, user=user
         )

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)

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)

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(
+        self.test_document.check_in()
-            document=self.document, expiration_datetime=expiration_datetime,
-            user=self.admin_user, block_new_version=True
-        )
 
-        self.document.check_in()
+        self.assertFalse(self.test_document.is_checked_out())
-
-        self.assertFalse(self.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)
+        self._create_test_case_superuser()
-
+        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
-        )
 
         with self.assertRaises(DocumentAlreadyCheckedOut):
             DocumentCheckout.objects.check_out_document(
-                document=self.document,
+                document=self.test_document,
-                expiration_datetime=expiration_datetime, user=self.admin_user,
+                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(
+        # Ensure we wait from longer than the document check out expiration
-            document=self.document, expiration_datetime=expiration_datetime,
+        time.sleep(self._test_document_check_out_seconds + 0.1)
-            user=self.admin_user, block_new_version=True
-        )
-
-        time.sleep(.11)
 
         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(DocumentCheckoutTestMixin, DocumentTestMixin, BaseTestCase):
-class NewVersionBlockTestCase(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(
+        self._check_out_test_document()
-            document=self.document, expiration_datetime=expiration_datetime,
-            user=self.admin_user, block_new_version=True
-        )
 
         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)

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,),
+            viewname='checkouts:check_out_document', kwargs={
-            data={
+                '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._create_test_case_superuser()
-
+        self._check_out_test_document()
-        self.login_admin_user()
+        self.login_superuser()
 
         response = self.post(
-            'sources:upload_version', args=(self.document.pk,),
+            viewname='sources:upload_version', kwargs={
-            follow=True
+                '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,),
+            viewname='documents:document_version_list', kwargs={
-            follow=True
+                '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
+        self._create_test_case_superuser()
-        logging.getLogger('navigation.classes').setLevel(logging.CRITICAL)
+        self._check_out_test_document(user=self._test_case_superuser)
-
-        self._check_out_document(user=self.admin_user)
 
         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())

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

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

mayan/apps/common/tests/test_api.py

@@ -10,23 +10,29 @@ TEST_TEMPLATE_RESULT = '<div'
 
 
 class CommonAPITestCase(BaseAPITestCase):
-    def test_content_type_list_view(self):
+    auto_login_user = False
-        response = self.get(viewname='rest_api:content-type-list')
+
+    def _request_content_type_list_api_view(self):
+        return self.get(viewname='rest_api:content-type-list')
+
+    def test_content_type_list_api_view(self):
+        response = self._request_content_type_list_api_view()
         self.assertEqual(response.status_code, 200)
 
+    def test_template_detail_anonymous_view(self):
+        template_main_menu = Template.get(name='menu_main')
+
+        response = self.get(path=template_main_menu.get_absolute_url())
+        self.assertNotContains(
+            response=response, text=TEST_TEMPLATE_RESULT, status_code=403
+        )
+
     @override_settings(LANGUAGE_CODE='de')
     def test_template_detail_view(self):
         self.login_user()
         template_main_menu = Template.get(name='menu_main')
-        response = self.get(path=template_main_menu.get_absolute_url())
 
+        response = self.get(path=template_main_menu.get_absolute_url())
         self.assertContains(
             response=response, text=TEST_TEMPLATE_RESULT, status_code=200
         )
-
-    def test_template_detail_anonymous_view(self):
-        template_main_menu = Template.get(name='menu_main')
-        response = self.get(path=template_main_menu.get_absolute_url())
-        self.assertNotContains(
-            response=response, text=TEST_TEMPLATE_RESULT, status_code=403
-        )

mayan/apps/common/tests/test_models.py

@@ -6,5 +6,5 @@ from mayan.apps.user_management.tests.mixins import UserTestMixin
 
 class UserLocaleProfileTestCase(UserTestMixin, BaseTestCase):
     def test_natural_keys(self):
-        self._create_user()
+        self._create_test_user()
         self._test_database_conversion('auth', 'common')

mayan/apps/common/tests/test_views.py

@@ -4,6 +4,7 @@ from django.contrib.auth import get_user_model
 from django.contrib.contenttypes.models import ContentType
 
 from mayan.apps.acls.classes import ModelPermission
+from mayan.apps.user_management.tests.mixins import UserTestMixin
 
 from ..models import ErrorLogEntry
 from ..permissions_runtime import permission_error_log_view
@@ -12,14 +13,13 @@ from .base import GenericViewTestCase
 from .literals import TEST_ERROR_LOG_ENTRY_RESULT
 
 
-class CommonViewTestCase(GenericViewTestCase):
+class CommonViewTestCase(UserTestMixin, GenericViewTestCase):
-    def setUp(self):
+    def _request_about_view(self):
-        super(CommonViewTestCase, self).setUp()
+        return self.get(viewname='common:about_view')
-        self.login_user()
 
     def test_about_view(self):
-        response = self.get('common:about_view')
+        response = self._request_about_view()
-        self.assertContains(response, text='About', status_code=200)
+        self.assertContains(response=response, text='About', status_code=200)
 
     def _create_error_log_entry(self):
         ModelPermission.register(
@@ -27,41 +27,41 @@ class CommonViewTestCase(GenericViewTestCase):
         )
         ErrorLogEntry.objects.register(model=get_user_model())
 
-        self.error_log_entry = self.user.error_logs.create(
+        self.error_log_entry = self.test_user.error_logs.create(
             result=TEST_ERROR_LOG_ENTRY_RESULT
         )
 
     def _request_object_error_log_list(self):
-        content_type = ContentType.objects.get_for_model(model=self.user)
+        content_type = ContentType.objects.get_for_model(model=self.test_user)
 
         return self.get(
-            'common:object_error_list', kwargs={
+            viewname='common:object_error_list', kwargs={
                 'app_label': content_type.app_label,
                 'model': content_type.model,
-                'object_id': self.user.pk
+                'object_id': self.test_user.pk
-            }, follow=True
+            }
-        )
-
-    def test_object_error_list_view_with_permissions(self):
-        self._create_error_log_entry()
-
-        self.grant_access(
-            obj=self.user, permission=permission_error_log_view
-        )
-
-        response = self._request_object_error_log_list()
-
-        self.assertContains(
-            response=response, text=TEST_ERROR_LOG_ENTRY_RESULT,
-            status_code=200
         )
 
     def test_object_error_list_view_no_permissions(self):
+        self._create_test_user()
         self._create_error_log_entry()
 
         response = self._request_object_error_log_list()
-
         self.assertNotContains(
             response=response, text=TEST_ERROR_LOG_ENTRY_RESULT,
             status_code=403
         )
+
+    def test_object_error_list_view_with_access(self):
+        self._create_test_user()
+        self._create_error_log_entry()
+
+        self.grant_access(
+            obj=self.test_user, permission=permission_error_log_view
+        )
+
+        response = self._request_object_error_log_list()
+        self.assertContains(
+            response=response, text=TEST_ERROR_LOG_ENTRY_RESULT,
+            status_code=200
+        )

mayan/apps/converter/tests/test_views.py

@@ -14,34 +14,9 @@ from .literals import TEST_TRANSFORMATION_NAME, TEST_TRANSFORMATION_ARGUMENT
 
 
 class TransformationViewsTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(TransformationViewsTestCase, self).setUp()
-        self.login_user()
-
-    def _transformation_list_view(self):
-        return self.get(
-            'converter:transformation_list', kwargs={
-                'app_label': 'documents', 'model': 'document',
-                'object_id': self.document.pk
-            }
-        )
-
-    def test_transformation_list_view_no_permissions(self):
-        response = self._transformation_list_view()
-
-        self.assertEqual(response.status_code, 403)
-
-    def test_transformation_list_view_with_permissions(self):
-        self.grant_permission(permission=permission_transformation_view)
-        response = self._transformation_list_view()
-
-        self.assertContains(
-            response, text=self.document.label, status_code=200
-        )
-
     def _transformation_create_view(self):
         return self.post(
-            'converter:transformation_create', kwargs={
+            viewname='converter:transformation_create', kwargs={
                 'app_label': 'documents', 'model': 'document',
                 'object_id': self.document.pk
             }, data={
@@ -51,42 +26,85 @@ class TransformationViewsTestCase(GenericDocumentViewTestCase):
         )
 
     def test_transformation_create_view_no_permissions(self):
-        response = self._transformation_create_view()
+        transformation_count = Transformation.objects.count()
 
+        response = self._transformation_create_view()
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(Transformation.objects.count(), 0)
+
+        self.assertEqual(Transformation.objects.count(), transformation_count)
 
     def test_transformation_create_view_with_permissions(self):
         self.grant_permission(permission=permission_transformation_create)
+
+        transformation_count = Transformation.objects.count()
+
         response = self._transformation_create_view()
-
         self.assertEqual(response.status_code, 302)
-        self.assertEqual(Transformation.objects.count(), 1)
 
-    def _transformation_delete_view(self):
+        self.assertEqual(
+            Transformation.objects.count(), transformation_count + 1
+        )
+
+    def _request_transformation_delete_view(self):
+        return self.post(
+            viewname='converter:transformation_delete', kwargs={
+                'pk': self.test_transformation.pk
+            }
+        )
+
+    def _create_test_transformation(self):
         content_type = ContentType.objects.get_for_model(model=self.document)
 
-        transformation = Transformation.objects.create(
+        self.test_transformation = Transformation.objects.create(
             content_type=content_type, object_id=self.document.pk,
             name=TEST_TRANSFORMATION_NAME,
             arguments=TEST_TRANSFORMATION_ARGUMENT
         )
 
-        return self.post(
+    def test_transformation_delete_view_no_permissions(self):
-            'converter:transformation_delete', kwargs={
+        self._create_test_transformation()
-                'pk': transformation.pk
+
+        transformation_count = Transformation.objects.count()
+
+        response = self._request_transformation_delete_view()
+        self.assertEqual(response.status_code, 403)
+
+        self.assertEqual(
+            Transformation.objects.count(), transformation_count
+        )
+
+    def test_transformation_delete_view_with_permissions(self):
+        self._create_test_transformation()
+
+        self.grant_permission(permission=permission_transformation_delete)
+
+        transformation_count = Transformation.objects.count()
+
+        response = self._request_transformation_delete_view()
+        self.assertEqual(response.status_code, 302)
+
+        self.assertEqual(
+            Transformation.objects.count(), transformation_count - 1
+        )
+
+    def _transformation_list_view(self):
+        return self.get(
+            viewname='converter:transformation_list', kwargs={
+                'app_label': 'documents', 'model': 'document',
+                'object_id': self.document.pk
             }
         )
 
-    def test_transformation_delete_view_no_permissions(self):
+    def test_transformation_list_view_no_permissions(self):
-        response = self._transformation_delete_view()
+        response = self._transformation_list_view()
-
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(Transformation.objects.count(), 1)
 
-    def test_transformation_delete_view_with_permissions(self):
+    def test_transformation_list_view_with_permissions(self):
-        self.grant_permission(permission=permission_transformation_delete)
+        self.grant_access(
-        response = self._transformation_delete_view()
+            obj=self.document, permission=permission_transformation_view
+        )
 
-        self.assertEqual(response.status_code, 302)
+        response = self._transformation_list_view()
-        self.assertEqual(Transformation.objects.count(), 0)
+        self.assertContains(
+            response=response, text=self.document.label, status_code=200
+        )

mayan/apps/django_gpg/tests/mixins.py

@@ -0,0 +1,10 @@
+from __future__ import unicode_literals
+
+from ..models import Key
+
+from .literals import TEST_KEY_DATA
+
+
+class KeyTestMixin(object):
+    def _create_test_key(self):
+        self.test_key = Key.objects.create(key_data=TEST_KEY_DATA)

mayan/apps/django_gpg/tests/test_api.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from rest_framework import status
 
 from mayan.apps.rest_api.tests import BaseAPITestCase
@@ -12,16 +10,10 @@ from ..permissions import (
 )
 
 from .literals import TEST_KEY_DATA, TEST_KEY_FINGERPRINT
+from .mixins import KeyTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class KeyAPITestCase(KeyTestMixin, BaseAPITestCase):
-class KeyAPITestCase(BaseAPITestCase):
-    def setUp(self):
-        super(KeyAPITestCase, self).setUp()
-        self.login_user()
-
-    def _create_key(self):
-        return Key.objects.create(key_data=TEST_KEY_DATA)
 
     # Key creation by upload
 
@@ -35,13 +27,13 @@ class KeyAPITestCase(BaseAPITestCase):
     def test_key_create_view_no_permission(self):
         response = self._request_key_create_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
         self.assertEqual(Key.objects.all().count(), 0)
 
     def test_key_create_view_with_permission(self):
         self.grant_permission(permission=permission_key_upload)
 
         response = self._request_key_create_view()
-
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
         self.assertEqual(response.data['fingerprint'], TEST_KEY_FINGERPRINT)
 
@@ -53,45 +45,49 @@ class KeyAPITestCase(BaseAPITestCase):
 
     def _request_key_delete_view(self):
         return self.delete(
-            viewname='rest_api:key-detail', args=(self.key.pk,)
+            viewname='rest_api:key-detail', kwargs={'pk': self.test_key.pk}
         )
 
     def test_key_delete_view_no_access(self):
-        self.key = self._create_key()
+        self._create_test_key()
+
         response = self._request_key_delete_view()
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
         self.assertEqual(Key.objects.count(), 1)
 
     def test_key_delete_view_with_access(self):
-        self.key = self._create_key()
+        self._create_test_key()
         self.grant_access(
-            permission=permission_key_delete, obj=self.key
+            obj=self.test_key, permission=permission_key_delete
         )
+
         response = self._request_key_delete_view()
         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+
         self.assertEqual(Key.objects.count(), 0)
 
     # Key detail
 
     def _request_key_detail_view(self):
         return self.get(
-            viewname='rest_api:key-detail', args=(self.key.pk,)
+            viewname='rest_api:key-detail', kwargs={'pk': self.test_key.pk}
         )
 
     def test_key_detail_view_no_access(self):
-        self.key = self._create_key()
+        self._create_test_key()
-        response = self._request_key_detail_view()
 
+        response = self._request_key_detail_view()
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
 
     def test_key_detail_view_with_access(self):
-        self.key = self._create_key()
+        self._create_test_key()
         self.grant_access(
-            permission=permission_key_view, obj=self.key
+            obj=self.test_key, permission=permission_key_view
         )
+
         response = self._request_key_detail_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-
         self.assertEqual(
-            response.data['fingerprint'], self.key.fingerprint
+            response.data['fingerprint'], self.test_key.fingerprint
         )

mayan/apps/django_gpg/tests/test_views.py

@@ -8,55 +8,50 @@ from ..models import Key
 from ..permissions import permission_key_download, permission_key_upload
 
 from .literals import TEST_KEY_DATA, TEST_KEY_FINGERPRINT
+from .mixins import KeyTestMixin
 
 
-class KeyViewTestCase(GenericViewTestCase):
+class KeyViewTestCase(KeyTestMixin, GenericViewTestCase):
-    def setUp(self):
-        super(KeyViewTestCase, self).setUp()
-        self.login_user()
-
     def test_key_download_view_no_permission(self):
-        key = Key.objects.create(key_data=TEST_KEY_DATA)
+        self._create_test_key()
 
         response = self.get(
-            viewname='django_gpg:key_download', args=(key.pk,)
+            viewname='django_gpg:key_download', kwargs={'pk': self.test_key.pk}
         )
-
         self.assertEqual(response.status_code, 403)
 
     def test_key_download_view_with_permission(self):
-        key = Key.objects.create(key_data=TEST_KEY_DATA)
-
-        self.role.permissions.add(permission_key_download.stored_permission)
-
         self.expected_content_type = 'application/octet-stream; charset=utf-8'
 
-        response = self.get(
+        self._create_test_key()
-            viewname='django_gpg:key_download', args=(key.pk,)
-        )
 
+        self.grant_access(obj=self.test_key, permission=permission_key_download)
+
+        response = self.get(
+            viewname='django_gpg:key_download', kwargs={'pk': self.test_key.pk}
+        )
         assert_download_response(
-            self, response=response, content=key.key_data,
+            self, response=response, content=self.test_key.key_data,
-            basename=key.key_id,
+            basename=self.test_key.key_id,
         )
 
     def test_key_upload_view_no_permission(self):
         response = self.post(
             viewname='django_gpg:key_upload', data={'key_data': TEST_KEY_DATA}
         )
-
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(Key.objects.count(), 0)
 
     def test_key_upload_view_with_permission(self):
-        self.role.permissions.add(permission_key_upload.stored_permission)
+        self.grant_permission(permission=permission_key_upload)
 
         response = self.post(
             viewname='django_gpg:key_upload', data={'key_data': TEST_KEY_DATA},
             follow=True
         )
 
-        self.assertContains(response, 'created', status_code=200)
+        self.assertContains(response=response, text='created', status_code=200)
 
         self.assertEqual(Key.objects.count(), 1)
         self.assertEqual(Key.objects.first().fingerprint, TEST_KEY_FINGERPRINT)

mayan/apps/document_comments/tests/test_api.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from rest_framework import status
 
 from mayan.apps.documents.tests import DocumentTestMixin
@@ -16,21 +14,17 @@ from ..permissions import (
 from .literals import TEST_COMMENT_TEXT
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class CommentAPITestCase(DocumentTestMixin, BaseAPITestCase):
-    def setUp(self):
+    def _create_test_comment(self):
-        super(CommentAPITestCase, self).setUp()
+        return self.test_document.comments.create(
-        self.login_user()
+            comment=TEST_COMMENT_TEXT, user=self._test_case_user
-
-    def _create_comment(self):
-        return self.document.comments.create(
-            comment=TEST_COMMENT_TEXT, user=self.admin_user
         )
 
     def _request_comment_create_view(self):
         return self.post(
-            viewname='rest_api:comment-list', args=(self.document.pk,),
+            viewname='rest_api:comment-list', kwargs={
-            data={
+                'document_pk': self.test_document.pk
+            }, data={
                 'comment': TEST_COMMENT_TEXT
             }
         )
@@ -38,76 +32,94 @@ class CommentAPITestCase(DocumentTestMixin, BaseAPITestCase):
     def test_comment_create_view_no_access(self):
         response = self._request_comment_create_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
         self.assertEqual(Comment.objects.count(), 0)
 
     def test_comment_create_view_with_access(self):
-        self.grant_access(permission=permission_comment_create, obj=self.document)
+        self.grant_access(
+            obj=self.test_document, permission=permission_comment_create
+        )
+
         response = self._request_comment_create_view()
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
         comment = Comment.objects.first()
         self.assertEqual(Comment.objects.count(), 1)
         self.assertEqual(response.data['id'], comment.pk)
 
     def _request_comment_delete_view(self):
         return self.delete(
-            viewname='rest_api:comment-detail', args=(
+            viewname='rest_api:comment-detail', kwargs={
-                self.document.pk, self.comment.pk,
+                'document_pk': self.test_document.pk,
-            )
+                'comment_pk': self.test_comment.pk,
+            }
         )
 
     def test_comment_delete_view_no_access(self):
-        self.comment = self._create_comment()
+        self.test_comment = self._create_test_comment()
+
         response = self._request_comment_delete_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertTrue(self.comment in Comment.objects.all())
+
+        self.assertTrue(self.test_comment in Comment.objects.all())
 
     def test_comment_delete_view_with_access(self):
-        self.comment = self._create_comment()
+        self.test_comment = self._create_test_comment()
         self.grant_access(
-            permission=permission_comment_delete, obj=self.document
+            obj=self.test_document, permission=permission_comment_delete
         )
+
         response = self._request_comment_delete_view()
         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
-        self.assertFalse(self.comment in Comment.objects.all())
+
+        self.assertFalse(self.test_comment in Comment.objects.all())
 
     def _request_comment_view(self):
         return self.get(
-            viewname='rest_api:comment-detail', args=(
+            viewname='rest_api:comment-detail', kwargs={
-                self.document.pk, self.comment.pk,
+                'document_pk': self.test_document.pk,
-            )
+                'comment_pk': self.test_comment.pk
+            }
         )
 
     def test_comment_detail_view_no_access(self):
-        self.comment = self._create_comment()
+        self.test_comment = self._create_test_comment()
+
         response = self._request_comment_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
     def test_comment_detail_view_with_access(self):
-        self.comment = self._create_comment()
+        self.test_comment = self._create_test_comment()
         self.grant_access(
-            permission=permission_comment_view, obj=self.document
+            obj=self.test_document, permission=permission_comment_view
         )
+
         response = self._request_comment_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data['comment'], self.comment.comment)
+
+        self.assertEqual(response.data['comment'], self.test_comment.comment)
 
     def _request_comment_list_view(self):
         return self.get(
-            viewname='rest_api:comment-list', args=(self.document.pk,)
+            viewname='rest_api:comment-list', kwargs={
+                'document_pk': self.test_document.pk
+            }
         )
 
     def test_comment_list_view_no_access(self):
-        self.comment = self._create_comment()
+        self.test_comment = self._create_test_comment()
+
         response = self._request_comment_list_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
     def test_comment_list_view_with_access(self):
-        self.comment = self._create_comment()
+        self.test_comment = self._create_test_comment()
         self.grant_access(
-            permission=permission_comment_view, obj=self.document
+            obj=self.test_document, permission=permission_comment_view
         )
+
         response = self._request_comment_list_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(
-            response.data['results'][0]['comment'], self.comment.comment
+            response.data['results'][0]['comment'], self.test_comment.comment
         )

mayan/apps/document_indexing/tests/mixins.py

@@ -6,9 +6,13 @@ from .literals import TEST_INDEX_LABEL
 
 
 class DocumentIndexingTestMixin(object):
-    def _create_index(self):
+    def _create_test_index(self, rebuild=False):
         # Create empty index
-        self.index = Index.objects.create(label=TEST_INDEX_LABEL)
+        self.test_index = Index.objects.create(label=TEST_INDEX_LABEL)
 
         # Add our document type to the new index
-        self.index.document_types.add(self.document_type)
+        self.test_index.document_types.add(self.test_document_type)
+
+        # Rebuild indexes
+        if rebuild:
+            Index.objects.rebuild()

mayan/apps/document_indexing/tests/test_api.py

@@ -18,10 +18,6 @@ from .mixins import DocumentIndexingTestMixin
 class DocumentIndexingAPITestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseAPITestCase):
     auto_upload_document = False
 
-    def setUp(self):
-        super(DocumentIndexingAPITestCase, self).setUp()
-        self.login_user()
-
     def _request_index_create_api_view(self):
         return self.post(
             viewname='rest_api:index-list', data={
@@ -53,39 +49,39 @@ class DocumentIndexingAPITestCase(DocumentIndexingTestMixin, DocumentTestMixin,
     def _request_index_delete_api_view(self):
         return self.delete(
             viewname='rest_api:index-detail', kwargs={
-                'pk': self.index.pk
+                'pk': self.test_index.pk
             }
         )
 
     def test_index_delete_api_view_no_permission(self):
-        self._create_index()
+        self._create_test_index()
 
         response = self._request_index_delete_api_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
-        self.assertTrue(self.index in Index.objects.all())
+        self.assertTrue(self.test_index in Index.objects.all())
 
     def test_index_delete_api_view_with_access(self):
-        self._create_index()
+        self._create_test_index()
 
         self.grant_access(
-            obj=self.index, permission=permission_document_indexing_delete
+            obj=self.test_index, permission=permission_document_indexing_delete
         )
 
         response = self._request_index_delete_api_view()
         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
 
-        self.assertTrue(self.index not in Index.objects.all())
+        self.assertTrue(self.test_index not in Index.objects.all())
 
     def _request_index_detail_api_view(self):
         return self.get(
             viewname='rest_api:index-detail', kwargs={
-                'pk': self.index.pk
+                'pk': self.test_index.pk
             }
         )
 
     def test_index_detail_api_view_no_access(self):
-        self._create_index()
+        self._create_test_index()
 
         response = self._request_index_detail_api_view()
 
@@ -93,15 +89,15 @@ class DocumentIndexingAPITestCase(DocumentIndexingTestMixin, DocumentTestMixin,
         self.assertTrue('id' not in response.data)
 
     def test_index_detail_api_view_with_access(self):
-        self._create_index()
+        self._create_test_index()
 
         self.grant_access(
-            obj=self.index, permission=permission_document_indexing_view
+            obj=self.test_index, permission=permission_document_indexing_view
         )
 
         response = self._request_index_detail_api_view()
 
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(
-            response.data['id'], self.index.pk
+            response.data['id'], self.test_index.pk
         )

mayan/apps/document_indexing/tests/test_models.py

@@ -1,6 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
 from django.utils.encoding import force_text
 
 from mayan.apps.common.tests import BaseTestCase
@@ -24,13 +23,12 @@ from .literals import (
 from .mixins import DocumentIndexingTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
     def test_document_description_index(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root,
+            parent=self.test_index.template_root,
             expression=TEST_INDEX_TEMPLATE_DOCUMENT_DESCRIPTION_EXPRESSION,
             link_documents=True
         )
@@ -38,7 +36,7 @@ class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
         self.document.description = TEST_DOCUMENT_DESCRIPTION
         self.document.save()
 
-        self.index.rebuild()
+        self.test_index.rebuild()
 
         self.assertEqual(
             IndexInstanceNode.objects.last().value, self.document.description
@@ -51,15 +49,15 @@ class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
         )
 
     def test_document_label_index(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root,
+            parent=self.test_index.template_root,
             expression=TEST_INDEX_TEMPLATE_DOCUMENT_LABEL_EXPRESSION,
             link_documents=True
         )
 
-        self.index.rebuild()
+        self.test_index.rebuild()
 
         self.assertEqual(
             IndexInstanceNode.objects.last().value, self.document.label
@@ -72,15 +70,15 @@ class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
         )
 
     def test_date_based_index(self):
-        self._create_index()
+        self._create_test_index()
 
-        level_year = self.index.node_templates.create(
+        level_year = self.test_index.node_templates.create(
-            parent=self.index.template_root,
+            parent=self.test_index.template_root,
             expression='{{ document.date_added|date:"Y" }}',
             link_documents=False
         )
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
             parent=level_year,
             expression='{{ document.date_added|date:"m" }}',
             link_documents=True
@@ -116,16 +114,16 @@ class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
                 file_object=file_object
             )
 
-        self._create_index()
+        self._create_test_index()
 
         # Create simple index template
-        root = self.index.template_root
+        root = self.test_index.template_root
-        level_1 = self.index.node_templates.create(
+        level_1 = self.test_index.node_templates.create(
             parent=root, expression='{{ document.uuid }}',
             link_documents=False
         )
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
             parent=level_1, expression='{{ document.label }}',
             link_documents=True
         )
@@ -151,11 +149,11 @@ class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
             document_type=self.document_type, metadata_type=metadata_type
         )
 
-        self._create_index()
+        self._create_test_index()
 
         # Create simple index template
-        root = self.index.template_root
+        root = self.test_index.template_root
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
             parent=root, expression=TEST_INDEX_TEMPLATE_METADATA_EXPRESSION,
             link_documents=True
         )
@@ -236,15 +234,15 @@ class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
         On a two level template if the first level doesn't return a result
         the indexing should stop. GitLab issue #391.
         """
-        self._create_index()
+        self._create_test_index()
 
-        level_1 = self.index.node_templates.create(
+        level_1 = self.test_index.node_templates.create(
-            parent=self.index.template_root,
+            parent=self.test_index.template_root,
             expression='',
             link_documents=True
         )
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
             parent=level_1, expression='{{ document.label }}',
             link_documents=True
         )
@@ -263,11 +261,11 @@ class IndexTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
             metadata_type=metadata_type, value='0001'
         )
 
-        self._create_index()
+        self._create_test_index()
 
         # Create simple index template
-        root = self.index.template_root
+        root = self.test_index.template_root
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
             parent=root, expression='{{ document.metadata_value_of.test }}',
             link_documents=True
         )

mayan/apps/document_indexing/tests/test_views.py

@@ -11,19 +11,15 @@ from ..permissions import (
 )
 
 from .literals import (
-    TEST_INDEX_LABEL, TEST_INDEX_LABEL_EDITED, TEST_INDEX_SLUG,
+    TEST_INDEX_LABEL, TEST_INDEX_LABEL_EDITED, TEST_INDEX_SLUG
-    TEST_INDEX_TEMPLATE_DOCUMENT_LABEL_EXPRESSION
 )
+from .mixins import DocumentIndexingTestMixin
 
 
-class IndexViewTestCase(GenericDocumentViewTestCase):
+class IndexViewTestCase(DocumentIndexingTestMixin, GenericDocumentViewTestCase):
-    def setUp(self):
-        super(IndexViewTestCase, self).setUp()
-        self.login_user()
-
     def _request_index_create_view(self):
         return self.post(
-            'indexing:index_setup_create', data={
+            viewname='indexing:index_setup_create', data={
                 'label': TEST_INDEX_LABEL, 'slug': TEST_INDEX_SLUG
             }
         )
@@ -31,6 +27,7 @@ class IndexViewTestCase(GenericDocumentViewTestCase):
     def test_index_create_view_no_permission(self):
         response = self._request_index_create_view()
         self.assertEquals(response.status_code, 403)
+
         self.assertEqual(Index.objects.count(), 0)
 
     def test_index_create_view_with_permission(self):
@@ -39,113 +36,93 @@ class IndexViewTestCase(GenericDocumentViewTestCase):
         )
 
         response = self._request_index_create_view()
-
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(Index.objects.count(), 1)
         self.assertEqual(Index.objects.first().label, TEST_INDEX_LABEL)
 
-    def _request_index_delete_view(self, index):
+    def _request_index_delete_view(self):
-        return self.post('indexing:index_setup_delete', args=(index.pk,))
+        return self.post(
-
+            viewname='indexing:index_setup_delete', kwargs={
-    def test_index_delete_view_no_permission(self):
+                'pk': self.test_index.pk
-        index = Index.objects.create(
+            }
-            label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
         )
 
-        response = self._request_index_delete_view(index=index)
+    def test_index_delete_view_no_permission(self):
+        self._create_test_index()
+
+        response = self._request_index_delete_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(Index.objects.count(), 1)
 
     def test_index_delete_view_with_permission(self):
-        self.role.permissions.add(
+        self._create_test_index()
-            permission_document_indexing_delete.stored_permission
-        )
 
-        index = Index.objects.create(
+        self.grant_permission(permission=permission_document_indexing_delete)
-            label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
-        )
-
-        response = self._request_index_delete_view(index=index)
 
+        response = self._request_index_delete_view()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(Index.objects.count(), 0)
 
-    def _request_index_edit_view(self, index):
+    def _request_index_edit_view(self):
         return self.post(
-            'indexing:index_setup_edit', args=(index.pk,), data={
+            viewname='indexing:index_setup_edit', kwargs={
+                'pk': self.test_index.pk
+            }, data={
                 'label': TEST_INDEX_LABEL_EDITED, 'slug': TEST_INDEX_SLUG
             }
         )
 
     def test_index_edit_view_no_permission(self):
-        index = Index.objects.create(
+        self._create_test_index()
-            label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
-        )
 
-        response = self._request_index_edit_view(index=index)
+        response = self._request_index_edit_view()
         self.assertEqual(response.status_code, 403)
-        index = Index.objects.get(pk=index.pk)
+
-        self.assertEqual(index.label, TEST_INDEX_LABEL)
+        self.test_index.refresh_from_db()
+        self.assertEqual(self.test_index.label, TEST_INDEX_LABEL)
 
     def test_index_edit_view_with_access(self):
-        index = Index.objects.create(
+        self._create_test_index()
-            label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
-        )
 
         self.grant_access(
-            permission=permission_document_indexing_edit,
+            obj=self.test_index, permission=permission_document_indexing_edit
-            obj=index
         )
 
-        response = self._request_index_edit_view(index=index)
+        response = self._request_index_edit_view()
         self.assertEqual(response.status_code, 302)
-        index.refresh_from_db()
-        self.assertEqual(index.label, TEST_INDEX_LABEL_EDITED)
 
-    def _create_index(self, rebuild=True):
+        self.test_index.refresh_from_db()
-        # Create empty index
+        self.assertEqual(self.test_index.label, TEST_INDEX_LABEL_EDITED)
-        self.index = Index.objects.create(label=TEST_INDEX_LABEL)
-
-        # Add our document type to the new index
-        self.index.document_types.add(self.document_type)
-
-        # Create simple index template
-        root = self.index.template_root
-        self.index.node_templates.create(
-            parent=root, expression=TEST_INDEX_TEMPLATE_DOCUMENT_LABEL_EXPRESSION,
-            link_documents=True
-        )
-
-        # Rebuild indexes
-        if rebuild:
-            Index.objects.rebuild()
 
     def _request_index_instance_node_view(self, index_instance_node):
         return self.get(
-            'indexing:index_instance_node_view', args=(index_instance_node.pk,)
+            viewname='indexing:index_instance_node_view', kwargs={
+                'pk': index_instance_node.pk
+            }
         )
 
     def test_index_instance_node_view_no_permission(self):
-        self._create_index()
+        self._create_test_index()
 
         response = self._request_index_instance_node_view(
-            index_instance_node=self.index.instance_root
+            index_instance_node=self.test_index.instance_root
         )
-
         self.assertEqual(response.status_code, 403)
 
     def test_index_instance_node_view_with_access(self):
-        self._create_index()
+        self._create_test_index()
 
         self.grant_access(
-            permission=permission_document_indexing_instance_view,
+            obj=self.test_index,
-            obj=self.index
+            permission=permission_document_indexing_instance_view
         )
 
         response = self._request_index_instance_node_view(
-            index_instance_node=self.index.instance_root
+            index_instance_node=self.test_index.instance_root
         )
-
         self.assertContains(response, text=TEST_INDEX_LABEL, status_code=200)
 
     def _request_index_rebuild_get_view(self):
@@ -156,36 +133,41 @@ class IndexViewTestCase(GenericDocumentViewTestCase):
     def _request_index_rebuild_post_view(self):
         return self.post(
             viewname='indexing:rebuild_index_instances', data={
-                'index_templates': self.index.pk
+                'index_templates': self.test_index.pk
             }
         )
 
     def test_index_rebuild_no_permission(self):
-        self._create_index(rebuild=False)
+        self._create_test_index(rebuild=False)
 
         response = self._request_index_rebuild_get_view()
-        self.assertNotContains(response=response, text=self.index.label, status_code=200)
+        self.assertNotContains(
+            response=response, text=self.test_index.label, status_code=200
+        )
 
         response = self._request_index_rebuild_post_view()
         # No error since we just don't see the index
         self.assertEqual(response.status_code, 200)
 
         self.assertEqual(
-            self.index.instance_root.get_children_count(), 0
+            self.test_index.instance_root.get_children_count(), 0
         )
 
     def test_index_rebuild_with_access(self):
-        self._create_index(rebuild=False)
+        self._create_test_index(rebuild=False)
 
         self.grant_access(
-            permission=permission_document_indexing_rebuild, obj=self.index
+            obj=self.test_index,
+            permission=permission_document_indexing_rebuild
         )
 
         response = self._request_index_rebuild_get_view()
-        self.assertContains(response=response, text=self.index.label, status_code=200)
+        self.assertContains(
+            response=response, text=self.test_index.label, status_code=200
+        )
 
         response = self._request_index_rebuild_post_view()
         self.assertEqual(response.status_code, 302)
 
         # An instance root exists
-        self.assertTrue(self.index.instance_root.pk)
+        self.assertTrue(self.test_index.instance_root.pk)

mayan/apps/document_parsing/tests/literals.py

@@ -1,3 +1,4 @@
 from __future__ import unicode_literals
 
+TEST_DOCUMENT_CONTENT = 'Sample text'
 TEST_PARSING_INDEX_NODE_TEMPLATE = '{% if "sample" in document.latest_version.content|join:" "|lower %}sample{% endif %}'

mayan/apps/document_parsing/tests/test_api.py

@@ -9,23 +9,19 @@ from mayan.apps.rest_api.tests import BaseAPITestCase
 
 from ..permissions import permission_content_view
 
-TEST_DOCUMENT_CONTENT = 'Sample text'
+from .literals import TEST_DOCUMENT_CONTENT
 
 
-@override_settings(OCR_AUTO_OCR=False)
+@override_settings(DOCUMENT_PARSING_AUTO_PARSING=True)
 class DocumentParsingAPITestCase(DocumentTestMixin, BaseAPITestCase):
     test_document_filename = TEST_HYBRID_DOCUMENT
 
-    def setUp(self):
-        super(DocumentParsingAPITestCase, self).setUp()
-        self.login_user()
-
     def _request_document_page_content_view(self):
         return self.get(
             viewname='rest_api:document-page-content-view',
             args=(
-                self.document.pk, self.document.latest_version.pk,
+                self.test_document.pk, self.test_document.latest_version.pk,
-                self.document.latest_version.pages.first().pk,
+                self.test_document.latest_version.pages.first().pk,
             )
         )
 
@@ -35,10 +31,12 @@ class DocumentParsingAPITestCase(DocumentTestMixin, BaseAPITestCase):
 
     def test_get_document_version_page_content_with_access(self):
         self.grant_access(
-            permission=permission_content_view, obj=self.document
+            permission=permission_content_view, obj=self.test_document
         )
+
         response = self._request_document_page_content_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
+
         self.assertTrue(
             TEST_DOCUMENT_CONTENT in response.data['content']
         )

mayan/apps/document_parsing/tests/test_events.py

@@ -17,10 +17,10 @@ class DocumentParsingEventsTestCase(GenericDocumentTestCase):
 
     def test_document_version_submit_event(self):
         Action.objects.all().delete()
-        self.document.submit_for_parsing()
+        self.test_document.submit_for_parsing()
 
         self.assertEqual(
-            Action.objects.last().target, self.document.latest_version
+            Action.objects.last().target, self.test_document.latest_version
         )
         self.assertEqual(
             Action.objects.last().verb,
@@ -29,9 +29,9 @@ class DocumentParsingEventsTestCase(GenericDocumentTestCase):
 
     def test_document_version_finish_event(self):
         Action.objects.all().delete()
-        self.document.submit_for_parsing()
+        self.test_document.submit_for_parsing()
         self.assertEqual(
-            Action.objects.first().target, self.document.latest_version
+            Action.objects.first().target, self.test_document.latest_version
         )
         self.assertEqual(
             Action.objects.first().verb,

mayan/apps/document_parsing/tests/test_indexing.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.documents.tests import DocumentTestMixin, TEST_HYBRID_DOCUMENT
 from mayan.apps.document_indexing.models import Index, IndexInstanceNode
@@ -10,8 +8,6 @@ from mayan.apps.document_indexing.tests.literals import TEST_INDEX_LABEL
 from .literals import TEST_PARSING_INDEX_NODE_TEMPLATE
 
 
-@override_settings(DOCUMENT_PARSING_AUTO_PARSING=False)
-@override_settings(OCR_AUTO_OCR=False)
 class ParsingIndexingTestCase(DocumentTestMixin, BaseTestCase):
     auto_upload_document = False
     test_document_filename = TEST_HYBRID_DOCUMENT
@@ -19,7 +15,7 @@ class ParsingIndexingTestCase(DocumentTestMixin, BaseTestCase):
     def test_parsing_indexing(self):
         index = Index.objects.create(label=TEST_INDEX_LABEL)
 
-        index.document_types.add(self.document_type)
+        index.document_types.add(self.test_document_type)
 
         root = index.template_root
         index.node_templates.create(
@@ -27,11 +23,11 @@ class ParsingIndexingTestCase(DocumentTestMixin, BaseTestCase):
             link_documents=True
         )
 
-        self.document = self.upload_document()
+        self.test_document = self.upload_document()
-        self.document.submit_for_parsing()
+        self.test_document.submit_for_parsing()
 
         self.assertTrue(
-            self.document in IndexInstanceNode.objects.get(
+            self.test_document in IndexInstanceNode.objects.get(
                 value='sample'
             ).documents.all()
         )

mayan/apps/document_parsing/tests/test_models.py

@@ -4,24 +4,23 @@ from django.test import override_settings
 
 from mayan.apps.documents.tests import GenericDocumentTestCase, TEST_HYBRID_DOCUMENT
 
-TEST_DOCUMENT_CONTENT = 'Sample text'
+from .literals import TEST_DOCUMENT_CONTENT
 
 
 class DocumentAutoParsingTestCase(GenericDocumentTestCase):
     test_document_filename = TEST_HYBRID_DOCUMENT
     auto_create_document_type = False
 
-    @override_settings(DOCUMENT_PARSING_AUTO_PARSING=False)
     def test_disable_auto_parsing(self):
         self._create_document_type()
-        self.document = self.upload_document()
+        self.test_document = self.upload_document()
         with self.assertRaises(StopIteration):
-            next(self.document.latest_version.content())
+            next(self.test_document.latest_version.content())
 
     @override_settings(DOCUMENT_PARSING_AUTO_PARSING=True)
     def test_enabled_auto_parsing(self):
         self._create_document_type()
-        self.document = self.upload_document()
+        self.test_document = self.upload_document()
         self.assertTrue(
-            TEST_DOCUMENT_CONTENT in next(self.document.content())
+            TEST_DOCUMENT_CONTENT in next(self.test_document.content())
         )

mayan/apps/document_parsing/tests/test_parsers.py

@@ -1,24 +1,21 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.documents.tests import DocumentTestMixin, TEST_HYBRID_DOCUMENT
 
 from ..parsers import PopplerParser
 
-TEST_DOCUMENT_CONTENT = 'Sample text'
+from .literals import TEST_DOCUMENT_CONTENT
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class ParserTestCase(DocumentTestMixin, BaseTestCase):
     test_document_filename = TEST_HYBRID_DOCUMENT
 
     def test_poppler_parser(self):
         parser = PopplerParser()
 
-        parser.process_document_version(self.document.latest_version)
+        parser.process_document_version(self.test_document.latest_version)
 
         self.assertTrue(
-            TEST_DOCUMENT_CONTENT in self.document.pages.first().content.content
+            TEST_DOCUMENT_CONTENT in self.test_document.pages.first().content.content
         )

mayan/apps/document_parsing/tests/test_views.py

@@ -11,7 +11,7 @@ from ..permissions import (
 )
 from ..utils import get_document_content
 
-TEST_DOCUMENT_CONTENT = 'Sample text'
+from .literals import TEST_DOCUMENT_CONTENT
 
 
 @override_settings(DOCUMENT_PARSING_AUTO_PARSING=True)
@@ -21,48 +21,44 @@ class DocumentContentViewsTestCase(GenericDocumentViewTestCase):
     # Ensure we use a PDF file
     test_document_filename = TEST_HYBRID_DOCUMENT
 
-    def setUp(self):
-        super(DocumentContentViewsTestCase, self).setUp()
-        self.login_user()
-
     def _request_document_content_view(self):
         return self.get(
-            'document_parsing:document_content', args=(self.document.pk,)
+            'document_parsing:document_content', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_content_view_no_permissions(self):
         response = self._request_document_content_view()
-
         self.assertEqual(response.status_code, 403)
 
     def test_document_content_view_with_access(self):
         self.grant_access(
-            permission=permission_content_view, obj=self.document
+            obj=self.test_document, permission=permission_content_view
         )
-        response = self._request_document_content_view()
 
+        response = self._request_document_content_view()
         self.assertContains(
             response=response, text=TEST_DOCUMENT_CONTENT, status_code=200
         )
 
     def _request_document_page_content_view(self):
         return self.get(
-            viewname='document_parsing:document_page_content', args=(
+            viewname='document_parsing:document_page_content', kwargs={
-                self.document.pages.first().pk,
+                'pk': self.test_document.pages.first().pk,
-            )
+            }
         )
 
     def test_document_page_content_view_no_permissions(self):
         response = self._request_document_page_content_view()
-
         self.assertEqual(response.status_code, 403)
 
     def test_document_page_content_view_with_access(self):
         self.grant_access(
-            permission=permission_content_view, obj=self.document
+            permission=permission_content_view, obj=self.test_document
         )
-        response = self._request_document_page_content_view()
 
+        response = self._request_document_page_content_view()
         self.assertContains(
             response=response, text=TEST_DOCUMENT_CONTENT, status_code=200
         )
@@ -70,7 +66,7 @@ class DocumentContentViewsTestCase(GenericDocumentViewTestCase):
     def _request_document_content_download_view(self):
         return self.get(
             viewname='document_parsing:document_content_download',
-            args=(self.document.pk,)
+            kwargs={'pk': self.test_document.pk}
         )
 
     def test_document_parsing_download_view_no_permission(self):
@@ -80,34 +76,33 @@ class DocumentContentViewsTestCase(GenericDocumentViewTestCase):
     def test_download_view_with_access(self):
         self.expected_content_type = 'application/octet-stream; charset=utf-8'
         self.grant_access(
-            permission=permission_content_view, obj=self.document
+            permission=permission_content_view, obj=self.test_document
         )
-        response = self._request_document_content_download_view()
 
+        response = self._request_document_content_download_view()
         self.assertEqual(response.status_code, 200)
 
         self.assert_download_response(
             response=response, content=(
-                ''.join(get_document_content(document=self.document))
+                ''.join(get_document_content(document=self.test_document))
             ),
         )
 
-    def test_document_type_parsing_settings_view_no_permission(self):
+    def _request_test_document_type_parsing_settings(self):
-        response = self.get(
+        return self.get(
             viewname='document_parsing:document_type_parsing_settings',
-            args=(self.document.document_type.pk,)
+            kwargs={'pk': self.test_document.document_type.pk}
         )
 
+    def test_document_type_parsing_settings_view_no_permission(self):
+        response = self._request_test_document_type_parsing_settings()
         self.assertEqual(response.status_code, 403)
 
     def test_document_type_parsing_settings_view_with_access(self):
         self.grant_access(
             permission=permission_document_type_parsing_setup,
-            obj=self.document.document_type
+            obj=self.test_document.document_type
-        )
-        response = self.get(
-            viewname='document_parsing:document_type_parsing_settings',
-            args=(self.document.document_type.pk,)
         )
 
+        response = self._request_test_document_type_parsing_settings()
         self.assertEqual(response.status_code, 200)

mayan/apps/document_signatures/tests/mixins.py

@@ -10,10 +10,10 @@ from .literals import TEST_KEY_FILE, TEST_SIGNATURE_FILE_PATH
 
 
 class SignaturesTestMixin(object):
-    def _create_detached_signature(self):
+    def _create_test_detached_signature(self):
         with open(TEST_SIGNATURE_FILE_PATH, mode='rb') as file_object:
             self.test_signature = DetachedSignature.objects.create(
-                document_version=self.document.latest_version,
+                document_version=self.test_document.latest_version,
                 signature_file=File(file_object)
             )
 

mayan/apps/document_signatures/tests/test_links.py

@@ -1,6 +1,5 @@
 from __future__ import unicode_literals
 
-from django.core.files import File
 from django.urls import reverse
 
 from mayan.apps.documents.tests import (
@@ -11,27 +10,21 @@ from ..links import (
     link_document_version_signature_delete,
     link_document_version_signature_details,
 )
-from ..models import DetachedSignature
 from ..permissions import (
     permission_document_version_signature_delete,
     permission_document_version_signature_view
 )
-from .literals import TEST_SIGNATURE_FILE_PATH, TEST_SIGNED_DOCUMENT_PATH
+from .literals import TEST_SIGNED_DOCUMENT_PATH
+from .mixins import SignaturesTestMixin
 
 
-class DocumentSignatureLinksTestCase(GenericDocumentViewTestCase):
+class DocumentSignatureLinksTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DocumentSignatureLinksTestCase, self).setUp()
-        self.login_user()
-
     def test_document_version_signature_detail_link_no_permission(self):
-        with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
-            document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
         self.add_test_view(
-            test_object=document.latest_version.signatures.first()
+            test_object=self.test_document.latest_version.signatures.first()
         )
         context = self.get_test_view()
         resolved_link = link_document_version_signature_details.resolve(
@@ -41,17 +34,16 @@ class DocumentSignatureLinksTestCase(GenericDocumentViewTestCase):
         self.assertEqual(resolved_link, None)
 
     def test_document_version_signature_detail_link_with_permission(self):
-        with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
-            document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self.role.permissions.add(
+        self.grant_access(
-            permission_document_version_signature_view.stored_permission
+            obj=self.test_document,
+            permission=permission_document_version_signature_view
         )
 
         self.add_test_view(
-            test_object=document.latest_version.signatures.first()
+            test_object=self.test_document.latest_version.signatures.first()
         )
         context = self.get_test_view()
         resolved_link = link_document_version_signature_details.resolve(
@@ -62,62 +54,49 @@ class DocumentSignatureLinksTestCase(GenericDocumentViewTestCase):
         self.assertEqual(
             resolved_link.url,
             reverse(
-                'signatures:document_version_signature_details',
+                viewname=link_document_version_signature_details.view,
-                args=(document.latest_version.signatures.first().pk,)
+                args=(self.test_document.latest_version.signatures.first().pk,)
             )
         )
 
     def test_document_version_signature_delete_link_no_permission(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        with open(TEST_SIGNATURE_FILE_PATH, mode='rb') as file_object:
+        self._create_test_detached_signature()
-            DetachedSignature.objects.create(
-                document_version=document.latest_version,
-                signature_file=File(file_object)
-            )
 
         self.add_test_view(
-            test_object=document.latest_version.signatures.first()
+            test_object=self.test_document.latest_version.signatures.first()
         )
         context = self.get_test_view()
         resolved_link = link_document_version_signature_delete.resolve(
             context=context
         )
-
         self.assertEqual(resolved_link, None)
 
     def test_document_version_signature_delete_link_with_permission(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        with open(TEST_SIGNATURE_FILE_PATH, mode='rb') as file_object:
+        self._create_test_detached_signature()
-            DetachedSignature.objects.create(
-                document_version=document.latest_version,
-                signature_file=File(file_object)
-            )
 
-        self.role.permissions.add(
+        self.grant_access(
-            permission_document_version_signature_delete.stored_permission
+            obj=self.test_document,
+            permission=permission_document_version_signature_delete
         )
 
         self.add_test_view(
-            test_object=document.latest_version.signatures.first()
+            test_object=self.test_document.latest_version.signatures.first()
         )
         context = self.get_test_view()
         resolved_link = link_document_version_signature_delete.resolve(
             context=context
         )
-
         self.assertNotEqual(resolved_link, None)
         self.assertEqual(
             resolved_link.url,
             reverse(
-                'signatures:document_version_signature_delete',
+                viewname=link_document_version_signature_delete.view,
-                args=(document.latest_version.signatures.first().pk,)
+                args=(self.test_document.latest_version.signatures.first().pk,)
             )
         )

mayan/apps/document_signatures/tests/test_models.py

@@ -1,112 +1,84 @@
 from __future__ import unicode_literals
 
 import hashlib
-import logging
 import time
 
-from django.test import override_settings
-
-from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.django_gpg.models import Key
 from mayan.apps.django_gpg.tests.literals import (
     TEST_KEY_DATA, TEST_KEY_PASSPHRASE
 )
-from mayan.apps.documents.models import DocumentType, DocumentVersion
+from mayan.apps.documents.models import DocumentVersion
-from mayan.apps.documents.tests import TEST_DOCUMENT_PATH, TEST_DOCUMENT_TYPE_LABEL
+from mayan.apps.documents.tests import (
+    GenericDocumentTestCase, TEST_DOCUMENT_PATH
+)
 
 from ..models import DetachedSignature, EmbeddedSignature
 from ..tasks import task_verify_missing_embedded_signature
 
-from .literals import (
+from .literals import TEST_SIGNED_DOCUMENT_PATH, TEST_KEY_ID, TEST_SIGNATURE_ID
-    TEST_SIGNED_DOCUMENT_PATH, TEST_KEY_FILE, TEST_KEY_ID, TEST_SIGNATURE_ID
-)
 from .mixins import SignaturesTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class DocumentSignaturesTestCase(SignaturesTestMixin, GenericDocumentTestCase):
-class DocumentSignaturesTestCase(SignaturesTestMixin, BaseTestCase):
+    auto_upload_document = False
-    def setUp(self):
-        super(DocumentSignaturesTestCase, self).setUp()
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
-    def tearDown(self):
-        self.document_type.delete()
-        super(DocumentSignaturesTestCase, self).tearDown()
 
     def test_embedded_signature_no_key(self):
-        with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
-            signed_document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
         self.assertEqual(EmbeddedSignature.objects.count(), 1)
 
         signature = EmbeddedSignature.objects.first()
-
         self.assertEqual(
-            signature.document_version, signed_document.latest_version
+            signature.document_version, self.test_document.latest_version
         )
         self.assertEqual(signature.key_id, TEST_KEY_ID)
         self.assertEqual(signature.signature_id, None)
 
     def test_embedded_signature_post_key_verify(self):
-        with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
-            signed_document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
         self.assertEqual(EmbeddedSignature.objects.count(), 1)
 
         signature = EmbeddedSignature.objects.first()
-
         self.assertEqual(
-            signature.document_version, signed_document.latest_version
+            signature.document_version, self.test_document.latest_version
         )
         self.assertEqual(signature.key_id, TEST_KEY_ID)
         self.assertEqual(signature.signature_id, None)
 
-        with open(TEST_KEY_FILE, mode='rb') as file_object:
+        self._create_test_key()
-            Key.objects.create(key_data=file_object.read())
 
         signature = EmbeddedSignature.objects.first()
 
         self.assertEqual(signature.signature_id, TEST_SIGNATURE_ID)
 
     def test_embedded_signature_post_no_key_verify(self):
-        with open(TEST_KEY_FILE, mode='rb') as file_object:
+        self._create_test_key()
-            key = Key.objects.create(key_data=file_object.read())
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
-
+        self.upload_document()
-        with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
-            signed_document = self.document_type.new_document(
-                file_object=file_object
-            )
 
         self.assertEqual(EmbeddedSignature.objects.count(), 1)
 
         signature = EmbeddedSignature.objects.first()
 
         self.assertEqual(
-            signature.document_version, signed_document.latest_version
+            signature.document_version, self.test_document.latest_version
         )
         self.assertEqual(signature.key_id, TEST_KEY_ID)
         self.assertEqual(signature.signature_id, TEST_SIGNATURE_ID)
 
-        key.delete()
+        self.test_key.delete()
 
         signature = EmbeddedSignature.objects.first()
 
         self.assertEqual(signature.signature_id, None)
 
     def test_embedded_signature_with_key(self):
-        with open(TEST_KEY_FILE, mode='rb') as file_object:
+        self._create_test_key()
-            key = Key.objects.create(key_data=file_object.read())
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
-
+        self.upload_document()
-        with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
-            self.signed_document = self.document_type.new_document(
-                file_object=file_object
-            )
 
         self.assertEqual(EmbeddedSignature.objects.count(), 1)
 
@@ -114,116 +86,107 @@ class DocumentSignaturesTestCase(SignaturesTestMixin, BaseTestCase):
 
         self.assertEqual(
             signature.document_version,
-            self.signed_document.latest_version
+            self.test_document.latest_version
         )
         self.assertEqual(signature.key_id, TEST_KEY_ID)
-        self.assertEqual(signature.public_key_fingerprint, key.fingerprint)
+        self.assertEqual(
+            signature.public_key_fingerprint, self.test_key.fingerprint
+        )
         self.assertEqual(signature.signature_id, TEST_SIGNATURE_ID)
 
     def test_detached_signature_no_key(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         self.assertEqual(DetachedSignature.objects.count(), 1)
 
         self.assertEqual(
-            self.test_signature.document_version, self.document.latest_version
+            self.test_signature.document_version, self.test_document.latest_version
         )
         self.assertEqual(self.test_signature.key_id, TEST_KEY_ID)
         self.assertEqual(self.test_signature.public_key_fingerprint, None)
 
     def test_detached_signature_with_key(self):
-        with open(TEST_KEY_FILE, mode='rb') as file_object:
+        self._create_test_key()
-            key = Key.objects.create(key_data=file_object.read())
+        self.test_document_path = TEST_DOCUMENT_PATH
+        self.upload_document()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self._create_test_detached_signature()
-            self.document = self.document_type.new_document(
-                file_object=file_object
-            )
-
-        self._create_detached_signature()
 
         self.assertEqual(DetachedSignature.objects.count(), 1)
 
         self.assertEqual(
-            self.test_signature.document_version, self.document.latest_version
+            self.test_signature.document_version, self.test_document.latest_version
         )
         self.assertEqual(self.test_signature.key_id, TEST_KEY_ID)
         self.assertEqual(
-            self.test_signature.public_key_fingerprint, key.fingerprint
+            self.test_signature.public_key_fingerprint,
+            self.test_key.fingerprint
         )
 
     def test_detached_signature_post_key_verify(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         self.assertEqual(DetachedSignature.objects.count(), 1)
 
         self.assertEqual(
-            self.test_signature.document_version, self.document.latest_version
+            self.test_signature.document_version,
+            self.test_document.latest_version
         )
         self.assertEqual(self.test_signature.key_id, TEST_KEY_ID)
         self.assertEqual(self.test_signature.public_key_fingerprint, None)
 
-        with open(TEST_KEY_FILE, mode='rb') as file_object:
+        self._create_test_key()
-            key = Key.objects.create(key_data=file_object.read())
 
         signature = DetachedSignature.objects.first()
 
-        self.assertEqual(signature.public_key_fingerprint, key.fingerprint)
+        self.assertEqual(
+            signature.public_key_fingerprint, self.test_key.fingerprint
+        )
 
     def test_detached_signature_post_no_key_verify(self):
-        with open(TEST_KEY_FILE, mode='rb') as file_object:
+        self._create_test_key()
-            key = Key.objects.create(key_data=file_object.read())
+        self.test_document_path = TEST_DOCUMENT_PATH
+        self.upload_document()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self._create_test_detached_signature()
-            self.document = self.document_type.new_document(
-                file_object=file_object
-            )
-
-        self._create_detached_signature()
 
         self.assertEqual(DetachedSignature.objects.count(), 1)
 
         self.assertEqual(
-            self.test_signature.document_version, self.document.latest_version
+            self.test_signature.document_version,
+            self.test_document.latest_version
         )
         self.assertEqual(self.test_signature.key_id, TEST_KEY_ID)
         self.assertEqual(
-            self.test_signature.public_key_fingerprint, key.fingerprint
+            self.test_signature.public_key_fingerprint,
+            self.test_key.fingerprint
         )
 
-        key.delete()
+        self.test_key.delete()
 
         signature = DetachedSignature.objects.first()
 
         self.assertEqual(signature.public_key_fingerprint, None)
 
     def test_document_no_signature(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
         self.assertEqual(EmbeddedSignature.objects.count(), 0)
 
     def test_new_signed_version(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
         with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
-            signed_version = document.new_version(
+            signed_version = self.test_document.new_version(
-                file_object=file_object, comment='test comment 1'
+                file_object=file_object, comment=''
             )
 
         # Artifical delay since MySQL doesn't store microsecond data in
@@ -239,34 +202,20 @@ class DocumentSignaturesTestCase(SignaturesTestMixin, BaseTestCase):
         self.assertEqual(signature.key_id, TEST_KEY_ID)
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class EmbeddedSignaturesTestCase(GenericDocumentTestCase):
-class EmbeddedSignaturesTestCase(BaseTestCase):
+    auto_upload_document = False
-    def setUp(self):
-        super(EmbeddedSignaturesTestCase, self).setUp()
-
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
-    def tearDown(self):
-        self.document_type.delete()
-        super(EmbeddedSignaturesTestCase, self).tearDown()
 
     def test_unsigned_document_version_method(self):
         TEST_UNSIGNED_DOCUMENT_COUNT = 2
         TEST_SIGNED_DOCUMENT_COUNT = 2
 
+        self.test_document_path = TEST_DOCUMENT_PATH
         for count in range(TEST_UNSIGNED_DOCUMENT_COUNT):
-            with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+            self.upload_document()
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
         for count in range(TEST_SIGNED_DOCUMENT_COUNT):
-            with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+            self.upload_document()
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
         self.assertEqual(
             EmbeddedSignature.objects.unsigned_document_versions().count(),
@@ -275,7 +224,7 @@ class EmbeddedSignaturesTestCase(BaseTestCase):
 
     def test_task_verify_missing_embedded_signature(self):
         # Silence converter logging
-        logging.getLogger('converter.backends').setLevel(logging.CRITICAL)
+        self._silence_logger(name='mayan.apps.converter.backends')
 
         old_hooks = DocumentVersion._post_save_hooks
 
@@ -284,17 +233,13 @@ class EmbeddedSignaturesTestCase(BaseTestCase):
         TEST_UNSIGNED_DOCUMENT_COUNT = 2
         TEST_SIGNED_DOCUMENT_COUNT = 2
 
+        self.test_document_path = TEST_DOCUMENT_PATH
         for count in range(TEST_UNSIGNED_DOCUMENT_COUNT):
-            with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+            self.upload_document()
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
         for count in range(TEST_SIGNED_DOCUMENT_COUNT):
-            with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+            self.upload_document()
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
         self.assertEqual(
             EmbeddedSignature.objects.unsigned_document_versions().count(),
@@ -311,21 +256,20 @@ class EmbeddedSignaturesTestCase(BaseTestCase):
         )
 
     def test_signing(self):
-        key = Key.objects.create(key_data=TEST_KEY_DATA)
+        self.test_key = Key.objects.create(key_data=TEST_KEY_DATA)
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        with document.latest_version.open() as file_object:
+        with self.test_document.latest_version.open() as file_object:
             file_object.seek(0, 2)
             original_size = file_object.tell()
             file_object.seek(0)
             original_hash = hashlib.sha256(file_object.read()).hexdigest()
 
         new_version = EmbeddedSignature.objects.sign_document_version(
-            document_version=document.latest_version, key=key,
+            document_version=self.test_document.latest_version,
+            key=self.test_key,
             passphrase=TEST_KEY_PASSPHRASE
         )
 

mayan/apps/document_signatures/tests/test_views.py

@@ -1,7 +1,5 @@
 from __future__ import absolute_import, unicode_literals
 
-import logging
-
 from django_downloadview.test import assert_download_response
 
 from mayan.apps.documents.models import DocumentVersion
@@ -26,48 +24,42 @@ TEST_SIGNED_DOCUMENT_COUNT = 2
 
 
 class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
-    def setUp(self):
+    auto_upload_document = False
-        super(SignaturesViewTestCase, self).setUp()
-        self.login_user()
 
     def _request_document_version_signature_list_view(self, document):
         return self.get(
             viewname='signatures:document_version_signature_list',
-            args=(document.latest_version.pk,)
+            kwargs={'pk': self.test_document.latest_version.pk}
         )
 
     def test_signature_list_view_no_permission(self):
         self._create_test_key()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         response = self._request_document_version_signature_list_view(
-            document=self.document
+            document=self.test_document
         )
         self.assertEqual(response.status_code, 403)
 
     def test_signature_list_view_with_access(self):
         self._create_test_key()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         self.grant_access(
-            obj=self.document,
+            obj=self.test_document,
             permission=permission_document_version_signature_view
         )
 
         response = self._request_document_version_signature_list_view(
-            document=self.document
+            document=self.test_document
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.context['object_list'].count(), 1)
@@ -75,18 +67,16 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
     def _request_document_version_signature_details_view(self):
         return self.get(
             viewname='signatures:document_version_signature_details',
-            args=(self.test_signature.pk,)
+            kwargs={'pk': self.test_signature.pk}
         )
 
     def test_signature_detail_view_no_permission(self):
         self._create_test_key()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         response = self._request_document_version_signature_details_view()
         self.assertEqual(response.status_code, 403)
@@ -94,15 +84,13 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
     def test_signature_detail_view_with_access(self):
         self._create_test_key()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         self.grant_access(
-            obj=self.document,
+            obj=self.test_document,
             permission=permission_document_version_signature_view
         )
 
@@ -116,33 +104,31 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
         with open(TEST_SIGNATURE_FILE_PATH, mode='rb') as file_object:
             return self.post(
                 viewname='signatures:document_version_signature_upload',
-                kwargs={'pk': self.document.latest_version.pk},
+                kwargs={'pk': self.test_document.latest_version.pk},
                 data={'signature_file': file_object}
             )
 
     def test_signature_upload_view_no_permission(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
         response = self._request_document_version_signature_upload_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(DetachedSignature.objects.count(), 0)
 
     def test_signature_upload_view_with_access(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
         self.grant_access(
-            obj=self.document,
+            obj=self.test_document,
             permission=permission_document_version_signature_upload
         )
 
         response = self._request_document_version_signature_upload_view()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(DetachedSignature.objects.count(), 1)
 
     def _request_document_version_signature_download_view(self):
@@ -152,26 +138,22 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
         )
 
     def test_signature_download_view_no_permission(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         response = self._request_document_version_signature_download_view()
         self.assertEqual(response.status_code, 403)
 
     def test_signature_download_view_with_access(self):
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         self.grant_access(
-            obj=self.document,
+            obj=self.test_document,
             permission=permission_document_version_signature_download
         )
 
@@ -193,15 +175,13 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
     def test_signature_delete_view_no_permission(self):
         self._create_test_key()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         self.grant_access(
-            obj=self.document,
+            obj=self.test_document,
             permission=permission_document_version_signature_view
         )
 
@@ -212,19 +192,17 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
     def test_signature_delete_view_with_access(self):
         self._create_test_key()
 
-        with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_document_path = TEST_DOCUMENT_PATH
-            self.document = self.document_type.new_document(
+        self.upload_document()
-                file_object=file_object
-            )
 
-        self._create_detached_signature()
+        self._create_test_detached_signature()
 
         self.grant_access(
-            obj=self.document,
+            obj=self.test_document,
             permission=permission_document_version_signature_delete
         )
         self.grant_access(
-            obj=self.document,
+            obj=self.test_document,
             permission=permission_document_version_signature_view
         )
 
@@ -239,24 +217,21 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
 
     def test_missing_signature_verify_view_no_permission(self):
         # Silence converter logging
-        logging.getLogger('converter.backends').setLevel(logging.CRITICAL)
+        self._silence_logger(name='mayan.apps.converter.backends')
 
-        for document in self.document_type.documents.all():
+        for document in self.test_document_type.documents.all():
             document.delete(to_trash=False)
 
         old_hooks = DocumentVersion._post_save_hooks
         DocumentVersion._post_save_hooks = {}
-        for count in range(TEST_UNSIGNED_DOCUMENT_COUNT):
-            with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
+        self.test_document_path = TEST_DOCUMENT_PATH
+        for count in range(TEST_UNSIGNED_DOCUMENT_COUNT):
+            self.upload_document()
+
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
         for count in range(TEST_SIGNED_DOCUMENT_COUNT):
-            with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+            self.upload_document()
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
         self.assertEqual(
             EmbeddedSignature.objects.unsigned_document_versions().count(),
@@ -275,24 +250,21 @@ class SignaturesViewTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
 
     def test_missing_signature_verify_view_with_permission(self):
         # Silence converter logging
-        logging.getLogger('converter.backends').setLevel(logging.CRITICAL)
+        self._silence_logger(name='mayan.apps.converter.backends')
 
-        for document in self.document_type.documents.all():
+        for document in self.test_document_type.documents.all():
             document.delete(to_trash=False)
 
         old_hooks = DocumentVersion._post_save_hooks
         DocumentVersion._post_save_hooks = {}
-        for count in range(TEST_UNSIGNED_DOCUMENT_COUNT):
-            with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
+        self.test_document_path = TEST_DOCUMENT_PATH
+        for count in range(TEST_UNSIGNED_DOCUMENT_COUNT):
+            self.upload_document()
+
+        self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
         for count in range(TEST_SIGNED_DOCUMENT_COUNT):
-            with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
+            self.upload_document()
-                self.document_type.new_document(
-                    file_object=file_object
-                )
 
         self.assertEqual(
             EmbeddedSignature.objects.unsigned_document_versions().count(),

mayan/apps/document_states/tests/mixins.py

@@ -1,48 +1,65 @@
 from __future__ import unicode_literals
 
-from ..models import Workflow, WorkflowState, WorkflowTransition
+from ..models import Workflow
 
 from .literals import (
     TEST_WORKFLOW_INITIAL_STATE_LABEL, TEST_WORKFLOW_INITIAL_STATE_COMPLETION,
-    TEST_WORKFLOW_INTERNAL_NAME, TEST_WORKFLOW_LABEL,
+    TEST_WORKFLOW_INSTANCE_LOG_ENTRY_COMMENT, TEST_WORKFLOW_INTERNAL_NAME,
-    TEST_WORKFLOW_STATE_LABEL, TEST_WORKFLOW_STATE_COMPLETION,
+    TEST_WORKFLOW_LABEL, TEST_WORKFLOW_STATE_LABEL,
-    TEST_WORKFLOW_TRANSITION_LABEL, TEST_WORKFLOW_TRANSITION_LABEL_2
+    TEST_WORKFLOW_STATE_COMPLETION, TEST_WORKFLOW_TRANSITION_LABEL,
+    TEST_WORKFLOW_TRANSITION_LABEL_2
 )
 
 
 class WorkflowTestMixin(object):
-    def _create_workflow(self):
+    def _create_test_workflow(self, add_document_type=False):
-        self.workflow = Workflow.objects.create(
+        self.test_workflow = Workflow.objects.create(
             label=TEST_WORKFLOW_LABEL,
             internal_name=TEST_WORKFLOW_INTERNAL_NAME
         )
 
-    def _create_workflow_states(self):
+        if add_document_type:
-        self.workflow_initial_state = WorkflowState.objects.create(
+            self.test_workflow.document_types.add(self.test_document_type)
-            workflow=self.workflow, label=TEST_WORKFLOW_INITIAL_STATE_LABEL,
+
-            completion=TEST_WORKFLOW_INITIAL_STATE_COMPLETION, initial=True
+    def _create_test_workflow_state(self):
-        )
+        self.test_workflow_state = self.test_workflow.states.create(
-        self.workflow_state = WorkflowState.objects.create(
+            completion=TEST_WORKFLOW_STATE_COMPLETION,
-            workflow=self.workflow, label=TEST_WORKFLOW_STATE_LABEL,
+            label=TEST_WORKFLOW_STATE_LABEL
-            completion=TEST_WORKFLOW_STATE_COMPLETION
         )
 
-    def _create_workflow_transition(self):
+    def _create_test_workflow_states(self):
-        self.workflow_transition = WorkflowTransition.objects.create(
+        self.test_workflow_state_1 = self.test_workflow.states.create(
-            workflow=self.workflow, label=TEST_WORKFLOW_TRANSITION_LABEL,
+            completion=TEST_WORKFLOW_INITIAL_STATE_COMPLETION,
-            origin_state=self.workflow_initial_state,
+            initial=True, label=TEST_WORKFLOW_INITIAL_STATE_LABEL
-            destination_state=self.workflow_state
+        )
+        self.test_workflow_state_2 = self.test_workflow.states.create(
+            completion=TEST_WORKFLOW_STATE_COMPLETION,
+            label=TEST_WORKFLOW_STATE_LABEL
         )
 
-    def _create_workflow_transitions(self):
+    def _create_test_workflow_transition(self):
-        self.workflow_transition = WorkflowTransition.objects.create(
+        self.test_workflow_transition = self.test_workflow.transitions.create(
-            workflow=self.workflow, label=TEST_WORKFLOW_TRANSITION_LABEL,
+            label=TEST_WORKFLOW_TRANSITION_LABEL,
-            origin_state=self.workflow_initial_state,
+            origin_state=self.test_workflow_state_1,
-            destination_state=self.workflow_state
+            destination_state=self.test_workflow_state_2,
         )
 
-        self.workflow_transition_2 = WorkflowTransition.objects.create(
+    def _create_test_workflow_transitions(self):
-            workflow=self.workflow, label=TEST_WORKFLOW_TRANSITION_LABEL_2,
+        self.test_workflow_transition = self.test_workflow.transitions.create(
-            origin_state=self.workflow_initial_state,
+            workflow=self.test_workflow, label=TEST_WORKFLOW_TRANSITION_LABEL,
-            destination_state=self.workflow_state
+            origin_state=self.test_workflow_state_1,
+            destination_state=self.test_workflow_state_2
+        )
+
+        self.test_workflow_transition_2 = self.test_workflow.transitions.create(
+            workflow=self.test_workflow, label=TEST_WORKFLOW_TRANSITION_LABEL_2,
+            origin_state=self.test_workflow_state_1,
+            destination_state=self.test_workflow_state_2
+        )
+
+    def _create_test_workflow_instance_log_entry(self):
+        self.test_document.workflows.first().log_entries.create(
+            comment=TEST_WORKFLOW_INSTANCE_LOG_ENTRY_COMMENT,
+            transition=self.test_workflow_transition,
+            user=self._test_case_user
         )

mayan/apps/document_states/tests/test_indexing.py

@@ -1,12 +1,6 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
+from mayan.apps.documents.tests import GenericDocumentTestCase
-
-from mayan.apps.common.tests import BaseTestCase
-from mayan.apps.documents.models import DocumentType
-from mayan.apps.documents.tests import (
-    TEST_SMALL_DOCUMENT_PATH, TEST_DOCUMENT_TYPE_LABEL
-)
 from mayan.apps.document_indexing.models import Index, IndexInstanceNode
 
 from ..models import Workflow
@@ -20,55 +14,41 @@ from .literals import (
 )
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class DocumentStateIndexingTestCase(GenericDocumentTestCase):
-class DocumentStateIndexingTestCase(BaseTestCase):
+    auto_upload_document = False
-    def tearDown(self):
-        self.document_type.delete()
-        super(DocumentStateIndexingTestCase, self).tearDown()
 
-    def _create_document_type(self):
+    def _create_test_workflow(self):
-        self.document_type = DocumentType.objects.create(
+        self.test_workflow = Workflow.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
-    def _create_document(self):
-        with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
-            self.document = self.document_type.new_document(
-                file_object=file_object
-            )
-
-    def _create_workflow(self):
-        self.workflow = Workflow.objects.create(
             label=TEST_WORKFLOW_LABEL,
             internal_name=TEST_WORKFLOW_INTERNAL_NAME
         )
-        self.workflow.document_types.add(self.document_type)
+        self.test_workflow.document_types.add(self.test_document_type)
 
-    def _create_workflow_states(self):
+    def _create_test_workflow_states(self):
-        self._create_workflow()
+        self._create_test_workflow()
-        self.workflow_state_1 = self.workflow.states.create(
+        self.test_workflow_state_1 = self.test_workflow.states.create(
             completion=TEST_WORKFLOW_INITIAL_STATE_COMPLETION,
             initial=True, label=TEST_WORKFLOW_INITIAL_STATE_LABEL
         )
-        self.workflow_state_2 = self.workflow.states.create(
+        self.test_workflow_state_2 = self.test_workflow.states.create(
             completion=TEST_WORKFLOW_STATE_COMPLETION,
             label=TEST_WORKFLOW_STATE_LABEL
         )
 
-    def _create_workflow_transition(self):
+    def _create_test_workflow_transition(self):
-        self._create_workflow_states()
+        self._create_test_workflow_states()
-        self.workflow_transition = self.workflow.transitions.create(
+        self.test_workflow_transition = self.test_workflow.transitions.create(
             label=TEST_WORKFLOW_TRANSITION_LABEL,
-            origin_state=self.workflow_state_1,
+            origin_state=self.test_workflow_state_1,
-            destination_state=self.workflow_state_2,
+            destination_state=self.test_workflow_state_2,
         )
 
-    def _create_index(self):
+    def _create_test_index(self):
         # Create empty index
         index = Index.objects.create(label=TEST_INDEX_LABEL)
 
         # Add our document type to the new index
-        index.document_types.add(self.document_type)
+        index.document_types.add(self.test_document_type)
 
         # Create simple index template
         root = index.template_root
@@ -78,10 +58,9 @@ class DocumentStateIndexingTestCase(BaseTestCase):
         )
 
     def test_workflow_indexing_initial_state(self):
-        self._create_document_type()
+        self._create_test_workflow_transition()
-        self._create_workflow_transition()
+        self._create_test_index()
-        self._create_index()
+        self.upload_document()
-        self._create_document()
 
         self.assertEqual(
             list(
@@ -90,14 +69,13 @@ class DocumentStateIndexingTestCase(BaseTestCase):
         )
 
     def test_workflow_indexing_transition(self):
-        self._create_document_type()
+        self._create_test_workflow_transition()
-        self._create_workflow_transition()
+        self._create_test_index()
-        self._create_index()
+        self.upload_document()
-        self._create_document()
 
-        self.document.workflows.first().do_transition(
+        self.test_document.workflows.first().do_transition(
-            transition=self.workflow_transition,
+            transition=self.test_workflow_transition,
-            user=self.admin_user
+            user=self._test_case_user
         )
 
         self.assertEqual(
@@ -107,17 +85,16 @@ class DocumentStateIndexingTestCase(BaseTestCase):
         )
 
     def test_workflow_indexing_document_delete(self):
-        self._create_document_type()
+        self._create_test_workflow_transition()
-        self._create_workflow_transition()
+        self._create_test_index()
-        self._create_index()
+        self.upload_document()
-        self._create_document()
 
-        self.document.workflows.first().do_transition(
+        self.test_document.workflows.first().do_transition(
-            transition=self.workflow_transition,
+            transition=self.test_workflow_transition,
-            user=self.admin_user
+            user=self._test_case_user
         )
 
-        self.document.delete(to_trash=False)
+        self.test_document.delete(to_trash=False)
 
         self.assertEqual(
             list(

mayan/apps/documents/apps.py

@@ -202,7 +202,17 @@ class DocumentsApp(MayanAppConfig):
         ModelPermission.register(
             model=DocumentType, permissions=(
                 permission_document_create, permission_document_type_delete,
-                permission_document_type_edit, permission_document_type_view
+                permission_document_type_edit, permission_document_type_view,
+                permission_acl_edit, permission_acl_view,
+                permission_document_delete, permission_document_download,
+                permission_document_edit, permission_document_new_version,
+                permission_document_print, permission_document_properties_edit,
+                permission_document_restore, permission_document_trash,
+                permission_document_version_revert,
+                permission_document_version_view, permission_document_view,
+                permission_events_view, permission_transformation_create,
+                permission_transformation_delete,
+                permission_transformation_edit, permission_transformation_view,
             )
         )
 

mayan/apps/documents/tests/base.py

@@ -1,19 +1,13 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase, GenericViewTestCase
 
 from .mixins import DocumentTestMixin
 
 
-@override_settings(DOCUMENT_PARSING_AUTO_PARSING=False)
-@override_settings(OCR_AUTO_OCR=False)
 class GenericDocumentTestCase(DocumentTestMixin, BaseTestCase):
     """Base test case when testing models or classes"""
 
 
-@override_settings(DOCUMENT_PARSING_AUTO_PARSING=False)
-@override_settings(OCR_AUTO_OCR=False)
 class GenericDocumentViewTestCase(DocumentTestMixin, GenericViewTestCase):
     """Base test case when testing views"""

mayan/apps/documents/tests/mixins.py

@@ -8,7 +8,8 @@ from ..models import DocumentType
 
 from .literals import (
     TEST_DOCUMENT_TYPE_LABEL, TEST_SMALL_DOCUMENT_FILENAME,
-    TEST_DOCUMENT_TYPE_QUICK_LABEL
+    TEST_DOCUMENT_TYPE_QUICK_LABEL, TEST_SMALL_DOCUMENT_PATH,
+    TEST_VERSION_COMMENT
 )
 
 __all__ = ('DocumentTestMixin',)
@@ -18,26 +19,34 @@ class DocumentTestMixin(object):
     auto_create_document_type = True
     auto_upload_document = True
     test_document_filename = TEST_SMALL_DOCUMENT_FILENAME
+    test_document_path = None
 
     def _create_document_type(self):
         self.document_type = DocumentType.objects.create(
             label=TEST_DOCUMENT_TYPE_LABEL
         )
+        self.test_document_type = self.document_type
 
-    def upload_document(self):
+    def upload_document(self, label=None):
         self._calculate_test_document_path()
 
+        if not label:
+            label = self.test_document_filename
+
         with open(self.test_document_path, mode='rb') as file_object:
             document = self.document_type.new_document(
-                file_object=file_object, label=self.test_document_filename
+                file_object=file_object, label=label
             )
+
+        self.test_document = document
         return document
 
     def _calculate_test_document_path(self):
-        self.test_document_path = os.path.join(
+        if not self.test_document_path:
-            settings.BASE_DIR, 'apps', 'documents', 'tests', 'contrib',
+            self.test_document_path = os.path.join(
-            'sample_documents', self.test_document_filename
+                settings.BASE_DIR, 'apps', 'documents', 'tests', 'contrib',
-        )
+                'sample_documents', self.test_document_filename
+            )
 
     def setUp(self):
         super(DocumentTestMixin, self).setUp()
@@ -54,8 +63,16 @@ class DocumentTestMixin(object):
         super(DocumentTestMixin, self).tearDown()
 
 
+class DocumentVersionTestMixin(object):
+    def _upload_new_version(self):
+        with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
+            self.test_document.new_version(
+                comment=TEST_VERSION_COMMENT, file_object=file_object
+            )
+
+
 class DocumentTypeQuickLabelTestMixin(object):
-    def _create_quick_label(self):
+    def _create_test_quick_label(self):
-        self.document_type_filename = self.document_type.filenames.create(
+        self.test_document_type_filename = self.test_document_type.filenames.create(
             filename=TEST_DOCUMENT_TYPE_QUICK_LABEL
         )

mayan/apps/documents/tests/test_deleted_document_views.py

@@ -10,83 +10,92 @@ from .base import GenericDocumentViewTestCase
 
 
 class DeletedDocumentTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DeletedDocumentTestCase, self).setUp()
-        self.login_user()
-
     def _request_document_restore_view(self):
         return self.post(
-            viewname='documents:document_restore', args=(self.document.pk,)
+            viewname='documents:document_restore', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_restore_view_no_permission(self):
-        self.document.delete()
+        self.test_document.delete()
         self.assertEqual(Document.objects.count(), 0)
 
         response = self._request_document_restore_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(DeletedDocument.objects.count(), 1)
         self.assertEqual(Document.objects.count(), 0)
 
     def test_document_restore_view_with_access(self):
-        self.document.delete()
+        self.test_document.delete()
         self.assertEqual(Document.objects.count(), 0)
 
         self.grant_access(
-            obj=self.document, permission=permission_document_restore
+            obj=self.test_document, permission=permission_document_restore
         )
+
         response = self._request_document_restore_view()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(DeletedDocument.objects.count(), 0)
         self.assertEqual(Document.objects.count(), 1)
 
     def _request_document_trash_view(self):
         return self.post(
-            viewname='documents:document_trash', args=(self.document.pk,)
+            viewname='documents:document_trash', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_trash_no_permissions(self):
         response = self._request_document_trash_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(DeletedDocument.objects.count(), 0)
         self.assertEqual(Document.objects.count(), 1)
 
     def test_document_trash_with_access(self):
         self.grant_access(
-            obj=self.document, permission=permission_document_trash
+            obj=self.test_document, permission=permission_document_trash
         )
 
         response = self._request_document_trash_view()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(DeletedDocument.objects.count(), 1)
         self.assertEqual(Document.objects.count(), 0)
 
     def _request_document_delete_view(self):
         return self.post(
-            viewname='documents:document_delete', args=(self.document.pk,),
+            viewname='documents:document_delete', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_delete_no_permissions(self):
-        self.document.delete()
+        self.test_document.delete()
         self.assertEqual(Document.objects.count(), 0)
         self.assertEqual(DeletedDocument.objects.count(), 1)
 
         response = self._request_document_delete_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(Document.objects.count(), 0)
         self.assertEqual(DeletedDocument.objects.count(), 1)
 
     def test_document_delete_with_access(self):
-        self.document.delete()
+        self.test_document.delete()
         self.assertEqual(Document.objects.count(), 0)
         self.assertEqual(DeletedDocument.objects.count(), 1)
 
         self.grant_access(
-            obj=self.document, permission=permission_document_delete
+            obj=self.test_document, permission=permission_document_delete
         )
 
         response = self._request_document_delete_view()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(DeletedDocument.objects.count(), 0)
         self.assertEqual(Document.objects.count(), 0)
 
@@ -94,21 +103,21 @@ class DeletedDocumentTestCase(GenericDocumentViewTestCase):
         return self.get(viewname='documents:document_list_deleted')
 
     def test_deleted_document_list_view_no_permissions(self):
-        self.document.delete()
+        self.test_document.delete()
 
         response = self._request_document_list_deleted_view()
         self.assertNotContains(
-            response=response, text=self.document.label, status_code=200
+            response=response, text=self.test_document.label, status_code=200
         )
 
     def test_deleted_document_list_view_with_access(self):
-        self.document.delete()
+        self.test_document.delete()
 
         self.grant_access(
-            obj=self.document, permission=permission_document_view
+            obj=self.test_document, permission=permission_document_view
         )
-        response = self._request_document_list_deleted_view()
 
+        response = self._request_document_list_deleted_view()
         self.assertContains(
-            response=response, text=self.document.label, status_code=200
+            response=response, text=self.test_document.label, status_code=200
         )

mayan/apps/documents/tests/test_document_page_views.py

@@ -6,13 +6,11 @@ from .base import GenericDocumentViewTestCase
 
 
 class DocumentPageViewTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DocumentPageViewTestCase, self).setUp()
-        self.login_user()
-
     def _document_page_list_view(self):
         return self.get(
-            viewname='documents:document_pages', args=(self.document.pk,)
+            viewname='documents:document_pages', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_page_list_view_no_permission(self):
@@ -21,9 +19,10 @@ class DocumentPageViewTestCase(GenericDocumentViewTestCase):
 
     def test_document_page_list_view_with_access(self):
         self.grant_access(
-            obj=self.document, permission=permission_document_view
+            obj=self.test_document, permission=permission_document_view
         )
+
         response = self._document_page_list_view()
         self.assertContains(
-            response=response, text=self.document.label, status_code=200
+            response=response, text=self.test_document.label, status_code=200
         )

mayan/apps/documents/tests/test_document_type_views.py

@@ -18,10 +18,6 @@ from .mixins import DocumentTypeQuickLabelTestMixin
 
 
 class DocumentTypeViewsTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DocumentTypeViewsTestCase, self).setUp()
-        self.login_user()
-
     def _request_document_type_create(self):
         return self.post(
             viewname='documents:document_type_create',
@@ -33,14 +29,17 @@ class DocumentTypeViewsTestCase(GenericDocumentViewTestCase):
         )
 
     def test_document_type_create_view_no_permission(self):
-        self.document_type.delete()
+        self.test_document_type.delete()
+
         response = self._request_document_type_create()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(DocumentType.objects.count(), 0)
 
     def test_document_type_create_view_with_permission(self):
-        self.document_type.delete()
+        self.test_document_type.delete()
         self.grant_permission(permission=permission_document_type_create)
+
         response = self._request_document_type_create()
         self.assertEqual(response.status_code, 302)
 
@@ -52,26 +51,29 @@ class DocumentTypeViewsTestCase(GenericDocumentViewTestCase):
     def _request_document_type_delete(self):
         return self.post(
             viewname='documents:document_type_delete',
-            args=(self.document_type.pk,)
+            kwargs={'pk': self.test_document_type.pk}
         )
 
     def test_document_type_delete_view_no_permission(self):
         response = self._request_document_type_delete()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(DocumentType.objects.count(), 1)
 
     def test_document_type_delete_view_with_access(self):
         self.grant_access(
-            obj=self.document_type, permission=permission_document_type_delete
+            obj=self.test_document_type, permission=permission_document_type_delete
         )
+
         response = self._request_document_type_delete()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(DocumentType.objects.count(), 0)
 
     def _request_document_type_edit(self):
         return self.post(
             viewname='documents:document_type_edit',
-            args=(self.document_type.pk,),
+            kwargs={'pk': self.test_document_type.pk},
             data={
                 'label': TEST_DOCUMENT_TYPE_LABEL_EDITED,
                 'delete_time_period': DEFAULT_DELETE_PERIOD,
@@ -81,33 +83,34 @@ class DocumentTypeViewsTestCase(GenericDocumentViewTestCase):
 
     def test_document_type_edit_view_no_permission(self):
         response = self._request_document_type_edit()
+
         self.assertEqual(response.status_code, 403)
-        self.document_type.refresh_from_db()
+        self.test_document_type.refresh_from_db()
+
         self.assertEqual(
-            self.document_type.label, TEST_DOCUMENT_TYPE_LABEL
+            self.test_document_type.label, TEST_DOCUMENT_TYPE_LABEL
         )
 
     def test_document_type_edit_view_with_access(self):
         self.grant_access(
-            obj=self.document_type, permission=permission_document_type_edit
+            obj=self.test_document_type,
+            permission=permission_document_type_edit
         )
+
         response = self._request_document_type_edit()
         self.assertEqual(response.status_code, 302)
-        self.document_type.refresh_from_db()
+
+        self.test_document_type.refresh_from_db()
         self.assertEqual(
-            self.document_type.label, TEST_DOCUMENT_TYPE_LABEL_EDITED
+            self.test_document_type.label, TEST_DOCUMENT_TYPE_LABEL_EDITED
         )
 
 
 class DocumentTypeQuickLabelViewsTestCase(DocumentTypeQuickLabelTestMixin, GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DocumentTypeQuickLabelViewsTestCase, self).setUp()
-        self.login_user()
-
     def _request_quick_label_create(self):
         return self.post(
             viewname='documents:document_type_filename_create',
-            args=(self.document_type.pk,),
+            kwargs={'pk': self.test_document_type.pk},
             data={
                 'filename': TEST_DOCUMENT_TYPE_QUICK_LABEL,
             }
@@ -115,100 +118,111 @@ class DocumentTypeQuickLabelViewsTestCase(DocumentTypeQuickLabelTestMixin, Gener
 
     def test_document_type_quick_label_create_no_access(self):
         self.grant_access(
-            obj=self.document_type, permission=permission_document_type_view
+            obj=self.test_document_type,
+            permission=permission_document_type_view
         )
-        response = self._request_quick_label_create()
 
+        response = self._request_quick_label_create()
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(self.document_type.filenames.count(), 0)
+
+        self.assertEqual(self.test_document_type.filenames.count(), 0)
 
     def test_document_type_quick_label_create_with_access(self):
         self.grant_access(
-            obj=self.document_type, permission=permission_document_type_edit
+            obj=self.test_document_type, permission=permission_document_type_edit
         )
+
         response = self._request_quick_label_create()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(self.document_type.filenames.count(), 1)
+        self.assertEqual(self.test_document_type.filenames.count(), 1)
 
     def _request_quick_label_delete(self):
         return self.post(
             viewname='documents:document_type_filename_delete',
-            args=(self.document_type_filename.pk,),
+            kwargs={'pk': self.test_document_type_filename.pk}
         )
 
     def test_document_type_quick_label_delete_no_access(self):
-        self._create_quick_label()
+        self._create_test_quick_label()
-        self._request_quick_label_delete()
+        response = self._request_quick_label_delete()
+        self.assertEqual(response.status_code, 403)
 
         self.assertEqual(
-            self.document_type.filenames.count(), 1
+            self.test_document_type.filenames.count(), 1
         )
 
     def test_document_type_quick_label_delete_with_access(self):
         self.grant_access(
-            obj=self.document_type, permission=permission_document_type_edit
+            obj=self.test_document_type, permission=permission_document_type_edit
         )
-        self._create_quick_label()
+        self._create_test_quick_label()
-        response = self._request_quick_label_delete()
 
+        response = self._request_quick_label_delete()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(
-            self.document_type.filenames.count(), 0
+            self.test_document_type.filenames.count(), 0
         )
 
     def _request_quick_label_edit(self):
         return self.post(
             viewname='documents:document_type_filename_edit',
-            args=(self.document_type_filename.pk,),
+            kwargs={'pk': self.test_document_type_filename.pk},
             data={
                 'filename': TEST_DOCUMENT_TYPE_QUICK_LABEL_EDITED,
             }
         )
 
     def test_document_type_quick_label_edit_no_access(self):
-        self._create_quick_label()
+        self._create_test_quick_label()
-        response = self._request_quick_label_edit()
 
+        response = self._request_quick_label_edit()
         self.assertEqual(response.status_code, 403)
-        self.document_type_filename.refresh_from_db()
+
+        self.test_document_type_filename.refresh_from_db()
         self.assertEqual(
-            self.document_type_filename.filename,
+            self.test_document_type_filename.filename,
             TEST_DOCUMENT_TYPE_QUICK_LABEL
         )
 
     def test_document_type_quick_label_edit_with_access(self):
         self.grant_access(
-            obj=self.document_type, permission=permission_document_type_edit
+            obj=self.test_document_type,
+            permission=permission_document_type_edit
         )
-        self._create_quick_label()
+        self._create_test_quick_label()
-        response = self._request_quick_label_edit()
 
+        response = self._request_quick_label_edit()
         self.assertEqual(response.status_code, 302)
 
-        self.document_type_filename.refresh_from_db()
+        self.test_document_type_filename.refresh_from_db()
         self.assertEqual(
-            self.document_type_filename.filename,
+            self.test_document_type_filename.filename,
             TEST_DOCUMENT_TYPE_QUICK_LABEL_EDITED
         )
 
     def _request_quick_label_list_view(self):
         return self.get(
             viewname='documents:document_type_filename_list',
-            args=(self.document_type.pk,),
+            kwargs={'pk': self.test_document_type.pk}
         )
 
     def test_document_type_quick_label_list_no_access(self):
-        self._create_quick_label()
+        self._create_test_quick_label()
+
         response = self._request_quick_label_list_view()
         self.assertEqual(response.status_code, 403)
 
     def test_document_type_quick_label_list_with_access(self):
-        self._create_quick_label()
+        self._create_test_quick_label()
+
         self.grant_access(
-            obj=self.document_type, permission=permission_document_type_view
+            obj=self.test_document_type,
+            permission=permission_document_type_view
         )
+
         response = self._request_quick_label_list_view()
         self.assertContains(
-            response, text=self.document_type_filename, status_code=200
+            response, text=self.test_document_type_filename, status_code=200
         )

mayan/apps/documents/tests/test_document_version_views.py

@@ -5,30 +5,20 @@ from ..permissions import (
 )
 
 from .base import GenericDocumentViewTestCase
-from .literals import (
+from .literals import TEST_VERSION_COMMENT
-    TEST_SMALL_DOCUMENT_PATH, TEST_VERSION_COMMENT
+from .mixins import DocumentVersionTestMixin
-)
 
 
-class DocumentVersionTestCase(GenericDocumentViewTestCase):
+class DocumentVersionTestCase(DocumentVersionTestMixin, GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DocumentVersionTestCase, self).setUp()
-        self.login_user()
-
-    def _upload_new_version(self):
-        with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
-            self.document.new_version(
-                comment=TEST_VERSION_COMMENT, file_object=file_object
-            )
-
     def _request_document_version_list_view(self):
         return self.get(
             viewname='documents:document_version_list',
-            args=(self.document.pk,)
+            kwargs={'pk': self.document.pk}
         )
 
     def test_document_version_list_no_permission(self):
         self._upload_new_version()
+
         response = self._request_document_version_list_view()
         self.assertEqual(response.status_code, 403)
 
@@ -37,6 +27,7 @@ class DocumentVersionTestCase(GenericDocumentViewTestCase):
         self.grant_access(
             obj=self.document, permission=permission_document_version_view
         )
+
         response = self._request_document_version_list_view()
         self.assertContains(
             response=response, text=TEST_VERSION_COMMENT, status_code=200
@@ -45,7 +36,7 @@ class DocumentVersionTestCase(GenericDocumentViewTestCase):
     def _request_document_version_revert_view(self, document_version):
         return self.post(
             viewname='documents:document_version_revert',
-            args=(document_version.pk,)
+            kwargs={'pk': document_version.pk}
         )
 
     def test_document_version_revert_no_permission(self):
@@ -56,6 +47,7 @@ class DocumentVersionTestCase(GenericDocumentViewTestCase):
             document_version=first_version
         )
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(self.document.versions.count(), 2)
 
     def test_document_version_revert_with_access(self):
@@ -70,4 +62,5 @@ class DocumentVersionTestCase(GenericDocumentViewTestCase):
             document_version=first_version
         )
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(self.document.versions.count(), 1)

mayan/apps/documents/tests/test_duplicated_document_views.py

@@ -3,21 +3,11 @@ from __future__ import unicode_literals
 from ..permissions import permission_document_view
 
 from .base import GenericDocumentViewTestCase
-from .literals import (
-    TEST_SMALL_DOCUMENT_FILENAME, TEST_SMALL_DOCUMENT_PATH,
-)
 
 
 class DuplicatedDocumentsViewsTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DuplicatedDocumentsViewsTestCase, self).setUp()
-        self.login_user()
-
     def _upload_duplicate_document(self):
-        with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
+        self.test_duplicated_document = self.upload_document()
-            self.document_duplicate = self.document_type.new_document(
-                file_object=file_object, label=TEST_SMALL_DOCUMENT_FILENAME
-            )
 
     def _request_duplicated_document_list_view(self):
         return self.get(viewname='documents:duplicated_document_list')
@@ -25,49 +15,49 @@ class DuplicatedDocumentsViewsTestCase(GenericDocumentViewTestCase):
     def _request_document_duplicates_list_view(self):
         return self.get(
             viewname='documents:document_duplicates_list',
-            args=(self.document.pk,)
+            kwargs={'pk': self.test_document.pk}
         )
 
     def test_duplicated_document_list_no_permissions(self):
         self._upload_duplicate_document()
-        response = self._request_duplicated_document_list_view()
 
+        response = self._request_duplicated_document_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_duplicated_document_list_with_access(self):
         self._upload_duplicate_document()
         self.grant_access(
-            obj=self.document, permission=permission_document_view
+            obj=self.test_document, permission=permission_document_view
         )
         self.grant_access(
-            obj=self.document_duplicate,
+            obj=self.test_duplicated_document,
             permission=permission_document_view
         )
-        response = self._request_duplicated_document_list_view()
 
+        response = self._request_duplicated_document_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_duplicates_list_no_permissions(self):
         self._upload_duplicate_document()
-        response = self._request_document_duplicates_list_view()
 
+        response = self._request_document_duplicates_list_view()
         self.assertEqual(response.status_code, 403)
 
     def test_document_duplicates_list_with_access(self):
         self._upload_duplicate_document()
         self.grant_access(
-            obj=self.document, permission=permission_document_view
+            obj=self.test_document, permission=permission_document_view
         )
         self.grant_access(
-            obj=self.document_duplicate,
+            obj=self.test_duplicated_document,
             permission=permission_document_view
         )
-        response = self._request_document_duplicates_list_view()
 
+        response = self._request_document_duplicates_list_view()
         self.assertContains(
-            response=response, text=self.document.label, status_code=200
+            response=response, text=self.test_document.label, status_code=200
         )

mayan/apps/documents/tests/test_events.py

@@ -3,10 +3,6 @@ from __future__ import unicode_literals
 from actstream.models import Action
 from django_downloadview import assert_download_response
 
-from mayan.apps.user_management.tests.literals import (
-    TEST_USER_PASSWORD, TEST_USER_USERNAME
-)
-
 from ..events import event_document_download, event_document_view
 from ..permissions import (
     permission_document_download, permission_document_view
@@ -22,80 +18,69 @@ TEST_TRANSFORMATION_ARGUMENT = 'degrees: 180'
 
 
 class DocumentEventsTestCase(GenericDocumentViewTestCase):
-    def test_document_download_event_no_permissions(self):
+    def _request_test_document_download_view(self):
-        self.login(
+        return self.get(
-            username=TEST_USER_USERNAME, password=TEST_USER_PASSWORD
+            'documents:document_download', kwargs={'pk': self.test_document.pk}
         )
 
+    def test_document_download_event_no_permissions(self):
         Action.objects.all().delete()
 
-        response = self.get(
+        response = self._request_test_document_download_view()
-            'documents:document_download', args=(self.document.pk,)
-        )
 
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(list(Action.objects.any(obj=self.document)), [])
+        self.assertEqual(list(Action.objects.any(obj=self.test_document)), [])
 
     def test_document_download_event_with_permissions(self):
-        self.login(
-            username=TEST_USER_USERNAME, password=TEST_USER_PASSWORD
-        )
-
-        Action.objects.all().delete()
-
-        self.role.permissions.add(
-            permission_document_download.stored_permission
-        )
-
         self.expected_content_type = 'image/png; charset=utf-8'
 
-        response = self.get(
+        Action.objects.all().delete()
-            viewname='documents:document_download', args=(self.document.pk,),
+
+        self.grant_access(
+            obj=self.test_document, permission=permission_document_download
         )
 
+        response = self._request_test_document_download_view()
+
         # Download the file to close the file descriptor
-        with self.document.open() as file_object:
+        with self.test_document.open() as file_object:
             assert_download_response(
                 self, response, content=file_object.read(),
-                mime_type=self.document.file_mimetype
+                mime_type=self.test_document.file_mimetype
             )
 
-        event = Action.objects.any(obj=self.document).first()
+        event = Action.objects.any(obj=self.test_document).first()
 
+        self.assertEqual(event.actor, self._test_case_user)
+        self.assertEqual(event.target, self.test_document)
         self.assertEqual(event.verb, event_document_download.id)
-        self.assertEqual(event.target, self.document)
+
-        self.assertEqual(event.actor, self.user)
+    def _request_test_document_preview_view(self):
+        return self.get(
+            viewname='documents:document_preview', kwargs={
+                'pk': self.test_document.pk
+            }
+        )
 
     def test_document_view_event_no_permissions(self):
-        self.login(
-            username=TEST_USER_USERNAME, password=TEST_USER_PASSWORD
-        )
-
         Action.objects.all().delete()
 
-        response = self.get(
+        response = self._request_test_document_preview_view()
-            viewname='documents:document_preview', args=(self.document.pk,)
-        )
-
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(list(Action.objects.any(obj=self.document)), [])
+
+        self.assertEqual(list(Action.objects.any(obj=self.test_document)), [])
 
     def test_document_view_event_with_permissions(self):
-        self.login(
-            username=TEST_USER_USERNAME, password=TEST_USER_PASSWORD
-        )
-
         Action.objects.all().delete()
 
-        self.role.permissions.add(
+        self.grant_access(
-            permission_document_view.stored_permission
+            obj=self.test_document, permission=permission_document_view
-        )
-        self.get(
-            viewname='documents:document_preview', args=(self.document.pk,),
         )
 
-        event = Action.objects.any(obj=self.document).first()
+        response = self._request_test_document_preview_view()
+        self.assertEqual(response.status_code, 200)
 
+        event = Action.objects.any(obj=self.test_document).first()
+        self.assertEqual(event.actor, self._test_case_user)
+        self.assertEqual(event.target, self.test_document)
         self.assertEqual(event.verb, event_document_view.id)
-        self.assertEqual(event.target, self.document)
-        self.assertEqual(event.actor, self.user)

mayan/apps/documents/tests/test_links.py

@@ -4,8 +4,6 @@ import time
 
 from django.urls import reverse
 
-from mayan.apps.acls.models import AccessControlList
-
 from ..links import (
     link_document_restore, link_document_version_download,
     link_document_version_revert
@@ -21,10 +19,6 @@ from .literals import TEST_SMALL_DOCUMENT_PATH
 
 
 class DocumentsLinksTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(DocumentsLinksTestCase, self).setUp()
-        self.login_user()
-
     def test_document_version_revert_link_no_permission(self):
         with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
             self.document.new_version(file_object=file_object)
@@ -47,11 +41,9 @@ class DocumentsLinksTestCase(GenericDocumentViewTestCase):
 
         self.assertTrue(self.document.versions.count(), 2)
 
-        acl = AccessControlList.objects.create(
+        self.grant_access(
-            content_object=self.document, role=self.role
+            obj=self.test_document,
-        )
+            permission=permission_document_version_revert
-        acl.permissions.add(
-            permission_document_version_revert.stored_permission
         )
 
         self.add_test_view(test_object=self.document.versions.first())
@@ -62,7 +54,7 @@ class DocumentsLinksTestCase(GenericDocumentViewTestCase):
         self.assertEqual(
             resolved_link.url,
             reverse(
-                'documents:document_version_revert',
+                viewname=link_document_version_revert.view,
                 args=(self.document.versions.first().pk,)
             )
         )
@@ -75,10 +67,10 @@ class DocumentsLinksTestCase(GenericDocumentViewTestCase):
         self.assertEqual(resolved_link, None)
 
     def test_document_version_download_link_with_permission(self):
-        acl = AccessControlList.objects.create(
+        self.grant_access(
-            content_object=self.document, role=self.role
+            obj=self.test_document,
+            permission=permission_document_download
         )
-        acl.permissions.add(permission_document_download.stored_permission)
 
         self.add_test_view(test_object=self.document.latest_version)
         context = self.get_test_view()
@@ -88,7 +80,7 @@ class DocumentsLinksTestCase(GenericDocumentViewTestCase):
         self.assertEqual(
             resolved_link.url,
             reverse(
-                'documents:document_version_download_form',
+                viewname=link_document_version_download.view,
                 args=(self.document.latest_version.pk,)
             )
         )

mayan/apps/documents/tests/test_models.py

@@ -3,8 +3,6 @@ from __future__ import unicode_literals
 from datetime import timedelta
 import time
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 
 from ..literals import STUB_EXPIRATION_INTERVAL
@@ -23,7 +21,6 @@ from .literals import (
 from .mixins import DocumentTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class DocumentTestCase(DocumentTestMixin, BaseTestCase):
     def test_natural_keys(self):
         self.document.pages.first().generate_image()
@@ -132,7 +129,6 @@ class DocumentTestCase(DocumentTestMixin, BaseTestCase):
         self.assertEqual(DeletedDocument.objects.count(), 0)
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class PDFCompatibilityTestCase(BaseTestCase):
     def test_indirect_rotate(self):
         self.document_type = DocumentType.objects.create(
@@ -149,7 +145,6 @@ class PDFCompatibilityTestCase(BaseTestCase):
         )
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class OfficeDocumentTestCase(BaseTestCase):
     def setUp(self):
         super(OfficeDocumentTestCase, self).setUp()
@@ -179,7 +174,6 @@ class OfficeDocumentTestCase(BaseTestCase):
         self.assertEqual(self.document.page_count, 2)
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class MultiPageTiffTestCase(BaseTestCase):
     def setUp(self):
         super(MultiPageTiffTestCase, self).setUp()
@@ -241,7 +235,6 @@ class DocumentVersionTestCase(GenericDocumentTestCase):
         self.assertEqual(self.document.versions.count(), 1)
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class DocumentManagerTestCase(BaseTestCase):
     def setUp(self):
         super(DocumentManagerTestCase, self).setUp()

mayan/apps/documents/tests/test_search.py

@@ -1,23 +1,20 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.documents.permissions import permission_document_view
 from mayan.apps.documents.search import document_search, document_page_search
 from mayan.apps.documents.tests import DocumentTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class DocumentSearchTestCase(DocumentTestMixin, BaseTestCase):
     def _perform_document_page_search(self):
         return document_page_search.search(
-            query_string={'q': self.document.label}, user=self.user
+            query_string={'q': self.document.label}, user=self._test_case_user
         )
 
     def _perform_document_search(self):
         return document_search.search(
-            query_string={'q': self.document.label}, user=self.user
+            query_string={'q': self.document.label}, user=self._test_case_user
         )
 
     def test_document_page_search_no_access(self):
@@ -26,7 +23,7 @@ class DocumentSearchTestCase(DocumentTestMixin, BaseTestCase):
 
     def test_document_page_search_with_access(self):
         self.grant_access(
-            permission=permission_document_view, obj=self.document
+            obj=self.test_document, permission=permission_document_view
         )
         queryset, elapsed_time = self._perform_document_page_search()
         self.assertTrue(self.document.pages.first() in queryset)
@@ -37,7 +34,7 @@ class DocumentSearchTestCase(DocumentTestMixin, BaseTestCase):
 
     def test_document_search_with_access(self):
         self.grant_access(
-            permission=permission_document_view, obj=self.document
+            obj=self.test_document, permission=permission_document_view
         )
         queryset, elapsed_time = self._perform_document_search()
         self.assertTrue(self.document in queryset)

mayan/apps/documents/tests/test_widgets.py

@@ -8,7 +8,7 @@ from .test_models import GenericDocumentTestCase
 class DocumentPageWidgetTestCase(GenericDocumentTestCase):
     def test_document_list_view_document_with_no_pages(self):
         document_thumbnail_widget = DocumentPageThumbnailWidget()
-        self.document.pages.all().delete()
+        self.test_document.pages.all().delete()
         result = document_thumbnail_widget.render(instance=self.document)
 
         self.assertTrue(self.document.get_absolute_url() in result)

mayan/apps/dynamic_search/tests/test_api.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from rest_framework import status
 
 from mayan.apps.documents.search import document_search
@@ -25,15 +23,7 @@ class SearchModelAPITestCase(BaseAPITestCase):
         )
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class SearchAPITestCase(DocumentTestMixin, BaseAPITestCase):
-    auto_upload_document = False
-
-    def setUp(self):
-        super(SearchAPITestCase, self).setUp()
-        self.login_user()
-        self.test_document = self.upload_document()
-
     def _request_search_view(self):
         query = {'q': self.test_document.label}
         return self.get(
@@ -51,9 +41,9 @@ class SearchAPITestCase(DocumentTestMixin, BaseAPITestCase):
         self.grant_access(
             obj=self.test_document, permission=permission_document_view
         )
+
         response = self._request_search_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-
         self.assertEqual(
             response.data['results'][0]['label'], self.test_document.label
         )

mayan/apps/dynamic_search/tests/test_models.py

@@ -1,15 +1,13 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
+from mayan.apps.documents.permissions import permission_document_view
 from mayan.apps.documents.search import document_search
 from mayan.apps.documents.tests import (
     DocumentTestMixin, TEST_DOCUMENT_FILENAME, TEST_SMALL_DOCUMENT_FILENAME
 )
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class DocumentSearchTestCase(DocumentTestMixin, BaseTestCase):
     auto_upload_document = False
     test_document_filename = TEST_DOCUMENT_FILENAME
@@ -19,87 +17,109 @@ class DocumentSearchTestCase(DocumentTestMixin, BaseTestCase):
         Test that simple search works after related_name changes to
         document versions and document version pages
         """
-        self.document = self.upload_document()
+        self.upload_document()
+
+        self.grant_access(
+            obj=self.test_document, permission=permission_document_view
+        )
+
         queryset, elapsed_time = document_search.search(
-            {'q': 'Mayan'}, user=self.admin_user
+            {'q': 'Mayan'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 1)
-        self.assertTrue(self.document in queryset)
+        self.assertTrue(self.test_document in queryset)
 
     def test_advanced_search_after_related_name_change(self):
         # Test versions__filename
-        self.document = self.upload_document()
+        self.upload_document()
+        self.grant_access(
+            obj=self.test_document, permission=permission_document_view
+        )
+
         queryset, elapsed_time = document_search.search(
-            {'label': self.document.label}, user=self.admin_user
+            {'label': self.test_document.label}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 1)
-        self.assertTrue(self.document in queryset)
+        self.assertTrue(self.test_document in queryset)
 
         # Test versions__mimetype
         queryset, elapsed_time = document_search.search(
-            {'versions__mimetype': self.document.file_mimetype},
+            {'versions__mimetype': self.test_document.file_mimetype},
-            user=self.admin_user
+            user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 1)
-        self.assertTrue(self.document in queryset)
+        self.assertTrue(self.test_document in queryset)
 
     def test_simple_or_search(self):
-        self.document = self.upload_document()
+        self.upload_document(label='first_doc.pdf')
+
+        self.grant_access(
+            obj=self.test_document, permission=permission_document_view
+        )
+
         self.test_document_filename = TEST_SMALL_DOCUMENT_FILENAME
-        self.document_2 = self.upload_document()
+        self.test_document_2 = self.upload_document(label='second_doc.pdf')
-        self.document_2.label = 'second_doc.pdf'
+
-        self.document_2.save()
+        self.grant_access(
+            obj=self.test_document_2, permission=permission_document_view
+        )
 
         queryset, elapsed_time = document_search.search(
-            {'q': 'Mayan OR second'}, user=self.admin_user
+            {'q': 'first OR second'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 2)
-        self.assertTrue(self.document in queryset)
+        self.assertTrue(self.test_document in queryset)
-        self.assertTrue(self.document_2 in queryset)
+        self.assertTrue(self.test_document_2 in queryset)
 
     def test_simple_and_search(self):
         self.test_document_filename = TEST_SMALL_DOCUMENT_FILENAME
-        self.document_2 = self.upload_document()
+        self.test_document_2 = self.upload_document(label='second_doc.pdf')
-        self.document_2.label = 'second_doc.pdf'
+
-        self.document_2.save()
+        self.grant_access(
+            obj=self.test_document_2, permission=permission_document_view
+        )
 
         queryset, elapsed_time = document_search.search(
-            {'q': 'non_valid second'}, user=self.admin_user
+            {'q': 'non_valid second'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 0)
 
         queryset, elapsed_time = document_search.search(
-            {'q': 'second non_valid'}, user=self.admin_user
+            {'q': 'second non_valid'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 0)
 
     def test_simple_negated_search(self):
         self.test_document_filename = TEST_SMALL_DOCUMENT_FILENAME
-        self.document_2 = self.upload_document()
+        self.test_document_2 = self.upload_document()
-        self.document_2.label = 'second_doc.pdf'
+        self.test_document_2.label = 'second_doc.pdf'
-        self.document_2.save()
+        self.test_document_2.save()
+
+        self.grant_access(
+            obj=self.test_document_2, permission=permission_document_view
+        )
 
         queryset, elapsed_time = document_search.search(
-            {'q': '-non_valid second'}, user=self.admin_user
+            {'q': '-non_valid second'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 1)
 
         queryset, elapsed_time = document_search.search(
-            {'label': '-second'}, user=self.admin_user
+            {'label': '-second'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 0)
 
         queryset, elapsed_time = document_search.search(
-            {'label': '-second -Mayan'}, user=self.admin_user
+            {'label': '-second -Mayan'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 0)
 
         queryset, elapsed_time = document_search.search(
-            {'label': '-second OR -Mayan'}, user=self.admin_user
+            {'label': '-second OR -Mayan'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 1)
 
         queryset, elapsed_time = document_search.search(
-            {'label': '-non_valid -second'}, user=self.admin_user
+            {'label': '-non_valid -second'}, user=self._test_case_user
         )
         self.assertEqual(queryset.count(), 0)

mayan/apps/dynamic_search/tests/test_views.py

@@ -1,54 +1,46 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import GenericViewTestCase
-from mayan.apps.documents.models import DocumentType
+from mayan.apps.documents.permissions import permission_document_view
 from mayan.apps.documents.search import document_search
-from mayan.apps.documents.tests import TEST_DOCUMENT_TYPE_LABEL, TEST_SMALL_DOCUMENT_PATH
+from mayan.apps.documents.tests import DocumentTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class Issue46TestCase(DocumentTestMixin, GenericViewTestCase):
-class Issue46TestCase(GenericViewTestCase):
     """
     Functional tests to make sure issue 46 is fixed
     """
     def setUp(self):
         super(Issue46TestCase, self).setUp()
-        self.login_admin_user()
+        self.test_document_count = 4
-
+        self.uploaded_documents = []
-        self.document_count = 4
-
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
 
         # Upload many instances of the same test document
-        for i in range(self.document_count):
+        for i in range(self.test_document_count):
-            with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
+            self.uploaded_documents.append(
-                self.document_type.new_document(
+                self.upload_document()
-                    file_object=file_object,
+            )
-                    label='test document',
-                )
-
-    def tearDown(self):
-        for document_type in DocumentType.objects.all():
-            document_type.delete()
-        super(Issue46TestCase, self).tearDown()
 
     def test_advanced_search_past_first_page(self):
+        test_document_label = self.uploaded_documents[0].label
+
+        for document in self.uploaded_documents:
+            self.grant_access(
+                obj=document, permission=permission_document_view
+            )
+
         # Make sure all documents are returned by the search
         queryset, elapsed_time = document_search.search(
-            {'label': 'test document'}, user=self.admin_user
+            {'label': test_document_label}, user=self._test_case_user
         )
-        self.assertEqual(queryset.count(), self.document_count)
+        self.assertEqual(queryset.count(), self.test_document_count)
 
         with self.settings(COMMON_PAGINATE_BY=2):
             # Functional test for the first page of advanced results
             response = self.get(
                 viewname='search:results',
                 args=(document_search.get_full_name(),),
-                data={'label': 'test'}
+                data={'label': test_document_label}
             )
 
             # Total (1 - 2 out of 4) (Page 1 of 2)
@@ -68,7 +60,7 @@ class Issue46TestCase(GenericViewTestCase):
             response = self.get(
                 viewname='search:results',
                 args=(document_search.get_full_name(),),
-                data={'label': 'test', 'page': 2}
+                data={'label': test_document_label, 'page': 2}
             )
 
             # Total (3 - 4 out of 4) (Page 2 of 2)

mayan/apps/events/tests/test_views.py

@@ -11,7 +11,7 @@ class EventsViewTestCase(GenericDocumentViewTestCase):
     def setUp(self):
         super(EventsViewTestCase, 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,
@@ -19,50 +19,27 @@ class EventsViewTestCase(GenericDocumentViewTestCase):
             'object_id': self.document.pk
         }
 
-    def test_events_for_object_view_no_permission(self):
+    def _request_events_for_object_view(self):
-        self.login_user()
+        return self.get(
-
+            viewname='events:events_for_object', kwargs=self.view_arguments
-        document = self.document.add_as_recent_document_for_user(
-            self.user
-        ).document
-
-        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='events:events_for_object', kwargs=view_arguments
         )
 
-        self.assertNotContains(response, text=document.label, status_code=403)
+    def test_events_for_object_view_no_permission(self):
-        self.assertNotContains(response, text='otal:', status_code=403)
+        response = self._request_events_for_object_view()
+        self.assertNotContains(
+            response=response, text=self.test_document.label, status_code=403
+        )
+        self.assertNotContains(
+            response=response, text='otal:', status_code=403
+        )
 
     def test_events_for_object_view_with_permission(self):
-        self.login_user()
+        self.grant_permission(permission=permission_events_view)
 
-        self.role.permissions.add(
+        response = self._request_events_for_object_view()
-            permission_events_view.stored_permission
+        self.assertContains(
+            response=response, text=self.test_document.label, status_code=200
         )
-
+        self.assertNotContains(
-        document = self.document.add_as_recent_document_for_user(
+            response=response, text='otal: 0', status_code=200
-            self.user
-        ).document
-
-        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='events:events_for_object', kwargs=view_arguments
         )
-
-        self.assertContains(response, text=document.label, status_code=200)
-        self.assertNotContains(response, text='otal: 0', status_code=200)

mayan/apps/linking/api_views.py

@@ -48,8 +48,8 @@ class APIResolvedSmartLinkDocumentListView(generics.ListAPIView):
         )
 
         AccessControlList.objects.check_access(
-            permissions=permission_smart_link_view, user=self.request.user,
+            obj=smart_link, permissions=permission_smart_link_view,
-            obj=smart_link
+            user=self.request.user
         )
 
         return smart_link

mayan/apps/linking/tests/test_models.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.documents.tests import GenericDocumentTestCase
 
 from ..models import SmartLink
@@ -9,16 +7,15 @@ from ..models import SmartLink
 from .literals import TEST_SMART_LINK_LABEL, TEST_SMART_LINK_DYNAMIC_LABEL
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class SmartLinkTestCase(GenericDocumentTestCase):
     def test_dynamic_label(self):
         smart_link = SmartLink.objects.create(
             label=TEST_SMART_LINK_LABEL,
             dynamic_label=TEST_SMART_LINK_DYNAMIC_LABEL
         )
-        smart_link.document_types.add(self.document_type)
+        smart_link.document_types.add(self.test_document_type)
 
         self.assertEqual(
-            smart_link.get_dynamic_label(document=self.document),
+            smart_link.get_dynamic_label(document=self.test_document),
-            self.document.label
+            self.test_document.label
         )

mayan/apps/linking/tests/test_views.py

@@ -16,138 +16,137 @@ from .literals import (
 
 
 class SmartLinkViewTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
+    def _request_test_smart_link_create_view(self):
-        super(SmartLinkViewTestCase, self).setUp()
+        return self.post(
-        self.login_user()
+            viewname='linking:smart_link_create', data={
-
-    def test_smart_link_create_view_no_permission(self):
-        response = self.post(
-            'linking:smart_link_create', data={
                 'label': TEST_SMART_LINK_LABEL
             }
         )
 
+    def test_smart_link_create_view_no_permission(self):
+        response = self._request_test_smart_link_create_view()
         self.assertEquals(response.status_code, 403)
+
         self.assertEqual(SmartLink.objects.count(), 0)
 
     def test_smart_link_create_view_with_permission(self):
-        self.role.permissions.add(
+        self.grant_permission(permission=permission_smart_link_create)
-            permission_smart_link_create.stored_permission
+
-        )
+        response = self._request_test_smart_link_create_view()
+        self.assertEqual(response.status_code, 302)
 
-        response = self.post(
-            'linking:smart_link_create', data={
-                'label': TEST_SMART_LINK_LABEL
-            }, follow=True
-        )
-        self.assertContains(response, text='created', status_code=200)
         self.assertEqual(SmartLink.objects.count(), 1)
         self.assertEqual(
             SmartLink.objects.first().label, TEST_SMART_LINK_LABEL
         )
 
-    def test_smart_link_delete_view_no_permission(self):
+    def _request_test_smart_link_delete_view(self):
-        smart_link = SmartLink.objects.create(label=TEST_SMART_LINK_LABEL)
+        return self.post(
-
+            viewname='linking:smart_link_delete', kwargs={
-        response = self.post(
+                'pk': self.test_smart_link.pk
-            'linking:smart_link_delete', args=(smart_link.pk,)
+            }
         )
+
+    def _create_test_smart_link(self):
+        self.test_smart_link = SmartLink.objects.create(
+            label=TEST_SMART_LINK_LABEL
+        )
+
+    def test_smart_link_delete_view_no_permission(self):
+        self._create_test_smart_link()
+
+        response = self._request_test_smart_link_delete_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(SmartLink.objects.count(), 1)
 
     def test_smart_link_delete_view_with_permission(self):
-        self.role.permissions.add(
+        self._create_test_smart_link()
-            permission_smart_link_delete.stored_permission
+        self.grant_permission(permission=permission_smart_link_delete)
-        )
 
-        smart_link = SmartLink.objects.create(label=TEST_SMART_LINK_LABEL)
+        response = self._request_test_smart_link_delete_view()
+        self.assertEqual(response.status_code, 302)
 
-        response = self.post(
-            'linking:smart_link_delete', args=(smart_link.pk,), follow=True
-        )
-
-        self.assertContains(response, text='deleted', status_code=200)
         self.assertEqual(SmartLink.objects.count(), 0)
 
-    def test_smart_link_edit_view_no_permission(self):
+    def _request_test_smart_link_edit_view(self):
-        smart_link = SmartLink.objects.create(label=TEST_SMART_LINK_LABEL)
+        return self.post(
-
+            viewname='linking:smart_link_edit', kwargs={
-        response = self.post(
+                'pk': self.test_smart_link.pk
-            'linking:smart_link_edit', args=(smart_link.pk,), data={
+            }, data={
                 'label': TEST_SMART_LINK_LABEL_EDITED
             }
         )
+
+    def test_smart_link_edit_view_no_permission(self):
+        self._create_test_smart_link()
+
+        response = self._request_test_smart_link_edit_view()
         self.assertEqual(response.status_code, 403)
-        smart_link = SmartLink.objects.get(pk=smart_link.pk)
+
-        self.assertEqual(smart_link.label, TEST_SMART_LINK_LABEL)
+        self.test_smart_link.refresh_from_db()
+        self.assertEqual(self.test_smart_link.label, TEST_SMART_LINK_LABEL)
 
     def test_smart_link_edit_view_with_permission(self):
-        self.role.permissions.add(
+        self._create_test_smart_link()
-            permission_smart_link_edit.stored_permission
-        )
 
-        smart_link = SmartLink.objects.create(label=TEST_SMART_LINK_LABEL)
+        self.grant_permission(permission=permission_smart_link_edit)
 
-        response = self.post(
+        response = self._request_test_smart_link_edit_view()
-            'linking:smart_link_edit', args=(smart_link.pk,), data={
+        self.assertEqual(response.status_code, 302)
-                'label': TEST_SMART_LINK_LABEL_EDITED
-            }, follow=True
-        )
 
-        smart_link = SmartLink.objects.get(pk=smart_link.pk)
+        self.test_smart_link.refresh_from_db()
-        self.assertContains(response, text='update', status_code=200)
+        self.assertEqual(self.test_smart_link.label, TEST_SMART_LINK_LABEL_EDITED)
-        self.assertEqual(smart_link.label, TEST_SMART_LINK_LABEL_EDITED)
 
     def setup_smart_links(self):
-        smart_link = SmartLink.objects.create(
+        self.test_smart_link = SmartLink.objects.create(
             label=TEST_SMART_LINK_LABEL,
             dynamic_label=TEST_SMART_LINK_DYNAMIC_LABEL
         )
-        smart_link.document_types.add(self.document_type)
+        self.test_smart_link.document_types.add(self.test_document_type)
 
-        smart_link_2 = SmartLink.objects.create(
+        self.test_smart_link_2 = SmartLink.objects.create(
             label=TEST_SMART_LINK_LABEL,
             dynamic_label=TEST_SMART_LINK_DYNAMIC_LABEL
         )
-        smart_link_2.document_types.add(self.document_type)
+        self.test_smart_link_2.document_types.add(self.test_document_type)
+
+    def _request_test_smart_link_document_instances_view(self):
+        return self.get(
+            viewname='linking:smart_link_instances_for_document',
+            kwargs={'pk': self.test_document.pk}
+        )
 
     def test_document_smart_link_list_view_no_permission(self):
         self.setup_smart_links()
 
-        self.role.permissions.add(
+        self.grant_access(
-            permission_document_view.stored_permission
+            obj=self.test_document, permission=permission_document_view
         )
 
-        response = self.get(
+        response = self._request_test_smart_link_document_instances_view()
-            'linking:smart_link_instances_for_document',
-            args=(self.document.pk,)
-        )
         # Text must appear 2 times, only for the windows title and template
         # heading. The two smart links are not shown.
-
         self.assertContains(
-            response, text=self.document.label, count=2, status_code=200
+            response, text=self.test_document.label, count=2, status_code=200
         )
 
     def test_document_smart_link_list_view_with_permission(self):
         self.setup_smart_links()
 
-        self.role.permissions.add(
+        self.grant_access(
-            permission_smart_link_view.stored_permission
+            obj=self.test_smart_link, permission=permission_smart_link_view
-        )
+        )
-
+        self.grant_access(
-        self.role.permissions.add(
+            obj=self.test_smart_link_2, permission=permission_smart_link_view
-            permission_document_view.stored_permission
+        )
-        )
+        self.grant_access(
-
+            obj=self.test_document, permission=permission_document_view
-        response = self.get(
-            'linking:smart_link_instances_for_document',
-            args=(self.document.pk,)
         )
 
+        response = self._request_test_smart_link_document_instances_view()
         # Text must appear 4 times: 2 for the windows title and template
         # heading, plus 2 for the test.
-
         self.assertContains(
-            response, text=self.document.label, count=4, status_code=200
+            response, text=self.test_document.label, count=4, status_code=200
         )

mayan/apps/metadata/tests/test_api.py

@@ -1,14 +1,11 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from rest_framework import status
 
-from mayan.apps.documents.models import DocumentType
 from mayan.apps.documents.permissions import (
     permission_document_type_edit, permission_document_type_view
 )
-from mayan.apps.documents.tests import TEST_DOCUMENT_TYPE_LABEL, TEST_SMALL_DOCUMENT_PATH
+from mayan.apps.documents.tests import DocumentTestMixin
 from mayan.apps.rest_api.tests import BaseAPITestCase
 
 from ..models import DocumentTypeMetadataType, MetadataType
@@ -27,10 +24,6 @@ from .literals import (
 
 
 class MetadataTypeAPITestCase(BaseAPITestCase):
-    def setUp(self):
-        super(MetadataTypeAPITestCase, self).setUp()
-        self.login_user()
-
     def _create_metadata_type(self):
         self.metadata_type = MetadataType.objects.create(
             label=TEST_METADATA_TYPE_LABEL, name=TEST_METADATA_TYPE_NAME
@@ -188,32 +181,24 @@ class MetadataTypeAPITestCase(BaseAPITestCase):
         )
 
 
-class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
+class DocumentTypeMetadataTypeAPITestCase(DocumentTestMixin, BaseAPITestCase):
+    auto_upload_document = False
+
     def setUp(self):
         super(DocumentTypeMetadataTypeAPITestCase, self).setUp()
-        self.login_user()
-
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
         self.metadata_type = MetadataType.objects.create(
             label=TEST_METADATA_TYPE_LABEL, name=TEST_METADATA_TYPE_NAME
         )
 
-    def tearDown(self):
-        self.document_type.delete()
-        super(DocumentTypeMetadataTypeAPITestCase, self).tearDown()
-
     def _create_document_type_metadata_type(self):
-        self.document_type_metadata_type = self.document_type.metadata.create(
+        self.test_document_type_metadata_type = self.test_document_type.metadata.create(
             metadata_type=self.metadata_type, required=False
         )
 
     def _request_document_type_metadata_type_create_view(self):
         return self.post(
             viewname='rest_api:documenttypemetadatatype-list',
-            args=(self.document_type.pk,), data={
+            args=(self.test_document_type.pk,), data={
                 'metadata_type_pk': self.metadata_type.pk, 'required': False
             }
         )
@@ -221,11 +206,11 @@ class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
     def test_document_type_metadata_type_create_view_no_access(self):
         response = self._request_document_type_metadata_type_create_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(self.document_type.metadata.count(), 0)
+        self.assertEqual(self.test_document_type.metadata.count(), 0)
 
     def test_document_type_metadata_type_create_view_with_access(self):
         self.grant_access(
-            permission=permission_document_type_edit, obj=self.document_type
+            permission=permission_document_type_edit, obj=self.test_document_type
         )
         response = self._request_document_type_metadata_type_create_view()
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
@@ -244,7 +229,7 @@ class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
         return self.delete(
             viewname='rest_api:documenttypemetadatatype-detail',
             args=(
-                self.document_type.pk, self.document_type_metadata_type.pk,
+                self.test_document_type.pk, self.test_document_type_metadata_type.pk,
             ),
         )
 
@@ -252,20 +237,20 @@ class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
         self._create_document_type_metadata_type()
         response = self._request_document_type_metadata_type_delete_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(self.document_type.metadata.count(), 1)
+        self.assertEqual(self.test_document_type.metadata.count(), 1)
 
     def test_document_type_metadata_type_delete_view_with_access(self):
         self._create_document_type_metadata_type()
-        self.grant_access(permission=permission_document_type_edit, obj=self.document_type)
+        self.grant_access(permission=permission_document_type_edit, obj=self.test_document_type)
         response = self._request_document_type_metadata_type_delete_view()
         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(self.document_type.metadata.all().count(), 0)
+        self.assertEqual(self.test_document_type.metadata.all().count(), 0)
 
     def _request_document_type_metadata_type_list_view(self):
         return self.get(
             viewname='rest_api:documenttypemetadatatype-list',
             args=(
-                self.document_type.pk,
+                self.test_document_type.pk,
             ),
         )
 
@@ -276,20 +261,20 @@ class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
 
     def test_document_type_metadata_type_list_view_with_access(self):
         self._create_document_type_metadata_type()
-        self.grant_access(permission=permission_document_type_view, obj=self.document_type)
+        self.grant_access(permission=permission_document_type_view, obj=self.test_document_type)
         response = self._request_document_type_metadata_type_list_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
         self.assertEqual(
             response.data['results'][0]['id'],
-            self.document_type_metadata_type.pk
+            self.test_document_type_metadata_type.pk
         )
 
     def _request_document_type_metadata_type_edit_view_via_patch(self):
         return self.patch(
             viewname='rest_api:documenttypemetadatatype-detail',
             args=(
-                self.document_type.pk, self.document_type_metadata_type.pk,
+                self.test_document_type.pk, self.test_document_type_metadata_type.pk,
             ), data={
                 'required': True
             }
@@ -304,7 +289,7 @@ class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
 
     def test_document_type_metadata_type_patch_view_with_access(self):
         self._create_document_type_metadata_type()
-        self.grant_access(permission=permission_document_type_edit, obj=self.document_type)
+        self.grant_access(permission=permission_document_type_edit, obj=self.test_document_type)
         response = self._request_document_type_metadata_type_edit_view_via_patch()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         document_type_metadata_type = DocumentTypeMetadataType.objects.first()
@@ -314,7 +299,7 @@ class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
         return self.put(
             viewname='rest_api:documenttypemetadatatype-detail',
             args=(
-                self.document_type.pk, self.document_type_metadata_type.pk,
+                self.test_document_type.pk, self.test_document_type_metadata_type.pk,
             ), data={
                 'required': True
             }
@@ -329,49 +314,32 @@ class DocumentTypeMetadataTypeAPITestCase(BaseAPITestCase):
 
     def test_document_type_metadata_type_put_view_with_access(self):
         self._create_document_type_metadata_type()
-        self.grant_access(permission=permission_document_type_edit, obj=self.document_type)
+        self.grant_access(permission=permission_document_type_edit, obj=self.test_document_type)
         response = self._request_document_type_metadata_type_edit_view_via_put()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         document_type_metadata_type = DocumentTypeMetadataType.objects.first()
         self.assertEqual(document_type_metadata_type.required, True)
 
 
-class DocumentMetadataAPITestCase(BaseAPITestCase):
+class DocumentMetadataAPITestCase(DocumentTestMixin, BaseAPITestCase):
-    @override_settings(OCR_AUTO_OCR=False)
     def setUp(self):
         super(DocumentMetadataAPITestCase, self).setUp()
-        self.login_user()
-
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
         self.metadata_type = MetadataType.objects.create(
             label=TEST_METADATA_TYPE_LABEL, name=TEST_METADATA_TYPE_NAME
         )
-
+        self.test_document_type.metadata.create(
-        self.document_type.metadata.create(
             metadata_type=self.metadata_type, required=False
         )
 
-        with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
-            self.document = self.document_type.new_document(
-                file_object=file_object,
-            )
-
-    def tearDown(self):
-        self.document_type.delete()
-        super(DocumentMetadataAPITestCase, self).tearDown()
-
     def _create_document_metadata(self):
-        self.document_metadata = self.document.metadata.create(
+        self.test_document_metadata = self.test_document.metadata.create(
             metadata_type=self.metadata_type, value=TEST_METADATA_VALUE
         )
 
     def _request_document_metadata_create_view(self):
         return self.post(
             viewname='rest_api:documentmetadata-list',
-            args=(self.document.pk,), data={
+            args=(self.test_document.pk,), data={
                 'metadata_type_pk': self.metadata_type.pk,
                 'value': TEST_METADATA_VALUE
             }
@@ -380,13 +348,13 @@ class DocumentMetadataAPITestCase(BaseAPITestCase):
     def test_document_metadata_create_view_no_access(self):
         response = self._request_document_metadata_create_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(self.document.metadata.count(), 0)
+        self.assertEqual(self.test_document.metadata.count(), 0)
 
     def test_document_metadata_create_view_with_access(self):
-        self.grant_access(permission=permission_metadata_document_add, obj=self.document)
+        self.grant_access(permission=permission_metadata_document_add, obj=self.test_document)
         response = self._request_document_metadata_create_view()
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-        document_metadata = self.document.metadata.first()
+        document_metadata = self.test_document.metadata.first()
         self.assertEqual(response.data['id'], document_metadata.pk)
         self.assertEqual(document_metadata.metadata_type, self.metadata_type)
         self.assertEqual(document_metadata.value, TEST_METADATA_VALUE)
@@ -409,28 +377,28 @@ class DocumentMetadataAPITestCase(BaseAPITestCase):
     def _request_document_metadata_delete_view(self):
         return self.delete(
             viewname='rest_api:documentmetadata-detail',
-            args=(self.document.pk, self.document_metadata.pk,)
+            args=(self.test_document.pk, self.test_document_metadata.pk,)
         )
 
     def test_document_metadata_delete_view_no_access(self):
         self._create_document_metadata()
         response = self._request_document_metadata_delete_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(self.document.metadata.all().count(), 1)
+        self.assertEqual(self.test_document.metadata.all().count(), 1)
 
     def test_document_metadata_delete_view_with_access(self):
         self._create_document_metadata()
         self.grant_access(
-            permission=permission_metadata_document_remove, obj=self.document
+            permission=permission_metadata_document_remove, obj=self.test_document
         )
         response = self._request_document_metadata_delete_view()
         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(self.document.metadata.all().count(), 0)
+        self.assertEqual(self.test_document.metadata.all().count(), 0)
 
     def _request_document_metadata_list_view(self):
         return self.get(
             viewname='rest_api:documentmetadata-list', args=(
-                self.document.pk,
+                self.test_document.pk,
             )
         )
 
@@ -442,12 +410,12 @@ class DocumentMetadataAPITestCase(BaseAPITestCase):
     def test_document_metadata_list_view_with_access(self):
         self._create_document_metadata()
         self.grant_access(
-            permission=permission_metadata_document_view, obj=self.document
+            permission=permission_metadata_document_view, obj=self.test_document
         )
         response = self._request_document_metadata_list_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(
-            response.data['results'][0]['document']['id'], self.document.pk
+            response.data['results'][0]['document']['id'], self.test_document.pk
         )
         self.assertEqual(
             response.data['results'][0]['metadata_type']['id'],
@@ -457,13 +425,13 @@ class DocumentMetadataAPITestCase(BaseAPITestCase):
             response.data['results'][0]['value'], TEST_METADATA_VALUE
         )
         self.assertEqual(
-            response.data['results'][0]['id'], self.document_metadata.pk
+            response.data['results'][0]['id'], self.test_document_metadata.pk
         )
 
     def _request_document_metadata_edit_view_via_patch(self):
         return self.patch(
             viewname='rest_api:documentmetadata-detail',
-            args=(self.document.pk, self.document_metadata.pk,), data={
+            args=(self.test_document.pk, self.test_document_metadata.pk,), data={
                 'value': TEST_METADATA_VALUE_EDITED
             }
         )
@@ -472,28 +440,28 @@ class DocumentMetadataAPITestCase(BaseAPITestCase):
         self._create_document_metadata()
         response = self._request_document_metadata_edit_view_via_patch()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.document_metadata.refresh_from_db()
+        self.test_document_metadata.refresh_from_db()
-        self.assertEqual(self.document_metadata.value, TEST_METADATA_VALUE)
+        self.assertEqual(self.test_document_metadata.value, TEST_METADATA_VALUE)
 
     def test_document_metadata_patch_view_with_access(self):
         self._create_document_metadata()
         self.grant_access(
-            permission=permission_metadata_document_edit, obj=self.document
+            permission=permission_metadata_document_edit, obj=self.test_document
         )
         response = self._request_document_metadata_edit_view_via_patch()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.document_metadata.refresh_from_db()
+        self.test_document_metadata.refresh_from_db()
         self.assertEqual(
             response.data['value'], TEST_METADATA_VALUE_EDITED
         )
         self.assertEqual(
-            self.document_metadata.value, TEST_METADATA_VALUE_EDITED
+            self.test_document_metadata.value, TEST_METADATA_VALUE_EDITED
         )
 
     def _request_document_metadata_edit_view_via_put(self):
         return self.put(
             viewname='rest_api:documentmetadata-detail',
-            args=(self.document.pk, self.document_metadata.pk,), data={
+            args=(self.test_document.pk, self.test_document_metadata.pk,), data={
                 'value': TEST_METADATA_VALUE_EDITED
             }
         )
@@ -502,20 +470,20 @@ class DocumentMetadataAPITestCase(BaseAPITestCase):
         self._create_document_metadata()
         response = self._request_document_metadata_edit_view_via_put()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.document_metadata.refresh_from_db()
+        self.test_document_metadata.refresh_from_db()
-        self.assertEqual(self.document_metadata.value, TEST_METADATA_VALUE)
+        self.assertEqual(self.test_document_metadata.value, TEST_METADATA_VALUE)
 
     def test_document_metadata_put_view_with_access(self):
         self._create_document_metadata()
         self.grant_access(
-            permission=permission_metadata_document_edit, obj=self.document
+            permission=permission_metadata_document_edit, obj=self.test_document
         )
         response = self._request_document_metadata_edit_view_via_put()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.document_metadata.refresh_from_db()
+        self.test_document_metadata.refresh_from_db()
         self.assertEqual(
             response.data['value'], TEST_METADATA_VALUE_EDITED
         )
         self.assertEqual(
-            self.document_metadata.value, TEST_METADATA_VALUE_EDITED
+            self.test_document_metadata.value, TEST_METADATA_VALUE_EDITED
         )

mayan/apps/metadata/tests/test_events.py

@@ -16,15 +16,12 @@ from .mixins import MetadataTestsMixin
 
 
 class MetadataTypeEventsTestCase(MetadataTestsMixin, GenericDocumentViewTestCase):
-    def setUp(self):
-        super(MetadataTypeEventsTestCase, self).setUp()
-        self.login_user()
-
     def test_metadata_type_create_event_no_permissions(self):
         Action.objects.all().delete()
 
         response = self._request_metadata_type_create_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(Action.objects.count(), 0)
 
     def test_metadata_type_create_event_with_permissions(self):
@@ -33,16 +30,15 @@ class MetadataTypeEventsTestCase(MetadataTestsMixin, GenericDocumentViewTestCase
         self.grant_permission(permission=permission_metadata_type_create)
 
         response = self._request_metadata_type_create_view()
-
         self.assertEqual(response.status_code, 302)
 
         event = Action.objects.first()
 
         metadata_type = MetadataType.objects.first()
 
-        self.assertEqual(event.verb, event_metadata_type_created.id)
+        self.assertEqual(event.actor, self._test_case_user)
         self.assertEqual(event.target, metadata_type)
-        self.assertEqual(event.actor, self.user)
+        self.assertEqual(event.verb, event_metadata_type_created.id)
 
     def test_metadata_type_edit_event_no_permissions(self):
         self._create_metadata_type()
@@ -51,6 +47,7 @@ class MetadataTypeEventsTestCase(MetadataTestsMixin, GenericDocumentViewTestCase
 
         response = self._request_metadata_type_edit_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(Action.objects.count(), 0)
 
     def test_metadata_type_edit_event_with_access(self):
@@ -59,7 +56,7 @@ class MetadataTypeEventsTestCase(MetadataTestsMixin, GenericDocumentViewTestCase
         Action.objects.all().delete()
 
         self.grant_access(
-            permission=permission_metadata_type_edit, obj=self.metadata_type
+            obj=self.metadata_type, permission=permission_metadata_type_edit
         )
 
         response = self._request_metadata_type_edit_view()
@@ -68,6 +65,6 @@ class MetadataTypeEventsTestCase(MetadataTestsMixin, GenericDocumentViewTestCase
 
         event = Action.objects.first()
 
-        self.assertEqual(event.verb, event_metadata_type_edited.id)
+        self.assertEqual(event.actor, self._test_case_user)
         self.assertEqual(event.target, self.metadata_type)
-        self.assertEqual(event.actor, self.user)
+        self.assertEqual(event.verb, event_metadata_type_edited.id)

mayan/apps/metadata/tests/test_models.py

@@ -2,7 +2,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.models import DocumentType
@@ -18,35 +17,34 @@ from .literals import (
 from .mixins import MetadataTypeTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
     def setUp(self):
         super(MetadataTestCase, self).setUp()
-        self.document_type.metadata.create(metadata_type=self.metadata_type)
+        self.test_document_type.metadata.create(metadata_type=self.metadata_type)
 
     def test_no_default(self):
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type
+            document=self.test_document, metadata_type=self.metadata_type
         )
 
         document_metadata.full_clean()
         document_metadata.save()
 
-        self.assertEqual(self.document.metadata_value_of.test, None)
+        self.assertEqual(self.test_document.metadata_value_of.test, None)
 
     def test_default(self):
         self.metadata_type.default = TEST_DEFAULT_VALUE
         self.metadata_type.save()
 
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type
+            document=self.test_document, metadata_type=self.metadata_type
         )
 
         document_metadata.full_clean()
         document_metadata.save()
 
         self.assertEqual(
-            self.document.metadata_value_of.test, TEST_DEFAULT_VALUE
+            self.test_document.metadata_value_of.test, TEST_DEFAULT_VALUE
         )
 
     def test_lookup_with_incorrect_value(self):
@@ -54,7 +52,7 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         self.metadata_type.save()
 
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type,
+            document=self.test_document, metadata_type=self.metadata_type,
             value=TEST_INCORRECT_LOOKUP_VALUE
         )
 
@@ -68,7 +66,7 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         self.metadata_type.save()
 
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type,
+            document=self.test_document, metadata_type=self.metadata_type,
             value=TEST_CORRECT_LOOKUP_VALUE
         )
 
@@ -76,7 +74,7 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         document_metadata.save()
 
         self.assertEqual(
-            self.document.metadata_value_of.test, TEST_CORRECT_LOOKUP_VALUE
+            self.test_document.metadata_value_of.test, TEST_CORRECT_LOOKUP_VALUE
         )
 
     def test_empty_optional_lookup(self):
@@ -88,7 +86,7 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         self.metadata_type.save()
 
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type
+            document=self.test_document, metadata_type=self.metadata_type
         )
 
         document_metadata.full_clean()
@@ -98,7 +96,7 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         self.metadata_type.validation = TEST_DATE_VALIDATOR
 
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type,
+            document=self.test_document, metadata_type=self.metadata_type,
             value=TEST_INVALID_DATE
         )
 
@@ -112,13 +110,13 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         document_metadata.full_clean()
         document_metadata.save()
 
-        self.assertEqual(self.document.metadata_value_of.test, TEST_VALID_DATE)
+        self.assertEqual(self.test_document.metadata_value_of.test, TEST_VALID_DATE)
 
     def test_parsing(self):
         self.metadata_type.parser = TEST_DATE_PARSER
 
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type,
+            document=self.test_document, metadata_type=self.metadata_type,
             value=TEST_INVALID_DATE
         )
 
@@ -133,32 +131,32 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         document_metadata.save()
 
         self.assertEqual(
-            self.document.metadata_value_of.test, TEST_PARSED_VALID_DATE
+            self.test_document.metadata_value_of.test, TEST_PARSED_VALID_DATE
         )
 
     def test_required_metadata(self):
-        self.document_type.metadata.all().delete()
+        self.test_document_type.metadata.all().delete()
 
         self.assertFalse(
-            self.metadata_type.get_required_for(self.document_type)
+            self.metadata_type.get_required_for(self.test_document_type)
         )
 
-        self.document_type.metadata.create(
+        self.test_document_type.metadata.create(
             metadata_type=self.metadata_type, required=False
         )
 
         self.assertFalse(
-            self.metadata_type.get_required_for(self.document_type)
+            self.metadata_type.get_required_for(self.test_document_type)
         )
 
-        self.document_type.metadata.all().delete()
+        self.test_document_type.metadata.all().delete()
 
-        self.document_type.metadata.create(
+        self.test_document_type.metadata.create(
             metadata_type=self.metadata_type, required=True
         )
 
         self.assertTrue(
-            self.metadata_type.get_required_for(self.document_type)
+            self.metadata_type.get_required_for(self.test_document_type)
         )
 
     def test_unicode_lookup(self):
@@ -181,19 +179,19 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         self.metadata_type.default = TEST_DEFAULT_VALUE
         self.metadata_type.save()
 
-        self.document_type_2 = DocumentType.objects.create(
+        self.test_document_type_2 = DocumentType.objects.create(
             label=TEST_DOCUMENT_TYPE_2_LABEL
         )
 
-        self.document_type_2.metadata.create(
+        self.test_document_type_2.metadata.create(
             metadata_type=self.metadata_type, required=True
         )
 
-        self.document.set_document_type(document_type=self.document_type_2)
+        self.test_document.set_document_type(document_type=self.test_document_type_2)
 
-        self.assertEqual(self.document.metadata.count(), 1)
+        self.assertEqual(self.test_document.metadata.count(), 1)
         self.assertEqual(
-            self.document.metadata.first().value, TEST_DEFAULT_VALUE
+            self.test_document.metadata.first().value, TEST_DEFAULT_VALUE
         )
 
     def test_preserve_metadata_value_on_document_type_change(self):
@@ -202,27 +200,27 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         old and new document types
         """
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type,
+            document=self.test_document, metadata_type=self.metadata_type,
             value=TEST_DEFAULT_VALUE
         )
 
         document_metadata.full_clean()
         document_metadata.save()
 
-        self.document_type_2 = DocumentType.objects.create(
+        self.test_document_type_2 = DocumentType.objects.create(
             label=TEST_DOCUMENT_TYPE_2_LABEL
         )
 
-        self.document_type_2.metadata.create(metadata_type=self.metadata_type)
+        self.test_document_type_2.metadata.create(metadata_type=self.metadata_type)
 
-        self.document.set_document_type(document_type=self.document_type_2)
+        self.test_document.set_document_type(document_type=self.test_document_type_2)
 
-        self.assertEqual(self.document.metadata.count(), 1)
+        self.assertEqual(self.test_document.metadata.count(), 1)
         self.assertEqual(
-            self.document.metadata.first().value, TEST_DEFAULT_VALUE
+            self.test_document.metadata.first().value, TEST_DEFAULT_VALUE
         )
         self.assertEqual(
-            self.document.metadata.first().metadata_type, self.metadata_type
+            self.test_document.metadata.first().metadata_type, self.metadata_type
         )
 
     def test_delete_metadata_value_on_document_type_change(self):
@@ -231,20 +229,20 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         new document type
         """
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type,
+            document=self.test_document, metadata_type=self.metadata_type,
             value=TEST_DEFAULT_VALUE
         )
 
         document_metadata.full_clean()
         document_metadata.save()
 
-        self.document_type_2 = DocumentType.objects.create(
+        self.test_document_type_2 = DocumentType.objects.create(
             label=TEST_DOCUMENT_TYPE_2_LABEL
         )
 
-        self.document.set_document_type(document_type=self.document_type_2)
+        self.test_document.set_document_type(document_type=self.test_document_type_2)
 
-        self.assertEqual(self.document.metadata.count(), 0)
+        self.assertEqual(self.test_document.metadata.count(), 0)
 
     def test_duplicate_metadata_value_on_document_type_change(self):
         """
@@ -252,27 +250,27 @@ class MetadataTestCase(DocumentTestMixin, MetadataTypeTestMixin, BaseTestCase):
         new document type
         """
         document_metadata = DocumentMetadata(
-            document=self.document, metadata_type=self.metadata_type,
+            document=self.test_document, metadata_type=self.metadata_type,
             value=TEST_DEFAULT_VALUE
         )
 
         document_metadata.full_clean()
         document_metadata.save()
 
-        self.document_type_2 = DocumentType.objects.create(
+        self.test_document_type_2 = DocumentType.objects.create(
             label=TEST_DOCUMENT_TYPE_2_LABEL
         )
 
-        self.document_type_2.metadata.create(
+        self.test_document_type_2.metadata.create(
             metadata_type=self.metadata_type, required=True
         )
 
-        self.document.set_document_type(document_type=self.document_type_2)
+        self.test_document.set_document_type(document_type=self.test_document_type_2)
 
-        self.assertEqual(self.document.metadata.count(), 1)
+        self.assertEqual(self.test_document.metadata.count(), 1)
         self.assertEqual(
-            self.document.metadata.first().value, TEST_DEFAULT_VALUE
+            self.test_document.metadata.first().value, TEST_DEFAULT_VALUE
         )
         self.assertEqual(
-            self.document.metadata.first().metadata_type, self.metadata_type
+            self.test_document.metadata.first().metadata_type, self.metadata_type
         )

mayan/apps/metadata/tests/test_views.py

@@ -40,21 +40,21 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
             name=TEST_METADATA_TYPE_NAME, label=TEST_METADATA_TYPE_LABEL
         )
 
-        self.document_type.metadata.create(metadata_type=self.metadata_type)
+        self.test_document_type.metadata.create(metadata_type=self.metadata_type)
         self.login_user()
 
     def test_metadata_add_view_no_permission(self):
         self.grant_permission(permission=permission_document_view)
 
         response = self.post(
-            'metadata:metadata_add', args=(self.document.pk,),
+            'metadata:metadata_add', args=(self.test_document.pk,),
             data={'metadata_type': self.metadata_type.pk}
         )
         self.assertNotContains(
             response, text=self.metadata_type.label, status_code=200
         )
 
-        self.assertEqual(len(self.document.metadata.all()), 0)
+        self.assertEqual(len(self.test_document.metadata.all()), 0)
 
     def test_metadata_add_view_with_permission(self):
         self.grant_permission(permission=permission_document_view)
@@ -62,12 +62,12 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         self.grant_permission(permission=permission_metadata_document_edit)
 
         response = self.post(
-            'metadata:metadata_add', args=(self.document.pk,),
+            'metadata:metadata_add', args=(self.test_document.pk,),
             data={'metadata_type': self.metadata_type.pk}, follow=True
         )
         self.assertContains(response, 'successfully', status_code=200)
 
-        self.assertEqual(len(self.document.metadata.all()), 1)
+        self.assertEqual(len(self.test_document.metadata.all()), 1)
 
     def test_metadata_edit_after_document_type_change(self):
         # Gitlab issue #204
@@ -88,16 +88,16 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
             metadata_type=metadata_type_2, required=True
         )
 
-        self.document.set_document_type(document_type=document_type_2)
+        self.test_document.set_document_type(document_type=document_type_2)
 
         response = self.get(
-            'metadata:metadata_edit', args=(self.document.pk,), follow=True
+            'metadata:metadata_edit', args=(self.test_document.pk,), follow=True
         )
 
         self.assertContains(response, 'Edit', status_code=200)
 
         response = self.post(
-            'metadata:metadata_edit', args=(self.document.pk,), data={
+            'metadata:metadata_edit', args=(self.test_document.pk,), data={
                 'form-0-id': document_metadata_2.metadata_type.pk,
                 'form-0-update': True,
                 'form-0-value': TEST_DOCUMENT_METADATA_VALUE_2,
@@ -110,22 +110,22 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         self.assertContains(response, 'Metadata for document', status_code=200)
 
         self.assertEqual(
-            self.document.metadata.get(metadata_type=metadata_type_2).value,
+            self.test_document.metadata.get(metadata_type=metadata_type_2).value,
             TEST_DOCUMENT_METADATA_VALUE_2
         )
 
     def test_metadata_remove_view_no_permission(self):
-        document_metadata = self.document.metadata.create(
+        document_metadata = self.test_document.metadata.create(
             metadata_type=self.metadata_type, value=''
         )
 
-        self.assertEqual(len(self.document.metadata.all()), 1)
+        self.assertEqual(len(self.test_document.metadata.all()), 1)
 
         self.grant_permission(permission=permission_document_view)
 
         # Test display of metadata removal form
         response = self.get(
-            'metadata:metadata_remove', args=(self.document.pk,),
+            'metadata:metadata_remove', args=(self.test_document.pk,),
         )
 
         self.assertNotContains(
@@ -134,7 +134,7 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
 
         # Test post to metadata removal view
         response = self.post(
-            'metadata:metadata_remove', args=(self.document.pk,), data={
+            'metadata:metadata_remove', args=(self.test_document.pk,), data={
                 'form-0-id': document_metadata.metadata_type.pk,
                 'form-0-update': True,
                 'form-TOTAL_FORMS': '1',
@@ -144,24 +144,24 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         )
         self.assertEqual(response.status_code, 200)
 
-        self.assertEqual(len(self.document.metadata.all()), 1)
+        self.assertEqual(len(self.test_document.metadata.all()), 1)
 
     def test_metadata_remove_view_with_permission(self):
         # Silence unrelated logging
         logging.getLogger('navigation.classes').setLevel(logging.CRITICAL)
 
-        document_metadata = self.document.metadata.create(
+        document_metadata = self.test_document.metadata.create(
             metadata_type=self.metadata_type, value=''
         )
 
-        self.assertEqual(len(self.document.metadata.all()), 1)
+        self.assertEqual(len(self.test_document.metadata.all()), 1)
 
         self.grant_permission(permission=permission_document_view)
         self.grant_permission(permission=permission_metadata_document_remove)
 
         # Test display of metadata removal form
         response = self.get(
-            'metadata:metadata_remove', args=(self.document.pk,),
+            'metadata:metadata_remove', args=(self.test_document.pk,),
         )
 
         self.assertContains(
@@ -172,7 +172,7 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
 
         # Test post to metadata removal view
         response = self.post(
-            'metadata:metadata_remove', args=(self.document.pk,), data={
+            'metadata:metadata_remove', args=(self.test_document.pk,), data={
                 'form-0-id': document_metadata.metadata_type.pk,
                 'form-0-update': True,
                 'form-TOTAL_FORMS': '1',
@@ -183,7 +183,7 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
 
         self.assertContains(response, 'Success', status_code=200)
 
-        self.assertEqual(len(self.document.metadata.all()), 0)
+        self.assertEqual(len(self.test_document.metadata.all()), 0)
 
     def test_multiple_document_metadata_edit(self):
         self.grant_permission(permission=permission_document_view)
@@ -191,18 +191,18 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         self.grant_permission(permission=permission_metadata_document_edit)
 
         with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
-            document_2 = self.document_type.new_document(
+            document_2 = self.test_document_type.new_document(
                 file_object=File(file_object)
             )
 
-        document_metadata = self.document.metadata.create(
+        document_metadata = self.test_document.metadata.create(
             metadata_type=self.metadata_type
         )
         document_2.metadata.create(metadata_type=self.metadata_type)
 
         response = self.get(
             'metadata:metadata_multiple_edit', data={
-                'id_list': '{},{}'.format(self.document.pk, document_2.pk)
+                'id_list': '{},{}'.format(self.test_document.pk, document_2.pk)
             }
         )
 
@@ -211,7 +211,7 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         # Test post to metadata removal view
         response = self.post(
             'metadata:metadata_multiple_edit', data={
-                'id_list': '{},{}'.format(self.document.pk, document_2.pk),
+                'id_list': '{},{}'.format(self.test_document.pk, document_2.pk),
                 'form-0-id': document_metadata.metadata_type.pk,
                 'form-0-value': TEST_METADATA_VALUE_EDITED,
                 'form-0-update': True,
@@ -224,7 +224,7 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         self.assertEqual(response.status_code, 200)
 
         self.assertEqual(
-            self.document.metadata.first().value, TEST_METADATA_VALUE_EDITED
+            self.test_document.metadata.first().value, TEST_METADATA_VALUE_EDITED
         )
         self.assertEqual(
             document_2.metadata.first().value, TEST_METADATA_VALUE_EDITED
@@ -235,18 +235,18 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         self.grant_permission(permission=permission_metadata_document_remove)
 
         with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
-            document_2 = self.document_type.new_document(
+            document_2 = self.test_document_type.new_document(
                 file_object=File(file_object)
             )
 
-        document_metadata = self.document.metadata.create(
+        document_metadata = self.test_document.metadata.create(
             metadata_type=self.metadata_type
         )
         document_2.metadata.create(metadata_type=self.metadata_type)
 
         response = self.get(
             'metadata:metadata_multiple_remove', data={
-                'id_list': '{},{}'.format(self.document.pk, document_2.pk)
+                'id_list': '{},{}'.format(self.test_document.pk, document_2.pk)
             }
         )
 
@@ -255,7 +255,7 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         # Test post to metadata removal view
         response = self.post(
             'metadata:metadata_multiple_remove', data={
-                'id_list': '{},{}'.format(self.document.pk, document_2.pk),
+                'id_list': '{},{}'.format(self.test_document.pk, document_2.pk),
                 'form-0-id': document_metadata.metadata_type.pk,
                 'form-0-update': True,
                 'form-TOTAL_FORMS': '1',
@@ -266,7 +266,7 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
 
         self.assertEqual(response.status_code, 200)
 
-        self.assertEqual(self.document.metadata.count(), 0)
+        self.assertEqual(self.test_document.metadata.count(), 0)
         self.assertEqual(document_2.metadata.count(), 0)
 
     def test_multiple_document_metadata_add(self):
@@ -275,13 +275,13 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
         self.grant_permission(permission=permission_metadata_document_edit)
 
         with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
-            document_2 = self.document_type.new_document(
+            document_2 = self.test_document_type.new_document(
                 file_object=File(file_object)
             )
 
         response = self.post(
             'metadata:metadata_multiple_add', data={
-                'id_list': '{},{}'.format(self.document.pk, document_2.pk),
+                'id_list': '{},{}'.format(self.test_document.pk, document_2.pk),
                 'metadata_type': self.metadata_type.pk
             }, follow=True
         )
@@ -297,17 +297,17 @@ class DocumentMetadataTestCase(GenericDocumentViewTestCase):
             name=TEST_METADATA_TYPE_NAME_2, label=TEST_METADATA_TYPE_LABEL_2
         )
 
-        self.document_type.metadata.create(
+        self.test_document_type.metadata.create(
             metadata_type=metadata_type_2
         )
 
         self.post(
-            'metadata:metadata_add', args=(self.document.pk,), data={
+            'metadata:metadata_add', args=(self.test_document.pk,), data={
                 'metadata_type': [self.metadata_type.pk, metadata_type_2.pk],
             }
         )
 
-        document_metadata_types = self.document.metadata.values_list(
+        document_metadata_types = self.test_document.metadata.values_list(
             'metadata_type', flat=True
         )
         self.assertTrue(
@@ -442,9 +442,9 @@ class MetadataTypeViewTestCase(DocumentTestMixin, MetadataTestsMixin, GenericVie
 
         self.assertEqual(response.status_code, 403)
 
-        self.document_type.refresh_from_db()
+        self.test_document_type.refresh_from_db()
 
-        self.assertEqual(self.document_type.metadata.count(), 0)
+        self.assertEqual(self.test_document_type.metadata.count(), 0)
 
     def test_metadata_type_relationship_view_with_document_type_access(self):
         self._create_metadata_type()
@@ -452,16 +452,16 @@ class MetadataTypeViewTestCase(DocumentTestMixin, MetadataTestsMixin, GenericVie
         self.upload_document()
 
         self.grant_access(
-            permission=permission_document_type_edit, obj=self.document_type
+            permission=permission_document_type_edit, obj=self.test_document_type
         )
 
         response = self._request_metadata_type_relationship_edit_view()
 
         self.assertEqual(response.status_code, 403)
 
-        self.document_type.refresh_from_db()
+        self.test_document_type.refresh_from_db()
 
-        self.assertEqual(self.document_type.metadata.count(), 0)
+        self.assertEqual(self.test_document_type.metadata.count(), 0)
 
     def test_metadata_type_relationship_view_with_metadata_type_access(self):
         self._create_metadata_type()
@@ -476,9 +476,9 @@ class MetadataTypeViewTestCase(DocumentTestMixin, MetadataTestsMixin, GenericVie
 
         self.assertEqual(response.status_code, 302)
 
-        self.document_type.refresh_from_db()
+        self.test_document_type.refresh_from_db()
 
-        self.assertEqual(self.document_type.metadata.count(), 0)
+        self.assertEqual(self.test_document_type.metadata.count(), 0)
 
     def test_metadata_type_relationship_view_with_metadata_type_and_document_type_access(self):
         self._create_metadata_type()
@@ -489,17 +489,17 @@ class MetadataTypeViewTestCase(DocumentTestMixin, MetadataTestsMixin, GenericVie
             permission=permission_metadata_type_edit, obj=self.metadata_type
         )
         self.grant_access(
-            permission=permission_document_type_edit, obj=self.document_type
+            permission=permission_document_type_edit, obj=self.test_document_type
         )
 
         response = self._request_metadata_type_relationship_edit_view()
 
         self.assertEqual(response.status_code, 302)
 
-        self.document_type.refresh_from_db()
+        self.test_document_type.refresh_from_db()
 
         self.assertQuerysetEqual(
-            qs=self.document_type.metadata.values('metadata_type', 'required'),
+            qs=self.test_document_type.metadata.values('metadata_type', 'required'),
             values=[
                 {
                     'metadata_type': self.metadata_type.pk,

mayan/apps/metadata/tests/test_wizard_steps.py

@@ -29,9 +29,9 @@ class DocumentUploadMetadataTestCase(MetadataTypeTestMixin, GenericDocumentViewT
             uncompress=TEST_SOURCE_UNCOMPRESS_N
         )
 
-        self.document.delete()
+        self.test_document.delete()
 
-        self.document_type.metadata.create(
+        self.test_document_type.metadata.create(
             metadata_type=self.metadata_type, required=True
         )
 
@@ -41,7 +41,7 @@ class DocumentUploadMetadataTestCase(MetadataTypeTestMixin, GenericDocumentViewT
         url.args['metadata0_value'] = TEST_METADATA_VALUE_UNICODE
 
         self.grant_access(
-            permission=permission_document_create, obj=self.document_type
+            permission=permission_document_create, obj=self.test_document_type
         )
 
         # Upload the test document
@@ -49,7 +49,7 @@ class DocumentUploadMetadataTestCase(MetadataTypeTestMixin, GenericDocumentViewT
             response = self.post(
                 path=url, data={
                     'document-language': 'eng', 'source-file': file_descriptor,
-                    'document_type_id': self.document_type.pk,
+                    'document_type_id': self.test_document_type.pk,
                 }
             )
         self.assertEqual(response.status_code, 302)
@@ -65,14 +65,14 @@ class DocumentUploadMetadataTestCase(MetadataTypeTestMixin, GenericDocumentViewT
         url.args['metadata0_value'] = TEST_METADATA_VALUE_WITH_AMPERSAND
 
         self.grant_access(
-            permission=permission_document_create, obj=self.document_type
+            permission=permission_document_create, obj=self.test_document_type
         )
         # Upload the test document
         with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_descriptor:
             response = self.post(
                 path=url, data={
                     'document-language': 'eng', 'source-file': file_descriptor,
-                    'document_type_id': self.document_type.pk,
+                    'document_type_id': self.test_document_type.pk,
                 }
             )
         self.assertEqual(response.status_code, 302)
@@ -84,12 +84,12 @@ class DocumentUploadMetadataTestCase(MetadataTypeTestMixin, GenericDocumentViewT
 
     def test_initial_step_conditions(self):
         self.grant_access(
-            obj=self.document_type, permission=permission_document_create
+            obj=self.test_document_type, permission=permission_document_create
         )
 
         response = self.post(
             viewname='sources:document_create_multiple', data={
-                'document_type_selection-document_type': self.document_type.pk,
+                'document_type_selection-document_type': self.test_document_type.pk,
                 'document_create_wizard-current_step': 0
             }
         )

mayan/apps/mimetype/tests/test_functions.py

@@ -16,8 +16,6 @@ from mayan.apps.documents.tests import DocumentTestMixin, TEST_DOCUMENT_FILENAME
 MAXIMUM_HEAP_MEMORY = 140000000
 
 
-@override_settings(OCR_AUTO_OCR=False)
-@override_settings(DOCUMENT_PARSING_AUTO_PARSING=False)
 @tag('memory', EXCLUDE_TEST_TAG)
 class MIMETypeTestCase(DocumentTestMixin, BaseTestCase):
     auto_upload_document = False

mayan/apps/mirroring/tests/test_caches.py

@@ -24,19 +24,19 @@ class IndexFilesystemCacheTestCase(BaseTestCase):
     def setUp(self):
         super(IndexFilesystemCacheTestCase, self).setUp()
         self.cache = IndexFilesystemCache()
-        self.document = MockDocument()
+        self.test_document = MockDocument()
         self.node = MockNode()
 
     def test_set_path_document(self):
-        self.cache.set_path(path=TEST_PATH, document=self.document)
+        self.cache.set_path(path=TEST_PATH, document=self.test_document)
         self.assertEquals(
             {'document_pk': TEST_DOCUMENT_PK},
             self.cache.get_path(path=TEST_PATH)
         )
 
     def test_set_path_document_clear_document(self):
-        self.cache.set_path(path=TEST_PATH, document=self.document)
+        self.cache.set_path(path=TEST_PATH, document=self.test_document)
-        self.cache.clear_document(document=self.document)
+        self.cache.clear_document(document=self.test_document)
 
         self.assertEquals(None, self.cache.get_path(path=TEST_PATH))
 

mayan/apps/mirroring/tests/test_filesystems.py

@@ -4,8 +4,6 @@ import hashlib
 
 from fuse import FuseOSError
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.documents.models import Document
 from mayan.apps.documents.tests import DocumentTestMixin
@@ -20,20 +18,19 @@ from .literals import (
 )
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class IndexFilesystemTestCase(DocumentIndexingTestMixin, DocumentTestMixin, BaseTestCase):
     auto_upload_document = False
 
     def test_document_access(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
+            parent=self.test_index.template_root, expression=TEST_NODE_EXPRESSION,
             link_documents=True
         )
 
         document = self.upload_document()
-        index_filesystem = IndexFilesystem(index_slug=self.index.slug)
+        index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
 
         self.assertEqual(
             index_filesystem.access(
@@ -42,15 +39,15 @@ class IndexFilesystemTestCase(DocumentIndexingTestMixin, DocumentTestMixin, Base
         )
 
     def test_document_access_failure(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
+            parent=self.test_index.template_root, expression=TEST_NODE_EXPRESSION,
             link_documents=True
         )
 
         document = self.upload_document()
-        index_filesystem = IndexFilesystem(index_slug=self.index.slug)
+        index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
 
         with self.assertRaises(FuseOSError):
             index_filesystem.access(
@@ -58,15 +55,15 @@ class IndexFilesystemTestCase(DocumentIndexingTestMixin, DocumentTestMixin, Base
             )
 
     def test_document_open(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
+            parent=self.test_index.template_root, expression=TEST_NODE_EXPRESSION,
             link_documents=True
         )
 
         document = self.upload_document()
-        index_filesystem = IndexFilesystem(index_slug=self.index.slug)
+        index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
 
         file_handle = index_filesystem.open(
             '/{}/{}'.format(TEST_NODE_EXPRESSION, document.label), 'rb'
@@ -82,16 +79,16 @@ class IndexFilesystemTestCase(DocumentIndexingTestMixin, DocumentTestMixin, Base
         )
 
     def test_multiline_indexes(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root,
+            parent=self.test_index.template_root,
             expression=TEST_NODE_EXPRESSION_MULTILINE,
             link_documents=True
         )
 
         self.upload_document()
-        index_filesystem = IndexFilesystem(index_slug=self.index.slug)
+        index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
 
         self.assertEqual(
             list(index_filesystem.readdir('/', ''))[2:],
@@ -99,16 +96,16 @@ class IndexFilesystemTestCase(DocumentIndexingTestMixin, DocumentTestMixin, Base
         )
 
     def test_multiline_indexes_first_and_last(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root,
+            parent=self.test_index.template_root,
             expression=TEST_NODE_EXPRESSION_MULTILINE_2,
             link_documents=True
         )
 
         self.upload_document()
-        index_filesystem = IndexFilesystem(index_slug=self.index.slug)
+        index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
 
         self.assertEqual(
             list(index_filesystem.readdir('/', ''))[2:],
@@ -116,37 +113,37 @@ class IndexFilesystemTestCase(DocumentIndexingTestMixin, DocumentTestMixin, Base
         )
 
     def test_duplicated_indexes(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
+            parent=self.test_index.template_root, expression=TEST_NODE_EXPRESSION,
             link_documents=True
         )
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
+            parent=self.test_index.template_root, expression=TEST_NODE_EXPRESSION,
             link_documents=True
         )
 
         self.upload_document()
-        index_filesystem = IndexFilesystem(index_slug=self.index.slug)
+        index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
 
         self.assertEqual(
             list(index_filesystem.readdir('/', ''))[2:], []
         )
 
     def test_ignore_stub_documents(self):
-        self._create_index()
+        self._create_test_index()
 
-        self.index.node_templates.create(
+        self.test_index.node_templates.create(
-            parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
+            parent=self.test_index.template_root, expression=TEST_NODE_EXPRESSION,
             link_documents=True
         )
 
         self.document = Document.objects.create(
             document_type=self.document_type, label='document_stub'
         )
-        index_filesystem = IndexFilesystem(index_slug=self.index.slug)
+        index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
-        self.index.rebuild()
+        self.test_index.rebuild()
 
         self.assertEqual(
             list(

mayan/apps/motd/tests/test_api.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from rest_framework import status
 
 from mayan.apps.rest_api.tests import BaseAPITestCase
@@ -17,12 +15,7 @@ from .literals import (
 )
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class MOTDAPITestCase(BaseAPITestCase):
-    def setUp(self):
-        super(MOTDAPITestCase, self).setUp()
-        self.login_user()
-
     def _create_message(self):
         return Message.objects.create(
             label=TEST_LABEL, message=TEST_MESSAGE

mayan/apps/navigation/tests/test_classes.py

@@ -5,7 +5,7 @@ from django.urls import reverse
 
 from furl import furl
 
-from mayan.apps.acls.models import AccessControlList
+from mayan.apps.acls.classes import ModelPermission
 from mayan.apps.common.tests import GenericViewTestCase
 from mayan.apps.common.tests.literals import TEST_VIEW_NAME
 from mayan.apps.permissions import Permission, PermissionNamespace
@@ -24,16 +24,23 @@ class LinkClassTestCase(GenericViewTestCase):
     def setUp(self):
         super(LinkClassTestCase, self).setUp()
 
-        self.add_test_view(test_object=self.group)
+        self.test_object = self._test_case_group
+
+        self.add_test_view(test_object=self.test_object)
 
         self.namespace = PermissionNamespace(
             TEST_PERMISSION_NAMESPACE_NAME, TEST_PERMISSION_NAMESPACE_TEXT
         )
 
-        self.permission = self.namespace.add_permission(
+        self.test_permission = self.namespace.add_permission(
             name=TEST_PERMISSION_NAME, label=TEST_PERMISSION_LABEL
         )
 
+        ModelPermission.register(
+            model=self.test_object._meta.model,
+            permissions=(self.test_permission,)
+        )
+
         self.link = Link(text=TEST_LINK_TEXT, view=TEST_VIEW_NAME)
         Permission.invalidate_cache()
 
@@ -49,7 +56,7 @@ class LinkClassTestCase(GenericViewTestCase):
         self.login_user()
 
         link = Link(
-            permissions=(self.permission,), text=TEST_LINK_TEXT,
+            permissions=(self.test_permission,), text=TEST_LINK_TEXT,
             view=TEST_VIEW_NAME
         )
 
@@ -65,11 +72,11 @@ class LinkClassTestCase(GenericViewTestCase):
         self.login_user()
 
         link = Link(
-            permissions=(self.permission,), text=TEST_LINK_TEXT,
+            permissions=(self.test_permission,), text=TEST_LINK_TEXT,
             view=TEST_VIEW_NAME
         )
 
-        self.role.permissions.add(self.permission.stored_permission)
+        self.grant_access(obj=self.test_object, permission=self.test_permission)
 
         response = self.get(TEST_VIEW_NAME)
         response.context.update({'request': response.wsgi_request})
@@ -81,17 +88,13 @@ class LinkClassTestCase(GenericViewTestCase):
 
     def test_link_permission_resolve_with_acl(self):
         # ACL is tested agains the resolved_object or just {{ object }} if not
-        self.login_user()
 
         link = Link(
-            permissions=(self.permission,), text=TEST_LINK_TEXT,
+            permissions=(self.test_permission,), text=TEST_LINK_TEXT,
             view=TEST_VIEW_NAME
         )
 
-        acl = AccessControlList.objects.create(
+        self.grant_access(obj=self.test_object, permission=self.test_permission)
-            content_object=self.group, role=self.role
-        )
-        acl.permissions.add(self.permission.stored_permission)
 
         response = self.get(TEST_VIEW_NAME)
         response.context.update({'request': response.wsgi_request})
@@ -156,13 +159,15 @@ class MenuClassTestCase(GenericViewTestCase):
     def setUp(self):
         super(MenuClassTestCase, self).setUp()
 
-        self.add_test_view(test_object=self.group)
+        self.test_object = self._test_case_group
+
+        self.add_test_view(test_object=self.test_object)
 
         self.namespace = PermissionNamespace(
             TEST_PERMISSION_NAMESPACE_NAME, TEST_PERMISSION_NAMESPACE_TEXT
         )
 
-        self.permission = self.namespace.add_permission(
+        self.test_permission = self.namespace.add_permission(
             name=TEST_PERMISSION_NAME, label=TEST_PERMISSION_LABEL
         )
 

mayan/apps/ocr/tests/literals.py

@@ -1,4 +1,10 @@
+# -*- coding: utf-8 -*-
+
 from __future__ import unicode_literals
 
+TEST_DOCUMENT_CONTENT = 'Mayan EDMS Documentation'
+TEST_DOCUMENT_CONTENT_DEU_1 = 'Repository für elektronische Dokumente.'
+TEST_DOCUMENT_CONTENT_DEU_2 = 'Es bietet einen'
+
 TEST_OCR_INDEX_NODE_TEMPLATE = '{% if "mayan" in document.latest_version.ocr_content|join:" "|lower %}mayan{% endif %}'
 TEST_OCR_INDEX_NODE_TEMPLATE_LEVEL = 'mayan'

mayan/apps/ocr/tests/test_api.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from rest_framework import status
 
 from mayan.apps.documents.tests import DocumentTestMixin
@@ -11,67 +9,58 @@ from ..permissions import (
     permission_ocr_document, permission_ocr_content_view,
 )
 
-TEST_DOCUMENT_CONTENT = 'Mayan EDMS Documentation'
+from .literals import TEST_DOCUMENT_CONTENT
 
 
-@override_settings(OCR_AUTO_OCR=False)
-@override_settings(DOCUMENT_PARSING_PDFTOTEXT_PATH='')
 class OCRAPITestCase(DocumentTestMixin, BaseAPITestCase):
-    """
-    Test the OCR app API endpoints
-    """
-    def setUp(self):
-        super(OCRAPITestCase, self).setUp()
-        self.login_user()
-
     def _request_document_ocr_submit_view(self):
         return self.post(
             viewname='rest_api:document-ocr-submit-view',
-            args=(self.document.pk,)
+            kwargs={'pk': self.test_document.pk}
         )
 
     def test_submit_document_no_access(self):
         response = self._request_document_ocr_submit_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
-        self.assertFalse(hasattr(self.document.pages.first(), 'ocr_content'))
+        self.assertFalse(hasattr(self.test_document.pages.first(), 'ocr_content'))
 
     def test_submit_document_with_access(self):
         self.grant_access(
-            permission=permission_ocr_document, obj=self.document
+            obj=self.test_document, permission=permission_ocr_document
         )
         response = self._request_document_ocr_submit_view()
         self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
 
-        self.assertTrue(hasattr(self.document.pages.first(), 'ocr_content'))
+        self.assertTrue(hasattr(self.test_document.pages.first(), 'ocr_content'))
 
     def _request_document_version_ocr_submit_view(self):
         return self.post(
             viewname='rest_api:document-version-ocr-submit-view',
-            args=(self.document.pk, self.document.latest_version.pk,)
+            args=(self.test_document.pk, self.test_document.latest_version.pk,)
         )
 
     def test_submit_document_version_no_access(self):
         response = self._request_document_version_ocr_submit_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
-        self.assertFalse(hasattr(self.document.pages.first(), 'ocr_content'))
+        self.assertFalse(hasattr(self.test_document.pages.first(), 'ocr_content'))
 
     def test_submit_document_version_with_access(self):
         self.grant_access(
-            permission=permission_ocr_document, obj=self.document
+            permission=permission_ocr_document, obj=self.test_document
         )
         response = self._request_document_version_ocr_submit_view()
         self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
 
-        self.assertTrue(hasattr(self.document.pages.first(), 'ocr_content'))
+        self.assertTrue(hasattr(self.test_document.pages.first(), 'ocr_content'))
 
     def _request_document_page_content_view(self):
         return self.get(
             viewname='rest_api:document-page-ocr-content-view',
             args=(
-                self.document.pk, self.document.latest_version.pk,
+                self.test_document.pk, self.test_document.latest_version.pk,
-                self.document.latest_version.pages.first().pk,
+                self.test_document.latest_version.pages.first().pk,
             )
         )
 
@@ -80,9 +69,9 @@ class OCRAPITestCase(DocumentTestMixin, BaseAPITestCase):
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
     def test_get_document_version_page_content_with_access(self):
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
         self.grant_access(
-            permission=permission_ocr_content_view, obj=self.document
+            permission=permission_ocr_content_view, obj=self.test_document
         )
         response = self._request_document_page_content_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)

mayan/apps/ocr/tests/test_indexing.py

@@ -1,7 +1,5 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.documents.tests import DocumentTestMixin
 from mayan.apps.document_indexing.models import Index, IndexInstanceNode
@@ -12,7 +10,6 @@ from .literals import (
 )
 
 
-@override_settings(OCR_AUTO_OCR=False)
 class OCRIndexingTestCase(DocumentTestMixin, BaseTestCase):
     auto_upload_document = False
 
@@ -27,11 +24,11 @@ class OCRIndexingTestCase(DocumentTestMixin, BaseTestCase):
             link_documents=True
         )
 
-        self.document = self.upload_document()
+        self.upload_document()
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
 
         self.assertTrue(
-            self.document in IndexInstanceNode.objects.get(
+            self.test_document in IndexInstanceNode.objects.get(
                 value=TEST_OCR_INDEX_NODE_TEMPLATE_LEVEL
             ).documents.all()
         )

mayan/apps/ocr/tests/test_models.py

@@ -1,19 +1,19 @@
-# -*- coding: utf-8 -*-
-
 from __future__ import unicode_literals
 
+from django.test import override_settings
+
 from mayan.apps.common.tests import BaseTestCase
-from mayan.apps.documents.models import DocumentType
 from mayan.apps.documents.tests import (
-    DocumentTestMixin, TEST_DEU_DOCUMENT_PATH, TEST_DOCUMENT_TYPE_LABEL
+    DocumentTestMixin, TEST_DEU_DOCUMENT_PATH
 )
-from mayan.apps.documents.utils import get_language_choices
 
-TEST_DOCUMENT_CONTENT = 'Mayan EDMS Documentation'
+from .literals import (
-TEST_DOCUMENT_CONTENT_DEU_1 = 'Repository für elektronische Dokumente.'
+    TEST_DOCUMENT_CONTENT, TEST_DOCUMENT_CONTENT_DEU_1,
-TEST_DOCUMENT_CONTENT_DEU_2 = 'Es bietet einen'
+    TEST_DOCUMENT_CONTENT_DEU_2
+)
 
 
+@override_settings(OCR_AUTO_OCR=True)
 class DocumentOCRTestCase(DocumentTestMixin, BaseTestCase):
     # PyOCR's leak descriptor in get_available_languages and image_to_string
     # Disable descriptor leak test until fixed in upstream
@@ -24,37 +24,24 @@ class DocumentOCRTestCase(DocumentTestMixin, BaseTestCase):
         self.assertTrue(TEST_DOCUMENT_CONTENT in content)
 
 
-class GermanOCRSupportTestCase(BaseTestCase):
+@override_settings(OCR_AUTO_OCR=True)
+class GermanOCRSupportTestCase(DocumentTestMixin, BaseTestCase):
     # PyOCR's leak descriptor in get_available_languages and image_to_string
     # Disable descriptor leak test until fixed in upstream
     _skip_file_descriptor_test = True
 
+    auto_upload_document = False
+
     def setUp(self):
         super(GermanOCRSupportTestCase, self).setUp()
 
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
-        # Get corresponding language code for German from the default language
-        # choices list
-        language_code = [
-            language for language in get_language_choices() if language[1] == 'German'
-        ][0][0]
-
-        self.assertEqual('deu', language_code)
-
         with open(TEST_DEU_DOCUMENT_PATH, mode='rb') as file_object:
-            self.document = self.document_type.new_document(
+            self.test_document = self.test_document_type.new_document(
-                file_object=file_object, language=language_code
+                file_object=file_object, language='deu'
             )
 
-    def tearDown(self):
-        self.document_type.delete()
-        super(GermanOCRSupportTestCase, self).tearDown()
-
     def test_ocr_language_backends_end(self):
-        content = self.document.pages.first().ocr_content.content
+        content = self.test_document.pages.first().ocr_content.content
 
         self.assertTrue(
             TEST_DOCUMENT_CONTENT_DEU_1 in content

mayan/apps/ocr/tests/test_views.py

@@ -8,7 +8,7 @@ from ..permissions import (
 )
 from ..utils import get_document_ocr_content
 
-TEST_DOCUMENT_CONTENT = 'Mayan EDMS Documentation'
+from .literals import TEST_DOCUMENT_CONTENT
 
 
 class OCRViewsTestCase(GenericDocumentViewTestCase):
@@ -16,77 +16,79 @@ class OCRViewsTestCase(GenericDocumentViewTestCase):
     # Disable descriptor leak test until fixed in upstream
     _skip_file_descriptor_test = True
 
-    def setUp(self):
-        super(OCRViewsTestCase, self).setUp()
-        self.login_user()
-
     def _request_document_content_view(self):
         return self.get(
-            viewname='ocr:document_ocr_content', args=(self.document.pk,)
+            viewname='ocr:document_ocr_content', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_content_view_no_permissions(self):
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
-        response = self._request_document_content_view()
 
+        response = self._request_document_content_view()
         self.assertEqual(response.status_code, 403)
 
     def test_document_content_view_with_access(self):
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
         self.grant_access(
-            permission=permission_ocr_content_view, obj=self.document
+            obj=self.test_document, permission=permission_ocr_content_view
         )
 
         response = self._request_document_content_view()
-
         self.assertContains(
             response=response, text=TEST_DOCUMENT_CONTENT, status_code=200
         )
 
     def _request_document_page_content_view(self):
         return self.get(
-            viewname='ocr:document_page_ocr_content', args=(
+            viewname='ocr:document_page_ocr_content', kwargs={
-                self.document.pages.first().pk,
+                'pk': self.test_document.pages.first().pk
-            )
+            }
         )
 
     def test_document_page_content_view_no_permissions(self):
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
-        response = self._request_document_page_content_view()
 
+        response = self._request_document_page_content_view()
         self.assertEqual(response.status_code, 403)
 
     def test_document_page_content_view_with_access(self):
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
         self.grant_access(
-            permission=permission_ocr_content_view, obj=self.document
+            obj=self.test_document, permission=permission_ocr_content_view
         )
 
         response = self._request_document_page_content_view()
-
         self.assertContains(
             response=response, text=TEST_DOCUMENT_CONTENT, status_code=200
         )
 
     def _request_document_submit_view(self):
         return self.post(
-            viewname='ocr:document_submit', args=(self.document.pk,)
+            viewname='ocr:document_submit', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_submit_view_no_permission(self):
-        self._request_document_submit_view()
+        response = self._request_document_submit_view()
+        self.assertEqual(response.status_code, 302)
+
         self.assertEqual(
-            ''.join(self.document.latest_version.ocr_content()), ''
+            ''.join(self.test_document.latest_version.ocr_content()), ''
         )
 
     def test_document_submit_view_with_access(self):
         self.grant_access(
-            permission=permission_ocr_document, obj=self.document
+            permission=permission_ocr_document, obj=self.test_document
         )
-        self._request_document_submit_view()
+        response = self._request_document_submit_view()
+        self.assertEqual(response.status_code, 302)
+
         self.assertTrue(
             TEST_DOCUMENT_CONTENT in ''.join(
-                self.document.latest_version.ocr_content()
+                self.test_document.latest_version.ocr_content()
             )
         )
 
@@ -94,56 +96,65 @@ class OCRViewsTestCase(GenericDocumentViewTestCase):
         return self.post(
             viewname='ocr:document_submit_multiple',
             data={
-                'id_list': self.document.pk,
+                'id_list': self.test_document.pk,
             }
         )
 
     def test_multiple_document_submit_view_no_permission(self):
-        self._request_multiple_document_submit_view()
+        response = self._request_multiple_document_submit_view()
+        self.assertEqual(response.status_code, 302)
+
         self.assertEqual(
-            ''.join(self.document.latest_version.ocr_content()), ''
+            ''.join(self.test_document.latest_version.ocr_content()), ''
         )
 
     def test_multiple_document_submit_view_with_access(self):
         self.grant_access(
-            permission=permission_ocr_document, obj=self.document
+            permission=permission_ocr_document, obj=self.test_document
         )
-        self._request_multiple_document_submit_view()
+        response = self._request_multiple_document_submit_view()
+        self.assertEqual(response.status_code, 302)
+
         self.assertTrue(
             TEST_DOCUMENT_CONTENT in ''.join(
-                self.document.latest_version.ocr_content()
+                self.test_document.latest_version.ocr_content()
             )
         )
 
     def _request_document_ocr_download_view(self):
         return self.get(
-            viewname='ocr:document_ocr_download', args=(self.document.pk,)
+            viewname='ocr:document_ocr_download', kwargs={
+                'pk': self.test_document.pk
+            }
         )
 
     def test_document_ocr_download_view_no_permission(self):
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
+
         response = self._request_document_ocr_download_view()
         self.assertEqual(response.status_code, 403)
 
-    def test_document_ocr_download_view_with_permission(self):
+    def test_document_ocr_download_view_with_access(self):
-        self.document.submit_for_ocr()
+        self.test_document.submit_for_ocr()
         self.expected_content_type = 'application/octet-stream; charset=utf-8'
 
-        self.grant_permission(permission=permission_ocr_content_view)
+        self.grant_access(
-        response = self._request_document_ocr_download_view()
+            obj=self.test_document, permission=permission_ocr_content_view
+        )
 
+        response = self._request_document_ocr_download_view()
         self.assertEqual(response.status_code, 200)
 
         self.assert_download_response(
             response=response, content=(
-                ''.join(get_document_ocr_content(document=self.document))
+                ''.join(get_document_ocr_content(document=self.test_document))
             ),
         )
 
     def _request_document_type_ocr_settings_view(self):
         return self.get(
             viewname='ocr:document_type_ocr_settings',
-            args=(self.document.document_type.pk,)
+            kwargs={'pk': self.test_document.document_type.pk}
         )
 
     def test_document_type_ocr_settings_view_no_permission(self):
@@ -152,9 +163,9 @@ class OCRViewsTestCase(GenericDocumentViewTestCase):
 
     def test_document_type_ocr_settings_view_with_access(self):
         self.grant_access(
-            permission=permission_document_type_ocr_setup,
+            obj=self.test_document.document_type,
-            obj=self.document.document_type
+            permission=permission_document_type_ocr_setup
         )
-        response = self._request_document_type_ocr_settings_view()
 
+        response = self._request_document_type_ocr_settings_view()
         self.assertEqual(response.status_code, 200)

mayan/apps/permissions/models.py

@@ -115,6 +115,9 @@ class Role(models.Model):
     def get_absolute_url(self):
         return reverse(viewname='permissions:role_list')
 
+    def grant(self, permission):
+        self.permissions.add(permission.stored_permission)
+
     def natural_key(self):
         return (self.label,)
     natural_key.dependencies = ['auth.Group', 'permissions.StoredPermission']

mayan/apps/permissions/tests/literals.py

@@ -1,5 +1,15 @@
 from __future__ import unicode_literals
 
-TEST_ROLE_2_LABEL = 'test role 2'
+TEST_CASE_ROLE_LABEL = 'test case role label'
-TEST_ROLE_LABEL = 'test role'
+TEST_INVALID_PERMISSION_NAMESPACE_NAME = 'invalid namespace'
+TEST_INVALID_PERMISSION_NAME = 'invalid name'
+TEST_PERMISSION_NAMESPACE_LABEL = 'test permission namespace label'
+TEST_PERMISSION_NAMESPACE_NAME = 'test_permission_namespace_name'
+TEST_PERMISSION_LABEL = 'test permission name label'
+TEST_PERMISSION_NAME = '{}.{}'.format(TEST_PERMISSION_NAMESPACE_NAME, 'test_permission_name')
+TEST_PERMISSION_NAMESPACE_LABEL_2 = 'test permission namespace label 2'
+TEST_PERMISSION_NAMESPACE_NAME_2 = 'test_permission_namespace_name_2'
+TEST_PERMISSION_LABEL_2 = 'test permission name label 2'
+TEST_PERMISSION_NAME_2 = '{}.{}'.format(TEST_PERMISSION_NAMESPACE_NAME_2, 'test_permission_name')
+TEST_ROLE_LABEL = 'test role label'
 TEST_ROLE_LABEL_EDITED = 'test role label edited'

mayan/apps/permissions/tests/mixins.py

@@ -1,8 +1,135 @@
 from __future__ import unicode_literals
 
+from ..classes import PermissionNamespace
+from ..models import Role
+
+from .literals import (
+    TEST_CASE_ROLE_LABEL, TEST_PERMISSION_LABEL, TEST_PERMISSION_LABEL_2,
+    TEST_PERMISSION_NAME, TEST_PERMISSION_NAME_2, TEST_PERMISSION_NAMESPACE_LABEL,
+    TEST_PERMISSION_NAMESPACE_LABEL_2, TEST_PERMISSION_NAMESPACE_NAME,
+    TEST_PERMISSION_NAMESPACE_NAME_2, TEST_ROLE_LABEL, TEST_ROLE_LABEL_EDITED
+)
+
+
+class GroupRoleViewTestMixin(object):
+    def _request_test_group_roles_view(self):
+        return self.get(
+            viewname='permissions:group_roles', kwargs={'pk': self.test_group.pk}
+        )
+
+
+class PermissionAPIViewTestMixin(object):
+    def _request_permissions_list_api_view(self):
+        return self.get(viewname='rest_api:permission-list')
+
+
+class PermissionTestMixin(object):
+    def _create_test_permission(self):
+        self.test_permission_namespace = PermissionNamespace(
+            label=TEST_PERMISSION_NAMESPACE_LABEL,
+            name=TEST_PERMISSION_NAMESPACE_NAME
+        )
+        self.test_permission = self.test_permission_namespace.add_permission(
+            label=TEST_PERMISSION_LABEL,
+            name=TEST_PERMISSION_NAME
+        )
+
+    def _create_test_permission_2(self):
+        self.test_permission_namespace_2 = PermissionNamespace(
+            label=TEST_PERMISSION_NAMESPACE_LABEL_2,
+            name=TEST_PERMISSION_NAMESPACE_NAME_2
+        )
+        self.test_permission_2 = self.test_permission_namespace_2.add_permission(
+            label=TEST_PERMISSION_LABEL_2,
+            name=TEST_PERMISSION_NAME_2
+        )
+
+
+class RoleAPIViewTestMixin(object):
+    def _request_test_role_create_api_view(self, extra_data=None):
+        data = {
+            'label': TEST_ROLE_LABEL
+        }
+
+        if extra_data:
+            data.update(extra_data)
+
+        return self.post(
+            viewname='rest_api:role-list', data=data
+        )
+
+    def _request_test_role_delete_api_view(self):
+        return self.delete(
+            viewname='rest_api:role-detail', kwargs={'pk': self.test_role.pk}
+        )
+
+    def _request_test_role_edit_api_view(self, extra_data=None, request_type='patch'):
+        data = {
+            'label': TEST_ROLE_LABEL_EDITED
+        }
+
+        if extra_data:
+            data.update(extra_data)
+
+        return getattr(self, request_type)(
+            viewname='rest_api:role-detail', kwargs={'pk': self.test_role.pk},
+            data=data
+        )
+
+    def _request_role_list_api_view(self):
+        return self.get(viewname='rest_api:role-list')
+
 
 class RoleTestCaseMixin(object):
+    def setUp(self):
+        super(RoleTestCaseMixin, self).setUp()
+        if hasattr(self, '_test_case_group'):
+            self.create_role()
+
+    def create_role(self):
+        self._test_case_role = Role.objects.create(label=TEST_CASE_ROLE_LABEL)
+
     def grant_permission(self, permission):
-        self.role.permissions.add(
+        self._test_case_role.grant(permission=permission)
-            permission.stored_permission
+
+
+class RoleTestMixin(object):
+    def _create_test_role(self):
+        self.test_role = Role.objects.create(label=TEST_ROLE_LABEL)
+
+
+class RoleViewTestMixin(object):
+    def _request_test_role_create_view(self):
+        return self.post(
+            viewname='permissions:role_create', data={
+                'label': TEST_ROLE_LABEL,
+            }
+        )
+
+    def _request_test_role_delete_view(self):
+        return self.post(
+            viewname='permissions:role_delete', kwargs={'pk': self.test_role.pk}
+        )
+
+    def _request_test_role_edit_view(self):
+        return self.post(
+            viewname='permissions:role_edit', kwargs={'pk': self.test_role.pk},
+            data={
+                'label': TEST_ROLE_LABEL_EDITED,
+            }
+        )
+
+    def _request_test_role_groups_view(self):
+        return self.get(
+            viewname='permissions:role_groups', kwargs={'pk': self.test_role.pk}
+        )
+
+    def _request_test_role_list_view(self):
+        return self.get(viewname='permissions:role_list')
+
+    def _request_test_role_permissions_view(self):
+        return self.get(
+            viewname='permissions:role_permissions', kwargs={
+                'pk': self.test_role.pk
+            }
         )

mayan/apps/permissions/tests/test_api.py

@@ -1,11 +1,9 @@
 from __future__ import unicode_literals
 
-from django.contrib.auth.models import Group
-
 from rest_framework import status
 
 from mayan.apps.rest_api.tests import BaseAPITestCase
-from mayan.apps.user_management.tests.literals import TEST_GROUP_2_NAME
+from mayan.apps.user_management.tests.mixins import GroupTestMixin
 
 from ..classes import Permission
 from ..models import Role
@@ -14,234 +12,269 @@ from ..permissions import (
     permission_role_edit, permission_role_view
 )
 
-from .literals import (
+from .mixins import (
-    TEST_ROLE_2_LABEL, TEST_ROLE_LABEL, TEST_ROLE_LABEL_EDITED
+    PermissionAPIViewTestMixin, PermissionTestMixin, RoleAPIViewTestMixin,
+    RoleTestMixin
 )
 
 
-class PermissionAPITestCase(BaseAPITestCase):
+class PermissionAPIViewTestCase(PermissionAPIViewTestMixin, BaseAPITestCase):
     def setUp(self):
-        super(PermissionAPITestCase, self).setUp()
+        super(PermissionAPIViewTestCase, self).setUp()
-        self.login_user()
         Permission.invalidate_cache()
 
-    def test_permissions_list_view(self):
+    def test_permissions_list_api_view(self):
-        response = self.get(viewname='rest_api:permission-list')
+        response = self._request_permissions_list_api_view()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
 
-    # Role view
 
-    def test_roles_list_view_no_access(self):
+class RoleAPIViewTestCase(GroupTestMixin, PermissionTestMixin, RoleAPIViewTestMixin, RoleTestMixin, BaseAPITestCase):
-        response = self.get(viewname='rest_api:role-list')
+    def test_role_create_api_view_no_permission(self):
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        response = self._request_test_role_create_api_view()
-        self.assertEqual(response.data['count'], 0)
 
-    def test_roles_list_view_with_access(self):
+        role_count = Role.objects.count()
-        self.grant_access(
-            permission=permission_role_view, obj=self.role
-        )
-        response = self.get(viewname='rest_api:role-list')
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data['count'], 1)
-        self.assertEqual(response.data['results'][0]['label'], self.role.label)
 
-    # Role create
-
-    def _role_create_request(self, extra_data=None):
-        data = {
-            'label': TEST_ROLE_2_LABEL
-        }
-
-        if extra_data:
-            data.update(extra_data)
-
-        return self.post(
-            viewname='rest_api:role-list', data=data
-        )
-
-    def test_role_create_view_no_permission(self):
-        response = self._role_create_request()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(Role.objects.count(), 1)
 
-    def test_role_create_view_with_permission(self):
+        self.assertEqual(Role.objects.count(), role_count)
+
+    def test_role_create_api_view_with_permission(self):
         self.grant_permission(permission=permission_role_create)
-        response = self._role_create_request()
+
+        role_count = Role.objects.count()
+
+        response = self._request_test_role_create_api_view()
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
 
-        role = Role.objects.get(label=TEST_ROLE_2_LABEL)
+        self.assertEqual(Role.objects.count(), role_count + 1)
-        self.assertEqual(response.data, {'label': role.label, 'id': role.pk})
-        self.assertEqual(Role.objects.count(), 2)
-        self.assertEqual(role.label, TEST_ROLE_2_LABEL)
 
-    def _create_group(self):
+    def _request_role_create_api_view_extra_data(self):
-        self.group_2 = Group.objects.create(name=TEST_GROUP_2_NAME)
+        extra_data = {
+            'groups_pk_list': '{}'.format(self.test_group.pk),
+            'permissions_pk_list': '{}'.format(self.test_permission.pk)
+        }
+        return self._request_test_role_create_api_view(extra_data=extra_data)
 
-    def _request_role_create_with_extra_data(self):
+    def test_role_create_api_view_extra_data_no_permission(self):
-        self._create_group()
+        self._create_test_group()
+        self._create_test_permission()
 
-        return self._role_create_request(
+        role_count = Role.objects.count()
-            extra_data={
-                'groups_pk_list': '{}'.format(self.group_2.pk),
-                'permissions_pk_list': '{}'.format(permission_role_view.pk)
-            }
-        )
-
-    def test_role_create_complex_view_no_permission(self):
-        response = self._request_role_create_with_extra_data()
 
+        response = self._request_role_create_api_view_extra_data()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(Role.objects.count(), 1)
+
-        self.assertEqual(
+        self.assertEqual(Role.objects.count(), role_count)
-            list(Role.objects.values_list('label', flat=True)),
-            [TEST_ROLE_LABEL]
-        )
 
     def test_role_create_complex_view_with_permission(self):
+        self._create_test_group()
+        self._create_test_permission()
+
         self.grant_permission(permission=permission_role_create)
-        response = self._request_role_create_with_extra_data()
 
+        role_count = Role.objects.count()
+
+        response = self._request_role_create_api_view_extra_data()
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-        self.assertEqual(Role.objects.count(), 2)
+
-        role = Role.objects.get(label=TEST_ROLE_2_LABEL)
+        self.assertEqual(Role.objects.count(), role_count + 1)
-        self.assertEqual(role.label, TEST_ROLE_2_LABEL)
+
-        self.assertQuerysetEqual(
+        new_role = Role.objects.get(pk=response.data['id'])
-            role.groups.all(), (repr(self.group_2),)
+
+        self.assertTrue(
+            self.test_group in new_role.groups.all()
         )
-        self.assertQuerysetEqual(
+        self.assertTrue(
-            role.permissions.all(),
+            self.test_permission.stored_permission in new_role.permissions.all()
-            (repr(permission_role_view.stored_permission),)
-        )
-
-    # Role edit
-
-    def _request_role_edit(self, extra_data=None, request_type='patch'):
-        data = {
-            'label': TEST_ROLE_LABEL_EDITED
-        }
-
-        if extra_data:
-            data.update(extra_data)
-
-        return getattr(self, request_type)(
-            viewname='rest_api:role-detail', args=(self.role.pk,),
-            data=data
-        )
-
-    def test_role_edit_via_patch_no_access(self):
-        response = self._request_role_edit(request_type='patch')
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL)
-
-    def test_role_edit_via_patch_with_access(self):
-        self.grant_access(permission=permission_role_edit, obj=self.role)
-        response = self._request_role_edit(request_type='patch')
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL_EDITED)
-
-    def _request_role_edit_via_patch_with_extra_data(self):
-        self._create_group()
-        return self._request_role_edit(
-            extra_data={
-                'groups_pk_list': '{}'.format(self.group_2.pk),
-                'permissions_pk_list': '{}'.format(permission_role_view.pk)
-            },
-            request_type='patch'
-        )
-
-    def test_role_edit_complex_via_patch_no_access(self):
-        response = self._request_role_edit_via_patch_with_extra_data()
-
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL)
-
-        self.assertQuerysetEqual(
-            self.role.groups.all(), (repr(self.group),)
-        )
-        self.assertQuerysetEqual(self.role.permissions.all(), ())
-
-    def test_role_edit_complex_via_patch_with_access(self):
-        self.grant_access(permission=permission_role_edit, obj=self.role)
-        response = self._request_role_edit_via_patch_with_extra_data()
-
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL_EDITED)
-        self.assertQuerysetEqual(
-            self.role.groups.all(), (repr(self.group_2),)
-        )
-        self.assertQuerysetEqual(
-            self.role.permissions.all(),
-            (repr(permission_role_view.stored_permission),)
-        )
-
-    def test_role_edit_via_put_no_access(self):
-        response = self._request_role_edit(request_type='put')
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL)
-
-    def test_role_edit_via_put_with_access(self):
-        self.grant_access(permission=permission_role_edit, obj=self.role)
-        response = self._request_role_edit(request_type='put')
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL_EDITED)
-
-    def _request_role_edit_via_put_with_extra_data(self):
-        self._create_group()
-
-        return self._request_role_edit(
-            extra_data={
-                'groups_pk_list': '{}'.format(self.group_2.pk),
-                'permissions_pk_list': '{}'.format(permission_role_view.pk)
-            }, request_type='put'
-        )
-
-    def test_role_edit_complex_via_put_no_access(self):
-        response = self._request_role_edit_via_put_with_extra_data()
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL)
-        self.assertQuerysetEqual(
-            self.role.groups.all(), (repr(self.group),)
-        )
-        self.assertQuerysetEqual(
-            self.role.permissions.all(),
-            ()
-        )
-
-    def test_role_edit_complex_via_put_with_access(self):
-        self.grant_access(permission=permission_role_edit, obj=self.role)
-        response = self._request_role_edit_via_put_with_extra_data()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.role.refresh_from_db()
-        self.assertEqual(self.role.label, TEST_ROLE_LABEL_EDITED)
-        self.assertQuerysetEqual(
-            self.role.groups.all(), (repr(self.group_2),)
-        )
-        self.assertQuerysetEqual(
-            self.role.permissions.all(),
-            (repr(permission_role_view.stored_permission),)
-        )
-
-    # Role delete
-
-    def _request_role_delete_view(self):
-        return self.delete(
-            viewname='rest_api:role-detail', args=(self.role.pk,)
         )
 
     def test_role_delete_view_no_access(self):
-        response = self._request_role_delete_view()
+        self._create_test_role()
+
+        role_count = Role.objects.count()
+
+        response = self._request_test_role_delete_api_view()
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-        self.assertEqual(Role.objects.count(), 1)
+
+        self.assertEqual(Role.objects.count(), role_count)
 
     def test_role_delete_view_with_access(self):
-        self.grant_access(permission=permission_role_delete, obj=self.role)
+        self._create_test_role()
-        response = self._request_role_delete_view()
+
+        self.grant_access(obj=self.test_role, permission=permission_role_delete)
+
+        role_count = Role.objects.count()
+
+        response = self._request_test_role_delete_api_view()
         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(Role.objects.count(), 0)
+
+        self.assertEqual(Role.objects.count(), role_count - 1)
+
+    def test_role_edit_via_patch_no_access(self):
+        self._create_test_role()
+
+        response = self._request_test_role_edit_api_view(request_type='patch')
+
+        role_label = self.test_role.label
+
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+        self.test_role.refresh_from_db()
+        self.assertEqual(self.test_role.label, role_label)
+
+    def test_role_edit_via_patch_with_access(self):
+        self._create_test_role()
+        self.grant_access(obj=self.test_role, permission=permission_role_edit)
+
+        role_label = self.test_role.label
+
+        response = self._request_test_role_edit_api_view(request_type='patch')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        self.test_role.refresh_from_db()
+        self.assertNotEqual(self.test_role.label, role_label)
+
+    def test_role_edit_via_put_no_access(self):
+        self._create_test_role()
+
+        response = self._request_test_role_edit_api_view(request_type='put')
+
+        role_label = self.test_role.label
+
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+        self.test_role.refresh_from_db()
+        self.assertEqual(self.test_role.label, role_label)
+
+    def test_role_edit_via_put_with_access(self):
+        self._create_test_role()
+        self.grant_access(obj=self.test_role, permission=permission_role_edit)
+
+        role_label = self.test_role.label
+
+        response = self._request_test_role_edit_api_view(request_type='put')
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        self.test_role.refresh_from_db()
+        self.assertNotEqual(self.test_role.label, role_label)
+
+    def _request_role_edit_api_patch_view_extra_data(self):
+        extra_data = {
+            'groups_pk_list': '{}'.format(self.test_group.pk),
+            'permissions_pk_list': '{}'.format(self.test_permission.pk)
+        }
+        return self._request_test_role_edit_api_view(
+            extra_data=extra_data, request_type='patch'
+        )
+
+    def test_role_edit_api_patch_view_extra_data_no_access(self):
+        self._create_test_group()
+        self._create_test_permission()
+        self._create_test_role()
+
+        role_label = self.test_role.label
+
+        response = self._request_role_edit_api_patch_view_extra_data()
+
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+        self.test_role.refresh_from_db()
+        self.assertEqual(self.test_role.label, role_label)
+        self.assertTrue(
+            self.test_group not in self.test_role.groups.all()
+        )
+        self.assertTrue(
+            self.test_permission.stored_permission not in self.test_role.permissions.all()
+        )
+
+    def test_role_edit_api_patch_view_extra_data_with_access(self):
+        self._create_test_group()
+        self._create_test_permission()
+        self._create_test_role()
+
+        self.grant_access(obj=self.test_role, permission=permission_role_edit)
+
+        role_label = self.test_role.label
+
+        response = self._request_role_edit_api_patch_view_extra_data()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        self.test_role.refresh_from_db()
+        self.assertNotEqual(self.test_role.label, role_label)
+        self.assertTrue(
+            self.test_group in self.test_role.groups.all()
+        )
+        self.assertTrue(
+            self.test_permission.stored_permission in self.test_role.permissions.all()
+        )
+
+    def _request_role_edit_api_put_view_extra_data(self):
+        extra_data = {
+            'groups_pk_list': '{}'.format(self.test_group.pk),
+            'permissions_pk_list': '{}'.format(self.test_permission.pk)
+        }
+        return self._request_test_role_edit_api_view(
+            extra_data=extra_data, request_type='put'
+        )
+
+    def test_role_edit_api_put_view_extra_data_no_access(self):
+        self._create_test_group()
+        self._create_test_permission()
+        self._create_test_role()
+
+        role_label = self.test_role.label
+
+        response = self._request_role_edit_api_put_view_extra_data()
+
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+        self.test_role.refresh_from_db()
+        self.assertEqual(self.test_role.label, role_label)
+        self.assertTrue(
+            self.test_group not in self.test_role.groups.all()
+        )
+        self.assertTrue(
+            self.test_permission.stored_permission not in self.test_role.permissions.all()
+        )
+
+    def test_role_edit_api_put_view_extra_data_with_access(self):
+        self._create_test_group()
+        self._create_test_permission()
+        self._create_test_role()
+
+        self.grant_access(obj=self.test_role, permission=permission_role_edit)
+
+        role_label = self.test_role.label
+
+        response = self._request_role_edit_api_put_view_extra_data()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        self.test_role.refresh_from_db()
+        self.assertNotEqual(self.test_role.label, role_label)
+        self.assertTrue(
+            self.test_group in self.test_role.groups.all()
+        )
+        self.assertTrue(
+            self.test_permission.stored_permission in self.test_role.permissions.all()
+        )
+
+    def test_roles_list_view_no_access(self):
+        self._create_test_role()
+
+        response = self._request_role_list_api_view()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+        self.assertEqual(response.data['count'], 0)
+
+    def test_roles_list_view_with_access(self):
+        self._create_test_role()
+        self.grant_access(
+            obj=self.test_role, permission=permission_role_view
+        )
+
+        response = self._request_role_list_api_view()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data['count'], 1)
+        self.assertEqual(
+            response.data['results'][0]['label'], self.test_role.label
+        )

mayan/apps/permissions/tests/test_models.py

@@ -3,29 +3,70 @@ from __future__ import unicode_literals
 from django.core.exceptions import PermissionDenied
 
 from mayan.apps.common.tests import BaseTestCase
+from mayan.apps.user_management.tests.mixins import GroupTestMixin, UserTestMixin
 
-from ..classes import Permission
+from ..classes import Permission, PermissionNamespace
-from ..permissions import permission_role_view
+from ..models import StoredPermission
+
+from .literals import (
+    TEST_INVALID_PERMISSION_NAME, TEST_INVALID_PERMISSION_NAMESPACE_NAME,
+    TEST_PERMISSION_LABEL, TEST_PERMISSION_NAME,
+    TEST_PERMISSION_NAMESPACE_LABEL, TEST_PERMISSION_NAMESPACE_NAME
+)
+from .mixins import PermissionTestMixin, RoleTestMixin
 
 
-class PermissionTestCase(BaseTestCase):
+class PermissionTestCase(GroupTestMixin, PermissionTestMixin, RoleTestMixin, UserTestMixin, BaseTestCase):
     def setUp(self):
         super(PermissionTestCase, self).setUp()
+        self._create_test_user()
+        self._create_test_group()
+        self._create_test_role()
+        self._create_test_permission()
 
     def test_no_permissions(self):
         with self.assertRaises(PermissionDenied):
             Permission.check_permissions(
-                permissions=(permission_role_view,), user=self.user
+                permissions=(self.test_permission,), user=self.test_user
             )
 
     def test_with_permissions(self):
-        self.group.user_set.add(self.user)
+        self.test_group.user_set.add(self.test_user)
-        self.role.permissions.add(permission_role_view.stored_permission)
+        self.test_role.grant(permission=self.test_permission)
-        self.role.groups.add(self.group)
+        self.test_role.groups.add(self.test_group)
 
         try:
             Permission.check_permissions(
-                permissions=(permission_role_view,), user=self.user
+                permissions=(self.test_permission,), user=self.test_user
             )
         except PermissionDenied:
             self.fail('PermissionDenied exception was not expected.')
+
+
+class StoredPermissionManagerTestCase(BaseTestCase):
+    create_test_case_superuser = False
+    create_test_case_user = False
+
+    def test_purge_obsolete_with_invalid(self):
+        StoredPermission.objects.create(
+            namespace=TEST_INVALID_PERMISSION_NAMESPACE_NAME,
+            name=TEST_INVALID_PERMISSION_NAME
+        )
+
+        StoredPermission.objects.purge_obsolete()
+
+        self.assertEqual(StoredPermission.objects.count(), 0)
+
+    def test_purge_obsolete_with_valid(self):
+        test_permission_namespace = PermissionNamespace(
+            label=TEST_PERMISSION_NAMESPACE_LABEL,
+            name=TEST_PERMISSION_NAMESPACE_NAME
+        )
+        test_permission = test_permission_namespace.add_permission(
+            label=TEST_PERMISSION_LABEL, name=TEST_PERMISSION_NAME
+        )
+        test_permission.stored_permission
+
+        StoredPermission.objects.purge_obsolete()
+
+        self.assertEqual(StoredPermission.objects.count(), 1)

mayan/apps/permissions/tests/test_views.py

@@ -1,10 +1,8 @@
 from __future__ import unicode_literals
 
-from django.contrib.auth.models import Group
-
 from mayan.apps.common.tests import GenericViewTestCase
 from mayan.apps.user_management.permissions import permission_group_edit
-from mayan.apps.user_management.tests.literals import TEST_GROUP_2_NAME
+from mayan.apps.user_management.tests.mixins import GroupTestMixin
 
 from ..models import Role
 from ..permissions import (
@@ -12,161 +10,128 @@ from ..permissions import (
     permission_role_view,
 )
 
-from .literals import TEST_ROLE_2_LABEL, TEST_ROLE_LABEL_EDITED
+from .mixins import GroupRoleViewTestMixin, RoleTestMixin, RoleViewTestMixin
 
 
-class PermissionsViewsTestCase(GenericViewTestCase):
+class RoleViewsTestCase(RoleTestMixin, RoleViewTestMixin, GenericViewTestCase):
-    def setUp(self):
-        super(PermissionsViewsTestCase, self).setUp()
-        self.login_user()
-
-    def _request_create_role_view(self):
-        return self.post(
-            viewname='permissions:role_create', data={
-                'label': TEST_ROLE_2_LABEL,
-            }
-        )
-
     def test_role_creation_view_no_permission(self):
-        response = self._request_create_role_view()
+        role_count = Role.objects.count()
+
+        response = self._request_test_role_create_view()
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(Role.objects.count(), 1)
+
-        self.assertFalse(
+        self.assertEqual(Role.objects.count(), role_count)
-            TEST_ROLE_2_LABEL in Role.objects.values_list('label', flat=True)
-        )
 
     def test_role_creation_view_with_permission(self):
         self.grant_permission(permission=permission_role_create)
-        response = self._request_create_role_view()
+        role_count = Role.objects.count()
+
+        response = self._request_test_role_create_view()
         self.assertEqual(response.status_code, 302)
-        self.assertEqual(Role.objects.count(), 2)
-        self.assertTrue(
-            TEST_ROLE_2_LABEL in Role.objects.values_list('label', flat=True)
-        )
 
-    def _request_role_delete_view(self):
+        self.assertEqual(Role.objects.count(), role_count + 1)
-        return self.post(
-            viewname='permissions:role_delete', args=(self.role_2.pk,),
-        )
-
-    def _create_role(self):
-        self.role_2 = Role.objects.create(label=TEST_ROLE_2_LABEL)
 
     def test_role_delete_view_no_access(self):
-        self._create_role()
+        self._create_test_role()
-        response = self._request_role_delete_view()
+
+        role_count = Role.objects.count()
+
+        response = self._request_test_role_delete_view()
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(Role.objects.count(), 2)
+
-        self.assertTrue(
+        self.assertEqual(Role.objects.count(), role_count)
-            TEST_ROLE_2_LABEL in Role.objects.values_list('label', flat=True)
-        )
 
     def test_role_delete_view_with_access(self):
-        self._create_role()
+        self._create_test_role()
-        self.grant_access(permission=permission_role_delete, obj=self.role_2)
+        self.grant_access(obj=self.test_role, permission=permission_role_delete)
-        response = self._request_role_delete_view()
-        self.assertEqual(response.status_code, 302)
-        self.assertEqual(Role.objects.count(), 1)
-        self.assertFalse(
-            TEST_ROLE_2_LABEL in Role.objects.values_list('label', flat=True)
-        )
 
-    def _request_role_edit_view(self):
+        role_count = Role.objects.count()
-        return self.post(
+
-            viewname='permissions:role_edit', args=(self.role_2.pk,), data={
+        response = self._request_test_role_delete_view()
-                'label': TEST_ROLE_LABEL_EDITED,
+        self.assertEqual(response.status_code, 302)
-            }
+
-        )
+        self.assertEqual(Role.objects.count(), role_count - 1)
 
     def test_role_edit_view_no_access(self):
-        self._create_role()
+        self._create_test_role()
-        response = self._request_role_edit_view()
+        role_label = self.test_role.label
+
+        response = self._request_test_role_edit_view()
 
         self.assertEqual(response.status_code, 403)
 
-        self.role_2.refresh_from_db()
+        self.test_role.refresh_from_db()
-        self.assertEqual(Role.objects.count(), 2)
+        self.assertEqual(self.test_role.label, role_label)
-        self.assertEqual(self.role_2.label, TEST_ROLE_2_LABEL)
 
     def test_role_edit_view_with_access(self):
-        self._create_role()
+        self._create_test_role()
-        self.grant_access(permission=permission_role_edit, obj=self.role_2)
+        self.grant_access(obj=self.test_role, permission=permission_role_edit)
-        response = self._request_role_edit_view()
 
+        role_label = self.test_role.label
+
+        response = self._request_test_role_edit_view()
         self.assertEqual(response.status_code, 302)
-        self.role_2.refresh_from_db()
 
-        self.assertEqual(Role.objects.count(), 2)
+        self.test_role.refresh_from_db()
-        self.assertEqual(self.role_2.label, TEST_ROLE_LABEL_EDITED)
+        self.assertNotEqual(self.test_role.label, role_label)
-
-    def _request_role_list_view(self):
-        return self.get(viewname='permissions:role_list')
 
     def test_role_list_view_no_access(self):
-        self._create_role()
+        self._create_test_role()
-        response = self._request_role_list_view()
+
+        response = self._request_test_role_list_view()
         self.assertEqual(response.status_code, 200)
         self.assertNotContains(
-            response=response, text=TEST_ROLE_2_LABEL, status_code=200
+            response=response, text=self.test_role.label, status_code=200
         )
 
     def test_role_list_view_with_access(self):
-        self._create_role()
+        self._create_test_role()
-        self.grant_access(permission=permission_role_view, obj=self.role_2)
+        self.grant_access(obj=self.test_role, permission=permission_role_view)
-        response = self._request_role_list_view()
-        self.assertContains(
-            response=response, text=TEST_ROLE_2_LABEL, status_code=200
-        )
 
-    def _request_role_permissions_view(self):
+        response = self._request_test_role_list_view()
-        return self.get(
+        self.assertContains(
-            viewname='permissions:role_permissions', args=(self.role_2.pk,)
+            response=response, text=self.test_role.label, status_code=200
         )
 
     def test_role_permissions_view_no_access(self):
-        self._create_role()
+        self._create_test_role()
-        response = self._request_role_permissions_view()
+
+        response = self._request_test_role_permissions_view()
         self.assertEqual(response.status_code, 403)
 
     def test_role_permissions_view_with_access(self):
-        self._create_role()
+        self._create_test_role()
         self.grant_access(
-            permission=permission_role_edit, obj=self.role_2
+            obj=self.test_role, permission=permission_role_edit
         )
-        response = self._request_role_permissions_view()
+
+        response = self._request_test_role_permissions_view()
         self.assertEqual(response.status_code, 200)
 
-    def _request_role_groups_view(self):
-        return self.get(
-            viewname='permissions:role_groups', args=(self.role_2.pk,)
-        )
-
     def test_role_groups_view_no_access(self):
-        self._create_role()
+        self._create_test_role()
-        response = self._request_role_groups_view()
+
+        response = self._request_test_role_groups_view()
         self.assertEqual(response.status_code, 403)
 
     def test_role_groups_view_with_access(self):
-        self._create_role()
+        self._create_test_role()
-        self.grant_access(permission=permission_role_edit, obj=self.role_2)
+        self.grant_access(obj=self.test_role, permission=permission_role_edit)
-        response = self._request_role_groups_view()
+
+        response = self._request_test_role_groups_view()
         self.assertEqual(response.status_code, 200)
 
-    def _create_group(self):
-        self.group_2 = Group.objects.create(name=TEST_GROUP_2_NAME)
-
-    def _request_group_roles_view(self):
-        return self.get(
-            viewname='permissions:group_roles', args=(self.group_2.pk,)
-        )
 
+class GroupRoleViewTestCase(GroupTestMixin, GroupRoleViewTestMixin, RoleTestMixin, GenericViewTestCase):
     def test_group_roles_view_no_access(self):
-        self._create_group()
+        self._create_test_group()
-        response = self._request_group_roles_view()
+
+        response = self._request_test_group_roles_view()
         self.assertEqual(response.status_code, 403)
 
     def test_group_roles_view_with_access(self):
-        self._create_group()
+        self._create_test_group()
-        self.grant_access(permission=permission_group_edit, obj=self.group_2)
+        self.grant_access(obj=self.test_group, permission=permission_group_edit)
-        response = self._request_group_roles_view()
+
+        response = self._request_test_group_roles_view()
         self.assertEqual(response.status_code, 200)

mayan/apps/sources/tests/test_links.py

@@ -7,14 +7,10 @@ from ..links import link_document_create_multiple
 
 
 class SourcesLinksTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(SourcesLinksTestCase, self).setUp()
-        self.login_user()
-
     def _get_document_create_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_document_create_multiple.resolve(context=context)
 
     def test_document_create_link_no_access(self):
@@ -23,7 +19,7 @@ class SourcesLinksTestCase(GenericDocumentViewTestCase):
 
     def test_document_create_link_with_access(self):
         self.grant_access(
-            permission=permission_document_create, obj=self.document_type
+            obj=self.test_document_type, permission=permission_document_create
         )
         resolved_link = self._get_document_create_link()
         self.assertNotEqual(resolved_link, None)

mayan/apps/sources/tests/test_models.py

@@ -5,13 +5,11 @@ import shutil
 import mock
 from pathlib2 import Path
 
-from django.test import override_settings
 from django.utils.encoding import force_text
 
-from mayan.apps.common.tests import BaseTestCase
+from mayan.apps.documents.models import Document
-from mayan.apps.documents.models import Document, DocumentType
 from mayan.apps.documents.tests import (
-    DocumentTestMixin, TEST_COMPRESSED_DOCUMENT_PATH, TEST_DOCUMENT_TYPE_LABEL,
+    GenericDocumentTestCase, TEST_COMPRESSED_DOCUMENT_PATH,
     TEST_NON_ASCII_DOCUMENT_FILENAME, TEST_NON_ASCII_DOCUMENT_PATH,
     TEST_NON_ASCII_COMPRESSED_DOCUMENT_PATH
 )
@@ -31,17 +29,8 @@ from .literals import (
 )
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class CompressedUploadsTestCase(GenericDocumentTestCase):
-class CompressedUploadsTestCase(BaseTestCase):
+    auto_upload_document = False
-    def setUp(self):
-        super(CompressedUploadsTestCase, self).setUp()
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
-    def tearDown(self):
-        self.document_type.delete()
-        super(CompressedUploadsTestCase, self).tearDown()
 
     def test_upload_compressed_file(self):
         source = WebFormSource(
@@ -50,7 +39,7 @@ class CompressedUploadsTestCase(BaseTestCase):
 
         with open(TEST_COMPRESSED_DOCUMENT_PATH, mode='rb') as file_object:
             source.handle_upload(
-                document_type=self.document_type,
+                document_type=self.test_document_type,
                 file_object=file_object,
                 expand=(source.uncompress == SOURCE_UNCOMPRESS_CHOICE_Y)
             )
@@ -68,21 +57,12 @@ class CompressedUploadsTestCase(BaseTestCase):
         )
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class EmailFilenameDecodingTestCase(GenericDocumentTestCase):
-class EmailFilenameDecodingTestCase(BaseTestCase):
+    auto_upload_document = False
-    def setUp(self):
-        super(EmailFilenameDecodingTestCase, self).setUp()
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
-    def tearDown(self):
-        self.document_type.delete()
-        super(EmailFilenameDecodingTestCase, self).tearDown()
 
     def _create_email_source(self):
         self.source = EmailBaseModel(
-            document_type=self.document_type,
+            document_type=self.test_document_type,
             host='', username='', password='', store_body=True
         )
 
@@ -120,6 +100,9 @@ class EmailFilenameDecodingTestCase(BaseTestCase):
         self.assertEqual(Document.objects.count(), 0)
 
     def test_decode_email_with_inline_image(self):
+        # Silence expected errors in other apps
+        self._silence_logger(name='mayan.apps.converter.backends')
+
         self._create_email_source()
         EmailBaseModel.process_message(
             source=self.source, message_text=TEST_EMAIL_INLINE_IMAGE
@@ -132,6 +115,9 @@ class EmailFilenameDecodingTestCase(BaseTestCase):
         )
 
     def test_decode_email_with_attachment_and_inline_image(self):
+        # Silence expected errors in other apps
+        self._silence_logger(name='mayan.apps.converter.backends')
+
         self._create_email_source()
         EmailBaseModel.process_message(
             source=self.source, message_text=TEST_EMAIL_ATTACHMENT_AND_INLINE
@@ -146,8 +132,8 @@ class EmailFilenameDecodingTestCase(BaseTestCase):
     def test_decode_email_and_store_from_and_subject_as_metadata(self):
         metadata_from = MetadataType.objects.create(name='from')
         metadata_subject = MetadataType.objects.create(name='subject')
-        self.document_type.metadata.create(metadata_type=metadata_from)
+        self.test_document_type.metadata.create(metadata_type=metadata_from)
-        self.document_type.metadata.create(metadata_type=metadata_subject)
+        self.test_document_type.metadata.create(metadata_type=metadata_subject)
 
         self._create_email_source()
         self.source.from_metadata_type = metadata_from
@@ -173,6 +159,9 @@ class EmailFilenameDecodingTestCase(BaseTestCase):
         )
 
     def test_document_upload_no_body(self):
+        # Silence expected errors in other apps
+        self._silence_logger(name='mayan.apps.converter.backends')
+
         self._create_email_source()
         self.source.store_body = False
         self.source.save()
@@ -185,6 +174,9 @@ class EmailFilenameDecodingTestCase(BaseTestCase):
         self.assertEqual(1, Document.objects.count())
 
     def test_document_upload_with_body(self):
+        # Silence expected errors in other apps
+        self._silence_logger(name='mayan.apps.converter.backends')
+
         self._create_email_source()
 
         EmailBaseModel.process_message(
@@ -195,8 +187,9 @@ class EmailFilenameDecodingTestCase(BaseTestCase):
         self.assertEqual(2, Document.objects.count())
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class POP3SourceTestCase(GenericDocumentTestCase):
-class POP3SourceTestCase(BaseTestCase):
+    auto_upload_document = False
+
     class MockMailbox(object):
         def dele(self, which):
             return
@@ -221,21 +214,11 @@ class POP3SourceTestCase(BaseTestCase):
         def user(self, username):
             return
 
-    def setUp(self):
-        super(POP3SourceTestCase, self).setUp()
-        self.document_type = DocumentType.objects.create(
-            label=TEST_DOCUMENT_TYPE_LABEL
-        )
-
-    def tearDown(self):
-        self.document_type.delete()
-        super(POP3SourceTestCase, self).tearDown()
-
     @mock.patch('poplib.POP3_SSL')
     def test_download_document(self, mock_poplib):
         mock_poplib.return_value = POP3SourceTestCase.MockMailbox()
         self.source = POP3Email.objects.create(
-            document_type=self.document_type, label='', host='', password='',
+            document_type=self.test_document_type, label='', host='', password='',
             username=''
         )
 
@@ -245,13 +228,12 @@ class POP3SourceTestCase(BaseTestCase):
         )
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class WatchFolderTestCase(GenericDocumentTestCase):
-class WatchFolderTestCase(DocumentTestMixin, BaseTestCase):
     auto_upload_document = False
 
     def _create_watchfolder(self):
         return WatchFolderSource.objects.create(
-            document_type=self.document_type,
+            document_type=self.test_document_type,
             folder_path=self.temporary_directory,
             include_subdirectories=False,
             uncompress=SOURCE_UNCOMPRESS_CHOICE_Y

mayan/apps/sources/tests/test_views.py

@@ -3,16 +3,14 @@ from __future__ import unicode_literals
 import os
 import shutil
 
-from django.test import override_settings
-
 from mayan.apps.checkouts.models import NewVersionBlock
 from mayan.apps.common.tests import GenericViewTestCase
-from mayan.apps.documents.models import Document, DocumentType
+from mayan.apps.documents.models import Document
 from mayan.apps.documents.permissions import permission_document_create
 from mayan.apps.documents.tests import (
     GenericDocumentViewTestCase, TEST_COMPRESSED_DOCUMENT_PATH,
-    TEST_DOCUMENT_DESCRIPTION, TEST_DOCUMENT_TYPE_LABEL,
+    TEST_DOCUMENT_DESCRIPTION, TEST_SMALL_DOCUMENT_CHECKSUM,
-    TEST_SMALL_DOCUMENT_CHECKSUM, TEST_SMALL_DOCUMENT_PATH,
+    TEST_SMALL_DOCUMENT_PATH,
 )
 from mayan.apps.storage.utils import fs_cleanup, mkdtemp
 
@@ -30,6 +28,8 @@ from .literals import (
 
 
 class DocumentUploadTestCase(GenericDocumentViewTestCase):
+    auto_upload_document = False
+
     def setUp(self):
         super(DocumentUploadTestCase, self).setUp()
         self.source = WebFormSource.objects.create(
@@ -37,17 +37,15 @@ class DocumentUploadTestCase(GenericDocumentViewTestCase):
             uncompress=TEST_SOURCE_UNCOMPRESS_N
         )
 
-        self.document.delete()
-        self.login_user()
-
     def _request_upload_wizard_view(self, document_path=TEST_SMALL_DOCUMENT_PATH):
         with open(document_path, mode='rb') as file_object:
             return self.post(
-                viewname='sources:upload_interactive', args=(self.source.pk,),
+                viewname='sources:upload_interactive', kwargs={
-                data={
+                    'source_id': self.source.pk
+                }, data={
                     'source-file': file_object,
                     'document_type_id': self.document_type.pk,
-                }, follow=True
+                }
             )
 
     def test_upload_compressed_file(self):
@@ -57,9 +55,12 @@ class DocumentUploadTestCase(GenericDocumentViewTestCase):
         self.grant_access(
             obj=self.document_type, permission=permission_document_create
         )
-        self._request_upload_wizard_view(
+
+        response = self._request_upload_wizard_view(
             document_path=TEST_COMPRESSED_DOCUMENT_PATH
         )
+        self.assertEqual(response.status_code, 302)
+
         self.assertEqual(Document.objects.count(), 2)
         self.assertTrue(
             'first document.pdf' in Document.objects.values_list(
@@ -75,14 +76,15 @@ class DocumentUploadTestCase(GenericDocumentViewTestCase):
     def test_upload_wizard_without_permission(self):
         response = self._request_upload_wizard_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(Document.objects.count(), 0)
 
     def test_upload_wizard_with_permission(self):
         self.grant_permission(permission=permission_document_create)
 
         response = self._request_upload_wizard_view()
+        self.assertEqual(response.status_code, 302)
 
-        self.assertTrue(b'queued' in response.content)
         self.assertEqual(Document.objects.count(), 1)
         self.assertEqual(
             Document.objects.first().checksum, TEST_SMALL_DOCUMENT_CHECKSUM
@@ -101,14 +103,15 @@ class DocumentUploadTestCase(GenericDocumentViewTestCase):
 
         with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
             response = self.post(
-                viewname='sources:upload_interactive', args=(self.source.pk,),
+                viewname='sources:upload_interactive', kwargs={
-                data={
+                    'source_id': self.source.pk
+                }, data={
                     'source-file': file_object,
                     'document_type_id': self.document_type.pk,
-                }, follow=True
+                }
             )
+        self.assertEqual(response.status_code, 302)
 
-        self.assertTrue(b'queued' in response.content)
         self.assertEqual(Document.objects.count(), 1)
 
     def _request_upload_interactive_view(self):
@@ -132,25 +135,18 @@ class DocumentUploadTestCase(GenericDocumentViewTestCase):
         )
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class DocumentUploadIssueTestCase(GenericDocumentViewTestCase):
-class DocumentUploadIssueTestCase(GenericViewTestCase):
+    auto_upload_document = False
-    def setUp(self):
+    auto_login_superuser = True
-        super(DocumentUploadIssueTestCase, self).setUp()
+    auto_login_user = False
-        self.document_type = DocumentType.objects.create(
+    create_test_case_superuser = True
-            label=TEST_DOCUMENT_TYPE_LABEL
+    create_test_case_user = False
-        )
-
-    def tearDown(self):
-        self.document_type.delete()
-        super(DocumentUploadIssueTestCase, self).tearDown()
 
     def test_issue_25(self):
-        self.login_admin_user()
-
         # Create new webform source
         self.post(
             viewname='sources:setup_source_create',
-            args=(SOURCE_CHOICE_WEB_FORM,),
+            kwargs={'source_type': SOURCE_CHOICE_WEB_FORM},
             data={'label': 'test', 'uncompress': 'n', 'enabled': True}
         )
         self.assertEqual(WebFormSource.objects.count(), 1)
@@ -161,7 +157,7 @@ class DocumentUploadIssueTestCase(GenericViewTestCase):
                 viewname='sources:upload_interactive', data={
                     'document-language': 'eng',
                     'source-file': file_descriptor,
-                    'document_type_id': self.document_type.pk
+                    'document_type_id': self.test_document_type.pk
                 }
             )
         self.assertEqual(Document.objects.count(), 1)
@@ -189,6 +185,11 @@ class DocumentUploadIssueTestCase(GenericViewTestCase):
 
 
 class NewDocumentVersionViewTestCase(GenericDocumentViewTestCase):
+    auto_login_superuser = True
+    auto_login_user = False
+    create_test_case_superuser = True
+    create_test_case_user = False
+
     def test_new_version_block(self):
         """
         Gitlab issue #231
@@ -199,9 +200,7 @@ class NewDocumentVersionViewTestCase(GenericDocumentViewTestCase):
             - Link to upload version view should not resolve
             - Upload version view should reject request
         """
-        self.login_admin_user()
+        NewVersionBlock.objects.block(self.test_document)
-
-        NewVersionBlock.objects.block(self.document)
 
         response = self.post(
             viewname='sources:upload_version', args=(self.document.pk,),
@@ -232,7 +231,6 @@ class StagingFolderViewTestCase(GenericViewTestCase):
         shutil.copy(TEST_SMALL_DOCUMENT_PATH, self.temporary_directory)
 
         self.filename = os.path.basename(TEST_SMALL_DOCUMENT_PATH)
-        self.login_user()
 
     def tearDown(self):
         fs_cleanup(self.temporary_directory)
@@ -285,10 +283,6 @@ class StagingFolderViewTestCase(GenericViewTestCase):
 
 
 class SourcesTestCase(GenericDocumentViewTestCase):
-    def setUp(self):
-        super(SourcesTestCase, self).setUp()
-        self.login_user()
-
     def _create_web_source(self):
         self.source = WebFormSource.objects.create(
             enabled=True, label=TEST_SOURCE_LABEL,
@@ -344,8 +338,8 @@ class SourcesTestCase(GenericDocumentViewTestCase):
 
     def _request_setup_source_delete_view(self):
         return self.post(
-            args=(self.source.pk,),
+            viewname='sources:setup_source_delete',
-            viewname='sources:setup_source_delete'
+            kwargs={'pk': self.source.pk}
         )
 
     def test_source_delete_view_with_permission(self):
@@ -356,6 +350,7 @@ class SourcesTestCase(GenericDocumentViewTestCase):
 
         response = self._request_setup_source_delete_view()
         self.assertEqual(response.status_code, 302)
+
         self.assertEqual(WebFormSource.objects.count(), 0)
 
     def test_source_delete_view_no_permission(self):
@@ -365,4 +360,5 @@ class SourcesTestCase(GenericDocumentViewTestCase):
 
         response = self._request_setup_source_delete_view()
         self.assertEqual(response.status_code, 403)
+
         self.assertEqual(WebFormSource.objects.count(), 1)

mayan/apps/tags/tests/mixins.py

@@ -3,18 +3,88 @@ from __future__ import unicode_literals
 from ..models import Tag
 
 from .literals import (
-    TEST_TAG_COLOR, TEST_TAG_COLOR_EDITED, TEST_TAG_LABEL,
+    TEST_TAG_COLOR, TEST_TAG_COLOR_EDITED, TEST_TAG_LABEL, TEST_TAG_LABEL_2,
     TEST_TAG_LABEL_EDITED
 )
 
 
+class TagAPIViewTestMixin(object):
+    def _request_test_tag_create_api_view(self):
+        return self.post(
+            viewname='rest_api:tag-list', data={
+                'label': TEST_TAG_LABEL, 'color': TEST_TAG_COLOR
+            }
+        )
+
+    def _request_test_tag_delete_api_view(self):
+        return self.delete(
+            viewname='rest_api:tag-detail', kwargs={'pk': self.test_tag.pk}
+        )
+
+    def _request_tag_edit_view(self, extra_data=None, verb='patch'):
+        data = {
+            'label': TEST_TAG_LABEL_EDITED,
+            'color': TEST_TAG_COLOR_EDITED
+        }
+
+        if extra_data:
+            data.update(extra_data)
+
+        return getattr(self, verb)(
+            viewname='rest_api:tag-detail', args=(self.test_tag.pk,),
+            data=data
+        )
+
+    def _request_test_tag_document_list_api_view(self):
+        return self.get(
+            viewname='rest_api:tag-document-list', kwargs={
+                'pk': self.test_tag.pk
+            }
+        )
+
+    def _request_test_document_attach_tag_api_view(self):
+        return self.post(
+            viewname='rest_api:document-tag-list', kwargs={
+                'document_pk': self.test_document.pk
+            }, data={'tag_pk': self.test_tag.pk}
+        )
+
+    def _request_test_document_tag_detail_api_view(self):
+        return self.get(
+            viewname='rest_api:document-tag-detail', kwargs={
+                'document_pk': self.test_document.pk, 'pk': self.test_tag.pk
+            }
+        )
+
+    def _request_test_document_tag_list_view(self):
+        return self.get(
+            viewname='rest_api:document-tag-list', kwargs={
+                'document_pk': self.test_document.pk
+            }
+        )
+
+    def _request_test_document_tag_remove_view(self):
+        return self.delete(
+            viewname='rest_api:document-tag-detail', kwargs={
+                'document_pk': self.test_document.pk, 'pk': self.test_tag.pk
+            }
+        )
+
+
 class TagTestMixin(object):
-    def _create_tag(self):
+    def _create_test_tag(self):
-        self.tag = Tag.objects.create(
+        self.test_tag = Tag.objects.create(
             color=TEST_TAG_COLOR, label=TEST_TAG_LABEL
         )
 
-    def _request_tag_create_view(self):
+    def _create_test_tag_2(self):
+        self.test_tag_2 = Tag.objects.create(
+            color=TEST_TAG_COLOR, label=TEST_TAG_LABEL_2
+        )
+
+
+class TagViewTestMixin(object):
+    def _request_test_tag_create_view(self):
         return self.post(
             viewname='tags:tag_create', data={
                 'label': TEST_TAG_LABEL,
@@ -22,14 +92,57 @@ class TagTestMixin(object):
             }
         )
 
-    def _request_tag_delete_view(self):
+    def _request_test_tag_delete_view(self):
         return self.post(
-            viewname='tags:tag_delete', args=(self.tag.pk,)
+            viewname='tags:tag_delete', kwargs={'pk': self.test_tag.pk}
         )
 
-    def _request_tag_edit_view(self):
+    def _request_test_tag_delete_multiple_view(self):
         return self.post(
-            viewname='tags:tag_edit', args=(self.tag.pk,), data={
+            viewname='tags:tag_multiple_delete',
+            data={'id_list': self.test_tag.pk},
+        )
+
+    def _request_test_tag_edit_view(self):
+        return self.post(
+            viewname='tags:tag_edit', kwargs={'pk': self.test_tag.pk}, data={
                 'label': TEST_TAG_LABEL_EDITED, 'color': TEST_TAG_COLOR_EDITED
             }
         )
+
+    def _request_test_tag_document_list_view(self):
+        return self.get(viewname='documents:document_list')
+
+    def _request_test_document_tag_attach_view(self):
+        return self.post(
+            viewname='tags:tag_attach', kwargs={'pk': self.test_document.pk},
+            data={
+                'tags': self.test_tag.pk,
+                'user': self._test_case_user.pk
+            }
+        )
+
+    def _request_test_document_multiple_tag_multiple_attach_view(self):
+        return self.post(
+            viewname='tags:multiple_documents_tag_attach', data={
+                'id_list': self.test_document.pk, 'tags': self.test_tag.pk,
+                'user': self._test_case_user.pk
+            }
+        )
+
+    def _request_test_document_tag_multiple_remove_view(self):
+        return self.post(
+            viewname='tags:single_document_multiple_tag_remove',
+            kwargs={'pk': self.test_document.pk}, data={
+                'tags': self.test_tag.pk,
+            }
+        )
+
+    def _request_test_document_multiple_tag_remove_view(self):
+        return self.post(
+            viewname='tags:multiple_documents_selection_tag_remove',
+            data={
+                'id_list': self.test_document.pk,
+                'tags': self.test_tag.pk,
+            }
+        )

mayan/apps/tags/tests/test_events.py

@@ -2,68 +2,68 @@ from __future__ import unicode_literals
 
 from actstream.models import Action
 
-from mayan.apps.documents.tests import GenericDocumentViewTestCase
+from mayan.apps.common.tests import GenericViewTestCase
 
 from ..events import event_tag_created, event_tag_edited
 from ..models import Tag
 from ..permissions import permission_tag_create, permission_tag_edit
 
-from .mixins import TagTestMixin
+from .mixins import TagTestMixin, TagViewTestMixin
 
 
-class TagEventsTestCase(TagTestMixin, GenericDocumentViewTestCase):
+class TagEventsTestCase(TagTestMixin, TagViewTestMixin, GenericViewTestCase):
-    def setUp(self):
-        super(TagEventsTestCase, self).setUp()
-        self.login_user()
-
     def test_tag_create_event_no_permissions(self):
-        Action.objects.all().delete()
+        action_count = Action.objects.count()
 
-        response = self._request_tag_create_view()
+        response = self._request_test_tag_create_view()
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(Action.objects.count(), 0)
+
+        self.assertEqual(Action.objects.count(), action_count)
 
     def test_tag_create_event_with_permissions(self):
-        Action.objects.all().delete()
-
         self.grant_permission(permission=permission_tag_create)
 
-        response = self._request_tag_create_view()
+        action_count = Action.objects.count()
 
+        response = self._request_test_tag_create_view()
         self.assertEqual(response.status_code, 302)
 
+        self.assertEqual(Action.objects.count(), action_count + 1)
+
         event = Action.objects.first()
 
         tag = Tag.objects.first()
 
         self.assertEqual(event.verb, event_tag_created.id)
         self.assertEqual(event.target, tag)
-        self.assertEqual(event.actor, self.user)
+        self.assertEqual(event.actor, self._test_case_user)
 
     def test_tag_edit_event_no_permissions(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        Action.objects.all().delete()
+        action_count = Action.objects.count()
 
-        response = self._request_tag_edit_view()
+        response = self._request_test_tag_edit_view()
         self.assertEqual(response.status_code, 403)
-        self.assertEqual(Action.objects.count(), 0)
+
+        self.assertEqual(Action.objects.count(), action_count)
 
     def test_tag_edit_event_with_access(self):
-        self._create_tag()
+        self._create_test_tag()
-
-        Action.objects.all().delete()
 
         self.grant_access(
-            permission=permission_tag_edit, obj=self.tag
+            obj=self.test_tag, permission=permission_tag_edit
         )
 
-        response = self._request_tag_edit_view()
+        action_count = Action.objects.count()
 
+        response = self._request_test_tag_edit_view()
         self.assertEqual(response.status_code, 302)
 
+        self.assertEqual(Action.objects.count(), action_count + 1)
+
         event = Action.objects.first()
 
         self.assertEqual(event.verb, event_tag_edited.id)
-        self.assertEqual(event.target, self.tag)
+        self.assertEqual(event.target, self.test_tag)
-        self.assertEqual(event.actor, self.user)
+        self.assertEqual(event.actor, self._test_case_user)

mayan/apps/tags/tests/test_indexing.py

@@ -1,56 +1,50 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.documents.tests import DocumentTestMixin
 from mayan.apps.document_indexing.models import Index, IndexInstanceNode
 from mayan.apps.document_indexing.tests.literals import TEST_INDEX_LABEL
 
-from ..models import Tag
-
 from .literals import (
-    TEST_TAG_COLOR, TEST_TAG_LABEL, TEST_TAG_INDEX_HAS_TAG,
+    TEST_TAG_INDEX_HAS_TAG, TEST_TAG_INDEX_NO_TAG, TEST_TAG_INDEX_NODE_TEMPLATE
-    TEST_TAG_INDEX_NO_TAG, TEST_TAG_INDEX_NODE_TEMPLATE
 )
+from .mixins import TagTestMixin
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class TagSignalIndexingTestCase(DocumentTestMixin, TagTestMixin, BaseTestCase):
-class TagSignalIndexingTestCase(DocumentTestMixin, BaseTestCase):
     auto_upload_document = False
 
     def test_tag_indexing(self):
-        index = Index.objects.create(label=TEST_INDEX_LABEL)
+        self._create_test_tag()
+        self.test_index = Index.objects.create(label=TEST_INDEX_LABEL)
+        self.test_index.document_types.add(self.test_document_type)
 
-        index.document_types.add(self.document_type)
+        root = self.test_index.template_root
-
+        self.test_index.node_templates.create(
-        root = index.template_root
-        index.node_templates.create(
             parent=root, expression=TEST_TAG_INDEX_NODE_TEMPLATE,
             link_documents=True
         )
 
-        tag = Tag.objects.create(color=TEST_TAG_COLOR, label=TEST_TAG_LABEL)
+        self.upload_document()
-        self.document = self.upload_document()
 
         self.assertTrue(
-            self.document in IndexInstanceNode.objects.get(
+            self.test_document in IndexInstanceNode.objects.get(
                 value=TEST_TAG_INDEX_NO_TAG
             ).documents.all()
         )
 
-        tag.documents.add(self.document)
+        self.test_tag.documents.add(self.test_document)
 
         self.assertTrue(
-            self.document in IndexInstanceNode.objects.get(
+            self.test_document in IndexInstanceNode.objects.get(
                 value=TEST_TAG_INDEX_HAS_TAG
             ).documents.all()
         )
 
-        tag.delete()
+        self.test_tag.delete()
 
         self.assertTrue(
-            self.document in IndexInstanceNode.objects.get(
+            self.test_document in IndexInstanceNode.objects.get(
                 value=TEST_TAG_INDEX_NO_TAG
             ).documents.all()
         )

mayan/apps/tags/tests/test_models.py

@@ -1,31 +1,26 @@
 from __future__ import unicode_literals
 
-from django.test import override_settings
-
 from mayan.apps.common.tests import BaseTestCase
 from mayan.apps.documents.tests import DocumentTestMixin
 
-from ..models import Tag
+from .mixins import TagTestMixin
-
-from .literals import TEST_TAG_COLOR, TEST_TAG_LABEL
 
 
-@override_settings(OCR_AUTO_OCR=False)
+class TagTestCase(DocumentTestMixin, TagTestMixin, BaseTestCase):
-class TagTestCase(DocumentTestMixin, BaseTestCase):
     auto_upload_document = False
 
-    def test_addition_and_deletion_of_documents(self):
+    def test_document_addition(self):
-        tag = Tag.objects.create(color=TEST_TAG_COLOR, label=TEST_TAG_LABEL)
+        self._create_test_tag()
-        self.document = self.upload_document()
+        self.test_document = self.upload_document()
 
-        tag.documents.add(self.document)
+        self.test_tag.documents.add(self.test_document)
 
-        self.assertEqual(tag.documents.count(), 1)
+        self.assertTrue(self.test_document in self.test_tag.documents.all())
-        self.assertEqual(list(tag.documents.all()), [self.document])
 
-        tag.documents.remove(self.document)
+    def test_document_remove(self):
+        self._create_test_tag()
+        self.test_document = self.upload_document()
 
-        self.assertEqual(tag.documents.count(), 0)
+        self.test_tag.documents.remove(self.test_document)
-        self.assertEqual(list(tag.documents.all()), [])
 
-        tag.delete()
+        self.assertTrue(self.test_document not in self.test_tag.documents.all())

mayan/apps/tags/tests/test_views.py

@@ -1,5 +1,6 @@
 from __future__ import unicode_literals
 
+from mayan.apps.common.tests import GenericViewTestCase
 from mayan.apps.documents.permissions import permission_document_view
 from mayan.apps.documents.tests import GenericDocumentViewTestCase
 
@@ -9,290 +10,285 @@ from ..permissions import (
     permission_tag_edit, permission_tag_remove, permission_tag_view
 )
 
-from .literals import (
+from .mixins import TagTestMixin, TagViewTestMixin
-    TEST_TAG_COLOR, TEST_TAG_COLOR_EDITED, TEST_TAG_LABEL,
-    TEST_TAG_LABEL_EDITED
-)
 
 
-class TagViewTestCase(GenericDocumentViewTestCase):
+class TagViewTestCase(TagTestMixin, TagViewTestMixin, GenericViewTestCase):
-    def setUp(self):
-        super(TagViewTestCase, self).setUp()
-        self.login_user()
-
-    def _create_tag(self):
-        self.tag = Tag.objects.create(
-            color=TEST_TAG_COLOR, label=TEST_TAG_LABEL
-        )
-
-    def _request_create_tag_view(self):
-        return self.post(
-            viewname='tags:tag_create', data={
-                'label': TEST_TAG_LABEL,
-                'color': TEST_TAG_COLOR
-            }
-        )
-
     def test_tag_create_view_no_permissions(self):
-        response = self._request_create_tag_view()
+        tag_count = Tag.objects.count()
+
+        response = self._request_test_tag_create_view()
         self.assertEqual(response.status_code, 403)
 
-        self.assertEqual(Tag.objects.count(), 0)
+        self.assertEqual(Tag.objects.count(), tag_count)
 
     def test_tag_create_view_with_permissions(self):
         self.grant_permission(permission=permission_tag_create)
 
-        response = self._request_create_tag_view()
+        tag_count = Tag.objects.count()
+
+        response = self._request_test_tag_create_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(Tag.objects.count(), 1)
+        self.assertEqual(Tag.objects.count(), tag_count + 1)
-        tag = Tag.objects.first()
-        self.assertEqual(tag.label, TEST_TAG_LABEL)
-        self.assertEqual(tag.color, TEST_TAG_COLOR)
-
-    def _request_delete_tag_view(self):
-        return self.post(
-            viewname='tags:tag_delete', args=(self.tag.pk,)
-        )
 
     def test_tag_delete_view_no_permissions(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        response = self._request_delete_tag_view()
+        tag_count = Tag.objects.count()
+
+        response = self._request_test_tag_delete_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(Tag.objects.count(), 1)
+        self.assertEqual(Tag.objects.count(), tag_count)
 
     def test_tag_delete_view_with_access(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.grant_access(obj=self.tag, permission=permission_tag_delete)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_delete)
 
-        response = self._request_delete_tag_view()
+        tag_count = Tag.objects.count()
+
+        response = self._request_test_tag_delete_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(Tag.objects.count(), 0)
+        self.assertEqual(Tag.objects.count(), tag_count - 1)
-
-    def _request_multiple_delete_view(self):
-        return self.post(
-            viewname='tags:tag_multiple_delete',
-            data={'id_list': self.tag.pk},
-        )
 
     def test_tag_multiple_delete_view_no_permissions(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        response = self._request_multiple_delete_view()
+        tag_count = Tag.objects.count()
+
+        response = self._request_test_tag_delete_multiple_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(Tag.objects.count(), 1)
+        self.assertEqual(Tag.objects.count(), tag_count)
 
     def test_tag_multiple_delete_view_with_access(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.grant_access(obj=self.tag, permission=permission_tag_delete)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_delete)
 
-        response = self._request_multiple_delete_view()
+        tag_count = Tag.objects.count()
+
+        response = self._request_test_tag_delete_multiple_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(Tag.objects.count(), 0)
+        self.assertEqual(Tag.objects.count(), tag_count - 1)
-
-    def _request_edit_tag_view(self):
-        return self.post(
-            viewname='tags:tag_edit', args=(self.tag.pk,), data={
-                'label': TEST_TAG_LABEL_EDITED, 'color': TEST_TAG_COLOR_EDITED
-            }
-        )
 
     def test_tag_edit_view_no_permissions(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        response = self._request_edit_tag_view()
+        tag_label = self.test_tag.label
+
+        response = self._request_test_tag_edit_view()
         self.assertEqual(response.status_code, 403)
 
-        tag = Tag.objects.get(pk=self.tag.pk)
+        self.test_tag.refresh_from_db()
-        self.assertEqual(tag.label, TEST_TAG_LABEL)
+        self.assertEqual(self.test_tag.label, tag_label)
-        self.assertEqual(tag.color, TEST_TAG_COLOR)
 
     def test_tag_edit_view_with_access(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.grant_access(obj=self.tag, permission=permission_tag_edit)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_edit)
 
-        response = self._request_edit_tag_view()
+        tag_label = self.test_tag.label
+
+        response = self._request_test_tag_edit_view()
         self.assertEqual(response.status_code, 302)
 
-        tag = Tag.objects.get(pk=self.tag.pk)
+        self.test_tag.refresh_from_db()
-        self.assertEqual(tag.label, TEST_TAG_LABEL_EDITED)
+        self.assertNotEqual(self.test_tag.label, tag_label)
-        self.assertEqual(tag.color, TEST_TAG_COLOR_EDITED)
 
-    def _request_document_list_view(self):
-        return self.get(viewname='documents:document_list')
 
+class TagDocumentViewTestCase(TagTestMixin, TagViewTestMixin, GenericDocumentViewTestCase):
     def test_document_tags_widget_no_permissions(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.tag.documents.add(self.document)
+        self.test_tag.documents.add(self.test_document)
-        response = self._request_document_list_view()
+
+        response = self._request_test_tag_document_list_view()
         self.assertNotContains(
-            response=response, text=TEST_TAG_LABEL, status_code=200
+            response=response, text=self.test_tag.label, status_code=200
         )
 
-    def test_document_tags_widget_with_access(self):
+    def test_document_tags_widget_with_tag_access(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.tag.documents.add(self.document)
+        self.test_tag.documents.add(self.test_document)
 
-        self.grant_access(obj=self.tag, permission=permission_tag_view)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_view)
         self.grant_access(
             obj=self.document, permission=permission_document_view
         )
 
-        response = self._request_document_list_view()
+        response = self._request_test_tag_document_list_view()
         self.assertContains(
-            response=response, text=TEST_TAG_LABEL, status_code=200
+            response=response, text=self.test_tag.label, status_code=200
-        )
-
-    def _request_attach_tag_view(self):
-        return self.post(
-            viewname='tags:tag_attach', args=(self.document.pk,), data={
-                'tags': self.tag.pk,
-                'user': self.user.pk
-            }
         )
 
     def test_document_attach_tag_view_no_permission(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.assertEqual(self.document.tags.count(), 0)
+        response = self._request_test_document_tag_attach_view()
+        # Show same view with a warning message that ID XX is not one of the
+        # available choices.
+        self.assertEqual(response.status_code, 200)
 
-        self.grant_access(obj=self.tag, permission=permission_tag_attach)
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())
 
-        response = self._request_attach_tag_view()
+    def test_document_attach_tag_view_with_tag_access(self):
-        # Redirect to previous URL and show warning message about having to
+        self._create_test_tag()
-        # select at least one object.
-        self.assertEqual(response.status_code, 302)
-        self.assertEqual(self.document.tags.count(), 0)
 
-    def test_document_attach_tag_view_with_access(self):
+        self.grant_access(obj=self.test_tag, permission=permission_tag_attach)
-        self._create_tag()
 
-        self.assertEqual(self.document.tags.count(), 0)
+        response = self._request_test_document_tag_attach_view()
-
-        self.grant_access(obj=self.document, permission=permission_tag_attach)
-        self.grant_access(obj=self.tag, permission=permission_tag_attach)
-        # permission_tag_view is needed because the form filters the
-        # choices
-        self.grant_access(obj=self.tag, permission=permission_tag_view)
-
-        response = self._request_attach_tag_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertQuerysetEqual(
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())
-            self.document.tags.all(), (repr(self.tag),)
-        )
 
-    def _request_multiple_attach_tag_view(self):
+    def test_document_attach_tag_view_with_document_access(self):
-        return self.post(
+        self._create_test_tag()
-            viewname='tags:multiple_documents_tag_attach', data={
+
-                'id_list': self.document.pk, 'tags': self.tag.pk,
+        self.grant_access(obj=self.test_document, permission=permission_tag_attach)
-                'user': self.user.pk
+
-            }
+        response = self._request_test_document_tag_attach_view()
-        )
+        self.assertEqual(response.status_code, 200)
+
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())
+
+    def test_document_attach_tag_view_with_full_access(self):
+        self._create_test_tag()
+
+        self.grant_access(obj=self.test_document, permission=permission_tag_attach)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_attach)
+
+        response = self._request_test_document_tag_attach_view()
+        self.assertEqual(response.status_code, 302)
+
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
 
     def test_document_multiple_attach_tag_view_no_permission(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.grant_permission(permission=permission_tag_view)
+        response = self._request_test_document_multiple_tag_multiple_attach_view()
-
-        response = self._request_multiple_attach_tag_view()
         self.assertEqual(response.status_code, 200)
 
-        self.assertEqual(self.document.tags.count(), 0)
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())
 
-    def test_document_multiple_attach_tag_view_with_access(self):
+    def test_document_multiple_attach_tag_view_with_tag_access(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.grant_access(obj=self.document, permission=permission_tag_attach)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_attach)
-        self.grant_access(obj=self.tag, permission=permission_tag_attach)
 
-        # permission_tag_view is needed because the form filters the
+        response = self._request_test_document_multiple_tag_multiple_attach_view()
-        # choices
-        self.grant_access(obj=self.tag, permission=permission_tag_view)
-
-        response = self._request_multiple_attach_tag_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertQuerysetEqual(
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())
-            self.document.tags.all(), (repr(self.tag),)
-        )
 
-    def _request_single_document_multiple_tag_remove_view(self):
+    def test_document_multiple_attach_tag_view_with_document_access(self):
-        return self.post(
+        self._create_test_tag()
-            viewname='tags:single_document_multiple_tag_remove',
-            args=(self.document.pk,), data={
-                'id_list': self.document.pk,
-                'tags': self.tag.pk,
-            }
-        )
 
-    def test_single_document_multiple_tag_remove_view_no_permissions(self):
+        self.grant_access(obj=self.test_document, permission=permission_tag_attach)
-        self._create_tag()
 
-        self.document.tags.add(self.tag)
+        response = self._request_test_document_multiple_tag_multiple_attach_view()
-
-        self.grant_access(obj=self.tag, permission=permission_tag_view)
-
-        response = self._request_single_document_multiple_tag_remove_view()
         self.assertEqual(response.status_code, 200)
 
-        self.assertQuerysetEqual(self.document.tags.all(), (repr(self.tag),))
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())
 
-    def test_single_document_multiple_tag_remove_view_with_access(self):
+    def test_document_multiple_attach_tag_view_with_full_access(self):
-        self._create_tag()
+        self._create_test_tag()
 
-        self.document.tags.add(self.tag)
+        self.grant_access(obj=self.test_document, permission=permission_tag_attach)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_attach)
 
-        self.grant_access(obj=self.document, permission=permission_tag_remove)
+        response = self._request_test_document_multiple_tag_multiple_attach_view()
-        self.grant_access(obj=self.tag, permission=permission_tag_remove)
-        self.grant_access(obj=self.tag, permission=permission_tag_view)
-
-        response = self._request_single_document_multiple_tag_remove_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(self.document.tags.count(), 0)
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
 
-    def _request_multiple_documents_selection_tag_remove_view(self):
+    def test_document_tag_multiple_remove_view_no_permissions(self):
-        return self.post(
+        self._create_test_tag()
-            viewname='tags:multiple_documents_selection_tag_remove',
+        self.test_document.tags.add(self.test_tag)
-            data={
-                'id_list': self.document.pk,
-                'tags': self.tag.pk,
-            }
-        )
 
-    def test_multiple_documents_selection_tag_remove_view_no_permissions(self):
+        response = self._request_test_document_tag_multiple_remove_view()
-        self._create_tag()
-
-        self.document.tags.add(self.tag)
-
-        self.grant_access(obj=self.tag, permission=permission_tag_view)
-
-        response = self._request_multiple_documents_selection_tag_remove_view()
         self.assertEqual(response.status_code, 200)
 
-        self.assertQuerysetEqual(self.document.tags.all(), (repr(self.tag),))
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
 
-    def test_multiple_documents_selection_tag_remove_view_with_access(self):
+    def test_document_tag_multiple_remove_view_with_tag_access(self):
-        self._create_tag()
+        self._create_test_tag()
+        self.test_document.tags.add(self.test_tag)
 
-        self.document.tags.add(self.tag)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_remove)
 
-        self.grant_access(obj=self.document, permission=permission_tag_remove)
+        response = self._request_test_document_tag_multiple_remove_view()
-        self.grant_access(obj=self.tag, permission=permission_tag_remove)
-        self.grant_access(obj=self.tag, permission=permission_tag_view)
-
-        response = self._request_multiple_documents_selection_tag_remove_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertEqual(self.document.tags.count(), 0)
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
+
+    def test_document_tag_multiple_remove_view_with_document_access(self):
+        self._create_test_tag()
+        self.test_document.tags.add(self.test_tag)
+
+        self.grant_access(obj=self.test_document, permission=permission_tag_remove)
+
+        response = self._request_test_document_tag_multiple_remove_view()
+        self.assertEqual(response.status_code, 200)
+
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
+
+    def test_document_tag_multiple_remove_view_with_full_access(self):
+        self._create_test_tag()
+        self.test_document.tags.add(self.test_tag)
+
+        self.grant_access(obj=self.test_document, permission=permission_tag_remove)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_remove)
+
+        response = self._request_test_document_tag_multiple_remove_view()
+        self.assertEqual(response.status_code, 302)
+
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())
+
+    def test_document_multiple_tag_multiple_remove_view_no_permissions(self):
+        self._create_test_tag()
+        self.test_document.tags.add(self.test_tag)
+
+        response = self._request_test_document_multiple_tag_remove_view()
+        self.assertEqual(response.status_code, 200)
+
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
+
+    def test_document_multiple_tag_remove_view_with_tag_access(self):
+        self._create_test_tag()
+        self.test_document.tags.add(self.test_tag)
+
+        self.grant_access(obj=self.test_tag, permission=permission_tag_remove)
+
+        response = self._request_test_document_multiple_tag_remove_view()
+        self.assertEqual(response.status_code, 302)
+
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
+
+    def test_document_multiple_tag_remove_view_with_document_access(self):
+        self._create_test_tag()
+        self.test_document.tags.add(self.test_tag)
+
+        self.grant_access(obj=self.test_document, permission=permission_tag_remove)
+
+        response = self._request_test_document_multiple_tag_remove_view()
+        self.assertEqual(response.status_code, 200)
+
+        self.assertTrue(self.test_tag in self.test_document.tags.all())
+
+    def test_document_multiple_tag_remove_view_with_full_access(self):
+        self._create_test_tag()
+        self.test_document.tags.add(self.test_tag)
+
+        self.grant_access(obj=self.test_document, permission=permission_tag_remove)
+        self.grant_access(obj=self.test_tag, permission=permission_tag_remove)
+
+        response = self._request_test_document_multiple_tag_remove_view()
+        self.assertEqual(response.status_code, 302)
+
+        self.assertTrue(self.test_tag not in self.test_document.tags.all())

mayan/apps/tags/tests/test_wizard_steps.py

@@ -12,16 +12,15 @@ from mayan.apps.sources.tests.literals import (
 
 from ..models import Tag
 
-from .literals import TEST_TAG_COLOR, TEST_TAG_LABEL, TEST_TAG_LABEL_2
+from .mixins import TagTestMixin
 
 
-class TaggedDocumentUploadTestCase(GenericDocumentViewTestCase):
+class TaggedDocumentUploadTestCase(TagTestMixin, GenericDocumentViewTestCase):
     auto_upload_document = False
 
     def setUp(self):
         super(TaggedDocumentUploadTestCase, self).setUp()
-        self.login_user()
+        self.test_source = WebFormSource.objects.create(
-        self.source = WebFormSource.objects.create(
             enabled=True, label=TEST_SOURCE_LABEL,
             uncompress=TEST_SOURCE_UNCOMPRESS_N
         )
@@ -29,44 +28,37 @@ class TaggedDocumentUploadTestCase(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,),
+                viewname='sources:upload_interactive', kwargs={
-                data={
+                    'source_id': self.test_source.pk
-                    'document_type_id': self.document_type.pk,
+                }, data={
+                    'document_type_id': self.test_document_type.pk,
                     'source-file': file_object,
-                    'tags': ','.join(map(str, Tag.objects.values_list('pk', flat=True)))
+                    'tags': ','.join(
+                        map(str, Tag.objects.values_list('pk', flat=True))
+                    )
                 }
             )
 
-    def _create_tag(self):
-        self.tag = Tag.objects.create(
-            color=TEST_TAG_COLOR, label=TEST_TAG_LABEL
-        )
-
-    def _create_tag_2(self):
-        self.tag_2 = Tag.objects.create(
-            color=TEST_TAG_COLOR, label=TEST_TAG_LABEL_2
-        )
-
     def test_upload_interactive_view_with_access(self):
-        self._create_tag()
+        self._create_test_tag()
 
         self.grant_access(
-            permission=permission_document_create, obj=self.document_type
+            obj=self.document_type, permission=permission_document_create
         )
         response = self._request_upload_interactive_document_create_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertTrue(self.tag in Document.objects.first().tags.all())
+        self.assertTrue(self.test_tag in Document.objects.first().tags.all())
 
     def test_upload_interactive_multiple_tags_view_with_access(self):
-        self._create_tag()
+        self._create_test_tag()
-        self._create_tag_2()
+        self._create_test_tag_2()
 
         self.grant_access(
-            permission=permission_document_create, obj=self.document_type
+            obj=self.test_document_type, permission=permission_document_create
         )
         response = self._request_upload_interactive_document_create_view()
         self.assertEqual(response.status_code, 302)
 
-        self.assertTrue(self.tag in Document.objects.first().tags.all())
+        self.assertTrue(self.test_tag in Document.objects.first().tags.all())
-        self.assertTrue(self.tag_2 in Document.objects.first().tags.all())
+        self.assertTrue(self.test_tag_2 in Document.objects.first().tags.all())