refactor(idm): share directory dependency resolution

Release v0.1.26. Coordinated integrity review: GovOPlaN/govoplan-core#298.

tests/test_directory_dependencies.py

@@ -0,0 +1,61 @@
+from types import SimpleNamespace
+import unittest
+from unittest.mock import Mock, patch
+
+from fastapi import HTTPException
+
+from govoplan_core.core.identity import CAPABILITY_IDENTITY_DIRECTORY, IdentityDirectory
+from govoplan_idm.backend.api.v1 import function_changes, relationships, routes
+
+
+class DirectoryDependencyTests(unittest.TestCase):
+    def test_identical_routes_preserve_missing_invalid_and_success_contracts(self) -> None:
+        valid = Mock(spec=IdentityDirectory)
+        for route in (relationships, routes):
+            for registry, expected_status, expected_detail in (
+                (None, 503, "Identity directory is unavailable"),
+                (Mock(has_capability=Mock(return_value=False)), 503, "Identity directory is unavailable"),
+                (Mock(has_capability=Mock(return_value=True), require_capability=Mock(return_value=object())), 500,
+                 f"Invalid capability: {CAPABILITY_IDENTITY_DIRECTORY}"),
+            ):
+                with self.subTest(route=route.__name__, status=expected_status), patch.object(route, "get_registry", return_value=registry):
+                    with self.assertRaises(HTTPException) as caught:
+                        route._identity_directory()
+                    self.assertEqual(expected_status, caught.exception.status_code)
+                    self.assertEqual(expected_detail, caught.exception.detail)
+            registry = Mock(has_capability=Mock(return_value=True), require_capability=Mock(return_value=valid))
+            with patch.object(route, "get_registry", return_value=registry):
+                self.assertIs(valid, route._identity_directory())
+            registry.has_capability.assert_called_once_with(CAPABILITY_IDENTITY_DIRECTORY)
+            registry.require_capability.assert_called_once_with(CAPABILITY_IDENTITY_DIRECTORY)
+
+    def test_each_call_resolves_current_registry_without_caching_authority(self) -> None:
+        for route in (relationships, routes):
+            valid = Mock(spec=IdentityDirectory)
+            registry = Mock(has_capability=Mock(return_value=True), require_capability=Mock(return_value=valid))
+            with patch.object(route, "get_registry", side_effect=[registry, None]) as get_registry:
+                self.assertIs(valid, route._identity_directory())
+                with self.assertRaises(HTTPException) as caught:
+                    route._identity_directory()
+                self.assertEqual(503, caught.exception.status_code)
+                self.assertEqual(2, get_registry.call_count)
+
+    def test_lookup_failure_is_not_silently_replaced_or_retried(self) -> None:
+        failure = RuntimeError("registry changed during lookup")
+        for route in (relationships, routes):
+            registry = Mock(has_capability=Mock(return_value=True), require_capability=Mock(side_effect=failure))
+            with patch.object(route, "get_registry", return_value=registry), self.assertRaises(RuntimeError) as caught:
+                route._identity_directory()
+            self.assertIs(failure, caught.exception)
+            self.assertEqual(1, registry.require_capability.call_count)
+
+    def test_function_changes_keeps_its_distinct_unavailable_contract(self) -> None:
+        registry = SimpleNamespace(capability=lambda _name: object())
+        with patch.object(function_changes, "get_registry", return_value=registry), self.assertRaises(HTTPException) as caught:
+            function_changes._identity_directory()
+        self.assertEqual(503, caught.exception.status_code)
+        self.assertEqual("The Identity directory is unavailable.", caught.exception.detail)
+
+
+if __name__ == "__main__":
+    unittest.main()