Merge pull request #1038 from alphagov/push-inbound-sms

Push inbound sms

tests/app/celery/test_tasks.py

@@ -1,8 +1,10 @@
+import json
 import uuid
 from datetime import datetime
 from unittest.mock import Mock
 
 import pytest
+import requests_mock
 from flask import current_app
 from freezegun import freeze_time
 from sqlalchemy.exc import SQLAlchemyError
@@ -25,8 +27,8 @@ from app.celery.tasks import (
     get_template_class,
     update_job_to_sent_to_dvla,
     update_letter_notifications_statuses,
-    process_updates_from_file
-)
+    process_updates_from_file,
+    send_inbound_sms_to_service)
 from app.dao import jobs_dao, services_dao
 from app.models import (
     Notification,
@@ -47,7 +49,7 @@ from tests.app.conftest import (
     sample_email_template,
     sample_notification
 )
-from tests.app.db import create_user, create_notification, create_job
+from tests.app.db import create_user, create_notification, create_job, create_service_inbound_api, create_inbound_sms
 
 
 class AnyStringWith(str):
@@ -1119,3 +1121,97 @@ def test_update_letter_notifications_statuses_builds_updates_list(notify_api, mo
     assert updates[1].status == 'Sent'
     assert updates[1].page_count == '2'
     assert updates[1].cost_threshold == 'Sorted'
+
+
+def test_send_inbound_sms_to_service_post_https_request_to_service(notify_api, sample_service):
+    inbound_api = create_service_inbound_api(service=sample_service, url="https://some.service.gov.uk/",
+                                             bearer_token="something_unique")
+    inbound_sms = create_inbound_sms(service=sample_service, notify_number="0751421", user_number="447700900111",
+                                     provider_date=datetime(2017, 6, 20), content="Here is some content")
+    data = {
+        "id": str(inbound_sms.id),
+        "from_number": inbound_sms.user_number,
+        "content": inbound_sms.content,
+        "date_received": inbound_sms.provider_date.strftime(DATETIME_FORMAT)
+    }
+
+    with requests_mock.Mocker() as request_mock:
+        request_mock.post(inbound_api.url,
+                          json={},
+                          status_code=200)
+        send_inbound_sms_to_service(inbound_sms.id, inbound_sms.service_id)
+    assert request_mock.call_count == 1
+    assert request_mock.request_history[0].url == inbound_api.url
+    assert request_mock.request_history[0].method == 'POST'
+    assert request_mock.request_history[0].text == json.dumps(data)
+    assert request_mock.request_history[0].headers["Content-type"] == "application/json"
+    assert request_mock.request_history[0].headers["Authorization"] == "Bearer {}".format(inbound_api.bearer_token)
+
+
+def test_send_inbound_sms_to_service_does_not_send_request_when_inbound_sms_does_not_exist(notify_api, sample_service):
+    inbound_api = create_service_inbound_api(service=sample_service)
+    with requests_mock.Mocker() as request_mock:
+        request_mock.post(inbound_api.url,
+                          json={},
+                          status_code=200)
+        with pytest.raises(SQLAlchemyError):
+            send_inbound_sms_to_service(inbound_sms_id=uuid.uuid4(), service_id=sample_service.id)
+
+    assert request_mock.call_count == 0
+
+
+def test_send_inbound_sms_to_service_does_not_sent_request_when_inbound_api_does_not_exist(
+        notify_api, sample_service, mocker):
+    inbound_sms = create_inbound_sms(service=sample_service, notify_number="0751421", user_number="447700900111",
+                                     provider_date=datetime(2017, 6, 20), content="Here is some content")
+    mocked = mocker.patch("requests.request")
+    send_inbound_sms_to_service(inbound_sms.id, inbound_sms.service_id)
+
+    mocked.call_count == 0
+
+
+def test_send_inbound_sms_to_service_retries_if_request_returns_500(notify_api, sample_service, mocker):
+    inbound_api = create_service_inbound_api(service=sample_service, url="https://some.service.gov.uk/",
+                                             bearer_token="something_unique")
+    inbound_sms = create_inbound_sms(service=sample_service, notify_number="0751421", user_number="447700900111",
+                                     provider_date=datetime(2017, 6, 20), content="Here is some content")
+    data = {
+        "id": str(inbound_sms.id),
+        "from_number": inbound_sms.user_number,
+        "content": inbound_sms.content,
+        "date_received": inbound_sms.provider_date.strftime(DATETIME_FORMAT)
+    }
+
+    mocked = mocker.patch('app.celery.tasks.send_inbound_sms_to_service.retry')
+    with requests_mock.Mocker() as request_mock:
+        request_mock.post(inbound_api.url,
+                          json={},
+                          status_code=500)
+        send_inbound_sms_to_service(inbound_sms.id, inbound_sms.service_id)
+
+    mocked.assert_called_with(
+        exc='Unable to send_inbound_sms_to_service for service_id: {} '
+            'and url: {}. \n500 Server Error: None'.format(sample_service.id, inbound_api.url),
+        queue="retry-tasks")
+
+
+def test_send_inbound_sms_to_service_does_not_retries_if_request_returns_404(notify_api, sample_service, mocker):
+    inbound_api = create_service_inbound_api(service=sample_service, url="https://some.service.gov.uk/",
+                                             bearer_token="something_unique")
+    inbound_sms = create_inbound_sms(service=sample_service, notify_number="0751421", user_number="447700900111",
+                                     provider_date=datetime(2017, 6, 20), content="Here is some content")
+    data = {
+        "id": str(inbound_sms.id),
+        "from_number": inbound_sms.user_number,
+        "content": inbound_sms.content,
+        "date_received": inbound_sms.provider_date.strftime(DATETIME_FORMAT)
+    }
+
+    mocked = mocker.patch('app.celery.tasks.send_inbound_sms_to_service.retry')
+    with requests_mock.Mocker() as request_mock:
+        request_mock.post(inbound_api.url,
+                          json={},
+                          status_code=404)
+        send_inbound_sms_to_service(inbound_sms.id, inbound_sms.service_id)
+
+    mocked.call_count == 0

tests/app/dao/test_service_inbound_api_dao.py

@@ -7,9 +7,10 @@ from app import encryption
 from app.dao.service_inbound_api_dao import (
     save_service_inbound_api,
     reset_service_inbound_api,
-    get_service_inbound_api
-)
+    get_service_inbound_api,
+    get_service_inbound_api_for_service)
 from app.models import ServiceInboundApi
+from tests.app.db import create_service_inbound_api
 
 
 def test_save_service_inbound_api(sample_service):
@@ -115,3 +116,14 @@ def test_get_service_inbound_api(sample_service):
     assert inbound_api.bearer_token == "some_unique_string"
     assert inbound_api._bearer_token != "some_unique_string"
     assert inbound_api.updated_at is None
+
+
+def test_get_service_inbound_api_for_service(sample_service):
+    service_inbound_api = create_service_inbound_api(service=sample_service)
+    result = get_service_inbound_api_for_service(sample_service.id)
+    assert result.id == service_inbound_api.id
+    assert result.url == service_inbound_api.url
+    assert result.bearer_token == service_inbound_api.bearer_token
+    assert result.created_at == service_inbound_api.created_at
+    assert result.updated_at == service_inbound_api.updated_at
+    assert result.updated_by_id == service_inbound_api.updated_by_id

tests/app/notifications/test_receive_notification.py

@@ -1,3 +1,4 @@
+import uuid
 from datetime import datetime
 from unittest.mock import call
 
@@ -7,7 +8,7 @@ from flask import json
 from app.notifications.receive_notifications import (
     format_mmg_message,
     format_mmg_datetime,
-    create_inbound_mmg_sms_object,
+    create_inbound_sms_object,
     strip_leading_forty_four
 )
 
@@ -15,7 +16,8 @@ from app.models import InboundSms
 from tests.app.db import create_service
 
 
-def test_receive_notification_returns_received_to_mmg(client, sample_service):
+def test_receive_notification_returns_received_to_mmg(client, sample_service, mocker):
+    mocked = mocker.patch("app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
     data = {"ID": "1234",
             "MSISDN": "447700900855",
             "Message": "Some message to notify",
@@ -30,6 +32,8 @@ def test_receive_notification_returns_received_to_mmg(client, sample_service):
 
     assert response.status_code == 200
     assert response.get_data(as_text=True) == 'RECEIVED'
+    inbound_sms_id = InboundSms.query.all()[0].id
+    mocked.assert_called_once_with([str(inbound_sms_id), str(sample_service.id)], queue="notify-internal-tasks")
 
 
 @pytest.mark.parametrize('message, expected_output', [
@@ -61,7 +65,8 @@ def test_create_inbound_mmg_sms_object(sample_service):
         'ID': 'bar',
     }
 
-    inbound_sms = create_inbound_mmg_sms_object(sample_service, data)
+    inbound_sms = create_inbound_sms_object(sample_service, format_mmg_message(data["Message"]),
+                                            data["MSISDN"], data["ID"], data["DateRecieved"], "mmg")
 
     assert inbound_sms.service_id == sample_service.id
     assert inbound_sms.notify_number == 'foo'
@@ -96,9 +101,10 @@ def test_receive_notification_error_if_not_single_matching_service(client, notif
 
 
 def test_receive_notification_returns_received_to_firetext(notify_db_session, client, mocker):
+    mocked = mocker.patch("app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
     mock = mocker.patch('app.notifications.receive_notifications.statsd_client.incr')
 
-    create_service(service_name='b', sms_sender='07111111111')
+    service = create_service(service_name='b', sms_sender='07111111111')
 
     data = "source=07999999999&destination=07111111111&message=this is a message&time=2017-01-01 12:00:00"
 
@@ -113,9 +119,12 @@ def test_receive_notification_returns_received_to_firetext(notify_db_session, cl
     mock.assert_has_calls([call('inbound.firetext.successful')])
 
     assert result['status'] == 'ok'
+    inbound_sms_id = InboundSms.query.all()[0].id
+    mocked.assert_called_once_with([str(inbound_sms_id), str(service.id)], queue="notify-internal-tasks")
 
 
 def test_receive_notification_from_firetext_persists_message(notify_db_session, client, mocker):
+    mocked = mocker.patch("app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
     mocker.patch('app.notifications.receive_notifications.statsd_client.incr')
 
     service = create_service(service_name='b', sms_sender='07111111111')
@@ -139,9 +148,11 @@ def test_receive_notification_from_firetext_persists_message(notify_db_session,
     assert persisted.content == 'this is a message'
     assert persisted.provider == 'firetext'
     assert persisted.provider_date == datetime(2017, 1, 1, 12, 0, 0, 0)
+    mocked.assert_called_once_with([str(persisted.id), str(service.id)], queue="notify-internal-tasks")
 
 
 def test_receive_notification_from_firetext_persists_message_with_normalized_phone(notify_db_session, client, mocker):
+    mocker.patch("app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
     mock = mocker.patch('app.notifications.receive_notifications.statsd_client.incr')
 
     create_service(service_name='b', sms_sender='07111111111')
@@ -163,6 +174,7 @@ def test_receive_notification_from_firetext_persists_message_with_normalized_pho
 
 
 def test_returns_ok_to_firetext_if_mismatched_sms_sender(notify_db_session, client, mocker):
+    mocked = mocker.patch("app.notifications.receive_notifications.tasks.send_inbound_sms_to_service.apply_async")
     mock = mocker.patch('app.notifications.receive_notifications.statsd_client.incr')
 
     create_service(service_name='b', sms_sender='07111111199')
@@ -180,6 +192,7 @@ def test_returns_ok_to_firetext_if_mismatched_sms_sender(notify_db_session, clie
     assert not InboundSms.query.all()
     assert result['status'] == 'ok'
     mock.assert_has_calls([call('inbound.firetext.failed')])
+    mocked.call_count == 0
 
 
 @pytest.mark.parametrize(