eli-579 tightening up registry initialisation

Author: eddalmond1

src/eligibility_signposting_api/services/processors/derived_values/registry.py

@@ -44,22 +44,40 @@ def register_default(cls, handler: DerivedValueHandler) -> None:
         Args:
             handler: The derived value handler to register
         """
-        cls._default_handlers[handler.function_name] = handler
+        normalized_name = handler.function_name.upper()
+        cls._default_handlers[normalized_name] = handler
+
+        if _RegistryHolder.instance is not None:
+            _RegistryHolder.instance.register(handler)
+
+    def clear(self) -> None:
+        """Clear all handlers from this registry instance."""
+        self._handlers.clear()
 
     @classmethod
     def clear_defaults(cls) -> None:
         """Clear all default handlers. Useful for testing."""
         cls._default_handlers.clear()
+        if _RegistryHolder.instance is not None:
+            _RegistryHolder.instance.clear()
 
     @classmethod
     def get_default_handlers(cls) -> dict[str, DerivedValueHandler]:
         """Get a copy of the default handlers. Useful for testing."""
         return cls._default_handlers.copy()
 
+    def set_handlers(self, handlers: dict[str, DerivedValueHandler]) -> None:
+        """Replace all handlers in this registry instance."""
+        self._handlers = {name.upper(): handler for name, handler in handlers.items()}
+
     @classmethod
     def set_default_handlers(cls, handlers: dict[str, DerivedValueHandler]) -> None:
         """Set the default handlers. Useful for testing."""
-        cls._default_handlers = handlers
+        normalized = {name.upper(): handler for name, handler in handlers.items()}
+        cls._default_handlers = normalized
+
+        if _RegistryHolder.instance is not None:
+            _RegistryHolder.instance.set_handlers(handlers)
 
     def register(self, handler: DerivedValueHandler) -> None:
         """Register a derived value handler.
@@ -68,7 +86,8 @@ def register(self, handler: DerivedValueHandler) -> None:
             handler: The handler to register. Its function_name attribute
                     will be used as the lookup key.
         """
-        self._handlers[handler.function_name] = handler
+        normalized_name = handler.function_name.upper()
+        self._handlers[normalized_name] = handler
 
     def get_handler(self, function_name: str) -> DerivedValueHandler | None:
         """Get a handler by function name.
@@ -151,8 +170,10 @@ def calculate(
         return handler.calculate(context)
 
 
-# Create a singleton instance for convenience
-_registry = DerivedValueRegistry()
+class _RegistryHolder:
+    """Holder for the singleton registry to avoid global statement."""
+
+    instance: DerivedValueRegistry | None = None
 
 
 def get_registry() -> DerivedValueRegistry:
@@ -161,4 +182,6 @@ def get_registry() -> DerivedValueRegistry:
     Returns:
         The singleton DerivedValueRegistry instance
     """
-    return _registry
+    if _RegistryHolder.instance is None:
+        _RegistryHolder.instance = DerivedValueRegistry()
+    return _RegistryHolder.instance

tests/unit/services/processors/test_derived_values.py

@@ -5,7 +5,9 @@
 from eligibility_signposting_api.services.processors.derived_values import (
     AddDaysHandler,
     DerivedValueContext,
+    DerivedValueHandler,
     DerivedValueRegistry,
+    get_registry,
 )
 
 
@@ -360,6 +362,29 @@ def test_default_handlers_are_registered(self):
         # The default ADD_DAYS handler should be registered via __init__.py
         assert_that(registry.has_handler("ADD_DAYS"), is_(True))
 
+    def test_global_registry_has_default_handlers(self):
+        """Test that the exported registry singleton sees default handlers."""
+        registry = get_registry()
+
+        assert_that(registry.has_handler("ADD_DAYS"), is_(True))
+
+    def test_register_normalizes_function_name(self):
+        """Test that registering handlers works regardless of name casing."""
+
+        class LowercaseHandler(DerivedValueHandler):
+            function_name = "custom_func"
+
+            def calculate(self, context: DerivedValueContext) -> str:  # noqa: ARG002
+                return ""
+
+            def get_source_attribute(self, target_attribute: str, function_args: str | None = None) -> str:  # noqa: ARG002
+                return target_attribute
+
+        registry = DerivedValueRegistry()
+        registry.register(LowercaseHandler())
+
+        assert_that(registry.has_handler("CUSTOM_FUNC"), is_(True))
+
     def test_clear_defaults_removes_default_handlers(self):
         """Test that clear_defaults removes all default handlers."""
         # Save current defaults using public method