chore: checkpoint current backend/runtime changes

backend/tests/unit/services/base/test_redis_service.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import pytest
 
 from core.config.settings import RedisSettings
-from services.base.redis import RedisService
+from services.base.redis import RedisService, get_or_init_redis_client, redis_service
 
 
 class _FakeRedisClient:
@@ -96,3 +96,35 @@ def test_get_client_raises_before_init() -> None:
 
     with pytest.raises(RuntimeError):
         service.get_client()
+
+
+@pytest.mark.asyncio
+async def test_get_or_init_redis_client_initializes_when_needed(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fake_client = _FakeRedisClient()
+
+    async def _fake_initialize() -> bool:
+        return True
+
+    monkeypatch.setattr(type(redis_service), "is_initialized", property(lambda _: False))
+    monkeypatch.setattr(redis_service, "initialize", _fake_initialize)
+    monkeypatch.setattr(redis_service, "get_client", lambda: fake_client)
+
+    client = await get_or_init_redis_client()
+
+    assert client is fake_client
+
+
+@pytest.mark.asyncio
+async def test_get_or_init_redis_client_raises_when_init_fails(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    async def _fake_initialize() -> bool:
+        return False
+
+    monkeypatch.setattr(type(redis_service), "is_initialized", property(lambda _: False))
+    monkeypatch.setattr(redis_service, "initialize", _fake_initialize)
+
+    with pytest.raises(RuntimeError, match="Redis service initialization failed"):
+        await get_or_init_redis_client()

backend/tests/unit/services/base/test_service_registry.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
+import pytest
+
 from services.base.service_interface import (
     BaseServiceProvider,
     ServiceRegistry,
+    close_registered_services,
+    initialize_registered_services,
     register_service,
     register_service_instance,
 )
@@ -35,6 +39,17 @@ def test_register_service_and_create_service() -> None:
     assert created.get_service_info()["name"] == "dummy"
 
 
+def test_register_service_and_get_service() -> None:
+    @register_service("dummy-service-get")
+    class _RegisteredService(_DummyService):
+        pass
+
+    resolved = ServiceRegistry.get_service("dummy-service-get")
+
+    assert resolved is not None
+    assert resolved.get_service_info()["name"] == "dummy"
+
+
 def test_register_service_instance_returns_same_instance() -> None:
     instance = _DummyService("singleton")
 
@@ -47,3 +62,77 @@ def test_register_service_instance_returns_same_instance() -> None:
 
 def test_create_service_returns_none_for_missing() -> None:
     assert ServiceRegistry.create_service("missing-service") is None
+
+
+def test_get_service_returns_none_for_missing() -> None:
+    assert ServiceRegistry.get_service("missing-service") is None
+
+
+class _LifecycleService(BaseServiceProvider):
+    def __init__(self, name: str, recorder: list[str], fail_on_init: bool = False) -> None:
+        super().__init__(name)
+        self._recorder = recorder
+        self._fail_on_init = fail_on_init
+
+    async def initialize(self, **_: object) -> bool:
+        self._recorder.append(f"init:{self.service_name}")
+        if self._fail_on_init:
+            return False
+        self._set_initialized(True)
+        return True
+
+    async def close(self) -> bool:
+        self._recorder.append(f"close:{self.service_name}")
+        self._set_initialized(False)
+        return True
+
+    async def health_check(self) -> dict[str, object]:
+        return {"status": "healthy", "details": {}}
+
+
+@pytest.mark.asyncio
+async def test_initialize_registered_services_success() -> None:
+    recorder: list[str] = []
+    first = register_service_instance(
+        "lifecycle-success-first", _LifecycleService("first", recorder)
+    )
+    second = register_service_instance(
+        "lifecycle-success-second", _LifecycleService("second", recorder)
+    )
+
+    initialized, services = await initialize_registered_services(
+        ["lifecycle-success-first", "lifecycle-success-second"]
+    )
+
+    assert initialized is True
+    assert services == [first, second]
+    assert recorder == ["init:first", "init:second"]
+
+
+@pytest.mark.asyncio
+async def test_initialize_registered_services_failure_rolls_back() -> None:
+    recorder: list[str] = []
+    register_service_instance("lifecycle-fail-first", _LifecycleService("first", recorder))
+    register_service_instance(
+        "lifecycle-fail-second", _LifecycleService("second", recorder, fail_on_init=True)
+    )
+
+    initialized, services = await initialize_registered_services(
+        ["lifecycle-fail-first", "lifecycle-fail-second"]
+    )
+
+    assert initialized is False
+    assert services == []
+    assert recorder == ["init:first", "init:second", "close:first"]
+
+
+@pytest.mark.asyncio
+async def test_close_registered_services_closes_in_reverse_order() -> None:
+    recorder: list[str] = []
+    first = _LifecycleService("first", recorder)
+    second = _LifecycleService("second", recorder)
+
+    closed = await close_registered_services([first, second])
+
+    assert closed is True
+    assert recorder == ["close:second", "close:first"]

backend/tests/unit/services/base/test_supabase_service.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from core.config.settings import SupabaseSettings
+from services.base.supabase import SupabaseService
+
+
+@pytest.mark.asyncio
+async def test_initialize_success(monkeypatch: pytest.MonkeyPatch) -> None:
+    service = SupabaseService(settings=SupabaseSettings())
+    anon_client = MagicMock()
+    admin_client = MagicMock()
+
+    create_calls: list[tuple[str, str]] = []
+
+    def _fake_create_client(url: str, key: str) -> object:
+        create_calls.append((url, key))
+        return anon_client if len(create_calls) == 1 else admin_client
+
+    monkeypatch.setattr("services.base.supabase.create_client", _fake_create_client)
+
+    result = await service.initialize()
+
+    assert result is True
+    assert service.is_initialized is True
+    assert service.get_client() is anon_client
+    assert service.get_admin_client() is admin_client
+    assert len(create_calls) == 2
+
+
+@pytest.mark.asyncio
+async def test_initialize_failure(monkeypatch: pytest.MonkeyPatch) -> None:
+    service = SupabaseService(settings=SupabaseSettings())
+
+    def _fake_create_client(_: str, __: str) -> object:
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr("services.base.supabase.create_client", _fake_create_client)
+
+    result = await service.initialize()
+
+    assert result is False
+    assert service.is_initialized is False
+    with pytest.raises(RuntimeError):
+        service.get_client()
+
+
+@pytest.mark.asyncio
+async def test_close_clears_clients(monkeypatch: pytest.MonkeyPatch) -> None:
+    service = SupabaseService(settings=SupabaseSettings())
+
+    def _fake_create_client(_: str, __: str) -> object:
+        return MagicMock()
+
+    monkeypatch.setattr("services.base.supabase.create_client", _fake_create_client)
+
+    assert await service.initialize() is True
+    assert await service.close() is True
+    assert service.is_initialized is False
+    with pytest.raises(RuntimeError):
+        service.get_client()
+    with pytest.raises(RuntimeError):
+        service.get_admin_client()
+
+
+@pytest.mark.asyncio
+async def test_health_check_uninitialized() -> None:
+    service = SupabaseService(settings=SupabaseSettings())
+
+    health = await service.health_check()
+
+    assert health["status"] == "unhealthy"
+
+
+@pytest.mark.asyncio
+async def test_health_check_initialized(monkeypatch: pytest.MonkeyPatch) -> None:
+    service = SupabaseService(settings=SupabaseSettings())
+
+    anon_client = MagicMock()
+    anon_client.auth.get_session = MagicMock(return_value=None)
+
+    admin_list_users = MagicMock(return_value=SimpleNamespace(users=[]))
+    admin_client = MagicMock()
+    admin_client.auth.admin = SimpleNamespace(list_users=admin_list_users)
+
+    create_sequence = [anon_client, admin_client]
+
+    def _fake_create_client(_: str, __: str) -> object:
+        return create_sequence.pop(0)
+
+    monkeypatch.setattr("services.base.supabase.create_client", _fake_create_client)
+
+    assert await service.initialize() is True
+
+    health = await service.health_check()
+
+    assert health["status"] == "healthy"
+    admin_list_users.assert_called_once_with(page=1, per_page=1)
+
+
+def test_get_client_raises_before_init() -> None:
+    service = SupabaseService(settings=SupabaseSettings())
+
+    with pytest.raises(RuntimeError):
+        service.get_client()
+    with pytest.raises(RuntimeError):
+        service.get_admin_client()