Merge pull request #91 from alphagov/send-email-from-templates

Send Email via the API

tests/app/celery/test_tasks.py

@@ -1,8 +1,9 @@
 import uuid
 import pytest
 from flask import current_app
-from app.celery.tasks import (send_sms, send_sms_code, send_email_code)
+from app.celery.tasks import (send_sms, send_sms_code, send_email_code, send_email)
 from app import (firetext_client, aws_ses_client, encryption)
+from app.clients.email.aws_ses import AwsSesClientException
 from app.clients.sms.firetext import FiretextClientException
 from app.dao import notifications_dao
 from sqlalchemy.exc import SQLAlchemyError
@@ -32,6 +33,36 @@ def test_should_send_template_to_correct_sms_provider_and_persist(sample_templat
     assert persisted_notification.status == 'sent'
 
 
+def test_should_send_template_to_email_provider_and_persist(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')
+
+    notification_id = uuid.uuid4()
+
+    send_email(
+        sample_email_template.service_id,
+        notification_id,
+        'subject',
+        'email_from',
+        "encrypted-in-reality")
+
+    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 == 'sent'
+
+
 def test_should_persist_notification_as_failed_if_sms_client_fails(sample_template, mocker):
     notification = {
         "template": sample_template.id,
@@ -55,13 +86,43 @@ def test_should_persist_notification_as_failed_if_sms_client_fails(sample_templa
     assert persisted_notification.status == 'failed'
 
 
+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())
+
+    notification_id = uuid.uuid4()
+
+    send_email(
+        sample_email_template.service_id,
+        notification_id,
+        'subject',
+        'email_from',
+        "encrypted-in-reality")
+
+    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'
+
+
 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', side_effect=FiretextClientException())
+    mocker.patch('app.firetext_client.send_sms')
     mocker.patch('app.db.session.add', side_effect=SQLAlchemyError())
 
     notification_id = uuid.uuid4()
@@ -77,6 +138,30 @@ def test_should_not_send_sms_if_db_peristance_failed(sample_template, mocker):
     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())
+
+    notification_id = uuid.uuid4()
+
+    send_email(
+        sample_email_template.service_id,
+        notification_id,
+        'subject',
+        'email_from',
+        "encrypted-in-reality")
+
+    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'}

tests/app/conftest.py

@@ -1,5 +1,6 @@
 import pytest
 
+from app import email_safe
 from app.models import (User, Service, Template, ApiKey, Job, Notification)
 from app.dao.users_dao import (save_model_user, create_user_code, create_secret_code)
 from app.dao.services_dao import dao_create_service
@@ -13,11 +14,24 @@ import uuid
 @pytest.fixture(scope='function')
 def service_factory(notify_db, notify_db_session):
     class ServiceFactory(object):
-        def get(self, service_name, user=None):
+        def get(self, service_name, user=None, template_type=None):
             if not user:
                 user = sample_user(notify_db, notify_db_session)
             service = sample_service(notify_db, notify_db_session, service_name, user)
-            sample_template(notify_db, notify_db_session, service=service)
+            if template_type == 'email':
+                sample_template(
+                    notify_db,
+                    notify_db_session,
+                    template_type=template_type,
+                    subject_line=email_safe(service_name),
+                    service=service
+                )
+            else:
+                sample_template(
+                    notify_db,
+                    notify_db_session,
+                    service=service
+                )
             return service
 
     return ServiceFactory()
@@ -93,7 +107,7 @@ def sample_service(notify_db,
         'limit': 1000,
         'active': False,
         'restricted': False,
-        'email_from': service_name
+        'email_from': email_safe(service_name)
     }
     service = Service.query.filter_by(name=service_name).first()
     if not service:
@@ -119,6 +133,33 @@ def sample_template(notify_db,
         'content': content,
         'service': service
     }
+    if template_type == 'email':
+        data.update({
+            'subject': subject_line
+        })
+    template = Template(**data)
+    save_model_template(template)
+    return template
+
+
+@pytest.fixture(scope='function')
+def sample_email_template(
+        notify_db,
+        notify_db_session,
+        template_name="Email Template Name",
+        template_type="email",
+        content="This is a template",
+        subject_line='Email Subject',
+        service=None):
+    if service is None:
+        service = sample_service(notify_db, notify_db_session)
+    sample_api_key(notify_db, notify_db_session, service=service)
+    data = {
+        'name': template_name,
+        'template_type': template_type,
+        'content': content,
+        'service': service
+    }
     if subject_line:
         data.update({
             'subject': subject_line

tests/app/notifications/test_rest.py

@@ -5,6 +5,7 @@ from tests import create_authorization_header
 from flask import json
 from app.models import Service
 from app.dao.templates_dao import get_model_templates
+from app.dao.services_dao import dao_update_service
 
 
 def test_get_notification_by_id(notify_api, sample_notification):
@@ -158,21 +159,20 @@ def test_prevents_sending_to_any_mobile_on_restricted_service(notify_api, sample
             app.celery.tasks.send_sms.apply_async.assert_not_called()
 
             assert response.status_code == 400
-            assert 'Invalid phone number for restricted service' in json_resp['message']['restricted']
+            assert 'Invalid phone number for restricted service' in json_resp['message']['to']
 
 
-def test_should_not_allow_template_from_another_service(notify_api, service_factory, mocker):
+def test_should_not_allow_template_from_another_service(notify_api, service_factory, sample_user, mocker):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
             mocker.patch('app.celery.tasks.send_sms.apply_async')
 
-            service_1 = service_factory.get('service 1')
-            service_2 = service_factory.get('service 2')
+            service_1 = service_factory.get('service 1', user=sample_user)
+            service_2 = service_factory.get('service 2', user=sample_user)
 
             service_2_templates = get_model_templates(service_id=service_2.id)
-
             data = {
-                'to': '+441234123123',
+                'to': sample_user.mobile_number,
                 'template': service_2_templates[0].id
             }
 
@@ -191,7 +191,7 @@ def test_should_not_allow_template_from_another_service(notify_api, service_fact
             app.celery.tasks.send_sms.apply_async.assert_not_called()
 
             assert response.status_code == 400
-            assert 'Invalid template' in json_resp['message']['restricted']
+            assert 'Template not found' in json_resp['message']['template']
 
 
 def test_should_allow_valid_sms_notification(notify_api, sample_template, mocker):
@@ -228,27 +228,14 @@ def test_should_allow_valid_sms_notification(notify_api, sample_template, mocker
             assert notification_id
 
 
-@moto.mock_sqs
-def test_send_email_valid_data(notify_api,
-                               notify_db,
-                               notify_db_session,
-                               sample_service,
-                               sample_admin_service_id,
-                               sqs_client_conn,
-                               mocker):
+def test_create_email_should_reject_if_missing_required_fields(notify_api, sample_api_key, mocker):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
-            to_address = "to@notify.com"
-            from_address = "from@notify.com"
-            subject = "This is the subject"
-            message = "This is the message"
-            data = {
-                'to': to_address,
-                'from': from_address,
-                'subject': subject,
-                'message': message
-            }
+            mocker.patch('app.celery.tasks.send_email.apply_async')
+
+            data = {}
             auth_header = create_authorization_header(
+                service_id=sample_api_key.service_id,
                 request_body=json.dumps(data),
                 path='/notifications/email',
                 method='POST')
@@ -258,8 +245,166 @@ def test_send_email_valid_data(notify_api,
                 data=json.dumps(data),
                 headers=[('Content-Type', 'application/json'), auth_header])
 
+            json_resp = json.loads(response.get_data(as_text=True))
+            app.celery.tasks.send_email.apply_async.assert_not_called()
+            assert json_resp['result'] == 'error'
+            assert 'Missing data for required field.' in json_resp['message']['to'][0]
+            assert 'Missing data for required field.' in json_resp['message']['template'][0]
+            assert response.status_code == 400
+
+
+def test_should_reject_email_notification_with_bad_email(notify_api, sample_email_template, mocker):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+            mocker.patch('app.celery.tasks.send_email.apply_async')
+            to_address = "bad-email"
+            data = {
+                'to': to_address,
+                'template': sample_email_template.service.id
+            }
+            auth_header = create_authorization_header(
+                service_id=sample_email_template.service.id,
+                request_body=json.dumps(data),
+                path='/notifications/email',
+                method='POST')
+
+            response = client.post(
+                path='/notifications/email',
+                data=json.dumps(data),
+                headers=[('Content-Type', 'application/json'), auth_header])
+
+            data = json.loads(response.get_data(as_text=True))
+            app.celery.tasks.send_email.apply_async.assert_not_called()
+            assert response.status_code == 400
+            assert data['result'] == 'error'
+            assert data['message']['to'][0] == 'Invalid email'
+
+
+def test_should_reject_email_notification_with_template_id_that_cant_be_found(
+        notify_api, sample_email_template, mocker):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+            mocker.patch('app.celery.tasks.send_email.apply_async')
+            data = {
+                'to': 'ok@ok.com',
+                'template': 1234
+            }
+            auth_header = create_authorization_header(
+                service_id=sample_email_template.service.id,
+                request_body=json.dumps(data),
+                path='/notifications/email',
+                method='POST')
+
+            response = client.post(
+                path='/notifications/email',
+                data=json.dumps(data),
+                headers=[('Content-Type', 'application/json'), auth_header])
+
+            data = json.loads(response.get_data(as_text=True))
+            app.celery.tasks.send_email.apply_async.assert_not_called()
+            assert response.status_code == 400
+            assert data['result'] == 'error'
+            assert data['message']['template'][0] == 'Template not found'
+
+
+def test_should_not_allow_email_template_from_another_service(notify_api, service_factory, sample_user, mocker):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+            mocker.patch('app.celery.tasks.send_email.apply_async')
+
+            service_1 = service_factory.get('service 1', template_type='email', user=sample_user)
+            service_2 = service_factory.get('service 2', template_type='email', user=sample_user)
+
+            service_2_templates = get_model_templates(service_id=service_2.id)
+
+            data = {
+                'to': sample_user.email_address,
+                'template': service_2_templates[0].id
+            }
+
+            auth_header = create_authorization_header(
+                service_id=service_1.id,
+                request_body=json.dumps(data),
+                path='/notifications/email',
+                method='POST')
+
+            response = client.post(
+                path='/notifications/email',
+                data=json.dumps(data),
+                headers=[('Content-Type', 'application/json'), auth_header])
+
+            json_resp = json.loads(response.get_data(as_text=True))
+            app.celery.tasks.send_email.apply_async.assert_not_called()
+
+            assert response.status_code == 400
+            assert 'Template not found' in json_resp['message']['template']
+
+
+def test_should_not_send_email_if_restricted_and_not_a_service_user(notify_api, sample_email_template, mocker):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+            mocker.patch('app.celery.tasks.send_email.apply_async')
+
+            sample_email_template.service.restricted = True
+            dao_update_service(sample_email_template)
+
+            data = {
+                'to': "not-someone-we-trust@email-address.com",
+                'template': sample_email_template.id
+            }
+
+            auth_header = create_authorization_header(
+                service_id=sample_email_template.service.id,
+                request_body=json.dumps(data),
+                path='/notifications/email',
+                method='POST')
+
+            response = client.post(
+                path='/notifications/email',
+                data=json.dumps(data),
+                headers=[('Content-Type', 'application/json'), auth_header])
+
+            json_resp = json.loads(response.get_data(as_text=True))
+            app.celery.tasks.send_email.apply_async.assert_not_called()
+
+            assert response.status_code == 400
+            assert 'Email address not permitted for restricted service' in json_resp['message']['to']
+
+
+def test_should_allow_valid_email_notification(notify_api, sample_email_template, mocker):
+    with notify_api.test_request_context():
+        with notify_api.test_client() as client:
+            mocker.patch('app.celery.tasks.send_email.apply_async')
+            mocker.patch('app.encryption.encrypt', return_value="something_encrypted")
+
+            data = {
+                'to': 'ok@ok.com',
+                'template': sample_email_template.id
+            }
+
+            auth_header = create_authorization_header(
+                request_body=json.dumps(data),
+                path='/notifications/email',
+                method='POST',
+                service_id=sample_email_template.service_id
+            )
+
+            response = client.post(
+                path='/notifications/email',
+                data=json.dumps(data),
+                headers=[('Content-Type', 'application/json'), auth_header])
+
+            notification_id = json.loads(response.data)['notification_id']
+            app.celery.tasks.send_email.apply_async.assert_called_once_with(
+                (str(sample_email_template.service_id),
+                 notification_id,
+                 "Email Subject",
+                 "sample.service@test.notify.com",
+                 "something_encrypted"),
+                queue="email"
+            )
             assert response.status_code == 201
-            assert json.loads(response.data)['notification_id'] is not None
+            assert notification_id
 
 
 @moto.mock_sqs