matthias/mayan-edms
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Backport test improvements

Browse Source 
Signed-off-by: Roberto Rosario <roberto.rosario.gonzalez@gmail.com>
This commit is contained in:
Roberto Rosario
2019-04-20 02:39:57 -04:00
parent bfcad278aa
commit 0267c79b07
108 changed files with 5434 additions and 4685 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
mayan/apps/acls/tests/mixins.py
View File

@@ -1,37 +1,41 @@
from __future__ import unicode_literals
from django.contrib.auth import get_user_model
from django.contrib.auth.models import Group
from django.core.exceptions import ImproperlyConfigured
from mayan.apps.acls.models import AccessControlList
from mayan.apps.permissions.models import Role
from mayan.apps.permissions.tests.literals import TEST_ROLE_LABEL
from mayan.apps.permissions.tests.mixins import RoleTestCaseMixin
from mayan.apps.user_management.tests.literals import (
TEST_ADMIN_PASSWORD, TEST_ADMIN_USERNAME, TEST_ADMIN_EMAIL,
TEST_GROUP_NAME, TEST_USER_EMAIL, TEST_USER_USERNAME, TEST_USER_PASSWORD
from mayan.apps.permissions.tests.mixins import (
PermissionTestMixin, RoleTestCaseMixin, RoleTestMixin
)
from mayan.apps.user_management.tests.mixins import UserTestCaseMixin
class ACLTestCaseMixin(RoleTestCaseMixin):
class ACLTestCaseMixin(RoleTestCaseMixin, UserTestCaseMixin):
def setUp(self):
super(ACLTestCaseMixin, self).setUp()
self.admin_user = get_user_model().objects.create_superuser(
username=TEST_ADMIN_USERNAME, email=TEST_ADMIN_EMAIL,
password=TEST_ADMIN_PASSWORD
if hasattr(self, '_test_case_user'):
self._test_case_role.groups.add(self._test_case_group)
def grant_access(self, obj, permission):
if not hasattr(self, '_test_case_role'):
raise ImproperlyConfigured(
'Enable the creation of the test case user, group, and role '
'in order to enable the usage of ACLs in tests.'
)
self._test_case_acl = AccessControlList.objects.grant(
obj=obj, permission=permission, role=self._test_case_role
)
self.user = get_user_model().objects.create_user(
username=TEST_USER_USERNAME, email=TEST_USER_EMAIL,
password=TEST_USER_PASSWORD
class ACLTestMixin(PermissionTestMixin, RoleTestMixin):
auto_create_test_role = True
def _create_test_acl(self):
self.test_acl = AccessControlList.objects.create(
content_object=self.test_object, role=self.test_role
)
self.group = Group.objects.create(name=TEST_GROUP_NAME)
self.role = Role.objects.create(label=TEST_ROLE_LABEL)
self.group.user_set.add(self.user)
self.role.groups.add(self.group)
def grant_access(self, permission, obj):
AccessControlList.objects.grant(
permission=permission, role=self.role, obj=obj
)
def setUp(self):
super(ACLTestMixin, self).setUp()
if self.auto_create_test_role:
self._create_test_role()

17
mayan/apps/acls/tests/test_actions.py
View File

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

132
mayan/apps/acls/tests/test_api.py
View File

@@ -1,7 +1,6 @@
from __future__ import absolute_import, unicode_literals
from django.contrib.contenttypes.models import ContentType
from django.test import override_settings
from rest_framework import status
@@ -13,75 +12,69 @@ from mayan.apps.rest_api.tests import BaseAPITestCase
from ..models import AccessControlList
from ..permissions import permission_acl_view
from .mixins import ACLTestMixin
@override_settings(OCR_AUTO_OCR=False)
class ACLAPITestCase(DocumentTestMixin, BaseAPITestCase):
class ACLAPITestCase(ACLTestMixin, DocumentTestMixin, BaseAPITestCase):
def setUp(self):
super(ACLAPITestCase, self).setUp()
self.login_admin_user()
self.document_content_type = ContentType.objects.get_for_model(
self.document
self.test_document_content_type = ContentType.objects.get_for_model(
self.test_document
)
def _create_acl(self):
self.acl = AccessControlList.objects.create(
content_object=self.document,
role=self.role
)
self.acl.permissions.add(permission_document_view.stored_permission)
self.test_object = self.test_document
def test_object_acl_list_view(self):
self._create_acl()
self._create_test_acl()
self.grant_access(obj=self.test_object, permission=permission_acl_view)
response = self.get(
viewname='rest_api:accesscontrollist-list',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk
)
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data['results'][0]['content_type']['app_label'],
self.document_content_type.app_label
self.test_object_content_type.app_label
)
self.assertEqual(
response.data['results'][0]['role']['label'], TEST_ROLE_LABEL
response.data['results'][0]['role']['label'],
self.test_acl.role.label
)
def test_object_acl_delete_view(self):
self.expected_content_type = None
self._create_acl()
self._create_test_acl()
response = self.delete(
viewname='rest_api:accesscontrollist-detail',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk, self.acl.pk
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk, self.test_acl.pk
)
)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(AccessControlList.objects.count(), 0)
def test_object_acl_detail_view(self):
self._create_acl()
self._create_test_acl()
response = self.get(
viewname='rest_api:accesscontrollist-detail',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk, self.acl.pk
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk, self.test_acl.pk
)
)
self.assertEqual(
response.data['content_type']['app_label'],
self.document_content_type.app_label
self.test_document_content_type.app_label
)
self.assertEqual(
response.data['role']['label'], TEST_ROLE_LABEL
@@ -89,71 +82,70 @@ class ACLAPITestCase(DocumentTestMixin, BaseAPITestCase):
def test_object_acl_permission_delete_view(self):
self.expected_content_type = None
self._create_acl()
permission = self.acl.permissions.first()
self._create_test_acl()
self.test_acls.grant_permission(permission=permission_document_view)
permission = self.test_acl.permissions.first()
response = self.delete(
viewname='rest_api:accesscontrollist-permission-detail',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk, self.acl.pk,
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk, self.test_acl.pk,
permission.pk
)
)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(self.acl.permissions.count(), 0)
self.assertEqual(self.test_acl.permissions.count(), 0)
def test_object_acl_permission_detail_view(self):
self._create_acl()
permission = self.acl.permissions.first()
self._create_test_acl()
permission = self.test_acl.permissions.first()
response = self.get(
viewname='rest_api:accesscontrollist-permission-detail',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk, self.acl.pk,
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk, self.test_acl.pk,
permission.pk
)
)
self.assertEqual(
response.data['pk'], permission_document_view.pk
)
def test_object_acl_permission_list_view(self):
self._create_acl()
self._create_test_acl()
response = self.get(
viewname='rest_api:accesscontrollist-permission-list',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk, self.acl.pk
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk, self.test_acl.pk
)
)
self.assertEqual(
response.data['results'][0]['pk'],
permission_document_view.pk
)
def test_object_acl_permission_list_post_view(self):
self._create_acl()
self._create_test_acl()
response = self.post(
viewname='rest_api:accesscontrollist-permission-list',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk, self.acl.pk
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk, self.test_acl.pk
), data={'permission_pk': permission_acl_view.pk}
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertQuerysetEqual(
ordered=False, qs=self.acl.permissions.all(), values=(
ordered=False, qs=self.test_acl.permissions.all(), values=(
repr(permission_document_view.stored_permission),
repr(permission_acl_view.stored_permission)
)
@@ -163,45 +155,45 @@ class ACLAPITestCase(DocumentTestMixin, BaseAPITestCase):
response = self.post(
viewname='rest_api:accesscontrollist-list',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk
), data={'role_pk': self.role.pk}
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk
), data={'role_pk': self.test_role.pk}
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(
self.document.acls.first().role, self.role
self.test_document.acls.first().role, self.test_role
)
self.assertEqual(
self.document.acls.first().content_object, self.document
self.test_document.acls.first().content_object, self.test_document
)
self.assertEqual(
self.document.acls.first().permissions.count(), 0
self.test_document.acls.first().permissions.count(), 0
)
def test_object_acl_post_with_permissions_added_view(self):
response = self.post(
viewname='rest_api:accesscontrollist-list',
args=(
self.document_content_type.app_label,
self.document_content_type.model,
self.document.pk
self.test_document_content_type.app_label,
self.test_document_content_type.model,
self.test_document.pk
), data={
'role_pk': self.role.pk,
'permissions_pk_list': permission_acl_view.pk
}
)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(
self.document.acls.first().content_object, self.document
self.test_document.acls.first().content_object, self.test_document
)
self.assertEqual(
self.document.acls.first().role, self.role
self.test_document.acls.first().role, self.role
)
self.assertEqual(
self.document.acls.first().permissions.first(),
self.test_document.acls.first().permissions.first(),
permission_acl_view.stored_permission
)

65
mayan/apps/acls/tests/test_links.py
View File

@@ -8,29 +8,28 @@ from mayan.apps.documents.tests import GenericDocumentViewTestCase
from ..links import (
link_acl_delete, link_acl_list, link_acl_create, link_acl_permissions
)
from ..models import AccessControlList
from ..permissions import permission_acl_edit, permission_acl_view
from .mixins import ACLTestMixin
class ACLsLinksTestCase(GenericDocumentViewTestCase):
class ACLsLinksTestCase(ACLTestMixin, GenericDocumentViewTestCase):
def setUp(self):
super(ACLsLinksTestCase, self).setUp()
self.login_user()
self.test_object = self.test_document
def test_document_acl_create_link(self):
acl = AccessControlList.objects.create(
content_object=self.document, role=self.role
self.grant_access(
obj=self.test_document, permission=permission_acl_edit
)
acl.permissions.add(permission_acl_edit.stored_permission)
self.add_test_view(test_object=self.document)
context = self.get_test_view()
resolved_link = link_acl_create.resolve(context=context)
self.assertNotEqual(resolved_link, None)
content_type = ContentType.objects.get_for_model(self.document)
content_type = ContentType.objects.get_for_model(self.test_document)
kwargs = {
'app_label': content_type.app_label,
'model': content_type.model,
@@ -38,63 +37,69 @@ class ACLsLinksTestCase(GenericDocumentViewTestCase):
}
self.assertEqual(
resolved_link.url, reverse('acls:acl_create', kwargs=kwargs)
resolved_link.url, reverse(
viewname=link_acl_create.view, kwargs=kwargs
)
)
def test_document_acl_delete_link(self):
acl = AccessControlList.objects.create(
content_object=self.document, role=self.role
self._create_test_acl()
self.grant_access(
obj=self.test_document, permission=permission_acl_edit
)
acl.permissions.add(permission_acl_edit.stored_permission)
self.add_test_view(test_object=acl)
self.add_test_view(test_object=self.test_acl)
context = self.get_test_view()
resolved_link = link_acl_delete.resolve(context=context)
self.assertNotEqual(resolved_link, None)
self.assertEqual(
resolved_link.url, reverse('acls:acl_delete', args=(acl.pk,))
resolved_link.url, reverse(
viewname=link_acl_delete.view, args=(self.test_acl.pk,)
)
)
def test_document_acl_edit_link(self):
acl = AccessControlList.objects.create(
content_object=self.document, role=self.role
self._create_test_acl()
self.grant_access(
obj=self.test_document, permission=permission_acl_edit
)
acl.permissions.add(permission_acl_edit.stored_permission)
self.add_test_view(test_object=acl)
self.add_test_view(test_object=self.test_acl)
context = self.get_test_view()
resolved_link = link_acl_permissions.resolve(context=context)
self.assertNotEqual(resolved_link, None)
self.assertEqual(
resolved_link.url, reverse('acls:acl_permissions', args=(acl.pk,))
resolved_link.url, reverse(
viewname=link_acl_permissions.view,
args=(self.test_acl.pk,)
)
)
def test_document_acl_list_link(self):
acl = AccessControlList.objects.create(
content_object=self.document, role=self.role
self.grant_access(
obj=self.test_document, permission=permission_acl_view
)
acl.permissions.add(permission_acl_view.stored_permission)
self.add_test_view(test_object=self.document)
self.add_test_view(test_object=self.test_document)
context = self.get_test_view()
resolved_link = link_acl_list.resolve(context=context)
self.assertNotEqual(resolved_link, None)
content_type = ContentType.objects.get_for_model(self.document)
content_type = ContentType.objects.get_for_model(self.test_document)
kwargs = {
'app_label': content_type.app_label,
'model': content_type.model,
'object_id': self.document.pk
'object_id': self.test_document.pk
}
self.assertEqual(
resolved_link.url, reverse('acls:acl_list', kwargs=kwargs)
resolved_link.url, reverse(
viewname=link_acl_list.view, kwargs=kwargs
)
)

79
mayan/apps/acls/tests/test_models.py
View File

@@ -1,7 +1,6 @@
from __future__ import absolute_import, unicode_literals
from django.core.exceptions import PermissionDenied
from django.test import override_settings
from mayan.apps.common.tests import BaseTestCase
from mayan.apps.documents.models import Document, DocumentType
@@ -13,9 +12,10 @@ from mayan.apps.documents.tests import (
from ..models import AccessControlList
from .mixins import ACLTestMixin
@override_settings(OCR_AUTO_OCR=False)
class PermissionTestCase(BaseTestCase):
class PermissionTestCase(ACLTestMixin, BaseTestCase):
def setUp(self):
super(PermissionTestCase, self).setUp()
self.document_type_1 = DocumentType.objects.create(
@@ -50,86 +50,79 @@ class PermissionTestCase(BaseTestCase):
with self.assertRaises(PermissionDenied):
AccessControlList.objects.check_access(
permissions=(permission_document_view,),
user=self.user, obj=self.document_1
user=self._test_case_user, obj=self.document_1
)
def test_filtering_without_permissions(self):
self.assertQuerysetEqual(
AccessControlList.objects.filter_by_access(
permission=permission_document_view, user=self.user,
permission=permission_document_view, user=self._test_case_user,
queryset=Document.objects.all()
), []
)
def test_check_access_with_acl(self):
acl = AccessControlList.objects.create(
content_object=self.document_1, role=self.role
self.grant_access(
obj=self.document_1, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
try:
AccessControlList.objects.check_access(
permissions=(permission_document_view,), user=self.user,
obj=self.document_1
obj=self.document_1, permissions=(permission_document_view,),
user=self._test_case_user,
)
except PermissionDenied:
self.fail('PermissionDenied exception was not expected.')
def test_filtering_with_permissions(self):
acl = AccessControlList.objects.create(
content_object=self.document_1, role=self.role
self.grant_access(
obj=self.document_1, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
self.assertQuerysetEqual(
AccessControlList.objects.filter_by_access(
permission=permission_document_view, user=self.user,
queryset=Document.objects.all()
permission=permission_document_view,
queryset=Document.objects.all(), user=self._test_case_user
), (repr(self.document_1),)
)
def test_check_access_with_inherited_acl(self):
acl = AccessControlList.objects.create(
content_object=self.document_type_1, role=self.role
self.grant_access(
obj=self.document_type_1, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
try:
AccessControlList.objects.check_access(
permissions=(permission_document_view,), user=self.user,
obj=self.document_1
obj=self.document_1, permissions=(permission_document_view,),
user=self._test_case_user
)
except PermissionDenied:
self.fail('PermissionDenied exception was not expected.')
def test_check_access_with_inherited_acl_and_local_acl(self):
acl = AccessControlList.objects.create(
content_object=self.document_type_1, role=self.role
self.grant_access(
obj=self.document_type_1, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
acl = AccessControlList.objects.create(
content_object=self.document_3, role=self.role
self.grant_access(
obj=self.document_3, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
try:
AccessControlList.objects.check_access(
permissions=(permission_document_view,), user=self.user,
obj=self.document_3
obj=self.document_3, permissions=(permission_document_view,),
user=self._test_case_user
)
except PermissionDenied:
self.fail('PermissionDenied exception was not expected.')
def test_filtering_with_inherited_permissions(self):
acl = AccessControlList.objects.create(
content_object=self.document_type_1, role=self.role
self.grant_access(
obj=self.document_type_1, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
result = AccessControlList.objects.filter_by_access(
permission=permission_document_view, user=self.user,
queryset=Document.objects.all()
permission=permission_document_view,
queryset=Document.objects.all(), user=self._test_case_user
)
# Since document_1 and document_2 are of document_type_1
@@ -140,21 +133,17 @@ class PermissionTestCase(BaseTestCase):
self.assertTrue(self.document_3 not in result)
def test_filtering_with_inherited_permissions_and_local_acl(self):
self.role.permissions.add(permission_document_view.stored_permission)
acl = AccessControlList.objects.create(
content_object=self.document_type_1, role=self.role
self.grant_permission(permission=permission_document_view)
self.grant_access(
obj=self.document_type_1, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
acl = AccessControlList.objects.create(
content_object=self.document_3, role=self.role
self.grant_access(
obj=self.document_3, permission=permission_document_view
)
acl.permissions.add(permission_document_view.stored_permission)
result = AccessControlList.objects.filter_by_access(
permission=permission_document_view, user=self.user,
queryset=Document.objects.all()
permission=permission_document_view,
queryset=Document.objects.all(), user=self._test_case_user,
)
self.assertTrue(self.document_1 in result)
self.assertTrue(self.document_2 in result)

149
mayan/apps/acls/tests/test_views.py
View File

@@ -7,79 +7,87 @@ from mayan.apps.documents.tests import GenericDocumentViewTestCase
from ..models import AccessControlList
from ..permissions import permission_acl_edit, permission_acl_view
from .mixins import ACLTestMixin
class AccessControlListViewTestCase(GenericDocumentViewTestCase):
class AccessControlListViewTestCase(ACLTestMixin, GenericDocumentViewTestCase):
def setUp(self):
super(AccessControlListViewTestCase, self).setUp()
content_type = ContentType.objects.get_for_model(self.document)
content_type = ContentType.objects.get_for_model(self.test_document)
self.view_arguments = {
'app_label': content_type.app_label,
'model': content_type.model,
'object_id': self.document.pk
'object_id': self.test_document.pk
}
self.login_user()
def test_acl_create_view_no_permission(self):
response = self.get(
self.test_object = self.test_document
def _request_test_acl_create_get_view(self):
return self.get(
viewname='acls:acl_create', kwargs=self.view_arguments, data={
'role': self.role.pk
}
)
self.assertEquals(response.status_code, 403)
self.assertEqual(AccessControlList.objects.count(), 0)
def test_acl_create_view_with_permission(self):
self.role.permissions.add(
permission_acl_edit.stored_permission
)
response = self.get(
viewname='acls:acl_create', kwargs=self.view_arguments, data={
'role': self.role.pk
'role': self.test_role.pk
}, follow=True
)
def test_acl_create_get_view_no_permission(self):
acl_count = AccessControlList.objects.count()
response = self._request_test_acl_create_get_view()
self.assertEquals(response.status_code, 403)
self.assertEqual(AccessControlList.objects.count(), acl_count)
def test_acl_create_get_view_with_access(self):
self.grant_access(
obj=self.test_document, permission=permission_acl_edit
)
acl_count = AccessControlList.objects.count()
response = self._request_test_acl_create_get_view()
self.assertContains(
response, text=self.document.label, status_code=200
response=response, text=self.test_document.label, status_code=200
)
self.assertEqual(AccessControlList.objects.count(), acl_count)
def _request_test_acl_create_post_view(self):
return self.post(
viewname='acls:acl_create', kwargs=self.view_arguments, data={
'role': self.test_role.pk
}, follow=True
)
def test_acl_create_view_post_no_permission(self):
response = self.post(
viewname='acls:acl_create', kwargs=self.view_arguments, data={
'role': self.role.pk
}
)
acl_count = AccessControlList.objects.count()
response = self._request_test_acl_create_post_view()
self.assertEquals(response.status_code, 403)
self.assertEqual(AccessControlList.objects.count(), 0)
def test_acl_create_view_with_post_permission(self):
self.role.permissions.add(
permission_acl_edit.stored_permission
self.assertEqual(AccessControlList.objects.count(), acl_count)
def test_acl_create_view_post_with_access(self):
self.grant_access(
obj=self.test_document, permission=permission_acl_edit
)
response = self.post(
viewname='acls:acl_create', kwargs=self.view_arguments, data={
'role': self.role.pk
}, follow=True
)
acl_count = AccessControlList.objects.count()
self.assertContains(response, text='created', status_code=200)
self.assertEqual(AccessControlList.objects.count(), 1)
response = self._request_test_acl_create_post_view()
self.assertContains(response=response, text='created', status_code=200)
self.assertEqual(AccessControlList.objects.count(), acl_count + 1)
def test_orphan_acl_create_view_with_permission(self):
"""
Test creating an ACL entry for an object with no model permissions.
Result: Should display a blank permissions list (not optgroup)
"""
self.role.permissions.add(
permission_acl_edit.stored_permission
)
self.grant_permission(permission=permission_acl_edit)
recent_entry = self.document.add_as_recent_document_for_user(self.user)
recent_entry = self.test_document.add_as_recent_document_for_user(
self._test_case_user
)
content_type = ContentType.objects.get_for_model(recent_entry)
@@ -91,61 +99,34 @@ class AccessControlListViewTestCase(GenericDocumentViewTestCase):
response = self.post(
viewname='acls:acl_create', kwargs=view_arguments, data={
'role': self.role.pk
'role': self.test_role.pk
}, follow=True
)
self.assertNotContains(response, text='optgroup', status_code=200)
self.assertEqual(AccessControlList.objects.count(), 1)
def test_acl_list_view_no_permission(self):
document = self.document.add_as_recent_document_for_user(
self.user
).document
acl = AccessControlList.objects.create(
content_object=document, role=self.role
)
acl.permissions.add(permission_acl_edit.stored_permission)
content_type = ContentType.objects.get_for_model(document)
view_arguments = {
'app_label': content_type.app_label,
'model': content_type.model,
'object_id': document.pk
}
self._create_test_acl()
response = self.get(
viewname='acls:acl_list', kwargs=view_arguments
viewname='acls:acl_list', kwargs=self.view_arguments
)
self.assertNotContains(response, text=document.label, status_code=403)
self.assertNotContains(response, text='otal: 1', status_code=403)
self.assertNotContains(
response=response, text=self.document.label, status_code=403
)
self.assertNotContains(
response=response, text='otal: 1', status_code=403
)
def test_acl_list_view_with_permission(self):
self.role.permissions.add(
permission_acl_view.stored_permission
self.grant_access(
obj=self.test_document, permission=permission_acl_view
)
document = self.document.add_as_recent_document_for_user(
self.user
).document
acl = AccessControlList.objects.create(
content_object=document, role=self.role
)
acl.permissions.add(permission_acl_view.stored_permission)
content_type = ContentType.objects.get_for_model(document)
view_arguments = {
'app_label': content_type.app_label,
'model': content_type.model,
'object_id': document.pk
}
response = self.get(
viewname='acls:acl_list', kwargs=view_arguments
viewname='acls:acl_list', kwargs=self.view_arguments
)
self.assertContains(
response=response, text=self.test_document.label, status_code=200
)
self.assertContains(response, text=document.label, status_code=200)

59
mayan/apps/authentication/tests/test_views.py
View File

@@ -10,9 +10,6 @@ from django.utils.http import urlunquote_plus
from mayan.apps.common.tests import GenericViewTestCase
from mayan.apps.smart_settings.classes import Namespace
from mayan.apps.user_management.tests.literals import (
TEST_ADMIN_EMAIL, TEST_ADMIN_PASSWORD, TEST_ADMIN_USERNAME
)
from ..settings import setting_maximum_session_length
@@ -35,6 +32,7 @@ class UserLoginTestCase(GenericViewTestCase):
).tostr()
)
auto_login_user = False
create_test_case_superuser = True
def setUp(self):
super(UserLoginTestCase, self).setUp()
@@ -53,7 +51,8 @@ class UserLoginTestCase(GenericViewTestCase):
@override_settings(AUTHENTICATION_LOGIN_METHOD='username')
def test_username_login(self):
logged_in = self.login(
username=TEST_ADMIN_USERNAME, password=TEST_ADMIN_PASSWORD
username=self._test_case_superuser.username,
password=self._test_case_superuser.cleartext_password
)
self.assertTrue(logged_in)
response = self._request_authenticated_view()
@@ -64,12 +63,14 @@ class UserLoginTestCase(GenericViewTestCase):
def test_email_login(self):
with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)):
logged_in = self.login(
username=TEST_ADMIN_USERNAME, password=TEST_ADMIN_PASSWORD
username=self._test_case_superuser.username,
password=self._test_case_superuser.cleartext_password
)
self.assertFalse(logged_in)
logged_in = self.login(
email=TEST_ADMIN_EMAIL, password=TEST_ADMIN_PASSWORD
email=self._test_case_superuser.email,
password=self._test_case_superuser.cleartext_password
)
self.assertTrue(logged_in)
@@ -86,8 +87,8 @@ class UserLoginTestCase(GenericViewTestCase):
response = self.post(
viewname=settings.LOGIN_URL, data={
'username': TEST_ADMIN_USERNAME,
'password': TEST_ADMIN_PASSWORD
'username': self._test_case_superuser.username,
'password': self._test_case_superuser.cleartext_password
}
)
response = self._request_authenticated_view()
@@ -104,7 +105,8 @@ class UserLoginTestCase(GenericViewTestCase):
response = self.post(
viewname=settings.LOGIN_URL, data={
'email': TEST_ADMIN_EMAIL, 'password': TEST_ADMIN_PASSWORD
'email': self._test_case_superuser.email,
'password': self._test_case_superuser.cleartext_password
}, follow=True
)
self.assertEqual(response.status_code, 200)
@@ -117,8 +119,8 @@ class UserLoginTestCase(GenericViewTestCase):
def test_username_remember_me(self):
response = self.post(
viewname=settings.LOGIN_URL, data={
'username': TEST_ADMIN_USERNAME,
'password': TEST_ADMIN_PASSWORD,
'username': self._test_case_superuser.username,
'password': self._test_case_superuser.cleartext_password,
'remember_me': True
}, follow=True
)
@@ -136,8 +138,8 @@ class UserLoginTestCase(GenericViewTestCase):
def test_username_dont_remember_me(self):
response = self.post(
viewname=settings.LOGIN_URL, data={
'username': TEST_ADMIN_USERNAME,
'password': TEST_ADMIN_PASSWORD,
'username': self._test_case_superuser.username,
'password': self._test_case_superuser.cleartext_password,
'remember_me': False
}, follow=True
)
@@ -152,8 +154,8 @@ class UserLoginTestCase(GenericViewTestCase):
with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)):
response = self.post(
viewname=settings.LOGIN_URL, data={
'email': TEST_ADMIN_EMAIL,
'password': TEST_ADMIN_PASSWORD,
'email': self._test_case_superuser.email,
'password': self._test_case_superuser.cleartext_password,
'remember_me': True
}, follow=True
)
@@ -172,8 +174,8 @@ class UserLoginTestCase(GenericViewTestCase):
with self.settings(AUTHENTICATION_BACKENDS=(TEST_EMAIL_AUTHENTICATION_BACKEND,)):
response = self.post(
viewname=settings.LOGIN_URL, data={
'email': TEST_ADMIN_EMAIL,
'password': TEST_ADMIN_PASSWORD,
'email': self._test_case_superuser.email,
'password': self._test_case_superuser.cleartext_password,
'remember_me': False
}
)
@@ -187,28 +189,31 @@ class UserLoginTestCase(GenericViewTestCase):
def test_password_reset(self):
response = self.post(
viewname='authentication:password_reset_view', data={
'email': TEST_ADMIN_EMAIL,
'email': self._test_case_superuser.email,
}
)
self.assertEqual(response.status_code, 302)
self.assertEqual(len(mail.outbox), 1)
uid_token = mail.outbox[0].body.replace('\n', '').split('/')
email_parts = mail.outbox[0].body.replace('\n', '').split('/')
uidb64 = email_parts[-3]
token = email_parts[-2]
new_password = 'new_password_123'
response = self.post(
viewname='authentication:password_reset_confirm_view',
args=uid_token[-3:-1], data={
'new_password1': TEST_ADMIN_PASSWORD,
'new_password2': TEST_ADMIN_PASSWORD,
kwargs={'uidb64': uidb64, 'token': token}, data={
'new_password1': new_password,
'new_password2': new_password
}
)
self.assertEqual(response.status_code, 302)
self.login(
username=TEST_ADMIN_USERNAME, password=TEST_ADMIN_PASSWORD
logged_in = self.login(
username=self._test_case_superuser.username, password=new_password
)
self.assertTrue(logged_in)
response = self._request_authenticated_view()
self.assertEqual(response.status_code, 200)
@@ -220,8 +225,8 @@ class UserLoginTestCase(GenericViewTestCase):
path='{}?next={}'.format(
reverse(settings.LOGIN_URL), TEST_REDIRECT_URL
), data={
'username': TEST_ADMIN_USERNAME,
'password': TEST_ADMIN_PASSWORD,
'username': self._test_case_superuser.username,
'password': self._test_case_superuser.cleartext_password,
'remember_me': False
}, follow=True
)

135
mayan/apps/cabinets/tests/test_api.py
View File

@@ -1,17 +1,18 @@
from __future__ import unicode_literals
from django.test import override_settings
from django.utils.encoding import force_text
from rest_framework import status
from mayan.apps.documents.permissions import permission_document_view
from mayan.apps.documents.tests import DocumentTestMixin
from mayan.apps.rest_api.tests import BaseAPITestCase
from ..models import Cabinet
from ..permissions import (
permission_cabinet_create, permission_cabinet_delete,
permission_cabinet_edit, permission_cabinet_view
permission_cabinet_add_document, permission_cabinet_create,
permission_cabinet_delete, permission_cabinet_edit,
permission_cabinet_remove_document, permission_cabinet_view
)
from .literals import TEST_CABINET_EDITED_LABEL, TEST_CABINET_LABEL
@@ -19,10 +20,6 @@ from .mixins import CabinetTestMixin
class CabinetAPITestCase(CabinetTestMixin, BaseAPITestCase):
def setUp(self):
super(CabinetAPITestCase, self).setUp()
self.login_user()
def _request_cabinet_create_api_view(self):
return self.post(
viewname='rest_api:cabinet-list', data={
@@ -174,21 +171,26 @@ class CabinetAPITestCase(CabinetTestMixin, BaseAPITestCase):
)
@override_settings(OCR_AUTO_OCR=False)
class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITestCase):
auto_upload_document = False
def setUp(self):
super(CabinetDocumentAPITestCase, self).setUp()
self.login_admin_user()
def _request_test_cabinet_create_api_view(self, extra_data=None):
data = {'label': TEST_CABINET_LABEL}
if extra_data:
data.update(extra_data)
return self.post(viewname='rest_api:cabinet-list', data=data)
def test_cabinet_create_with_single_document(self):
self.document = self.upload_document()
self.upload_document()
response = self.post(
viewname='rest_api:cabinet-list', data={
'label': TEST_CABINET_LABEL, 'documents_pk_list': '{}'.format(
self.document.pk
self.grant_permission(permission=permission_cabinet_create)
response = self._request_test_cabinet_create_api_view(
extra_data={
'documents_pk_list': '{}'.format(
self.test_document.pk
)
}
)
@@ -200,19 +202,20 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes
self.assertEqual(response.data['label'], TEST_CABINET_LABEL)
self.assertQuerysetEqual(
cabinet.documents.all(), (repr(self.document),)
cabinet.documents.all(), (repr(self.test_document),)
)
self.assertEqual(cabinet.label, TEST_CABINET_LABEL)
def test_cabinet_create_with_multiple_documents(self):
self.document = self.upload_document()
self.document_2 = self.upload_document()
self.upload_document()
self.test_document_2 = self.upload_document()
response = self.post(
viewname='rest_api:cabinet-list', data={
'label': TEST_CABINET_LABEL,
self.grant_permission(permission=permission_cabinet_create)
response = self._request_test_cabinet_create_api_view(
extra_data={
'documents_pk_list': '{},{}'.format(
self.document.pk, self.document_2.pk
self.test_document.pk, self.test_document_2.pk
)
}
)
@@ -229,49 +232,65 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes
self.assertQuerysetEqual(
cabinet.documents.all(), map(
repr, (self.document, self.document_2)
repr, (self.test_document, self.test_document_2)
)
)
def test_cabinet_document_delete(self):
self.document = self.upload_document()
self._create_test_cabinet()
self.test_cabinet.documents.add(self.document)
response = self.delete(
def _request_test_cabinet_document_remove_api_view(self):
return self.delete(
viewname='rest_api:cabinet-document', kwargs={
'pk': self.test_cabinet.pk, 'document_pk': self.document.pk
'pk': self.test_cabinet.pk, 'document_pk': self.test_document.pk
}
)
def test_cabinet_document_remove_api_view(self):
self.upload_document()
self._create_test_cabinet()
self.test_cabinet.documents.add(self.test_document)
self.grant_permission(
permission=permission_cabinet_remove_document
)
response = self._request_test_cabinet_document_remove_api_view()
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(self.test_cabinet.documents.count(), 0)
def test_cabinet_document_detail(self):
self.document = self.upload_document()
def test_cabinet_document_detail_api_view(self):
self.upload_document()
self._create_test_cabinet()
self.test_cabinet.documents.add(self.document)
self.test_cabinet.documents.add(self.test_document)
self.grant_permission(
permission=permission_cabinet_view
)
self.grant_permission(
permission=permission_document_view
)
response = self.get(
viewname='rest_api:cabinet-document', kwargs={
'pk': self.test_cabinet.pk, 'document_pk': self.document.pk
'pk': self.test_cabinet.pk, 'document_pk': self.test_document.pk
}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data['uuid'], force_text(self.document.uuid)
response.data['uuid'], force_text(self.test_document.uuid)
)
def test_cabinet_document_list(self):
self.document = self.upload_document()
def test_cabinet_document_list_api_view(self):
self.upload_document()
self._create_test_cabinet()
self.test_cabinet.documents.add(self.document)
self.test_cabinet.documents.add(self.test_document)
self.grant_permission(permission=permission_cabinet_view)
self.grant_permission(permission=permission_document_view)
response = self.get(
viewname='rest_api:cabinet-document-list', kwargs={
@@ -281,32 +300,17 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(
response.data['results'][0]['uuid'], force_text(self.document.uuid)
response.data['results'][0]['uuid'], force_text(self.test_document.uuid)
)
def test_cabinet_remove_document(self):
self.document = self.upload_document()
self._create_test_cabinet()
self.test_cabinet.documents.add(self.document)
response = self.delete(
viewname='rest_api:cabinet-document', kwargs={
'pk': self.test_cabinet.pk, 'document_pk': self.document.pk
}
)
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(self.test_cabinet.documents.count(), 0)
def test_cabinet_add_document(self):
self.document = self.upload_document()
def test_cabinet_add_document_api_view(self):
self.upload_document()
self._create_test_cabinet()
response = self.post(
data={
'documents_pk_list': '{}'.format(self.document.pk)
'documents_pk_list': '{}'.format(self.test_document.pk)
}, kwargs={
'pk': self.test_cabinet.pk
}, viewname='rest_api:cabinet-document-list'
@@ -314,19 +318,20 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertQuerysetEqual(
self.test_cabinet.documents.all(), (repr(self.document),)
self.test_cabinet.documents.all(), (repr(self.test_document),)
)
def test_cabinet_add_multiple_documents(self):
self.document = self.upload_document()
self.document_2 = self.upload_document()
def test_cabinet_add_multiple_documents_api_view(self):
self.upload_document()
self.test_document_2 = self.upload_document()
self._create_test_cabinet()
self.grant_permission(permission=permission_cabinet_add_document)
response = self.post(
data={
'documents_pk_list': '{},{}'.format(
self.document.pk, self.document_2.pk
self.test_document.pk, self.test_document_2.pk
),
}, kwargs={
'pk': self.test_cabinet.pk
@@ -336,6 +341,6 @@ class CabinetDocumentAPITestCase(CabinetTestMixin, DocumentTestMixin, BaseAPITes
self.assertQuerysetEqual(
self.test_cabinet.documents.all(), map(
repr, (self.document, self.document_2)
repr, (self.test_document, self.test_document_2)
)
)

20
mayan/apps/cabinets/tests/test_events.py
View File

@@ -7,35 +7,31 @@ from mayan.apps.documents.tests.test_models import GenericDocumentTestCase
from ..events import (
event_cabinets_add_document, event_cabinets_remove_document
)
from ..models import Cabinet
from .literals import TEST_CABINET_LABEL
from .mixins import CabinetTestMixin
class CabinetsEventsTestCase(GenericDocumentTestCase):
class CabinetsEventsTestCase(CabinetTestMixin, GenericDocumentTestCase):
def setUp(self):
super(CabinetsEventsTestCase, self).setUp()
self._create_cabinet()
def _create_cabinet(self):
self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
self._create_test_cabinet()
def test_document_cabinet_add_event(self):
Action.objects.all().delete()
self.cabinet.add_document(document=self.document)
self.test_cabinet.add_document(document=self.test_document)
self.assertEqual(Action.objects.last().target, self.document)
self.assertEqual(Action.objects.last().target, self.test_document)
self.assertEqual(
Action.objects.last().verb,
event_cabinets_add_document.id
)
def test_document_cabinet_remove_event(self):
self.cabinet.add_document(document=self.document)
self.test_cabinet.add_document(document=self.test_document)
Action.objects.all().delete()
self.cabinet.remove_document(document=self.document)
self.test_cabinet.remove_document(document=self.test_document)
self.assertEqual(Action.objects.first().target, self.document)
self.assertEqual(Action.objects.first().target, self.test_document)
self.assertEqual(
Action.objects.first().verb,
event_cabinets_remove_document.id

41
mayan/apps/cabinets/tests/test_models.py
View File

@@ -1,7 +1,6 @@
from __future__ import unicode_literals
from django.core.exceptions import ValidationError
from django.test import override_settings
from mayan.apps.common.tests import BaseTestCase
from mayan.apps.documents.tests import DocumentTestMixin
@@ -9,18 +8,18 @@ from mayan.apps.documents.tests import DocumentTestMixin
from ..models import Cabinet
from .literals import TEST_CABINET_LABEL
from .mixins import CabinetTestMixin
@override_settings(OCR_AUTO_OCR=False)
class CabinetTestCase(DocumentTestMixin, BaseTestCase):
class CabinetTestCase(CabinetTestMixin, DocumentTestMixin, BaseTestCase):
def test_cabinet_creation(self):
cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
self._create_test_cabinet()
self.assertEqual(Cabinet.objects.all().count(), 1)
self.assertQuerysetEqual(Cabinet.objects.all(), (repr(cabinet),))
self.assertQuerysetEqual(Cabinet.objects.all(), (repr(self.test_cabinet),))
def test_cabinet_duplicate_creation(self):
cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
self._create_test_cabinet()
with self.assertRaises(ValidationError):
cabinet_2 = Cabinet(label=TEST_CABINET_LABEL)
@@ -28,39 +27,39 @@ class CabinetTestCase(DocumentTestMixin, BaseTestCase):
cabinet_2.save()
self.assertEqual(Cabinet.objects.all().count(), 1)
self.assertQuerysetEqual(Cabinet.objects.all(), (repr(cabinet),))
self.assertQuerysetEqual(Cabinet.objects.all(), (repr(self.test_cabinet),))
def test_inner_cabinet_creation(self):
cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
self._create_test_cabinet()
inner_cabinet = Cabinet.objects.create(
parent=cabinet, label=TEST_CABINET_LABEL
parent=self.test_cabinet, label=TEST_CABINET_LABEL
)
self.assertEqual(Cabinet.objects.all().count(), 2)
self.assertQuerysetEqual(
Cabinet.objects.all(), map(repr, (cabinet, inner_cabinet))
Cabinet.objects.all(), map(repr, (self.test_cabinet, inner_cabinet))
)
def test_addition_of_documents(self):
cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
cabinet.documents.add(self.document)
self._create_test_cabinet()
self.test_cabinet.documents.add(self.test_document)
self.assertEqual(cabinet.documents.count(), 1)
self.assertEqual(self.test_cabinet.documents.count(), 1)
self.assertQuerysetEqual(
cabinet.documents.all(), (repr(self.document),)
self.test_cabinet.documents.all(), (repr(self.test_document),)
)
def test_addition_and_deletion_of_documents(self):
cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
cabinet.documents.add(self.document)
self._create_test_cabinet()
self.test_cabinet.documents.add(self.test_document)
self.assertEqual(cabinet.documents.count(), 1)
self.assertEqual(self.test_cabinet.documents.count(), 1)
self.assertQuerysetEqual(
cabinet.documents.all(), (repr(self.document),)
self.test_cabinet.documents.all(), (repr(self.test_document),)
)
cabinet.documents.remove(self.document)
self.test_cabinet.documents.remove(self.test_document)
self.assertEqual(cabinet.documents.count(), 0)
self.assertQuerysetEqual(cabinet.documents.all(), ())
self.assertEqual(self.test_cabinet.documents.count(), 0)
self.assertQuerysetEqual(self.test_cabinet.documents.all(), ())

168
mayan/apps/cabinets/tests/test_views.py
View File

@@ -1,5 +1,6 @@
from __future__ import absolute_import, unicode_literals
from mayan.apps.common.tests import GenericViewTestCase
from mayan.apps.documents.tests import GenericDocumentViewTestCase
from ..models import Cabinet
@@ -9,16 +10,10 @@ from ..permissions import (
permission_cabinet_remove_document, permission_cabinet_view
)
from .literals import TEST_CABINET_LABEL, TEST_CABINET_EDITED_LABEL
from .mixins import CabinetTestMixin
class CabinetViewTestCase(GenericDocumentViewTestCase):
def setUp(self):
super(CabinetViewTestCase, self).setUp()
self.login_user()
def _create_cabinet(self):
self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
class CabinetViewTestCase(CabinetTestMixin, GenericViewTestCase):
def _request_create_cabinet(self, label):
return self.post(
'cabinets:cabinet_create', data={
@@ -28,209 +23,222 @@ class CabinetViewTestCase(GenericDocumentViewTestCase):
def test_cabinet_create_view_no_permission(self):
response = self._request_create_cabinet(label=TEST_CABINET_LABEL)
self.assertEquals(response.status_code, 403)
self.assertEqual(Cabinet.objects.count(), 0)
def test_cabinet_create_view_with_permission(self):
self.grant_permission(permission=permission_cabinet_create)
response = self._request_create_cabinet(label=TEST_CABINET_LABEL)
self.assertEqual(response.status_code, 302)
self.assertEqual(Cabinet.objects.count(), 1)
self.assertEqual(Cabinet.objects.first().label, TEST_CABINET_LABEL)
def test_cabinet_create_duplicate_view_with_permission(self):
self._create_cabinet()
self._create_test_cabinet()
self.grant_permission(permission=permission_cabinet_create)
response = self._request_create_cabinet(label=TEST_CABINET_LABEL)
response = self._request_create_cabinet(label=TEST_CABINET_LABEL)
# HTTP 200 with error message
self.assertEqual(response.status_code, 200)
self.assertEqual(Cabinet.objects.count(), 1)
self.assertEqual(Cabinet.objects.first().pk, self.cabinet.pk)
self.assertEqual(Cabinet.objects.first().pk, self.test_cabinet.pk)
def _request_delete_cabinet(self):
return self.post('cabinets:cabinet_delete', args=(self.cabinet.pk,))
return self.post(
viewname='cabinets:cabinet_delete', kwargs={
'pk': self.test_cabinet.pk
}
)
def test_cabinet_delete_view_no_permission(self):
self._create_cabinet()
self._create_test_cabinet()
response = self._request_delete_cabinet()
self.assertEqual(response.status_code, 403)
self.assertEqual(Cabinet.objects.count(), 1)
def test_cabinet_delete_view_with_access(self):
self._create_cabinet()
self.grant_access(obj=self.cabinet, permission=permission_cabinet_delete)
self._create_test_cabinet()
self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_delete)
response = self._request_delete_cabinet()
self.assertEqual(response.status_code, 302)
self.assertEqual(Cabinet.objects.count(), 0)
def _request_edit_cabinet(self):
return self.post(
'cabinets:cabinet_edit', args=(self.cabinet.pk,), data={
viewname='cabinets:cabinet_edit', kwargs={
'pk': self.test_cabinet.pk
}, data={
'label': TEST_CABINET_EDITED_LABEL
}
)
def test_cabinet_edit_view_no_permission(self):
self._create_cabinet()
self._create_test_cabinet()
response = self._request_edit_cabinet()
self.assertEqual(response.status_code, 403)
self.cabinet.refresh_from_db()
self.assertEqual(self.cabinet.label, TEST_CABINET_LABEL)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.label, TEST_CABINET_LABEL)
def test_cabinet_edit_view_with_access(self):
self._create_cabinet()
self._create_test_cabinet()
self.grant_access(obj=self.cabinet, permission=permission_cabinet_edit)
self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_edit)
response = self._request_edit_cabinet()
self.assertEqual(response.status_code, 302)
self.cabinet.refresh_from_db()
self.assertEqual(self.cabinet.label, TEST_CABINET_EDITED_LABEL)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.label, TEST_CABINET_EDITED_LABEL)
class CabinetDocumentViewTestCase(CabinetTestMixin, GenericDocumentViewTestCase):
def _add_document_to_cabinet(self):
return self.post(
'cabinets:cabinet_add_document', args=(self.document.pk,), data={
'cabinets': self.cabinet.pk
viewname='cabinets:cabinet_add_document', kwargs={
'pk': self.test_document.pk
}, data={
'cabinets': self.test_cabinet.pk
}
)
def test_cabinet_add_document_view_no_permission(self):
self._create_cabinet()
self._create_test_cabinet()
self.grant_permission(permission=permission_cabinet_view)
response = self._add_document_to_cabinet()
self.assertContains(
response, text='Select a valid choice.', status_code=200
response=response, text='Select a valid choice.', status_code=200
)
self.cabinet.refresh_from_db()
self.assertEqual(self.cabinet.documents.count(), 0)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.documents.count(), 0)
def test_cabinet_add_document_view_with_access(self):
self._create_cabinet()
self._create_test_cabinet()
self.grant_access(obj=self.cabinet, permission=permission_cabinet_view)
self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_view)
self.grant_access(
obj=self.cabinet, permission=permission_cabinet_add_document
obj=self.test_cabinet, permission=permission_cabinet_add_document
)
self.grant_access(
obj=self.document, permission=permission_cabinet_add_document
obj=self.test_document, permission=permission_cabinet_add_document
)
response = self._add_document_to_cabinet()
self.cabinet.refresh_from_db()
self.assertEqual(response.status_code, 302)
self.assertEqual(self.cabinet.documents.count(), 1)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.documents.count(), 1)
self.assertQuerysetEqual(
self.cabinet.documents.all(), (repr(self.document),)
self.test_cabinet.documents.all(), (repr(self.test_document),)
)
def _request_add_multiple_documents_to_cabinet(self):
return self.post(
'cabinets:cabinet_add_multiple_documents', data={
'id_list': (self.document.pk,), 'cabinets': self.cabinet.pk
viewname='cabinets:cabinet_add_multiple_documents', data={
'id_list': (self.test_document.pk,), 'cabinets': self.test_cabinet.pk
}
)
def test_cabinet_add_multiple_documents_view_no_permission(self):
self._create_cabinet()
self._create_test_cabinet()
self.grant_permission(permission=permission_cabinet_view)
response = self._request_add_multiple_documents_to_cabinet()
self.assertContains(
response, text='Select a valid choice', status_code=200
response=response, text='Select a valid choice', status_code=200
)
self.cabinet.refresh_from_db()
self.assertEqual(self.cabinet.documents.count(), 0)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.documents.count(), 0)
def test_cabinet_add_multiple_documents_view_with_access(self):
self._create_cabinet()
self._create_test_cabinet()
self.grant_access(
obj=self.cabinet, permission=permission_cabinet_add_document
obj=self.test_cabinet, permission=permission_cabinet_add_document
)
self.grant_access(
obj=self.document, permission=permission_cabinet_add_document
obj=self.test_document, permission=permission_cabinet_add_document
)
response = self._request_add_multiple_documents_to_cabinet()
self.assertEqual(response.status_code, 302)
self.cabinet.refresh_from_db()
self.assertEqual(self.cabinet.documents.count(), 1)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.documents.count(), 1)
self.assertQuerysetEqual(
self.cabinet.documents.all(), (repr(self.document),)
self.test_cabinet.documents.all(), (repr(self.test_document),)
)
def _request_remove_document_from_cabinet(self):
return self.post(
'cabinets:document_cabinet_remove', args=(self.document.pk,),
data={
'cabinets': (self.cabinet.pk,),
viewname='cabinets:document_cabinet_remove', kwargs={
'pk': self.test_document.pk
}, data={
'cabinets': (self.test_cabinet.pk,),
}
)
def test_cabinet_remove_document_view_no_permission(self):
self._create_cabinet()
self._create_test_cabinet()
self.cabinet.documents.add(self.document)
self.test_cabinet.documents.add(self.test_document)
response = self._request_remove_document_from_cabinet()
self.assertContains(
response, text='Select a valid choice', status_code=200
response=response, text='Select a valid choice', status_code=200
)
self.cabinet.refresh_from_db()
self.assertEqual(self.cabinet.documents.count(), 1)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.documents.count(), 1)
def test_cabinet_remove_document_view_with_access(self):
self._create_cabinet()
self._create_test_cabinet()
self.cabinet.documents.add(self.document)
self.test_cabinet.documents.add(self.test_document)
self.grant_access(
obj=self.cabinet, permission=permission_cabinet_remove_document
obj=self.test_cabinet, permission=permission_cabinet_remove_document
)
self.grant_access(
obj=self.document, permission=permission_cabinet_remove_document
obj=self.test_document, permission=permission_cabinet_remove_document
)
response = self._request_remove_document_from_cabinet()
self.assertEqual(response.status_code, 302)
self.cabinet.refresh_from_db()
self.assertEqual(self.cabinet.documents.count(), 0)
self.test_cabinet.refresh_from_db()
self.assertEqual(self.test_cabinet.documents.count(), 0)
def _request_cabinet_list(self):
return self.get('cabinets:cabinet_list')
return self.get(viewname='cabinets:cabinet_list')
def test_cabinet_list_view_no_permission(self):
self._create_cabinet()
self._create_test_cabinet()
response = self._request_cabinet_list()
self.assertNotContains(
response, text=self.cabinet.label, status_code=200
response, text=self.test_cabinet.label, status_code=200
)
def test_cabinet_list_view_with_access(self):
self._create_cabinet()
self.grant_access(obj=self.cabinet, permission=permission_cabinet_view)
response = self._request_cabinet_list()
self._create_test_cabinet()
self.grant_access(obj=self.test_cabinet, permission=permission_cabinet_view)
response = self._request_cabinet_list()
self.assertContains(
response, text=self.cabinet.label, status_code=200
response, text=self.test_cabinet.label, status_code=200
)

31
mayan/apps/cabinets/tests/test_wizard_steps.py
View File

@@ -11,23 +11,21 @@ from mayan.apps.sources.tests.literals import (
)
from mayan.apps.sources.wizards import WizardStep
from ..models import Cabinet
from ..wizard_steps import WizardStepCabinets
from .literals import TEST_CABINET_LABEL
from .mixins import CabinetTestMixin
class CabinetDocumentUploadTestCase(GenericDocumentViewTestCase):
class CabinetDocumentUploadTestCase(CabinetTestMixin, GenericDocumentViewTestCase):
auto_upload_document = False
def setUp(self):
super(CabinetDocumentUploadTestCase, self).setUp()
self.login_user()
self.source = WebFormSource.objects.create(
self.test_source = WebFormSource.objects.create(
enabled=True, label=TEST_SOURCE_LABEL,
uncompress=TEST_SOURCE_UNCOMPRESS_N
)
self.document.delete()
def tearDown(self):
super(CabinetDocumentUploadTestCase, self).tearDown()
WizardStep.reregister_all()
@@ -35,26 +33,24 @@ class CabinetDocumentUploadTestCase(GenericDocumentViewTestCase):
def _request_upload_interactive_document_create_view(self):
with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
return self.post(
viewname='sources:upload_interactive', args=(self.source.pk,),
data={
'document_type_id': self.document_type.pk,
viewname='sources:upload_interactive', kwargs={
'source_id': self.test_source.pk
}, data={
'document_type_id': self.test_document_type.pk,
'source-file': file_object,
'cabinets': self.cabinet.pk
'cabinets': self.test_cabinet.pk
}
)
def _create_cabinet(self):
self.cabinet = Cabinet.objects.create(label=TEST_CABINET_LABEL)
def test_upload_interactive_view_with_access(self):
self._create_cabinet()
self._create_test_cabinet()
self.grant_access(
permission=permission_document_create, obj=self.document_type
)
response = self._request_upload_interactive_document_create_view()
self.assertEqual(response.status_code, 302)
self.assertTrue(self.cabinet in Document.objects.first().cabinets.all())
self.assertTrue(self.test_cabinet in Document.objects.first().cabinets.all())
def _request_wizard_view(self):
return self.get(viewname='sources:document_create_multiple')
@@ -63,9 +59,10 @@ class CabinetDocumentUploadTestCase(GenericDocumentViewTestCase):
WizardStep.deregister_all()
WizardStep.reregister(name=WizardStepCabinets.name)
self._create_cabinet()
self._create_test_cabinet()
self.grant_access(
permission=permission_document_create, obj=self.document_type
)
response = self._request_wizard_view()
self.assertEqual(response.status_code, 200)

17
mayan/apps/checkouts/tests/mixins.py
View File

@@ -8,13 +8,18 @@ from ..models import DocumentCheckout
class DocumentCheckoutTestMixin(object):
def _check_out_document(self, user=None):
if not user:
user = self.user
_test_document_check_out_seconds = 0.1
expiration_datetime = now() + datetime.timedelta(days=1)
def _check_out_test_document(self, user=None):
if not user:
user = self._test_case_user
self._check_out_expiration_datetime = now() + datetime.timedelta(
seconds=self._test_document_check_out_seconds
)
self.test_check_out = DocumentCheckout.objects.check_out_document(
document=self.document, expiration_datetime=expiration_datetime,
user=user, block_new_version=True
document=self.test_document,
expiration_datetime=self._check_out_expiration_datetime,
block_new_version=True, user=user
)

75
mayan/apps/checkouts/tests/test_api.py
View File

@@ -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)

17
mayan/apps/checkouts/tests/test_links.py
View File

@@ -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)

98
mayan/apps/checkouts/tests/test_models.py
View File

@@ -1,14 +1,9 @@
from __future__ import unicode_literals
import datetime
import logging
import time
from django.test import override_settings
from django.utils.timezone import now
from mayan.apps.common.tests import BaseTestCase
from mayan.apps.documents.tests import DocumentTestMixin
from mayan.apps.documents.tests import GenericDocumentTestCase, DocumentTestMixin
from mayan.apps.documents.tests.literals import TEST_SMALL_DOCUMENT_PATH
from ..exceptions import (
@@ -17,126 +12,107 @@ from ..exceptions import (
)
from ..models import DocumentCheckout, NewVersionBlock
from .mixins import DocumentCheckoutTestMixin
class DocumentCheckoutTestCase(DocumentCheckoutTestMixin, GenericDocumentTestCase):
# auto
@override_settings(OCR_AUTO_OCR=False)
class DocumentCheckoutTestCase(DocumentTestMixin, BaseTestCase):
def test_document_check_out(self):
expiration_datetime = now() + datetime.timedelta(days=1)
self._check_out_test_document()
DocumentCheckout.objects.check_out_document(
document=self.document, expiration_datetime=expiration_datetime,
user=self.admin_user, block_new_version=True
)
self.assertTrue(self.document.is_checked_out())
self.assertTrue(
DocumentCheckout.objects.is_checked_out(
document=self.document
document=self.test_document
)
)
def test_checkin_in(self):
expiration_datetime = now() + datetime.timedelta(days=1)
self._check_out_test_document()
DocumentCheckout.objects.check_out_document(
document=self.document, expiration_datetime=expiration_datetime,
user=self.admin_user, block_new_version=True
)
self.test_document.check_in()
self.document.check_in()
self.assertFalse(self.document.is_checked_out())
self.assertFalse(self.test_document.is_checked_out())
self.assertFalse(
DocumentCheckout.objects.is_checked_out(
document=self.document
document=self.test_document
)
)
def test_double_check_out(self):
expiration_datetime = now() + datetime.timedelta(days=1)
DocumentCheckout.objects.check_out_document(
document=self.document, expiration_datetime=expiration_datetime,
user=self.admin_user, block_new_version=True
)
self._create_test_case_superuser()
self._check_out_test_document()
with self.assertRaises(DocumentAlreadyCheckedOut):
DocumentCheckout.objects.check_out_document(
document=self.document,
expiration_datetime=expiration_datetime, user=self.admin_user,
document=self.test_document,
expiration_datetime=self._check_out_expiration_datetime,
user=self._test_case_superuser,
block_new_version=True
)
def test_checkin_without_checkout(self):
with self.assertRaises(DocumentNotCheckedOut):
self.document.check_in()
self.test_document.check_in()
def test_auto_check_in(self):
expiration_datetime = now() + datetime.timedelta(seconds=.1)
self._check_out_test_document()
DocumentCheckout.objects.check_out_document(
document=self.document, expiration_datetime=expiration_datetime,
user=self.admin_user, block_new_version=True
)
time.sleep(.11)
# Ensure we wait from longer than the document check out expiration
time.sleep(self._test_document_check_out_seconds + 0.1)
DocumentCheckout.objects.check_in_expired_check_outs()
self.assertFalse(self.document.is_checked_out())
self.assertFalse(self.test_document.is_checked_out())
@override_settings(OCR_AUTO_OCR=False)
class NewVersionBlockTestCase(DocumentTestMixin, BaseTestCase):
class NewVersionBlockTestCase(DocumentCheckoutTestMixin, DocumentTestMixin, BaseTestCase):
def test_blocking(self):
NewVersionBlock.objects.block(document=self.document)
NewVersionBlock.objects.block(document=self.test_document)
self.assertEqual(NewVersionBlock.objects.count(), 1)
self.assertEqual(
NewVersionBlock.objects.first().document, self.document
NewVersionBlock.objects.first().document, self.test_document
)
def test_blocking_new_versions(self):
# Silence unrelated logging
logging.getLogger('documents.models').setLevel(logging.CRITICAL)
self._silence_logger(name='mayan.apps.documents.models')
NewVersionBlock.objects.block(document=self.document)
NewVersionBlock.objects.block(document=self.test_document)
with self.assertRaises(NewDocumentVersionNotAllowed):
with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
self.document.new_version(file_object=file_object)
self.test_document.new_version(file_object=file_object)
def test_unblocking(self):
NewVersionBlock.objects.create(document=self.document)
NewVersionBlock.objects.create(document=self.test_document)
NewVersionBlock.objects.unblock(document=self.document)
NewVersionBlock.objects.unblock(document=self.test_document)
self.assertEqual(NewVersionBlock.objects.count(), 0)
def test_is_blocked(self):
NewVersionBlock.objects.create(document=self.document)
NewVersionBlock.objects.create(document=self.test_document)
self.assertTrue(
NewVersionBlock.objects.is_blocked(document=self.document)
NewVersionBlock.objects.is_blocked(document=self.test_document)
)
NewVersionBlock.objects.all().delete()
self.assertFalse(
NewVersionBlock.objects.is_blocked(document=self.document)
NewVersionBlock.objects.is_blocked(document=self.test_document)
)
def test_version_creation_blocking(self):
# Silence unrelated logging
logging.getLogger('documents.models').setLevel(logging.CRITICAL)
self._silence_logger(name='mayan.apps.documents.models')
expiration_datetime = now() + datetime.timedelta(days=1)
self._create_test_case_superuser()
DocumentCheckout.objects.check_out_document(
document=self.document, expiration_datetime=expiration_datetime,
user=self.admin_user, block_new_version=True
)
self._check_out_test_document()
with self.assertRaises(NewDocumentVersionNotAllowed):
with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
self.document.new_version(file_object=file_object)
self.test_document.new_version(file_object=file_object)

133
mayan/apps/checkouts/tests/test_views.py
View File

@@ -1,7 +1,5 @@
from __future__ import unicode_literals
import logging
from mayan.apps.common.literals import TIME_DELTA_UNIT_DAYS
from mayan.apps.documents.permissions import permission_document_view
from mayan.apps.documents.tests import GenericDocumentViewTestCase
@@ -18,73 +16,74 @@ from .mixins import DocumentCheckoutTestMixin
class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentViewTestCase):
def setUp(self):
super(DocumentCheckoutViewTestCase, self).setUp()
self.login_user()
def _request_document_check_in_get_view(self):
return self.get(
viewname='checkouts:check_in_document', args=(self.document.pk,),
viewname='checkouts:check_in_document', kwargs={
'pk': self.test_document.pk
}
)
def test_check_in_document_get_view_no_permission(self):
self._check_out_document()
self._check_out_test_document()
response = self._request_document_check_in_get_view()
self.assertContains(
response=response, text=self.document.label, status_code=200
response=response, text=self.test_document.label, status_code=200
)
self.assertTrue(self.document.is_checked_out())
self.assertTrue(self.test_document.is_checked_out())
def test_check_in_document_get_view_with_access(self):
self._check_out_document()
self._check_out_test_document()
self.grant_access(
obj=self.document, permission=permission_document_check_in
obj=self.test_document, permission=permission_document_check_in
)
response = self._request_document_check_in_get_view()
self.assertContains(
response=response, text=self.document.label, status_code=200
response=response, text=self.test_document.label, status_code=200
)
self.assertTrue(self.document.is_checked_out())
self.assertTrue(self.test_document.is_checked_out())
def _request_document_check_in_post_view(self):
return self.post(
viewname='checkouts:check_in_document', args=(self.document.pk,),
viewname='checkouts:check_in_document', kwargs={
'pk': self.test_document.pk
}
)
def test_check_in_document_post_view_no_permission(self):
self._check_out_document()
self._check_out_test_document()
response = self._request_document_check_in_post_view()
self.assertEquals(response.status_code, 403)
self.assertTrue(self.document.is_checked_out())
self.assertTrue(self.test_document.is_checked_out())
def test_check_in_document_post_view_with_access(self):
self._check_out_document()
self._check_out_test_document()
self.grant_access(
obj=self.document, permission=permission_document_check_in
obj=self.test_document, permission=permission_document_check_in
)
response = self._request_document_check_in_post_view()
self.assertEquals(response.status_code, 302)
self.assertFalse(self.document.is_checked_out())
self.assertFalse(self.test_document.is_checked_out())
self.assertFalse(
DocumentCheckout.objects.is_checked_out(
document=self.document
document=self.test_document
)
)
def _request_document_checkout_view(self):
return self.post(
viewname='checkouts:check_out_document', args=(self.document.pk,),
data={
viewname='checkouts:check_out_document', kwargs={
'pk': self.test_document.pk
}, data={
'expiration_datetime_0': 2,
'expiration_datetime_1': TIME_DELTA_UNIT_DAYS,
'block_new_version': True
@@ -94,49 +93,51 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie
def test_check_out_document_view_no_permission(self):
response = self._request_document_checkout_view()
self.assertEquals(response.status_code, 403)
self.assertFalse(self.document.is_checked_out())
self.assertFalse(self.test_document.is_checked_out())
def test_check_out_document_view_with_access(self):
self.grant_access(
obj=self.document, permission=permission_document_check_out
obj=self.test_document, permission=permission_document_check_out
)
self.grant_access(
obj=self.document,
obj=self.test_document,
permission=permission_document_check_out_detail_view
)
response = self._request_document_checkout_view()
self.assertEquals(response.status_code, 302)
self.assertTrue(self.document.is_checked_out())
self.assertTrue(self.test_document.is_checked_out())
def _request_check_out_detail_view(self):
return self.get(
viewname='checkouts:check_out_info', args=(self.document.pk,),
viewname='checkouts:check_out_info', kwargs={
'pk': self.test_document.pk
}
)
def test_checkout_detail_view_no_permission(self):
self._check_out_document()
self._check_out_test_document()
self.grant_access(
obj=self.document,
obj=self.test_document,
permission=permission_document_check_out
)
response = self._request_check_out_detail_view()
self.assertNotContains(
response, text=STATE_LABELS[STATE_CHECKED_OUT], status_code=403
)
def test_checkout_detail_view_with_access(self):
self._check_out_document()
self._check_out_test_document()
self.grant_access(
obj=self.document,
obj=self.test_document,
permission=permission_document_check_out_detail_view
)
response = self._request_check_out_detail_view()
self.assertContains(
response, text=STATE_LABELS[STATE_CHECKED_OUT], status_code=200
)
@@ -145,36 +146,33 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie
return self.get(viewname='checkouts:check_out_list')
def test_checkout_list_view_no_permission(self):
self._check_out_document()
self._check_out_test_document()
self.grant_access(
obj=self.document,
obj=self.test_document,
permission=permission_document_view
)
response = self._request_check_out_list_view()
self.assertNotContains(
response=response, text=self.document.label, status_code=200
response=response, text=self.test_document.label, status_code=200
)
def test_checkout_list_view_with_access(self):
self._check_out_document()
self._check_out_test_document()
self.grant_access(
obj=self.document,
obj=self.test_document,
permission=permission_document_check_out_detail_view
)
self.grant_access(
obj=self.document,
obj=self.test_document,
permission=permission_document_view
)
response = self._request_check_out_list_view()
self.assertContains(
response=response, text=self.document.label, status_code=200
response=response, text=self.test_document.label, status_code=200
)
def test_document_new_version_after_check_out(self):
@@ -187,23 +185,25 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie
- Link to upload version view should not resolve
- Upload version view should reject request
"""
self._check_out_document()
self.login_admin_user()
self._create_test_case_superuser()
self._check_out_test_document()
self.login_superuser()
response = self.post(
'sources:upload_version', args=(self.document.pk,),
follow=True
viewname='sources:upload_version', kwargs={
'document_pk': self.test_document.pk
}, follow=True
)
self.assertContains(
response, text='blocked from uploading',
response=response, text='blocked from uploading',
status_code=200
)
response = self.get(
'documents:document_version_list', args=(self.document.pk,),
follow=True
viewname='documents:document_version_list', kwargs={
'pk': self.test_document.pk
}, follow=True
)
# Needed by the url view resolver
@@ -217,37 +217,40 @@ class DocumentCheckoutViewTestCase(DocumentCheckoutTestMixin, GenericDocumentVie
# Forcefully checking in a document by a user without adequate
# permissions throws out an error
# Silence unrelated logging
logging.getLogger('navigation.classes').setLevel(logging.CRITICAL)
self._check_out_document(user=self.admin_user)
self._create_test_case_superuser()
self._check_out_test_document(user=self._test_case_superuser)
self.grant_access(
obj=self.document, permission=permission_document_check_in
obj=self.test_document, permission=permission_document_check_in
)
response = self.post(
'checkouts:check_in_document', args=(self.document.pk,)
viewname='checkouts:check_in_document', kwargs={
'pk': self.test_document.pk
}
)
self.assertContains(
response, text='Insufficient permissions', status_code=403
response=response, text='Insufficient permissions', status_code=403
)
self.assertTrue(self.document.is_checked_out())
self.assertTrue(self.test_document.is_checked_out())
def test_forcefull_check_in_document_view_with_permission(self):
self._check_out_document(user=self.admin_user)
self._create_test_case_superuser()
self._check_out_test_document(user=self._test_case_superuser)
self.grant_access(
obj=self.document, permission=permission_document_check_in
obj=self.test_document, permission=permission_document_check_in
)
self.grant_access(
obj=self.document, permission=permission_document_check_in_override
obj=self.test_document, permission=permission_document_check_in_override
)
response = self.post(
'checkouts:check_in_document', args=(self.document.pk,)
viewname='checkouts:check_in_document', kwargs={
'pk': self.test_document.pk
}
)
self.assertEqual(response.status_code, 302)
self.assertFalse(self.document.is_checked_out())
self.assertFalse(self.test_document.is_checked_out())

3
mayan/apps/common/tests/base.py
View File

@@ -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

4
mayan/apps/common/tests/mixins.py
View File

@@ -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

26
mayan/apps/common/tests/test_api.py
View File

@@ -10,23 +10,29 @@ TEST_TEMPLATE_RESULT = '<div'
class CommonAPITestCase(BaseAPITestCase):
def test_content_type_list_view(self):
response = self.get(viewname='rest_api:content-type-list')
auto_login_user = False
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
)

2
mayan/apps/common/tests/test_models.py
View File

@@ -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')

52
mayan/apps/common/tests/test_views.py
View File

@@ -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):
def setUp(self):
super(CommonViewTestCase, self).setUp()
self.login_user()
class CommonViewTestCase(UserTestMixin, GenericViewTestCase):
def _request_about_view(self):
return self.get(viewname='common:about_view')
def test_about_view(self):
response = self.get('common:about_view')
self.assertContains(response, text='About', status_code=200)
response = self._request_about_view()
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
}, 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
'object_id': self.test_user.pk
}
)
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
)

106
mayan/apps/converter/tests/test_views.py
View File

@@ -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(
'converter:transformation_delete', kwargs={
'pk': transformation.pk
def test_transformation_delete_view_no_permissions(self):
self._create_test_transformation()
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):
response = self._transformation_delete_view()
def test_transformation_list_view_no_permissions(self):
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):
self.grant_permission(permission=permission_transformation_delete)
response = self._transformation_delete_view()
def test_transformation_list_view_with_permissions(self):
self.grant_access(
obj=self.document, permission=permission_transformation_view
)
self.assertEqual(response.status_code, 302)
self.assertEqual(Transformation.objects.count(), 0)
response = self._transformation_list_view()
self.assertContains(
response=response, text=self.document.label, status_code=200
)

10
mayan/apps/django_gpg/tests/mixins.py Normal file
View File

@@ -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)

40
mayan/apps/django_gpg/tests/test_api.py
View File

@@ -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(BaseAPITestCase):
def setUp(self):
super(KeyAPITestCase, self).setUp()
self.login_user()
def _create_key(self):
return Key.objects.create(key_data=TEST_KEY_DATA)
class KeyAPITestCase(KeyTestMixin, BaseAPITestCase):
# 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()
response = self._request_key_detail_view()
self._create_test_key()
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
)

35
mayan/apps/django_gpg/tests/test_views.py
View File

@@ -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):
def setUp(self):
super(KeyViewTestCase, self).setUp()
self.login_user()
class KeyViewTestCase(KeyTestMixin, GenericViewTestCase):
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(
viewname='django_gpg:key_download', args=(key.pk,)
)
self._create_test_key()
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,
basename=key.key_id,
self, response=response, content=self.test_key.key_data,
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)

78
mayan/apps/document_comments/tests/test_api.py
View File

@@ -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):
super(CommentAPITestCase, self).setUp()
self.login_user()
def _create_comment(self):
return self.document.comments.create(
comment=TEST_COMMENT_TEXT, user=self.admin_user
def _create_test_comment(self):
return self.test_document.comments.create(
comment=TEST_COMMENT_TEXT, user=self._test_case_user
)
def _request_comment_create_view(self):
return self.post(
viewname='rest_api:comment-list', args=(self.document.pk,),
data={
viewname='rest_api:comment-list', kwargs={
'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=(
self.document.pk, self.comment.pk,
)
viewname='rest_api:comment-detail', kwargs={
'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=(
self.document.pk, self.comment.pk,
)
viewname='rest_api:comment-detail', kwargs={
'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
)

10
mayan/apps/document_indexing/tests/mixins.py
View File

@@ -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()

26
mayan/apps/document_indexing/tests/test_api.py
View File

@@ -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
)

54
mayan/apps/document_indexing/tests/test_models.py
View File

@@ -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(
parent=self.index.template_root,
self.test_index.node_templates.create(
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(
parent=self.index.template_root,
self.test_index.node_templates.create(
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(
parent=self.index.template_root,
level_year = self.test_index.node_templates.create(
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
level_1 = self.index.node_templates.create(
root = self.test_index.template_root
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
self.index.node_templates.create(
root = self.test_index.template_root
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(
parent=self.index.template_root,
level_1 = self.test_index.node_templates.create(
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
self.index.node_templates.create(
root = self.test_index.template_root
self.test_index.node_templates.create(
parent=root, expression='{{ document.metadata_value_of.test }}',
link_documents=True
)

130
mayan/apps/document_indexing/tests/test_views.py
View File

@@ -11,19 +11,15 @@ from ..permissions import (
)
from .literals import (
TEST_INDEX_LABEL, TEST_INDEX_LABEL_EDITED, TEST_INDEX_SLUG,
TEST_INDEX_TEMPLATE_DOCUMENT_LABEL_EXPRESSION
TEST_INDEX_LABEL, TEST_INDEX_LABEL_EDITED, TEST_INDEX_SLUG
)
from .mixins import DocumentIndexingTestMixin
class IndexViewTestCase(GenericDocumentViewTestCase):
def setUp(self):
super(IndexViewTestCase, self).setUp()
self.login_user()
class IndexViewTestCase(DocumentIndexingTestMixin, GenericDocumentViewTestCase):
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):
return self.post('indexing:index_setup_delete', args=(index.pk,))
def test_index_delete_view_no_permission(self):
index = Index.objects.create(
label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
def _request_index_delete_view(self):
return self.post(
viewname='indexing:index_setup_delete', kwargs={
'pk': self.test_index.pk
}
)
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(
permission_document_indexing_delete.stored_permission
)
self._create_test_index()
index = Index.objects.create(
label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
)
response = self._request_index_delete_view(index=index)
self.grant_permission(permission=permission_document_indexing_delete)
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(
label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
)
self._create_test_index()
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(
label=TEST_INDEX_LABEL, slug=TEST_INDEX_SLUG
)
self._create_test_index()
self.grant_access(
permission=permission_document_indexing_edit,
obj=index
obj=self.test_index, permission=permission_document_indexing_edit
)
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):
# Create empty index
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()
self.test_index.refresh_from_db()
self.assertEqual(self.test_index.label, TEST_INDEX_LABEL_EDITED)
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.index
obj=self.test_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)

1
mayan/apps/document_parsing/tests/literals.py
View File

@@ -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 %}'

16
mayan/apps/document_parsing/tests/test_api.py
View File

@@ -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.document.latest_version.pages.first().pk,
self.test_document.pk, self.test_document.latest_version.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']
)

8
mayan/apps/document_parsing/tests/test_events.py
View File

@@ -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,

12
mayan/apps/document_parsing/tests/test_indexing.py
View File

@@ -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.document.submit_for_parsing()
self.test_document = self.upload_document()
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()
)

11
mayan/apps/document_parsing/tests/test_models.py
View File

@@ -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())
)

9
mayan/apps/document_parsing/tests/test_parsers.py
View File

@@ -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
)

49
mayan/apps/document_parsing/tests/test_views.py
View File

@@ -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=(
self.document.pages.first().pk,
)
viewname='document_parsing:document_page_content', kwargs={
'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):
response = self.get(
def _request_test_document_type_parsing_settings(self):
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
)
response = self.get(
viewname='document_parsing:document_type_parsing_settings',
args=(self.document.document_type.pk,)
obj=self.test_document.document_type
)
response = self._request_test_document_type_parsing_settings()
self.assertEqual(response.status_code, 200)

4
mayan/apps/document_signatures/tests/mixins.py
View File

@@ -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)
)

75
mayan/apps/document_signatures/tests/test_links.py
View File

@@ -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):
def setUp(self):
super(DocumentSignatureLinksTestCase, self).setUp()
self.login_user()
class DocumentSignatureLinksTestCase(SignaturesTestMixin, GenericDocumentViewTestCase):
def test_document_version_signature_detail_link_no_permission(self):
with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
self.upload_document()
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:
document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
self.upload_document()
self.role.permissions.add(
permission_document_version_signature_view.stored_permission
self.grant_access(
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',
args=(document.latest_version.signatures.first().pk,)
viewname=link_document_version_signature_details.view,
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:
document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
with open(TEST_SIGNATURE_FILE_PATH, mode='rb') as file_object:
DetachedSignature.objects.create(
document_version=document.latest_version,
signature_file=File(file_object)
)
self._create_test_detached_signature()
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:
document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
with open(TEST_SIGNATURE_FILE_PATH, mode='rb') as file_object:
DetachedSignature.objects.create(
document_version=document.latest_version,
signature_file=File(file_object)
)
self._create_test_detached_signature()
self.role.permissions.add(
permission_document_version_signature_delete.stored_permission
self.grant_access(
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',
args=(document.latest_version.signatures.first().pk,)
viewname=link_document_version_signature_delete.view,
args=(self.test_document.latest_version.signatures.first().pk,)
)
)

212
mayan/apps/document_signatures/tests/test_models.py
View File

@@ -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.tests import TEST_DOCUMENT_PATH, TEST_DOCUMENT_TYPE_LABEL
from mayan.apps.documents.models import DocumentVersion
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 (
TEST_SIGNED_DOCUMENT_PATH, TEST_KEY_FILE, TEST_KEY_ID, TEST_SIGNATURE_ID
)
from .literals import TEST_SIGNED_DOCUMENT_PATH, TEST_KEY_ID, TEST_SIGNATURE_ID
from .mixins import SignaturesTestMixin
@override_settings(OCR_AUTO_OCR=False)
class DocumentSignaturesTestCase(SignaturesTestMixin, BaseTestCase):
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()
class DocumentSignaturesTestCase(SignaturesTestMixin, GenericDocumentTestCase):
auto_upload_document = False
def test_embedded_signature_no_key(self):
with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
signed_document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
self.upload_document()
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:
signed_document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
self.upload_document()
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:
Key.objects.create(key_data=file_object.read())
self._create_test_key()
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:
key = Key.objects.create(key_data=file_object.read())
with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
signed_document = self.document_type.new_document(
file_object=file_object
)
self._create_test_key()
self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
self.upload_document()
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:
key = Key.objects.create(key_data=file_object.read())
with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
self.signed_document = self.document_type.new_document(
file_object=file_object
)
self._create_test_key()
self.test_document_path = TEST_SIGNED_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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:
key = Key.objects.create(key_data=file_object.read())
self._create_test_key()
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
self.document = self.document_type.new_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, 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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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:
key = Key.objects.create(key_data=file_object.read())
self._create_test_key()
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:
key = Key.objects.create(key_data=file_object.read())
self._create_test_key()
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
self.document = self.document_type.new_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, 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.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
self.assertEqual(EmbeddedSignature.objects.count(), 0)
def test_new_signed_version(self):
with open(TEST_DOCUMENT_PATH, mode='rb') as file_object:
document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
with open(TEST_SIGNED_DOCUMENT_PATH, mode='rb') as file_object:
signed_version = document.new_version(
file_object=file_object, comment='test comment 1'
signed_version = self.test_document.new_version(
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(BaseTestCase):
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()
class EmbeddedSignaturesTestCase(GenericDocumentTestCase):
auto_upload_document = False
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.document_type.new_document(
file_object=file_object
)
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.document_type.new_document(
file_object=file_object
)
self.upload_document()
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.document_type.new_document(
file_object=file_object
)
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.document_type.new_document(
file_object=file_object
)
self.upload_document()
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:
document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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
)

146
mayan/apps/document_signatures/tests/test_views.py
View File

@@ -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):
super(SignaturesViewTestCase, self).setUp()
self.login_user()
auto_upload_document = False
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document = self.document_type.new_document(
file_object=file_object
)
self.test_document_path = TEST_DOCUMENT_PATH
self.upload_document()
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.document_type.new_document(
file_object=file_object
)
self.upload_document()
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.document_type.new_document(
file_object=file_object
)
self.upload_document()
self.assertEqual(
EmbeddedSignature.objects.unsigned_document_versions().count(),

73
mayan/apps/document_states/tests/mixins.py
View File

@@ -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_STATE_LABEL, TEST_WORKFLOW_STATE_COMPLETION,
TEST_WORKFLOW_TRANSITION_LABEL, TEST_WORKFLOW_TRANSITION_LABEL_2
TEST_WORKFLOW_INSTANCE_LOG_ENTRY_COMMENT, TEST_WORKFLOW_INTERNAL_NAME,
TEST_WORKFLOW_LABEL, TEST_WORKFLOW_STATE_LABEL,
TEST_WORKFLOW_STATE_COMPLETION, TEST_WORKFLOW_TRANSITION_LABEL,
TEST_WORKFLOW_TRANSITION_LABEL_2
)
class WorkflowTestMixin(object):
def _create_workflow(self):
self.workflow = Workflow.objects.create(
def _create_test_workflow(self, add_document_type=False):
self.test_workflow = Workflow.objects.create(
label=TEST_WORKFLOW_LABEL,
internal_name=TEST_WORKFLOW_INTERNAL_NAME
)
def _create_workflow_states(self):
self.workflow_initial_state = WorkflowState.objects.create(
workflow=self.workflow, label=TEST_WORKFLOW_INITIAL_STATE_LABEL,
completion=TEST_WORKFLOW_INITIAL_STATE_COMPLETION, initial=True
)
self.workflow_state = WorkflowState.objects.create(
workflow=self.workflow, label=TEST_WORKFLOW_STATE_LABEL,
completion=TEST_WORKFLOW_STATE_COMPLETION
if add_document_type:
self.test_workflow.document_types.add(self.test_document_type)
def _create_test_workflow_state(self):
self.test_workflow_state = self.test_workflow.states.create(
completion=TEST_WORKFLOW_STATE_COMPLETION,
label=TEST_WORKFLOW_STATE_LABEL
)
def _create_workflow_transition(self):
self.workflow_transition = WorkflowTransition.objects.create(
workflow=self.workflow, label=TEST_WORKFLOW_TRANSITION_LABEL,
origin_state=self.workflow_initial_state,
destination_state=self.workflow_state
def _create_test_workflow_states(self):
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.test_workflow_state_2 = self.test_workflow.states.create(
completion=TEST_WORKFLOW_STATE_COMPLETION,
label=TEST_WORKFLOW_STATE_LABEL
)
def _create_workflow_transitions(self):
self.workflow_transition = WorkflowTransition.objects.create(
workflow=self.workflow, label=TEST_WORKFLOW_TRANSITION_LABEL,
origin_state=self.workflow_initial_state,
destination_state=self.workflow_state
def _create_test_workflow_transition(self):
self.test_workflow_transition = self.test_workflow.transitions.create(
label=TEST_WORKFLOW_TRANSITION_LABEL,
origin_state=self.test_workflow_state_1,
destination_state=self.test_workflow_state_2,
)
self.workflow_transition_2 = WorkflowTransition.objects.create(
workflow=self.workflow, label=TEST_WORKFLOW_TRANSITION_LABEL_2,
origin_state=self.workflow_initial_state,
destination_state=self.workflow_state
def _create_test_workflow_transitions(self):
self.test_workflow_transition = self.test_workflow.transitions.create(
workflow=self.test_workflow, label=TEST_WORKFLOW_TRANSITION_LABEL,
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
)

941
mayan/apps/document_states/tests/test_api.py
View File

File diff suppressed because it is too large Load Diff

89
mayan/apps/document_states/tests/test_indexing.py
View File

@@ -1,12 +1,6 @@
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 (
TEST_SMALL_DOCUMENT_PATH, TEST_DOCUMENT_TYPE_LABEL
)
from mayan.apps.documents.tests import GenericDocumentTestCase
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(BaseTestCase):
def tearDown(self):
self.document_type.delete()
super(DocumentStateIndexingTestCase, self).tearDown()
class DocumentStateIndexingTestCase(GenericDocumentTestCase):
auto_upload_document = False
def _create_document_type(self):
self.document_type = DocumentType.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(
def _create_test_workflow(self):
self.test_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):
self._create_workflow()
self.workflow_state_1 = self.workflow.states.create(
def _create_test_workflow_states(self):
self._create_test_workflow()
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):
self._create_workflow_states()
self.workflow_transition = self.workflow.transitions.create(
def _create_test_workflow_transition(self):
self._create_test_workflow_states()
self.test_workflow_transition = self.test_workflow.transitions.create(
label=TEST_WORKFLOW_TRANSITION_LABEL,
origin_state=self.workflow_state_1,
destination_state=self.workflow_state_2,
origin_state=self.test_workflow_state_1,
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_workflow_transition()
self._create_index()
self._create_document()
self._create_test_workflow_transition()
self._create_test_index()
self.upload_document()
self.assertEqual(
list(
@@ -90,14 +69,13 @@ class DocumentStateIndexingTestCase(BaseTestCase):
)
def test_workflow_indexing_transition(self):
self._create_document_type()
self._create_workflow_transition()
self._create_index()
self._create_document()
self._create_test_workflow_transition()
self._create_test_index()
self.upload_document()
self.document.workflows.first().do_transition(
transition=self.workflow_transition,
user=self.admin_user
self.test_document.workflows.first().do_transition(
transition=self.test_workflow_transition,
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_workflow_transition()
self._create_index()
self._create_document()
self._create_test_workflow_transition()
self._create_test_index()
self.upload_document()
self.document.workflows.first().do_transition(
transition=self.workflow_transition,
user=self.admin_user
self.test_document.workflows.first().do_transition(
transition=self.test_workflow_transition,
user=self._test_case_user
)
self.document.delete(to_trash=False)
self.test_document.delete(to_trash=False)
self.assertEqual(
list(

472
mayan/apps/document_states/tests/test_views.py
View File

File diff suppressed because it is too large Load Diff

12
mayan/apps/documents/apps.py
View File

@@ -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,
)
)

6
mayan/apps/documents/tests/base.py
View File

@@ -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"""

35
mayan/apps/documents/tests/mixins.py
View File

@@ -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(
settings.BASE_DIR, 'apps', 'documents', 'tests', 'contrib',
'sample_documents', self.test_document_filename
)
if not self.test_document_path:
self.test_document_path = os.path.join(
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):
self.document_type_filename = self.document_type.filenames.create(
def _create_test_quick_label(self):
self.test_document_type_filename = self.test_document_type.filenames.create(
filename=TEST_DOCUMENT_TYPE_QUICK_LABEL
)

379
mayan/apps/documents/tests/test_api.py
View File

File diff suppressed because it is too large Load Diff

49
mayan/apps/documents/tests/test_deleted_document_views.py
View File

@@ -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
)

13
mayan/apps/documents/tests/test_document_page_views.py
View File

@@ -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
)

108
mayan/apps/documents/tests/test_document_type_views.py
View File

@@ -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._request_quick_label_delete()
self._create_test_quick_label()
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()
response = self._request_quick_label_delete()
self._create_test_quick_label()
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()
response = self._request_quick_label_edit()
self._create_test_quick_label()
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()
response = self._request_quick_label_edit()
self._create_test_quick_label()
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
)

25
mayan/apps/documents/tests/test_document_version_views.py
View File

@@ -5,30 +5,20 @@ from ..permissions import (
)
from .base import GenericDocumentViewTestCase
from .literals import (
TEST_SMALL_DOCUMENT_PATH, TEST_VERSION_COMMENT
)
from .literals import TEST_VERSION_COMMENT
from .mixins import DocumentVersionTestMixin
class DocumentVersionTestCase(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
)
class DocumentVersionTestCase(DocumentVersionTestMixin, GenericDocumentViewTestCase):
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)

252
mayan/apps/documents/tests/test_document_views.py
View File

File diff suppressed because it is too large Load Diff

36
mayan/apps/documents/tests/test_duplicated_document_views.py
View File

@@ -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.document_duplicate = self.document_type.new_document(
file_object=file_object, label=TEST_SMALL_DOCUMENT_FILENAME
)
self.test_duplicated_document = self.upload_document()
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
)

83
mayan/apps/documents/tests/test_events.py
View File

@@ -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):
self.login(
username=TEST_USER_USERNAME, password=TEST_USER_PASSWORD
def _request_test_document_download_view(self):
return self.get(
'documents:document_download', kwargs={'pk': self.test_document.pk}
)
def test_document_download_event_no_permissions(self):
Action.objects.all().delete()
response = self.get(
'documents:document_download', args=(self.document.pk,)
)
response = self._request_test_document_download_view()
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(
viewname='documents:document_download', args=(self.document.pk,),
Action.objects.all().delete()
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(
viewname='documents:document_preview', args=(self.document.pk,)
)
response = self._request_test_document_preview_view()
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(
permission_document_view.stored_permission
)
self.get(
viewname='documents:document_preview', args=(self.document.pk,),
self.grant_access(
obj=self.test_document, permission=permission_document_view
)
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)

24
mayan/apps/documents/tests/test_links.py
View File

@@ -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(
content_object=self.document, role=self.role
)
acl.permissions.add(
permission_document_version_revert.stored_permission
self.grant_access(
obj=self.test_document,
permission=permission_document_version_revert
)
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(
content_object=self.document, role=self.role
self.grant_access(
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,)
)
)

7
mayan/apps/documents/tests/test_models.py
View File

@@ -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()

11
mayan/apps/documents/tests/test_search.py
View File

@@ -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)

2
mayan/apps/documents/tests/test_widgets.py
View File

@@ -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)

12
mayan/apps/dynamic_search/tests/test_api.py
View File

@@ -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
)

84
mayan/apps/dynamic_search/tests/test_models.py
View File

@@ -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},
user=self.admin_user
{'versions__mimetype': self.test_document.file_mimetype},
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.document_2.label = 'second_doc.pdf'
self.document_2.save()
self.test_document_2 = self.upload_document(label='second_doc.pdf')
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.document_2 in queryset)
self.assertTrue(self.test_document 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.document_2.label = 'second_doc.pdf'
self.document_2.save()
self.test_document_2 = self.upload_document(label='second_doc.pdf')
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.document_2.label = 'second_doc.pdf'
self.document_2.save()
self.test_document_2 = self.upload_document()
self.test_document_2.label = 'second_doc.pdf'
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)

48
mayan/apps/dynamic_search/tests/test_views.py
View File

@@ -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(GenericViewTestCase):
class Issue46TestCase(DocumentTestMixin, GenericViewTestCase):
"""
Functional tests to make sure issue 46 is fixed
"""
def setUp(self):
super(Issue46TestCase, self).setUp()
self.login_admin_user()
self.document_count = 4
self.document_type = DocumentType.objects.create(
label=TEST_DOCUMENT_TYPE_LABEL
)
self.test_document_count = 4
self.uploaded_documents = []
# Upload many instances of the same test document
for i in range(self.document_count):
with open(TEST_SMALL_DOCUMENT_PATH, mode='rb') as file_object:
self.document_type.new_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()
for i in range(self.test_document_count):
self.uploaded_documents.append(
self.upload_document()
)
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)

59
mayan/apps/events/tests/test_views.py
View File

@@ -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):
self.login_user()
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
def _request_events_for_object_view(self):
return self.get(
viewname='events:events_for_object', kwargs=self.view_arguments
)
self.assertNotContains(response, text=document.label, status_code=403)
self.assertNotContains(response, text='otal:', status_code=403)
def test_events_for_object_view_no_permission(self):
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(
permission_events_view.stored_permission
response = self._request_events_for_object_view()
self.assertContains(
response=response, text=self.test_document.label, status_code=200
)
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=response, text='otal: 0', status_code=200
)
self.assertContains(response, text=document.label, status_code=200)
self.assertNotContains(response, text='otal: 0', status_code=200)

4
mayan/apps/linking/api_views.py
View File

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

371
mayan/apps/linking/tests/test_api.py
View File

File diff suppressed because it is too large Load Diff

9
mayan/apps/linking/tests/test_models.py
View File

@@ -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),
self.document.label
smart_link.get_dynamic_label(document=self.test_document),
self.test_document.label
)

147
mayan/apps/linking/tests/test_views.py
View File

@@ -16,138 +16,137 @@ from .literals import (
class SmartLinkViewTestCase(GenericDocumentViewTestCase):
def setUp(self):
super(SmartLinkViewTestCase, self).setUp()
self.login_user()
def test_smart_link_create_view_no_permission(self):
response = self.post(
'linking:smart_link_create', data={
def _request_test_smart_link_create_view(self):
return self.post(
viewname='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(
permission_smart_link_create.stored_permission
)
self.grant_permission(permission=permission_smart_link_create)
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):
smart_link = SmartLink.objects.create(label=TEST_SMART_LINK_LABEL)
response = self.post(
'linking:smart_link_delete', args=(smart_link.pk,)
def _request_test_smart_link_delete_view(self):
return self.post(
viewname='linking:smart_link_delete', kwargs={
'pk': self.test_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(
permission_smart_link_delete.stored_permission
)
self._create_test_smart_link()
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):
smart_link = SmartLink.objects.create(label=TEST_SMART_LINK_LABEL)
response = self.post(
'linking:smart_link_edit', args=(smart_link.pk,), data={
def _request_test_smart_link_edit_view(self):
return self.post(
viewname='linking:smart_link_edit', kwargs={
'pk': self.test_smart_link.pk
}, 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(
permission_smart_link_edit.stored_permission
)
self._create_test_smart_link()
smart_link = SmartLink.objects.create(label=TEST_SMART_LINK_LABEL)
self.grant_permission(permission=permission_smart_link_edit)
response = self.post(
'linking:smart_link_edit', args=(smart_link.pk,), data={
'label': TEST_SMART_LINK_LABEL_EDITED
}, follow=True
)
response = self._request_test_smart_link_edit_view()
self.assertEqual(response.status_code, 302)
smart_link = SmartLink.objects.get(pk=smart_link.pk)
self.assertContains(response, text='update', status_code=200)
self.assertEqual(smart_link.label, TEST_SMART_LINK_LABEL_EDITED)
self.test_smart_link.refresh_from_db()
self.assertEqual(self.test_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(
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 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(
permission_smart_link_view.stored_permission
)
self.role.permissions.add(
permission_document_view.stored_permission
)
response = self.get(
'linking:smart_link_instances_for_document',
args=(self.document.pk,)
self.grant_access(
obj=self.test_smart_link, permission=permission_smart_link_view
)
self.grant_access(
obj=self.test_smart_link_2, permission=permission_smart_link_view
)
self.grant_access(
obj=self.test_document, permission=permission_document_view
)
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
)

124
mayan/apps/metadata/tests/test_api.py
View File

@@ -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):
@override_settings(OCR_AUTO_OCR=False)
class DocumentMetadataAPITestCase(DocumentTestMixin, BaseAPITestCase):
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.document_type.metadata.create(
self.test_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.assertEqual(self.document_metadata.value, TEST_METADATA_VALUE)
self.test_document_metadata.refresh_from_db()
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.assertEqual(self.document_metadata.value, TEST_METADATA_VALUE)
self.test_document_metadata.refresh_from_db()
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
)

17
mayan/apps/metadata/tests/test_events.py
View File

@@ -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)

88
mayan/apps/metadata/tests/test_models.py
View File

@@ -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
)

88
mayan/apps/metadata/tests/test_views.py
View File

@@ -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,

16
mayan/apps/metadata/tests/test_wizard_steps.py
View File

@@ -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
}
)

2
mayan/apps/mimetype/tests/test_functions.py
View File

@@ -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

8
mayan/apps/mirroring/tests/test_caches.py
View File

@@ -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.clear_document(document=self.document)
self.cache.set_path(path=TEST_PATH, document=self.test_document)
self.cache.clear_document(document=self.test_document)
self.assertEquals(None, self.cache.get_path(path=TEST_PATH))

65
mayan/apps/mirroring/tests/test_filesystems.py
View File

@@ -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(
parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
self.test_index.node_templates.create(
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(
parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
self.test_index.node_templates.create(
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(
parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
self.test_index.node_templates.create(
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(
parent=self.index.template_root,
self.test_index.node_templates.create(
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(
parent=self.index.template_root,
self.test_index.node_templates.create(
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(
parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
self.test_index.node_templates.create(
parent=self.test_index.template_root, expression=TEST_NODE_EXPRESSION,
link_documents=True
)
self.index.node_templates.create(
parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
self.test_index.node_templates.create(
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(
parent=self.index.template_root, expression=TEST_NODE_EXPRESSION,
self.test_index.node_templates.create(
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)
self.index.rebuild()
index_filesystem = IndexFilesystem(index_slug=self.test_index.slug)
self.test_index.rebuild()
self.assertEqual(
list(

7
mayan/apps/motd/tests/test_api.py
View File

@@ -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

33
mayan/apps/navigation/tests/test_classes.py
View File

@@ -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(
content_object=self.group, role=self.role
)
acl.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})
@@ -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
)

6
mayan/apps/ocr/tests/literals.py
View File

@@ -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'

37
mayan/apps/ocr/tests/test_api.py
View File

@@ -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.document.latest_version.pages.first().pk,
self.test_document.pk, self.test_document.latest_version.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)

9
mayan/apps/ocr/tests/test_indexing.py
View File

@@ -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.document.submit_for_ocr()
self.upload_document()
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()
)

43
mayan/apps/ocr/tests/test_models.py
View File

@@ -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'
TEST_DOCUMENT_CONTENT_DEU_1 = 'Repository für elektronische Dokumente.'
TEST_DOCUMENT_CONTENT_DEU_2 = 'Es bietet einen'
from .literals import (
TEST_DOCUMENT_CONTENT, TEST_DOCUMENT_CONTENT_DEU_1,
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(
file_object=file_object, language=language_code
self.test_document = self.test_document_type.new_document(
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

95
mayan/apps/ocr/tests/test_views.py
View File

@@ -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()
response = self._request_document_content_view()
self.test_document.submit_for_ocr()
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=(
self.document.pages.first().pk,
)
viewname='ocr:document_page_ocr_content', kwargs={
'pk': self.test_document.pages.first().pk
}
)
def test_document_page_content_view_no_permissions(self):
self.document.submit_for_ocr()
response = self._request_document_page_content_view()
self.test_document.submit_for_ocr()
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):
self.document.submit_for_ocr()
def test_document_ocr_download_view_with_access(self):
self.test_document.submit_for_ocr()
self.expected_content_type = 'application/octet-stream; charset=utf-8'
self.grant_permission(permission=permission_ocr_content_view)
response = self._request_document_ocr_download_view()
self.grant_access(
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.document.document_type
obj=self.test_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)

3
mayan/apps/permissions/models.py
View File

@@ -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']

14
mayan/apps/permissions/tests/literals.py
View File

@@ -1,5 +1,15 @@
from __future__ import unicode_literals
TEST_ROLE_2_LABEL = 'test role 2'
TEST_ROLE_LABEL = 'test role'
TEST_CASE_ROLE_LABEL = 'test case role label'
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'

131
mayan/apps/permissions/tests/mixins.py
View File

@@ -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(
permission.stored_permission
self._test_case_role.grant(permission=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
}
)

433
mayan/apps/permissions/tests/test_api.py
View File

@@ -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 (
TEST_ROLE_2_LABEL, TEST_ROLE_LABEL, TEST_ROLE_LABEL_EDITED
from .mixins import (
PermissionAPIViewTestMixin, PermissionTestMixin, RoleAPIViewTestMixin,
RoleTestMixin
)
class PermissionAPITestCase(BaseAPITestCase):
class PermissionAPIViewTestCase(PermissionAPIViewTestMixin, BaseAPITestCase):
def setUp(self):
super(PermissionAPITestCase, self).setUp()
self.login_user()
super(PermissionAPIViewTestCase, self).setUp()
Permission.invalidate_cache()
def test_permissions_list_view(self):
response = self.get(viewname='rest_api:permission-list')
def test_permissions_list_api_view(self):
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):
response = self.get(viewname='rest_api:role-list')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['count'], 0)
class RoleAPIViewTestCase(GroupTestMixin, PermissionTestMixin, RoleAPIViewTestMixin, RoleTestMixin, BaseAPITestCase):
def test_role_create_api_view_no_permission(self):
response = self._request_test_role_create_api_view()
def test_roles_list_view_with_access(self):
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_count = Role.objects.count()
# 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(response.data, {'label': role.label, 'id': role.pk})
self.assertEqual(Role.objects.count(), 2)
self.assertEqual(role.label, TEST_ROLE_2_LABEL)
self.assertEqual(Role.objects.count(), role_count + 1)
def _create_group(self):
self.group_2 = Group.objects.create(name=TEST_GROUP_2_NAME)
def _request_role_create_api_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_create_api_view(extra_data=extra_data)
def _request_role_create_with_extra_data(self):
self._create_group()
def test_role_create_api_view_extra_data_no_permission(self):
self._create_test_group()
self._create_test_permission()
return self._role_create_request(
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()
role_count = Role.objects.count()
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(
list(Role.objects.values_list('label', flat=True)),
[TEST_ROLE_LABEL]
)
self.assertEqual(Role.objects.count(), role_count)
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.label, TEST_ROLE_2_LABEL)
self.assertQuerysetEqual(
role.groups.all(), (repr(self.group_2),)
self.assertEqual(Role.objects.count(), role_count + 1)
new_role = Role.objects.get(pk=response.data['id'])
self.assertTrue(
self.test_group in new_role.groups.all()
)
self.assertQuerysetEqual(
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,)
self.assertTrue(
self.test_permission.stored_permission in new_role.permissions.all()
)
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)
response = self._request_role_delete_view()
self._create_test_role()
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
)

57
mayan/apps/permissions/tests/test_models.py
View File

@@ -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 ..permissions import permission_role_view
from ..classes import Permission, PermissionNamespace
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.role.permissions.add(permission_role_view.stored_permission)
self.role.groups.add(self.group)
self.test_group.user_set.add(self.test_user)
self.test_role.grant(permission=self.test_permission)
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)

177
mayan/apps/permissions/tests/test_views.py
View File

@@ -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):
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,
}
)
class RoleViewsTestCase(RoleTestMixin, RoleViewTestMixin, GenericViewTestCase):
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(
TEST_ROLE_2_LABEL in Role.objects.values_list('label', flat=True)
)
self.assertEqual(Role.objects.count(), role_count)
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):
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)
self.assertEqual(Role.objects.count(), role_count + 1)
def test_role_delete_view_no_access(self):
self._create_role()
response = self._request_role_delete_view()
self._create_test_role()
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(
TEST_ROLE_2_LABEL in Role.objects.values_list('label', flat=True)
)
self.assertEqual(Role.objects.count(), role_count)
def test_role_delete_view_with_access(self):
self._create_role()
self.grant_access(permission=permission_role_delete, obj=self.role_2)
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)
)
self._create_test_role()
self.grant_access(obj=self.test_role, permission=permission_role_delete)
def _request_role_edit_view(self):
return self.post(
viewname='permissions:role_edit', args=(self.role_2.pk,), data={
'label': TEST_ROLE_LABEL_EDITED,
}
)
role_count = Role.objects.count()
response = self._request_test_role_delete_view()
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()
response = self._request_role_edit_view()
self._create_test_role()
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.assertEqual(Role.objects.count(), 2)
self.assertEqual(self.role_2.label, TEST_ROLE_2_LABEL)
self.test_role.refresh_from_db()
self.assertEqual(self.test_role.label, role_label)
def test_role_edit_view_with_access(self):
self._create_role()
self.grant_access(permission=permission_role_edit, obj=self.role_2)
response = self._request_role_edit_view()
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_view()
self.assertEqual(response.status_code, 302)
self.role_2.refresh_from_db()
self.assertEqual(Role.objects.count(), 2)
self.assertEqual(self.role_2.label, TEST_ROLE_LABEL_EDITED)
def _request_role_list_view(self):
return self.get(viewname='permissions:role_list')
self.test_role.refresh_from_db()
self.assertNotEqual(self.test_role.label, role_label)
def test_role_list_view_no_access(self):
self._create_role()
response = self._request_role_list_view()
self._create_test_role()
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.grant_access(permission=permission_role_view, obj=self.role_2)
response = self._request_role_list_view()
self.assertContains(
response=response, text=TEST_ROLE_2_LABEL, status_code=200
)
self._create_test_role()
self.grant_access(obj=self.test_role, permission=permission_role_view)
def _request_role_permissions_view(self):
return self.get(
viewname='permissions:role_permissions', args=(self.role_2.pk,)
response = self._request_test_role_list_view()
self.assertContains(
response=response, text=self.test_role.label, status_code=200
)
def test_role_permissions_view_no_access(self):
self._create_role()
response = self._request_role_permissions_view()
self._create_test_role()
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()
response = self._request_role_groups_view()
self._create_test_role()
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.grant_access(permission=permission_role_edit, obj=self.role_2)
response = self._request_role_groups_view()
self._create_test_role()
self.grant_access(obj=self.test_role, permission=permission_role_edit)
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()
response = self._request_group_roles_view()
self._create_test_group()
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.grant_access(permission=permission_group_edit, obj=self.group_2)
response = self._request_group_roles_view()
self._create_test_group()
self.grant_access(obj=self.test_group, permission=permission_group_edit)
response = self._request_test_group_roles_view()
self.assertEqual(response.status_code, 200)

10
mayan/apps/sources/tests/test_links.py
View File

@@ -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)

74
mayan/apps/sources/tests/test_models.py
View File

@@ -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, DocumentType
from mayan.apps.documents.models import Document
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(BaseTestCase):
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()
class CompressedUploadsTestCase(GenericDocumentTestCase):
auto_upload_document = False
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(BaseTestCase):
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()
class EmailFilenameDecodingTestCase(GenericDocumentTestCase):
auto_upload_document = False
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.document_type.metadata.create(metadata_type=metadata_subject)
self.test_document_type.metadata.create(metadata_type=metadata_from)
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(BaseTestCase):
class POP3SourceTestCase(GenericDocumentTestCase):
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(DocumentTestMixin, BaseTestCase):
class WatchFolderTestCase(GenericDocumentTestCase):
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

80
mayan/apps/sources/tests/test_views.py
View File

@@ -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_SMALL_DOCUMENT_CHECKSUM, TEST_SMALL_DOCUMENT_PATH,
TEST_DOCUMENT_DESCRIPTION, TEST_SMALL_DOCUMENT_CHECKSUM,
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,),
data={
viewname='sources:upload_interactive', kwargs={
'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,),
data={
viewname='sources:upload_interactive', kwargs={
'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(GenericViewTestCase):
def setUp(self):
super(DocumentUploadIssueTestCase, self).setUp()
self.document_type = DocumentType.objects.create(
label=TEST_DOCUMENT_TYPE_LABEL
)
def tearDown(self):
self.document_type.delete()
super(DocumentUploadIssueTestCase, self).tearDown()
class DocumentUploadIssueTestCase(GenericDocumentViewTestCase):
auto_upload_document = False
auto_login_superuser = True
auto_login_user = False
create_test_case_superuser = True
create_test_case_user = False
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.document)
NewVersionBlock.objects.block(self.test_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)

129
mayan/apps/tags/tests/mixins.py
View File

@@ -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):
self.tag = Tag.objects.create(
def _create_test_tag(self):
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,
}
)

503
mayan/apps/tags/tests/test_api.py
View File

File diff suppressed because it is too large Load Diff

50
mayan/apps/tags/tests/test_events.py
View File

@@ -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):
def setUp(self):
super(TagEventsTestCase, self).setUp()
self.login_user()
class TagEventsTestCase(TagTestMixin, TagViewTestMixin, GenericViewTestCase):
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()
Action.objects.all().delete()
self._create_test_tag()
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.actor, self.user)
self.assertEqual(event.target, self.test_tag)
self.assertEqual(event.actor, self._test_case_user)

34
mayan/apps/tags/tests/test_indexing.py
View File

@@ -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_NO_TAG, TEST_TAG_INDEX_NODE_TEMPLATE
TEST_TAG_INDEX_HAS_TAG, TEST_TAG_INDEX_NO_TAG, TEST_TAG_INDEX_NODE_TEMPLATE
)
from .mixins import TagTestMixin
@override_settings(OCR_AUTO_OCR=False)
class TagSignalIndexingTestCase(DocumentTestMixin, BaseTestCase):
class TagSignalIndexingTestCase(DocumentTestMixin, TagTestMixin, 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 = index.template_root
index.node_templates.create(
root = self.test_index.template_root
self.test_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.document = self.upload_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()
)

29
mayan/apps/tags/tests/test_models.py
View File

@@ -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 .literals import TEST_TAG_COLOR, TEST_TAG_LABEL
from .mixins import TagTestMixin
@override_settings(OCR_AUTO_OCR=False)
class TagTestCase(DocumentTestMixin, BaseTestCase):
class TagTestCase(DocumentTestMixin, TagTestMixin, BaseTestCase):
auto_upload_document = False
def test_addition_and_deletion_of_documents(self):
tag = Tag.objects.create(color=TEST_TAG_COLOR, label=TEST_TAG_LABEL)
self.document = self.upload_document()
def test_document_addition(self):
self._create_test_tag()
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.assertEqual(list(tag.documents.all()), [self.document])
self.assertTrue(self.test_document in self.test_tag.documents.all())
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.assertEqual(list(tag.documents.all()), [])
self.test_tag.documents.remove(self.test_document)
tag.delete()
self.assertTrue(self.test_document not in self.test_tag.documents.all())

374
mayan/apps/tags/tests/test_views.py
View File

@@ -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 (
TEST_TAG_COLOR, TEST_TAG_COLOR_EDITED, TEST_TAG_LABEL,
TEST_TAG_LABEL_EDITED
)
from .mixins import TagTestMixin, TagViewTestMixin
class TagViewTestCase(GenericDocumentViewTestCase):
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
}
)
class TagViewTestCase(TagTestMixin, TagViewTestMixin, GenericViewTestCase):
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)
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,)
)
self.assertEqual(Tag.objects.count(), tag_count + 1)
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)
def _request_multiple_delete_view(self):
return self.post(
viewname='tags:tag_multiple_delete',
data={'id_list': self.tag.pk},
)
self.assertEqual(Tag.objects.count(), tag_count - 1)
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)
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
}
)
self.assertEqual(Tag.objects.count(), tag_count - 1)
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.assertEqual(tag.label, TEST_TAG_LABEL)
self.assertEqual(tag.color, TEST_TAG_COLOR)
self.test_tag.refresh_from_db()
self.assertEqual(self.test_tag.label, tag_label)
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.assertEqual(tag.label, TEST_TAG_LABEL_EDITED)
self.assertEqual(tag.color, TEST_TAG_COLOR_EDITED)
self.test_tag.refresh_from_db()
self.assertNotEqual(self.test_tag.label, tag_label)
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)
response = self._request_document_list_view()
self.test_tag.documents.add(self.test_document)
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):
self._create_tag()
def test_document_tags_widget_with_tag_access(self):
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
)
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
}
response=response, text=self.test_tag.label, status_code=200
)
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()
# Redirect to previous URL and show warning message about having to
# 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_tag_access(self):
self._create_test_tag()
def test_document_attach_tag_view_with_access(self):
self._create_tag()
self.grant_access(obj=self.test_tag, permission=permission_tag_attach)
self.assertEqual(self.document.tags.count(), 0)
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()
response = self._request_test_document_tag_attach_view()
self.assertEqual(response.status_code, 302)
self.assertQuerysetEqual(
self.document.tags.all(), (repr(self.tag),)
)
self.assertTrue(self.test_tag not in self.test_document.tags.all())
def _request_multiple_attach_tag_view(self):
return self.post(
viewname='tags:multiple_documents_tag_attach', data={
'id_list': self.document.pk, 'tags': self.tag.pk,
'user': self.user.pk
}
)
def test_document_attach_tag_view_with_document_access(self):
self._create_test_tag()
self.grant_access(obj=self.test_document, permission=permission_tag_attach)
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_multiple_attach_tag_view()
response = self._request_test_document_multiple_tag_multiple_attach_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):
self._create_tag()
def test_document_multiple_attach_tag_view_with_tag_access(self):
self._create_test_tag()
self.grant_access(obj=self.document, permission=permission_tag_attach)
self.grant_access(obj=self.tag, permission=permission_tag_attach)
self.grant_access(obj=self.test_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_multiple_attach_tag_view()
response = self._request_test_document_multiple_tag_multiple_attach_view()
self.assertEqual(response.status_code, 302)
self.assertQuerysetEqual(
self.document.tags.all(), (repr(self.tag),)
)
self.assertTrue(self.test_tag not in self.test_document.tags.all())
def _request_single_document_multiple_tag_remove_view(self):
return self.post(
viewname='tags:single_document_multiple_tag_remove',
args=(self.document.pk,), data={
'id_list': self.document.pk,
'tags': self.tag.pk,
}
)
def test_document_multiple_attach_tag_view_with_document_access(self):
self._create_test_tag()
def test_single_document_multiple_tag_remove_view_no_permissions(self):
self._create_tag()
self.grant_access(obj=self.test_document, permission=permission_tag_attach)
self.document.tags.add(self.tag)
self.grant_access(obj=self.tag, permission=permission_tag_view)
response = self._request_single_document_multiple_tag_remove_view()
response = self._request_test_document_multiple_tag_multiple_attach_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):
self._create_tag()
def test_document_multiple_attach_tag_view_with_full_access(self):
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)
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()
response = self._request_test_document_multiple_tag_multiple_attach_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):
return self.post(
viewname='tags:multiple_documents_selection_tag_remove',
data={
'id_list': self.document.pk,
'tags': self.tag.pk,
}
)
def test_document_tag_multiple_remove_view_no_permissions(self):
self._create_test_tag()
self.test_document.tags.add(self.test_tag)
def test_multiple_documents_selection_tag_remove_view_no_permissions(self):
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()
response = self._request_test_document_tag_multiple_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):
self._create_tag()
def test_document_tag_multiple_remove_view_with_tag_access(self):
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)
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()
response = self._request_test_document_tag_multiple_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())

44
mayan/apps/tags/tests/test_wizard_steps.py
View File

@@ -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.source = WebFormSource.objects.create(
self.test_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,),
data={
'document_type_id': self.document_type.pk,
viewname='sources:upload_interactive', kwargs={
'source_id': self.test_source.pk
}, data={
'document_type_id': self.test_document_type.pk,
'source-file': file_object,
'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_tag_2()
self._create_test_tag()
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.tag_2 in Document.objects.first().tags.all())
self.assertTrue(self.test_tag in Document.objects.first().tags.all())
self.assertTrue(self.test_tag_2 in Document.objects.first().tags.all())

Some files were not shown because too many files have changed in this diff Show More