consumer with no mappings is a valid scenario

Author: Karthikeyannhs

src/eligibility_signposting_api/services/eligibility_services.py

@@ -20,10 +20,6 @@ class InvalidQueryParamError(Exception):
     pass
 
 
-class NoPermittedCampaignsError(Exception):
-    pass
-
-
 @service
 class EligibilityService:
     def __init__(
@@ -74,4 +70,4 @@ def __collect_permitted_campaign_configs(
                 campaign for campaign in campaign_configs if campaign.id in permitted_campaign_ids
             ]
             return permitted_campaign_configs
-        raise NoPermittedCampaignsError
+        return []

src/eligibility_signposting_api/views/eligibility.py

@@ -20,7 +20,6 @@
 from eligibility_signposting_api.model.consumer_mapping import ConsumerId
 from eligibility_signposting_api.model.eligibility_status import Condition, EligibilityStatus, NHSNumber, Status
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
-from eligibility_signposting_api.services.eligibility_services import NoPermittedCampaignsError
 from eligibility_signposting_api.views.response_model import eligibility_response
 from eligibility_signposting_api.views.response_model.eligibility_response import ProcessedSuggestion
 
@@ -66,8 +65,6 @@ def check_eligibility(
         )
     except UnknownPersonError:
         return handle_unknown_person_error(nhs_number)
-    except NoPermittedCampaignsError:
-        return handle_no_permitted_campaigns_for_the_consumer_error(consumer_id)
     else:
         response: eligibility_response.EligibilityResponse = build_eligibility_response(eligibility_status)
         AuditContext.write_to_firehose(audit_service)

tests/integration/in_process/test_eligibility_endpoint.py

@@ -836,8 +836,9 @@ def test_response_when_no_campaign_config_is_present(
         headers = {"nhs-login-nhs-number": str(persisted_77yo_person), CONSUMER_ID: "23-mic7heal-jor6don"}
 
         # When
-        response = client.get(f'/patient-check/{persisted_77yo_person}?includeActions=N&conditions=FLU',
-                              headers=headers)
+        response = client.get(
+            f"/patient-check/{persisted_77yo_person}?includeActions=N&conditions=FLU", headers=headers
+        )
 
         # Then
         assert_that(
@@ -848,9 +849,7 @@ def test_response_when_no_campaign_config_is_present(
                 is_json_that(
                     has_entry(
                         "processedSuggestions",
-                        equal_to(
-                            []
-                        ),
+                        equal_to([]),
                     )
                 )
             ),

tests/unit/repos/test_consumer_mapping_repo.py

@@ -1,9 +1,10 @@
 import json
-import pytest
 from unittest.mock import MagicMock
 
+import pytest
+
 from eligibility_signposting_api.model.consumer_mapping import ConsumerId
-from eligibility_signposting_api.repos.consumer_mapping_repo import ConsumerMappingRepo, BucketName
+from eligibility_signposting_api.repos.consumer_mapping_repo import BucketName, ConsumerMappingRepo
 
 
 class TestConsumerMappingRepo:
@@ -13,38 +14,26 @@ def mock_s3_client(self):
 
     @pytest.fixture
     def repo(self, mock_s3_client):
-        return ConsumerMappingRepo(
-            s3_client=mock_s3_client,
-            bucket_name=BucketName("test-bucket")
-        )
+        return ConsumerMappingRepo(s3_client=mock_s3_client, bucket_name=BucketName("test-bucket"))
 
     def test_get_permitted_campaign_ids_success(self, repo, mock_s3_client):
         # Given
         consumer_id = "user-123"
         expected_campaigns = ["flu-2024", "covid-2024"]
-        mapping_data = {
-            consumer_id: expected_campaigns
-        }
+        mapping_data = {consumer_id: expected_campaigns}
 
-        mock_s3_client.list_objects.return_value = {
-            "Contents": [{"Key": "mappings.json"}]
-        }
+        mock_s3_client.list_objects.return_value = {"Contents": [{"Key": "mappings.json"}]}
 
         body_json = json.dumps(mapping_data).encode("utf-8")
-        mock_s3_client.get_object.return_value = {
-            "Body": MagicMock(read=lambda: body_json)
-        }
+        mock_s3_client.get_object.return_value = {"Body": MagicMock(read=lambda: body_json)}
 
         # When
         result = repo.get_permitted_campaign_ids(ConsumerId(consumer_id))
 
         # Then
         assert result == expected_campaigns
         mock_s3_client.list_objects.assert_called_once_with(Bucket="test-bucket")
-        mock_s3_client.get_object.assert_called_once_with(
-            Bucket="test-bucket",
-            Key="mappings.json"
-        )
+        mock_s3_client.get_object.assert_called_once_with(Bucket="test-bucket", Key="mappings.json")
 
     def test_get_permitted_campaign_ids_returns_none_when_missing(self, repo, mock_s3_client):
         # Setup data where the consumer_id doesn't exist

tests/unit/services/test_eligibility_services.py

@@ -3,33 +3,32 @@
 import pytest
 from hamcrest import assert_that, empty
 
-from eligibility_signposting_api.model.campaign_config import CampaignID, CampaignConfig
+from eligibility_signposting_api.model.campaign_config import CampaignConfig, CampaignID
 from eligibility_signposting_api.model.eligibility_status import NHSNumber
 from eligibility_signposting_api.repos import CampaignRepo, NotFoundError, PersonRepo
 from eligibility_signposting_api.repos.consumer_mapping_repo import ConsumerMappingRepo
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
 from eligibility_signposting_api.services.calculators.eligibility_calculator import EligibilityCalculatorFactory
-from eligibility_signposting_api.services.eligibility_services import NoPermittedCampaignsError
 from tests.fixtures.matchers.eligibility import is_eligibility_status
 
+
 @pytest.fixture
 def mock_repos():
     return {
         "person": MagicMock(spec=PersonRepo),
         "campaign": MagicMock(spec=CampaignRepo),
         "consumer": MagicMock(spec=ConsumerMappingRepo),
-        "factory": MagicMock(spec=EligibilityCalculatorFactory)
+        "factory": MagicMock(spec=EligibilityCalculatorFactory),
     }
 
+
 @pytest.fixture
 def service(mock_repos):
     return EligibilityService(
-        mock_repos["person"],
-        mock_repos["campaign"],
-        mock_repos["consumer"],
-        mock_repos["factory"]
+        mock_repos["person"], mock_repos["campaign"], mock_repos["consumer"], mock_repos["factory"]
     )
 
+
 def test_eligibility_service_returns_from_repo():
     # Given
     person_repo = MagicMock(spec=PersonRepo)
@@ -66,48 +65,58 @@ def test_eligibility_service_for_nonexistent_nhs_number():
         )
 
 
-def test_get_eligibility_status_filters_permitted_campaigns(service, mock_repos):
-        """Tests that ONLY permitted campaigns reach the calculator factory."""
-        # Given
-        nhs_number = NHSNumber("1234567890")
-        person_data = {"age": 65, "vulnerable": True}
-        mock_repos["person"].get_eligibility_data.return_value = person_data
-
-        # Available campaigns in system
-        camp_a = MagicMock(spec=CampaignConfig, id=CampaignID("CAMP_A"))
-        camp_b = MagicMock(spec=CampaignConfig, id=CampaignID("CAMP_B"))
-        mock_repos["campaign"].get_campaign_configs.return_value = [camp_a, camp_b]
-
-        # Consumer is only permitted to see CAMP_B
-        mock_repos["consumer"].get_permitted_campaign_ids.return_value = [CampaignID("CAMP_B")]
-
-        # Mock calculator behavior
-        mock_calc = MagicMock()
-        mock_repos["factory"].get.return_value = mock_calc
-        mock_calc.get_eligibility_status.return_value = "eligible_result"
+def test_raises_unknown_person_error_on_repo_not_found(service, mock_repos):
+    """Tests that NotFoundError from repo is translated to UnknownPersonError."""
+    mock_repos["person"].get_eligibility_data.side_effect = NotFoundError
 
-        # When
-        result = service.get_eligibility_status(nhs_number, "Y", ["FLU"], "G1", "consumer_xyz")
+    with pytest.raises(UnknownPersonError):
+        service.get_eligibility_status(NHSNumber("999"), "Y", [], "", "any")
 
-        # Then
-        # Verify the factory was called ONLY with camp_b
-        mock_repos["factory"].get.assert_called_once_with(person_data, [camp_b])
-        assert result == "eligible_result"
 
-def test_raises_no_permitted_campaigns_error(service, mock_repos):
-    """Tests the scenario where the consumer mapping exists but returns nothing."""
-    mock_repos["person"].get_eligibility_data.return_value = {"data": "exists"}
-    mock_repos["campaign"].get_campaign_configs.return_value = [MagicMock()]
+@pytest.mark.parametrize(
+    "available_campaign_ids, permitted_campaign_ids, expected_campaign_ids",
+    [
+        # permitted campaigns is NOT empty → only permitted campaigns used
+        (
+            ["CAMP_A", "CAMP_B"],
+            ["CAMP_B"],
+            ["CAMP_B"],
+        ),
+        # permitted campaigns is empty → no campaigns used
+        (
+            ["CAMP_A", "CAMP_B"],
+            [],
+            [],
+        ),
+        # no campaigns in system → no campaigns used
+        (
+            [],
+            [],
+            [],
+        ),
+    ],
+)
+def test_get_eligibility_status_campaign_filtering(
+    service,
+    mock_repos,
+    available_campaign_ids,
+    permitted_campaign_ids,
+    expected_campaign_ids,
+):
+    # Given
+    nhs_number = NHSNumber("1234567890")
+    person_data = {"age": 65, "vulnerable": True}
+    mock_repos["person"].get_eligibility_data.return_value = person_data
 
-    # Consumer has no permitted IDs mapped
-    mock_repos["consumer"].get_permitted_campaign_ids.return_value = []
+    # Build campaign configs
+    campaigns = [MagicMock(spec=CampaignConfig, id=CampaignID(camp_id)) for camp_id in available_campaign_ids]
+    mock_repos["campaign"].get_campaign_configs.return_value = campaigns
 
-    with pytest.raises(NoPermittedCampaignsError):
-        service.get_eligibility_status(NHSNumber("1"), "Y", [], "", "bad_consumer")
+    permitted_ids = [CampaignID(camp_id) for camp_id in permitted_campaign_ids]
+    mock_repos["consumer"].get_permitted_campaign_ids.return_value = permitted_ids
 
-def test_raises_unknown_person_error_on_repo_not_found(service, mock_repos):
-    """Tests that NotFoundError from repo is translated to UnknownPersonError."""
-    mock_repos["person"].get_eligibility_data.side_effect = NotFoundError
+    expected_ids = [CampaignID(camp_id) for camp_id in expected_campaign_ids]
+    expected_campaigns = [camp for camp in campaigns if camp.id in expected_ids]
 
-    with pytest.raises(UnknownPersonError):
-        service.get_eligibility_status(NHSNumber("999"), "Y", [], "", "any")
+    mock_calc = MagicMock()
+    mock_repos["factory"].get.return_v

tests/unit/views/test_eligibility.py

@@ -94,6 +94,7 @@ def get_eligibility_status(
     ) -> EligibilityStatus:
         raise ValueError
 
+
 class FakeNoPermittedCampaignsService(EligibilityService):
     def __init__(self):
         pass
@@ -109,6 +110,7 @@ def get_eligibility_status(
         # Simulate the new error scenario
         raise NoPermittedCampaignsError
 
+
 def test_security_headers_present_on_successful_response(app: Flask, client: FlaskClient):
     """Test that security headers are present on successful eligibility check response."""
     # Given
@@ -610,10 +612,7 @@ def test_no_permitted_campaigns_for_consumer_error(app: Flask, client: FlaskClie
         get_app_container(app).override.service(EligibilityService, new=FakeNoPermittedCampaignsService()),
         get_app_container(app).override.service(AuditService, new=FakeAuditService()),
     ):
-        headers = {
-            "nhs-login-nhs-number": "9876543210",
-            "Consumer-Id": "unrecognized_consumer"
-        }
+        headers = {"nhs-login-nhs-number": "9876543210", "Consumer-Id": "unrecognized_consumer"}
 
         # When
         response = client.get("/patient-check/9876543210", headers=headers)
@@ -632,12 +631,12 @@ def test_no_permitted_campaigns_for_consumer_error(app: Flask, client: FlaskClie
                             has_entries(
                                 severity="error",
                                 code="forbidden",
-                                diagnostics="Consumer ID 'unrecognized_consumer' was not recognised by the Eligibility Signposting API"
+                                diagnostics="Consumer ID 'unrecognized_consumer' was not recognised by the Eligibility Signposting API",
                             )
-                        )
+                        ),
                     )
                 )
-            )
+            ),
         )
 
 
@@ -654,10 +653,7 @@ def test_consumer_id_is_passed_to_service(app: Flask, client: FlaskClient):
         get_app_container(app).override.service(EligibilityService, new=mock_service),
         get_app_container(app).override.service(AuditService, new=FakeAuditService()),
     ):
-        headers = {
-            "nhs-login-nhs-number": "1234567890",
-            "Consumer-Id": "specific_consumer_123"
-        }
+        headers = {"nhs-login-nhs-number": "1234567890", "Consumer-Id": "specific_consumer_123"}
 
         # When
         client.get("/patient-check/1234567890", headers=headers)