respect service broadcast provider restrictions when sending

app/celery/broadcast_message_tasks.py

@@ -16,13 +16,15 @@ def send_broadcast_event(broadcast_event_id):
         current_app.logger.info(f'CBC Proxy disabled, not sending broadcast_event {broadcast_event_id}')
         return
 
+    broadcast_event = dao_get_broadcast_event_by_id(broadcast_event_id)
     for provider in current_app.config['ENABLED_CBCS']:
-        # TODO: Decide whether to send to each provider based on platform admin, service level settings, broadcast
+        if broadcast_event.service.allowed_broadcast_provider in {None, provider}:
-        # level settings, etc.
+            # There may be future checks here to decide whether to send to each provider based on platform admin level
-        send_broadcast_provider_message.apply_async(
+            # settings
-            kwargs={'broadcast_event_id': broadcast_event_id, 'provider': provider},
+            send_broadcast_provider_message.apply_async(
-            queue=QueueNames.NOTIFY
+                kwargs={'broadcast_event_id': broadcast_event_id, 'provider': provider},
-        )
+                queue=QueueNames.NOTIFY
+            )
 
 
 @notify_celery.task(name="send-broadcast-provider-message")

app/dao/broadcast_message_dao.py

@@ -10,12 +10,8 @@ def dao_get_broadcast_message_by_id_and_service_id(broadcast_message_id, service
     ).one()
 
 
-def dao_get_broadcast_message_by_id(broadcast_message_id):
-    return BroadcastMessage.query.get(broadcast_message_id)
-
-
 def dao_get_broadcast_event_by_id(broadcast_event_id):
-    return BroadcastEvent.query.get(broadcast_event_id)
+    return BroadcastEvent.query.filter(BroadcastEvent.id == broadcast_event_id).one()
 
 
 def dao_get_broadcast_messages_for_service(service_id):

tests/app/celery/test_broadcast_message_tasks.py

@@ -4,7 +4,13 @@ from unittest.mock import call, ANY
 from freezegun import freeze_time
 import pytest
 
-from app.models import BROADCAST_TYPE, BroadcastStatusType, BroadcastEventMessageType, BroadcastProviderMessageStatus
+from app.models import (
+    BROADCAST_TYPE,
+    BroadcastStatusType,
+    BroadcastEventMessageType,
+    BroadcastProviderMessageStatus,
+    ServiceBroadcastProviderRestriction
+)
 from app.celery.broadcast_message_tasks import send_broadcast_event, send_broadcast_provider_message, trigger_link_test
 
 from tests.app.db import (
@@ -16,21 +22,76 @@ from tests.app.db import (
 from tests.conftest import set_config
 
 
-def test_send_broadcast_event_queues_up_for_active_providers(mocker, notify_api):
+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',
     )
 
-    event_id = uuid.uuid4()
     with set_config(notify_api, 'ENABLED_CBCS', ['ee', 'vodafone']):
-        send_broadcast_event(event_id)
+        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': 'ee'}, queue='notify-internal-tasks'),
-        call(kwargs={'broadcast_event_id': event_id, 'provider': 'vodafone'}, queue='notify-internal-tasks')
+        call(kwargs={'broadcast_event_id': event.id, 'provider': 'vodafone'}, queue='notify-internal-tasks')
     ]
 
 
+def test_send_broadcast_event_only_sends_to_one_provider_if_set_on_service(
+    mocker,
+    notify_db,
+    notify_api,
+    sample_service
+):
+    notify_db.session.add(ServiceBroadcastProviderRestriction(
+        service=sample_service,
+        provider='vodafone'
+    ))
+
+    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='notify-internal-tasks')
+    ]
+
+
+def test_send_broadcast_event_does_nothing_if_provider_set_on_service_isnt_enabled_globally(
+    mocker,
+    notify_db,
+    notify_api,
+    sample_service
+):
+    notify_db.session.add(ServiceBroadcastProviderRestriction(
+        service=sample_service,
+        provider='three'
+    ))
+
+    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.called is False
+
+
 def test_send_broadcast_event_does_nothing_if_cbc_proxy_disabled(mocker, notify_api):
     mock_send_broadcast_provider_message = mocker.patch(
         'app.celery.broadcast_message_tasks.send_broadcast_provider_message',