darkhelm/notifications-api
1
0
Fork 0
mirror of https://github.com/GSA/notifications-api.git synced 2026-08-18 21:48:49 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3035 from alphagov/broadcast-event-response

Browse Source 
Send broadcast events per provider
This commit is contained in:
Leo Hemsted
2020-11-25 10:16:30 +00:00
committed by GitHub
parent 928b62e079 087cc5053d
commit 54fecf2182
13 changed files with 447 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
tests/app/celery/test_broadcast_message_tasks.py
View File

@@ -1,13 +1,38 @@
import uuid
from unittest.mock import call, ANY
from freezegun import freeze_time
import pytest
from app.models import BROADCAST_TYPE, BroadcastStatusType, BroadcastEventMessageType
from app.celery.broadcast_message_tasks import send_broadcast_event
from tests.app.db import create_template, create_broadcast_message, create_broadcast_event
from app.models import BROADCAST_TYPE, BroadcastStatusType, BroadcastEventMessageType, BroadcastProviderMessageStatus
from app.celery.broadcast_message_tasks import send_broadcast_event, send_broadcast_provider_message, trigger_link_test
from tests.app.db import (
create_template,
create_broadcast_message,
create_broadcast_event,
create_broadcast_provider_message
)
from tests.conftest import set_config
def test_send_broadcast_event_queues_up_for_active_providers(mocker, notify_api):
mock_send_broadcast_provider_message = mocker.patch(
'app.celery.broadcast_message_tasks.send_broadcast_provider_message',
)
event_id = uuid.uuid4()
with set_config(notify_api, 'ENABLED_CBCS', ['ee', 'vodafone']):
send_broadcast_event(event_id)
assert mock_send_broadcast_provider_message.apply_async.call_args_list == [
call(kwargs={'broadcast_event_id': event_id, 'provider': 'ee'}, queue='notify-internal-tasks'),
call(kwargs={'broadcast_event_id': event_id, 'provider': 'vodafone'}, queue='notify-internal-tasks')
]
@freeze_time('2020-08-01 12:00')
def test_create_broadcast_event_sends_data_correctly(mocker, sample_service):
def test_send_broadcast_provider_message_sends_data_correctly(mocker, sample_service):
template = create_template(sample_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template,
@@ -23,13 +48,18 @@ def test_create_broadcast_event_sends_data_correctly(mocker, sample_service):
event = create_broadcast_event(broadcast_message)
mock_create_broadcast = mocker.patch(
'app.cbc_proxy_client.create_and_send_broadcast',
'app.clients.cbc_proxy.CBCProxyEE.create_and_send_broadcast',
)
send_broadcast_event(broadcast_event_id=str(event.id))
assert event.get_provider_message('ee') is None
send_broadcast_provider_message(provider='ee', broadcast_event_id=str(event.id))
broadcast_provider_message = event.get_provider_message('ee')
assert broadcast_provider_message.status == BroadcastProviderMessageStatus.SENDING
mock_create_broadcast.assert_called_once_with(
identifier=str(event.id),
identifier=str(broadcast_provider_message.id),
headline='GOV.UK Notify Broadcast',
description='this is an emergency broadcast message',
areas=[{
@@ -46,7 +76,7 @@ def test_create_broadcast_event_sends_data_correctly(mocker, sample_service):
)
def test_update_broadcast_event_sends_references(mocker, sample_service):
def test_send_broadcast_provider_message_sends_update_with_references(mocker, sample_service):
template = create_template(sample_service, BROADCAST_TYPE, content='content')
broadcast_message = create_broadcast_message(
@@ -61,28 +91,34 @@ def test_update_broadcast_event_sends_references(mocker, sample_service):
)
alert_event = create_broadcast_event(broadcast_message, message_type=BroadcastEventMessageType.ALERT)
create_broadcast_provider_message(alert_event, 'ee')
update_event = create_broadcast_event(broadcast_message, message_type=BroadcastEventMessageType.UPDATE)
mock_update_broadcast = mocker.patch(
'app.cbc_proxy_client.update_and_send_broadcast',
'app.clients.cbc_proxy.CBCProxyEE.update_and_send_broadcast',
)
send_broadcast_event(broadcast_event_id=str(update_event.id))
send_broadcast_provider_message(provider='ee', broadcast_event_id=str(update_event.id))
broadcast_provider_message = update_event.get_provider_message('ee')
assert broadcast_provider_message.status == BroadcastProviderMessageStatus.SENDING
mock_update_broadcast.assert_called_once_with(
identifier=str(update_event.id),
identifier=str(broadcast_provider_message.id),
headline="GOV.UK Notify Broadcast",
description='this is an emergency broadcast message',
areas=[{
"polygon": [[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]],
}],
references=[alert_event.reference],
previous_provider_messages=[
alert_event.get_provider_message('ee')
],
sent=update_event.sent_at_as_cap_datetime_string,
expires=update_event.transmitted_finishes_at_as_cap_datetime_string,
)
def test_cancel_broadcast_event_sends_references(mocker, sample_service):
def test_send_broadcast_provider_message_sends_cancel_with_references(mocker, sample_service):
template = create_template(sample_service, BROADCAST_TYPE, content='content')
broadcast_message = create_broadcast_message(
@@ -100,26 +136,35 @@ def test_cancel_broadcast_event_sends_references(mocker, sample_service):
update_event = create_broadcast_event(broadcast_message, message_type=BroadcastEventMessageType.UPDATE)
cancel_event = create_broadcast_event(broadcast_message, message_type=BroadcastEventMessageType.CANCEL)
create_broadcast_provider_message(alert_event, 'ee')
create_broadcast_provider_message(update_event, 'ee')
mock_cancel_broadcast = mocker.patch(
'app.cbc_proxy_client.cancel_broadcast',
'app.clients.cbc_proxy.CBCProxyEE.cancel_broadcast',
)
send_broadcast_event(broadcast_event_id=str(cancel_event.id))
send_broadcast_provider_message(provider='ee', broadcast_event_id=str(cancel_event.id))
broadcast_provider_message = cancel_event.get_provider_message('ee')
assert broadcast_provider_message.status == BroadcastProviderMessageStatus.SENDING
mock_cancel_broadcast.assert_called_once_with(
identifier=str(cancel_event.id),
identifier=str(broadcast_provider_message.id),
headline="GOV.UK Notify Broadcast",
description='this is an emergency broadcast message',
areas=[{
"polygon": [[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]],
}],
references=[alert_event.reference, update_event.reference],
previous_provider_messages=[
alert_event.get_provider_message('ee'),
update_event.get_provider_message('ee')
],
sent=cancel_event.sent_at_as_cap_datetime_string,
expires=cancel_event.transmitted_finishes_at_as_cap_datetime_string,
)
def test_send_broadcast_event_errors(mocker, sample_service):
def test_send_broadcast_provider_message_errors(mocker, sample_service):
template = create_template(sample_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
@@ -136,17 +181,17 @@ def test_send_broadcast_event_errors(mocker, sample_service):
event = create_broadcast_event(broadcast_message)
mock_create_broadcast = mocker.patch(
'app.cbc_proxy_client.create_and_send_broadcast',
'app.clients.cbc_proxy.CBCProxyEE.create_and_send_broadcast',
side_effect=Exception('oh no'),
)
with pytest.raises(Exception) as ex:
send_broadcast_event(broadcast_event_id=str(event.id))
send_broadcast_provider_message(provider='ee', broadcast_event_id=str(event.id))
assert ex.match('oh no')
mock_create_broadcast.assert_called_once_with(
identifier=str(event.id),
identifier=ANY,
headline="GOV.UK Notify Broadcast",
description='this is an emergency broadcast message',
areas=[{
@@ -159,3 +204,22 @@ def test_send_broadcast_event_errors(mocker, sample_service):
sent=event.sent_at_as_cap_datetime_string,
expires=event.transmitted_finishes_at_as_cap_datetime_string,
)
def test_trigger_link_tests_invokes_cbc_proxy_client(
mocker,
):
mock_send_link_test = mocker.patch(
'app.clients.cbc_proxy.CBCProxyEE.send_link_test',
)
trigger_link_test('ee')
assert mock_send_link_test.called
# the 0th argument of the call to send_link_test
identifier = mock_send_link_test.mock_calls[0][1][0]
try:
uuid.UUID(identifier)
except BaseException:
pytest.fail(f"{identifier} is not a valid uuid")

29
tests/app/celery/test_scheduled_tasks.py
View File

@@ -19,6 +19,7 @@ from app.celery.scheduled_tasks import (
check_for_missing_rows_in_completed_jobs,
check_for_services_with_high_failure_rates_or_sending_to_tv_numbers,
switch_current_sms_provider_on_slow_delivery,
trigger_link_tests,
)
from app.config import QueueNames, Config
from app.dao.jobs_dao import dao_get_job_by_id
@@ -30,8 +31,8 @@ from app.models import (
NOTIFICATION_DELIVERED,
NOTIFICATION_PENDING_VIRUS_CHECK,
)
from tests.conftest import set_config
from tests.app import load_example_csv
from tests.app.db import (
create_notification,
create_template,
@@ -560,9 +561,10 @@ def test_check_for_services_with_high_failure_rates_or_sending_to_tv_numbers(
def test_send_canary_to_cbc_proxy_invokes_cbc_proxy_client(
mocker,
notify_api
):
mock_send_canary = mocker.patch(
'app.cbc_proxy_client.send_canary',
'app.clients.cbc_proxy.CBCProxyCanary.send_canary',
)
scheduled_tasks.send_canary_to_cbc_proxy()
@@ -577,20 +579,17 @@ def test_send_canary_to_cbc_proxy_invokes_cbc_proxy_client(
pytest.fail(f"{identifier} is not a valid uuid")
def test_trigger_link_tests_invokes_cbc_proxy_client(
mocker,
def test_trigger_link_tests_calls_for_all_providers(
mocker, notify_api
):
mock_send_link_test = mocker.patch(
'app.cbc_proxy_client.send_link_test',
mock_trigger_link_test = mocker.patch(
'app.celery.scheduled_tasks.trigger_link_test',
)
scheduled_tasks.trigger_link_tests()
with set_config(notify_api, 'ENABLED_CBCS', ['ee', 'vodafone']):
trigger_link_tests()
mock_send_link_test.assert_called
# the 0th argument of the call to send_link_test
identifier = mock_send_link_test.mock_calls[0][1][0]
try:
uuid.UUID(identifier)
except BaseException:
pytest.fail(f"{identifier} is not a valid uuid")
assert mock_trigger_link_test.apply_async.call_args_list == [
call(kwargs={'provider': 'ee'}, queue='notify-internal-tasks'),
call(kwargs={'provider': 'vodafone'}, queue='notify-internal-tasks')
]

177
tests/app/clients/test_cbc_proxy.py
View File

@@ -1,13 +1,14 @@
import json
import uuid
from unittest.mock import Mock
import pytest
from app.clients.cbc_proxy import CBCProxyClient, CBCProxyException
from app.clients.cbc_proxy import CBCProxyClient, CBCProxyException, CBCProxyEE, CBCProxyCanary
@pytest.fixture(scope='function')
def cbc_proxy(client, mocker):
def cbc_proxy_client(client, mocker):
client = CBCProxyClient()
current_app = mocker.Mock(config={
'CBC_PROXY_AWS_ACCESS_KEY_ID': 'cbc-proxy-aws-access-key-id',
@@ -17,19 +18,39 @@ def cbc_proxy(client, mocker):
return client
def test_cbc_proxy_lambda_client_has_correct_region(cbc_proxy):
assert cbc_proxy._lambda_client._client_config.region_name == 'eu-west-2'
@pytest.fixture
def cbc_proxy_ee(cbc_proxy_client):
return cbc_proxy_client.get_proxy('ee')
def test_cbc_proxy_lambda_client_has_correct_keys(cbc_proxy):
key = cbc_proxy._lambda_client._request_signer._credentials.access_key
secret = cbc_proxy._lambda_client._request_signer._credentials.secret_key
@pytest.mark.parametrize('provider_name, expected_provider_class', [
('ee', CBCProxyEE),
('canary', CBCProxyCanary),
])
def test_cbc_proxy_client_returns_correct_client(provider_name, expected_provider_class):
mock_lambda = Mock()
cbc_proxy_client = CBCProxyClient()
cbc_proxy_client._lambda_client = mock_lambda
ret = cbc_proxy_client.get_proxy(provider_name)
assert type(ret) == expected_provider_class
assert ret._lambda_client == mock_lambda
def test_cbc_proxy_lambda_client_has_correct_region(cbc_proxy_ee):
assert cbc_proxy_ee._lambda_client._client_config.region_name == 'eu-west-2'
def test_cbc_proxy_lambda_client_has_correct_keys(cbc_proxy_ee):
key = cbc_proxy_ee._lambda_client._request_signer._credentials.access_key
secret = cbc_proxy_ee._lambda_client._request_signer._credentials.secret_key
assert key == 'cbc-proxy-aws-access-key-id'
assert secret == 'cbc-proxy-aws-secret-access-key'
def test_cbc_proxy_create_and_send_invokes_function(mocker, cbc_proxy):
def test_cbc_proxy_create_and_send_invokes_function(mocker, cbc_proxy_ee):
identifier = 'my-identifier'
headline = 'my-headline'
description = 'my-description'
@@ -50,7 +71,7 @@ def test_cbc_proxy_create_and_send_invokes_function(mocker, cbc_proxy):
}]
ld_client_mock = mocker.patch.object(
cbc_proxy,
cbc_proxy_ee,
'_lambda_client',
create=True,
)
@@ -59,7 +80,7 @@ def test_cbc_proxy_create_and_send_invokes_function(mocker, cbc_proxy):
'StatusCode': 200,
}
cbc_proxy.create_and_send_broadcast(
cbc_proxy_ee.create_and_send_broadcast(
identifier=identifier,
headline=headline,
description=description,
@@ -86,7 +107,7 @@ def test_cbc_proxy_create_and_send_invokes_function(mocker, cbc_proxy):
assert payload['expires'] == expires
def test_cbc_proxy_create_and_send_handles_invoke_error(mocker, cbc_proxy):
def test_cbc_proxy_create_and_send_handles_invoke_error(mocker, cbc_proxy_ee):
identifier = 'my-identifier'
headline = 'my-headline'
description = 'my-description'
@@ -107,7 +128,7 @@ def test_cbc_proxy_create_and_send_handles_invoke_error(mocker, cbc_proxy):
}]
ld_client_mock = mocker.patch.object(
cbc_proxy,
cbc_proxy_ee,
'_lambda_client',
create=True,
)
@@ -117,7 +138,7 @@ def test_cbc_proxy_create_and_send_handles_invoke_error(mocker, cbc_proxy):
}
with pytest.raises(CBCProxyException) as e:
cbc_proxy.create_and_send_broadcast(
cbc_proxy_ee.create_and_send_broadcast(
identifier=identifier,
headline=headline,
description=description,
@@ -134,7 +155,7 @@ def test_cbc_proxy_create_and_send_handles_invoke_error(mocker, cbc_proxy):
)
def test_cbc_proxy_create_and_send_handles_function_error(mocker, cbc_proxy):
def test_cbc_proxy_create_and_send_handles_function_error(mocker, cbc_proxy_ee):
identifier = 'my-identifier'
headline = 'my-headline'
description = 'my-description'
@@ -155,7 +176,7 @@ def test_cbc_proxy_create_and_send_handles_function_error(mocker, cbc_proxy):
}]
ld_client_mock = mocker.patch.object(
cbc_proxy,
cbc_proxy_ee,
'_lambda_client',
create=True,
)
@@ -166,7 +187,7 @@ def test_cbc_proxy_create_and_send_handles_function_error(mocker, cbc_proxy):
}
with pytest.raises(CBCProxyException) as e:
cbc_proxy.create_and_send_broadcast(
cbc_proxy_ee.create_and_send_broadcast(
identifier=identifier,
headline=headline,
description=description,
@@ -183,11 +204,13 @@ def test_cbc_proxy_create_and_send_handles_function_error(mocker, cbc_proxy):
)
def test_cbc_proxy_send_canary_invokes_function(mocker, cbc_proxy):
def test_cbc_proxy_send_canary_invokes_function(mocker, cbc_proxy_client):
identifier = str(uuid.uuid4())
canary_client = cbc_proxy_client.get_proxy('canary')
ld_client_mock = mocker.patch.object(
cbc_proxy,
canary_client,
'_lambda_client',
create=True,
)
@@ -196,7 +219,7 @@ def test_cbc_proxy_send_canary_invokes_function(mocker, cbc_proxy):
'StatusCode': 200,
}
cbc_proxy.send_canary(
canary_client.send_canary(
identifier=identifier,
)
@@ -213,66 +236,11 @@ def test_cbc_proxy_send_canary_invokes_function(mocker, cbc_proxy):
assert payload['identifier'] == identifier
def test_cbc_proxy_send_canary_handles_invoke_error(mocker, cbc_proxy):
def test_cbc_proxy_send_link_test_invokes_function(mocker, cbc_proxy_ee):
identifier = str(uuid.uuid4())
ld_client_mock = mocker.patch.object(
cbc_proxy,
'_lambda_client',
create=True,
)
ld_client_mock.invoke.return_value = {
'StatusCode': 400,
}
with pytest.raises(CBCProxyException) as e:
cbc_proxy.send_canary(
identifier=identifier,
)
assert e.match('Could not invoke lambda')
ld_client_mock.invoke.assert_called_once_with(
FunctionName='canary',
InvocationType='RequestResponse',
Payload=mocker.ANY,
)
def test_cbc_proxy_send_canary_handles_function_error(mocker, cbc_proxy):
identifier = str(uuid.uuid4())
ld_client_mock = mocker.patch.object(
cbc_proxy,
'_lambda_client',
create=True,
)
ld_client_mock.invoke.return_value = {
'StatusCode': 200,
'FunctionError': 'something',
}
with pytest.raises(CBCProxyException) as e:
cbc_proxy.send_canary(
identifier=identifier,
)
assert e.match('Function exited with unhandled exception')
ld_client_mock.invoke.assert_called_once_with(
FunctionName='canary',
InvocationType='RequestResponse',
Payload=mocker.ANY,
)
def test_cbc_proxy_send_link_test_invokes_function(mocker, cbc_proxy):
identifier = str(uuid.uuid4())
ld_client_mock = mocker.patch.object(
cbc_proxy,
cbc_proxy_ee,
'_lambda_client',
create=True,
)
@@ -281,7 +249,7 @@ def test_cbc_proxy_send_link_test_invokes_function(mocker, cbc_proxy):
'StatusCode': 200,
}
cbc_proxy.send_link_test(
cbc_proxy_ee.send_link_test(
identifier=identifier,
)
@@ -297,58 +265,3 @@ def test_cbc_proxy_send_link_test_invokes_function(mocker, cbc_proxy):
assert payload['identifier'] == identifier
assert payload['message_type'] == 'test'
def test_cbc_proxy_send_link_test_handles_invoke_error(mocker, cbc_proxy):
identifier = str(uuid.uuid4())
ld_client_mock = mocker.patch.object(
cbc_proxy,
'_lambda_client',
create=True,
)
ld_client_mock.invoke.return_value = {
'StatusCode': 400,
}
with pytest.raises(CBCProxyException) as e:
cbc_proxy.send_link_test(
identifier=identifier,
)
assert e.match('Could not invoke lambda')
ld_client_mock.invoke.assert_called_once_with(
FunctionName='bt-ee-1-proxy',
InvocationType='RequestResponse',
Payload=mocker.ANY,
)
def test_cbc_proxy_send_link_test_handles_function_error(mocker, cbc_proxy):
identifier = str(uuid.uuid4())
ld_client_mock = mocker.patch.object(
cbc_proxy,
'_lambda_client',
create=True,
)
ld_client_mock.invoke.return_value = {
'StatusCode': 200,
'FunctionError': 'something',
}
with pytest.raises(CBCProxyException) as e:
cbc_proxy.send_link_test(
identifier=identifier,
)
assert e.match('Function exited with unhandled exception')
ld_client_mock.invoke.assert_called_once_with(
FunctionName='bt-ee-1-proxy',
InvocationType='RequestResponse',
Payload=mocker.ANY,
)

24
tests/app/dao/test_broadcast_message_dao.py
View File

@@ -1,7 +1,7 @@
from datetime import datetime
from app.models import BROADCAST_TYPE
from app.models import BroadcastEventMessageType
from app.dao.broadcast_message_dao import get_earlier_events_for_broadcast_event
from app.models import BROADCAST_TYPE, BroadcastEventMessageType
from app.dao.broadcast_message_dao import get_earlier_events_for_broadcast_event, create_broadcast_provider_message
from tests.app.db import create_broadcast_message, create_template, create_broadcast_event
@@ -41,3 +41,21 @@ def test_get_earlier_events_for_broadcast_event(sample_service):
# only fetches earlier events, and they're in time order
earlier_events = get_earlier_events_for_broadcast_event(events[2].id)
assert earlier_events == [events[0], events[1]]
def test_create_broadcast_provider_message_creates_in_correct_state(sample_broadcast_service):
t = create_template(sample_broadcast_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(t)
broadcast_event = create_broadcast_event(
broadcast_message,
sent_at=datetime(2020, 1, 1, 12, 0, 0),
message_type=BroadcastEventMessageType.ALERT,
transmitted_content={'body': 'Initial content'}
)
broadcast_provider_message = create_broadcast_provider_message(broadcast_event, 'fake-provider')
assert broadcast_provider_message.status == 'sending'
assert broadcast_provider_message.broadcast_event_id == broadcast_event.id
assert broadcast_provider_message.created_at is not None
assert broadcast_provider_message.updated_at is None

18
tests/app/db.py
View File

@@ -62,7 +62,8 @@ from app.models import (
ServiceContactList,
BroadcastMessage,
BroadcastStatusType,
BroadcastEvent
BroadcastEvent,
BroadcastProviderMessage
)
@@ -1050,3 +1051,18 @@ def create_broadcast_event(
db.session.add(b_e)
db.session.commit()
return b_e
def create_broadcast_provider_message(
broadcast_event,
provider,
status='sending'
):
provider_message = BroadcastProviderMessage(
broadcast_event=broadcast_event,
provider=provider,
status=status
)
db.session.add(provider_message)
db.session.commit()
return provider_message