def test_that_normal_user_can_not_create_project_with_indices(self): url = reverse(f"{VERSION_NAMESPACE}:project-list") payload = { "title": "the holy hand grenade", "indices_write": [TEST_INDEX] } response = self.client.post(url, data=payload, format="json") print_output( "test_that_normal_user_can_not_create_project_with_indices:response.data", response.data) self.assertTrue(response.status_code, status.HTTP_403_FORBIDDEN)
def test_search_match_phrase_empty_result(self): payload = { "match_text": "jeesus tuleb ja tapab kõik ära", "match_type": "phrase" } url = f'{self.project_url}/elastic/search/' response = self.client.post(url, payload) print_output('search:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue(isinstance(response.data, list)) self.assertTrue(len(response.data) == 0)
def test_autocomplete_fact_values(self): payload = {"limit": 5, "startswith": "fo", "fact_name": TEST_FACT_NAME} url = f'{self.project_url}/autocomplete_fact_values/' response = self.client.post(url, payload) print_output('test_autocomplete_fact_values:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue(isinstance(response.data, list)) self.assertTrue('foo' in response.data) self.assertTrue('bar' not in response.data)
def _basic_pipeline_functionality(self): url = reverse(f"{VERSION_NAMESPACE}:docparser") payload = { "file": self.file, "project_id": self.project.pk, "indices": [self.test_index_name], "file_name": self.file_name } response = self.client.post(url, data=payload) print_output("_basic_pipeline_functionality:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_200_OK)
def test_being_rejected_with_wrong_project_id(self): url = reverse(f"{VERSION_NAMESPACE}:docparser") payload = { "file": self.file, "project_id": self.unauth_project.pk, "indices": [self.test_index_name] } self.unauth_project.users.remove(self.user) response = self.client.post(url, data=payload) print_output("test_being_rejected_with_wrong_project_id:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_403_FORBIDDEN)
def import_test_model(self, file_path: str): """Import models for testing.""" print_output("Importing model from file:", file_path) files = {"file": open(file_path, "rb")} import_url = f'{self.url}import_model/' resp = self.client.post(import_url, data={ 'file': open(file_path, "rb") }).json() print_output("Importing test model:", resp) return resp["id"]
def run_test_that_creating_taggers_with_invalid_regex_creates_validation_exception(self): invalid_payload = { "description": "TestRegexTagger", "lexicon": ["jossif stalin))", "adolf** hitler"], "counter_lexicon": ["benito** (mussolini"] } response = self.client.post(self.url, invalid_payload) print_output('test_regex_tagger_create_invalid_input:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertTrue("lexicon" in response.data) self.assertTrue("counter_lexicon" in response.data)
def test_that_project_administrator_can_edit_users(self): project = self.__create_project() self.assertTrue(self.project_user in project.administrators.all()) url = reverse(f"{VERSION_NAMESPACE}:project-add-users", kwargs={"pk": project.pk}) response = self.client.post(url, data={"users": [self.user.pk]}, format="json") print_output( "test_that_project_administrator_can_edit_users:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_200_OK)
def test_get_facts_with_include_doc_path(self): url = f'{self.project_url}/elastic/get_facts/' response = self.client.post(url, format="json", data={"include_doc_path": True}) print_output('get_facts_with_include_doc_path:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue(isinstance(response.data, list)) for field in response.data: for value in field['values']: self.assertTrue('doc_path' in value)
def test_get_facts_with_indices(self): url = f'{self.project_url}/elastic/get_facts/' response = self.client.post(url, format="json", data={"indices": [{ "name": TEST_INDEX }]}) print_output('get_facts_with_indices:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue(isinstance(response.data, list)) self.assertTrue( TEST_FACT_NAME in [field['name'] for field in response.data])
def run_models_retrain(self): """Tests the endpoint for the models_retrain action""" url = f'{self.url}{self.test_tagger_group_id}/models_retrain/' response = self.client.post(url) print_output('test_models_retrain:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) # Check if response data self.assertTrue(response.data) self.assertTrue('success' in response.data) # remove retrained tagger models retrained_tagger_group = TaggerGroup.objects.get( id=response.data['tagger_group_id'])
def test_that_making_a_normal_user_a_superusers_adds_the_is_staff_flag( self): self.client.login(username="******", password="******") response = self.client.patch(self.user_url, data={"is_superuser": True}, format="json") print_output( "test_that_making_a_normal_user_a_superusers_adds_the_is_staff_flag:response.data", response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) user = User.objects.get(username="******") self.assertEqual(user.is_staff, True)
def run_test_apply_rakun_extractor_to_index(self): index_payload = { "indices": [{"name": self.test_index_name}], "description": "test_apply_rakun_to_index", "fields": TEST_FIELD_CHOICE, "query": json.dumps(TEST_RAKUN_QUERY) } for rakun_id in self.ids: rakun_apply_to_index_url = f'{TEST_VERSION_PREFIX}/projects/{self.project.id}/rakun_extractors/{rakun_id}/apply_to_index/' response = self.client.post(rakun_apply_to_index_url, index_payload) print_output(f"Apply Rakun to Index for ID: {rakun_id}", response.json()) self.assertTrue(response.status_code == status.HTTP_201_CREATED)
def run_refresh_token_invalid_token(self): ''' Test if the refresh token endpoint gives the correct response on an invalid/expired token ''' # Auth the root url response = self.client.post(f'{self.url}/refresh-token', {'refresh_token': 'wrongvalue'}, format='json') print_output("run_refresh_token_invalid_token", response.data) # Check if the refresh-token endpoint returned 403 self.assertEqual(400, response.status_code)
def run_predict(self, test_embedding_id): """Tests the endpoint for the predict action""" # Send only "text" in payload, because "output_size" should be 10 by default payload = {"positives_used": ["eesti", "läti"]} predict_url = f'{self.url}{test_embedding_id}/predict_similar/' response = self.client.post(predict_url, json.dumps(payload), content_type='application/json') print_output('predict:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) # Check if response data is not empty, but a result instead self.assertTrue(response.data)
def test_unauthenticated_access(self): self.client.logout() url = reverse(f"{VERSION_NAMESPACE}:document_import", kwargs={"pk": self.project.pk}) response = self.client.post(url, data={"documents": [self.document]}, format="json") print_output("test_unauthenticated_access:response.data", response.data) self.assertTrue( response.status_code == status.HTTP_403_FORBIDDEN or response.status_code == status.HTTP_401_UNAUTHORIZED)
def run_multiclass_tag_text(self, test_tagger_ids: List[int]): """Tests the endpoint for the tag_text action""" payload = {"text": "This is some test text for the Tagger Test"} for test_tagger_id in test_tagger_ids: tag_text_url = f'{self.url}{test_tagger_id}/tag_text/' response = self.client.post(tag_text_url, payload) print_output('test_multiclass_tag_text:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) # Check if response data is not empty, but a result instead self.assertTrue(response.data) self.assertTrue('result' in response.data) self.assertTrue('probability' in response.data)
def run_test_that_user_cant_delete_pretrained_model(self): self.client.login(username='******', password='******') url = reverse("v2:bert_tagger-delete-pretrained-model", kwargs={"project_pk": self.project.pk}) resp = self.client.post(url, data={"model_name": "EMBEDDIA/finest-bert"}) print_output( "run_test_that_user_cant_delete_pretrained_model:response.data", data=resp.data) self.assertTrue(resp.status_code == status.HTTP_401_UNAUTHORIZED or resp.status_code == status.HTTP_403_FORBIDDEN)
def _apply_lang_detect_to_index(self): payload = { "description": "TestingIndexProcessing", "field": TEST_FIELD, "query": json.dumps(TEST_QUERY, ensure_ascii=False) } url = reverse(f"{VERSION_NAMESPACE}:lang_index-list", kwargs={"project_pk": self.project.pk}) response = self.client.post(url, data=payload, format="json") print_output("_apply_lang_detect_to_index:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_201_CREATED)
def run_train_torchtagger_without_embedding(self): payload = { "description": "TestTorchTaggerTraining", "fields": TEST_FIELD_CHOICE, "maximum_sample_size": 500, "model_architecture": self.torch_models[0], "num_epochs": 3 } response = self.client.post(self.url, payload, format='json') print_output(f"run_train_torchtagger_without_embedding", response.data) self.assertTrue(response.status_code == status.HTTP_400_BAD_REQUEST)
def run_test_anonymizer_create(self): """Tests Anonymizer creation.""" payload = {"description": "TestAnonymizer"} response = self.client.post(self.url, payload) print_output('test_anonymizer_create:response.data', response.data) created_id = response.data['id'] self.anonymizer_id = created_id # Check if lexicon gets created self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_tagging_documents_with_matches(self): tagger_group_url = reverse( f"{VERSION_NAMESPACE}:regex_tagger_group-tag-docs", kwargs={ "project_pk": self.project.pk, "pk": self.emergency_tagger_group_id }) payload = { "docs": [{ "text": "see varas oli süüdi!" }, { "text_2": { "text": "See põleng on kohutav!" } }], "fields": ["text", "text_2.text"] } response = self.client.post(tagger_group_url, data=payload, format="json") print_output("test_tagging_documents_with_matches::response.data", response.data) first_item, second_item = response.data first_facts, second_facts = first_item[TEXTA_TAGS_KEY], second_item[ TEXTA_TAGS_KEY] self.assertTrue(response.status_code == status.HTTP_200_OK) self.assertTrue("text" in first_item) self.assertTrue("text_2" in second_item and "text" in second_item["text_2"]) self.assertTrue(TEXTA_TAGS_KEY in first_item and TEXTA_TAGS_KEY in second_item) self.assertTrue(len(first_facts) == 1 and len(second_facts) == 1) fact = first_item[TEXTA_TAGS_KEY][0] source = json.loads(fact["source"]) self.assertTrue(fact["fact"] == "Hädaabi") self.assertTrue(fact["str_val"] == "politsei") self.assertTrue("regextagger_id" in source and source["regextagger_id"] == self.police_id) self.assertTrue("regextaggergroup_id" in source and source["regextaggergroup_id"] == self.emergency_tagger_group_id) fact = second_item[TEXTA_TAGS_KEY][0] source = json.loads(fact["source"]) self.assertTrue(fact["fact"] == "Hädaabi") self.assertTrue(fact["str_val"] == "tuletõrje") self.assertTrue("regextagger_id" in source and source["regextagger_id"] == self.firefighter_id) self.assertTrue("regextaggergroup_id" in source and source["regextaggergroup_id"] == self.emergency_tagger_group_id)
def test_normal_process_with_multiple_fields(self): payload = { "fields": [TEST_NESTED_FIELDS, TEST_FIELD], "detect_lang": True, "analyzers": ["stemmer"], "description": "suvakas bby", "query": json.dumps(TEST_QUERY, ensure_ascii=False) } response = self.client.post(self.list_url, data=payload, format="json") print_output("test_normal_process_with_multiple_fields:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_201_CREATED)
def test_blank_indices_input(self): payload = { "description": "hello there, kenobi.", "fields": [TEST_FIELD], "analyzers": ["stemmer"], "stemmer_lang": "estonian", "indices": [], "query": json.dumps(TEST_QUERY, ensure_ascii=False) } response = self.client.post(self.list_url, data=payload, format="json") print_output("test_blank_indices_input:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_201_CREATED)
def run_tag_random_doc(self): """Tests the endpoint for the tag_random_doc action""" payload = {"indices": [{"name": self.test_index_name}]} url = f'{self.url}{self.test_tagger_id}/tag_random_doc/' response = self.client.post(url, format="json", data=payload) print_output('test_tag_random_doc:response.data', response.data) self.assertEqual(response.status_code, status.HTTP_200_OK) # Check if response is list self.assertTrue(isinstance(response.data, dict)) self.assertTrue('prediction' in response.data) self.assertTrue('result' in response.data['prediction']) self.assertTrue('probability' in response.data['prediction']) self.assertTrue('tagger_id' in response.data['prediction'])
def test_creation(self): '''Tests if a saved search gets created properly.''' url = f'{TEST_VERSION_PREFIX}/projects/{self.project.id}/searches/' payload = {"description":"test", "query":{"elasticsearchQuery":{"highlight":{"fields":{},"number_of_fragments":0,"post_tags":["<TEXTA_SEARCHER_HIGHLIGHT_END_TAG>"],"pre_tags":["<TEXTA_SEARCHER_HIGHLIGHT_START_TAG>"]},"query":{"bool":{"boost":1,"filter":[],"minimum_should_match":0,"must":[],"must_not":[],"should":[]}}},"highlight":{"fields":{},"number_of_fragments":0,"post_tags":["<TEXTA_SEARCHER_HIGHLIGHT_END_TAG>"],"pre_tags":["<TEXTA_SEARCHER_HIGHLIGHT_START_TAG>"]},"query":{"bool":{"boost":1,"filter":[],"minimum_should_match":0,"must":[],"must_not":[],"should":[]}}},"query_constraints":[]} response = self.client.post(url, payload, format='json') print_output("search_creation: ", response.data) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertTrue(isinstance(response.data, dict)) self.assertTrue('query' in response.data) self.assertTrue('query_constraints' in response.data) self.assertTrue('author' in response.data) self.assertTrue('project' in response.data)
def run_test_check_for_validation_error(self): anonymizer_url = f'{self.url}{self.anonymizer_id}/anonymize_text/' payload = { "texts": [ "selles tekstis on mõrtsukas Jossif Stalini nimi", "selles tekstis on onkel Adolf Hitler" ], "names": ["Stalin, Jossif", "Hitler Adolf"], } response = self.client.post(anonymizer_url, payload, format="json") self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) print_output("test_check_for_validation_error:response.data", response.data)
def access_project_resources(self, username, password, SAFE_FORBIDDEN=False): url = self.project_resource_url self.client.login(username=username, password=password) response = self.client.get(url) print_output(f'{username} access project resources at: {url}', response.status_code) if SAFE_FORBIDDEN is True: return self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_processing_with_query(self): payload = { "description": "hello there, kenobi.", "fields": [TEST_FIELD], "analyzers": ["tokenizer"], "indices": [{ "name": self.test_index_name }], "query": json.dumps(TEST_QUERY, ensure_ascii=False) } response = self.client.post(self.list_url, data=payload, format="json") print_output("test_processing_with_query:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_201_CREATED)
def test_blank_fields_input(self): payload = { "description": "random text", "fields": [], "analyzers": ["stemmer"], "stemmer_lang": "estonian", "indices": [{ "name": self.test_index_name }] } response = self.client.post(self.list_url, data=payload, format="json") print_output("test_blank_fields_input:response.data", response.data) self.assertTrue(response.status_code == status.HTTP_400_BAD_REQUEST)