darkhelm/notifications-api
1
0
Fork 0
mirror of https://github.com/GSA/notifications-api.git synced 2026-02-03 18:01:08 -05: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

192
tests/app/v2/inbound_sms/test_get_inbound_sms.py
View File

@@ -8,36 +8,41 @@ from tests.app.db import (
)
def test_get_inbound_sms_returns_200(
client, sample_service
):
def test_get_inbound_sms_returns_200(client, sample_service):
all_inbound_sms = [
create_inbound_sms(service=sample_service, user_number='447700900111', content='Hi'),
create_inbound_sms(service=sample_service, user_number='447700900112'),
create_inbound_sms(service=sample_service, user_number='447700900111', content='Bye'),
create_inbound_sms(service=sample_service, user_number='07700900113')
create_inbound_sms(
service=sample_service, user_number="447700900111", content="Hi"
),
create_inbound_sms(service=sample_service, user_number="447700900112"),
create_inbound_sms(
service=sample_service, user_number="447700900111", content="Bye"
),
create_inbound_sms(service=sample_service, user_number="07700900113"),
]
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
path='/v2/received-text-messages',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/received-text-messages",
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))['received_text_messages']
json_response = json.loads(response.get_data(as_text=True))[
"received_text_messages"
]
reversed_all_inbound_sms = sorted(all_inbound_sms, key=lambda sms: sms.created_at, reverse=True)
reversed_all_inbound_sms = sorted(
all_inbound_sms, key=lambda sms: sms.created_at, reverse=True
)
expected_response = [i.serialize() for i in reversed_all_inbound_sms]
assert json_response == expected_response
def test_get_inbound_sms_returns_200_when_service_has_callbacks(
client, sample_service
):
def test_get_inbound_sms_returns_200_when_service_has_callbacks(client, sample_service):
create_service_inbound_api(
service=sample_service,
url="https://inbound.example.com",
@@ -49,8 +54,8 @@ def test_get_inbound_sms_returns_200_when_service_has_callbacks(
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
path='/v2/received-text-messages',
headers=[('Content-Type', 'application/json'), auth_header],
path="/v2/received-text-messages",
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
@@ -58,105 +63,139 @@ def test_get_inbound_sms_returns_200_when_service_has_callbacks(
def test_get_inbound_sms_generate_page_links(client, sample_service, mocker):
mocker.patch.dict(
"app.v2.inbound_sms.get_inbound_sms.current_app.config",
{"API_PAGE_SIZE": 2}
"app.v2.inbound_sms.get_inbound_sms.current_app.config", {"API_PAGE_SIZE": 2}
)
all_inbound_sms = [
create_inbound_sms(service=sample_service, user_number='447700900111', content='Hi'),
create_inbound_sms(service=sample_service, user_number='447700900111'),
create_inbound_sms(service=sample_service, user_number='447700900111', content='End'),
create_inbound_sms(
service=sample_service, user_number="447700900111", content="Hi"
),
create_inbound_sms(service=sample_service, user_number="447700900111"),
create_inbound_sms(
service=sample_service, user_number="447700900111", content="End"
),
]
reversed_inbound_sms = sorted(all_inbound_sms, key=lambda sms: sms.created_at, reverse=True)
reversed_inbound_sms = sorted(
all_inbound_sms, key=lambda sms: sms.created_at, reverse=True
)
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
url_for('v2_inbound_sms.get_inbound_sms'),
headers=[('Content-Type', 'application/json'), auth_header])
url_for("v2_inbound_sms.get_inbound_sms"),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
json_response = json.loads(response.get_data(as_text=True))
expected_inbound_sms_list = [i.serialize() for i in reversed_inbound_sms[:2]]
assert json_response['received_text_messages'] == expected_inbound_sms_list
assert url_for(
'v2_inbound_sms.get_inbound_sms',
_external=True) == json_response['links']['current']
assert url_for(
'v2_inbound_sms.get_inbound_sms',
older_than=reversed_inbound_sms[1].id,
_external=True) == json_response['links']['next']
assert json_response["received_text_messages"] == expected_inbound_sms_list
assert (
url_for("v2_inbound_sms.get_inbound_sms", _external=True)
== json_response["links"]["current"]
)
assert (
url_for(
"v2_inbound_sms.get_inbound_sms",
older_than=reversed_inbound_sms[1].id,
_external=True,
)
== json_response["links"]["next"]
)
def test_get_next_inbound_sms_will_get_correct_inbound_sms_list(client, sample_service, mocker):
def test_get_next_inbound_sms_will_get_correct_inbound_sms_list(
client, sample_service, mocker
):
mocker.patch.dict(
"app.v2.inbound_sms.get_inbound_sms.current_app.config",
{"API_PAGE_SIZE": 2}
"app.v2.inbound_sms.get_inbound_sms.current_app.config", {"API_PAGE_SIZE": 2}
)
all_inbound_sms = [
create_inbound_sms(service=sample_service, user_number='447700900111', content='1'),
create_inbound_sms(service=sample_service, user_number='447700900111', content='2'),
create_inbound_sms(service=sample_service, user_number='447700900111', content='3'),
create_inbound_sms(service=sample_service, user_number='447700900111', content='4'),
create_inbound_sms(
service=sample_service, user_number="447700900111", content="1"
),
create_inbound_sms(
service=sample_service, user_number="447700900111", content="2"
),
create_inbound_sms(
service=sample_service, user_number="447700900111", content="3"
),
create_inbound_sms(
service=sample_service, user_number="447700900111", content="4"
),
]
reversed_inbound_sms = sorted(all_inbound_sms, key=lambda sms: sms.created_at, reverse=True)
reversed_inbound_sms = sorted(
all_inbound_sms, key=lambda sms: sms.created_at, reverse=True
)
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
path=url_for('v2_inbound_sms.get_inbound_sms', older_than=reversed_inbound_sms[1].id),
headers=[('Content-Type', 'application/json'), auth_header])
path=url_for(
"v2_inbound_sms.get_inbound_sms", older_than=reversed_inbound_sms[1].id
),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
json_response = json.loads(response.get_data(as_text=True))
expected_inbound_sms_list = [i.serialize() for i in reversed_inbound_sms[2:]]
assert json_response['received_text_messages'] == expected_inbound_sms_list
assert url_for(
'v2_inbound_sms.get_inbound_sms',
_external=True) == json_response['links']['current']
assert url_for(
'v2_inbound_sms.get_inbound_sms',
older_than=reversed_inbound_sms[3].id,
_external=True) == json_response['links']['next']
assert json_response["received_text_messages"] == expected_inbound_sms_list
assert (
url_for("v2_inbound_sms.get_inbound_sms", _external=True)
== json_response["links"]["current"]
)
assert (
url_for(
"v2_inbound_sms.get_inbound_sms",
older_than=reversed_inbound_sms[3].id,
_external=True,
)
== json_response["links"]["next"]
)
def test_get_next_inbound_sms_at_end_will_return_empty_inbound_sms_list(client, sample_service, mocker):
def test_get_next_inbound_sms_at_end_will_return_empty_inbound_sms_list(
client, sample_service, mocker
):
inbound_sms = create_inbound_sms(service=sample_service)
mocker.patch.dict(
"app.v2.inbound_sms.get_inbound_sms.current_app.config",
{"API_PAGE_SIZE": 1}
"app.v2.inbound_sms.get_inbound_sms.current_app.config", {"API_PAGE_SIZE": 1}
)
auth_header = create_service_authorization_header(service_id=inbound_sms.service.id)
response = client.get(
path=url_for('v2_inbound_sms.get_inbound_sms', older_than=inbound_sms.id),
headers=[('Content-Type', 'application/json'), auth_header])
path=url_for("v2_inbound_sms.get_inbound_sms", older_than=inbound_sms.id),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
json_response = json.loads(response.get_data(as_text=True))
expected_inbound_sms_list = []
assert json_response['received_text_messages'] == expected_inbound_sms_list
assert url_for(
'v2_inbound_sms.get_inbound_sms',
_external=True) == json_response['links']['current']
assert 'next' not in json_response['links'].keys()
assert json_response["received_text_messages"] == expected_inbound_sms_list
assert (
url_for("v2_inbound_sms.get_inbound_sms", _external=True)
== json_response["links"]["current"]
)
assert "next" not in json_response["links"].keys()
def test_get_inbound_sms_for_no_inbound_sms_returns_empty_list(
client, sample_service
):
def test_get_inbound_sms_for_no_inbound_sms_returns_empty_list(client, sample_service):
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
path='/v2/received-text-messages',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/received-text-messages",
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))['received_text_messages']
json_response = json.loads(response.get_data(as_text=True))[
"received_text_messages"
]
expected_response = []
@@ -166,15 +205,18 @@ def test_get_inbound_sms_for_no_inbound_sms_returns_empty_list(
def test_get_inbound_sms_with_invalid_query_string_returns_400(client, sample_service):
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
path='/v2/received-text-messages?user_number=447700900000',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/received-text-messages?user_number=447700900000",
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 400
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['status_code'] == 400
assert json_response['errors'][0]['error'] == 'ValidationError'
assert json_response['errors'][0]['message'] == \
'Additional properties are not allowed (user_number was unexpected)'
assert json_response["status_code"] == 400
assert json_response["errors"][0]["error"] == "ValidationError"
assert (
json_response["errors"][0]["message"]
== "Additional properties are not allowed (user_number was unexpected)"
)

56
tests/app/v2/inbound_sms/test_inbound_sms_schemas.py
View File

@@ -17,15 +17,12 @@ valid_inbound_sms = {
"service_id": "a5149c32-f03b-4711-af49-ad6993797d45",
"id": "342786aa-23ce-4695-9aad-7f79e68ee29a",
"notify_number": "testing",
"content": "Hello"
"content": "Hello",
}
valid_inbound_sms_list = {
"received_text_messages": [valid_inbound_sms],
"links": {
"current": valid_inbound_sms["id"]
}
"links": {"current": valid_inbound_sms["id"]},
}
invalid_inbound_sms = {
@@ -33,36 +30,44 @@ invalid_inbound_sms = {
"created_at": "2017-11-02T15:07:57.197546",
"service_id": "a5149c32-f03b-4711-af49-ad6993797d45",
"id": "342786aa-23ce-4695-9aad-7f79e68ee29a",
"notify_number": "testing"
"notify_number": "testing",
}
invalid_inbound_sms_list = {
"received_text_messages": [invalid_inbound_sms]
}
invalid_inbound_sms_list = {"received_text_messages": [invalid_inbound_sms]}
def test_get_inbound_sms_contract(client, sample_service):
all_inbound_sms = [
create_inbound_sms(service=sample_service, user_number='447700900113'),
create_inbound_sms(service=sample_service, user_number='447700900112'),
create_inbound_sms(service=sample_service, user_number='447700900111'),
create_inbound_sms(service=sample_service, user_number="447700900113"),
create_inbound_sms(service=sample_service, user_number="447700900112"),
create_inbound_sms(service=sample_service, user_number="447700900111"),
]
reversed_inbound_sms = sorted(all_inbound_sms, key=lambda sms: sms.created_at, reverse=True)
reversed_inbound_sms = sorted(
all_inbound_sms, key=lambda sms: sms.created_at, reverse=True
)
auth_header = create_service_authorization_header(service_id=all_inbound_sms[0].service_id)
response = client.get('/v2/received-text-messages', headers=[auth_header])
auth_header = create_service_authorization_header(
service_id=all_inbound_sms[0].service_id
)
response = client.get("/v2/received-text-messages", headers=[auth_header])
response_json = json.loads(response.get_data(as_text=True))
validated_resp = validate(response_json, get_inbound_sms_response)
assert validated_resp['received_text_messages'] == [i.serialize() for i in reversed_inbound_sms]
assert validated_resp['links']['current'] == url_for(
'v2_inbound_sms.get_inbound_sms', _external=True)
assert validated_resp['links']['next'] == url_for(
'v2_inbound_sms.get_inbound_sms', older_than=all_inbound_sms[0].id, _external=True)
assert validated_resp["received_text_messages"] == [
i.serialize() for i in reversed_inbound_sms
]
assert validated_resp["links"]["current"] == url_for(
"v2_inbound_sms.get_inbound_sms", _external=True
)
assert validated_resp["links"]["next"] == url_for(
"v2_inbound_sms.get_inbound_sms",
older_than=all_inbound_sms[0].id,
_external=True,
)
@pytest.mark.parametrize('request_args', [
{'older_than': "6ce466d0-fd6a-11e5-82f5-e0accb9d11a6"}, {}]
@pytest.mark.parametrize(
"request_args", [{"older_than": "6ce466d0-fd6a-11e5-82f5-e0accb9d11a6"}, {}]
)
def test_valid_inbound_sms_request_json(client, request_args):
validate(request_args, get_inbound_sms_request)
@@ -70,11 +75,14 @@ def test_valid_inbound_sms_request_json(client, request_args):
def test_invalid_inbound_sms_request_json(client):
with pytest.raises(expected_exception=ValidationError):
validate({'user_number': '447700900111'}, get_inbound_sms_request)
validate({"user_number": "447700900111"}, get_inbound_sms_request)
def test_valid_inbound_sms_response_json():
assert validate(valid_inbound_sms, get_inbound_sms_single_response) == valid_inbound_sms
assert (
validate(valid_inbound_sms, get_inbound_sms_single_response)
== valid_inbound_sms
)
def test_valid_inbound_sms_list_response_json():

629
tests/app/v2/notifications/test_get_notifications.py
View File

@@ -6,13 +6,11 @@ from tests import create_service_authorization_header
from tests.app.db import create_notification, create_template
@pytest.mark.parametrize('billable_units, provider', [
(1, 'sns'),
(0, 'sns'),
(1, None)
])
@pytest.mark.parametrize(
"billable_units, provider", [(1, "sns"), (0, "sns"), (1, None)]
)
def test_get_notification_by_id_returns_200(
client, billable_units, provider, sample_template
client, billable_units, provider, sample_template
):
sample_notification = create_notification(
template=sample_template,
@@ -27,119 +25,133 @@ def test_get_notification_by_id_returns_200(
sent_by=provider,
)
auth_header = create_service_authorization_header(service_id=sample_notification.service_id)
auth_header = create_service_authorization_header(
service_id=sample_notification.service_id
)
response = client.get(
path='/v2/notifications/{}'.format(sample_notification.id),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications/{}".format(sample_notification.id),
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_template_response = {
'id': '{}'.format(sample_notification.serialize()['template']['id']),
'version': sample_notification.serialize()['template']['version'],
'uri': sample_notification.serialize()['template']['uri']
"id": "{}".format(sample_notification.serialize()["template"]["id"]),
"version": sample_notification.serialize()["template"]["version"],
"uri": sample_notification.serialize()["template"]["uri"],
}
expected_response = {
'id': '{}'.format(sample_notification.id),
'reference': None,
'email_address': None,
'phone_number': '{}'.format(sample_notification.to),
'line_1': None,
'line_2': None,
'line_3': None,
'line_4': None,
'line_5': None,
'line_6': None,
'postcode': None,
'type': '{}'.format(sample_notification.notification_type),
'status': '{}'.format(sample_notification.status),
'template': expected_template_response,
'created_at': sample_notification.created_at.strftime(DATETIME_FORMAT),
'created_by_name': None,
'body': sample_notification.template.content,
"id": "{}".format(sample_notification.id),
"reference": None,
"email_address": None,
"phone_number": "{}".format(sample_notification.to),
"line_1": None,
"line_2": None,
"line_3": None,
"line_4": None,
"line_5": None,
"line_6": None,
"postcode": None,
"type": "{}".format(sample_notification.notification_type),
"status": "{}".format(sample_notification.status),
"template": expected_template_response,
"created_at": sample_notification.created_at.strftime(DATETIME_FORMAT),
"created_by_name": None,
"body": sample_notification.template.content,
"subject": None,
'sent_at': sample_notification.sent_at,
'completed_at': sample_notification.completed_at(),
'scheduled_for': None,
'provider_response': None
"sent_at": sample_notification.sent_at,
"completed_at": sample_notification.completed_at(),
"scheduled_for": None,
"provider_response": None,
}
assert json_response == expected_response
def test_get_notification_by_id_with_placeholders_returns_200(
client, sample_email_template_with_placeholders
client, sample_email_template_with_placeholders
):
sample_notification = create_notification(
template=sample_email_template_with_placeholders,
personalisation={"name": "Bob"}
personalisation={"name": "Bob"},
)
auth_header = create_service_authorization_header(service_id=sample_notification.service_id)
auth_header = create_service_authorization_header(
service_id=sample_notification.service_id
)
response = client.get(
path='/v2/notifications/{}'.format(sample_notification.id),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications/{}".format(sample_notification.id),
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_template_response = {
'id': '{}'.format(sample_notification.serialize()['template']['id']),
'version': sample_notification.serialize()['template']['version'],
'uri': sample_notification.serialize()['template']['uri']
"id": "{}".format(sample_notification.serialize()["template"]["id"]),
"version": sample_notification.serialize()["template"]["version"],
"uri": sample_notification.serialize()["template"]["uri"],
}
expected_response = {
'id': '{}'.format(sample_notification.id),
'reference': None,
'email_address': '{}'.format(sample_notification.to),
'phone_number': None,
'line_1': None,
'line_2': None,
'line_3': None,
'line_4': None,
'line_5': None,
'line_6': None,
'postcode': None,
'type': '{}'.format(sample_notification.notification_type),
'status': '{}'.format(sample_notification.status),
'template': expected_template_response,
'created_at': sample_notification.created_at.strftime(DATETIME_FORMAT),
'created_by_name': None,
'body': "Hello Bob\nThis is an email from GOV.UK",
"id": "{}".format(sample_notification.id),
"reference": None,
"email_address": "{}".format(sample_notification.to),
"phone_number": None,
"line_1": None,
"line_2": None,
"line_3": None,
"line_4": None,
"line_5": None,
"line_6": None,
"postcode": None,
"type": "{}".format(sample_notification.notification_type),
"status": "{}".format(sample_notification.status),
"template": expected_template_response,
"created_at": sample_notification.created_at.strftime(DATETIME_FORMAT),
"created_by_name": None,
"body": "Hello Bob\nThis is an email from GOV.UK",
"subject": "Bob",
'sent_at': sample_notification.sent_at,
'completed_at': sample_notification.completed_at(),
'scheduled_for': None,
'provider_response': None
"sent_at": sample_notification.sent_at,
"completed_at": sample_notification.completed_at(),
"scheduled_for": None,
"provider_response": None,
}
assert json_response == expected_response
def test_get_notification_by_reference_returns_200(client, sample_template):
sample_notification_with_reference = create_notification(template=sample_template,
client_reference='some-client-reference')
sample_notification_with_reference = create_notification(
template=sample_template, client_reference="some-client-reference"
)
auth_header = create_service_authorization_header(service_id=sample_notification_with_reference.service_id)
auth_header = create_service_authorization_header(
service_id=sample_notification_with_reference.service_id
)
response = client.get(
path='/v2/notifications?reference={}'.format(sample_notification_with_reference.client_reference),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?reference={}".format(
sample_notification_with_reference.client_reference
),
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))
assert len(json_response['notifications']) == 1
assert len(json_response["notifications"]) == 1
assert json_response['notifications'][0]['id'] == str(sample_notification_with_reference.id)
assert json_response['notifications'][0]['reference'] == "some-client-reference"
assert json_response["notifications"][0]["id"] == str(
sample_notification_with_reference.id
)
assert json_response["notifications"][0]["reference"] == "some-client-reference"
def test_get_notification_by_id_returns_created_by_name_if_notification_created_by_id(
@@ -150,110 +162,134 @@ def test_get_notification_by_id_returns_created_by_name_if_notification_created_
sms_notification = create_notification(template=sample_template)
sms_notification.created_by_id = sample_user.id
auth_header = create_service_authorization_header(service_id=sms_notification.service_id)
auth_header = create_service_authorization_header(
service_id=sms_notification.service_id
)
response = client.get(
path=url_for('v2_notifications.get_notification_by_id', notification_id=sms_notification.id),
headers=[('Content-Type', 'application/json'), auth_header]
path=url_for(
"v2_notifications.get_notification_by_id",
notification_id=sms_notification.id,
),
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = response.get_json()
assert json_response['created_by_name'] == 'Test User'
assert json_response["created_by_name"] == "Test User"
def test_get_notification_by_reference_nonexistent_reference_returns_no_notifications(client, sample_service):
def test_get_notification_by_reference_nonexistent_reference_returns_no_notifications(
client, sample_service
):
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
path='/v2/notifications?reference={}'.format('nonexistent-reference'),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?reference={}".format("nonexistent-reference"),
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert len(json_response['notifications']) == 0
assert response.headers["Content-type"] == "application/json"
assert len(json_response["notifications"]) == 0
def test_get_notification_by_id_nonexistent_id(client, sample_notification):
auth_header = create_service_authorization_header(service_id=sample_notification.service_id)
auth_header = create_service_authorization_header(
service_id=sample_notification.service_id
)
response = client.get(
path='/v2/notifications/dd4b8b9d-d414-4a83-9256-580046bf18f9',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications/dd4b8b9d-d414-4a83-9256-580046bf18f9",
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("id", ["1234-badly-formatted-id-7890", "0"])
def test_get_notification_by_id_invalid_id(client, sample_notification, id):
auth_header = create_service_authorization_header(service_id=sample_notification.service_id)
auth_header = create_service_authorization_header(
service_id=sample_notification.service_id
)
response = client.get(
path='/v2/notifications/{}'.format(id),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications/{}".format(id),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 400
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": "ValidationError",
"message": "notification_id is not a valid UUID"
}],
"status_code": 400}
assert json_response == {
"errors": [
{
"error": "ValidationError",
"message": "notification_id is not a valid UUID",
}
],
"status_code": 400,
}
@pytest.mark.parametrize('template_type', ['sms', 'email'])
def test_get_notification_doesnt_have_delivery_estimate_for_non_letters(client, sample_service, template_type):
@pytest.mark.parametrize("template_type", ["sms", "email"])
def test_get_notification_doesnt_have_delivery_estimate_for_non_letters(
client, sample_service, template_type
):
template = create_template(service=sample_service, template_type=template_type)
mocked_notification = create_notification(template=template)
auth_header = create_service_authorization_header(service_id=mocked_notification.service_id)
auth_header = create_service_authorization_header(
service_id=mocked_notification.service_id
)
response = client.get(
path='/v2/notifications/{}'.format(mocked_notification.id),
headers=[('Content-Type', 'application/json'), auth_header]
path="/v2/notifications/{}".format(mocked_notification.id),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
assert 'estimated_delivery' not in json.loads(response.get_data(as_text=True))
assert "estimated_delivery" not in json.loads(response.get_data(as_text=True))
def test_get_all_notifications_except_job_notifications_returns_200(client, sample_template, sample_job):
create_notification(template=sample_template, job=sample_job) # should not return this job notification
def test_get_all_notifications_except_job_notifications_returns_200(
client, sample_template, sample_job
):
create_notification(
template=sample_template, job=sample_job
) # should not return this job notification
notifications = [create_notification(template=sample_template) for _ in range(2)]
notification = notifications[-1]
auth_header = create_service_authorization_header(service_id=notification.service_id)
auth_header = create_service_authorization_header(
service_id=notification.service_id
)
response = client.get(
path='/v2/notifications',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications")
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 2
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith("/v2/notifications")
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 2
assert json_response['notifications'][0]['id'] == str(notification.id)
assert json_response['notifications'][0]['status'] == "created"
assert json_response['notifications'][0]['template'] == {
'id': str(notification.template.id),
'uri': notification.template.get_link(),
'version': 1
assert json_response["notifications"][0]["id"] == str(notification.id)
assert json_response["notifications"][0]["status"] == "created"
assert json_response["notifications"][0]["template"] == {
"id": str(notification.template.id),
"uri": notification.template.get_link(),
"version": 1,
}
assert json_response['notifications'][0]['phone_number'] == "+447700900855"
assert json_response['notifications'][0]['type'] == "sms"
assert not json_response['notifications'][0]['scheduled_for']
assert json_response["notifications"][0]["phone_number"] == "+447700900855"
assert json_response["notifications"][0]["type"] == "sms"
assert not json_response["notifications"][0]["scheduled_for"]
def test_get_all_notifications_with_include_jobs_arg_returns_200(
@@ -261,128 +297,166 @@ def test_get_all_notifications_with_include_jobs_arg_returns_200(
):
notifications = [
create_notification(template=sample_template, job=sample_job),
create_notification(template=sample_template)
create_notification(template=sample_template),
]
notification = notifications[-1]
auth_header = create_service_authorization_header(service_id=notification.service_id)
auth_header = create_service_authorization_header(
service_id=notification.service_id
)
response = client.get(
path='/v2/notifications?include_jobs=true',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?include_jobs=true",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert json_response['links']['current'].endswith("/v2/notifications?include_jobs=true")
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 2
assert json_response["links"]["current"].endswith(
"/v2/notifications?include_jobs=true"
)
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 2
assert json_response['notifications'][0]['id'] == str(notification.id)
assert json_response['notifications'][0]['status'] == notification.status
assert json_response['notifications'][0]['phone_number'] == notification.to
assert json_response['notifications'][0]['type'] == notification.template.template_type
assert not json_response['notifications'][0]['scheduled_for']
assert json_response["notifications"][0]["id"] == str(notification.id)
assert json_response["notifications"][0]["status"] == notification.status
assert json_response["notifications"][0]["phone_number"] == notification.to
assert (
json_response["notifications"][0]["type"] == notification.template.template_type
)
assert not json_response["notifications"][0]["scheduled_for"]
def test_get_all_notifications_no_notifications_if_no_notifications(client, sample_service):
def test_get_all_notifications_no_notifications_if_no_notifications(
client, sample_service
):
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(
path='/v2/notifications',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications")
assert 'next' not in json_response['links'].keys()
assert len(json_response['notifications']) == 0
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith("/v2/notifications")
assert "next" not in json_response["links"].keys()
assert len(json_response["notifications"]) == 0
def test_get_all_notifications_filter_by_template_type(client, sample_service):
email_template = create_template(service=sample_service, template_type="email")
sms_template = create_template(service=sample_service, template_type="sms")
notification = create_notification(template=email_template, to_field="don.draper@scdp.biz")
notification = create_notification(
template=email_template, to_field="don.draper@scdp.biz"
)
create_notification(template=sms_template)
auth_header = create_service_authorization_header(service_id=notification.service_id)
auth_header = create_service_authorization_header(
service_id=notification.service_id
)
response = client.get(
path='/v2/notifications?template_type=email',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?template_type=email",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications?template_type=email")
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 1
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith(
"/v2/notifications?template_type=email"
)
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 1
assert json_response['notifications'][0]['id'] == str(notification.id)
assert json_response['notifications'][0]['status'] == "created"
assert json_response['notifications'][0]['template'] == {
'id': str(email_template.id),
'uri': notification.template.get_link(),
'version': 1
assert json_response["notifications"][0]["id"] == str(notification.id)
assert json_response["notifications"][0]["status"] == "created"
assert json_response["notifications"][0]["template"] == {
"id": str(email_template.id),
"uri": notification.template.get_link(),
"version": 1,
}
assert json_response['notifications'][0]['email_address'] == "don.draper@scdp.biz"
assert json_response['notifications'][0]['type'] == "email"
assert json_response["notifications"][0]["email_address"] == "don.draper@scdp.biz"
assert json_response["notifications"][0]["type"] == "email"
def test_get_all_notifications_filter_by_template_type_invalid_template_type(client, sample_notification):
auth_header = create_service_authorization_header(service_id=sample_notification.service_id)
def test_get_all_notifications_filter_by_template_type_invalid_template_type(
client, sample_notification
):
auth_header = create_service_authorization_header(
service_id=sample_notification.service_id
)
response = client.get(
path='/v2/notifications?template_type=orange',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?template_type=orange",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 400
assert response.headers['Content-type'] == "application/json"
assert response.headers["Content-type"] == "application/json"
assert json_response['status_code'] == 400
assert len(json_response['errors']) == 1
assert json_response['errors'][0]['message'] == "template_type orange is not one of [sms, email]"
assert json_response["status_code"] == 400
assert len(json_response["errors"]) == 1
assert (
json_response["errors"][0]["message"]
== "template_type orange is not one of [sms, email]"
)
def test_get_all_notifications_filter_by_single_status(client, sample_template):
notification = create_notification(template=sample_template, status="pending")
create_notification(template=sample_template)
auth_header = create_service_authorization_header(service_id=notification.service_id)
auth_header = create_service_authorization_header(
service_id=notification.service_id
)
response = client.get(
path='/v2/notifications?status=pending',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?status=pending",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications?status=pending")
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 1
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith(
"/v2/notifications?status=pending"
)
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 1
assert json_response['notifications'][0]['id'] == str(notification.id)
assert json_response['notifications'][0]['status'] == "pending"
assert json_response["notifications"][0]["id"] == str(notification.id)
assert json_response["notifications"][0]["status"] == "pending"
def test_get_all_notifications_filter_by_status_invalid_status(client, sample_notification):
auth_header = create_service_authorization_header(service_id=sample_notification.service_id)
def test_get_all_notifications_filter_by_status_invalid_status(
client, sample_notification
):
auth_header = create_service_authorization_header(
service_id=sample_notification.service_id
)
response = client.get(
path='/v2/notifications?status=elephant',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?status=elephant",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 400
assert response.headers['Content-type'] == "application/json"
assert response.headers["Content-type"] == "application/json"
assert json_response['status_code'] == 400
assert len(json_response['errors']) == 1
assert json_response['errors'][0]['message'] == "status elephant is not one of [cancelled, created, sending, " \
"sent, delivered, pending, failed, technical-failure, temporary-failure, permanent-failure, " \
assert json_response["status_code"] == 400
assert len(json_response["errors"]) == 1
assert (
json_response["errors"][0]["message"]
== "status elephant is not one of [cancelled, created, sending, "
"sent, delivered, pending, failed, technical-failure, temporary-failure, permanent-failure, "
"pending-virus-check, validation-failed, virus-scan-failed]"
)
def test_get_all_notifications_filter_by_multiple_statuses(client, sample_template):
@@ -390,22 +464,29 @@ def test_get_all_notifications_filter_by_multiple_statuses(client, sample_templa
create_notification(template=sample_template, status=_status)
for _status in ["created", "pending", "sending"]
]
failed_notification = create_notification(template=sample_template, status="permanent-failure")
failed_notification = create_notification(
template=sample_template, status="permanent-failure"
)
auth_header = create_service_authorization_header(service_id=notifications[0].service_id)
auth_header = create_service_authorization_header(
service_id=notifications[0].service_id
)
response = client.get(
path='/v2/notifications?status=created&status=pending&status=sending',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?status=created&status=pending&status=sending",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications?status=created&status=pending&status=sending")
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 3
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith(
"/v2/notifications?status=created&status=pending&status=sending"
)
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 3
returned_notification_ids = [_n['id'] for _n in json_response['notifications']]
returned_notification_ids = [_n["id"] for _n in json_response["notifications"]]
for _id in [_notification.id for _notification in notifications]:
assert str(_id) in returned_notification_ids
@@ -413,22 +494,29 @@ def test_get_all_notifications_filter_by_multiple_statuses(client, sample_templa
def test_get_all_notifications_filter_by_failed_status(client, sample_template):
created_notification = create_notification(template=sample_template, status="created")
failed_notifications = [create_notification(template=sample_template, status='failed')]
auth_header = create_service_authorization_header(service_id=created_notification.service_id)
created_notification = create_notification(
template=sample_template, status="created"
)
failed_notifications = [
create_notification(template=sample_template, status="failed")
]
auth_header = create_service_authorization_header(
service_id=created_notification.service_id
)
response = client.get(
path='/v2/notifications?status=failed',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?status=failed",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications?status=failed")
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 1
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith("/v2/notifications?status=failed")
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 1
returned_notification_ids = [n['id'] for n in json_response['notifications']]
returned_notification_ids = [n["id"] for n in json_response["notifications"]]
for _id in [_notification.id for _notification in failed_notifications]:
assert str(_id) in returned_notification_ids
@@ -439,79 +527,103 @@ def test_get_all_notifications_filter_by_id(client, sample_template):
older_notification = create_notification(template=sample_template)
newer_notification = create_notification(template=sample_template)
auth_header = create_service_authorization_header(service_id=newer_notification.service_id)
auth_header = create_service_authorization_header(
service_id=newer_notification.service_id
)
response = client.get(
path='/v2/notifications?older_than={}'.format(newer_notification.id),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?older_than={}".format(newer_notification.id),
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications?older_than={}".format(newer_notification.id))
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 1
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith(
"/v2/notifications?older_than={}".format(newer_notification.id)
)
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 1
assert json_response['notifications'][0]['id'] == str(older_notification.id)
assert json_response["notifications"][0]["id"] == str(older_notification.id)
def test_get_all_notifications_filter_by_id_invalid_id(client, sample_notification):
auth_header = create_service_authorization_header(service_id=sample_notification.service_id)
auth_header = create_service_authorization_header(
service_id=sample_notification.service_id
)
response = client.get(
path='/v2/notifications?older_than=1234-badly-formatted-id-7890',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?older_than=1234-badly-formatted-id-7890",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert json_response['status_code'] == 400
assert len(json_response['errors']) == 1
assert json_response['errors'][0]['message'] == "older_than is not a valid UUID"
assert json_response["status_code"] == 400
assert len(json_response["errors"]) == 1
assert json_response["errors"][0]["message"] == "older_than is not a valid UUID"
def test_get_all_notifications_filter_by_id_no_notifications_if_nonexistent_id(client, sample_template):
def test_get_all_notifications_filter_by_id_no_notifications_if_nonexistent_id(
client, sample_template
):
notification = create_notification(template=sample_template)
auth_header = create_service_authorization_header(service_id=notification.service_id)
auth_header = create_service_authorization_header(
service_id=notification.service_id
)
response = client.get(
path='/v2/notifications?older_than=dd4b8b9d-d414-4a83-9256-580046bf18f9',
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?older_than=dd4b8b9d-d414-4a83-9256-580046bf18f9",
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith(
"/v2/notifications?older_than=dd4b8b9d-d414-4a83-9256-580046bf18f9")
assert 'next' not in json_response['links'].keys()
assert len(json_response['notifications']) == 0
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith(
"/v2/notifications?older_than=dd4b8b9d-d414-4a83-9256-580046bf18f9"
)
assert "next" not in json_response["links"].keys()
assert len(json_response["notifications"]) == 0
def test_get_all_notifications_filter_by_id_no_notifications_if_last_notification(client, sample_template):
def test_get_all_notifications_filter_by_id_no_notifications_if_last_notification(
client, sample_template
):
notification = create_notification(template=sample_template)
auth_header = create_service_authorization_header(service_id=notification.service_id)
auth_header = create_service_authorization_header(
service_id=notification.service_id
)
response = client.get(
path='/v2/notifications?older_than={}'.format(notification.id),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?older_than={}".format(notification.id),
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert json_response['links']['current'].endswith("/v2/notifications?older_than={}".format(notification.id))
assert 'next' not in json_response['links'].keys()
assert len(json_response['notifications']) == 0
assert response.headers["Content-type"] == "application/json"
assert json_response["links"]["current"].endswith(
"/v2/notifications?older_than={}".format(notification.id)
)
assert "next" not in json_response["links"].keys()
assert len(json_response["notifications"]) == 0
def test_get_all_notifications_filter_multiple_query_parameters(client, sample_email_template):
def test_get_all_notifications_filter_multiple_query_parameters(
client, sample_email_template
):
# TODO had to change pending to sending. Is that correct?
# this is the notification we are looking for
older_notification = create_notification(
template=sample_email_template, status="sending")
template=sample_email_template, status="sending"
)
# wrong status
create_notification(template=sample_email_template)
wrong_template = create_template(sample_email_template.service, template_type='sms')
wrong_template = create_template(sample_email_template.service, template_type="sms")
# wrong template
create_notification(template=wrong_template, status="sending")
@@ -521,28 +633,33 @@ def test_get_all_notifications_filter_multiple_query_parameters(client, sample_e
# this notification was created too recently
create_notification(template=sample_email_template, status="sending")
auth_header = create_service_authorization_header(service_id=newer_notification.service_id)
auth_header = create_service_authorization_header(
service_id=newer_notification.service_id
)
response = client.get(
path='/v2/notifications?status=sending&template_type=email&older_than={}'.format(newer_notification.id),
headers=[('Content-Type', 'application/json'), auth_header])
path="/v2/notifications?status=sending&template_type=email&older_than={}".format(
newer_notification.id
),
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
assert response.headers['Content-type'] == "application/json"
assert response.headers["Content-type"] == "application/json"
# query parameters aren't returned in order
for url_part in [
"/v2/notifications?",
"template_type=email",
"status=sending",
"older_than={}".format(newer_notification.id)
"older_than={}".format(newer_notification.id),
]:
assert url_part in json_response['links']['current']
assert url_part in json_response["links"]["current"]
assert 'next' in json_response['links'].keys()
assert len(json_response['notifications']) == 1
assert "next" in json_response["links"].keys()
assert len(json_response["notifications"]) == 1
assert json_response['notifications'][0]['id'] == str(older_notification.id)
assert json_response["notifications"][0]["id"] == str(older_notification.id)
def test_get_all_notifications_renames_letter_statuses(
@@ -550,17 +667,19 @@ def test_get_all_notifications_renames_letter_statuses(
sample_notification,
sample_email_notification,
):
auth_header = create_service_authorization_header(service_id=sample_email_notification.service_id)
auth_header = create_service_authorization_header(
service_id=sample_email_notification.service_id
)
response = client.get(
path=url_for('v2_notifications.get_notifications'),
headers=[('Content-Type', 'application/json'), auth_header]
path=url_for("v2_notifications.get_notifications"),
headers=[("Content-Type", "application/json"), auth_header],
)
json_response = json.loads(response.get_data(as_text=True))
assert response.status_code == 200
for noti in json_response['notifications']:
if noti['type'] == 'sms' or noti['type'] == 'email':
assert noti['status'] == 'created'
for noti in json_response["notifications"]:
if noti["type"] == "sms" or noti["type"] == "email":
assert noti["status"] == "created"
else:
pytest.fail()

340
tests/app/v2/notifications/test_notification_schemas.py
View File

@@ -22,7 +22,7 @@ valid_get_with_optionals_json = {
"status": [NOTIFICATION_CREATED],
"template_type": [EMAIL_TYPE],
"include_jobs": "true",
"older_than": "a5149c32-f03b-4711-af49-ad6993797d45"
"older_than": "a5149c32-f03b-4711-af49-ad6993797d45",
}
@@ -31,85 +31,106 @@ def test_get_notifications_valid_json(input):
assert validate(input, get_notifications_request) == input
@pytest.mark.parametrize('invalid_statuses, valid_statuses', [
# one invalid status
(["elephant"], []),
# multiple invalid statuses
(["elephant", "giraffe", "cheetah"], []),
# one bad status and one good status
(["elephant"], ["created"]),
])
def test_get_notifications_request_invalid_statuses(
invalid_statuses, valid_statuses
):
partial_error_status = "is not one of " \
"[cancelled, created, sending, sent, delivered, pending, failed, " \
"technical-failure, temporary-failure, permanent-failure, pending-virus-check, " \
@pytest.mark.parametrize(
"invalid_statuses, valid_statuses",
[
# one invalid status
(["elephant"], []),
# multiple invalid statuses
(["elephant", "giraffe", "cheetah"], []),
# one bad status and one good status
(["elephant"], ["created"]),
],
)
def test_get_notifications_request_invalid_statuses(invalid_statuses, valid_statuses):
partial_error_status = (
"is not one of "
"[cancelled, created, sending, sent, delivered, pending, failed, "
"technical-failure, temporary-failure, permanent-failure, pending-virus-check, "
"validation-failed, virus-scan-failed]"
)
with pytest.raises(ValidationError) as e:
validate({'status': invalid_statuses + valid_statuses}, get_notifications_request)
validate(
{"status": invalid_statuses + valid_statuses}, get_notifications_request
)
errors = json.loads(str(e.value)).get('errors')
errors = json.loads(str(e.value)).get("errors")
assert len(errors) == len(invalid_statuses)
for index, value in enumerate(invalid_statuses):
assert errors[index]['message'] == "status {} {}".format(value, partial_error_status)
assert errors[index]["message"] == "status {} {}".format(
value, partial_error_status
)
@pytest.mark.parametrize('invalid_template_types, valid_template_types', [
# one invalid template_type
(["orange"], []),
# multiple invalid template_types
(["orange", "avocado", "banana"], []),
# one bad template_type and one good template_type
(["orange"], ["sms"]),
])
@pytest.mark.parametrize(
"invalid_template_types, valid_template_types",
[
# one invalid template_type
(["orange"], []),
# multiple invalid template_types
(["orange", "avocado", "banana"], []),
# one bad template_type and one good template_type
(["orange"], ["sms"]),
],
)
def test_get_notifications_request_invalid_template_types(
invalid_template_types, valid_template_types
invalid_template_types, valid_template_types
):
partial_error_template_type = "is not one of [sms, email]"
with pytest.raises(ValidationError) as e:
validate({'template_type': invalid_template_types + valid_template_types}, get_notifications_request)
validate(
{"template_type": invalid_template_types + valid_template_types},
get_notifications_request,
)
errors = json.loads(str(e.value)).get('errors')
errors = json.loads(str(e.value)).get("errors")
assert len(errors) == len(invalid_template_types)
for index, value in enumerate(invalid_template_types):
assert errors[index]['message'] == "template_type {} {}".format(value, partial_error_template_type)
assert errors[index]["message"] == "template_type {} {}".format(
value, partial_error_template_type
)
def test_get_notifications_request_invalid_statuses_and_template_types():
with pytest.raises(ValidationError) as e:
validate({
'status': ["created", "elephant", "giraffe"],
'template_type': ["sms", "orange", "avocado"]
}, get_notifications_request)
validate(
{
"status": ["created", "elephant", "giraffe"],
"template_type": ["sms", "orange", "avocado"],
},
get_notifications_request,
)
errors = json.loads(str(e.value)).get('errors')
errors = json.loads(str(e.value)).get("errors")
assert len(errors) == 4
error_messages = [error['message'] for error in errors]
error_messages = [error["message"] for error in errors]
for invalid_status in ["elephant", "giraffe"]:
assert "status {} is not one of [cancelled, created, sending, sent, delivered, " \
"pending, failed, technical-failure, temporary-failure, permanent-failure, " \
assert (
"status {} is not one of [cancelled, created, sending, sent, delivered, "
"pending, failed, technical-failure, temporary-failure, permanent-failure, "
"pending-virus-check, validation-failed, virus-scan-failed]".format(
invalid_status
) in error_messages
)
in error_messages
)
for invalid_template_type in ["orange", "avocado"]:
assert "template_type {} is not one of [sms, email]" \
.format(invalid_template_type) in error_messages
assert (
"template_type {} is not one of [sms, email]".format(invalid_template_type)
in error_messages
)
valid_json = {"phone_number": "2028675309",
"template_id": str(uuid.uuid4())
}
valid_json = {"phone_number": "2028675309", "template_id": str(uuid.uuid4())}
valid_json_with_optionals = {
"phone_number": "2028675309",
"template_id": str(uuid.uuid4()),
"reference": "reference from caller",
"personalisation": {"key": "value"}
"personalisation": {"key": "value"},
}
@@ -118,28 +139,29 @@ def test_post_sms_schema_is_valid(input):
assert validate(input, post_sms_request_schema) == input
@pytest.mark.parametrize("template_id",
['2ebe4da8-17be-49fe-b02f-dff2760261a0' + "\n",
'2ebe4da8-17be-49fe-b02f-dff2760261a0' + " ",
'2ebe4da8-17be-49fe-b02f-dff2760261a0' + "\r",
"\t" + '2ebe4da8-17be-49fe-b02f-dff2760261a0',
'2ebe4da8-17be-49fe-b02f-dff2760261a0'[4:],
"bad_uuid"
]
)
@pytest.mark.parametrize(
"template_id",
[
"2ebe4da8-17be-49fe-b02f-dff2760261a0" + "\n",
"2ebe4da8-17be-49fe-b02f-dff2760261a0" + " ",
"2ebe4da8-17be-49fe-b02f-dff2760261a0" + "\r",
"\t" + "2ebe4da8-17be-49fe-b02f-dff2760261a0",
"2ebe4da8-17be-49fe-b02f-dff2760261a0"[4:],
"bad_uuid",
],
)
def test_post_sms_json_schema_bad_uuid(template_id):
j = {
"template_id": template_id,
"phone_number": "2028675309"
}
j = {"template_id": template_id, "phone_number": "2028675309"}
with pytest.raises(ValidationError) as e:
validate(j, post_sms_request_schema)
error = json.loads(str(e.value))
assert len(error.keys()) == 2
assert error.get('status_code') == 400
assert len(error.get('errors')) == 1
assert {'error': 'ValidationError',
'message': "template_id is not a valid UUID"} in error['errors']
assert error.get("status_code") == 400
assert len(error.get("errors")) == 1
assert {
"error": "ValidationError",
"message": "template_id is not a valid UUID",
} in error["errors"]
def test_post_sms_json_schema_bad_uuid_and_missing_phone_number():
@@ -148,12 +170,16 @@ def test_post_sms_json_schema_bad_uuid_and_missing_phone_number():
validate(j, post_sms_request_schema)
error = json.loads(str(e.value))
assert len(error.keys()) == 2
assert error.get('status_code') == 400
assert len(error.get('errors')) == 2
assert {'error': 'ValidationError',
'message': "phone_number is a required property"} in error['errors']
assert {'error': 'ValidationError',
'message': "template_id is not a valid UUID"} in error['errors']
assert error.get("status_code") == 400
assert len(error.get("errors")) == 2
assert {
"error": "ValidationError",
"message": "phone_number is a required property",
} in error["errors"]
assert {
"error": "ValidationError",
"message": "template_id is not a valid UUID",
} in error["errors"]
def test_post_sms_schema_with_personalisation_that_is_not_a_dict():
@@ -161,61 +187,79 @@ def test_post_sms_schema_with_personalisation_that_is_not_a_dict():
"phone_number": "2028675309",
"template_id": str(uuid.uuid4()),
"reference": "reference from caller",
"personalisation": "not_a_dict"
"personalisation": "not_a_dict",
}
with pytest.raises(ValidationError) as e:
validate(j, post_sms_request_schema)
error = json.loads(str(e.value))
assert len(error.get('errors')) == 1
assert error['errors'] == [{'error': 'ValidationError',
'message': "personalisation not_a_dict is not of type object"}]
assert error.get('status_code') == 400
assert len(error.get("errors")) == 1
assert error["errors"] == [
{
"error": "ValidationError",
"message": "personalisation not_a_dict is not of type object",
}
]
assert error.get("status_code") == 400
assert len(error.keys()) == 2
@pytest.mark.parametrize('invalid_phone_number, err_msg', [
('08515111111', 'phone_number Phone number is not possible'),
('07515111*11', 'phone_number Not enough digits'),
('notaphoneumber', 'phone_number The string supplied did not seem to be a phone number.'),
(7700900001, 'phone_number 7700900001 is not of type string'),
(None, 'phone_number None is not of type string'),
([], 'phone_number [] is not of type string'),
({}, 'phone_number {} is not of type string'),
])
@pytest.mark.parametrize(
"invalid_phone_number, err_msg",
[
("08515111111", "phone_number Phone number is not possible"),
("07515111*11", "phone_number Not enough digits"),
(
"notaphoneumber",
"phone_number The string supplied did not seem to be a phone number.",
),
(7700900001, "phone_number 7700900001 is not of type string"),
(None, "phone_number None is not of type string"),
([], "phone_number [] is not of type string"),
({}, "phone_number {} is not of type string"),
],
)
def test_post_sms_request_schema_invalid_phone_number(invalid_phone_number, err_msg):
j = {"phone_number": invalid_phone_number,
"template_id": str(uuid.uuid4())
}
j = {"phone_number": invalid_phone_number, "template_id": str(uuid.uuid4())}
with pytest.raises(ValidationError) as e:
validate(j, post_sms_request_schema)
errors = json.loads(str(e.value)).get('errors')
errors = json.loads(str(e.value)).get("errors")
assert len(errors) == 1
assert {"error": "ValidationError", "message": err_msg} == errors[0]
def test_post_sms_request_schema_invalid_phone_number_and_missing_template():
j = {"phone_number": '5558675309',
}
j = {
"phone_number": "5558675309",
}
with pytest.raises(ValidationError) as e:
validate(j, post_sms_request_schema)
errors = json.loads(str(e.value)).get('errors')
errors = json.loads(str(e.value)).get("errors")
assert len(errors) == 2
assert {"error": "ValidationError", "message": "phone_number Phone number range is not in use"} in errors
assert {"error": "ValidationError", "message": "template_id is a required property"} in errors
assert {
"error": "ValidationError",
"message": "phone_number Phone number range is not in use",
} in errors
assert {
"error": "ValidationError",
"message": "template_id is a required property",
} in errors
valid_post_email_json = {"email_address": "test@example.gov.uk",
"template_id": str(uuid.uuid4())
}
valid_post_email_json = {
"email_address": "test@example.gov.uk",
"template_id": str(uuid.uuid4()),
}
valid_post_email_json_with_optionals = {
"email_address": "test@example.gov.uk",
"template_id": str(uuid.uuid4()),
"reference": "reference from caller",
"personalisation": {"key": "value"}
"personalisation": {"key": "value"},
}
@pytest.mark.parametrize("input", [valid_post_email_json, valid_post_email_json_with_optionals])
@pytest.mark.parametrize(
"input", [valid_post_email_json, valid_post_email_json_with_optionals]
)
def test_post_email_schema_is_valid(input):
assert validate(input, post_email_request_schema) == input
@@ -226,20 +270,23 @@ def test_post_email_schema_bad_uuid_and_missing_email_address():
validate(j, post_email_request_schema)
@pytest.mark.parametrize('email_address, err_msg', [
('example', 'email_address Not a valid email address'),
(12345, 'email_address 12345 is not of type string'),
('with(brackets)@example.com', 'email_address Not a valid email address'),
(None, 'email_address None is not of type string'),
([], 'email_address [] is not of type string'),
({}, 'email_address {} is not of type string'),
])
@pytest.mark.parametrize(
"email_address, err_msg",
[
("example", "email_address Not a valid email address"),
(12345, "email_address 12345 is not of type string"),
("with(brackets)@example.com", "email_address Not a valid email address"),
(None, "email_address None is not of type string"),
([], "email_address [] is not of type string"),
({}, "email_address {} is not of type string"),
],
)
def test_post_email_schema_invalid_email_address(email_address, err_msg):
j = {"template_id": str(uuid.uuid4()), "email_address": email_address}
with pytest.raises(ValidationError) as e:
validate(j, post_email_request_schema)
errors = json.loads(str(e.value)).get('errors')
errors = json.loads(str(e.value)).get("errors")
assert len(errors) == 1
assert {"error": "ValidationError", "message": err_msg} == errors[0]
@@ -247,25 +294,25 @@ def test_post_email_schema_invalid_email_address(email_address, err_msg):
def valid_email_response():
return {
"id": str(uuid.uuid4()),
"content": {"body": "the body of the message",
"subject": "subject of the message",
"from_email": "service@dig.gov.uk"},
"content": {
"body": "the body of the message",
"subject": "subject of the message",
"from_email": "service@dig.gov.uk",
},
"uri": "http://notify.api/v2/notifications/id",
"template": {
"id": str(uuid.uuid4()),
"version": 1,
"uri": "http://notify.api/v2/template/id"
"uri": "http://notify.api/v2/template/id",
},
"scheduled_for": ""
"scheduled_for": "",
}
@pytest.mark.parametrize("schema",
[post_email_request_schema, post_sms_request_schema])
@pytest.mark.parametrize("schema", [post_email_request_schema, post_sms_request_schema])
@freeze_time("2017-05-12 13:00:00")
def test_post_schema_valid_scheduled_for(schema):
j = {"template_id": str(uuid.uuid4()),
"scheduled_for": "2017-05-12 13:15"}
j = {"template_id": str(uuid.uuid4()), "scheduled_for": "2017-05-12 13:15"}
if schema == post_email_request_schema:
j.update({"email_address": "joe@gmail.com"})
else:
@@ -273,16 +320,13 @@ def test_post_schema_valid_scheduled_for(schema):
assert validate(j, schema) == j
@pytest.mark.parametrize("invalid_datetime",
["13:00:00 2017-01-01",
"2017-31-12 13:00:00",
"01-01-2017T14:00:00.0000Z"
])
@pytest.mark.parametrize("schema",
[post_email_request_schema, post_sms_request_schema])
@pytest.mark.parametrize(
"invalid_datetime",
["13:00:00 2017-01-01", "2017-31-12 13:00:00", "01-01-2017T14:00:00.0000Z"],
)
@pytest.mark.parametrize("schema", [post_email_request_schema, post_sms_request_schema])
def test_post_email_schema_invalid_scheduled_for(invalid_datetime, schema):
j = {"template_id": str(uuid.uuid4()),
"scheduled_for": invalid_datetime}
j = {"template_id": str(uuid.uuid4()), "scheduled_for": invalid_datetime}
if schema == post_email_request_schema:
j.update({"email_address": "joe@gmail.com"})
else:
@@ -290,34 +334,50 @@ def test_post_email_schema_invalid_scheduled_for(invalid_datetime, schema):
with pytest.raises(ValidationError) as e:
validate(j, schema)
error = json.loads(str(e.value))
assert error['status_code'] == 400
assert error['errors'] == [{'error': 'ValidationError',
'message': "scheduled_for datetime format is invalid. "
"It must be a valid ISO8601 date time format, "
"https://en.wikipedia.org/wiki/ISO_8601"}]
assert error["status_code"] == 400
assert error["errors"] == [
{
"error": "ValidationError",
"message": "scheduled_for datetime format is invalid. "
"It must be a valid ISO8601 date time format, "
"https://en.wikipedia.org/wiki/ISO_8601",
}
]
@freeze_time("2017-05-12 13:00:00")
def test_scheduled_for_raises_validation_error_when_in_the_past():
j = {"phone_number": "2028675309",
"template_id": str(uuid.uuid4()),
"scheduled_for": "2017-05-12 10:00"}
j = {
"phone_number": "2028675309",
"template_id": str(uuid.uuid4()),
"scheduled_for": "2017-05-12 10:00",
}
with pytest.raises(ValidationError) as e:
validate(j, post_sms_request_schema)
error = json.loads(str(e.value))
assert error['status_code'] == 400
assert error['errors'] == [{'error': 'ValidationError',
'message': "scheduled_for datetime can not be in the past"}]
assert error["status_code"] == 400
assert error["errors"] == [
{
"error": "ValidationError",
"message": "scheduled_for datetime can not be in the past",
}
]
@freeze_time("2017-05-12 13:00:00")
def test_scheduled_for_raises_validation_error_when_more_than_24_hours_in_the_future():
j = {"phone_number": "2028675309",
"template_id": str(uuid.uuid4()),
"scheduled_for": "2017-05-13 14:00"}
j = {
"phone_number": "2028675309",
"template_id": str(uuid.uuid4()),
"scheduled_for": "2017-05-13 14:00",
}
with pytest.raises(ValidationError) as e:
validate(j, post_sms_request_schema)
error = json.loads(str(e.value))
assert error['status_code'] == 400
assert error['errors'] == [{'error': 'ValidationError',
'message': "scheduled_for datetime can only be 24 hours in the future"}]
assert error["status_code"] == 400
assert error["errors"] == [
{
"error": "ValidationError",
"message": "scheduled_for datetime can only be 24 hours in the future",
}
]

1274
tests/app/v2/notifications/test_post_notifications.py
View File

File diff suppressed because it is too large Load Diff

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

80
tests/app/v2/templates/test_get_templates.py
View File

@@ -13,30 +13,32 @@ def test_get_all_templates_returns_200(client, sample_service):
create_template(
sample_service,
template_type=tmp_type,
subject='subject_{}'.format(name) if tmp_type == EMAIL_TYPE else '',
subject="subject_{}".format(name) if tmp_type == EMAIL_TYPE else "",
template_name=name,
)
for name, tmp_type in product(('A', 'B', 'C'), TEMPLATE_TYPES)
for name, tmp_type in product(("A", "B", "C"), TEMPLATE_TYPES)
]
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(path='/v2/templates',
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/templates",
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))
assert len(json_response['templates']) == len(templates)
assert len(json_response["templates"]) == len(templates)
for index, template in enumerate(json_response['templates']):
assert template['id'] == str(templates[index].id)
assert template['body'] == templates[index].content
assert template['type'] == templates[index].template_type
for index, template in enumerate(json_response["templates"]):
assert template["id"] == str(templates[index].id)
assert template["body"] == templates[index].content
assert template["type"] == templates[index].template_type
if templates[index].template_type == EMAIL_TYPE:
assert template['subject'] == templates[index].subject
assert template["subject"] == templates[index].subject
@pytest.mark.parametrize("tmp_type", TEMPLATE_TYPES)
@@ -45,34 +47,38 @@ def test_get_all_templates_for_valid_type_returns_200(client, sample_service, tm
create_template(
sample_service,
template_type=tmp_type,
template_name='Template {}'.format(i),
subject='subject_{}'.format(i) if tmp_type == EMAIL_TYPE else ''
template_name="Template {}".format(i),
subject="subject_{}".format(i) if tmp_type == EMAIL_TYPE else "",
)
for i in range(3)
]
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(path='/v2/templates?type={}'.format(tmp_type),
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/templates?type={}".format(tmp_type),
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))
assert len(json_response['templates']) == len(templates)
assert len(json_response["templates"]) == len(templates)
for index, template in enumerate(json_response['templates']):
assert template['id'] == str(templates[index].id)
assert template['body'] == templates[index].content
assert template['type'] == tmp_type
for index, template in enumerate(json_response["templates"]):
assert template["id"] == str(templates[index].id)
assert template["body"] == templates[index].content
assert template["type"] == tmp_type
if templates[index].template_type == EMAIL_TYPE:
assert template['subject'] == templates[index].subject
assert template["subject"] == templates[index].subject
@pytest.mark.parametrize("tmp_type", TEMPLATE_TYPES)
def test_get_correct_num_templates_for_valid_type_returns_200(client, sample_service, tmp_type):
def test_get_correct_num_templates_for_valid_type_returns_200(
client, sample_service, tmp_type
):
num_templates = 3
templates = []
@@ -85,35 +91,39 @@ def test_get_correct_num_templates_for_valid_type_returns_200(client, sample_ser
auth_header = create_service_authorization_header(service_id=sample_service.id)
response = client.get(path='/v2/templates?type={}'.format(tmp_type),
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/templates?type={}".format(tmp_type),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 200
json_response = json.loads(response.get_data(as_text=True))
assert len(json_response['templates']) == num_templates
assert len(json_response["templates"]) == num_templates
def test_get_all_templates_for_invalid_type_returns_400(client, sample_service):
auth_header = create_service_authorization_header(service_id=sample_service.id)
invalid_type = 'coconut'
invalid_type = "coconut"
response = client.get(path='/v2/templates?type={}'.format(invalid_type),
headers=[('Content-Type', 'application/json'), auth_header])
response = client.get(
path="/v2/templates?type={}".format(invalid_type),
headers=[("Content-Type", "application/json"), auth_header],
)
assert response.status_code == 400
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 == {
'status_code': 400,
'errors': [
"status_code": 400,
"errors": [
{
'message': 'type coconut is not one of [sms, email]',
'error': 'ValidationError'
"message": "type coconut is not one of [sms, email]",
"error": "ValidationError",
}
]
],
}

431
tests/app/v2/templates/test_templates_schemas.py
View File

@@ -15,207 +15,244 @@ valid_json_get_all_response = [
{
"templates": [
{
'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",
},
{
'id': str(uuid.uuid4()),
'type': EMAIL_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 2,
'created_by': 'someone@test.com',
'subject': 'test subject',
'body': 'some body',
'name': 'some name',
}
"id": str(uuid.uuid4()),
"type": EMAIL_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 2,
"created_by": "someone@test.com",
"subject": "test subject",
"body": "some body",
"name": "some name",
},
]
},
{
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 2,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 2,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
{
"templates": []
}
{"templates": []},
]
invalid_json_get_all_response = [
({
"templates": [
{
'id': 'invalid_id',
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates is not a valid UUID']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 'invalid_version',
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates invalid_version is not of type integer']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': 'invalid_created_at',
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates invalid_created_at is not a date-time']),
({}, ['templates is a required property']),
({
"templates": [
{
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates id is a required property']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
}
]
}, ['templates name is a required property']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates type is a required property']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates created_at is a required property']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'version': 1,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates updated_at is a required property']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates version is a required property']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'body': 'some body',
'name': 'some name',
}
]
}, ['templates created_by is a required property']),
({
"templates": [
{
'id': str(uuid.uuid4()),
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'version': 1,
'created_by': 'someone@test.com',
'name': 'some name',
}
]
}, ['templates body is a required property']),
({
"templates": [
{
'type': SMS_TYPE,
'created_at': '2017-02-10T18:25:43.511Z',
'updated_at': None,
'created_by': 'someone@test.com',
'body': 'some body',
'name': 'some name',
}
]
}, ['templates id is a required property', 'templates version is a required property']),
(
{
"templates": [
{
"id": "invalid_id",
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates is not a valid UUID"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": "invalid_version",
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates invalid_version is not of type integer"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "invalid_created_at",
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates invalid_created_at is not a date-time"],
),
({}, ["templates is a required property"]),
(
{
"templates": [
{
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates id is a required property"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
}
]
},
["templates name is a required property"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates type is a required property"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates created_at is a required property"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"version": 1,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates updated_at is a required property"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
["templates version is a required property"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"body": "some body",
"name": "some name",
}
]
},
["templates created_by is a required property"],
),
(
{
"templates": [
{
"id": str(uuid.uuid4()),
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"version": 1,
"created_by": "someone@test.com",
"name": "some name",
}
]
},
["templates body is a required property"],
),
(
{
"templates": [
{
"type": SMS_TYPE,
"created_at": "2017-02-10T18:25:43.511Z",
"updated_at": None,
"created_by": "someone@test.com",
"body": "some body",
"name": "some name",
}
]
},
[
"templates id is a required property",
"templates version is a required property",
],
),
]
@@ -227,21 +264,21 @@ def test_get_all_template_request_schema_against_no_args_is_valid(template_type)
@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
def test_get_all_template_request_schema_against_valid_args_is_valid(template_type):
data = {'type': template_type}
data = {"type": template_type}
assert validate(data, get_all_template_request) == data
@pytest.mark.parametrize("template_type", TEMPLATE_TYPES)
def test_get_all_template_request_schema_against_invalid_args_is_invalid(template_type):
data = {'type': 'unknown'}
data = {"type": "unknown"}
with pytest.raises(ValidationError) as e:
validate(data, get_all_template_request)
errors = json.loads(str(e.value))
assert errors['status_code'] == 400
assert len(errors['errors']) == 1
assert errors['errors'][0]['message'] == 'type unknown is not one of [sms, email]'
assert errors["status_code"] == 400
assert len(errors["errors"]) == 1
assert errors["errors"][0]["message"] == "type unknown is not one of [sms, email]"
@pytest.mark.parametrize("response", valid_json_get_all_response)
@@ -255,7 +292,7 @@ def test_invalid_get_all_templates_response_schema_is_invalid(response, error_me
validate(response, get_all_template_response)
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

78
tests/app/v2/test_errors.py
View File

@@ -5,7 +5,7 @@ from sqlalchemy.exc import DataError
from app.v2.errors import ValidationError
@pytest.fixture(scope='function')
@pytest.fixture(scope="function")
def app_for_test():
import flask
from flask import Blueprint
@@ -15,11 +15,12 @@ def app_for_test():
from app.v2.errors import BadRequestError, TooManyRequestsError
app = flask.Flask(__name__)
app.config['TESTING'] = True
app.config["TESTING"] = True
init_app(app)
from app.v2.errors import register_errors
blue = Blueprint("v2_under_test", __name__, url_prefix='/v2/under_test')
blue = Blueprint("v2_under_test", __name__, url_prefix="/v2/under_test")
@blue.route("/raise_auth_error", methods=["GET"])
def raising_auth_error():
@@ -37,6 +38,7 @@ def app_for_test():
def raising_validation_error():
from app.schema_validation import validate
from app.v2.notifications.notification_schemas import post_sms_request
validate({"template_id": "bad_uuid"}, post_sms_request)
@blue.route("raise_data_error", methods=["GET"])
@@ -56,49 +58,63 @@ def app_for_test():
def test_auth_error(app_for_test):
with app_for_test.test_request_context():
with app_for_test.test_client() as client:
response = client.get(url_for('v2_under_test.raising_auth_error'))
response = client.get(url_for("v2_under_test.raising_auth_error"))
assert response.status_code == 403
error = response.json
assert error == {"status_code": 403,
"errors": [{"error": "AuthError",
"message": "some message"}]}
assert error == {
"status_code": 403,
"errors": [{"error": "AuthError", "message": "some message"}],
}
def test_bad_request_error(app_for_test):
with app_for_test.test_request_context():
with app_for_test.test_client() as client:
response = client.get(url_for('v2_under_test.raising_bad_request'))
response = client.get(url_for("v2_under_test.raising_bad_request"))
assert response.status_code == 400
error = response.json
assert error == {"status_code": 400,
"errors": [{"error": "BadRequestError",
"message": "you forgot the thing"}]}
assert error == {
"status_code": 400,
"errors": [
{"error": "BadRequestError", "message": "you forgot the thing"}
],
}
def test_too_many_requests_error(app_for_test):
with app_for_test.test_request_context():
with app_for_test.test_client() as client:
response = client.get(url_for('v2_under_test.raising_too_many_requests'))
response = client.get(url_for("v2_under_test.raising_too_many_requests"))
assert response.status_code == 429
error = response.json
assert error == {"status_code": 429,
"errors": [{"error": "TooManyRequestsError",
"message": "Exceeded send limits (452) for today"}]}
assert error == {
"status_code": 429,
"errors": [
{
"error": "TooManyRequestsError",
"message": "Exceeded send limits (452) for today",
}
],
}
def test_validation_error(app_for_test):
with app_for_test.test_request_context():
with app_for_test.test_client() as client:
response = client.get(url_for('v2_under_test.raising_validation_error'))
response = client.get(url_for("v2_under_test.raising_validation_error"))
assert response.status_code == 400
error = response.json
assert len(error.keys()) == 2
assert error['status_code'] == 400
assert len(error['errors']) == 2
assert {'error': 'ValidationError',
'message': "phone_number is a required property"} in error['errors']
assert {'error': 'ValidationError',
'message': "template_id is not a valid UUID"} in error['errors']
assert error["status_code"] == 400
assert len(error["errors"]) == 2
assert {
"error": "ValidationError",
"message": "phone_number is a required property",
} in error["errors"]
assert {
"error": "ValidationError",
"message": "template_id is not a valid UUID",
} in error["errors"]
ve = ValidationError("phone_number is a required property")
assert ve.message == "Your notification has failed validation"
assert ve.status_code == 400
@@ -107,11 +123,13 @@ def test_validation_error(app_for_test):
def test_data_errors(app_for_test):
with app_for_test.test_request_context():
with app_for_test.test_client() as client:
response = client.get(url_for('v2_under_test.raising_data_error'))
response = client.get(url_for("v2_under_test.raising_data_error"))
assert response.status_code == 404
error = response.json
assert error == {"status_code": 404,
"errors": [{"error": "DataError", "message": "No result found"}]}
assert error == {
"status_code": 404,
"errors": [{"error": "DataError", "message": "No result found"}],
}
def test_internal_server_error_handler(app_for_test):
@@ -120,8 +138,12 @@ def test_internal_server_error_handler(app_for_test):
response = client.get(url_for("v2_under_test.raising_exception"))
assert response.status_code == 500
error = response.json
assert error == {"status_code": 500,
"errors": [{"error": "AssertionError", "message": "Internal server error"}]}
assert error == {
"status_code": 500,
"errors": [
{"error": "AssertionError", "message": "Internal server error"}
],
}
def test_bad_method(app_for_test):
@@ -133,5 +155,5 @@ def test_bad_method(app_for_test):
assert response.get_json(force=True) == {
"result": "error",
"message": "The method is not allowed for the requested URL."
"message": "The method is not allowed for the requested URL.",
}