def test_get_broadcast_messages_for_service(admin_request, sample_service):
t = create_template(sample_service, BROADCAST_TYPE)
with freeze_time('2020-01-01 12:00'):
bm1 = create_broadcast_message(t, personalisation={'foo': 'bar'})
with freeze_time('2020-01-01 13:00'):
bm2 = create_broadcast_message(t, personalisation={'foo': 'baz'})
response = admin_request.get(
'broadcast_message.get_broadcast_messages_for_service',
service_id=t.service_id,
_expected_status=200)
assert response['broadcast_messages'][0]['id'] == str(bm1.id)
assert response['broadcast_messages'][1]['id'] == str(bm2.id)
def test_send_broadcast_provider_message_uses_channel_set_on_broadcast_service(
notify_db, mocker, sample_broadcast_service, provider, provider_capitalised, channel
):
sample_broadcast_service.broadcast_channel = channel
template = create_template(sample_broadcast_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template,
areas={
'areas': ['london', 'glasgow'],
'simple_polygons': [
[[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]],
[[-4.53, 55.72], [-3.88, 55.72], [-3.88, 55.96], [-4.53, 55.96]],
],
},
status=BroadcastStatusType.BROADCASTING
)
event = create_broadcast_event(broadcast_message)
mock_create_broadcast = mocker.patch(
f'app.clients.cbc_proxy.CBCProxy{provider_capitalised}.create_and_send_broadcast',
)
send_broadcast_provider_message(provider=provider, broadcast_event_id=str(event.id))
mock_create_broadcast.assert_called_once_with(
identifier=mocker.ANY,
message_number=mocker.ANY,
headline='GOV.UK Notify Broadcast',
description='this is an emergency broadcast message',
areas=mocker.ANY,
sent=mocker.ANY,
expires=mocker.ANY,
channel=channel,
)
def test_send_broadcast_event_creates_zendesk_p1(mocker, notify_api, sample_broadcast_service):
template = create_template(sample_broadcast_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template,
status=BroadcastStatusType.BROADCASTING,
areas={'areas': ['wd20-S13002775', 'wd20-S13002773'], 'simple_polygons': []},
)
event = create_broadcast_event(broadcast_message)
mock_create_ticket = mocker.patch("app.celery.broadcast_message_tasks.zendesk_client.create_ticket")
mocker.patch('app.celery.broadcast_message_tasks.send_broadcast_provider_message')
with set_config(notify_api, 'NOTIFY_ENVIRONMENT', 'live'):
send_broadcast_event(event.id)
assert mock_create_ticket.call_count == 1
zendesk_args = mock_create_ticket.call_args[1]
assert zendesk_args['p1'] is True
assert zendesk_args['ticket_type'] == 'incident'
assert str(broadcast_message.id) in zendesk_args['message']
assert 'channel severe' in zendesk_args['message']
assert "areas ['wd20-S13002775', 'wd20-S13002773']" in zendesk_args['message']
# the start of the content from the broadcast template
assert "Dear Sir/Madam" in zendesk_args['message']
def test_send_broadcast_message_sends_old_version_of_template(sample_service):
template = create_template(sample_service,
BROADCAST_TYPE,
content='first content')
broadcast_message = create_broadcast_message(
template, areas=['london'], status=BroadcastStatusType.BROADCASTING)
template.content = 'second content'
dao_update_template(template)
assert template.version == 2
with requests_mock.Mocker() as request_mock:
request_mock.post("http://test-cbc-proxy/broadcasts/stub-1",
json={'valid': 'true'},
status_code=200)
send_broadcast_message(broadcast_message_id=str(broadcast_message.id))
assert request_mock.call_count == 1
assert request_mock.request_history[0].method == 'POST'
assert request_mock.request_history[0].headers[
"Content-type"] == "application/json"
cbc_json = request_mock.request_history[0].json()
assert cbc_json['template']['id'] == str(template.id)
assert cbc_json['template']['version'] == 1
assert cbc_json['template']['content'] == 'first content'
def test_cancel_broadcast_event_sends_references(mocker, sample_service):
template = create_template(sample_service, BROADCAST_TYPE, content='content')
broadcast_message = create_broadcast_message(
template,
areas={
'areas': ['london'],
'simple_polygons': [
[[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]],
],
},
status=BroadcastStatusType.BROADCASTING
)
alert_event = create_broadcast_event(broadcast_message, message_type=BroadcastEventMessageType.ALERT)
update_event = create_broadcast_event(broadcast_message, message_type=BroadcastEventMessageType.UPDATE)
cancel_event = create_broadcast_event(broadcast_message, message_type=BroadcastEventMessageType.CANCEL)
mock_cancel_broadcast = mocker.patch(
'app.cbc_proxy_client.cancel_broadcast',
)
send_broadcast_event(broadcast_event_id=str(cancel_event.id))
mock_cancel_broadcast.assert_called_once_with(
identifier=str(cancel_event.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],
sent=cancel_event.sent_at_as_cap_datetime_string,
expires=cancel_event.transmitted_finishes_at_as_cap_datetime_string,
)
def test_update_broadcast_message_status_allows_platform_admin_to_approve_own_message(
notify_db, admin_request, sample_service, mocker):
user = sample_service.created_by
user.platform_admin = True
t = create_template(sample_service, BROADCAST_TYPE)
bm = create_broadcast_message(t,
status=BroadcastStatusType.PENDING_APPROVAL)
mock_task = mocker.patch(
'app.celery.broadcast_message_tasks.send_broadcast_event.apply_async')
response = admin_request.post(
'broadcast_message.update_broadcast_message_status',
_data={
'status': BroadcastStatusType.BROADCASTING,
'created_by': str(user.id)
},
service_id=t.service_id,
broadcast_message_id=bm.id,
_expected_status=200)
assert response['status'] == BroadcastStatusType.BROADCASTING
assert response['approved_at'] is not None
assert response['created_by_id'] == str(user.id)
assert response['approved_by_id'] == str(user.id)
mock_task.assert_called_once_with(
kwargs={'broadcast_event_id': str(bm.events[0].id)},
queue='notify-internal-tasks')
def test_send_broadcast_provider_message_sends_data_correctly_when_broadcast_message_has_no_template(
mocker, sample_broadcast_service, provider, provider_capitalised):
broadcast_message = create_broadcast_message(
service=sample_broadcast_service,
template=None,
content='this is an emergency broadcast message',
areas={
'areas': ['london', 'glasgow'],
'simple_polygons': [
[[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]],
[[-4.53, 55.72], [-3.88, 55.72], [-3.88, 55.96],
[-4.53, 55.96]],
],
},
status=BroadcastStatusType.BROADCASTING)
event = create_broadcast_event(broadcast_message)
mock_create_broadcast = mocker.patch(
f'app.clients.cbc_proxy.CBCProxy{provider_capitalised}.create_and_send_broadcast',
)
send_broadcast_provider_message(provider=provider,
broadcast_event_id=str(event.id))
broadcast_provider_message = event.get_provider_message(provider)
mock_create_broadcast.assert_called_once_with(
identifier=str(broadcast_provider_message.id),
message_number=mocker.ANY,
headline='GOV.UK Notify Broadcast',
description='this is an emergency broadcast message',
areas=mocker.ANY,
sent=mocker.ANY,
expires=mocker.ANY,
channel="severe")
def test_update_broadcast_message_status_allows_trial_mode_services_to_approve_own_message(
notify_db, admin_request, sample_broadcast_service, mocker):
sample_broadcast_service.restricted = True
t = create_template(sample_broadcast_service, BROADCAST_TYPE)
bm = create_broadcast_message(t,
status=BroadcastStatusType.PENDING_APPROVAL,
areas={
"areas": ["london"],
"simple_polygons": [[[51.30, 0.7],
[51.28, 0.8],
[51.25, -0.7]]]
})
mock_task = mocker.patch(
'app.celery.broadcast_message_tasks.send_broadcast_event.apply_async')
response = admin_request.post(
'broadcast_message.update_broadcast_message_status',
_data={
'status': BroadcastStatusType.BROADCASTING,
'created_by': str(t.created_by_id)
},
service_id=t.service_id,
broadcast_message_id=bm.id,
_expected_status=200)
assert response['status'] == BroadcastStatusType.BROADCASTING
assert response['approved_at'] is not None
assert response['created_by_id'] == str(t.created_by_id)
assert response['approved_by_id'] == str(t.created_by_id)
mock_task.assert_called_once_with(kwargs={'broadcast_event_id': ANY},
queue='notify-internal-tasks')
def test_send_broadcast_event_queues_up_for_active_providers(
mocker, notify_api, sample_service):
template = create_template(sample_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template, status=BroadcastStatusType.BROADCASTING)
event = create_broadcast_event(broadcast_message)
mock_send_broadcast_provider_message = mocker.patch(
'app.celery.broadcast_message_tasks.send_broadcast_provider_message', )
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')
]
def test_update_broadcast_message_allows_edit_while_not_yet_live(
admin_request, sample_broadcast_service, status):
t = create_template(sample_broadcast_service, BROADCAST_TYPE)
bm = create_broadcast_message(t,
areas={
"areas": ['manchester'],
"simple_polygons": [[[50.12, 1.2],
[50.13, 1.2],
[50.14, 1.21]]]
},
status=status)
response = admin_request.post('broadcast_message.update_broadcast_message',
_data={
'starts_at':
'2020-06-01 20:00:01',
'areas': ['london', 'glasgow'],
"simple_polygons": [[[51.12, 0.2],
[50.13, 0.4],
[50.14, 0.45]]]
},
service_id=t.service_id,
broadcast_message_id=bm.id,
_expected_status=200)
assert response['starts_at'] == '2020-06-01T20:00:01.000000Z'
assert response['areas'] == ['london', 'glasgow']
assert response['simple_polygons'] == [[[51.12, 0.2], [50.13, 0.4],
[50.14, 0.45]]]
assert response['updated_at'] is not None
def test_get_broadcast_message_without_template(admin_request,
sample_broadcast_service):
bm = create_broadcast_message(
service=sample_broadcast_service,
content='emergency broadcast content',
areas={
"areas": ['place A', 'region B'],
"simple_polygons": [[[50.1, 1.2], [50.12, 1.2], [50.13, 1.2]]],
},
)
response = admin_request.get('broadcast_message.get_broadcast_message',
service_id=sample_broadcast_service.id,
broadcast_message_id=bm.id,
_expected_status=200)
assert response['id'] == str(bm.id)
assert response['template_id'] is None
assert response['template_version'] is None
assert response['template_name'] is None
assert response['content'] == 'emergency broadcast content'
assert response['status'] == BroadcastStatusType.DRAFT
assert response['created_at'] is not None
assert response['starts_at'] is None
assert response['areas'] == ['place A', 'region B']
assert response['personalisation'] is None
def test_send_broadcast_event_only_sends_to_one_provider_if_set_on_service(
mocker, notify_db, notify_api, sample_service):
settings = ServiceBroadcastSettings(service=sample_service,
channel="test",
provider="vodafone")
notify_db.session.add(settings)
template = create_template(sample_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template, status=BroadcastStatusType.BROADCASTING)
event = create_broadcast_event(broadcast_message)
mock_send_broadcast_provider_message = mocker.patch(
'app.celery.broadcast_message_tasks.send_broadcast_provider_message', )
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': 'vodafone'
},
queue='broadcast-tasks')
]
def test_send_broadcast_event_sends_references(sample_service):
template = create_template(sample_service,
BROADCAST_TYPE,
content='content')
broadcast_message = create_broadcast_message(
template, areas=['london'], status=BroadcastStatusType.BROADCASTING)
alert_event = create_broadcast_event(
broadcast_message, message_type=BroadcastEventMessageType.ALERT)
cancel_event = create_broadcast_event(
broadcast_message, message_type=BroadcastEventMessageType.CANCEL)
with requests_mock.Mocker() as request_mock:
request_mock.post("http://test-cbc-proxy/broadcasts/events/stub-1",
json={'valid': 'true'},
status_code=200)
send_broadcast_event(broadcast_event_id=str(cancel_event.id))
assert request_mock.call_count == 1
assert request_mock.request_history[0].method == 'POST'
assert request_mock.request_history[0].headers[
"Content-type"] == "application/json"
cbc_json = request_mock.request_history[0].json()
assert cbc_json['id'] == str(cancel_event.id)
assert cbc_json['message_type'] == cancel_event.message_type
assert cbc_json['previous_event_references'] == [alert_event.reference]
def test_get_earlier_events_for_broadcast_event(sample_service):
t = create_template(sample_service, BROADCAST_TYPE)
bm = create_broadcast_message(t)
events = [
create_broadcast_event(bm,
sent_at=datetime(2020, 1, 1, 12, 0, 0),
message_type=BroadcastEventMessageType.ALERT,
transmitted_content={'body':
'Initial content'}),
create_broadcast_event(bm,
sent_at=datetime(2020, 1, 1, 13, 0, 0),
message_type=BroadcastEventMessageType.UPDATE,
transmitted_content={'body':
'Updated content'}),
create_broadcast_event(bm,
sent_at=datetime(2020, 1, 1, 14, 0, 0),
message_type=BroadcastEventMessageType.UPDATE,
transmitted_content={'body': 'Updated content'},
transmitted_areas=['wales']),
create_broadcast_event(
bm,
sent_at=datetime(2020, 1, 1, 15, 0, 0),
message_type=BroadcastEventMessageType.CANCEL,
transmitted_finishes_at=datetime(2020, 1, 1, 15, 0, 0),
)
]
# 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_get_broadcast_message(admin_request, sample_broadcast_service):
t = create_template(sample_broadcast_service,
BROADCAST_TYPE,
content='This is a ((thing))')
bm = create_broadcast_message(
t,
areas={
"areas": ['place A', 'region B'],
"simple_polygons": [[[50.1, 1.2], [50.12, 1.2], [50.13, 1.2]]],
},
personalisation={
'thing': 'test',
},
)
response = admin_request.get('broadcast_message.get_broadcast_message',
service_id=t.service_id,
broadcast_message_id=bm.id,
_expected_status=200)
assert response['id'] == str(bm.id)
assert response['template_id'] == str(t.id)
assert response['content'] == 'This is a test'
assert response['template_name'] == t.name
assert response['status'] == BroadcastStatusType.DRAFT
assert response['created_at'] is not None
assert response['starts_at'] is None
assert response['areas'] == ['place A', 'region B']
assert response['personalisation'] == {'thing': 'test'}
def test_send_broadcast_event_sends_data_correctly(sample_service):
template = create_template(sample_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template,
areas={
"areas": ['london'],
"simple_polygons": [[[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]]]
},
status=BroadcastStatusType.BROADCASTING)
event = create_broadcast_event(broadcast_message)
with requests_mock.Mocker() as request_mock:
request_mock.post("http://test-cbc-proxy/broadcasts/events/stub-1",
json={'valid': 'true'},
status_code=200)
send_broadcast_event(broadcast_event_id=str(event.id))
assert request_mock.call_count == 1
assert request_mock.request_history[0].method == 'POST'
assert request_mock.request_history[0].headers[
"Content-type"] == "application/json"
cbc_json = request_mock.request_history[0].json()
assert cbc_json['id'] == str(event.id)
assert cbc_json['broadcast_message_id'] == str(broadcast_message.id)
assert cbc_json['sent_at'] == '2020-08-01T12:00:00.000000Z'
assert cbc_json['transmitted_starts_at'] is None
assert cbc_json['transmitted_areas'] == {
"areas": ['london'],
"simple_polygons": [[[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]]]
}
def test_send_broadcast_event_doesnt_p1_when_cancelling(
mocker, notify_api, sample_broadcast_service):
template = create_template(sample_broadcast_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template,
status=BroadcastStatusType.BROADCASTING,
areas={
'areas': ['wd20-S13002775', 'wd20-S13002773'],
'simple_polygons': []
},
)
create_broadcast_event(broadcast_message,
message_type=BroadcastEventMessageType.ALERT)
cancel_event = create_broadcast_event(
broadcast_message, message_type=BroadcastEventMessageType.CANCEL)
mock_create_ticket = mocker.patch(
"app.celery.broadcast_message_tasks.zendesk_client.create_ticket")
mocker.patch(
'app.celery.broadcast_message_tasks.send_broadcast_provider_message')
with set_config(notify_api, 'NOTIFY_ENVIRONMENT', 'live'):
send_broadcast_event(cancel_event.id)
assert mock_create_ticket.called is False
def test_check_provider_message_should_send_raises_if_older_event_hasnt_started_sending_yet(sample_template):
broadcast_message = create_broadcast_message(sample_template)
# event approved at midnight
past_succesful_event = create_broadcast_event(
broadcast_message,
message_type='alert',
sent_at=datetime(2021, 1, 1, 0, 0),
)
# event updated at 5am
past_still_sending_event = create_broadcast_event(
broadcast_message,
message_type='update',
sent_at=datetime(2021, 1, 1, 5, 0),
)
# event updated at 7am
current_event = create_broadcast_event(
broadcast_message,
message_type='update',
sent_at=datetime(2021, 1, 1, 7, 0),
)
# no provider message for past_still_sending_event
create_broadcast_provider_message(past_succesful_event, provider='ee', status=BroadcastProviderMessageStatus.ACK)
# we shouldn't send the update now, because a previous event is still stuck in sending
with pytest.raises(CBCProxyFatalException) as exc:
check_provider_message_should_send(current_event, 'ee')
assert f'Previous event {past_still_sending_event.id} (type update) has no provider_message for provider ee' in str(exc.value) # noqa
def test_check_provider_message_should_send_raises_if_older_event_still_sending(sample_template):
broadcast_message = create_broadcast_message(sample_template)
# event approved at midnight
past_succesful_event = create_broadcast_event(
broadcast_message,
message_type='alert',
sent_at=datetime(2021, 1, 1, 0, 0),
)
# event updated at 5am (this event is still sending)
past_still_sending_event = create_broadcast_event(
broadcast_message,
message_type='update',
sent_at=datetime(2021, 1, 1, 5, 0),
)
# event updated again at 7am
current_event = create_broadcast_event(
broadcast_message,
message_type='update',
sent_at=datetime(2021, 1, 1, 7, 0),
)
create_broadcast_provider_message(past_succesful_event, provider='ee', status=BroadcastProviderMessageStatus.ACK)
create_broadcast_provider_message(past_still_sending_event, provider='ee', status=BroadcastProviderMessageStatus.SENDING) # noqa
# we havent sent the previous update yet - it's still in sending - so don't try and send this one.
with pytest.raises(CBCProxyFatalException) as exc:
check_provider_message_should_send(current_event, 'ee')
assert f'Previous event {past_still_sending_event.id} (type update) has not finished sending to provider ee' in str(exc.value) # noqa
def test_check_provider_message_should_send_doesnt_raise_if_event_hasnt_expired_yet(sample_template):
broadcast_message = create_broadcast_message(sample_template)
current_event = create_broadcast_event(
broadcast_message,
transmitted_starts_at=datetime(2021, 1, 1, 0, 0),
transmitted_finishes_at=datetime(2021, 1, 1, 12, 1),
)
check_provider_message_should_send(current_event, 'ee')
def test_check_provider_message_should_send_raises_if_event_has_expired(sample_template):
broadcast_message = create_broadcast_message(sample_template)
current_event = create_broadcast_event(
broadcast_message,
transmitted_starts_at=datetime(2021, 1, 1, 0, 0),
transmitted_finishes_at=datetime(2021, 1, 1, 11, 59),
)
with pytest.raises(CBCProxyFatalException) as exc:
check_provider_message_should_send(current_event, 'ee')
assert 'The expiry time of 2021-01-01 11:59:00 has already passed' in str(exc.value)
def test_check_provider_message_should_send_raises_if_current_event_already_has_provider_message_not_in_sending(
sample_template,
existing_message_status
):
broadcast_message = create_broadcast_message(sample_template)
current_event = create_broadcast_event(broadcast_message, message_type='alert')
create_broadcast_provider_message(current_event, provider='ee', status=existing_message_status)
check_provider_message_should_send(current_event, 'ee')
def test_get_broadcast_message_404s_if_message_is_for_different_service(
admin_request, sample_broadcast_service):
other_service = create_service(service_name='other')
other_template = create_template(other_service, BROADCAST_TYPE)
bm = create_broadcast_message(other_template)
err = admin_request.get('broadcast_message.get_broadcast_message',
service_id=sample_broadcast_service.id,
broadcast_message_id=bm.id,
_expected_status=404)
assert err == {'message': 'No result found', 'result': 'error'}
def test_update_broadcast_message_doesnt_allow_edits_after_broadcast_goes_live(
admin_request, sample_broadcast_service, status):
t = create_template(sample_broadcast_service, BROADCAST_TYPE)
bm = create_broadcast_message(t, areas=['manchester'], status=status)
response = admin_request.post('broadcast_message.update_broadcast_message',
_data={'areas': ['london', 'glasgow']},
service_id=t.service_id,
broadcast_message_id=bm.id,
_expected_status=400)
assert f'status {status}' in response['message']
def test_update_broadcast_message_doesnt_let_you_update_areas_but_not_polygons(
admin_request, sample_broadcast_service, incomplete_area_data):
template = create_template(sample_broadcast_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(template)
response = admin_request.post('broadcast_message.update_broadcast_message',
_data=incomplete_area_data,
service_id=template.service_id,
broadcast_message_id=broadcast_message.id,
_expected_status=400)
assert response[
'message'] == f'Cannot update broadcast_message {broadcast_message.id}, areas or polygons are missing.'
def test_update_broadcast_message_allows_sensible_datetime_formats(
admin_request, sample_broadcast_service, input_dt):
t = create_template(sample_broadcast_service, BROADCAST_TYPE)
bm = create_broadcast_message(t)
response = admin_request.post('broadcast_message.update_broadcast_message',
_data={'starts_at': input_dt},
service_id=t.service_id,
broadcast_message_id=bm.id,
_expected_status=200)
assert response['starts_at'] == '2020-06-01T20:00:01.000000Z'
assert response['updated_at'] is not None
def test_send_broadcast_provider_message_does_nothing_if_cbc_proxy_disabled(mocker, notify_api, sample_template):
mock_proxy_client_getter = mocker.patch(
'app.celery.broadcast_message_tasks.cbc_proxy_client',
)
mock_client = Mock()
mock_proxy_client_getter.get_proxy.return_value = mock_client
broadcast_message = create_broadcast_message(sample_template)
broadcast_event = create_broadcast_event(broadcast_message, message_type='alert')
with set_config(notify_api, 'ENABLED_CBCS', ['ee', 'vodafone']), set_config(notify_api, 'CBC_PROXY_ENABLED', False):
send_broadcast_provider_message(broadcast_event.id, 'ee')
assert mock_client.create_and_send_broadcast.called is False
def test_send_broadcast_provider_message_sends_data_correctly(
mocker, sample_broadcast_service, provider, provider_capitalised):
template = create_template(sample_broadcast_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template,
areas={
'areas': ['london', 'glasgow'],
'simple_polygons': [
[[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]],
[[-4.53, 55.72], [-3.88, 55.72], [-3.88, 55.96],
[-4.53, 55.96]],
],
},
status=BroadcastStatusType.BROADCASTING)
event = create_broadcast_event(broadcast_message)
mock_create_broadcast = mocker.patch(
f'app.clients.cbc_proxy.CBCProxy{provider_capitalised}.create_and_send_broadcast',
)
assert event.get_provider_message(provider) is None
send_broadcast_provider_message(provider=provider,
broadcast_event_id=str(event.id))
broadcast_provider_message = event.get_provider_message(provider)
assert broadcast_provider_message.status == BroadcastProviderMessageStatus.ACK
mock_create_broadcast.assert_called_once_with(
identifier=str(broadcast_provider_message.id),
message_number=mocker.ANY,
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],
],
}, {
'polygon': [
[-4.53, 55.72],
[-3.88, 55.72],
[-3.88, 55.96],
[-4.53, 55.96],
],
}],
sent=event.sent_at_as_cap_datetime_string,
expires=event.transmitted_finishes_at_as_cap_datetime_string,
channel="severe",
)
def test_send_broadcast_provider_message_errors(mocker, sample_broadcast_service, provider, provider_capitalised):
template = create_template(sample_broadcast_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template,
areas={
'areas': ['london'],
'simple_polygons': [
[[50.12, 1.2], [50.13, 1.2], [50.14, 1.21]],
],
},
status=BroadcastStatusType.BROADCASTING
)
event = create_broadcast_event(broadcast_message)
mock_create_broadcast = mocker.patch(
f'app.clients.cbc_proxy.CBCProxy{provider_capitalised}.create_and_send_broadcast',
side_effect=CBCProxyRetryableException('oh no'),
)
mock_retry = mocker.patch(
'app.celery.broadcast_message_tasks.send_broadcast_provider_message.retry',
side_effect=Retry
)
with pytest.raises(Retry):
send_broadcast_provider_message(provider=provider, broadcast_event_id=str(event.id))
mock_create_broadcast.assert_called_once_with(
identifier=ANY,
message_number=mocker.ANY,
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],
],
}],
sent=event.sent_at_as_cap_datetime_string,
expires=event.transmitted_finishes_at_as_cap_datetime_string,
channel="severe"
)
mock_retry.assert_called_once_with(
countdown=1,
exc=mock_create_broadcast.side_effect,
queue='broadcast-tasks'
)
broadcast_provider_message = event.get_provider_message(provider)
assert broadcast_provider_message.status == BroadcastProviderMessageStatus.SENDING
def test_send_broadcast_event_errors(sample_service):
template = create_template(sample_service, BROADCAST_TYPE)
broadcast_message = create_broadcast_message(
template, status=BroadcastStatusType.BROADCASTING)
event = create_broadcast_event(broadcast_message)
with requests_mock.Mocker() as request_mock:
request_mock.post("http://test-cbc-proxy/broadcasts/events/stub-1",
text='503 bad gateway',
status_code=503)
# we're not retrying or anything for the moment - but this'll ensure any exception gets logged
with pytest.raises(RequestException) as ex:
send_broadcast_event(broadcast_event_id=str(event.id))
assert ex.value.response.status_code == 503
