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)
