From 7f2cfb1717f82b8328463a6113010ecb48ec68c4 Mon Sep 17 00:00:00 2001 From: Hironsan Date: Fri, 23 Apr 2021 15:10:45 +0900 Subject: [PATCH] Split test cases --- backend/api/tests/api/__init__.py | 0 backend/api/tests/api/test_annotation.py | 270 +++ backend/api/tests/api/test_comment.py | 121 ++ backend/api/tests/api/test_document.py | 415 +++++ backend/api/tests/api/test_label.py | 241 +++ backend/api/tests/api/test_other.py | 12 + backend/api/tests/api/test_project.py | 221 +++ backend/api/tests/api/test_role.py | 170 ++ backend/api/tests/api/test_statistics.py | 79 + backend/api/tests/api/test_upload.py | 88 + backend/api/tests/api/test_user.py | 24 + backend/api/tests/api/utils.py | 484 +++++ backend/api/tests/test_api.py | 2049 ---------------------- backend/api/tests/test_views.py | 1 - 14 files changed, 2125 insertions(+), 2050 deletions(-) create mode 100644 backend/api/tests/api/__init__.py create mode 100644 backend/api/tests/api/test_annotation.py create mode 100644 backend/api/tests/api/test_comment.py create mode 100644 backend/api/tests/api/test_document.py create mode 100644 backend/api/tests/api/test_label.py create mode 100644 backend/api/tests/api/test_other.py create mode 100644 backend/api/tests/api/test_project.py create mode 100644 backend/api/tests/api/test_role.py create mode 100644 backend/api/tests/api/test_statistics.py create mode 100644 backend/api/tests/api/test_upload.py create mode 100644 backend/api/tests/api/test_user.py create mode 100644 backend/api/tests/api/utils.py delete mode 100644 backend/api/tests/test_api.py delete mode 100644 backend/api/tests/test_views.py diff --git a/backend/api/tests/api/__init__.py b/backend/api/tests/api/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/backend/api/tests/api/test_annotation.py b/backend/api/tests/api/test_annotation.py new file mode 100644 index 00000000..04f69232 --- /dev/null +++ b/backend/api/tests/api/test_annotation.py @@ -0,0 +1,270 @@ +from django.conf import settings +from django.contrib.auth.models import User +from model_mommy import mommy +from rest_framework import status +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from ...models import SequenceAnnotation +from .utils import (TestUtilsMixin, assign_user_to_role, create_default_roles, + remove_all_role_mappings) + + +class TestAnnotationListAPI(APITestCase, TestUtilsMixin): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.another_project_member_name = 'another_project_member_name' + cls.another_project_member_pass = 'another_project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + another_project_member = User.objects.create_user(username=cls.another_project_member_name, + password=cls.another_project_member_pass) + non_project_member = User.objects.create_user(username=cls.non_project_member_name, + password=cls.non_project_member_pass) + + main_project = mommy.make('SequenceLabelingProject', users=[project_member, another_project_member]) + main_project_label = mommy.make('Label', project=main_project) + main_project_doc = mommy.make('Document', project=main_project) + mommy.make('SequenceAnnotation', document=main_project_doc, user=project_member) + mommy.make('SequenceAnnotation', document=main_project_doc, user=another_project_member) + + sub_project = mommy.make('SequenceLabelingProject', users=[non_project_member]) + sub_project_doc = mommy.make('Document', project=sub_project) + mommy.make('SequenceAnnotation', document=sub_project_doc) + + cls.classification_project = mommy.make('TextClassificationProject', + users=[project_member, another_project_member]) + cls.classification_project_label_1 = mommy.make('Label', project=cls.classification_project) + cls.classification_project_label_2 = mommy.make('Label', project=cls.classification_project) + cls.classification_project_document = mommy.make('Document', project=cls.classification_project) + cls.classification_project_url = reverse( + viewname='annotation_list', args=[cls.classification_project.id, cls.classification_project_document.id]) + assign_user_to_role(project_member=project_member, project=cls.classification_project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=another_project_member, project=cls.classification_project, + role_name=settings.ROLE_ANNOTATOR) + + cls.url = reverse(viewname='annotation_list', args=[main_project.id, main_project_doc.id]) + cls.post_data = {'start_offset': 0, 'end_offset': 1, 'label': main_project_label.id} + cls.num_entity_of_project_member = SequenceAnnotation.objects.filter(document=main_project_doc, + user=project_member).count() + cls.num_entity_of_another_project_member = SequenceAnnotation.objects.filter( + document=main_project_doc, + user=another_project_member).count() + cls.main_project = main_project + assign_user_to_role(project_member=project_member, project=main_project, + role_name=settings.ROLE_ANNOTATOR) + + def test_returns_annotations_to_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + + def test_do_not_return_annotations_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_do_not_return_annotations_of_another_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(len(response.data), self.num_entity_of_project_member) + + def test_returns_annotations_of_another_project_member_if_collaborative_project(self): + self._patch_project(self.main_project, 'collaborative_annotation', True) + + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(len(response.data), + self.num_entity_of_project_member + self.num_entity_of_another_project_member) + + def test_allows_project_member_to_create_annotation(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.post(self.url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_disallows_non_project_member_to_create_annotation(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.post(self.url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allow_replace_annotation_for_single_class_project(self): + self._patch_project(self.classification_project, 'single_class_classification', True) + + self.client.login(username=self.project_member_name, password=self.project_member_pass) + response = self.client.post(self.classification_project_url, format='json', + data={'label': self.classification_project_label_1.id}) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + response = self.client.post(self.classification_project_url, format='json', + data={'label': self.classification_project_label_2.id}) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_allow_replace_annotation_for_single_class_shared_project(self): + self._patch_project(self.classification_project, 'single_class_classification', True) + self._patch_project(self.classification_project, 'collaborative_annotation', True) + + self.client.login(username=self.project_member_name, password=self.project_member_pass) + response = self.client.post(self.classification_project_url, format='json', + data={'label': self.classification_project_label_1.id}) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + self.client.login(username=self.another_project_member_name, password=self.another_project_member_pass) + response = self.client.post(self.classification_project_url, format='json', + data={'label': self.classification_project_label_2.id}) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def _patch_project(self, project, attribute, value): + old_value = getattr(project, attribute, None) + setattr(project, attribute, value) + project.save() + + def cleanup_project(): + setattr(project, attribute, old_value) + project.save() + + self.addCleanup(cleanup_project) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestAnnotationDetailAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.another_project_member_name = 'another_project_member_name' + cls.another_project_member_pass = 'another_project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + # Todo: change super_user to project_admin. + super_user = User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + another_project_member = User.objects.create_user(username=cls.another_project_member_name, + password=cls.another_project_member_pass) + non_project_member = User.objects.create_user(username=cls.non_project_member_name, + password=cls.non_project_member_pass) + + main_project = mommy.make('SequenceLabelingProject', + users=[super_user, project_member, another_project_member]) + main_project_doc = mommy.make('Document', project=main_project) + main_project_entity = mommy.make('SequenceAnnotation', + document=main_project_doc, user=project_member) + another_entity = mommy.make('SequenceAnnotation', + document=main_project_doc, user=another_project_member) + + shared_project = mommy.make('SequenceLabelingProject', + collaborative_annotation=True, + users=[project_member, another_project_member]) + shared_project_doc = mommy.make('Document', project=shared_project) + shared_entity = mommy.make('SequenceAnnotation', document=shared_project_doc, user=another_project_member) + + cls.url = reverse(viewname='annotation_detail', args=[main_project.id, + main_project_doc.id, + main_project_entity.id]) + cls.another_url = reverse(viewname='annotation_detail', args=[main_project.id, + main_project_doc.id, + another_entity.id]) + cls.shared_url = reverse(viewname='annotation_detail', args=[shared_project.id, + shared_project_doc.id, + shared_entity.id]) + cls.post_data = {'start_offset': 0, 'end_offset': 10} + assign_user_to_role(project_member=project_member, project=main_project, role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=project_member, project=shared_project, role_name=settings.ROLE_ANNOTATOR) + + def test_returns_annotation_to_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + + def test_do_not_return_annotation_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_do_not_return_annotation_by_another_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.another_url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_project_member_to_update_annotation(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.patch(self.url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_200_OK) + + def test_disallows_non_project_member_to_update_annotation(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.patch(self.url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_disallows_project_member_to_update_annotation_of_another_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.patch(self.another_url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_superuser_to_delete_annotation_of_another_member(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.delete(self.another_url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + def test_allows_project_member_to_delete_annotation(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + def test_disallows_project_member_to_delete_annotation(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_disallows_project_member_to_delete_annotation_of_another_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.delete(self.another_url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allow_member_to_update_others_annotation_in_shared_project(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.patch(self.shared_url, format='json', data=self.post_data) + self.assertEqual(response.status_code, status.HTTP_200_OK) + + def test_allow_member_to_delete_others_annotation_in_shared_project(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.delete(self.shared_url, format='json') + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() diff --git a/backend/api/tests/api/test_comment.py b/backend/api/tests/api/test_comment.py new file mode 100644 index 00000000..32f65f7a --- /dev/null +++ b/backend/api/tests/api/test_comment.py @@ -0,0 +1,121 @@ +from django.conf import settings +from django.contrib.auth.models import User +from model_mommy import mommy +from rest_framework import status +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from .utils import (assign_user_to_role, create_default_roles, + remove_all_role_mappings) + + +class TestCommentListAPI(APITestCase): + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.another_project_member_name = 'another_project_member_name' + cls.another_project_member_pass = 'another_project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + create_default_roles() + cls.project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + another_project_member = User.objects.create_user(username=cls.another_project_member_name, + password=cls.another_project_member_pass) + User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) + + main_project = mommy.make('SequenceLabelingProject', users=[cls.project_member, another_project_member]) + main_project_doc = mommy.make('Document', project=main_project) + cls.comment = mommy.make('Comment', document=main_project_doc, text='comment 1', user=cls.project_member) + mommy.make('Comment', document=main_project_doc, text='comment 2', user=cls.project_member) + mommy.make('Comment', document=main_project_doc, text='comment 3', user=another_project_member) + + cls.url = reverse(viewname='comment_list_doc', args=[main_project.id, main_project_doc.id]) + cls.url_project = reverse(viewname='comment_list_project', args=[main_project.id]) + + assign_user_to_role(project_member=cls.project_member, project=main_project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=another_project_member, project=main_project, + role_name=settings.ROLE_ANNOTATOR) + + def test_returns_comments_to_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(len(response.data), 3) + + self.client.login(username=self.another_project_member_name, + password=self.another_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(len(response.data), 3) + + def test_does_not_return_comments_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_does_not_allow_deletion_by_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.delete('{}/{}'.format(self.url, self.comment.id), format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_does_not_allow_deletion_of_non_owned_comment(self): + self.client.login(username=self.another_project_member_name, + password=self.another_project_member_pass) + response = self.client.delete('{}/{}'.format(self.url, self.comment.id), format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_create_update_delete_comment(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.post(self.url, format='json', data={'text': 'comment'}) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self.assertEqual(response.data['user'], self.project_member.id) + self.assertEqual(response.data['text'], 'comment') + url = '{}/{}'.format(self.url, response.data['id']) + + # check if all comments are fetched + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(len(response.data), 4) + + # update comment + response = self.client.patch(url, format='json', data={'text': 'new comment'}) + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(response.data['text'], 'new comment') + + # delete comment + response = self.client.delete(url) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(len(response.data), 3) + + def test_returns_project_comments_to_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url_project, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(len(response.data), 3) + + self.client.login(username=self.another_project_member_name, + password=self.another_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(len(response.data), 3) + + def test_does_not_return_project_comments_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url_project, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() diff --git a/backend/api/tests/api/test_document.py b/backend/api/tests/api/test_document.py new file mode 100644 index 00000000..5cc3664c --- /dev/null +++ b/backend/api/tests/api/test_document.py @@ -0,0 +1,415 @@ +from django.conf import settings +from django.contrib.auth.models import User +from model_mommy import mommy +from rest_framework import status +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from ...models import Document +from .utils import (TestUtilsMixin, assign_user_to_role, create_default_roles, + remove_all_role_mappings) + + +class TestDocumentListAPI(APITestCase, TestUtilsMixin): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + non_project_member = User.objects.create_user(username=cls.non_project_member_name, + password=cls.non_project_member_pass) + super_user = User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + + cls.main_project = mommy.make('TextClassificationProject', users=[project_member, super_user]) + doc1 = mommy.make('Document', project=cls.main_project) + doc2 = mommy.make('Document', project=cls.main_project) + mommy.make('Document', project=cls.main_project) + + cls.random_order_project = mommy.make('TextClassificationProject', users=[project_member, super_user], + randomize_document_order=True) + mommy.make('Document', 100, project=cls.random_order_project) + + sub_project = mommy.make('TextClassificationProject', users=[non_project_member]) + mommy.make('Document', project=sub_project) + cls.url = reverse(viewname='doc_list', args=[cls.main_project.id]) + cls.random_order_project_url = reverse(viewname='doc_list', args=[cls.random_order_project.id]) + cls.data = {'text': 'example'} + assign_user_to_role(project_member=project_member, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=project_member, project=cls.random_order_project, + role_name=settings.ROLE_ANNOTATOR) + + mommy.make('DocumentAnnotation', document=doc1, user=project_member) + mommy.make('DocumentAnnotation', document=doc2, user=project_member) + + def _test_list(self, url, username, password, expected_num_results): + self.client.login(username=username, password=password) + response = self.client.get(url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(len(response.json().get('results')), expected_num_results) + + def test_returns_docs_to_project_member(self): + self._test_list(self.url, + username=self.project_member_name, + password=self.project_member_pass, + expected_num_results=3) + + def test_returns_docs_to_project_member_filtered_to_active(self): + self._test_list('{}?doc_annotations__isnull=true'.format(self.url), + username=self.project_member_name, + password=self.project_member_pass, + expected_num_results=1) + + def test_returns_docs_to_project_member_filtered_to_completed(self): + self._test_list('{}?doc_annotations__isnull=false'.format(self.url), + username=self.project_member_name, + password=self.project_member_pass, + expected_num_results=2) + + def test_returns_docs_to_project_member_filtered_to_active_with_collaborative_annotation(self): + self._test_list('{}?doc_annotations__isnull=true'.format(self.url), + username=self.super_user_name, + password=self.super_user_pass, + expected_num_results=3) + + self._patch_project(self.main_project, 'collaborative_annotation', True) + + self._test_list('{}?doc_annotations__isnull=true'.format(self.url), + username=self.super_user_name, + password=self.super_user_pass, + expected_num_results=1) + + def test_returns_docs_to_project_member_filtered_to_completed_with_collaborative_annotation(self): + self._test_list('{}?doc_annotations__isnull=false'.format(self.url), + username=self.super_user_name, + password=self.super_user_pass, + expected_num_results=0) + + self._patch_project(self.main_project, 'collaborative_annotation', True) + + self._test_list('{}?doc_annotations__isnull=false'.format(self.url), + username=self.super_user_name, + password=self.super_user_pass, + expected_num_results=2) + + def test_returns_docs_in_consistent_order_for_all_users(self): + self.client.login(username=self.project_member_name, password=self.project_member_pass) + user1_documents = self.client.get(self.url, format='json').json().get('results') + self.client.logout() + + self.client.login(username=self.super_user_name, password=self.super_user_pass) + user2_documents = self.client.get(self.url, format='json').json().get('results') + self.client.logout() + + self.assertEqual([doc['id'] for doc in user1_documents], [doc['id'] for doc in user2_documents]) + + def test_can_return_docs_in_consistent_random_order(self): + self.client.login(username=self.project_member_name, password=self.project_member_pass) + user1_documents1 = self.client.get(self.random_order_project_url, format='json').json().get('results') + user1_documents2 = self.client.get(self.random_order_project_url, format='json').json().get('results') + self.client.logout() + self.assertEqual(user1_documents1, user1_documents2) + + self.client.login(username=self.super_user_name, password=self.super_user_pass) + user2_documents1 = self.client.get(self.random_order_project_url, format='json').json().get('results') + user2_documents2 = self.client.get(self.random_order_project_url, format='json').json().get('results') + self.client.logout() + self.assertEqual(user2_documents1, user2_documents2) + + self.assertNotEqual(user1_documents1, user2_documents1) + self.assertNotEqual(user1_documents2, user2_documents2) + + def test_do_not_return_docs_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_do_not_return_docs_of_other_projects(self): + self._test_list(self.url, + username=self.project_member_name, + password=self.project_member_pass, + expected_num_results=self.main_project.documents.count()) + + def test_allows_superuser_to_create_doc(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.post(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_disallows_project_member_to_create_doc(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.post(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestDocumentDetailAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + non_project_member = User.objects.create_user(username=cls.non_project_member_name, + password=cls.non_project_member_pass) + # Todo: change super_user to project_admin. + super_user = User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + project = mommy.make('TextClassificationProject', users=[project_member, super_user]) + cls.doc = mommy.make('Document', project=project) + cls.url = reverse(viewname='doc_detail', args=[project.id, cls.doc.id]) + cls.data = {'text': 'example'} + assign_user_to_role(project_member=project_member, project=project, + role_name=settings.ROLE_ANNOTATOR) + + def test_returns_doc_to_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.data['id'], self.doc.id) + + def test_do_not_return_doc_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_superuser_to_update_doc(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.data['text'], self.data['text']) + + def test_disallows_project_member_to_update_doc(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_superuser_to_delete_doc(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + def test_disallows_project_member_to_delete_doc(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestApproveLabelsAPI(APITestCase): + @classmethod + def setUpTestData(cls): + cls.annotator_name = 'annotator_name' + cls.annotator_pass = 'annotator_pass' + cls.approver_name = 'approver_name_name' + cls.approver_pass = 'approver_pass' + cls.project_admin_name = 'project_admin_name' + cls.project_admin_pass = 'project_admin_pass' + create_default_roles() + annotator = User.objects.create_user(username=cls.annotator_name, + password=cls.annotator_pass) + approver = User.objects.create_user(username=cls.approver_name, + password=cls.approver_pass) + project_admin = User.objects.create_user(username=cls.project_admin_name, + password=cls.project_admin_pass) + project = mommy.make('TextClassificationProject', users=[annotator, approver, project_admin]) + cls.doc = mommy.make('Document', project=project) + cls.url = reverse(viewname='approve_labels', args=[project.id, cls.doc.id]) + assign_user_to_role(project_member=annotator, project=project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=approver, project=project, + role_name=settings.ROLE_ANNOTATION_APPROVER) + assign_user_to_role(project_member=project_admin, project=project, + role_name=settings.ROLE_PROJECT_ADMIN) + + def test_allow_project_admin_to_approve_and_disapprove_labels(self): + self.client.login(username=self.project_admin_name, password=self.project_admin_pass) + + response = self.client.post(self.url, format='json', data={'approved': True}) + self.assertEqual(response.data['annotation_approver'], self.project_admin_name) + + response = self.client.post(self.url, format='json', data={'approved': False}) + self.assertIsNone(response.data['annotation_approver']) + + def test_allow_approver_to_approve_and_disapprove_labels(self): + self.client.login(username=self.approver_name, password=self.approver_pass) + + response = self.client.post(self.url, format='json', data={'approved': True}) + self.assertEqual(response.data['annotation_approver'], self.approver_name) + + response = self.client.post(self.url, format='json', data={'approved': False}) + self.assertIsNone(response.data['annotation_approver']) + + def test_disallows_non_annotation_approver_to_approve_and_disapprove_labels(self): + self.client.login(username=self.annotator_name, password=self.annotator_pass) + + response = self.client.post(self.url, format='json', data={'approved': True}) + + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestSearch(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + non_project_member = User.objects.create_user(username=cls.non_project_member_name, + password=cls.non_project_member_pass) + + cls.main_project = mommy.make('TextClassificationProject', users=[project_member]) + cls.search_term = 'example' + doc1 = mommy.make('Document', text=cls.search_term, project=cls.main_project) + doc2 = mommy.make('Document', text='Lorem', project=cls.main_project) + label1 = mommy.make('Label', project=cls.main_project) + label2 = mommy.make('Label', project=cls.main_project) + mommy.make('SequenceAnnotation', document=doc1, user=project_member, label=label1) + mommy.make('SequenceAnnotation', document=doc2, user=project_member, label=label2) + + sub_project = mommy.make('TextClassificationProject', users=[non_project_member]) + mommy.make('Document', text=cls.search_term, project=sub_project) + cls.url = reverse(viewname='doc_list', args=[cls.main_project.id]) + cls.data = {'q': cls.search_term} + assign_user_to_role(project_member=project_member, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + + def test_can_filter_doc_by_term(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=self.data) + count = Document.objects.filter(text__contains=self.search_term, + project=self.main_project).count() + self.assertEqual(response.data['count'], count) + + def test_can_order_doc_by_created_at_ascending(self): + params = {'ordering': 'created_at'} + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=params) + docs = Document.objects.filter(project=self.main_project).order_by('created_at').values() + for d1, d2 in zip(response.data['results'], docs): + self.assertEqual(d1['id'], d2['id']) + + def test_can_order_doc_by_created_at_descending(self): + params = {'ordering': '-created_at'} + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=params) + docs = Document.objects.filter(project=self.main_project).order_by('-created_at').values() + for d1, d2 in zip(response.data['results'], docs): + self.assertEqual(d1['id'], d2['id']) + + def test_can_order_doc_by_annotation_updated_at_ascending(self): + params = {'ordering': 'seq_annotations__updated_at'} + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=params) + docs = Document.objects.filter(project=self.main_project).order_by('seq_annotations__updated_at').values() + for d1, d2 in zip(response.data['results'], docs): + self.assertEqual(d1['id'], d2['id']) + + def test_can_order_doc_by_annotation_updated_at_descending(self): + params = {'ordering': '-seq_annotations__updated_at'} + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=params) + docs = Document.objects.filter(project=self.main_project).order_by('-seq_annotations__updated_at').values() + for d1, d2 in zip(response.data['results'], docs): + self.assertEqual(d1['id'], d2['id']) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestFilter(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + cls.main_project = mommy.make('SequenceLabelingProject', users=[project_member]) + cls.label1 = mommy.make('Label', project=cls.main_project) + cls.label2 = mommy.make('Label', project=cls.main_project) + doc1 = mommy.make('Document', project=cls.main_project) + doc2 = mommy.make('Document', project=cls.main_project) + mommy.make('Document', project=cls.main_project) + mommy.make('SequenceAnnotation', document=doc1, user=project_member, label=cls.label1) + mommy.make('SequenceAnnotation', document=doc2, user=project_member, label=cls.label2) + cls.url = reverse(viewname='doc_list', args=[cls.main_project.id]) + cls.params = {'seq_annotations__label__id': cls.label1.id} + assign_user_to_role(project_member=project_member, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + + def test_can_filter_by_label(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=self.params) + docs = Document.objects.filter(project=self.main_project, + seq_annotations__label__id=self.label1.id).values() + for d1, d2 in zip(response.data['results'], docs): + self.assertEqual(d1['id'], d2['id']) + + def test_can_filter_doc_with_annotation(self): + params = {'seq_annotations__isnull': False} + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=params) + docs = Document.objects.filter(project=self.main_project, seq_annotations__isnull=False).values() + self.assertEqual(response.data['count'], docs.count()) + for d1, d2 in zip(response.data['results'], docs): + self.assertEqual(d1['id'], d2['id']) + + def test_can_filter_doc_without_anotation(self): + params = {'seq_annotations__isnull': True} + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json', data=params) + docs = Document.objects.filter(project=self.main_project, seq_annotations__isnull=True).values() + self.assertEqual(response.data['count'], docs.count()) + for d1, d2 in zip(response.data['results'], docs): + self.assertEqual(d1['id'], d2['id']) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() diff --git a/backend/api/tests/api/test_label.py b/backend/api/tests/api/test_label.py new file mode 100644 index 00000000..a0a0d33a --- /dev/null +++ b/backend/api/tests/api/test_label.py @@ -0,0 +1,241 @@ +import os + +from django.conf import settings +from django.contrib.auth.models import User +from model_mommy import mommy +from rest_framework import status +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from .utils import (DATA_DIR, assign_user_to_role, create_default_roles, + remove_all_role_mappings) + + +class TestLabelListAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + cls.admin_user_name = 'admin_user_name' + cls.admin_user_pass = 'admin_user_pass' + create_default_roles() + cls.project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + non_project_member = User.objects.create_user(username=cls.non_project_member_name, + password=cls.non_project_member_pass) + project_admin = User.objects.create_superuser(username=cls.admin_user_name, + password=cls.admin_user_pass, + email='fizz@buzz.com') + cls.main_project = mommy.make('Project', users=[cls.project_member, project_admin]) + cls.main_project_label = mommy.make('Label', project=cls.main_project) + + sub_project = mommy.make('Project', users=[non_project_member]) + other_project = mommy.make('Project', users=[project_admin]) + mommy.make('Label', project=sub_project) + cls.url = reverse(viewname='label_list', args=[cls.main_project.id]) + cls.other_url = reverse(viewname='label_list', args=[other_project.id]) + cls.data = {'text': 'example'} + assign_user_to_role(project_member=cls.project_member, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + + def test_returns_labels_to_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + + def test_do_not_return_labels_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_do_not_return_labels_of_other_projects(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + label = response.data[0] + num_labels = len(response.data) + self.assertEqual(num_labels, len(self.main_project.labels.all())) + self.assertEqual(label['id'], self.main_project_label.id) + + def test_allows_admin_to_create_label(self): + self.client.login(username=self.admin_user_name, + password=self.admin_user_pass) + response = self.client.post(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_can_create_multiple_labels_without_shortcut_key(self): + self.client.login(username=self.admin_user_name, + password=self.admin_user_pass) + labels = [ + {'text': 'Ruby', 'prefix_key': None, 'suffix_key': None}, + {'text': 'PHP', 'prefix_key': None, 'suffix_key': None} + ] + for label in labels: + response = self.client.post(self.url, format='json', data=label) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_can_create_same_label_in_multiple_projects(self): + self.client.login(username=self.admin_user_name, + password=self.admin_user_pass) + label = {'text': 'LOC', 'prefix_key': None, 'suffix_key': 'l'} + response = self.client.post(self.url, format='json', data=label) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + response = self.client.post(self.other_url, format='json', data=label) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_can_create_same_suffix_with_different_prefix(self): + self.client.login(username=self.admin_user_name, + password=self.admin_user_pass) + label = {'text': 'Person', 'prefix_key': None, 'suffix_key': 'p'} + response = self.client.post(self.url, format='json', data=label) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + label = {'text': 'Percentage', 'prefix_key': 'ctrl', 'suffix_key': 'p'} + response = self.client.post(self.url, format='json', data=label) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_cannot_create_same_shortcut_key(self): + self.client.login(username=self.admin_user_name, + password=self.admin_user_pass) + label = {'text': 'Person', 'prefix_key': None, 'suffix_key': 'p'} + response = self.client.post(self.url, format='json', data=label) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + label = {'text': 'Percentage', 'prefix_key': None, 'suffix_key': 'p'} + response = self.client.post(self.url, format='json', data=label) + self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) + + def test_disallows_project_member_to_create_label(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.post(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestLabelDetailAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) + # Todo: change super_user to project_admin. + super_user = User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + project = mommy.make('Project', users=[project_member, super_user]) + cls.label = mommy.make('Label', project=project) + cls.label_with_shortcut = mommy.make('Label', suffix_key='l', project=project) + cls.url = reverse(viewname='label_detail', args=[project.id, cls.label.id]) + cls.url_with_shortcut = reverse(viewname='label_detail', args=[project.id, cls.label_with_shortcut.id]) + cls.data = {'text': 'example'} + create_default_roles() + assign_user_to_role(project_member=project_member, project=project, + role_name=settings.ROLE_ANNOTATOR) + + def test_returns_label_to_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.data['id'], self.label.id) + + def test_do_not_return_label_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_superuser_to_update_label(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.data['text'], self.data['text']) + + def test_allows_superuser_to_update_label_with_shortcut(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.patch(self.url_with_shortcut, format='json', data={'suffix_key': 's'}) + self.assertEqual(response.data['suffix_key'], 's') + + def test_disallows_project_member_to_update_label(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_superuser_to_delete_label(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + def test_disallows_project_member_to_delete_label(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestLabelUploadAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) + project_admin = User.objects.create_user(username=cls.super_user_name, + password=cls.super_user_pass) + project = mommy.make('Project', users=[project_member, project_admin]) + cls.url = reverse(viewname='label_upload', args=[project.id]) + create_default_roles() + assign_user_to_role(project_member=project_admin, project=project, role_name=settings.ROLE_PROJECT_ADMIN) + assign_user_to_role(project_member=project_member, project=project, role_name=settings.ROLE_ANNOTATOR) + + def help_to_upload_file(self, filename, expected_status): + with open(os.path.join(DATA_DIR, filename), 'rb') as f: + response = self.client.post(self.url, data={'file': f}) + self.assertEqual(response.status_code, expected_status) + + def test_allows_project_admin_to_upload_label(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + self.help_to_upload_file('valid_labels.json', status.HTTP_201_CREATED) + + def test_disallows_project_member_to_upload_label(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + self.help_to_upload_file('valid_labels.json', status.HTTP_403_FORBIDDEN) + + def test_try_to_upload_invalid_file(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + self.help_to_upload_file('invalid_labels.json', status.HTTP_400_BAD_REQUEST) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() diff --git a/backend/api/tests/api/test_other.py b/backend/api/tests/api/test_other.py new file mode 100644 index 00000000..1bce374f --- /dev/null +++ b/backend/api/tests/api/test_other.py @@ -0,0 +1,12 @@ +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + + +class TestHealthEndpoint(APITestCase): + @classmethod + def setUpTestData(cls): + cls.url = reverse(viewname='health') + + def test_returns_green_status_on_health_endpoint(self): + response = self.client.get(self.url, format='json') + self.assertEqual(response.data['status'], 'green') diff --git a/backend/api/tests/api/test_project.py b/backend/api/tests/api/test_project.py new file mode 100644 index 00000000..dbd9fd4d --- /dev/null +++ b/backend/api/tests/api/test_project.py @@ -0,0 +1,221 @@ +from django.conf import settings +from django.contrib.auth.models import User +from django.test import override_settings +from model_mommy import mommy +from rest_framework import status +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from .utils import (assign_user_to_role, create_default_roles, + remove_all_role_mappings) + + +@override_settings(STATICFILES_STORAGE='django.contrib.staticfiles.storage.StaticFilesStorage') +class TestProjectListAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.main_project_member_name = 'project_member_name' + cls.main_project_member_pass = 'project_member_pass' + cls.sub_project_member_name = 'sub_project_member_name' + cls.sub_project_member_pass = 'sub_project_member_pass' + cls.approver_name = 'approver_name_name' + cls.approver_pass = 'approver_pass' + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + create_default_roles() + main_project_member = User.objects.create_user(username=cls.main_project_member_name, + password=cls.main_project_member_pass) + sub_project_member = User.objects.create_user(username=cls.sub_project_member_name, + password=cls.sub_project_member_pass) + approver = User.objects.create_user(username=cls.approver_name, + password=cls.approver_pass) + User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + cls.main_project = mommy.make('TextClassificationProject', users=[main_project_member]) + cls.sub_project = mommy.make('TextClassificationProject', users=[sub_project_member]) + assign_user_to_role(project_member=main_project_member, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=sub_project_member, project=cls.sub_project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=approver, project=cls.main_project, + role_name=settings.ROLE_ANNOTATION_APPROVER) + cls.url = reverse(viewname='project_list') + cls.data = {'name': 'example', 'project_type': 'DocumentClassification', + 'description': 'example', 'guideline': 'example', + 'resourcetype': 'TextClassificationProject'} + cls.num_project = main_project_member.projects.count() + + def test_returns_main_project_to_approver(self): + self.client.login(username=self.approver_name, + password=self.approver_pass) + response = self.client.get(self.url, format='json') + project = response.data[0] + num_project = len(response.data) + self.assertEqual(num_project, self.num_project) + self.assertEqual(project['id'], self.main_project.id) + + def test_returns_main_project_to_main_project_member(self): + self.client.login(username=self.main_project_member_name, + password=self.main_project_member_pass) + response = self.client.get(self.url, format='json') + project = response.data[0] + num_project = len(response.data) + self.assertEqual(num_project, self.num_project) + self.assertEqual(project['id'], self.main_project.id) + + def test_do_not_return_main_project_to_sub_project_member(self): + self.client.login(username=self.sub_project_member_name, + password=self.sub_project_member_pass) + response = self.client.get(self.url, format='json') + project = response.data[0] + num_project = len(response.data) + self.assertEqual(num_project, self.num_project) + self.assertNotEqual(project['id'], self.main_project.id) + + def test_allows_superuser_to_create_project(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.post(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self.assertFalse(response.json().get('collaborative_annotation')) + self.assertFalse(response.json().get('randomize_document_order')) + + def test_allows_superuser_to_create_project_with_flags(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + data = dict(self.data) + data['collaborative_annotation'] = True + data['randomize_document_order'] = True + response = self.client.post(self.url, format='json', data=data) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + self.assertTrue(response.json().get('collaborative_annotation')) + self.assertTrue(response.json().get('randomize_document_order')) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +@override_settings(STATICFILES_STORAGE='django.contrib.staticfiles.storage.StaticFilesStorage') +class TestProjectDetailAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + cls.admin_user_name = 'admin_user_name' + cls.admin_user_pass = 'admin_user_pass' + create_default_roles() + cls.project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + non_project_member = User.objects.create_user(username=cls.non_project_member_name, + password=cls.non_project_member_pass) + project_admin = User.objects.create_superuser(username=cls.admin_user_name, + password=cls.admin_user_pass, + email='fizz@buzz.com') + + cls.main_project = mommy.make('TextClassificationProject', users=[cls.project_member, project_admin]) + mommy.make('TextClassificationProject', users=[non_project_member]) + cls.url = reverse(viewname='project_detail', args=[cls.main_project.id]) + cls.data = {'description': 'lorem'} + assign_user_to_role(project_member=cls.project_member, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=project_admin, project=cls.main_project, + role_name=settings.ROLE_PROJECT_ADMIN) + + def test_returns_main_project_detail_to_main_project_member(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.data['id'], self.main_project.id) + + def test_do_not_return_main_project_to_sub_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_admin_to_update_project(self): + self.client.login(username=self.admin_user_name, + password=self.admin_user_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.data['description'], self.data['description']) + + def test_disallows_non_project_member_to_update_project(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_admin_to_delete_project(self): + self.client.login(username=self.admin_user_name, + password=self.admin_user_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + def test_disallows_non_project_member_to_delete_project(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + +class TestTagAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.main_project_member_name = 'project_member_name' + cls.main_project_member_pass = 'project_member_pass' + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + create_default_roles() + main_project_member = User.objects.create_user(username=cls.main_project_member_name, + password=cls.main_project_member_pass) + super_user = User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + cls.main_project = mommy.make('TextClassificationProject', users=[main_project_member, super_user]) + assign_user_to_role(project_member=main_project_member, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + assign_user_to_role(project_member=super_user, project=cls.main_project, + role_name=settings.ROLE_ANNOTATOR) + cls.tag = mommy.make('Tag', project=cls.main_project, text='Tag 1') + cls.url = reverse(viewname='tag_list', args=[cls.main_project.id]) + cls.project_url = reverse(viewname='project_list') + cls.delete_url = reverse(viewname='tag_list', args=[cls.main_project.id]) + + def test_create_tag(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.post(self.url, data={'text': 'Tag 2'}) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + response = self.client.get(self.project_url, format='json') + self.assertTrue(response.data[0]['tags'][1]['text'] == 'Tag 2' ,'Content of tags differs.') + + def test_tag_list(self): + self.client.login(username=self.main_project_member_name, + password=self.main_project_member_pass) + response = self.client.get(self.project_url, format='json') + self.assertTrue(len(response.data[0]['tags']) == 1 ,'Number of tags differs expected amount.') + self.assertTrue(response.data[0]['tags'][0]['text'] == 'Tag 1' ,'Content of tags differs.') + + def test_delete_tag(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.delete(self.delete_url, data={'id': self.tag.id}) + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + response = self.client.get(self.project_url, format='json') + self.assertTrue(len(response.data[0]['tags']) == 0 ,'Number of tags differs expected amount.') + + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() diff --git a/backend/api/tests/api/test_role.py b/backend/api/tests/api/test_role.py new file mode 100644 index 00000000..38fd3533 --- /dev/null +++ b/backend/api/tests/api/test_role.py @@ -0,0 +1,170 @@ +from django.conf import settings +from django.contrib.auth.models import User +from model_mommy import mommy +from rest_framework import status +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from ...models import Role +from .utils import assign_user_to_role, create_default_roles + + +class TestRoleAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.user_name = 'user_name' + cls.user_pass = 'user_pass' + cls.project_admin_name = 'project_admin_name' + cls.project_admin_pass = 'project_admin_pass' + create_default_roles() + cls.user = User.objects.create_user(username=cls.user_name, + password=cls.user_pass) + User.objects.create_superuser(username=cls.project_admin_name, + password=cls.project_admin_pass, + email='fizz@buzz.com') + cls.url = reverse(viewname='roles') + + def test_cannot_create_multiple_roles_with_same_name(self): + self.client.login(username=self.project_admin_name, + password=self.project_admin_pass) + roles = [ + {'name': 'examplerole', 'description': 'example'}, + {'name': 'examplerole', 'description': 'example'} + ] + self.client.post(self.url, format='json', data=roles[0]) + second_response = self.client.post(self.url, format='json', data=roles[1]) + self.assertEqual(second_response.status_code, status.HTTP_400_BAD_REQUEST) + + def test_nonadmin_cannot_create_role(self): + self.client.login(username=self.user_name, + password=self.user_pass) + data = {'name': 'testrole', 'description': 'example'} + response = self.client.post(self.url, format='json', data=data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_admin_can_create_role(self): + self.client.login(username=self.project_admin_name, + password=self.project_admin_pass) + data = {'name': 'testrole', 'description': 'example'} + response = self.client.post(self.url, format='json', data=data) + self.assertEqual(response.status_code, status.HTTP_201_CREATED) + + def test_admin_can_get_roles(self): + self.client.login(username=self.project_admin_name, + password=self.project_admin_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + + +class TestRoleMappingListAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.second_project_member_name = 'second_project_member_name' + cls.second_project_member_pass = 'second_project_member_pass' + cls.project_admin_name = 'project_admin_name' + cls.project_admin_pass = 'project_admin_pass' + create_default_roles() + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + cls.second_project_member = User.objects.create_user(username=cls.second_project_member_name, + password=cls.second_project_member_pass) + project_admin = User.objects.create_user(username=cls.project_admin_name, + password=cls.project_admin_pass) + cls.main_project = mommy.make('Project', users=[project_member, project_admin, cls.second_project_member]) + cls.other_project = mommy.make('Project', users=[cls.second_project_member, project_admin]) + cls.admin_role = Role.objects.get(name=settings.ROLE_PROJECT_ADMIN) + cls.role = mommy.make('Role', name='otherrole') + assign_user_to_role(project_admin, cls.main_project, cls.admin_role) + cls.data = {'user': project_member.id, 'role': cls.admin_role.id, 'project': cls.main_project.id} + cls.other_url = reverse(viewname='rolemapping_list', args=[cls.other_project.id]) + cls.url = reverse(viewname='rolemapping_list', args=[cls.main_project.id]) + + def test_returns_mappings_to_project_admin(self): + self.client.login(username=self.project_admin_name, + password=self.project_admin_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_200_OK) + + # Todo: refactoring testing. + # def test_allows_superuser_to_create_mapping(self): + # self.client.login(username=self.project_admin_name, + # password=self.project_admin_pass) + # response = self.client.post(self.url, format='json', data=self.data) + # self.assertEqual(response.status_code, status.HTTP_201_CREATED) + # + # def test_do_not_allow_nonadmin_to_create_mapping(self): + # self.client.login(username=self.project_member_name, + # password=self.project_member_pass) + # response = self.client.post(self.url, format='json', data=self.data) + # self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + # + # def test_do_not_return_mappings_to_nonadmin(self): + # self.client.login(username=self.project_member_name, + # password=self.project_member_pass) + # response = self.client.get(self.url, format='json') + # self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + +class TestRoleMappingDetailAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.project_admin_name = 'project_admin_name' + cls.project_admin_pass = 'project_admin_pass' + cls.project_member_name = 'project_member_name' + cls.project_member_pass = 'project_member_pass' + cls.non_project_member_name = 'non_project_member_name' + cls.non_project_member_pass = 'non_project_member_pass' + create_default_roles() + project_admin = User.objects.create_user(username=cls.project_admin_name, + password=cls.project_admin_pass) + project_member = User.objects.create_user(username=cls.project_member_name, + password=cls.project_member_pass) + User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) + project = mommy.make('Project', users=[project_admin, project_member]) + admin_role = Role.objects.get(name=settings.ROLE_PROJECT_ADMIN) + annotator_role = Role.objects.get(name=settings.ROLE_ANNOTATOR) + cls.rolemapping = assign_user_to_role(project_admin, project, admin_role) + assign_user_to_role(project_member, project, annotator_role) + cls.url = reverse(viewname='rolemapping_detail', args=[project.id, cls.rolemapping.id]) + cls.data = {'role': admin_role.id} + + def test_returns_rolemapping_to_project_member(self): + self.client.login(username=self.project_admin_name, + password=self.project_admin_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.data['id'], self.rolemapping.id) + + def test_do_not_return_mapping_to_non_project_member(self): + self.client.login(username=self.non_project_member_name, + password=self.non_project_member_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_admin_to_update_mapping(self): + self.client.login(username=self.project_admin_name, + password=self.project_admin_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.data['role'], self.data['role']) + + def test_disallows_project_member_to_update_mapping(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.patch(self.url, format='json', data=self.data) + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) + + def test_allows_admin_to_delete_mapping(self): + self.client.login(username=self.project_admin_name, + password=self.project_admin_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) + + def test_disallows_project_member_to_delete_mapping(self): + self.client.login(username=self.project_member_name, + password=self.project_member_pass) + response = self.client.delete(self.url, format='json') + self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) diff --git a/backend/api/tests/api/test_statistics.py b/backend/api/tests/api/test_statistics.py new file mode 100644 index 00000000..c2d0a180 --- /dev/null +++ b/backend/api/tests/api/test_statistics.py @@ -0,0 +1,79 @@ +from django.conf import settings +from django.contrib.auth.models import User +from model_mommy import mommy +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from ...models import Document +from .utils import (TestUtilsMixin, assign_user_to_role, create_default_roles, + remove_all_role_mappings) + + +class TestStatisticsAPI(APITestCase, TestUtilsMixin): + + @classmethod + def setUpTestData(cls): + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + cls.other_user_name = 'other_user_name' + cls.other_user_pass = 'other_user_pass' + create_default_roles() + # Todo: change super_user to project_admin. + super_user = User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + + other_user = User.objects.create_user(username=cls.other_user_name, + password=cls.other_user_pass, + email='bar@buzz.com') + + cls.project = mommy.make('TextClassificationProject', users=[super_user]) + doc1 = mommy.make('Document', project=cls.project) + doc2 = mommy.make('Document', project=cls.project) + mommy.make('DocumentAnnotation', document=doc1, user=super_user) + mommy.make('DocumentAnnotation', document=doc2, user=other_user) + cls.url = reverse(viewname='statistics', args=[cls.project.id]) + cls.doc = Document.objects.filter(project=cls.project) + + assign_user_to_role(project_member=other_user, project=cls.project, + role_name=settings.ROLE_ANNOTATOR) + + @classmethod + def doCleanups(cls): + remove_all_role_mappings() + + def test_returns_exact_progress(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.data['total'], 2) + self.assertEqual(response.data['remaining'], 1) + + def test_returns_exact_progress_with_collaborative_annotation(self): + self._patch_project(self.project, 'collaborative_annotation', True) + + self.client.login(username=self.other_user_name, + password=self.other_user_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(response.data['total'], 2) + self.assertEqual(response.data['remaining'], 0) + + def test_returns_user_count(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.get(self.url, format='json') + self.assertIn('label', response.data) + self.assertIsInstance(response.data['label'], dict) + + def test_returns_label_count(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.get(self.url, format='json') + self.assertIn('user', response.data) + self.assertIsInstance(response.data['user'], dict) + + def test_returns_partial_response(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.get(f'{self.url}?include=user', format='json') + self.assertEqual(list(response.data.keys()), ['user']) diff --git a/backend/api/tests/api/test_upload.py b/backend/api/tests/api/test_upload.py new file mode 100644 index 00000000..08b373d8 --- /dev/null +++ b/backend/api/tests/api/test_upload.py @@ -0,0 +1,88 @@ +import os + +from django.contrib.auth.models import User +from django.test import override_settings +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from ...exceptions import FileParseException +from ...utils import (CoNLLParser, CSVParser, FastTextParser, JSONParser, + PlainTextParser) +from .utils import DATA_DIR, create_default_roles + + +class TestFeatures(APITestCase): + @classmethod + def setUpTestData(cls): + cls.user_name = 'user_name' + cls.user_pass = 'user_pass' + create_default_roles() + cls.user = User.objects.create_user(username=cls.user_name, password=cls.user_pass, email='fizz@buzz.com') + + def setUp(self): + self.client.login(username=self.user_name, password=self.user_pass) + + @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_PROVIDER=None) + def test_no_cloud_upload(self): + response = self.client.get(reverse('features')) + + self.assertFalse(response.json().get('cloud_upload')) + + +@override_settings(IMPORT_BATCH_SIZE=2) +class TestParser(APITestCase): + + def parser_helper(self, filename, parser, include_label=True): + with open(os.path.join(DATA_DIR, filename), mode='rb') as f: + result = list(parser.parse(f)) + for data in result: + for r in data: + self.assertIn('text', r) + if include_label: + self.assertIn('labels', r) + return result + + def test_give_valid_data_to_conll_parser(self): + self.parser_helper(filename='labeling.conll', parser=CoNLLParser()) + + def test_give_valid_data_to_conll_parser_with_trailing_newlines(self): + result = self.parser_helper(filename='labeling.trailing.conll', parser=CoNLLParser()) + self.assertEqual(len(result), 1) + self.assertEqual(len(result[0]), 1) + + def test_plain_parser(self): + self.parser_helper(filename='example.txt', parser=PlainTextParser(), include_label=False) + + def test_give_invalid_data_to_conll_parser(self): + with self.assertRaises(FileParseException): + self.parser_helper(filename='labeling.invalid.conll', + parser=CoNLLParser()) + + def test_give_classification_data_to_csv_parser(self): + self.parser_helper(filename='example.csv', parser=CSVParser(), include_label=False) + + def test_give_seq2seq_data_to_csv_parser(self): + self.parser_helper(filename='example.csv', parser=CSVParser(), include_label=False) + + def test_give_classification_data_to_json_parser(self): + self.parser_helper(filename='classification.jsonl', parser=JSONParser()) + + def test_give_labeling_data_to_json_parser(self): + self.parser_helper(filename='labeling.jsonl', parser=JSONParser()) + + def test_give_seq2seq_data_to_json_parser(self): + self.parser_helper(filename='seq2seq.jsonl', parser=JSONParser()) + + def test_give_data_without_label_to_json_parser(self): + self.parser_helper(filename='example.jsonl', parser=JSONParser(), include_label=False) + + def test_give_labeling_data_to_fasttext_parser(self): + self.parser_helper(filename='example_fasttext.txt', parser=FastTextParser()) + + def test_give_data_without_label_name_to_fasttext_parser(self): + with self.assertRaises(FileParseException): + self.parser_helper(filename='example_fasttext_label_tag_without_name.txt', parser=FastTextParser()) + + def test_give_data_without_text_to_fasttext_parser(self): + with self.assertRaises(FileParseException): + self.parser_helper(filename='example_fasttext_without_text.txt', parser=FastTextParser()) diff --git a/backend/api/tests/api/test_user.py b/backend/api/tests/api/test_user.py new file mode 100644 index 00000000..1849106d --- /dev/null +++ b/backend/api/tests/api/test_user.py @@ -0,0 +1,24 @@ +from django.contrib.auth.models import User +from rest_framework.reverse import reverse +from rest_framework.test import APITestCase + +from .utils import create_default_roles + + +class TestUserAPI(APITestCase): + + @classmethod + def setUpTestData(cls): + cls.super_user_name = 'super_user_name' + cls.super_user_pass = 'super_user_pass' + create_default_roles() + User.objects.create_superuser(username=cls.super_user_name, + password=cls.super_user_pass, + email='fizz@buzz.com') + cls.url = reverse(viewname='user_list') + + def test_returns_user_count(self): + self.client.login(username=self.super_user_name, + password=self.super_user_pass) + response = self.client.get(self.url, format='json') + self.assertEqual(1, len(response.data)) diff --git a/backend/api/tests/api/utils.py b/backend/api/tests/api/utils.py new file mode 100644 index 00000000..58689523 --- /dev/null +++ b/backend/api/tests/api/utils.py @@ -0,0 +1,484 @@ +import os + +from django.conf import settings + +from ...models import Role, RoleMapping + +DATA_DIR = os.path.join(os.path.dirname(__file__), '../data') + + +def create_default_roles(): + Role.objects.get_or_create(name=settings.ROLE_PROJECT_ADMIN) + Role.objects.get_or_create(name=settings.ROLE_ANNOTATOR) + Role.objects.get_or_create(name=settings.ROLE_ANNOTATION_APPROVER) + + +def assign_user_to_role(project_member, project, role_name): + role, _ = Role.objects.get_or_create(name=role_name) + if RoleMapping.objects.filter(user=project_member, project=project).exists(): + mapping = RoleMapping.objects.get(user=project_member, project=project) + mapping.role = role + mapping.save() + else: + mapping = RoleMapping.objects.get_or_create(role_id=role.id, user_id=project_member.id, project_id=project.id) + return mapping + + +def remove_all_role_mappings(): + RoleMapping.objects.all().delete() + + +class TestUtilsMixin: + def _patch_project(self, project, attribute, value): + old_value = getattr(project, attribute, None) + setattr(project, attribute, value) + project.save() + + def cleanup_project(): + setattr(project, attribute, old_value) + project.save() + + self.addCleanup(cleanup_project) + +# class TestImportExportIntegrity(APITestCase): +# """Tests that check for equality between imported and exported data of a file. """ +# @classmethod +# def setUpTestData(cls): +# cls.super_user_name = 'super_user_name' +# cls.super_user_pass = 'super_user_pass' +# create_default_roles() +# super_user = User.objects.create_superuser(username=cls.super_user_name, +# password=cls.super_user_pass, +# email='fizz@buzz.com') +# cls.classification_project = mommy.make('TextClassificationProject', +# users=[super_user], project_type=DOCUMENT_CLASSIFICATION) +# +# cls.classification_upload_url = reverse(viewname='doc_uploader', args=[cls.classification_project.id]) +# cls.classification_download_url = reverse(viewname='doc_downloader', args=[cls.classification_project.id]) +# assign_user_to_role(project_member=super_user, project=cls.classification_project, +# role_name=settings.ROLE_PROJECT_ADMIN) +# +# def setUp(self): +# self.client.login(username=self.super_user_name, +# password=self.super_user_pass) +# +# def load_test_helper(self, upload_url, download_url, filename, import_format, export_format, response_format="text/csv; charset=utf-8",**kwargs): +# parser = TextUploadAPI.select_parser(import_format) +# with open(os.path.join(DATA_DIR, filename), 'rb') as f: +# self.client.post(upload_url, data={'file': f, 'format': import_format}) +# f.seek(0) +# imported = parser.parse(f) +# import_data = [elem for elem in [x for elem in imported for x in elem] if elem.get('labels')] +# +# r = self.client.get(download_url, data={'q': export_format}, HTTP_ACCEPT=response_format) +# b = BytesIO(r.content) +# if export_format == 'txt': +# export_format = import_format +# parser = TextUploadAPI.select_parser(export_format) +# exported = parser.parse(b) +# exported_data = [x for elem in exported for x in elem if x.get('labels') or x.get('annotations')] +# self.assertTrue(len(import_data) == len(exported_data), 'Length of imported dataset does not match exported') +# return import_data, exported_data +# +# # Classification +# def test_jsonl_classification_import_export_integrity(self): +# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, +# download_url=self.classification_download_url, +# filename='classification.jsonl', +# import_format='json', +# project=self.classification_project, +# export_format='json', +# response_format='application/json') +# label_mapping = {label.id: label.text for label in self.classification_project.labels.all()} +# for im, ex in zip(import_data, export_data): +# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') +# ex_labels = set(label_mapping[int(x.get('label'))] for x in ex.get('annotations', [])) +# self.assertFalse(set(im.get('labels')).symmetric_difference(ex_labels), 'Integritycheck failed. Labels differ.') +# +# def test_csv_classification_import_export_integrity(self): +# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, +# download_url=self.classification_download_url, +# filename='example.csv', +# import_format='csv', +# project=self.classification_project, +# export_format='csv') +# label_mapping = {label.id: label.text for label in self.classification_project.labels.all()} +# for im, ex in zip(import_data, export_data): +# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') +# ex_labels = [label_mapping[int(elem)] for elem in ex.get('labels', [])] +# self.assertTrue(im.get('labels') == ex_labels, 'Integritycheck failed. Labels differ.') +# +# def test_xlsx_classification_import_export_integrity(self): +# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, +# download_url=self.classification_download_url, +# filename='example.xlsx', +# import_format='excel', +# project=self.classification_project, +# export_format='csv') +# label_mapping = {label.id: label.text for label in self.classification_project.labels.all()} +# for im, ex in zip(import_data, export_data): +# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') +# ex_labels = [label_mapping[int(elem)] for elem in ex.get('labels', [])] +# self.assertTrue(im.get('labels') == ex_labels, 'Integritycheck failed. Labels differ.') +# +# def test_fasttext_classification_import_export_integrity(self): +# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, +# download_url=self.classification_download_url, +# filename='example_fasttext.txt', +# import_format='fastText', +# project=self.classification_project, +# export_format='txt') +# for im, ex in zip(import_data, export_data): +# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') +# self.assertFalse(set(im.get('labels')).symmetric_difference(ex.get('labels')), 'Integritycheck failed. Labels differ.') +# +# @classmethod +# def doCleanups(cls): +# remove_all_role_mappings() + +# class TestUploader(APITestCase): +# +# @classmethod +# def setUpTestData(cls): +# cls.super_user_name = 'super_user_name' +# cls.super_user_pass = 'super_user_pass' +# # Todo: change super_user to project_admin. +# create_default_roles() +# super_user = User.objects.create_superuser(username=cls.super_user_name, +# password=cls.super_user_pass, +# email='fizz@buzz.com') +# cls.classification_project = mommy.make('TextClassificationProject', +# users=[super_user], project_type=DOCUMENT_CLASSIFICATION) +# cls.labeling_project = mommy.make('SequenceLabelingProject', +# users=[super_user], project_type=SEQUENCE_LABELING) +# cls.seq2seq_project = mommy.make('Seq2seqProject', users=[super_user], project_type=SEQ2SEQ) +# assign_user_to_role(project_member=super_user, project=cls.classification_project, +# role_name=settings.ROLE_PROJECT_ADMIN) +# assign_user_to_role(project_member=super_user, project=cls.labeling_project, +# role_name=settings.ROLE_PROJECT_ADMIN) +# assign_user_to_role(project_member=super_user, project=cls.seq2seq_project, +# role_name=settings.ROLE_PROJECT_ADMIN) +# +# def setUp(self): +# self.client.login(username=self.super_user_name, +# password=self.super_user_pass) +# +# def upload_test_helper(self, project_id, filename, file_format, expected_status, **kwargs): +# url = reverse(viewname='doc_uploader', args=[project_id]) +# +# with open(os.path.join(DATA_DIR, filename), 'rb') as f: +# response = self.client.post(url, data={'file': f, 'format': file_format}) +# +# self.assertEqual(response.status_code, expected_status) +# +# def label_test_helper(self, project_id, expected_labels, expected_label_keys): +# url = reverse(viewname='label_list', args=[project_id]) +# expected_keys = {key for label in expected_labels for key in label} +# +# response = self.client.get(url).json() +# +# actual_labels = [{key: value for (key, value) in label.items() if key in expected_keys} +# for label in response] +# +# self.assertCountEqual(actual_labels, expected_labels) +# +# for label in response: +# for expected_label_key in expected_label_keys: +# self.assertIsNotNone(label.get(expected_label_key)) +# +# def test_can_upload_conll_format_file(self): +# self.upload_test_helper(project_id=self.labeling_project.id, +# filename='labeling.conll', +# file_format='conll', +# expected_status=status.HTTP_201_CREATED) +# +# def test_cannot_upload_wrong_conll_format_file(self): +# self.upload_test_helper(project_id=self.labeling_project.id, +# filename='labeling.invalid.conll', +# file_format='conll', +# expected_status=status.HTTP_400_BAD_REQUEST) +# +# def test_can_upload_classification_csv(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.csv', +# file_format='csv', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_classification_csv_with_out_of_order_columns(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example_out_of_order_columns.csv', +# file_format='csv', +# expected_status=status.HTTP_201_CREATED) +# +# self.label_test_helper( +# project_id=self.classification_project.id, +# expected_labels=[ +# {'text': 'Positive'}, +# {'text': 'Negative'}, +# ], +# expected_label_keys=[], +# ) +# +# def test_can_upload_csv_with_non_utf8_encoding(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.utf16.csv', +# file_format='csv', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_seq2seq_csv(self): +# self.upload_test_helper(project_id=self.seq2seq_project.id, +# filename='example.csv', +# file_format='csv', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_single_column_csv(self): +# self.upload_test_helper(project_id=self.seq2seq_project.id, +# filename='example_one_column.csv', +# file_format='csv', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_csv_file_does_not_match_column_and_row(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example_column_and_row_not_matching.csv', +# file_format='csv', +# expected_status=status.HTTP_201_CREATED) +# +# def test_cannot_upload_csv_file_has_too_many_columns(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.invalid.2.csv', +# file_format='csv', +# expected_status=status.HTTP_400_BAD_REQUEST) +# +# def test_can_upload_classification_excel(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.xlsx', +# file_format='excel', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_seq2seq_excel(self): +# self.upload_test_helper(project_id=self.seq2seq_project.id, +# filename='example.xlsx', +# file_format='excel', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_single_column_excel(self): +# self.upload_test_helper(project_id=self.seq2seq_project.id, +# filename='example_one_column.xlsx', +# file_format='excel', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_excel_file_does_not_match_column_and_row(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example_column_and_row_not_matching.xlsx', +# file_format='excel', +# expected_status=status.HTTP_201_CREATED) +# +# def test_cannot_upload_excel_file_has_too_many_columns(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.invalid.2.xlsx', +# file_format='excel', +# expected_status=status.HTTP_400_BAD_REQUEST) +# +# @override_settings(IMPORT_BATCH_SIZE=1) +# def test_can_upload_small_batch_size(self): +# self.upload_test_helper(project_id=self.seq2seq_project.id, +# filename='example_one_column_no_header.xlsx', +# file_format='excel', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_classification_jsonl(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='classification.jsonl', +# file_format='json', +# expected_status=status.HTTP_201_CREATED) +# +# self.label_test_helper( +# project_id=self.classification_project.id, +# expected_labels=[ +# {'text': 'positive', 'suffix_key': 'p', 'prefix_key': None}, +# {'text': 'negative', 'suffix_key': 'n', 'prefix_key': None}, +# {'text': 'neutral', 'suffix_key': 'n', 'prefix_key': 'ctrl'}, +# ], +# expected_label_keys=[ +# 'background_color', +# 'text_color', +# ]) +# +# def test_can_upload_labeling_jsonl(self): +# self.upload_test_helper(project_id=self.labeling_project.id, +# filename='labeling.jsonl', +# file_format='json', +# expected_status=status.HTTP_201_CREATED) +# +# self.label_test_helper( +# project_id=self.labeling_project.id, +# expected_labels=[ +# {'text': 'LOC', 'suffix_key': 'l', 'prefix_key': None}, +# {'text': 'ORG', 'suffix_key': 'o', 'prefix_key': None}, +# {'text': 'PER', 'suffix_key': 'p', 'prefix_key': None}, +# ], +# expected_label_keys=[ +# 'background_color', +# 'text_color', +# ]) +# +# def test_can_upload_seq2seq_jsonl(self): +# self.upload_test_helper(project_id=self.seq2seq_project.id, +# filename='seq2seq.jsonl', +# file_format='json', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_plain_text(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.txt', +# file_format='plain', +# expected_status=status.HTTP_201_CREATED) +# +# def test_can_upload_data_without_label(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.jsonl', +# file_format='json', +# expected_status=status.HTTP_201_CREATED) +# +# @classmethod +# def doCleanups(cls): +# remove_all_role_mappings() + + +# @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_PROVIDER='LOCAL') +# @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_ACCOUNT=os.path.dirname(DATA_DIR)) +# @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_SECRET_KEY='not-used') +# class TestCloudUploader(TestUploader): +# def upload_test_helper(self, project_id, filename, file_format, expected_status, **kwargs): +# query_params = { +# 'project_id': project_id, +# 'upload_format': file_format, +# 'container': kwargs.pop('container', os.path.basename(DATA_DIR)), +# 'object': filename, +# } +# +# query_params.update(kwargs) +# +# response = self.client.get(reverse('cloud_uploader'), query_params) +# +# self.assertEqual(response.status_code, expected_status) +# +# def test_cannot_upload_with_missing_file(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='does-not-exist', +# file_format='json', +# expected_status=status.HTTP_400_BAD_REQUEST) +# +# def test_cannot_upload_with_missing_container(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.jsonl', +# container='does-not-exist', +# file_format='json', +# expected_status=status.HTTP_400_BAD_REQUEST) +# +# def test_cannot_upload_with_missing_query_parameters(self): +# response = self.client.get(reverse('cloud_uploader'), {'project_id': self.classification_project.id}) +# +# self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) +# +# def test_can_upload_with_redirect(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.jsonl', +# next='http://somewhere', +# file_format='json', +# expected_status=status.HTTP_302_FOUND) +# +# def test_can_upload_with_redirect_to_blank(self): +# self.upload_test_helper(project_id=self.classification_project.id, +# filename='example.jsonl', +# next='about:blank', +# file_format='json', +# expected_status=status.HTTP_201_CREATED) + + +# class TestDownloader(APITestCase): +# +# @classmethod +# def setUpTestData(cls): +# cls.super_user_name = 'super_user_name' +# cls.super_user_pass = 'super_user_pass' +# # Todo: change super_user to project_admin. +# create_default_roles() +# super_user = User.objects.create_superuser(username=cls.super_user_name, +# password=cls.super_user_pass, +# email='fizz@buzz.com') +# cls.classification_project = mommy.make('TextClassificationProject', +# users=[super_user], project_type=DOCUMENT_CLASSIFICATION) +# cls.labeling_project = mommy.make('SequenceLabelingProject', +# users=[super_user], project_type=SEQUENCE_LABELING) +# cls.seq2seq_project = mommy.make('Seq2seqProject', users=[super_user], project_type=SEQ2SEQ) +# cls.speech2text_project = mommy.make('Speech2textProject', users=[super_user], project_type=SPEECH2TEXT) +# cls.classification_url = reverse(viewname='doc_downloader', args=[cls.classification_project.id]) +# cls.labeling_url = reverse(viewname='doc_downloader', args=[cls.labeling_project.id]) +# cls.seq2seq_url = reverse(viewname='doc_downloader', args=[cls.seq2seq_project.id]) +# cls.speech2text_url = reverse(viewname='doc_downloader', args=[cls.speech2text_project.id]) +# +# def setUp(self): +# self.client.login(username=self.super_user_name, +# password=self.super_user_pass) +# +# def download_test_helper(self, url, format, expected_status): +# response = self.client.get(url, data={'q': format}) +# self.assertEqual(response.status_code, expected_status) +# +# def test_cannot_download_conll_format_file(self): +# self.download_test_helper(url=self.labeling_url, +# format='conll', +# expected_status=status.HTTP_400_BAD_REQUEST) +# +# def test_can_download_classification_csv(self): +# self.download_test_helper(url=self.classification_url, +# format='csv', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_labeling_csv(self): +# self.download_test_helper(url=self.labeling_url, +# format='csv', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_seq2seq_csv(self): +# self.download_test_helper(url=self.seq2seq_url, +# format='csv', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_classification_jsonl(self): +# self.download_test_helper(url=self.classification_url, +# format='json', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_labeling_jsonl(self): +# self.download_test_helper(url=self.labeling_url, +# format='json', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_seq2seq_jsonl(self): +# self.download_test_helper(url=self.seq2seq_url, +# format='json', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_speech2text_jsonl(self): +# self.download_test_helper(url=self.speech2text_url, +# format='json', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_labelling_jsonl(self): +# self.download_test_helper(url=self.labeling_url, +# format='jsonl', +# expected_status=status.HTTP_200_OK) +# +# def test_can_download_plain_text(self): +# self.download_test_helper(url=self.classification_url, +# format='plain', +# expected_status=status.HTTP_400_BAD_REQUEST) +# +# def test_can_download_classification_fasttext(self): +# self.download_test_helper(url=self.classification_url, +# format='txt', +# expected_status=status.HTTP_200_OK) + + diff --git a/backend/api/tests/test_api.py b/backend/api/tests/test_api.py deleted file mode 100644 index d4ea2b0f..00000000 --- a/backend/api/tests/test_api.py +++ /dev/null @@ -1,2049 +0,0 @@ -import os -from io import BytesIO - -from django.conf import settings -from django.test import override_settings -from model_mommy import mommy -from rest_framework import status -from rest_framework.reverse import reverse -from rest_framework.test import APITestCase - -from ..exceptions import FileParseException -from ..models import (DOCUMENT_CLASSIFICATION, SEQ2SEQ, SEQUENCE_LABELING, - SPEECH2TEXT, Document, Role, RoleMapping, - SequenceAnnotation, User) -from ..utils import (CoNLLParser, CSVParser, FastTextParser, JSONParser, - PlainTextParser) -from ..views import TextUploadAPI - -DATA_DIR = os.path.join(os.path.dirname(__file__), 'data') - - -def create_default_roles(): - Role.objects.get_or_create(name=settings.ROLE_PROJECT_ADMIN) - Role.objects.get_or_create(name=settings.ROLE_ANNOTATOR) - Role.objects.get_or_create(name=settings.ROLE_ANNOTATION_APPROVER) - - -def assign_user_to_role(project_member, project, role_name): - role, _ = Role.objects.get_or_create(name=role_name) - if RoleMapping.objects.filter(user=project_member, project=project).exists(): - mapping = RoleMapping.objects.get(user=project_member, project=project) - mapping.role = role - mapping.save() - else: - mapping = RoleMapping.objects.get_or_create(role_id=role.id, user_id=project_member.id, project_id=project.id) - return mapping - - -def remove_all_role_mappings(): - RoleMapping.objects.all().delete() - - -class TestHealthEndpoint(APITestCase): - @classmethod - def setUpTestData(cls): - cls.url = reverse(viewname='health') - - def test_returns_green_status_on_health_endpoint(self): - response = self.client.get(self.url, format='json') - self.assertEqual(response.data['status'], 'green') - - -class TestUtilsMixin: - def _patch_project(self, project, attribute, value): - old_value = getattr(project, attribute, None) - setattr(project, attribute, value) - project.save() - - def cleanup_project(): - setattr(project, attribute, old_value) - project.save() - - self.addCleanup(cleanup_project) - - -@override_settings(STATICFILES_STORAGE='django.contrib.staticfiles.storage.StaticFilesStorage') -class TestProjectListAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.main_project_member_name = 'project_member_name' - cls.main_project_member_pass = 'project_member_pass' - cls.sub_project_member_name = 'sub_project_member_name' - cls.sub_project_member_pass = 'sub_project_member_pass' - cls.approver_name = 'approver_name_name' - cls.approver_pass = 'approver_pass' - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - create_default_roles() - main_project_member = User.objects.create_user(username=cls.main_project_member_name, - password=cls.main_project_member_pass) - sub_project_member = User.objects.create_user(username=cls.sub_project_member_name, - password=cls.sub_project_member_pass) - approver = User.objects.create_user(username=cls.approver_name, - password=cls.approver_pass) - User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - cls.main_project = mommy.make('TextClassificationProject', users=[main_project_member]) - cls.sub_project = mommy.make('TextClassificationProject', users=[sub_project_member]) - assign_user_to_role(project_member=main_project_member, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=sub_project_member, project=cls.sub_project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=approver, project=cls.main_project, - role_name=settings.ROLE_ANNOTATION_APPROVER) - cls.url = reverse(viewname='project_list') - cls.data = {'name': 'example', 'project_type': 'DocumentClassification', - 'description': 'example', 'guideline': 'example', - 'resourcetype': 'TextClassificationProject'} - cls.num_project = main_project_member.projects.count() - - def test_returns_main_project_to_approver(self): - self.client.login(username=self.approver_name, - password=self.approver_pass) - response = self.client.get(self.url, format='json') - project = response.data[0] - num_project = len(response.data) - self.assertEqual(num_project, self.num_project) - self.assertEqual(project['id'], self.main_project.id) - - def test_returns_main_project_to_main_project_member(self): - self.client.login(username=self.main_project_member_name, - password=self.main_project_member_pass) - response = self.client.get(self.url, format='json') - project = response.data[0] - num_project = len(response.data) - self.assertEqual(num_project, self.num_project) - self.assertEqual(project['id'], self.main_project.id) - - def test_do_not_return_main_project_to_sub_project_member(self): - self.client.login(username=self.sub_project_member_name, - password=self.sub_project_member_pass) - response = self.client.get(self.url, format='json') - project = response.data[0] - num_project = len(response.data) - self.assertEqual(num_project, self.num_project) - self.assertNotEqual(project['id'], self.main_project.id) - - def test_allows_superuser_to_create_project(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.post(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - self.assertFalse(response.json().get('collaborative_annotation')) - self.assertFalse(response.json().get('randomize_document_order')) - - def test_allows_superuser_to_create_project_with_flags(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - data = dict(self.data) - data['collaborative_annotation'] = True - data['randomize_document_order'] = True - response = self.client.post(self.url, format='json', data=data) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - self.assertTrue(response.json().get('collaborative_annotation')) - self.assertTrue(response.json().get('randomize_document_order')) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -@override_settings(STATICFILES_STORAGE='django.contrib.staticfiles.storage.StaticFilesStorage') -class TestProjectDetailAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - cls.admin_user_name = 'admin_user_name' - cls.admin_user_pass = 'admin_user_pass' - create_default_roles() - cls.project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - non_project_member = User.objects.create_user(username=cls.non_project_member_name, - password=cls.non_project_member_pass) - project_admin = User.objects.create_superuser(username=cls.admin_user_name, - password=cls.admin_user_pass, - email='fizz@buzz.com') - - cls.main_project = mommy.make('TextClassificationProject', users=[cls.project_member, project_admin]) - mommy.make('TextClassificationProject', users=[non_project_member]) - cls.url = reverse(viewname='project_detail', args=[cls.main_project.id]) - cls.data = {'description': 'lorem'} - assign_user_to_role(project_member=cls.project_member, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=project_admin, project=cls.main_project, - role_name=settings.ROLE_PROJECT_ADMIN) - - def test_returns_main_project_detail_to_main_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.data['id'], self.main_project.id) - - def test_do_not_return_main_project_to_sub_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_admin_to_update_project(self): - self.client.login(username=self.admin_user_name, - password=self.admin_user_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.data['description'], self.data['description']) - - def test_disallows_non_project_member_to_update_project(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_admin_to_delete_project(self): - self.client.login(username=self.admin_user_name, - password=self.admin_user_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - - def test_disallows_non_project_member_to_delete_project(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestLabelListAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - cls.admin_user_name = 'admin_user_name' - cls.admin_user_pass = 'admin_user_pass' - create_default_roles() - cls.project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - non_project_member = User.objects.create_user(username=cls.non_project_member_name, - password=cls.non_project_member_pass) - project_admin = User.objects.create_superuser(username=cls.admin_user_name, - password=cls.admin_user_pass, - email='fizz@buzz.com') - cls.main_project = mommy.make('Project', users=[cls.project_member, project_admin]) - cls.main_project_label = mommy.make('Label', project=cls.main_project) - - sub_project = mommy.make('Project', users=[non_project_member]) - other_project = mommy.make('Project', users=[project_admin]) - mommy.make('Label', project=sub_project) - cls.url = reverse(viewname='label_list', args=[cls.main_project.id]) - cls.other_url = reverse(viewname='label_list', args=[other_project.id]) - cls.data = {'text': 'example'} - assign_user_to_role(project_member=cls.project_member, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - - def test_returns_labels_to_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - - def test_do_not_return_labels_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_do_not_return_labels_of_other_projects(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - label = response.data[0] - num_labels = len(response.data) - self.assertEqual(num_labels, len(self.main_project.labels.all())) - self.assertEqual(label['id'], self.main_project_label.id) - - def test_allows_admin_to_create_label(self): - self.client.login(username=self.admin_user_name, - password=self.admin_user_pass) - response = self.client.post(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_can_create_multiple_labels_without_shortcut_key(self): - self.client.login(username=self.admin_user_name, - password=self.admin_user_pass) - labels = [ - {'text': 'Ruby', 'prefix_key': None, 'suffix_key': None}, - {'text': 'PHP', 'prefix_key': None, 'suffix_key': None} - ] - for label in labels: - response = self.client.post(self.url, format='json', data=label) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_can_create_same_label_in_multiple_projects(self): - self.client.login(username=self.admin_user_name, - password=self.admin_user_pass) - label = {'text': 'LOC', 'prefix_key': None, 'suffix_key': 'l'} - response = self.client.post(self.url, format='json', data=label) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - response = self.client.post(self.other_url, format='json', data=label) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_can_create_same_suffix_with_different_prefix(self): - self.client.login(username=self.admin_user_name, - password=self.admin_user_pass) - label = {'text': 'Person', 'prefix_key': None, 'suffix_key': 'p'} - response = self.client.post(self.url, format='json', data=label) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - label = {'text': 'Percentage', 'prefix_key': 'ctrl', 'suffix_key': 'p'} - response = self.client.post(self.url, format='json', data=label) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_cannot_create_same_shortcut_key(self): - self.client.login(username=self.admin_user_name, - password=self.admin_user_pass) - label = {'text': 'Person', 'prefix_key': None, 'suffix_key': 'p'} - response = self.client.post(self.url, format='json', data=label) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - label = {'text': 'Percentage', 'prefix_key': None, 'suffix_key': 'p'} - response = self.client.post(self.url, format='json', data=label) - self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) - - def test_disallows_project_member_to_create_label(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.post(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestLabelDetailAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) - # Todo: change super_user to project_admin. - super_user = User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - project = mommy.make('Project', users=[project_member, super_user]) - cls.label = mommy.make('Label', project=project) - cls.label_with_shortcut = mommy.make('Label', suffix_key='l', project=project) - cls.url = reverse(viewname='label_detail', args=[project.id, cls.label.id]) - cls.url_with_shortcut = reverse(viewname='label_detail', args=[project.id, cls.label_with_shortcut.id]) - cls.data = {'text': 'example'} - create_default_roles() - assign_user_to_role(project_member=project_member, project=project, - role_name=settings.ROLE_ANNOTATOR) - - def test_returns_label_to_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.data['id'], self.label.id) - - def test_do_not_return_label_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_superuser_to_update_label(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.data['text'], self.data['text']) - - def test_allows_superuser_to_update_label_with_shortcut(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.patch(self.url_with_shortcut, format='json', data={'suffix_key': 's'}) - self.assertEqual(response.data['suffix_key'], 's') - - def test_disallows_project_member_to_update_label(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_superuser_to_delete_label(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - - def test_disallows_project_member_to_delete_label(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestLabelUploadAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) - project_admin = User.objects.create_user(username=cls.super_user_name, - password=cls.super_user_pass) - project = mommy.make('Project', users=[project_member, project_admin]) - cls.url = reverse(viewname='label_upload', args=[project.id]) - create_default_roles() - assign_user_to_role(project_member=project_admin, project=project, role_name=settings.ROLE_PROJECT_ADMIN) - assign_user_to_role(project_member=project_member, project=project, role_name=settings.ROLE_ANNOTATOR) - - def help_to_upload_file(self, filename, expected_status): - with open(os.path.join(DATA_DIR, filename), 'rb') as f: - response = self.client.post(self.url, data={'file': f}) - self.assertEqual(response.status_code, expected_status) - - def test_allows_project_admin_to_upload_label(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - self.help_to_upload_file('valid_labels.json', status.HTTP_201_CREATED) - - def test_disallows_project_member_to_upload_label(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - self.help_to_upload_file('valid_labels.json', status.HTTP_403_FORBIDDEN) - - def test_try_to_upload_invalid_file(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - self.help_to_upload_file('invalid_labels.json', status.HTTP_400_BAD_REQUEST) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestDocumentListAPI(APITestCase, TestUtilsMixin): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - non_project_member = User.objects.create_user(username=cls.non_project_member_name, - password=cls.non_project_member_pass) - super_user = User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - - cls.main_project = mommy.make('TextClassificationProject', users=[project_member, super_user]) - doc1 = mommy.make('Document', project=cls.main_project) - doc2 = mommy.make('Document', project=cls.main_project) - mommy.make('Document', project=cls.main_project) - - cls.random_order_project = mommy.make('TextClassificationProject', users=[project_member, super_user], - randomize_document_order=True) - mommy.make('Document', 100, project=cls.random_order_project) - - sub_project = mommy.make('TextClassificationProject', users=[non_project_member]) - mommy.make('Document', project=sub_project) - cls.url = reverse(viewname='doc_list', args=[cls.main_project.id]) - cls.random_order_project_url = reverse(viewname='doc_list', args=[cls.random_order_project.id]) - cls.data = {'text': 'example'} - assign_user_to_role(project_member=project_member, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=project_member, project=cls.random_order_project, - role_name=settings.ROLE_ANNOTATOR) - - mommy.make('DocumentAnnotation', document=doc1, user=project_member) - mommy.make('DocumentAnnotation', document=doc2, user=project_member) - - def _test_list(self, url, username, password, expected_num_results): - self.client.login(username=username, password=password) - response = self.client.get(url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(len(response.json().get('results')), expected_num_results) - - def test_returns_docs_to_project_member(self): - self._test_list(self.url, - username=self.project_member_name, - password=self.project_member_pass, - expected_num_results=3) - - def test_returns_docs_to_project_member_filtered_to_active(self): - self._test_list('{}?doc_annotations__isnull=true'.format(self.url), - username=self.project_member_name, - password=self.project_member_pass, - expected_num_results=1) - - def test_returns_docs_to_project_member_filtered_to_completed(self): - self._test_list('{}?doc_annotations__isnull=false'.format(self.url), - username=self.project_member_name, - password=self.project_member_pass, - expected_num_results=2) - - def test_returns_docs_to_project_member_filtered_to_active_with_collaborative_annotation(self): - self._test_list('{}?doc_annotations__isnull=true'.format(self.url), - username=self.super_user_name, - password=self.super_user_pass, - expected_num_results=3) - - self._patch_project(self.main_project, 'collaborative_annotation', True) - - self._test_list('{}?doc_annotations__isnull=true'.format(self.url), - username=self.super_user_name, - password=self.super_user_pass, - expected_num_results=1) - - def test_returns_docs_to_project_member_filtered_to_completed_with_collaborative_annotation(self): - self._test_list('{}?doc_annotations__isnull=false'.format(self.url), - username=self.super_user_name, - password=self.super_user_pass, - expected_num_results=0) - - self._patch_project(self.main_project, 'collaborative_annotation', True) - - self._test_list('{}?doc_annotations__isnull=false'.format(self.url), - username=self.super_user_name, - password=self.super_user_pass, - expected_num_results=2) - - def test_returns_docs_in_consistent_order_for_all_users(self): - self.client.login(username=self.project_member_name, password=self.project_member_pass) - user1_documents = self.client.get(self.url, format='json').json().get('results') - self.client.logout() - - self.client.login(username=self.super_user_name, password=self.super_user_pass) - user2_documents = self.client.get(self.url, format='json').json().get('results') - self.client.logout() - - self.assertEqual([doc['id'] for doc in user1_documents], [doc['id'] for doc in user2_documents]) - - def test_can_return_docs_in_consistent_random_order(self): - self.client.login(username=self.project_member_name, password=self.project_member_pass) - user1_documents1 = self.client.get(self.random_order_project_url, format='json').json().get('results') - user1_documents2 = self.client.get(self.random_order_project_url, format='json').json().get('results') - self.client.logout() - self.assertEqual(user1_documents1, user1_documents2) - - self.client.login(username=self.super_user_name, password=self.super_user_pass) - user2_documents1 = self.client.get(self.random_order_project_url, format='json').json().get('results') - user2_documents2 = self.client.get(self.random_order_project_url, format='json').json().get('results') - self.client.logout() - self.assertEqual(user2_documents1, user2_documents2) - - self.assertNotEqual(user1_documents1, user2_documents1) - self.assertNotEqual(user1_documents2, user2_documents2) - - def test_do_not_return_docs_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_do_not_return_docs_of_other_projects(self): - self._test_list(self.url, - username=self.project_member_name, - password=self.project_member_pass, - expected_num_results=self.main_project.documents.count()) - - def test_allows_superuser_to_create_doc(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.post(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_disallows_project_member_to_create_doc(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.post(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestDocumentDetailAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - non_project_member = User.objects.create_user(username=cls.non_project_member_name, - password=cls.non_project_member_pass) - # Todo: change super_user to project_admin. - super_user = User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - project = mommy.make('TextClassificationProject', users=[project_member, super_user]) - cls.doc = mommy.make('Document', project=project) - cls.url = reverse(viewname='doc_detail', args=[project.id, cls.doc.id]) - cls.data = {'text': 'example'} - assign_user_to_role(project_member=project_member, project=project, - role_name=settings.ROLE_ANNOTATOR) - - def test_returns_doc_to_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.data['id'], self.doc.id) - - def test_do_not_return_doc_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_superuser_to_update_doc(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.data['text'], self.data['text']) - - def test_disallows_project_member_to_update_doc(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_superuser_to_delete_doc(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - - def test_disallows_project_member_to_delete_doc(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestApproveLabelsAPI(APITestCase): - @classmethod - def setUpTestData(cls): - cls.annotator_name = 'annotator_name' - cls.annotator_pass = 'annotator_pass' - cls.approver_name = 'approver_name_name' - cls.approver_pass = 'approver_pass' - cls.project_admin_name = 'project_admin_name' - cls.project_admin_pass = 'project_admin_pass' - create_default_roles() - annotator = User.objects.create_user(username=cls.annotator_name, - password=cls.annotator_pass) - approver = User.objects.create_user(username=cls.approver_name, - password=cls.approver_pass) - project_admin = User.objects.create_user(username=cls.project_admin_name, - password=cls.project_admin_pass) - project = mommy.make('TextClassificationProject', users=[annotator, approver, project_admin]) - cls.doc = mommy.make('Document', project=project) - cls.url = reverse(viewname='approve_labels', args=[project.id, cls.doc.id]) - assign_user_to_role(project_member=annotator, project=project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=approver, project=project, - role_name=settings.ROLE_ANNOTATION_APPROVER) - assign_user_to_role(project_member=project_admin, project=project, - role_name=settings.ROLE_PROJECT_ADMIN) - - def test_allow_project_admin_to_approve_and_disapprove_labels(self): - self.client.login(username=self.project_admin_name, password=self.project_admin_pass) - - response = self.client.post(self.url, format='json', data={'approved': True}) - self.assertEqual(response.data['annotation_approver'], self.project_admin_name) - - response = self.client.post(self.url, format='json', data={'approved': False}) - self.assertIsNone(response.data['annotation_approver']) - - def test_allow_approver_to_approve_and_disapprove_labels(self): - self.client.login(username=self.approver_name, password=self.approver_pass) - - response = self.client.post(self.url, format='json', data={'approved': True}) - self.assertEqual(response.data['annotation_approver'], self.approver_name) - - response = self.client.post(self.url, format='json', data={'approved': False}) - self.assertIsNone(response.data['annotation_approver']) - - def test_disallows_non_annotation_approver_to_approve_and_disapprove_labels(self): - self.client.login(username=self.annotator_name, password=self.annotator_pass) - - response = self.client.post(self.url, format='json', data={'approved': True}) - - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestCommentListAPI(APITestCase): - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.another_project_member_name = 'another_project_member_name' - cls.another_project_member_pass = 'another_project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - create_default_roles() - cls.project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - another_project_member = User.objects.create_user(username=cls.another_project_member_name, - password=cls.another_project_member_pass) - User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) - - main_project = mommy.make('SequenceLabelingProject', users=[cls.project_member, another_project_member]) - main_project_doc = mommy.make('Document', project=main_project) - cls.comment = mommy.make('Comment', document=main_project_doc, text='comment 1', user=cls.project_member) - mommy.make('Comment', document=main_project_doc, text='comment 2', user=cls.project_member) - mommy.make('Comment', document=main_project_doc, text='comment 3', user=another_project_member) - - cls.url = reverse(viewname='comment_list_doc', args=[main_project.id, main_project_doc.id]) - cls.url_project = reverse(viewname='comment_list_project', args=[main_project.id]) - - assign_user_to_role(project_member=cls.project_member, project=main_project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=another_project_member, project=main_project, - role_name=settings.ROLE_ANNOTATOR) - - def test_returns_comments_to_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(len(response.data), 3) - - self.client.login(username=self.another_project_member_name, - password=self.another_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(len(response.data), 3) - - def test_does_not_return_comments_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_does_not_allow_deletion_by_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.delete('{}/{}'.format(self.url, self.comment.id), format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_does_not_allow_deletion_of_non_owned_comment(self): - self.client.login(username=self.another_project_member_name, - password=self.another_project_member_pass) - response = self.client.delete('{}/{}'.format(self.url, self.comment.id), format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_create_update_delete_comment(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.post(self.url, format='json', data={'text': 'comment'}) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - self.assertEqual(response.data['user'], self.project_member.id) - self.assertEqual(response.data['text'], 'comment') - url = '{}/{}'.format(self.url, response.data['id']) - - # check if all comments are fetched - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(len(response.data), 4) - - # update comment - response = self.client.patch(url, format='json', data={'text': 'new comment'}) - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(response.data['text'], 'new comment') - - # delete comment - response = self.client.delete(url) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(len(response.data), 3) - - def test_returns_project_comments_to_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url_project, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(len(response.data), 3) - - self.client.login(username=self.another_project_member_name, - password=self.another_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - self.assertEqual(len(response.data), 3) - - def test_does_not_return_project_comments_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url_project, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestTagAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.main_project_member_name = 'project_member_name' - cls.main_project_member_pass = 'project_member_pass' - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - create_default_roles() - main_project_member = User.objects.create_user(username=cls.main_project_member_name, - password=cls.main_project_member_pass) - super_user = User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - cls.main_project = mommy.make('TextClassificationProject', users=[main_project_member, super_user]) - assign_user_to_role(project_member=main_project_member, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=super_user, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - cls.tag = mommy.make('Tag', project=cls.main_project, text='Tag 1') - cls.url = reverse(viewname='tag_list', args=[cls.main_project.id]) - cls.project_url = reverse(viewname='project_list') - cls.delete_url = reverse(viewname='tag_list', args=[cls.main_project.id]) - - def test_create_tag(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.post(self.url, data={'text': 'Tag 2'}) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - response = self.client.get(self.project_url, format='json') - self.assertTrue(response.data[0]['tags'][1]['text'] == 'Tag 2' ,'Content of tags differs.') - - def test_tag_list(self): - self.client.login(username=self.main_project_member_name, - password=self.main_project_member_pass) - response = self.client.get(self.project_url, format='json') - self.assertTrue(len(response.data[0]['tags']) == 1 ,'Number of tags differs expected amount.') - self.assertTrue(response.data[0]['tags'][0]['text'] == 'Tag 1' ,'Content of tags differs.') - - def test_delete_tag(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.delete(self.delete_url, data={'id': self.tag.id}) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - response = self.client.get(self.project_url, format='json') - self.assertTrue(len(response.data[0]['tags']) == 0 ,'Number of tags differs expected amount.') - - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestAnnotationListAPI(APITestCase, TestUtilsMixin): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.another_project_member_name = 'another_project_member_name' - cls.another_project_member_pass = 'another_project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - another_project_member = User.objects.create_user(username=cls.another_project_member_name, - password=cls.another_project_member_pass) - non_project_member = User.objects.create_user(username=cls.non_project_member_name, - password=cls.non_project_member_pass) - - main_project = mommy.make('SequenceLabelingProject', users=[project_member, another_project_member]) - main_project_label = mommy.make('Label', project=main_project) - main_project_doc = mommy.make('Document', project=main_project) - mommy.make('SequenceAnnotation', document=main_project_doc, user=project_member) - mommy.make('SequenceAnnotation', document=main_project_doc, user=another_project_member) - - sub_project = mommy.make('SequenceLabelingProject', users=[non_project_member]) - sub_project_doc = mommy.make('Document', project=sub_project) - mommy.make('SequenceAnnotation', document=sub_project_doc) - - cls.classification_project = mommy.make('TextClassificationProject', - users=[project_member, another_project_member]) - cls.classification_project_label_1 = mommy.make('Label', project=cls.classification_project) - cls.classification_project_label_2 = mommy.make('Label', project=cls.classification_project) - cls.classification_project_document = mommy.make('Document', project=cls.classification_project) - cls.classification_project_url = reverse( - viewname='annotation_list', args=[cls.classification_project.id, cls.classification_project_document.id]) - assign_user_to_role(project_member=project_member, project=cls.classification_project, - role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=another_project_member, project=cls.classification_project, - role_name=settings.ROLE_ANNOTATOR) - - cls.url = reverse(viewname='annotation_list', args=[main_project.id, main_project_doc.id]) - cls.post_data = {'start_offset': 0, 'end_offset': 1, 'label': main_project_label.id} - cls.num_entity_of_project_member = SequenceAnnotation.objects.filter(document=main_project_doc, - user=project_member).count() - cls.num_entity_of_another_project_member = SequenceAnnotation.objects.filter( - document=main_project_doc, - user=another_project_member).count() - cls.main_project = main_project - assign_user_to_role(project_member=project_member, project=main_project, - role_name=settings.ROLE_ANNOTATOR) - - def test_returns_annotations_to_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - - def test_do_not_return_annotations_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_do_not_return_annotations_of_another_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(len(response.data), self.num_entity_of_project_member) - - def test_returns_annotations_of_another_project_member_if_collaborative_project(self): - self._patch_project(self.main_project, 'collaborative_annotation', True) - - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(len(response.data), - self.num_entity_of_project_member + self.num_entity_of_another_project_member) - - def test_allows_project_member_to_create_annotation(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.post(self.url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_disallows_non_project_member_to_create_annotation(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.post(self.url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allow_replace_annotation_for_single_class_project(self): - self._patch_project(self.classification_project, 'single_class_classification', True) - - self.client.login(username=self.project_member_name, password=self.project_member_pass) - response = self.client.post(self.classification_project_url, format='json', - data={'label': self.classification_project_label_1.id}) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - response = self.client.post(self.classification_project_url, format='json', - data={'label': self.classification_project_label_2.id}) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_allow_replace_annotation_for_single_class_shared_project(self): - self._patch_project(self.classification_project, 'single_class_classification', True) - self._patch_project(self.classification_project, 'collaborative_annotation', True) - - self.client.login(username=self.project_member_name, password=self.project_member_pass) - response = self.client.post(self.classification_project_url, format='json', - data={'label': self.classification_project_label_1.id}) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - self.client.login(username=self.another_project_member_name, password=self.another_project_member_pass) - response = self.client.post(self.classification_project_url, format='json', - data={'label': self.classification_project_label_2.id}) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def _patch_project(self, project, attribute, value): - old_value = getattr(project, attribute, None) - setattr(project, attribute, value) - project.save() - - def cleanup_project(): - setattr(project, attribute, old_value) - project.save() - - self.addCleanup(cleanup_project) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestAnnotationDetailAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.another_project_member_name = 'another_project_member_name' - cls.another_project_member_pass = 'another_project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - # Todo: change super_user to project_admin. - super_user = User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - another_project_member = User.objects.create_user(username=cls.another_project_member_name, - password=cls.another_project_member_pass) - non_project_member = User.objects.create_user(username=cls.non_project_member_name, - password=cls.non_project_member_pass) - - main_project = mommy.make('SequenceLabelingProject', - users=[super_user, project_member, another_project_member]) - main_project_doc = mommy.make('Document', project=main_project) - main_project_entity = mommy.make('SequenceAnnotation', - document=main_project_doc, user=project_member) - another_entity = mommy.make('SequenceAnnotation', - document=main_project_doc, user=another_project_member) - - shared_project = mommy.make('SequenceLabelingProject', - collaborative_annotation=True, - users=[project_member, another_project_member]) - shared_project_doc = mommy.make('Document', project=shared_project) - shared_entity = mommy.make('SequenceAnnotation', document=shared_project_doc, user=another_project_member) - - cls.url = reverse(viewname='annotation_detail', args=[main_project.id, - main_project_doc.id, - main_project_entity.id]) - cls.another_url = reverse(viewname='annotation_detail', args=[main_project.id, - main_project_doc.id, - another_entity.id]) - cls.shared_url = reverse(viewname='annotation_detail', args=[shared_project.id, - shared_project_doc.id, - shared_entity.id]) - cls.post_data = {'start_offset': 0, 'end_offset': 10} - assign_user_to_role(project_member=project_member, project=main_project, role_name=settings.ROLE_ANNOTATOR) - assign_user_to_role(project_member=project_member, project=shared_project, role_name=settings.ROLE_ANNOTATOR) - - def test_returns_annotation_to_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - - def test_do_not_return_annotation_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_do_not_return_annotation_by_another_project_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.another_url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_project_member_to_update_annotation(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.patch(self.url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_200_OK) - - def test_disallows_non_project_member_to_update_annotation(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.patch(self.url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_disallows_project_member_to_update_annotation_of_another_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.patch(self.another_url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_superuser_to_delete_annotation_of_another_member(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.delete(self.another_url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - - def test_allows_project_member_to_delete_annotation(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - - def test_disallows_project_member_to_delete_annotation(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_disallows_project_member_to_delete_annotation_of_another_member(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.delete(self.another_url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allow_member_to_update_others_annotation_in_shared_project(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.patch(self.shared_url, format='json', data=self.post_data) - self.assertEqual(response.status_code, status.HTTP_200_OK) - - def test_allow_member_to_delete_others_annotation_in_shared_project(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.delete(self.shared_url, format='json') - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestSearch(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - non_project_member = User.objects.create_user(username=cls.non_project_member_name, - password=cls.non_project_member_pass) - - cls.main_project = mommy.make('TextClassificationProject', users=[project_member]) - cls.search_term = 'example' - doc1 = mommy.make('Document', text=cls.search_term, project=cls.main_project) - doc2 = mommy.make('Document', text='Lorem', project=cls.main_project) - label1 = mommy.make('Label', project=cls.main_project) - label2 = mommy.make('Label', project=cls.main_project) - mommy.make('SequenceAnnotation', document=doc1, user=project_member, label=label1) - mommy.make('SequenceAnnotation', document=doc2, user=project_member, label=label2) - - sub_project = mommy.make('TextClassificationProject', users=[non_project_member]) - mommy.make('Document', text=cls.search_term, project=sub_project) - cls.url = reverse(viewname='doc_list', args=[cls.main_project.id]) - cls.data = {'q': cls.search_term} - assign_user_to_role(project_member=project_member, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - - def test_can_filter_doc_by_term(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=self.data) - count = Document.objects.filter(text__contains=self.search_term, - project=self.main_project).count() - self.assertEqual(response.data['count'], count) - - def test_can_order_doc_by_created_at_ascending(self): - params = {'ordering': 'created_at'} - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=params) - docs = Document.objects.filter(project=self.main_project).order_by('created_at').values() - for d1, d2 in zip(response.data['results'], docs): - self.assertEqual(d1['id'], d2['id']) - - def test_can_order_doc_by_created_at_descending(self): - params = {'ordering': '-created_at'} - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=params) - docs = Document.objects.filter(project=self.main_project).order_by('-created_at').values() - for d1, d2 in zip(response.data['results'], docs): - self.assertEqual(d1['id'], d2['id']) - - def test_can_order_doc_by_annotation_updated_at_ascending(self): - params = {'ordering': 'seq_annotations__updated_at'} - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=params) - docs = Document.objects.filter(project=self.main_project).order_by('seq_annotations__updated_at').values() - for d1, d2 in zip(response.data['results'], docs): - self.assertEqual(d1['id'], d2['id']) - - def test_can_order_doc_by_annotation_updated_at_descending(self): - params = {'ordering': '-seq_annotations__updated_at'} - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=params) - docs = Document.objects.filter(project=self.main_project).order_by('-seq_annotations__updated_at').values() - for d1, d2 in zip(response.data['results'], docs): - self.assertEqual(d1['id'], d2['id']) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - -class TestFilter(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - cls.main_project = mommy.make('SequenceLabelingProject', users=[project_member]) - cls.label1 = mommy.make('Label', project=cls.main_project) - cls.label2 = mommy.make('Label', project=cls.main_project) - doc1 = mommy.make('Document', project=cls.main_project) - doc2 = mommy.make('Document', project=cls.main_project) - mommy.make('Document', project=cls.main_project) - mommy.make('SequenceAnnotation', document=doc1, user=project_member, label=cls.label1) - mommy.make('SequenceAnnotation', document=doc2, user=project_member, label=cls.label2) - cls.url = reverse(viewname='doc_list', args=[cls.main_project.id]) - cls.params = {'seq_annotations__label__id': cls.label1.id} - assign_user_to_role(project_member=project_member, project=cls.main_project, - role_name=settings.ROLE_ANNOTATOR) - - def test_can_filter_by_label(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=self.params) - docs = Document.objects.filter(project=self.main_project, - seq_annotations__label__id=self.label1.id).values() - for d1, d2 in zip(response.data['results'], docs): - self.assertEqual(d1['id'], d2['id']) - - def test_can_filter_doc_with_annotation(self): - params = {'seq_annotations__isnull': False} - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=params) - docs = Document.objects.filter(project=self.main_project, seq_annotations__isnull=False).values() - self.assertEqual(response.data['count'], docs.count()) - for d1, d2 in zip(response.data['results'], docs): - self.assertEqual(d1['id'], d2['id']) - - def test_can_filter_doc_without_anotation(self): - params = {'seq_annotations__isnull': True} - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.get(self.url, format='json', data=params) - docs = Document.objects.filter(project=self.main_project, seq_annotations__isnull=True).values() - self.assertEqual(response.data['count'], docs.count()) - for d1, d2 in zip(response.data['results'], docs): - self.assertEqual(d1['id'], d2['id']) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - -# class TestImportExportIntegrity(APITestCase): -# """Tests that check for equality between imported and exported data of a file. """ -# @classmethod -# def setUpTestData(cls): -# cls.super_user_name = 'super_user_name' -# cls.super_user_pass = 'super_user_pass' -# create_default_roles() -# super_user = User.objects.create_superuser(username=cls.super_user_name, -# password=cls.super_user_pass, -# email='fizz@buzz.com') -# cls.classification_project = mommy.make('TextClassificationProject', -# users=[super_user], project_type=DOCUMENT_CLASSIFICATION) -# -# cls.classification_upload_url = reverse(viewname='doc_uploader', args=[cls.classification_project.id]) -# cls.classification_download_url = reverse(viewname='doc_downloader', args=[cls.classification_project.id]) -# assign_user_to_role(project_member=super_user, project=cls.classification_project, -# role_name=settings.ROLE_PROJECT_ADMIN) -# -# def setUp(self): -# self.client.login(username=self.super_user_name, -# password=self.super_user_pass) -# -# def load_test_helper(self, upload_url, download_url, filename, import_format, export_format, response_format="text/csv; charset=utf-8",**kwargs): -# parser = TextUploadAPI.select_parser(import_format) -# with open(os.path.join(DATA_DIR, filename), 'rb') as f: -# self.client.post(upload_url, data={'file': f, 'format': import_format}) -# f.seek(0) -# imported = parser.parse(f) -# import_data = [elem for elem in [x for elem in imported for x in elem] if elem.get('labels')] -# -# r = self.client.get(download_url, data={'q': export_format}, HTTP_ACCEPT=response_format) -# b = BytesIO(r.content) -# if export_format == 'txt': -# export_format = import_format -# parser = TextUploadAPI.select_parser(export_format) -# exported = parser.parse(b) -# exported_data = [x for elem in exported for x in elem if x.get('labels') or x.get('annotations')] -# self.assertTrue(len(import_data) == len(exported_data), 'Length of imported dataset does not match exported') -# return import_data, exported_data -# -# # Classification -# def test_jsonl_classification_import_export_integrity(self): -# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, -# download_url=self.classification_download_url, -# filename='classification.jsonl', -# import_format='json', -# project=self.classification_project, -# export_format='json', -# response_format='application/json') -# label_mapping = {label.id: label.text for label in self.classification_project.labels.all()} -# for im, ex in zip(import_data, export_data): -# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') -# ex_labels = set(label_mapping[int(x.get('label'))] for x in ex.get('annotations', [])) -# self.assertFalse(set(im.get('labels')).symmetric_difference(ex_labels), 'Integritycheck failed. Labels differ.') -# -# def test_csv_classification_import_export_integrity(self): -# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, -# download_url=self.classification_download_url, -# filename='example.csv', -# import_format='csv', -# project=self.classification_project, -# export_format='csv') -# label_mapping = {label.id: label.text for label in self.classification_project.labels.all()} -# for im, ex in zip(import_data, export_data): -# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') -# ex_labels = [label_mapping[int(elem)] for elem in ex.get('labels', [])] -# self.assertTrue(im.get('labels') == ex_labels, 'Integritycheck failed. Labels differ.') -# -# def test_xlsx_classification_import_export_integrity(self): -# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, -# download_url=self.classification_download_url, -# filename='example.xlsx', -# import_format='excel', -# project=self.classification_project, -# export_format='csv') -# label_mapping = {label.id: label.text for label in self.classification_project.labels.all()} -# for im, ex in zip(import_data, export_data): -# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') -# ex_labels = [label_mapping[int(elem)] for elem in ex.get('labels', [])] -# self.assertTrue(im.get('labels') == ex_labels, 'Integritycheck failed. Labels differ.') -# -# def test_fasttext_classification_import_export_integrity(self): -# import_data, export_data = self.load_test_helper(upload_url=self.classification_upload_url, -# download_url=self.classification_download_url, -# filename='example_fasttext.txt', -# import_format='fastText', -# project=self.classification_project, -# export_format='txt') -# for im, ex in zip(import_data, export_data): -# self.assertTrue(im['text'] == ex['text'], 'Integritycheck failed. Dataset texts do not match.') -# self.assertFalse(set(im.get('labels')).symmetric_difference(ex.get('labels')), 'Integritycheck failed. Labels differ.') -# -# @classmethod -# def doCleanups(cls): -# remove_all_role_mappings() - -# class TestUploader(APITestCase): -# -# @classmethod -# def setUpTestData(cls): -# cls.super_user_name = 'super_user_name' -# cls.super_user_pass = 'super_user_pass' -# # Todo: change super_user to project_admin. -# create_default_roles() -# super_user = User.objects.create_superuser(username=cls.super_user_name, -# password=cls.super_user_pass, -# email='fizz@buzz.com') -# cls.classification_project = mommy.make('TextClassificationProject', -# users=[super_user], project_type=DOCUMENT_CLASSIFICATION) -# cls.labeling_project = mommy.make('SequenceLabelingProject', -# users=[super_user], project_type=SEQUENCE_LABELING) -# cls.seq2seq_project = mommy.make('Seq2seqProject', users=[super_user], project_type=SEQ2SEQ) -# assign_user_to_role(project_member=super_user, project=cls.classification_project, -# role_name=settings.ROLE_PROJECT_ADMIN) -# assign_user_to_role(project_member=super_user, project=cls.labeling_project, -# role_name=settings.ROLE_PROJECT_ADMIN) -# assign_user_to_role(project_member=super_user, project=cls.seq2seq_project, -# role_name=settings.ROLE_PROJECT_ADMIN) -# -# def setUp(self): -# self.client.login(username=self.super_user_name, -# password=self.super_user_pass) -# -# def upload_test_helper(self, project_id, filename, file_format, expected_status, **kwargs): -# url = reverse(viewname='doc_uploader', args=[project_id]) -# -# with open(os.path.join(DATA_DIR, filename), 'rb') as f: -# response = self.client.post(url, data={'file': f, 'format': file_format}) -# -# self.assertEqual(response.status_code, expected_status) -# -# def label_test_helper(self, project_id, expected_labels, expected_label_keys): -# url = reverse(viewname='label_list', args=[project_id]) -# expected_keys = {key for label in expected_labels for key in label} -# -# response = self.client.get(url).json() -# -# actual_labels = [{key: value for (key, value) in label.items() if key in expected_keys} -# for label in response] -# -# self.assertCountEqual(actual_labels, expected_labels) -# -# for label in response: -# for expected_label_key in expected_label_keys: -# self.assertIsNotNone(label.get(expected_label_key)) -# -# def test_can_upload_conll_format_file(self): -# self.upload_test_helper(project_id=self.labeling_project.id, -# filename='labeling.conll', -# file_format='conll', -# expected_status=status.HTTP_201_CREATED) -# -# def test_cannot_upload_wrong_conll_format_file(self): -# self.upload_test_helper(project_id=self.labeling_project.id, -# filename='labeling.invalid.conll', -# file_format='conll', -# expected_status=status.HTTP_400_BAD_REQUEST) -# -# def test_can_upload_classification_csv(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.csv', -# file_format='csv', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_classification_csv_with_out_of_order_columns(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example_out_of_order_columns.csv', -# file_format='csv', -# expected_status=status.HTTP_201_CREATED) -# -# self.label_test_helper( -# project_id=self.classification_project.id, -# expected_labels=[ -# {'text': 'Positive'}, -# {'text': 'Negative'}, -# ], -# expected_label_keys=[], -# ) -# -# def test_can_upload_csv_with_non_utf8_encoding(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.utf16.csv', -# file_format='csv', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_seq2seq_csv(self): -# self.upload_test_helper(project_id=self.seq2seq_project.id, -# filename='example.csv', -# file_format='csv', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_single_column_csv(self): -# self.upload_test_helper(project_id=self.seq2seq_project.id, -# filename='example_one_column.csv', -# file_format='csv', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_csv_file_does_not_match_column_and_row(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example_column_and_row_not_matching.csv', -# file_format='csv', -# expected_status=status.HTTP_201_CREATED) -# -# def test_cannot_upload_csv_file_has_too_many_columns(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.invalid.2.csv', -# file_format='csv', -# expected_status=status.HTTP_400_BAD_REQUEST) -# -# def test_can_upload_classification_excel(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.xlsx', -# file_format='excel', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_seq2seq_excel(self): -# self.upload_test_helper(project_id=self.seq2seq_project.id, -# filename='example.xlsx', -# file_format='excel', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_single_column_excel(self): -# self.upload_test_helper(project_id=self.seq2seq_project.id, -# filename='example_one_column.xlsx', -# file_format='excel', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_excel_file_does_not_match_column_and_row(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example_column_and_row_not_matching.xlsx', -# file_format='excel', -# expected_status=status.HTTP_201_CREATED) -# -# def test_cannot_upload_excel_file_has_too_many_columns(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.invalid.2.xlsx', -# file_format='excel', -# expected_status=status.HTTP_400_BAD_REQUEST) -# -# @override_settings(IMPORT_BATCH_SIZE=1) -# def test_can_upload_small_batch_size(self): -# self.upload_test_helper(project_id=self.seq2seq_project.id, -# filename='example_one_column_no_header.xlsx', -# file_format='excel', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_classification_jsonl(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='classification.jsonl', -# file_format='json', -# expected_status=status.HTTP_201_CREATED) -# -# self.label_test_helper( -# project_id=self.classification_project.id, -# expected_labels=[ -# {'text': 'positive', 'suffix_key': 'p', 'prefix_key': None}, -# {'text': 'negative', 'suffix_key': 'n', 'prefix_key': None}, -# {'text': 'neutral', 'suffix_key': 'n', 'prefix_key': 'ctrl'}, -# ], -# expected_label_keys=[ -# 'background_color', -# 'text_color', -# ]) -# -# def test_can_upload_labeling_jsonl(self): -# self.upload_test_helper(project_id=self.labeling_project.id, -# filename='labeling.jsonl', -# file_format='json', -# expected_status=status.HTTP_201_CREATED) -# -# self.label_test_helper( -# project_id=self.labeling_project.id, -# expected_labels=[ -# {'text': 'LOC', 'suffix_key': 'l', 'prefix_key': None}, -# {'text': 'ORG', 'suffix_key': 'o', 'prefix_key': None}, -# {'text': 'PER', 'suffix_key': 'p', 'prefix_key': None}, -# ], -# expected_label_keys=[ -# 'background_color', -# 'text_color', -# ]) -# -# def test_can_upload_seq2seq_jsonl(self): -# self.upload_test_helper(project_id=self.seq2seq_project.id, -# filename='seq2seq.jsonl', -# file_format='json', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_plain_text(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.txt', -# file_format='plain', -# expected_status=status.HTTP_201_CREATED) -# -# def test_can_upload_data_without_label(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.jsonl', -# file_format='json', -# expected_status=status.HTTP_201_CREATED) -# -# @classmethod -# def doCleanups(cls): -# remove_all_role_mappings() - - -# @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_PROVIDER='LOCAL') -# @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_ACCOUNT=os.path.dirname(DATA_DIR)) -# @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_SECRET_KEY='not-used') -# class TestCloudUploader(TestUploader): -# def upload_test_helper(self, project_id, filename, file_format, expected_status, **kwargs): -# query_params = { -# 'project_id': project_id, -# 'upload_format': file_format, -# 'container': kwargs.pop('container', os.path.basename(DATA_DIR)), -# 'object': filename, -# } -# -# query_params.update(kwargs) -# -# response = self.client.get(reverse('cloud_uploader'), query_params) -# -# self.assertEqual(response.status_code, expected_status) -# -# def test_cannot_upload_with_missing_file(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='does-not-exist', -# file_format='json', -# expected_status=status.HTTP_400_BAD_REQUEST) -# -# def test_cannot_upload_with_missing_container(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.jsonl', -# container='does-not-exist', -# file_format='json', -# expected_status=status.HTTP_400_BAD_REQUEST) -# -# def test_cannot_upload_with_missing_query_parameters(self): -# response = self.client.get(reverse('cloud_uploader'), {'project_id': self.classification_project.id}) -# -# self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) -# -# def test_can_upload_with_redirect(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.jsonl', -# next='http://somewhere', -# file_format='json', -# expected_status=status.HTTP_302_FOUND) -# -# def test_can_upload_with_redirect_to_blank(self): -# self.upload_test_helper(project_id=self.classification_project.id, -# filename='example.jsonl', -# next='about:blank', -# file_format='json', -# expected_status=status.HTTP_201_CREATED) - - -class TestFeatures(APITestCase): - @classmethod - def setUpTestData(cls): - cls.user_name = 'user_name' - cls.user_pass = 'user_pass' - create_default_roles() - cls.user = User.objects.create_user(username=cls.user_name, password=cls.user_pass, email='fizz@buzz.com') - - def setUp(self): - self.client.login(username=self.user_name, password=self.user_pass) - - @override_settings(CLOUD_BROWSER_APACHE_LIBCLOUD_PROVIDER=None) - def test_no_cloud_upload(self): - response = self.client.get(reverse('features')) - - self.assertFalse(response.json().get('cloud_upload')) - - -@override_settings(IMPORT_BATCH_SIZE=2) -class TestParser(APITestCase): - - def parser_helper(self, filename, parser, include_label=True): - with open(os.path.join(DATA_DIR, filename), mode='rb') as f: - result = list(parser.parse(f)) - for data in result: - for r in data: - self.assertIn('text', r) - if include_label: - self.assertIn('labels', r) - return result - - def test_give_valid_data_to_conll_parser(self): - self.parser_helper(filename='labeling.conll', parser=CoNLLParser()) - - def test_give_valid_data_to_conll_parser_with_trailing_newlines(self): - result = self.parser_helper(filename='labeling.trailing.conll', parser=CoNLLParser()) - self.assertEqual(len(result), 1) - self.assertEqual(len(result[0]), 1) - - def test_plain_parser(self): - self.parser_helper(filename='example.txt', parser=PlainTextParser(), include_label=False) - - def test_give_invalid_data_to_conll_parser(self): - with self.assertRaises(FileParseException): - self.parser_helper(filename='labeling.invalid.conll', - parser=CoNLLParser()) - - def test_give_classification_data_to_csv_parser(self): - self.parser_helper(filename='example.csv', parser=CSVParser(), include_label=False) - - def test_give_seq2seq_data_to_csv_parser(self): - self.parser_helper(filename='example.csv', parser=CSVParser(), include_label=False) - - def test_give_classification_data_to_json_parser(self): - self.parser_helper(filename='classification.jsonl', parser=JSONParser()) - - def test_give_labeling_data_to_json_parser(self): - self.parser_helper(filename='labeling.jsonl', parser=JSONParser()) - - def test_give_seq2seq_data_to_json_parser(self): - self.parser_helper(filename='seq2seq.jsonl', parser=JSONParser()) - - def test_give_data_without_label_to_json_parser(self): - self.parser_helper(filename='example.jsonl', parser=JSONParser(), include_label=False) - - def test_give_labeling_data_to_fasttext_parser(self): - self.parser_helper(filename='example_fasttext.txt', parser=FastTextParser()) - - def test_give_data_without_label_name_to_fasttext_parser(self): - with self.assertRaises(FileParseException): - self.parser_helper(filename='example_fasttext_label_tag_without_name.txt', parser=FastTextParser()) - - def test_give_data_without_text_to_fasttext_parser(self): - with self.assertRaises(FileParseException): - self.parser_helper(filename='example_fasttext_without_text.txt', parser=FastTextParser()) - - -# class TestDownloader(APITestCase): -# -# @classmethod -# def setUpTestData(cls): -# cls.super_user_name = 'super_user_name' -# cls.super_user_pass = 'super_user_pass' -# # Todo: change super_user to project_admin. -# create_default_roles() -# super_user = User.objects.create_superuser(username=cls.super_user_name, -# password=cls.super_user_pass, -# email='fizz@buzz.com') -# cls.classification_project = mommy.make('TextClassificationProject', -# users=[super_user], project_type=DOCUMENT_CLASSIFICATION) -# cls.labeling_project = mommy.make('SequenceLabelingProject', -# users=[super_user], project_type=SEQUENCE_LABELING) -# cls.seq2seq_project = mommy.make('Seq2seqProject', users=[super_user], project_type=SEQ2SEQ) -# cls.speech2text_project = mommy.make('Speech2textProject', users=[super_user], project_type=SPEECH2TEXT) -# cls.classification_url = reverse(viewname='doc_downloader', args=[cls.classification_project.id]) -# cls.labeling_url = reverse(viewname='doc_downloader', args=[cls.labeling_project.id]) -# cls.seq2seq_url = reverse(viewname='doc_downloader', args=[cls.seq2seq_project.id]) -# cls.speech2text_url = reverse(viewname='doc_downloader', args=[cls.speech2text_project.id]) -# -# def setUp(self): -# self.client.login(username=self.super_user_name, -# password=self.super_user_pass) -# -# def download_test_helper(self, url, format, expected_status): -# response = self.client.get(url, data={'q': format}) -# self.assertEqual(response.status_code, expected_status) -# -# def test_cannot_download_conll_format_file(self): -# self.download_test_helper(url=self.labeling_url, -# format='conll', -# expected_status=status.HTTP_400_BAD_REQUEST) -# -# def test_can_download_classification_csv(self): -# self.download_test_helper(url=self.classification_url, -# format='csv', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_labeling_csv(self): -# self.download_test_helper(url=self.labeling_url, -# format='csv', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_seq2seq_csv(self): -# self.download_test_helper(url=self.seq2seq_url, -# format='csv', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_classification_jsonl(self): -# self.download_test_helper(url=self.classification_url, -# format='json', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_labeling_jsonl(self): -# self.download_test_helper(url=self.labeling_url, -# format='json', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_seq2seq_jsonl(self): -# self.download_test_helper(url=self.seq2seq_url, -# format='json', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_speech2text_jsonl(self): -# self.download_test_helper(url=self.speech2text_url, -# format='json', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_labelling_jsonl(self): -# self.download_test_helper(url=self.labeling_url, -# format='jsonl', -# expected_status=status.HTTP_200_OK) -# -# def test_can_download_plain_text(self): -# self.download_test_helper(url=self.classification_url, -# format='plain', -# expected_status=status.HTTP_400_BAD_REQUEST) -# -# def test_can_download_classification_fasttext(self): -# self.download_test_helper(url=self.classification_url, -# format='txt', -# expected_status=status.HTTP_200_OK) - - -class TestStatisticsAPI(APITestCase, TestUtilsMixin): - - @classmethod - def setUpTestData(cls): - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - cls.other_user_name = 'other_user_name' - cls.other_user_pass = 'other_user_pass' - create_default_roles() - # Todo: change super_user to project_admin. - super_user = User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - - other_user = User.objects.create_user(username=cls.other_user_name, - password=cls.other_user_pass, - email='bar@buzz.com') - - cls.project = mommy.make('TextClassificationProject', users=[super_user]) - doc1 = mommy.make('Document', project=cls.project) - doc2 = mommy.make('Document', project=cls.project) - mommy.make('DocumentAnnotation', document=doc1, user=super_user) - mommy.make('DocumentAnnotation', document=doc2, user=other_user) - cls.url = reverse(viewname='statistics', args=[cls.project.id]) - cls.doc = Document.objects.filter(project=cls.project) - - assign_user_to_role(project_member=other_user, project=cls.project, - role_name=settings.ROLE_ANNOTATOR) - - @classmethod - def doCleanups(cls): - remove_all_role_mappings() - - def test_returns_exact_progress(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.data['total'], 2) - self.assertEqual(response.data['remaining'], 1) - - def test_returns_exact_progress_with_collaborative_annotation(self): - self._patch_project(self.project, 'collaborative_annotation', True) - - self.client.login(username=self.other_user_name, - password=self.other_user_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.data['total'], 2) - self.assertEqual(response.data['remaining'], 0) - - def test_returns_user_count(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.get(self.url, format='json') - self.assertIn('label', response.data) - self.assertIsInstance(response.data['label'], dict) - - def test_returns_label_count(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.get(self.url, format='json') - self.assertIn('user', response.data) - self.assertIsInstance(response.data['user'], dict) - - def test_returns_partial_response(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.get(f'{self.url}?include=user', format='json') - self.assertEqual(list(response.data.keys()), ['user']) - - -class TestUserAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.super_user_name = 'super_user_name' - cls.super_user_pass = 'super_user_pass' - create_default_roles() - User.objects.create_superuser(username=cls.super_user_name, - password=cls.super_user_pass, - email='fizz@buzz.com') - cls.url = reverse(viewname='user_list') - - def test_returns_user_count(self): - self.client.login(username=self.super_user_name, - password=self.super_user_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(1, len(response.data)) - - -class TestRoleAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.user_name = 'user_name' - cls.user_pass = 'user_pass' - cls.project_admin_name = 'project_admin_name' - cls.project_admin_pass = 'project_admin_pass' - create_default_roles() - cls.user = User.objects.create_user(username=cls.user_name, - password=cls.user_pass) - User.objects.create_superuser(username=cls.project_admin_name, - password=cls.project_admin_pass, - email='fizz@buzz.com') - cls.url = reverse(viewname='roles') - - def test_cannot_create_multiple_roles_with_same_name(self): - self.client.login(username=self.project_admin_name, - password=self.project_admin_pass) - roles = [ - {'name': 'examplerole', 'description': 'example'}, - {'name': 'examplerole', 'description': 'example'} - ] - self.client.post(self.url, format='json', data=roles[0]) - second_response = self.client.post(self.url, format='json', data=roles[1]) - self.assertEqual(second_response.status_code, status.HTTP_400_BAD_REQUEST) - - def test_nonadmin_cannot_create_role(self): - self.client.login(username=self.user_name, - password=self.user_pass) - data = {'name': 'testrole', 'description': 'example'} - response = self.client.post(self.url, format='json', data=data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_admin_can_create_role(self): - self.client.login(username=self.project_admin_name, - password=self.project_admin_pass) - data = {'name': 'testrole', 'description': 'example'} - response = self.client.post(self.url, format='json', data=data) - self.assertEqual(response.status_code, status.HTTP_201_CREATED) - - def test_admin_can_get_roles(self): - self.client.login(username=self.project_admin_name, - password=self.project_admin_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - - -class TestRoleMappingListAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.second_project_member_name = 'second_project_member_name' - cls.second_project_member_pass = 'second_project_member_pass' - cls.project_admin_name = 'project_admin_name' - cls.project_admin_pass = 'project_admin_pass' - create_default_roles() - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - cls.second_project_member = User.objects.create_user(username=cls.second_project_member_name, - password=cls.second_project_member_pass) - project_admin = User.objects.create_user(username=cls.project_admin_name, - password=cls.project_admin_pass) - cls.main_project = mommy.make('Project', users=[project_member, project_admin, cls.second_project_member]) - cls.other_project = mommy.make('Project', users=[cls.second_project_member, project_admin]) - cls.admin_role = Role.objects.get(name=settings.ROLE_PROJECT_ADMIN) - cls.role = mommy.make('Role', name='otherrole') - assign_user_to_role(project_admin, cls.main_project, cls.admin_role) - cls.data = {'user': project_member.id, 'role': cls.admin_role.id, 'project': cls.main_project.id} - cls.other_url = reverse(viewname='rolemapping_list', args=[cls.other_project.id]) - cls.url = reverse(viewname='rolemapping_list', args=[cls.main_project.id]) - - def test_returns_mappings_to_project_admin(self): - self.client.login(username=self.project_admin_name, - password=self.project_admin_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_200_OK) - - # Todo: refactoring testing. - # def test_allows_superuser_to_create_mapping(self): - # self.client.login(username=self.project_admin_name, - # password=self.project_admin_pass) - # response = self.client.post(self.url, format='json', data=self.data) - # self.assertEqual(response.status_code, status.HTTP_201_CREATED) - # - # def test_do_not_allow_nonadmin_to_create_mapping(self): - # self.client.login(username=self.project_member_name, - # password=self.project_member_pass) - # response = self.client.post(self.url, format='json', data=self.data) - # self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - # - # def test_do_not_return_mappings_to_nonadmin(self): - # self.client.login(username=self.project_member_name, - # password=self.project_member_pass) - # response = self.client.get(self.url, format='json') - # self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - -class TestRoleMappingDetailAPI(APITestCase): - - @classmethod - def setUpTestData(cls): - cls.project_admin_name = 'project_admin_name' - cls.project_admin_pass = 'project_admin_pass' - cls.project_member_name = 'project_member_name' - cls.project_member_pass = 'project_member_pass' - cls.non_project_member_name = 'non_project_member_name' - cls.non_project_member_pass = 'non_project_member_pass' - create_default_roles() - project_admin = User.objects.create_user(username=cls.project_admin_name, - password=cls.project_admin_pass) - project_member = User.objects.create_user(username=cls.project_member_name, - password=cls.project_member_pass) - User.objects.create_user(username=cls.non_project_member_name, password=cls.non_project_member_pass) - project = mommy.make('Project', users=[project_admin, project_member]) - admin_role = Role.objects.get(name=settings.ROLE_PROJECT_ADMIN) - annotator_role = Role.objects.get(name=settings.ROLE_ANNOTATOR) - cls.rolemapping = assign_user_to_role(project_admin, project, admin_role) - assign_user_to_role(project_member, project, annotator_role) - cls.url = reverse(viewname='rolemapping_detail', args=[project.id, cls.rolemapping.id]) - cls.data = {'role': admin_role.id} - - def test_returns_rolemapping_to_project_member(self): - self.client.login(username=self.project_admin_name, - password=self.project_admin_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.data['id'], self.rolemapping.id) - - def test_do_not_return_mapping_to_non_project_member(self): - self.client.login(username=self.non_project_member_name, - password=self.non_project_member_pass) - response = self.client.get(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_admin_to_update_mapping(self): - self.client.login(username=self.project_admin_name, - password=self.project_admin_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.data['role'], self.data['role']) - - def test_disallows_project_member_to_update_mapping(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.patch(self.url, format='json', data=self.data) - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) - - def test_allows_admin_to_delete_mapping(self): - self.client.login(username=self.project_admin_name, - password=self.project_admin_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT) - - def test_disallows_project_member_to_delete_mapping(self): - self.client.login(username=self.project_member_name, - password=self.project_member_pass) - response = self.client.delete(self.url, format='json') - self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) diff --git a/backend/api/tests/test_views.py b/backend/api/tests/test_views.py deleted file mode 100644 index 8b137891..00000000 --- a/backend/api/tests/test_views.py +++ /dev/null @@ -1 +0,0 @@ -