def test_given_encrypt_called_then_decrypt_returns_the_original_encrypted_text(
):
text_for_encryption = "text_for_encryption"
key = "1111111111111111"
anonymize_request = {
"text":
text_for_encryption,
"anonymizers": {
"DEFAULT": {
"type": "encrypt",
"key": key
}
},
"analyzer_results": [{
"start": 0,
"end": len(text_for_encryption),
"score": 0.8,
"entity_type": "NAME",
}],
}
_, anonymize_response_content = anonymize(json.dumps(anonymize_request))
encrypted_text = json.loads(anonymize_response_content)["text"]
decrypt_request = {"text": encrypted_text, "key": key}
_, decrypt_response_content = decrypt(json.dumps(decrypt_request))
decrypted_text = json.loads(decrypt_response_content)["result"]
assert encrypted_text != text_for_encryption
assert decrypted_text == text_for_encryption
def test_given_anonymize_called_with_valid_request_then_expected_valid_response_returned(
):
request_body = """
{
"text": "hello world, my name is Jane Doe. My number is: 034453334",
"anonymizers": {
"DEFAULT": { "type": "replace", "new_value": "ANONYMIZED" },
"PHONE_NUMBER": { "type": "mask", "masking_char": "*", "chars_to_mask": 4, "from_end": true }
},
"analyzer_results": [
{ "start": 24, "end": 32, "score": 0.8, "entity_type": "NAME" },
{ "start": 24, "end": 28, "score": 0.8, "entity_type": "FIRST_NAME" },
{ "start": 29, "end": 32, "score": 0.6, "entity_type": "LAST_NAME" },
{ "start": 48, "end": 57, "score": 0.95,
"entity_type": "PHONE_NUMBER" }
]
}
"""
response_status, response_content = anonymize(request_body)
expected_response = (
"""{"text": "hello world, my name is ANONYMIZED. My number is: 03445****", "items": [{"anonymizer": "mask", "entity_type": "PHONE_NUMBER", "start": 50, "end": 59, "anonymized_text": "03445****"}, {"anonymizer": "replace", "entity_type": "NAME", "start": 24, "end": 34, "anonymized_text": "ANONYMIZED"}]}"""
)
assert response_status == 200
assert equal_json_strings(expected_response, response_content)
def test_given_encrypt_called_then_decrypt_returns_the_original_encrypted_text(
):
text_for_encryption = "Lorem Ipsum is a Software Engineer"
key = "1111111111111111"
anonymize_request = {
"text":
text_for_encryption,
"anonymizers": {
"DEFAULT": {
"type": "encrypt",
"key": key
},
"TITLE": {
"type": "encrypt",
"key": "2222222222222222"
}
},
"analyzer_results": [{
"start": 0,
"end": 12,
"score": 0.8,
"entity_type": "NAME",
}, {
"start": 18,
"end": len(text_for_encryption),
"score": 0.8,
"entity_type": "TITLE",
}],
}
_, anonymize_response_content = anonymize(json.dumps(anonymize_request))
encrypted_text = json.loads(anonymize_response_content)["text"]
decrypt_request = {
"text":
encrypted_text,
"deanonymizers": {
"DEFAULT": {
"type": "decrypt",
"key": "1111111111111111"
},
"TITLE": {
"type": "decrypt",
"key": "2222222222222222"
}
},
"anonymizer_results": [{
"start": 0,
"end": 44,
"entity_type": "NAME",
}, {
"start": 50,
"end": 114,
"entity_type": "TITLE",
}],
}
_, decrypted_text_response = deanonymize(json.dumps(decrypt_request))
decrypted_text = json.loads(decrypted_text_response)["text"]
assert decrypted_text == text_for_encryption
def test_demo_website_text_returns_correct_anonymized_version():
# Analyzer request info
dir_path = Path(__file__).resolve().parent.parent
with open(Path(dir_path, "resources", "demo.txt"), encoding="utf-8") as f:
text_into_rows = f.read().split("\n")
text_into_rows = [txt.strip() for txt in text_into_rows]
text = " ".join(text_into_rows)
language = "en"
score_threshold = 0.35
analyzer_request = {
"text": text,
"language": language,
"score_threshold": score_threshold,
}
# Call analyzer
analyzer_status_code, analyzer_content = analyze(json.dumps(analyzer_request))
analyzer_data = json.loads(analyzer_content)
# Anonymizer request info
anonymizer_request = {
"text": analyzer_request["text"],
"analyzer_results": analyzer_data,
}
# Call anonymizer
anonymizer_status_code, anonymizer_response = anonymize(
json.dumps(anonymizer_request)
)
anonymizer_response_dict = json.loads(anonymizer_response)
actual_anonymized_text = anonymizer_response_dict["text"]
# Expected output:
with open(
Path(dir_path, "resources", "demo_anonymized.txt"), encoding="utf-8"
) as f_exp:
text_into_rows = f_exp.read().split("\n")
text_into_rows = [txt.strip() for txt in text_into_rows]
expected_anonymized_text = " ".join(text_into_rows)
# Assert equal
assert expected_anonymized_text == actual_anonymized_text
def test_given_anonymize_called_with_custom_then_bad_request_error_returned():
request_body = """
{
"text": "The user has the following two emails: [email protected] and [email protected]",
"anonymizers": {
"DEFAULT": { "type": "custom", "new_value": "lambda x: x[::-1]" }
},
"analyzer_results": [
{ "start": 39, "end": 55, "score": 1.0, "entity_type": "EMAIL_ADDRESS" },
{ "start": 60, "end": 76, "score": 1.0, "entity_type": "EMAIL_ADDRESS" }
]
}
"""
response_status, response_content = anonymize(request_body)
expected_response = '{"error": "Custom type anonymizer is not supported"}'
assert response_status == 400
assert equal_json_strings(expected_response, response_content)
def test_given_anonymize_called_with_deformed_body_then_internal_server_error_returned(
):
request_body = """
{
"text": "hello world, my name is Jane Doe. My number is: 034453334",
"anonymizers": {
"DEFAULT": {"type": "replace", "new_value": "ANONYMIZED"},
},
"analyzer_results": [
{"start": 24, "end": 32, "score": 0.8, "entity_type": "NAME"},
{"start": 24, "end": 28, "score": 0.8, "entity_type": "FIRST_NAME"},
]
}
"""
response_status, response_content = anonymize(request_body)
expected_response = '{"error": "Internal server error"}'
assert response_status == 500
assert equal_json_strings(expected_response, response_content)
def test_given_anonymize_called_with_empty_analyzer_results_then_unchanged_text_is_returned(
):
request_body = """
{
"text": "hello world! nice to meet you!",
"anonymizers": {
"DEFAULT": { "type": "replace", "new_value": "ANONYMIZED" },
"PHONE_NUMBER": { "type": "mask", "masking_char": "*", "chars_to_mask": 4, "from_end": true }
},
"analyzer_results": [
]
}
"""
response_status, response_content = anonymize(request_body)
expected_response = """{"text": "hello world! nice to meet you!", "items": []}"""
assert response_status == 200
assert equal_json_strings(expected_response, response_content)
def test_given_anonymize_called_with_empty_text_then_invalid_input_message_returned(
):
request_body = """
{
"text": "",
"anonymizers": {
"DEFAULT": { "type": "replace", "new_value": "ANONYMIZED" }
},
"analyzer_results": [
{ "start": 24, "end": 32, "score": 0.8, "entity_type": "NAME" }
]
}
"""
response_status, response_content = anonymize(request_body)
expected_response = '{"error": "Invalid input, text can not be empty"}'
assert response_status == 422
assert equal_json_strings(expected_response, response_content)
def anonymize_and_assert(anonymizer_request, expected_response):
response_status, response_content = anonymize(json.dumps(anonymizer_request))
assert response_status == 200
assert equal_json_strings(expected_response, response_content)
