darkhelm/notifications-api
1
0
Fork 0
mirror of https://github.com/GSA/notifications-api.git synced 2026-08-24 16:23:44 -04:00
Code Issues Packages Projects Releases Wiki Activity

reformat

Browse Source
This commit is contained in:
Kenneth Kehl
2023-08-29 14:54:30 -07:00
parent 19dcd7a48b
commit 1ecb747c6d
588 changed files with 34100 additions and 23589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

140
tests/app/v2/template/test_get_template.py
View File

@@ -9,10 +9,13 @@ from tests.app.db import create_template
valid_version_params = [None, 1]
@pytest.mark.parametrize("tmp_type, expected_name, expected_subject", [
(SMS_TYPE, 'sms Template Name', None),
(EMAIL_TYPE, 'email Template Name', 'Template subject'),
])
@pytest.mark.parametrize(
"tmp_type, expected_name, expected_subject",
[
(SMS_TYPE, "sms Template Name", None),
(EMAIL_TYPE, "email Template Name", "Template subject"),
],
)
@pytest.mark.parametrize("version", valid_version_params)
def test_get_template_by_id_returns_200(
client, sample_service, tmp_type, expected_name, expected_subject, version
@@ -20,63 +23,60 @@ def test_get_template_by_id_returns_200(
template = create_template(sample_service, template_type=tmp_type)
auth_header = create_service_authorization_header(service_id=sample_service.id)
version_path = '/version/{}'.format(version) if version else ''
version_path = "/version/{}".format(version) if version else ""
response = client.get(path='/v2/template/{}{}'.format(template.id, version_path),
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/template/{}{}".format(template.id, version_path),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
assert response.headers['Content-type'] == 'application/json'
assert response.headers["Content-type"] == "application/json"
json_response = json.loads(response.get_data(as_text=True))
expected_response = {
'id': '{}'.format(template.id),
'type': '{}'.format(template.template_type),
'created_at': template.created_at.strftime(DATETIME_FORMAT),
'updated_at': None,
'version': template.version,
'created_by': template.created_by.email_address,
'body': template.content,
"id": "{}".format(template.id),
"type": "{}".format(template.template_type),
"created_at": template.created_at.strftime(DATETIME_FORMAT),
"updated_at": None,
"version": template.version,
"created_by": template.created_by.email_address,
"body": template.content,
"subject": expected_subject,
'name': expected_name,
'personalisation': {},
"name": expected_name,
"personalisation": {},
}
assert json_response == expected_response
@pytest.mark.parametrize("create_template_args, expected_personalisation", [
(
{
"template_type": SMS_TYPE,
"content": "Hello ((placeholder)) ((conditional??yes))",
},
{
"placeholder": {
"required": True
@pytest.mark.parametrize(
"create_template_args, expected_personalisation",
[
(
{
"template_type": SMS_TYPE,
"content": "Hello ((placeholder)) ((conditional??yes))",
},
"conditional": {
"required": True
{
"placeholder": {"required": True},
"conditional": {"required": True},
},
},
),
(
{
"template_type": EMAIL_TYPE,
"subject": "((subject))",
"content": "((content))",
},
{
"subject": {
"required": True
),
(
{
"template_type": EMAIL_TYPE,
"subject": "((subject))",
"content": "((content))",
},
"content": {
"required": True
{
"subject": {"required": True},
"content": {"required": True},
},
},
),
])
),
],
)
@pytest.mark.parametrize("version", valid_version_params)
def test_get_template_by_id_returns_placeholders(
client,
@@ -88,59 +88,59 @@ def test_get_template_by_id_returns_placeholders(
template = create_template(sample_service, **create_template_args)
auth_header = create_service_authorization_header(service_id=sample_service.id)
version_path = '/version/{}'.format(version) if version else ''
version_path = "/version/{}".format(version) if version else ""
response = client.get(path='/v2/template/{}{}'.format(template.id, version_path),
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/template/{}{}".format(template.id, version_path),
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert json_response['personalisation'] == expected_personalisation
assert json_response["personalisation"] == expected_personalisation
def test_get_template_with_non_existent_template_id_returns_404(client, fake_uuid, sample_service):
def test_get_template_with_non_existent_template_id_returns_404(
client, fake_uuid, sample_service
):
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(path='/v2/template/{}'.format(fake_uuid),
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/template/{}".format(fake_uuid),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 404
assert response.headers['Content-type'] == 'application/json'
assert response.headers["Content-type"] == "application/json"
json_response = json.loads(response.get_data(as_text=True))
assert json_response == {
"errors": [
{
"error": "NoResultFound",
"message": "No result found"
}
],
"status_code": 404
"errors": [{"error": "NoResultFound", "message": "No result found"}],
"status_code": 404,
}
@pytest.mark.parametrize("tmp_type", TEMPLATE_TYPES)
def test_get_template_with_non_existent_version_returns_404(client, sample_service, tmp_type):
def test_get_template_with_non_existent_version_returns_404(
client, sample_service, tmp_type
):
template = create_template(sample_service, template_type=tmp_type)
auth_header = create_service_authorization_header(service_id=sample_service.id)
invalid_version = template.version + 1
response = client.get(path='/v2/template/{}/version/{}'.format(template.id, invalid_version),
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/template/{}/version/{}".format(template.id, invalid_version),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 404
assert response.headers['Content-type'] == 'application/json'
assert response.headers["Content-type"] == "application/json"
json_response = json.loads(response.get_data(as_text=True))
assert json_response == {
"errors": [
{
"error": "NoResultFound",
"message": "No result found"
}
],
"status_code": 404
"errors": [{"error": "NoResultFound", "message": "No result found"}],
"status_code": 404,
}

175
tests/app/v2/template/test_post_template.py
View File

@@ -5,9 +5,7 @@ from app.models import EMAIL_TYPE, TEMPLATE_TYPES
from tests import create_service_authorization_header
from tests.app.db import create_template
valid_personalisation = {
'personalisation': {'Name': 'Jo'}
}
valid_personalisation = {"personalisation": {"Name": "Jo"}}
valid_post = [
(
@@ -18,8 +16,8 @@ valid_post = [
"Some content",
(
'<p style="Margin: 0 0 20px 0; font-size: 19px; line-height: 25px; color: #0B0C0C;">'
'Some content'
'</p>'
"Some content"
"</p>"
),
),
(
@@ -30,8 +28,8 @@ valid_post = [
"Dear Jo, Hello. Yours Truly, The Government.",
(
'<p style="Margin: 0 0 20px 0; font-size: 19px; line-height: 25px; color: #0B0C0C;">'
'Dear Jo, Hello. Yours Truly, The Government.'
'</p>'
"Dear Jo, Hello. Yours Truly, The Government."
"</p>"
),
),
(
@@ -42,8 +40,8 @@ valid_post = [
"Dear Jo, Hello. Yours Truly, The Government.",
(
'<p style="Margin: 0 0 20px 0; font-size: 19px; line-height: 25px; color: #0B0C0C;">'
'Dear Jo, Hello. Yours Truly, The Government.'
'</p>'
"Dear Jo, Hello. Yours Truly, The Government."
"</p>"
),
),
(
@@ -54,8 +52,8 @@ valid_post = [
"Some content",
(
'<p style="Margin: 0 0 20px 0; font-size: 19px; line-height: 25px; color: #0B0C0C;">'
'Some content'
'</p>'
"Some content"
"</p>"
),
),
]
@@ -64,7 +62,7 @@ valid_post = [
@pytest.mark.parametrize("tmp_type", TEMPLATE_TYPES)
@pytest.mark.parametrize(
"subject,content,post_data,expected_subject,expected_content,expected_html",
valid_post
valid_post,
)
def test_valid_post_template_returns_200(
client,
@@ -78,64 +76,53 @@ def test_valid_post_template_returns_200(
expected_html,
):
template = create_template(
sample_service,
template_type=tmp_type,
subject=subject,
content=content)
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.post(
path='/v2/template/{}/preview'.format(template.id),
data=json.dumps(post_data),
headers=[('Content-Type', 'application/json'), auth_header])
assert response.status_code == 200
resp_json = json.loads(response.get_data(as_text=True))
assert resp_json['id'] == str(template.id)
if tmp_type == EMAIL_TYPE:
assert expected_subject in resp_json['subject']
assert resp_json['html'] == expected_html
else:
assert resp_json['html'] is None
assert expected_content in resp_json['body']
def test_email_templates_not_rendered_into_content(
client,
sample_service
):
template = create_template(
sample_service,
template_type=EMAIL_TYPE,
subject='Test',
content=(
'Hello\n'
'\r\n'
'\r\n'
'\n'
'# This is a heading\n'
'\n'
'Paragraph'
),
sample_service, template_type=tmp_type, subject=subject, content=content
)
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.post(
path='/v2/template/{}/preview'.format(template.id),
data=json.dumps(None),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/template/{}/preview".format(template.id),
data=json.dumps(post_data),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
resp_json = json.loads(response.get_data(as_text=True))
assert resp_json['body'] == template.content
assert resp_json["id"] == str(template.id)
if tmp_type == EMAIL_TYPE:
assert expected_subject in resp_json["subject"]
assert resp_json["html"] == expected_html
else:
assert resp_json["html"] is None
assert expected_content in resp_json["body"]
def test_email_templates_not_rendered_into_content(client, sample_service):
template = create_template(
sample_service,
template_type=EMAIL_TYPE,
subject="Test",
content=("Hello\n" "\r\n" "\r\n" "\n" "# This is a heading\n" "\n" "Paragraph"),
)
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.post(
path="/v2/template/{}/preview".format(template.id),
data=json.dumps(None),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
resp_json = json.loads(response.get_data(as_text=True))
assert resp_json["body"] == template.content
@pytest.mark.parametrize("tmp_type", TEMPLATE_TYPES)
@@ -143,81 +130,93 @@ def test_invalid_post_template_returns_400(client, sample_service, tmp_type):
template = create_template(
sample_service,
template_type=tmp_type,
content='Dear ((Name)), Hello ((Missing)). Yours Truly, The Government.')
content="Dear ((Name)), Hello ((Missing)). Yours Truly, The Government.",
)
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.post(
path='/v2/template/{}/preview'.format(template.id),
path="/v2/template/{}/preview".format(template.id),
data=json.dumps(valid_personalisation),
headers=[('Content-Type', 'application/json'), auth_header])
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 400
resp_json = json.loads(response.get_data(as_text=True))
assert resp_json['errors'][0]['error'] == 'BadRequestError'
assert 'Missing personalisation: Missing' in resp_json['errors'][0]['message']
assert resp_json["errors"][0]["error"] == "BadRequestError"
assert "Missing personalisation: Missing" in resp_json["errors"][0]["message"]
def test_post_template_with_non_existent_template_id_returns_404(client, fake_uuid, sample_service):
def test_post_template_with_non_existent_template_id_returns_404(
client, fake_uuid, sample_service
):
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.post(
path='/v2/template/{}/preview'.format(fake_uuid),
path="/v2/template/{}/preview".format(fake_uuid),
data=json.dumps(valid_personalisation),
headers=[('Content-Type', 'application/json'), auth_header])
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 404
assert response.headers['Content-type'] == 'application/json'
assert response.headers["Content-type"] == "application/json"
json_response = json.loads(response.get_data(as_text=True))
assert json_response == {
"errors": [
{
"error": "NoResultFound",
"message": "No result found"
}
],
"status_code": 404
"errors": [{"error": "NoResultFound", "message": "No result found"}],
"status_code": 404,
}
def test_post_template_returns_200_without_personalisation(client, sample_template):
response = client.post(
path='/v2/template/{}/preview'.format(sample_template.id),
path="/v2/template/{}/preview".format(sample_template.id),
data=None,
headers=[('Content-Type', 'application/json'),
create_service_authorization_header(service_id=sample_template.service_id)]
headers=[
("Content-Type", "application/json"),
create_service_authorization_header(service_id=sample_template.service_id),
],
)
assert response.status_code == 200
def test_post_template_returns_200_without_personalisation_and_missing_content_header(client, sample_template):
def test_post_template_returns_200_without_personalisation_and_missing_content_header(
client, sample_template
):
response = client.post(
path='/v2/template/{}/preview'.format(sample_template.id),
path="/v2/template/{}/preview".format(sample_template.id),
data=None,
headers=[create_service_authorization_header(service_id=sample_template.service_id)]
headers=[
create_service_authorization_header(service_id=sample_template.service_id)
],
)
assert response.status_code == 200
def test_post_template_returns_200_without_personalisation_as_valid_json_and_missing_content_header(
client, sample_template
client, sample_template
):
response = client.post(
path='/v2/template/{}/preview'.format(sample_template.id),
path="/v2/template/{}/preview".format(sample_template.id),
data=json.dumps(None),
headers=[create_service_authorization_header(service_id=sample_template.service_id)]
headers=[
create_service_authorization_header(service_id=sample_template.service_id)
],
)
assert response.status_code == 200
def test_post_template_returns_200_with_valid_json_and_missing_content_header(client, sample_template):
def test_post_template_returns_200_with_valid_json_and_missing_content_header(
client, sample_template
):
response = client.post(
path='/v2/template/{}/preview'.format(sample_template.id),
path="/v2/template/{}/preview".format(sample_template.id),
data=json.dumps(valid_personalisation),
headers=[create_service_authorization_header(service_id=sample_template.service_id)]
headers=[
create_service_authorization_header(service_id=sample_template.service_id)
],
)
assert response.status_code == 200

143
tests/app/v2/template/test_template_schemas.py
View File

@@ -14,72 +14,84 @@ from app.v2.template.template_schemas import (
)
valid_json_get_response = {
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-01-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-01-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
valid_json_get_response_with_optionals = {
'id': str(uuid.uuid4()),
'type': EMAIL_TYPE,
'created_at': '2017-01-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'created_by': 'someone',
'body': 'some body',
'subject': "some subject",
'name': 'some name',
"id": str(uuid.uuid4()),
"type": EMAIL_TYPE,
"created_at": "2017-01-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"created_by": "someone",
"body": "some body",
"subject": "some subject",
"name": "some name",
}
valid_request_args = [{"id": str(uuid.uuid4()), "version": 1}, {"id": str(uuid.uuid4())}]
invalid_request_args = [
({"id": str(uuid.uuid4()), "version": "test"}, ["version test is not of type integer, null"]),
({"id": str(uuid.uuid4()), "version": 0}, ["version 0 is less than the minimum of 1"]),
({"version": 1}, ["id is a required property"]),
({"id": "invalid_uuid"}, ["id is not a valid UUID"]),
({"id": "invalid_uuid", "version": 0}, ["version 0 is less than the minimum of 1", "id is not a valid UUID"])
valid_request_args = [
{"id": str(uuid.uuid4()), "version": 1},
{"id": str(uuid.uuid4())},
]
valid_json_post_args = {
"id": str(uuid.uuid4()),
"personalisation": {"key": "value"}
}
invalid_request_args = [
(
{"id": str(uuid.uuid4()), "version": "test"},
["version test is not of type integer, null"],
),
(
{"id": str(uuid.uuid4()), "version": 0},
["version 0 is less than the minimum of 1"],
),
({"version": 1}, ["id is a required property"]),
({"id": "invalid_uuid"}, ["id is not a valid UUID"]),
(
{"id": "invalid_uuid", "version": 0},
["version 0 is less than the minimum of 1", "id is not a valid UUID"],
),
]
valid_json_post_args = {"id": str(uuid.uuid4()), "personalisation": {"key": "value"}}
invalid_json_post_args = [
(
{"id": "invalid_uuid", "personalisation": {"key": "value"}},
["id is not a valid UUID"]
["id is not a valid UUID"],
),
(
{"id": str(uuid.uuid4()), "personalisation": ['a', 'b']},
["personalisation [a, b] is not of type object"]
{"id": str(uuid.uuid4()), "personalisation": ["a", "b"]},
["personalisation [a, b] is not of type object"],
),
(
{"personalisation": "invalid_personalisation"},
["id is a required property", "personalisation invalid_personalisation is not of type object"]
)
[
"id is a required property",
"personalisation invalid_personalisation is not of type object",
],
),
]
valid_json_post_response = {
'id': str(uuid.uuid4()),
'type': 'email',
'version': 1,
'body': 'some body',
"id": str(uuid.uuid4()),
"type": "email",
"version": 1,
"body": "some body",
}
valid_json_post_response_with_optionals = {
'id': str(uuid.uuid4()),
'type': 'email',
'version': 1,
'body': "some body",
'subject': 'some subject',
'html': '<p>some body</p>',
"id": str(uuid.uuid4()),
"type": "email",
"version": 1,
"body": "some body",
"subject": "some subject",
"html": "<p>some body</p>",
}
@@ -89,31 +101,40 @@ def test_get_template_request_schema_against_valid_args_is_valid(args):
@pytest.mark.parametrize("args,error_message", invalid_request_args)
def test_get_template_request_schema_against_invalid_args_is_invalid(args, error_message):
def test_get_template_request_schema_against_invalid_args_is_invalid(
args, error_message
):
with pytest.raises(ValidationError) as e:
validate(args, get_template_by_id_request)
errors = json.loads(str(e.value))
assert errors['status_code'] == 400
assert errors["status_code"] == 400
for error in errors['errors']:
assert error['message'] in error_message
for error in errors["errors"]:
assert error["message"] in error_message
@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
@pytest.mark.parametrize("response", [valid_json_get_response, valid_json_get_response_with_optionals])
@pytest.mark.parametrize("updated_datetime", [None, '2017-01-11T18:25:43.511Z'])
def test_get_template_response_schema_is_valid(response, template_type, updated_datetime):
@pytest.mark.parametrize(
"response", [valid_json_get_response, valid_json_get_response_with_optionals]
)
@pytest.mark.parametrize("updated_datetime", [None, "2017-01-11T18:25:43.511Z"])
def test_get_template_response_schema_is_valid(
response, template_type, updated_datetime
):
if updated_datetime:
response['updated_at'] = updated_datetime
response["updated_at"] = updated_datetime
response['type'] = template_type
response["type"] = template_type
assert validate(response, get_template_by_id_response) == response
def test_post_template_preview_against_valid_args_is_valid():
assert validate(valid_json_post_args, post_template_preview_request) == valid_json_post_args
assert (
validate(valid_json_post_args, post_template_preview_request)
== valid_json_post_args
)
@pytest.mark.parametrize("args,error_messages", invalid_json_post_args)
@@ -122,15 +143,17 @@ def test_post_template_preview_against_invalid_args_is_invalid(args, error_messa
validate(args, post_template_preview_request)
errors = json.loads(str(e.value))
assert errors['status_code'] == 400
assert len(errors['errors']) == len(error_messages)
for error in errors['errors']:
assert error['message'] in error_messages
assert errors["status_code"] == 400
assert len(errors["errors"]) == len(error_messages)
for error in errors["errors"]:
assert error["message"] in error_messages
@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
@pytest.mark.parametrize("response", [valid_json_post_response, valid_json_post_response_with_optionals])
@pytest.mark.parametrize(
"response", [valid_json_post_response, valid_json_post_response_with_optionals]
)
def test_post_template_preview_response_schema_is_valid(response, template_type):
response['type'] = template_type
response["type"] = template_type
assert validate(response, post_template_preview_response) == response