def test_ses_callback_should_set_status_to_permanent_failure(
notify_db,
notify_db_session,
sample_email_template,
mocker,
bounce_subtype,
provider_response,
):
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",
bounce_subtype=bounce_subtype))
notification = get_notification_by_id(notification.id)
assert notification.status == "permanent-failure"
assert notification.provider_response == provider_response
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",
)
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": "*****@*****.**",
}
def test_ses_callback_should_update_multiple_notification_status_sent(
client, notify_db_session, sample_email_template, mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
create_notification(
template=sample_email_template,
status='sending',
reference='ref1',
)
create_notification(
template=sample_email_template,
status='sending',
reference='ref2',
)
create_notification(
template=sample_email_template,
status='sending',
reference='ref3',
)
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_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')
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': '*****@*****.**'
}
def test_update_letter_notifications_statuses_persisted(
notify_api, mocker, sample_letter_template):
sent_letter = create_notification(sample_letter_template,
reference='ref-foo',
status=NOTIFICATION_SENDING,
billable_units=1)
failed_letter = create_notification(sample_letter_template,
reference='ref-bar',
status=NOTIFICATION_SENDING,
billable_units=2)
create_service_callback_api(service=sample_letter_template.service,
url="https://original_url.com")
valid_file = '{}|Sent|1|Unsorted\n{}|Failed|2|Sorted'.format(
sent_letter.reference, failed_letter.reference)
mocker.patch('app.celery.tasks.s3.get_s3_file', return_value=valid_file)
with pytest.raises(expected_exception=DVLAException) as e:
update_letter_notifications_statuses(
filename='NOTIFY-20170823160812-RSP.TXT')
assert sent_letter.status == NOTIFICATION_DELIVERED
assert sent_letter.billable_units == 1
assert sent_letter.updated_at
assert failed_letter.status == NOTIFICATION_TEMPORARY_FAILURE
assert failed_letter.billable_units == 2
assert failed_letter.updated_at
assert "DVLA response file: {filename} has failed letters with notification.reference {failures}".format(
filename="NOTIFY-20170823160812-RSP.TXT",
failures=[format(failed_letter.reference)]) in str(e.value)
def test_no_service_delivery_status_callback_api_by_status(
sample_service, saved_notification_statuses, query_notification_statuses
):
create_service_callback_api(
service=sample_service, notification_statuses=saved_notification_statuses
)
for notification_status in query_notification_statuses:
result = get_service_delivery_status_callback_api_for_service(
sample_service.id,
notification_status=notification_status
)
assert result is None
def test_ses_smtp_callback_should_set_status_to_permanent_failure(
client, notify_db, notify_db_session, sample_email_template,
smtp_template, mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
create_notification(template=sample_email_template, reference='ref1')
create_service_callback_api(service=sample_email_template.service,
url="https://original_url.com")
assert process_ses_smtp_results(
ses_smtp_hard_bounce_callback(reference='ref'))
assert send_mock.called
def test_ses_smtp_callback_should_send_on_complaint_to_user_callback_api(
smtp_template, 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")
create_notification(template=sample_email_template, reference='ref1')
response = ses_smtp_complaint_callback()
assert process_ses_smtp_results(response)
assert send_mock.call_count == 1
def test_outcome_statistics_called_for_successful_callback(
sample_notification, mocker):
mocker.patch(
'app.notifications.process_client_response.notifications_dao.update_notification_status_by_id',
return_value=sample_notification)
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
callback_api = create_service_callback_api(
service=sample_notification.service,
url="https://original_url.com",
notification_statuses=NOTIFICATION_STATUS_TYPES)
reference = str(uuid.uuid4())
success, error = process_sms_client_response(status='3',
provider_reference=reference,
client_name='MMG')
assert success == "MMG callback succeeded. reference {} updated".format(
str(reference))
assert error is None
encrypted_data = create_delivery_status_callback_data(
sample_notification, callback_api)
send_mock.assert_called_once_with(
[str(sample_notification.id), encrypted_data],
queue="service-callbacks")
def test_create_complaint_callback_data(
notify_db,
notify_db_session,
sample_email_template,
):
notification = create_sample_notification(
notify_db,
notify_db_session,
template=sample_email_template,
status="delivered",
sent_at=datetime.utcnow(),
)
complaint = create_complaint(notification=notification,
service=notification.service)
callback_api = create_service_callback_api(
service=sample_email_template.service, url="https://original_url.com")
assert encryption.decrypt(
create_complaint_callback_data(
complaint, notification, callback_api,
"*****@*****.**")) == {
"complaint_id": str(complaint.id),
"notification_id": str(notification.id),
"reference": notification.client_reference,
"to": "*****@*****.**",
"complaint_date":
complaint.complaint_date.strftime(DATETIME_FORMAT),
"service_callback_api_url": callback_api.url,
"service_callback_api_bearer_token": callback_api.bearer_token,
}
def test_process_sns_results_calls_service_callback(sample_template,
notify_db_session,
notify_db, mocker):
with freeze_time('2021-01-01T12:00:00'):
mocker.patch('app.statsd_client.incr')
mocker.patch('app.statsd_client.timing_with_dates')
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_template,
reference='ref',
status=NOTIFICATION_SENT,
sent_by='sns',
sent_at=datetime.utcnow())
callback_api = create_service_callback_api(
service=sample_template.service, url="https://example.com")
assert get_notification_by_id(
notification.id).status == NOTIFICATION_SENT
assert process_sns_results(sns_success_callback(reference='ref'))
assert get_notification_by_id(
notification.id).status == NOTIFICATION_DELIVERED
statsd_client.timing_with_dates.assert_any_call(
"callback.sns.elapsed-time", datetime.utcnow(),
notification.sent_at)
statsd_client.incr.assert_any_call("callback.sns.delivered")
updated_notification = get_notification_by_id(notification.id)
encrypted_data = create_delivery_status_callback_data(
updated_notification, callback_api)
send_mock.assert_called_once_with(
[str(notification.id), encrypted_data], queue="service-callbacks")
def test_ses_callback_should_update_notification_status(
notify_db, notify_db_session, sample_email_template, mocker):
with freeze_time("2001-01-01T12:00:00"):
mocker.patch("app.statsd_client.incr")
mocker.patch("app.statsd_client.timing_with_dates")
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(),
)
callback_api = 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_notification_callback(reference="ref"))
notification = get_notification_by_id(notification.id)
assert notification.status == "delivered"
assert notification.provider_response is None
statsd_client.timing_with_dates.assert_any_call(
"callback.ses.elapsed-time", datetime.utcnow(),
notification.sent_at)
statsd_client.incr.assert_any_call("callback.ses.delivered")
updated_notification = Notification.query.get(notification.id)
encrypted_data = create_delivery_status_callback_data(
updated_notification, callback_api)
send_mock.assert_called_once_with(
[str(notification.id), encrypted_data], queue="service-callbacks")
def test_ses_callback_should_update_notification_status(
client, notify_db_session, sample_email_template, mocker):
with freeze_time('2001-01-01T12:00:00'):
mocker.patch('app.statsd_client.incr')
mocker.patch('app.statsd_client.timing_with_dates')
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
notification = create_notification(
template=sample_email_template,
status='sending',
reference='ref',
)
callback_api = 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_notification_callback(reference='ref'))
assert get_notification_by_id(notification.id).status == 'delivered'
statsd_client.timing_with_dates.assert_any_call(
"callback.ses.elapsed-time", datetime.utcnow(),
notification.sent_at)
statsd_client.incr.assert_any_call("callback.ses.delivered")
updated_notification = Notification.query.get(notification.id)
encrypted_data = create_delivery_status_callback_data(
updated_notification, callback_api)
send_mock.assert_called_once_with(
[str(notification.id), encrypted_data], queue="service-callbacks")
def test_fetch_service_callback_api(client, sample_service):
service_callback_api = create_service_callback_api(service=sample_service)
response = client.get("/service/{}/delivery-receipt-api/{}".format(sample_service.id, service_callback_api.id),
headers=[create_authorization_header()])
assert response.status_code == 200
assert json.loads(response.get_data(as_text=True))["data"] == service_callback_api.serialize()
def test_ses_callback_should_set_status_to_temporary_failure(
client, 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_notification(
template=sample_email_template,
status='sending',
reference='ref',
)
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_delete_service_callback_api(client, sample_service):
service_callback_api = create_service_callback_api(service=sample_service)
response = client.delete(
"/service/{}/delivery-receipt-api/{}".format(sample_service.id, service_callback_api.id),
headers=[create_authorization_header()])
assert response.status_code == 204
def test_update_letter_notifications_to_error_updates_based_on_notification_references(
sample_letter_template, ):
first = create_notification(sample_letter_template, reference="first ref")
second = create_notification(sample_letter_template,
reference="second ref")
create_service_callback_api(service=sample_letter_template.service,
url="https://original_url.com")
dt = datetime.utcnow()
with freeze_time(dt):
with pytest.raises(NotificationTechnicalFailureException) as e:
update_letter_notifications_to_error([first.reference])
assert first.reference in str(e.value)
assert first.status == NOTIFICATION_TECHNICAL_FAILURE
assert first.sent_by is None
assert first.sent_at is None
assert first.updated_at == dt
assert second.status == NOTIFICATION_CREATED
def test_get_service_delivery_status_callback_api_for_service(sample_service):
service_callback_api = create_service_callback_api(service=sample_service)
result = get_service_delivery_status_callback_api_for_service(sample_service.id)
assert result.id == service_callback_api.id
assert result.url == service_callback_api.url
assert result.bearer_token == service_callback_api.bearer_token
assert result.created_at == service_callback_api.created_at
assert result.updated_at == service_callback_api.updated_at
assert result.updated_by_id == service_callback_api.updated_by_id
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",
)
create_service_callback_api(
service=sample_service,
url="https://inbound.example.com",
)
auth_header = create_authorization_header(service_id=sample_service.id)
response = client.get(
path='/v2/received-text-messages',
headers=[('Content-Type', 'application/json'), auth_header],
)
assert response.status_code == 200
def test_process_mmg_response_unknown_status_updates_notification_with_technical_failure(
notify_db, notify_db_session, client, 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, status='sending', sent_at=datetime.utcnow()
)
data = json.dumps({"reference": "mmg_reference",
"CID": str(notification.id),
"MSISDN": "447777349060",
"status": 10})
create_service_callback_api(service=notification.service, url="https://original_url.com")
with pytest.raises(ClientException) as e:
mmg_post(client, data)
assert 'MMG callback failed: status 10 not found.' in str(e.value)
assert get_notification_by_id(notification.id).status == 'technical-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_task(ses_hard_bounce_callback(reference='ref'))
assert get_notification_by_id(
notification.id).status == 'permanent-failure'
assert send_mock.called
def test_fetch_service_callback_api(admin_request, sample_service):
service_callback_api = create_service_callback_api(service=sample_service)
response = admin_request.get(
'service_callback.fetch_service_callback_api',
service_id=sample_service.id,
callback_api_id=service_callback_api.id,
)
assert response["data"] == service_callback_api.serialize()
def _set_up_test_data(notification_type, callback_type):
service = create_service(restricted=True)
template = create_template(service=service, template_type=notification_type, subject="Hello")
callback_api = create_service_callback_api(
service=service,
url="https://some.service.gov.uk/",
bearer_token="something_unique",
callback_type=callback_type,
)
return callback_api, template
def test_delete_service_callback_api(admin_request, sample_service):
service_callback_api = create_service_callback_api(sample_service)
response = admin_request.delete(
'service_callback.remove_service_callback_api',
service_id=sample_service.id,
callback_api_id=service_callback_api.id,
)
assert response is None
assert ServiceCallbackApi.query.count() == 0
def test_update_service_callback_api_updates_bearer_token(client, sample_service):
service_callback_api = create_service_callback_api(service=sample_service,
bearer_token="some_super_secret")
data = {
"bearer_token": "different_token",
"updated_by_id": str(sample_service.users[0].id)
}
response = client.post("/service/{}/delivery-receipt-api/{}".format(sample_service.id, service_callback_api.id),
data=json.dumps(data),
headers=[('Content-Type', 'application/json'), create_authorization_header()])
assert response.status_code == 200
assert service_callback_api.bearer_token == "different_token"
def test_timeout_notifications_sends_status_update_to_service(client, sample_template, mocker):
callback_api = create_service_callback_api(service=sample_template.service)
mocked = mocker.patch('app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async')
notification = create_notification(
template=sample_template,
status='sending',
created_at=datetime.utcnow() - timedelta(
seconds=current_app.config.get('SENDING_NOTIFICATIONS_TIMEOUT_PERIOD') + 10))
timeout_notifications()
encrypted_data = create_delivery_status_callback_data(notification, callback_api)
mocked.assert_called_once_with([str(notification.id), encrypted_data], queue=QueueNames.CALLBACKS)
def test_outcome_statistics_called_for_successful_callback(sample_notification, mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
callback_api = create_service_callback_api(service=sample_notification.service, url="https://original_url.com")
reference = str(sample_notification.id)
process_sms_client_response('3', reference, 'MMG')
encrypted_data = create_delivery_status_callback_data(sample_notification, callback_api)
send_mock.assert_called_once_with([reference, encrypted_data],
queue="service-callbacks")
def test_ses_callback_should_set_status_to_permanent_failure(
client, notify_db_session, sample_email_template, mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
mock_logger = mocker.patch(
'app.celery.process_ses_receipts_tasks.current_app.logger.info')
notification = create_notification(
template=sample_email_template,
status='sending',
reference='ref',
)
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
assert f'SES bounce for notification ID {notification.id}: ' in mock_logger.call_args[
0][0]
def test_update_service_callback_api_updates_bearer_token(
admin_request, sample_service):
service_callback_api = create_service_callback_api(
service=sample_service, bearer_token="some_super_secret")
data = {
"bearer_token": "different_token",
"updated_by_id": str(sample_service.users[0].id)
}
admin_request.post('service_callback.update_service_callback_api',
service_id=sample_service.id,
callback_api_id=service_callback_api.id,
_data=data)
assert service_callback_api.bearer_token == "different_token"
def test_update_service_callback_api_raises_400_when_wrong_request(
admin_request, sample_service, request_data):
service_callback_api = create_service_callback_api(
service=sample_service, notification_statuses=['technical-failure'])
resp_json = admin_request.post(
'service_callback.update_service_callback_api',
service_id=sample_service.id,
callback_api_id=service_callback_api.id,
_data=request_data,
_expected_status=400)
assert len(resp_json['errors']) > 0
for error in resp_json['errors']:
assert error['message'] is not None
