import uuid import pytest from flask import current_app from app.celery.tasks import ( send_sms, send_sms_code, send_email_code, send_email, process_job, email_invited_user, email_reset_password, delete_verify_codes, delete_invitations, delete_failed_notifications, delete_successful_notifications ) from app import (firetext_client, aws_ses_client, encryption, DATETIME_FORMAT) from app.clients.email.aws_ses import AwsSesClientException from app.clients.sms.firetext import FiretextClientException from app.dao import notifications_dao, jobs_dao from sqlalchemy.exc import SQLAlchemyError from sqlalchemy.orm.exc import NoResultFound from app.celery.tasks import s3 from app.celery import tasks from tests.app import load_example_csv from datetime import datetime, timedelta from freezegun import freeze_time from tests.app.conftest import ( sample_service, sample_user, sample_template ) def test_should_call_delete_successful_notifications_in_task(notify_api, mocker): mocker.patch('app.celery.tasks.delete_successful_notifications_created_more_than_a_day_ago') delete_successful_notifications() assert tasks.delete_successful_notifications_created_more_than_a_day_ago.call_count == 1 def test_should_call_delete_failed_notifications_in_task(notify_api, mocker): mocker.patch('app.celery.tasks.delete_failed_notifications_created_more_than_a_week_ago') delete_failed_notifications() assert tasks.delete_failed_notifications_created_more_than_a_week_ago.call_count == 1 def test_should_call_delete_codes_on_delete_verify_codes_task(notify_api, mocker): mocker.patch('app.celery.tasks.delete_codes_older_created_more_than_a_day_ago') delete_verify_codes() assert tasks.delete_codes_older_created_more_than_a_day_ago.call_count == 1 def test_should_call_delete_invotations_on_delete_invitations_task(notify_api, mocker): mocker.patch('app.celery.tasks.delete_invitations_older_created_more_than_a_day_ago') delete_invitations() assert tasks.delete_invitations_older_created_more_than_a_day_ago.call_count == 1 @freeze_time("2016-01-01 11:09:00.061258") def test_should_process_sms_job(sample_job, mocker): mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('sms')) mocker.patch('app.celery.tasks.send_sms.apply_async') mocker.patch('app.encryption.encrypt', return_value="something_encrypted") mocker.patch('app.celery.tasks.create_uuid', return_value="uuid") process_job(sample_job.id) s3.get_job_from_s3.assert_called_once_with(sample_job.bucket_name, sample_job.id) assert encryption.encrypt.call_args[0][0]['to'] == '+441234123123' assert encryption.encrypt.call_args[0][0]['personalisation'] == {} tasks.send_sms.apply_async.assert_called_once_with( (str(sample_job.service_id), "uuid", "something_encrypted", "2016-01-01T11:09:00.061258"), queue="bulk-sms" ) job = jobs_dao.dao_get_job_by_id(sample_job.id) assert job.status == 'finished' def test_should_not_create_send_task_for_empty_file(sample_job, sample_template, mocker): mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('empty')) mocker.patch('app.celery.tasks.send_sms.apply_async') process_job(sample_job.id) s3.get_job_from_s3.assert_called_once_with(sample_job.bucket_name, sample_job.id) job = jobs_dao.dao_get_job_by_id(sample_job.id) assert job.status == 'finished' tasks.send_sms.apply_async.assert_not_called @freeze_time("2016-01-01 11:09:00.061258") def test_should_process_email_job(sample_email_job, sample_template, mocker): mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('email')) mocker.patch('app.celery.tasks.send_email.apply_async') mocker.patch('app.encryption.encrypt', return_value="something_encrypted") mocker.patch('app.celery.tasks.create_uuid', return_value="uuid") process_job(sample_email_job.id) s3.get_job_from_s3.assert_called_once_with(sample_email_job.bucket_name, sample_email_job.id) assert encryption.encrypt.call_args[0][0]['to'] == 'test@test.com' assert encryption.encrypt.call_args[0][0]['personalisation'] == {} tasks.send_email.apply_async.assert_called_once_with( (str(sample_email_job.service_id), "uuid", sample_email_job.template.subject, "{}@{}".format(sample_email_job.service.email_from, "test.notify.com"), "something_encrypted", "2016-01-01T11:09:00.061258"), queue="bulk-email" ) job = jobs_dao.dao_get_job_by_id(sample_email_job.id) assert job.status == 'finished' def test_should_process_all_sms_job(sample_job, sample_job_with_placeholdered_template, mocker): mocker.patch('app.celery.tasks.s3.get_job_from_s3', return_value=load_example_csv('multiple_sms')) mocker.patch('app.celery.tasks.send_sms.apply_async') mocker.patch('app.encryption.encrypt', return_value="something_encrypted") mocker.patch('app.celery.tasks.create_uuid', return_value="uuid") process_job(sample_job_with_placeholdered_template.id) s3.get_job_from_s3.assert_called_once_with( sample_job_with_placeholdered_template.bucket_name, sample_job_with_placeholdered_template.id ) assert encryption.encrypt.call_args[0][0]['to'] == '+441234123120' assert encryption.encrypt.call_args[0][0]['personalisation'] == {'name': 'chris'} tasks.send_sms.apply_async.call_count == 10 job = jobs_dao.dao_get_job_by_id(sample_job_with_placeholdered_template.id) assert job.status == 'finished' def test_should_send_template_to_correct_sms_provider_and_persist(sample_template_with_placeholders, mocker): notification = { "template": sample_template_with_placeholders.id, "to": "+441234123123", "personalisation": {"name": "Jo"} } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.firetext_client.send_sms') mocker.patch('app.firetext_client.get_name', return_value="firetext") notification_id = uuid.uuid4() now = datetime.utcnow() send_sms( sample_template_with_placeholders.service_id, notification_id, "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) firetext_client.send_sms.assert_called_once_with("+441234123123", "Sample service: Hello Jo") persisted_notification = notifications_dao.get_notification( sample_template_with_placeholders.service_id, notification_id ) assert persisted_notification.id == notification_id assert persisted_notification.to == '+441234123123' assert persisted_notification.template_id == sample_template_with_placeholders.id assert persisted_notification.status == 'sent' assert persisted_notification.created_at == now assert persisted_notification.sent_at > now assert persisted_notification.sent_by == 'firetext' assert not persisted_notification.job_id def test_should_send_sms_without_personalisation(sample_template, mocker): notification = { "template": sample_template.id, "to": "+441234123123" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.firetext_client.send_sms') mocker.patch('app.firetext_client.get_name', return_value="firetext") notification_id = uuid.uuid4() now = datetime.utcnow() send_sms( sample_template.service_id, notification_id, "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) firetext_client.send_sms.assert_called_once_with("+441234123123", "Sample service: This is a template") def test_should_send_sms_if_restricted_service_and_valid_number(notify_db, notify_db_session, mocker): user = sample_user(notify_db, notify_db_session, mobile_numnber="+441234123123") service = sample_service(notify_db, notify_db_session, user=user, restricted=True) template = sample_template(notify_db, notify_db_session, service=service) notification = { "template": template.id, "to": "+441234123123" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.firetext_client.send_sms') mocker.patch('app.firetext_client.get_name', return_value="firetext") notification_id = uuid.uuid4() now = datetime.utcnow() send_sms( service.id, notification_id, "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) firetext_client.send_sms.assert_called_once_with("+441234123123", "Sample service: This is a template") def test_should_not_send_sms_if_restricted_service_and_invalid_number(notify_db, notify_db_session, mocker): user = sample_user(notify_db, notify_db_session, mobile_numnber="+441234123123") service = sample_service(notify_db, notify_db_session, user=user, restricted=True) template = sample_template(notify_db, notify_db_session, service=service) notification = { "template": template.id, "to": "+440000000000" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.firetext_client.send_sms') mocker.patch('app.firetext_client.get_name', return_value="firetext") notification_id = uuid.uuid4() now = datetime.utcnow() send_sms( service.id, notification_id, "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) firetext_client.send_sms.assert_not_called() def test_should_send_email_if_restricted_service_and_valid_email(notify_db, notify_db_session, mocker): user = sample_user(notify_db, notify_db_session, email="test@restricted.com") service = sample_service(notify_db, notify_db_session, user=user, restricted=True) template = sample_template(notify_db, notify_db_session, service=service) notification = { "template": template.id, "to": "test@restricted.com" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.aws_ses_client.send_email') notification_id = uuid.uuid4() now = datetime.utcnow() send_email( service.id, notification_id, 'subject', 'email_from', "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) aws_ses_client.send_email.assert_called_once_with( "email_from", "test@restricted.com", "subject", template.content ) def test_should_send_template_to_correct_sms_provider_and_persist_with_job_id(sample_job, mocker): notification = { "template": sample_job.template.id, "job": sample_job.id, "to": "+441234123123" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.firetext_client.send_sms') mocker.patch('app.firetext_client.get_name', return_value="firetext") notification_id = uuid.uuid4() now = datetime.utcnow() send_sms( sample_job.service.id, notification_id, "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) firetext_client.send_sms.assert_called_once_with("+441234123123", "Sample service: This is a template") persisted_notification = notifications_dao.get_notification(sample_job.template.service_id, notification_id) assert persisted_notification.id == notification_id assert persisted_notification.to == '+441234123123' assert persisted_notification.job_id == sample_job.id assert persisted_notification.template_id == sample_job.template.id assert persisted_notification.status == 'sent' assert persisted_notification.sent_at > now assert persisted_notification.created_at == now assert persisted_notification.sent_by == 'firetext' def test_should_use_email_template_and_persist(sample_email_template_with_placeholders, mocker): notification = { "template": sample_email_template_with_placeholders.id, "to": "my_email@my_email.com", "personalisation": {"name": "Jo"} } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.aws_ses_client.send_email') mocker.patch('app.aws_ses_client.get_name', return_value='ses') notification_id = uuid.uuid4() now = datetime.utcnow() send_email( sample_email_template_with_placeholders.service_id, notification_id, 'subject', 'email_from', "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) aws_ses_client.send_email.assert_called_once_with( "email_from", "my_email@my_email.com", "subject", "Hello Jo" ) persisted_notification = notifications_dao.get_notification( sample_email_template_with_placeholders.service_id, notification_id ) assert persisted_notification.id == notification_id assert persisted_notification.to == 'my_email@my_email.com' assert persisted_notification.template_id == sample_email_template_with_placeholders.id assert persisted_notification.created_at == now assert persisted_notification.sent_at > now assert persisted_notification.status == 'sent' assert persisted_notification.sent_by == 'ses' def test_should_use_email_template_and_persist_without_personalisation( sample_email_template, mocker ): mocker.patch('app.encryption.decrypt', return_value={ "template": sample_email_template.id, "to": "my_email@my_email.com", }) mocker.patch('app.aws_ses_client.send_email') mocker.patch('app.aws_ses_client.get_name', return_value='ses') notification_id = uuid.uuid4() now = datetime.utcnow() send_email( sample_email_template.service_id, notification_id, 'subject', 'email_from', "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) aws_ses_client.send_email.assert_called_once_with( "email_from", "my_email@my_email.com", "subject", "This is a template" ) def test_should_persist_notification_as_failed_if_sms_client_fails(sample_template, mocker): notification = { "template": sample_template.id, "to": "+441234123123" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.firetext_client.send_sms', side_effect=FiretextClientException()) mocker.patch('app.firetext_client.get_name', return_value="firetext") now = datetime.utcnow() notification_id = uuid.uuid4() send_sms( sample_template.service_id, notification_id, "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) firetext_client.send_sms.assert_called_once_with("+441234123123", "Sample service: This is a template") persisted_notification = notifications_dao.get_notification(sample_template.service_id, notification_id) assert persisted_notification.id == notification_id assert persisted_notification.to == '+441234123123' assert persisted_notification.template_id == sample_template.id assert persisted_notification.status == 'failed' assert persisted_notification.created_at == now assert persisted_notification.sent_at > now assert persisted_notification.sent_by == 'firetext' def test_should_persist_notification_as_failed_if_email_client_fails(sample_email_template, mocker): notification = { "template": sample_email_template.id, "to": "my_email@my_email.com" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.aws_ses_client.send_email', side_effect=AwsSesClientException()) mocker.patch('app.aws_ses_client.get_name', return_value="ses") now = datetime.utcnow() notification_id = uuid.uuid4() send_email( sample_email_template.service_id, notification_id, 'subject', 'email_from', "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) aws_ses_client.send_email.assert_called_once_with( "email_from", "my_email@my_email.com", "subject", sample_email_template.content ) persisted_notification = notifications_dao.get_notification(sample_email_template.service_id, notification_id) assert persisted_notification.id == notification_id assert persisted_notification.to == 'my_email@my_email.com' assert persisted_notification.template_id == sample_email_template.id assert persisted_notification.status == 'failed' assert persisted_notification.created_at == now assert persisted_notification.sent_by == 'ses' assert persisted_notification.sent_at > now def test_should_not_send_sms_if_db_peristance_failed(sample_template, mocker): notification = { "template": sample_template.id, "to": "+441234123123" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.firetext_client.send_sms') mocker.patch('app.db.session.add', side_effect=SQLAlchemyError()) now = datetime.utcnow() notification_id = uuid.uuid4() send_sms( sample_template.service_id, notification_id, "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) firetext_client.send_sms.assert_not_called() with pytest.raises(NoResultFound) as e: notifications_dao.get_notification(sample_template.service_id, notification_id) assert 'No row was found for one' in str(e.value) def test_should_not_send_email_if_db_peristance_failed(sample_email_template, mocker): notification = { "template": sample_email_template.id, "to": "my_email@my_email.com" } mocker.patch('app.encryption.decrypt', return_value=notification) mocker.patch('app.aws_ses_client.send_email') mocker.patch('app.db.session.add', side_effect=SQLAlchemyError()) now = datetime.utcnow() notification_id = uuid.uuid4() send_email( sample_email_template.service_id, notification_id, 'subject', 'email_from', "encrypted-in-reality", now.strftime(DATETIME_FORMAT) ) aws_ses_client.send_email.assert_not_called() with pytest.raises(NoResultFound) as e: notifications_dao.get_notification(sample_email_template.service_id, notification_id) assert 'No row was found for one' in str(e.value) def test_should_send_sms_code(mocker): notification = {'to': '+441234123123', 'secret_code': '12345'} encrypted_notification = encryption.encrypt(notification) mocker.patch('app.firetext_client.send_sms') send_sms_code(encrypted_notification) firetext_client.send_sms.assert_called_once_with(notification['to'], notification['secret_code']) def test_should_throw_firetext_client_exception(mocker): notification = {'to': '+441234123123', 'secret_code': '12345'} encrypted_notification = encryption.encrypt(notification) mocker.patch('app.firetext_client.send_sms', side_effect=FiretextClientException) send_sms_code(encrypted_notification) firetext_client.send_sms.assert_called_once_with(notification['to'], notification['secret_code']) def test_should_send_email_code(mocker): verification = {'to': 'someone@it.gov.uk', 'secret_code': 11111} encrypted_verification = encryption.encrypt(verification) mocker.patch('app.aws_ses_client.send_email') send_email_code(encrypted_verification) aws_ses_client.send_email.assert_called_once_with( current_app.config['VERIFY_CODE_FROM_EMAIL_ADDRESS'], verification['to'], "Verification code", verification['secret_code'] ) def test_email_invited_user_should_send_email(notify_api, mocker): with notify_api.test_request_context(): invitation = {'to': 'new_person@it.gov.uk', 'user_name': 'John Smith', 'service_id': '123123', 'service_name': 'Blacksmith Service', 'token': 'the-token', 'expiry_date': str(datetime.now() + timedelta(days=1)) } mocker.patch('app.aws_ses_client.send_email') mocker.patch('app.encryption.decrypt', return_value=invitation) url = tasks.invited_user_url(current_app.config['ADMIN_BASE_URL'], invitation['token']) expected_content = tasks.invitation_template(invitation['user_name'], invitation['service_name'], url, invitation['expiry_date']) email_invited_user(encryption.encrypt(invitation)) email_from = "{}@{}".format(current_app.config['INVITATION_EMAIL_FROM'], current_app.config['NOTIFY_EMAIL_DOMAIN']) expected_subject = tasks.invitation_subject_line(invitation['user_name'], invitation['service_name']) aws_ses_client.send_email.assert_called_once_with(email_from, invitation['to'], expected_subject, expected_content) def test_email_reset_password_should_send_email(notify_api, mocker): with notify_api.test_request_context(): reset_password_message = {'to': 'someone@it.gov.uk', 'name': 'Some One', 'reset_password_url': 'bah'} mocker.patch('app.aws_ses_client.send_email') mocker.patch('app.encryption.decrypt', return_value=reset_password_message) encrypted_message = encryption.encrypt(reset_password_message) email_reset_password(encrypted_message) message = tasks.password_reset_message(reset_password_message['name'], reset_password_message['reset_password_url']) aws_ses_client.send_email(current_app.config['VERIFY_CODE_FROM_EMAIL_ADDRESS'], reset_password_message['to'], "Reset password for GOV.UK Notify", message)