Return empty FHIR bundle from the enterprise view rather than the custom model.

Author: acerathereinspirative-nhs-nvir

src/eligibility_signposting_api/model/eligibility.py

@@ -8,5 +8,7 @@
 Postcode = NewType("Postcode", str)
 
 
-class Eligibility(BaseModel):
-    processed_suggestions: list[dict]
+class EligibilityStatus(BaseModel):
+    eligible: bool
+    reasons: list[dict]
+    actions: list[dict]

src/eligibility_signposting_api/services/eligibility_services.py

@@ -2,7 +2,7 @@
 
 from wireup import service
 
-from eligibility_signposting_api.model.eligibility import Eligibility, NHSNumber
+from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber
 from eligibility_signposting_api.repos import EligibilityRepo, NotFoundError, RulesRepo
 
 logger = logging.getLogger(__name__)
@@ -19,7 +19,7 @@ def __init__(self, eligibility_repo: EligibilityRepo, rules_repo: RulesRepo) ->
         self.eligibility_repo = eligibility_repo
         self.rules_repo = rules_repo
 
-    def get_eligibility(self, nhs_number: NHSNumber | None = None) -> Eligibility:
+    def get_eligibility_status(self, nhs_number: NHSNumber | None = None) -> EligibilityStatus:
         if nhs_number:
             try:
                 person_data = self.eligibility_repo.get_eligibility_data(nhs_number)
@@ -47,6 +47,6 @@ def get_eligibility(self, nhs_number: NHSNumber | None = None) -> Eligibility:
                         "nhs_number": nhs_number,
                     },
                 )
-                return Eligibility(processed_suggestions=[])
+                return EligibilityStatus(eligible=True, reasons=[], actions=[])
 
         raise UnknownPersonError

src/eligibility_signposting_api/views/eligibility.py

@@ -1,14 +1,18 @@
 import logging
 from http import HTTPStatus
 
-from fhir.resources.operationoutcome import OperationOutcome, OperationOutcomeIssue
+from fhir.resources.R4B.bundle import Bundle, BundleEntry
+from fhir.resources.R4B.guidanceresponse import GuidanceResponse
+from fhir.resources.R4B.location import Location
+from fhir.resources.R4B.operationoutcome import OperationOutcome, OperationOutcomeIssue
+from fhir.resources.R4B.requestgroup import RequestGroup
+from fhir.resources.R4B.task import Task
 from flask import Blueprint, make_response, request
 from flask.typing import ResponseReturnValue
 from wireup import Injected
 
-from eligibility_signposting_api.model.eligibility import Eligibility, NHSNumber
+from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
-from eligibility_signposting_api.views.response_models import EligibilityResponse
 
 logger = logging.getLogger(__name__)
 
@@ -20,7 +24,7 @@ def check_eligibility(eligibility_service: Injected[EligibilityService]) -> Resp
     nhs_number = NHSNumber(request.args.get("nhs_number", ""))
     logger.debug("checking nhs_number %r in %r", nhs_number, eligibility_service, extra={"nhs_number": nhs_number})
     try:
-        eligibility = eligibility_service.get_eligibility(nhs_number)
+        eligibility_status = eligibility_service.get_eligibility_status(nhs_number)
     except UnknownPersonError:
         logger.debug("nhs_number %r not found", nhs_number, extra={"nhs_number": nhs_number})
         problem = OperationOutcome(
@@ -34,9 +38,20 @@ def check_eligibility(eligibility_service: Injected[EligibilityService]) -> Resp
         )
         return make_response(problem.model_dump(by_alias=True), HTTPStatus.NOT_FOUND)
     else:
-        eligibility_response = build_eligibility_response(eligibility)
-        return make_response(eligibility_response.model_dump(by_alias=True), HTTPStatus.OK)
-
-
-def build_eligibility_response(eligibility: Eligibility) -> EligibilityResponse:
-    return EligibilityResponse(processed_suggestions=eligibility.processed_suggestions)
+        bundle = build_bundle(eligibility_status)
+        return make_response(bundle.model_dump(by_alias=True), HTTPStatus.OK)
+
+
+def build_bundle(_eligibility_status: EligibilityStatus) -> Bundle:
+    return Bundle(  # pyright: ignore[reportCallIssue]
+        id="dummy-bundle",
+        type="collection",
+        entry=[
+            BundleEntry(  # pyright: ignore[reportCallIssue]
+                resource=GuidanceResponse(id="dummy-guidance-response", status="requested", moduleCodeableConcept={})  # pyright: ignore[reportCallIssue]
+            ),
+            BundleEntry(resource=RequestGroup(id="dummy-request-group", intent="proposal", status="requested")),  # pyright: ignore[reportCallIssue]
+            BundleEntry(resource=Task(id="dummy-task", intent="proposal", status="requested")),  # pyright: ignore[reportCallIssue]
+            BundleEntry(resource=Location(id="dummy-location")),  # pyright: ignore[reportCallIssue]
+        ],
+    )

src/eligibility_signposting_api/views/response_models.py

@@ -23,7 +23,7 @@ def test_nhs_number_given(
     # Then
     assert_that(
         response,
-        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_entries(processed_suggestions=[]))),
+        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_entries(resourceType="Bundle"))),
     )
 
 

tests/integration/in_process/test_eligibility_endpoint.py

@@ -57,7 +57,7 @@ def test_install_and_call_lambda_flask(
     logger.info(response_payload)
     assert_that(
         response_payload,
-        has_entries(statusCode=HTTPStatus.OK, body=is_json_that(has_entries(processed_suggestions=[]))),
+        has_entries(statusCode=HTTPStatus.OK, body=is_json_that(has_entries(resourceType="Bundle"))),
     )
 
     assert_that(log_output, contains_string("person_data"))
@@ -78,7 +78,7 @@ def test_install_and_call_flask_lambda_over_http(
     # Then
     assert_that(
         response,
-        is_response().with_status_code(HTTPStatus.OK).and_body(is_json_that(has_entries(processed_suggestions=[]))),
+        is_response().with_status_code(HTTPStatus.OK).and_body(is_json_that(has_entries(resourceType="Bundle"))),
     )
 
 

tests/integration/lambda/test_app_running_as_lambda.py

@@ -1,13 +1,16 @@
 from unittest.mock import MagicMock
 
 import pytest
+from brunns.matchers.object import true
 from faker import Faker
+from hamcrest import assert_that
 
-from eligibility_signposting_api.model.eligibility import DateOfBirth, Eligibility, NHSNumber, Postcode
+from eligibility_signposting_api.model.eligibility import DateOfBirth, NHSNumber, Postcode
 from eligibility_signposting_api.model.rules import RuleOperator, RuleType
 from eligibility_signposting_api.repos import EligibilityRepo, NotFoundError, RulesRepo
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
 from tests.utils.builders import CampaignConfigFactory, IterationFactory, IterationRuleFactory
+from tests.utils.matchers.eligibility import is_eligibility_status
 
 
 @pytest.fixture(scope="session")
@@ -23,10 +26,10 @@ def test_eligibility_service_returns_from_repo():
     ps = EligibilityService(eligibility_repo, rules_repo)
 
     # When
-    actual = ps.get_eligibility(NHSNumber("1234567890"))
+    actual = ps.get_eligibility_status(NHSNumber("1234567890"))
 
     # Then
-    assert actual == Eligibility(processed_suggestions=[])
+    assert_that(actual, is_eligibility_status().with_eligible(true()))
 
 
 def test_eligibility_service_for_nonexistent_nhs_number():
@@ -38,7 +41,7 @@ def test_eligibility_service_for_nonexistent_nhs_number():
 
     # When
     with pytest.raises(UnknownPersonError):
-        ps.get_eligibility(NHSNumber("1234567890"))
+        ps.get_eligibility_status(NHSNumber("1234567890"))
 
 
 def test_simple_rule(faker: Faker):
@@ -72,7 +75,7 @@ def test_simple_rule(faker: Faker):
     ps = EligibilityService(eligibility_repo, rules_repo)
 
     # When
-    actual = ps.get_eligibility(NHSNumber(nhs_number))
+    actual = ps.get_eligibility_status(NHSNumber(nhs_number))
 
     # Then
-    assert actual == Eligibility(processed_suggestions=[])
+    assert_that(actual, is_eligibility_status().with_eligible(true()))

tests/unit/services/test_eligibility_services.py

@@ -8,7 +8,7 @@
 from hamcrest import assert_that, contains_exactly, has_entries
 from wireup.integration.flask import get_app_container
 
-from eligibility_signposting_api.model.eligibility import Eligibility, NHSNumber
+from eligibility_signposting_api.model.eligibility import EligibilityStatus, NHSNumber
 from eligibility_signposting_api.services import EligibilityService, UnknownPersonError
 
 logger = logging.getLogger(__name__)
@@ -18,23 +18,23 @@ class FakeEligibilityService(EligibilityService):
     def __init__(self):
         pass
 
-    def get_eligibility(self, _: NHSNumber | None = None) -> Eligibility:
-        return Eligibility(processed_suggestions=[])
+    def get_eligibility_status(self, _: NHSNumber | None = None) -> EligibilityStatus:
+        return EligibilityStatus(eligible=True, reasons=[], actions=[])
 
 
 class FakeUnknownPersonEligibilityService(EligibilityService):
     def __init__(self):
         pass
 
-    def get_eligibility(self, _: NHSNumber | None = None) -> Eligibility:
+    def get_eligibility_status(self, _: NHSNumber | None = None) -> EligibilityStatus:
         raise UnknownPersonError
 
 
 class FakeUnexpectedErrorEligibilityService(EligibilityService):
     def __init__(self):
         pass
 
-    def get_eligibility(self, _: NHSNumber | None = None) -> Eligibility:
+    def get_eligibility_status(self, _: NHSNumber | None = None) -> EligibilityStatus:
         raise ValueError
 
 
@@ -47,7 +47,7 @@ def test_nhs_number_given(app: Flask, client: FlaskClient):
         # Then
     assert_that(
         response,
-        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_entries(processed_suggestions=[]))),
+        is_response().with_status_code(HTTPStatus.OK).and_text(is_json_that(has_entries(resourceType="Bundle"))),
     )
 
 

tests/unit/views/test_eligibility.py

@@ -0,0 +1,12 @@
+from hamcrest.core.matcher import Matcher
+
+from eligibility_signposting_api.model.eligibility import EligibilityStatus
+
+from .meta import BaseAutoMatcher
+
+
+class EligibilityStatusMatcher(BaseAutoMatcher[EligibilityStatus]): ...
+
+
+def is_eligibility_status() -> Matcher[EligibilityStatus]:
+    return EligibilityStatusMatcher()

tests/utils/matchers/eligibility.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, get_args, get_origin
 
 from hamcrest import anything
 from hamcrest.core.base_matcher import BaseMatcher
@@ -14,8 +14,21 @@ def __new__(cls, name, bases, namespace, **_kwargs):
             return super().__new__(cls, name, bases, namespace)
 
         domain_class = namespace.get("__domain_class__")
+
         if domain_class is None:
-            msg = f"{name} must define __domain_class__"
+            orig_bases = namespace.get("__orig_bases__", [])
+            for orig in orig_bases:
+                origin = get_origin(orig)
+                args = get_args(orig)
+                if origin is BaseAutoMatcher and args:
+                    inferred_type = args[0]
+                    if hasattr(inferred_type, "__annotations__"):
+                        domain_class = inferred_type
+                        namespace["__domain_class__"] = domain_class
+                        break
+
+        if domain_class is None or not hasattr(domain_class, "__annotations__"):
+            msg = f"{name} must define or infer __domain_class__ with annotations"
             raise TypeError(msg)
 
         for field_name in domain_class.__annotations__:
@@ -25,8 +38,27 @@ def __new__(cls, name, bases, namespace, **_kwargs):
         return super().__new__(cls, name, bases, namespace)
 
 
-class BaseAutoMatcher(BaseMatcher, metaclass=AutoMatcherMeta):
-    __domain_class__ = None  # must be overridden
+class BaseAutoMatcher[T](BaseMatcher, metaclass=AutoMatcherMeta):
+    """Create matchers for classes. Use like so:
+
+    ```python
+    from hamcrest import assert_that, equal_to
+
+    class EligibilityStatus(BaseModel):
+        status: str
+        reason: str | None = None
+
+    class EligibilityStatusMatcher(BaseAutoMatcher[EligibilityStatus]): ...
+    def is_eligibility_status() -> Matcher[EligibilityStatus]: return EligibilityStatusMatcher()
+
+    assert_that(EligibilityStatus(status="ACTIVE"), is_eligibility_status().with_status("ACTIVE").and_reason(None))
+    ```
+
+    Works only for classes with `__annotations__`; manually annotated classes, dataclasses.dataclass and
+    pydantic.BaseModel instances.
+    """
+
+    __domain_class__ = None  # Will be inferred when subclassed generically
 
     def __init__(self):
         super().__init__()
@@ -37,24 +69,24 @@ def describe_to(self, description: Description) -> None:
             attr_name = f"{field_name}_" if field_name in {"id", "type"} else field_name
             self.append_matcher_description(getattr(self, attr_name), field_name, description)
 
-    def _matches(self, item) -> bool:
+    def _matches(self, item: T) -> bool:
         return all(
             getattr(self, f"{field}_" if field in {"id", "type"} else field).matches(getattr(item, field))
             for field in self.__domain_class__.__annotations__
         )
 
-    def describe_mismatch(self, item, mismatch_description: Description) -> None:
+    def describe_mismatch(self, item: T, mismatch_description: Description) -> None:
         mismatch_description.append_text(f"was {self.__domain_class__.__name__} with")
         for field_name in self.__domain_class__.__annotations__:
-            value = getattr(item, field_name)
             matcher = getattr(self, f"{field_name}_" if field_name in {"id", "type"} else field_name)
+            value = getattr(item, field_name)
             self.describe_field_mismatch(matcher, field_name, value, mismatch_description)
 
-    def describe_match(self, item, match_description: Description) -> None:
+    def describe_match(self, item: T, match_description: Description) -> None:
         match_description.append_text(f"was {self.__domain_class__.__name__} with")
         for field_name in self.__domain_class__.__annotations__:
-            value = getattr(item, field_name)
             matcher = getattr(self, f"{field_name}_" if field_name in {"id", "type"} else field_name)
+            value = getattr(item, field_name)
             self.describe_field_match(matcher, field_name, value, match_description)
 
     def __getattr__(self, name: str):
@@ -74,8 +106,8 @@ def setter(value):
     def __dir__(self):
         dynamic_methods = []
         for field_name in self.__domain_class__.__annotations__:
-            method_base = field_name.rstrip("_") if field_name in {"id", "type"} else field_name
-            dynamic_methods.extend([f"with_{method_base}", f"and_{method_base}"])
+            base = field_name.rstrip("_") if field_name in {"id", "type"} else field_name
+            dynamic_methods.extend([f"with_{base}", f"and_{base}"])
         return list(super().__dir__()) + dynamic_methods
 
     @staticmethod