eli-579 reverting changes to registry

Author: eddalmond1

poetry.lock

@@ -43,7 +43,7 @@ jsonpath-rw = "^1.4.0"
 semver = "^3.0.4"
 gitpython = "^3.1.45"
 pytest = "^8.4.2"
-pytest-asyncio = "^1.2.0"
+pytest-asyncio = "^1.3.0"
 pytest-cov = "^7.0.0"
 pytest-nhsd-apim = "^5.0.14"
 aiohttp = "^3.12.15"
@@ -62,7 +62,7 @@ jsonschema = "^4.25.1"
 behave = "^1.3.3"
 python-dotenv = "^1.2.1"
 openapi-spec-validator = "^0.7.2"
-pip-licenses = "^5.0.0"
+pip-licenses = "^5.5.0"
 
 
 [tool.poetry-plugin-lambda-build]

pyproject.toml

@@ -1,6 +1,7 @@
 from unittest.mock import MagicMock
 
 import pytest
+from hamcrest import assert_that, empty, equal_to, is_
 
 from eligibility_signposting_api.services.processors.derived_values import (
     AddDaysHandler,
@@ -26,7 +27,7 @@ def test_calculate_adds_default_days_to_date(self):
         result = handler.calculate(context)
 
         # 2025-01-01 + 91 days = 2025-04-02
-        assert result == "20250402"
+        assert_that(result, is_(equal_to("20250402")))
 
     def test_calculate_with_function_args_override(self):
         """Test that function args override default days."""
@@ -42,7 +43,7 @@ def test_calculate_with_function_args_override(self):
         result = handler.calculate(context)
 
         # 2025-01-01 + 30 days = 2025-01-31
-        assert result == "20250131"
+        assert_that(result, is_(equal_to("20250131")))
 
     def test_calculate_with_vaccine_specific_days(self):
         """Test that vaccine-specific days are used when configured."""
@@ -61,7 +62,7 @@ def test_calculate_with_vaccine_specific_days(self):
         result = handler.calculate(context)
 
         # 2025-01-01 + 365 days = 2026-01-01
-        assert result == "20260101"
+        assert_that(result, is_(equal_to("20260101")))
 
     def test_calculate_with_date_format(self):
         """Test that date format is applied to output."""
@@ -76,7 +77,7 @@ def test_calculate_with_date_format(self):
 
         result = handler.calculate(context)
 
-        assert result == "02 April 2025"
+        assert_that(result, is_(equal_to("02 April 2025")))
 
     def test_calculate_returns_empty_when_source_not_found(self):
         """Test that empty string is returned when source date not found."""
@@ -91,7 +92,7 @@ def test_calculate_returns_empty_when_source_not_found(self):
 
         result = handler.calculate(context)
 
-        assert result == ""
+        assert_that(result, is_(empty()))
 
     def test_calculate_returns_empty_when_vaccine_not_found(self):
         """Test that empty string is returned when vaccine type not found."""
@@ -106,7 +107,7 @@ def test_calculate_returns_empty_when_vaccine_not_found(self):
 
         result = handler.calculate(context)
 
-        assert result == ""
+        assert_that(result, is_(empty()))
 
     def test_calculate_with_invalid_date_raises_error(self):
         """Test that invalid date format raises ValueError."""
@@ -126,13 +127,13 @@ def test_get_source_attribute_maps_derived_to_source(self):
         """Test that get_source_attribute maps derived attributes correctly."""
         handler = AddDaysHandler()
 
-        assert handler.get_source_attribute("NEXT_DOSE_DUE") == "LAST_SUCCESSFUL_DATE"
+        assert_that(handler.get_source_attribute("NEXT_DOSE_DUE"), is_(equal_to("LAST_SUCCESSFUL_DATE")))
 
     def test_get_source_attribute_returns_original_if_not_mapped(self):
         """Test that unmapped attributes return themselves."""
         handler = AddDaysHandler()
 
-        assert handler.get_source_attribute("UNKNOWN_ATTR") == "UNKNOWN_ATTR"
+        assert_that(handler.get_source_attribute("UNKNOWN_ATTR"), is_(equal_to("UNKNOWN_ATTR")))
 
     def test_function_args_priority_over_vaccine_config(self):
         """Test that function args take priority over vaccine-specific config."""
@@ -151,7 +152,86 @@ def test_function_args_priority_over_vaccine_config(self):
         result = handler.calculate(context)
 
         # 2025-01-01 + 30 days = 2025-01-31
-        assert result == "20250131"
+        assert_that(result, is_(equal_to("20250131")))
+
+    def test_calculate_with_negative_days(self):
+        """Test that negative days subtracts from date."""
+        handler = AddDaysHandler(default_days=91)
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20250110"}],
+            attribute_name="COVID",
+            source_attribute="LAST_SUCCESSFUL_DATE",
+            function_args="-7",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        # 2025-01-10 - 7 days = 2025-01-03
+        assert_that(result, is_(equal_to("20250103")))
+
+    def test_calculate_with_zero_days(self):
+        """Test that zero days returns the same date."""
+        handler = AddDaysHandler(default_days=91)
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20250115"}],
+            attribute_name="COVID",
+            source_attribute="LAST_SUCCESSFUL_DATE",
+            function_args="0",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        assert_that(result, is_(equal_to("20250115")))
+
+    def test_calculate_with_invalid_args_falls_back_to_default(self):
+        """Test that invalid (non-numeric) function args falls back to default days."""
+        handler = AddDaysHandler(default_days=91)
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20250101"}],
+            attribute_name="COVID",
+            source_attribute="LAST_SUCCESSFUL_DATE",
+            function_args="invalid",  # Non-numeric, should fall back to default
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        # 2025-01-01 + 91 days (default) = 2025-04-02
+        assert_that(result, is_(equal_to("20250402")))
+
+    def test_calculate_crossing_year_boundary(self):
+        """Test adding days that crosses year boundary."""
+        handler = AddDaysHandler(default_days=91)
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20251230"}],
+            attribute_name="COVID",
+            source_attribute="LAST_SUCCESSFUL_DATE",
+            function_args="5",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        # 2025-12-30 + 5 days = 2026-01-04
+        assert_that(result, is_(equal_to("20260104")))
+
+    def test_calculate_leap_year_handling(self):
+        """Test adding days from leap year date."""
+        handler = AddDaysHandler(default_days=91)
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20240229"}],
+            attribute_name="COVID",
+            source_attribute="LAST_SUCCESSFUL_DATE",
+            function_args="365",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        # 2024-02-29 + 365 days = 2025-02-28 (no Feb 29 in 2025)
+        assert_that(result, is_(equal_to("20250228")))
 
 
 class TestDerivedValueRegistry:
@@ -165,29 +245,29 @@ def test_register_and_get_handler(self):
 
         retrieved = registry.get_handler("ADD_DAYS")
 
-        assert retrieved is handler
+        assert_that(retrieved, is_(handler))
 
     def test_get_handler_case_insensitive(self):
         """Test that handler lookup is case insensitive."""
         registry = DerivedValueRegistry()
         handler = AddDaysHandler()
         registry.register(handler)
 
-        assert registry.get_handler("add_days") is handler
-        assert registry.get_handler("Add_Days") is handler
+        assert_that(registry.get_handler("add_days"), is_(handler))
+        assert_that(registry.get_handler("Add_Days"), is_(handler))
 
     def test_has_handler_returns_true_when_exists(self):
         """Test has_handler returns True for registered handlers."""
         registry = DerivedValueRegistry()
         registry.register(AddDaysHandler())
 
-        assert registry.has_handler("ADD_DAYS") is True
+        assert_that(registry.has_handler("ADD_DAYS"), is_(True))
 
     def test_has_handler_returns_false_when_not_exists(self):
         """Test has_handler returns False for unregistered handlers."""
         registry = DerivedValueRegistry()
 
-        assert registry.has_handler("UNKNOWN") is False
+        assert_that(registry.has_handler("UNKNOWN"), is_(False))
 
     def test_calculate_delegates_to_correct_handler(self):
         """Test that calculate delegates to the correct handler."""
@@ -215,7 +295,7 @@ def test_calculate_delegates_to_correct_handler(self):
 
         # Verify the mock handler was called with the context
         mock_handler.calculate.assert_called_once_with(context)
-        assert result == "mock_result"
+        assert_that(result, is_(equal_to("mock_result")))
 
     def test_calculate_raises_for_unknown_function(self):
         """Test that calculate raises ValueError for unknown functions."""
@@ -240,21 +320,21 @@ def test_is_derived_attribute_returns_true_for_derived(self):
         registry = DerivedValueRegistry()
         registry.register(AddDaysHandler())
 
-        assert registry.is_derived_attribute("NEXT_DOSE_DUE") is True
+        assert_that(registry.is_derived_attribute("NEXT_DOSE_DUE"), is_(True))
 
     def test_is_derived_attribute_returns_false_for_non_derived(self):
         """Test is_derived_attribute for non-derived attributes."""
         registry = DerivedValueRegistry()
         registry.register(AddDaysHandler())
 
-        assert registry.is_derived_attribute("LAST_SUCCESSFUL_DATE") is False
+        assert_that(registry.is_derived_attribute("LAST_SUCCESSFUL_DATE"), is_(False))
 
     def test_default_handlers_are_registered(self):
         """Test that default handlers from the module are registered."""
         registry = DerivedValueRegistry()
 
         # The default ADD_DAYS handler should be registered via __init__.py
-        assert registry.has_handler("ADD_DAYS")
+        assert_that(registry.has_handler("ADD_DAYS"), is_(True))
 
     def test_clear_defaults_removes_default_handlers(self):
         """Test that clear_defaults removes all default handlers."""
@@ -266,7 +346,7 @@ def test_clear_defaults_removes_default_handlers(self):
 
             # New registry should have no handlers
             registry = DerivedValueRegistry()
-            assert not registry.has_handler("ADD_DAYS")
+            assert_that(registry.has_handler("ADD_DAYS"), is_(False))
         finally:
             # Restore defaults for other tests using public method
             DerivedValueRegistry.set_default_handlers(saved_defaults)