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

reformat

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

384
tests/app/celery/test_process_ses_receipts_tasks.py
View File

@@ -28,9 +28,9 @@ from tests.app.db import (
def test_notifications_ses_400_with_invalid_header(client):
data = json.dumps({"foo": "bar"})
response = client.post(
path='/notifications/email/ses',
path="/notifications/email/ses",
data=data,
headers=[('Content-Type', 'application/json')]
headers=[("Content-Type", "application/json")],
)
assert response.status_code == 400
@@ -38,44 +38,68 @@ def test_notifications_ses_400_with_invalid_header(client):
def test_notifications_ses_400_with_invalid_message_type(client):
data = json.dumps({"foo": "bar"})
response = client.post(
path='/notifications/email/ses',
path="/notifications/email/ses",
data=data,
headers=[('Content-Type', 'application/json'), ('x-amz-sns-message-type', 'foo')]
headers=[
("Content-Type", "application/json"),
("x-amz-sns-message-type", "foo"),
],
)
assert response.status_code == 400
assert "SES-SNS callback failed: invalid message type" in response.get_data(as_text=True)
assert "SES-SNS callback failed: invalid message type" in response.get_data(
as_text=True
)
def test_notifications_ses_400_with_invalid_json(client):
data = "FOOO"
response = client.post(
path='/notifications/email/ses',
path="/notifications/email/ses",
data=data,
headers=[('Content-Type', 'application/json'), ('x-amz-sns-message-type', 'Notification')]
headers=[
("Content-Type", "application/json"),
("x-amz-sns-message-type", "Notification"),
],
)
assert response.status_code == 400
assert "SES-SNS callback failed: invalid JSON given" in response.get_data(as_text=True)
assert "SES-SNS callback failed: invalid JSON given" in response.get_data(
as_text=True
)
def test_notifications_ses_400_with_certificate(client):
data = json.dumps({"foo": "bar"})
response = client.post(
path='/notifications/email/ses',
path="/notifications/email/ses",
data=data,
headers=[('Content-Type', 'application/json'), ('x-amz-sns-message-type', 'Notification')]
headers=[
("Content-Type", "application/json"),
("x-amz-sns-message-type", "Notification"),
],
)
assert response.status_code == 400
assert "SES-SNS callback failed: validation failed" in response.get_data(as_text=True)
assert "SES-SNS callback failed: validation failed" in response.get_data(
as_text=True
)
def test_notifications_ses_200_autoconfirms_subscription(client, mocker):
mocker.patch("app.notifications.sns_handlers.validate_sns_cert", return_value=True)
requests_mock = mocker.patch("requests.get")
data = json.dumps({"Type": "SubscriptionConfirmation", "SubscribeURL": "https://foo", "Message": "foo"})
data = json.dumps(
{
"Type": "SubscriptionConfirmation",
"SubscribeURL": "https://foo",
"Message": "foo",
}
)
response = client.post(
path='/notifications/email/ses',
path="/notifications/email/ses",
data=data,
headers=[('Content-Type', 'application/json'), ('x-amz-sns-message-type', 'SubscriptionConfirmation')]
headers=[
("Content-Type", "application/json"),
("x-amz-sns-message-type", "SubscriptionConfirmation"),
],
)
requests_mock.assert_called_once_with("https://foo")
@@ -83,38 +107,64 @@ def test_notifications_ses_200_autoconfirms_subscription(client, mocker):
def test_notifications_ses_200_call_process_task(client, mocker):
process_mock = mocker.patch("app.notifications.notifications_ses_callback.process_ses_results.apply_async")
process_mock = mocker.patch(
"app.notifications.notifications_ses_callback.process_ses_results.apply_async"
)
mocker.patch("app.notifications.sns_handlers.validate_sns_cert", return_value=True)
data = {"Type": "Notification", "foo": "bar", "Message": {"mail": "baz"}}
mocker.patch("app.notifications.sns_handlers.sns_notification_handler", return_value=data)
mocker.patch(
"app.notifications.sns_handlers.sns_notification_handler", return_value=data
)
json_data = json.dumps(data)
response = client.post(
path='/notifications/email/ses',
path="/notifications/email/ses",
data=json_data,
headers=[('Content-Type', 'application/json'), ('x-amz-sns-message-type', 'Notification')]
headers=[
("Content-Type", "application/json"),
("x-amz-sns-message-type", "Notification"),
],
)
process_mock.assert_called_once_with([{'Message': {"mail": "baz"}}], queue='notify-internal-tasks')
process_mock.assert_called_once_with(
[{"Message": {"mail": "baz"}}], queue="notify-internal-tasks"
)
assert response.status_code == 200
def test_process_ses_results(sample_email_template):
create_notification(sample_email_template, reference='ref1', sent_at=datetime.utcnow(), status='sending')
create_notification(
sample_email_template,
reference="ref1",
sent_at=datetime.utcnow(),
status="sending",
)
assert process_ses_results(response=ses_notification_callback(reference='ref1'))
assert process_ses_results(response=ses_notification_callback(reference="ref1"))
def test_process_ses_results_retry_called(sample_email_template, mocker):
create_notification(sample_email_template, reference='ref1', sent_at=datetime.utcnow(), status='sending')
mocker.patch("app.dao.notifications_dao._update_notification_status", side_effect=Exception("EXPECTED"))
mocked = mocker.patch('app.celery.process_ses_receipts_tasks.process_ses_results.retry')
process_ses_results(response=ses_notification_callback(reference='ref1'))
create_notification(
sample_email_template,
reference="ref1",
sent_at=datetime.utcnow(),
status="sending",
)
mocker.patch(
"app.dao.notifications_dao._update_notification_status",
side_effect=Exception("EXPECTED"),
)
mocked = mocker.patch(
"app.celery.process_ses_receipts_tasks.process_ses_results.retry"
)
process_ses_results(response=ses_notification_callback(reference="ref1"))
assert mocked.call_count != 0
def test_process_ses_results_in_complaint(sample_email_template, mocker):
notification = create_notification(template=sample_email_template, reference='ref1')
mocked = mocker.patch("app.dao.notifications_dao.update_notification_status_by_reference")
notification = create_notification(template=sample_email_template, reference="ref1")
mocked = mocker.patch(
"app.dao.notifications_dao.update_notification_status_by_reference"
)
process_ses_results(response=ses_complaint_callback())
assert mocked.call_count == 0
complaints = Complaint.query.all()
@@ -123,212 +173,236 @@ def test_process_ses_results_in_complaint(sample_email_template, mocker):
def test_remove_emails_from_complaint():
test_json = json.loads(ses_complaint_callback()['Message'])
test_json = json.loads(ses_complaint_callback()["Message"])
remove_emails_from_complaint(test_json)
assert "recipient1@example.com" not in json.dumps(test_json)
def test_remove_email_from_bounce():
test_json = json.loads(ses_hard_bounce_callback(reference='ref1')['Message'])
test_json = json.loads(ses_hard_bounce_callback(reference="ref1")["Message"])
remove_emails_from_bounce(test_json)
assert "bounce@simulator.amazonses.com" not in json.dumps(test_json)
def test_ses_callback_should_update_notification_status(
client,
_notify_db,
notify_db_session,
sample_email_template,
mocker):
with freeze_time('2001-01-01T12:00:00'):
client, _notify_db, notify_db_session, sample_email_template, mocker
):
with freeze_time("2001-01-01T12:00:00"):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
"app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async"
)
notification = create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference='ref',
status='sending',
sent_at=datetime.utcnow()
reference="ref",
status="sending",
sent_at=datetime.utcnow(),
)
create_service_callback_api(
service=sample_email_template.service,
url="https://original_url.com"
service=sample_email_template.service, url="https://original_url.com"
)
assert get_notification_by_id(notification.id).status == "sending"
assert process_ses_results(ses_notification_callback(reference="ref"))
assert get_notification_by_id(notification.id).status == "delivered"
send_mock.assert_called_once_with(
[str(notification.id), ANY], queue="service-callbacks"
)
assert get_notification_by_id(notification.id).status == 'sending'
assert process_ses_results(ses_notification_callback(reference='ref'))
assert get_notification_by_id(notification.id).status == 'delivered'
send_mock.assert_called_once_with([str(notification.id), ANY], queue="service-callbacks")
# assert second arg is an encrypted string
assert isinstance(send_mock.call_args.args[0][1], str)
def test_ses_callback_should_not_update_notification_status_if_already_delivered(sample_email_template, mocker):
mock_dup = mocker.patch('app.celery.process_ses_receipts_tasks.notifications_dao._duplicate_update_warning')
mock_upd = mocker.patch('app.celery.process_ses_receipts_tasks.notifications_dao._update_notification_status')
notification = create_notification(template=sample_email_template, reference='ref', status='delivered')
assert process_ses_results(ses_notification_callback(reference='ref')) is None
assert get_notification_by_id(notification.id).status == 'delivered'
mock_dup.assert_called_once_with(notification, 'delivered')
def test_ses_callback_should_not_update_notification_status_if_already_delivered(
sample_email_template, mocker
):
mock_dup = mocker.patch(
"app.celery.process_ses_receipts_tasks.notifications_dao._duplicate_update_warning"
)
mock_upd = mocker.patch(
"app.celery.process_ses_receipts_tasks.notifications_dao._update_notification_status"
)
notification = create_notification(
template=sample_email_template, reference="ref", status="delivered"
)
assert process_ses_results(ses_notification_callback(reference="ref")) is None
assert get_notification_by_id(notification.id).status == "delivered"
mock_dup.assert_called_once_with(notification, "delivered")
assert mock_upd.call_count == 0
def test_ses_callback_should_retry_if_notification_is_new(mocker):
mock_retry = mocker.patch('app.celery.process_ses_receipts_tasks.process_ses_results.retry')
mock_logger = mocker.patch('app.celery.process_ses_receipts_tasks.current_app.logger.error')
with freeze_time('2017-11-17T12:14:03.646Z'):
assert process_ses_results(ses_notification_callback(reference='ref')) is None
mock_retry = mocker.patch(
"app.celery.process_ses_receipts_tasks.process_ses_results.retry"
)
mock_logger = mocker.patch(
"app.celery.process_ses_receipts_tasks.current_app.logger.error"
)
with freeze_time("2017-11-17T12:14:03.646Z"):
assert process_ses_results(ses_notification_callback(reference="ref")) is None
assert mock_logger.call_count == 0
assert mock_retry.call_count == 1
def test_ses_callback_should_log_if_notification_is_missing(client, _notify_db, mocker):
mock_retry = mocker.patch('app.celery.process_ses_receipts_tasks.process_ses_results.retry')
mock_logger = mocker.patch('app.celery.process_ses_receipts_tasks.current_app.logger.warning')
with freeze_time('2017-11-17T12:34:03.646Z'):
assert process_ses_results(ses_notification_callback(reference='ref')) is None
mock_retry = mocker.patch(
"app.celery.process_ses_receipts_tasks.process_ses_results.retry"
)
mock_logger = mocker.patch(
"app.celery.process_ses_receipts_tasks.current_app.logger.warning"
)
with freeze_time("2017-11-17T12:34:03.646Z"):
assert process_ses_results(ses_notification_callback(reference="ref")) is None
assert mock_retry.call_count == 0
mock_logger.assert_called_once_with(
'Notification not found for reference: ref (while attempting update to delivered)'
"Notification not found for reference: ref (while attempting update to delivered)"
)
def test_ses_callback_should_not_retry_if_notification_is_old(mocker):
mock_retry = mocker.patch('app.celery.process_ses_receipts_tasks.process_ses_results.retry')
mock_logger = mocker.patch('app.celery.process_ses_receipts_tasks.current_app.logger.error')
with freeze_time('2017-11-21T12:14:03.646Z'):
assert process_ses_results(ses_notification_callback(reference='ref')) is None
mock_retry = mocker.patch(
"app.celery.process_ses_receipts_tasks.process_ses_results.retry"
)
mock_logger = mocker.patch(
"app.celery.process_ses_receipts_tasks.current_app.logger.error"
)
with freeze_time("2017-11-21T12:14:03.646Z"):
assert process_ses_results(ses_notification_callback(reference="ref")) is None
assert mock_logger.call_count == 0
assert mock_retry.call_count == 0
def test_ses_callback_does_not_call_send_delivery_status_if_no_db_entry(
client,
_notify_db,
notify_db_session,
sample_email_template,
mocker):
with freeze_time('2001-01-01T12:00:00'):
client, _notify_db, notify_db_session, sample_email_template, mocker
):
with freeze_time("2001-01-01T12:00:00"):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
"app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async"
)
notification = create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference='ref',
status='sending',
sent_at=datetime.utcnow()
reference="ref",
status="sending",
sent_at=datetime.utcnow(),
)
assert get_notification_by_id(notification.id).status == 'sending'
assert process_ses_results(ses_notification_callback(reference='ref'))
assert get_notification_by_id(notification.id).status == 'delivered'
assert get_notification_by_id(notification.id).status == "sending"
assert process_ses_results(ses_notification_callback(reference="ref"))
assert get_notification_by_id(notification.id).status == "delivered"
send_mock.assert_not_called()
def test_ses_callback_should_update_multiple_notification_status_sent(
client,
_notify_db,
notify_db_session,
sample_email_template,
mocker):
client, _notify_db, notify_db_session, sample_email_template, mocker
):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
"app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async"
)
create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference='ref1',
reference="ref1",
sent_at=datetime.utcnow(),
status='sending')
status="sending",
)
create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference='ref2',
reference="ref2",
sent_at=datetime.utcnow(),
status='sending')
status="sending",
)
create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference='ref3',
reference="ref3",
sent_at=datetime.utcnow(),
status='sending')
create_service_callback_api(service=sample_email_template.service, url="https://original_url.com")
assert process_ses_results(ses_notification_callback(reference='ref1'))
assert process_ses_results(ses_notification_callback(reference='ref2'))
assert process_ses_results(ses_notification_callback(reference='ref3'))
assert send_mock.called
def test_ses_callback_should_set_status_to_temporary_failure(client,
_notify_db,
notify_db_session,
sample_email_template,
mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
notification = create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference='ref',
status='sending',
sent_at=datetime.utcnow()
)
create_service_callback_api(service=notification.service, url="https://original_url.com")
assert get_notification_by_id(notification.id).status == 'sending'
assert process_ses_results(ses_soft_bounce_callback(reference='ref'))
assert get_notification_by_id(notification.id).status == 'temporary-failure'
assert send_mock.called
def test_ses_callback_should_set_status_to_permanent_failure(client,
_notify_db,
notify_db_session,
sample_email_template,
mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
notification = create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference='ref',
status='sending',
sent_at=datetime.utcnow()
)
create_service_callback_api(service=sample_email_template.service, url="https://original_url.com")
assert get_notification_by_id(notification.id).status == 'sending'
assert process_ses_results(ses_hard_bounce_callback(reference='ref'))
assert get_notification_by_id(notification.id).status == 'permanent-failure'
assert send_mock.called
def test_ses_callback_should_send_on_complaint_to_user_callback_api(sample_email_template, mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_complaint_to_service.apply_async'
status="sending",
)
create_service_callback_api(
service=sample_email_template.service, url="https://original_url.com", callback_type="complaint"
service=sample_email_template.service, url="https://original_url.com"
)
assert process_ses_results(ses_notification_callback(reference="ref1"))
assert process_ses_results(ses_notification_callback(reference="ref2"))
assert process_ses_results(ses_notification_callback(reference="ref3"))
assert send_mock.called
def test_ses_callback_should_set_status_to_temporary_failure(
client, _notify_db, notify_db_session, sample_email_template, mocker
):
send_mock = mocker.patch(
"app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async"
)
notification = create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference="ref",
status="sending",
sent_at=datetime.utcnow(),
)
create_service_callback_api(
service=notification.service, url="https://original_url.com"
)
assert get_notification_by_id(notification.id).status == "sending"
assert process_ses_results(ses_soft_bounce_callback(reference="ref"))
assert get_notification_by_id(notification.id).status == "temporary-failure"
assert send_mock.called
def test_ses_callback_should_set_status_to_permanent_failure(
client, _notify_db, notify_db_session, sample_email_template, mocker
):
send_mock = mocker.patch(
"app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async"
)
notification = create_sample_notification(
_notify_db,
notify_db_session,
template=sample_email_template,
reference="ref",
status="sending",
sent_at=datetime.utcnow(),
)
create_service_callback_api(
service=sample_email_template.service, url="https://original_url.com"
)
assert get_notification_by_id(notification.id).status == "sending"
assert process_ses_results(ses_hard_bounce_callback(reference="ref"))
assert get_notification_by_id(notification.id).status == "permanent-failure"
assert send_mock.called
def test_ses_callback_should_send_on_complaint_to_user_callback_api(
sample_email_template, mocker
):
send_mock = mocker.patch(
"app.celery.service_callback_tasks.send_complaint_to_service.apply_async"
)
create_service_callback_api(
service=sample_email_template.service,
url="https://original_url.com",
callback_type="complaint",
)
notification = create_notification(
template=sample_email_template, reference='ref1', sent_at=datetime.utcnow(), status='sending'
template=sample_email_template,
reference="ref1",
sent_at=datetime.utcnow(),
status="sending",
)
response = ses_complaint_callback()
assert process_ses_results(response)
assert send_mock.call_count == 1
assert encryption.decrypt(send_mock.call_args[0][0][0]) == {
'complaint_date': '2018-06-05T13:59:58.000000Z',
'complaint_id': str(Complaint.query.one().id),
'notification_id': str(notification.id),
'reference': None,
'service_callback_api_bearer_token': 'some_super_secret',
'service_callback_api_url': 'https://original_url.com',
'to': 'recipient1@example.com'
"complaint_date": "2018-06-05T13:59:58.000000Z",
"complaint_id": str(Complaint.query.one().id),
"notification_id": str(notification.id),
"reference": None,
"service_callback_api_bearer_token": "some_super_secret",
"service_callback_api_url": "https://original_url.com",
"to": "recipient1@example.com",
}