ELI-578 Unit tests

Karthikeyannhs · Karthikeyannhs · commit 4afb1222a838 · 2025-12-22T18:18:17.000Z
diff --git a/tests/unit/repos/test_consumer_mapping_repo.py b/tests/unit/repos/test_consumer_mapping_repo.py
@@ -0,0 +1,57 @@
+import json
+import pytest
+from unittest.mock import MagicMock
+
+from eligibility_signposting_api.model.consumer_mapping import ConsumerId
+from eligibility_signposting_api.repos.consumer_mapping_repo import ConsumerMappingRepo, BucketName
+
+
+class TestConsumerMappingRepo:
+    @pytest.fixture
+    def mock_s3_client(self):
+        return MagicMock()
+
+    @pytest.fixture
+    def repo(self, mock_s3_client):
+        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
+        }
+
+        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)
+        }
+
+        # 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"
+        )
+
+    def test_get_permitted_campaign_ids_returns_none_when_missing(self, repo, mock_s3_client):
+        # Setup data where the consumer_id doesn't exist
+        mock_s3_client.list_objects.return_value = {"Contents": [{"Key": "mappings.json"}]}
+        body_json = json.dumps({"other-user": ["camp-1"]}).encode("utf-8")
+        mock_s3_client.get_object.return_value = {"Body": MagicMock(read=lambda: body_json)}
+
+        result = repo.get_permitted_campaign_ids(ConsumerId("missing-user"))
+
+        assert result is None
diff --git a/tests/unit/services/test_eligibility_services.py b/tests/unit/services/test_eligibility_services.py
@@ -3,13 +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.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)
+    }
+
+@pytest.fixture
+def service(mock_repos):
+    return EligibilityService(
+        mock_repos["person"],
+        mock_repos["campaign"],
+        mock_repos["consumer"],
+        mock_repos["factory"]
+    )
 
 def test_eligibility_service_returns_from_repo():
     # Given
@@ -45,3 +64,50 @@ def test_eligibility_service_for_nonexistent_nhs_number():
             category="ALL",
             consumer_id="test_consumer_id",
         )
+
+
+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"
+
+        # When
+        result = service.get_eligibility_status(nhs_number, "Y", ["FLU"], "G1", "consumer_xyz")
+
+        # 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()]
+
+    # Consumer has no permitted IDs mapped
+    mock_repos["consumer"].get_permitted_campaign_ids.return_value = []
+
+    with pytest.raises(NoPermittedCampaignsError):
+        service.get_eligibility_status(NHSNumber("1"), "Y", [], "", "bad_consumer")
+
+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
+
+    with pytest.raises(UnknownPersonError):
+        service.get_eligibility_status(NHSNumber("999"), "Y", [], "", "any")
diff --git a/tests/unit/views/test_eligibility.py b/tests/unit/views/test_eligibility.py
@@ -28,6 +28,7 @@
     UrlLink,
 )
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
+from eligibility_signposting_api.services.eligibility_services import NoPermittedCampaignsError
 from eligibility_signposting_api.views.eligibility import (
     _get_or_default_query_params,
     build_actions,
@@ -93,6 +94,20 @@ def get_eligibility_status(
     ) -> EligibilityStatus:
         raise ValueError
 
+class FakeNoPermittedCampaignsService(EligibilityService):
+    def __init__(self):
+        pass
+
+    def get_eligibility_status(
+        self,
+        _nhs_number: NHSNumber,
+        _include_actions: str,
+        _conditions: list[str],
+        _category: str,
+        _consumer_id: str,
+    ) -> EligibilityStatus:
+        # 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."""
@@ -583,3 +598,74 @@ def test_status_endpoint(app: Flask, client: FlaskClient):
                 )
             ),
         )
+
+
+def test_no_permitted_campaigns_for_consumer_error(app: Flask, client: FlaskClient):
+    """
+    Tests that NoPermittedCampaignsError is caught and returns
+    the correct FHIR OperationOutcome with FORBIDDEN status.
+    """
+    # Given
+    with (
+        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"
+        }
+
+        # When
+        response = client.get("/patient-check/9876543210", headers=headers)
+
+        # Then
+        assert_that(
+            response,
+            is_response()
+            .with_status_code(HTTPStatus.FORBIDDEN)
+            .with_headers(has_entries({"Content-Type": "application/fhir+json"}))
+            .and_text(
+                is_json_that(
+                    has_entries(
+                        resourceType="OperationOutcome",
+                        issue=contains_exactly(
+                            has_entries(
+                                severity="error",
+                                code="forbidden",
+                                diagnostics="Consumer ID 'unrecognized_consumer' was not recognised by the Eligibility Signposting API"
+                            )
+                        )
+                    )
+                )
+            )
+        )
+
+
+def test_consumer_id_is_passed_to_service(app: Flask, client: FlaskClient):
+    """
+    Verifies that the consumer ID from the header is actually passed
+    to the eligibility service call.
+    """
+    # Given
+    mock_service = MagicMock(spec=EligibilityService)
+    mock_service.get_eligibility_status.return_value = EligibilityStatusFactory.build()
+
+    with (
+        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"
+        }
+
+        # When
+        client.get("/patient-check/1234567890", headers=headers)
+
+        # Then
+        # Verify the 5th positional argument or the keyword argument 'consumer_id'
+        mock_service.get_eligibility_status.assert_called_once()
+        args, kwargs = mock_service.get_eligibility_status.call_args
+
+        # Check that 'specific_consumer_123' was the consumer_id passed
+        assert args[4] == "specific_consumer_123"
