feat(backend): verifie l extension TimescaleDB sur la sonde de disponibilite

/api/v1/health/ready interrogeait la base par un SELECT 1, qui ne distingue
pas un PostgreSQL nu d'un PostgreSQL avec TimescaleDB. La sonde lit desormais
pg_extension et repond 503 si l'extension manque, cas qui survient quand
db/init n'a pas ete joue.

- Premiere revision Alembic : aucune table, une garde qui refuse de
  s'appliquer sans l'extension.
- Tests du chemin nominal et de l'extension absente, plus un test marque
  `integration` contre la vraie base. pytest ecarte ce marqueur par defaut
  pour que make check reste jouable sans Docker.
- conftest recycle l'engine entre les tests : get_engine est lru_cache alors
  que pytest-asyncio ouvre une boucle par test, et les connexions asyncpg
  sont liees a leur boucle.

apps/backend/tests/api/test_health.py

@@ -20,6 +20,44 @@ async def test_liveness_exposes_service_metadata(client: AsyncClient) -> None:
     }
 
 
+async def test_readiness_reports_the_timescaledb_version(app: FastAPI, client: AsyncClient) -> None:
+    class ReadySession:
+        async def scalar(self, *_: object, **__: object) -> str:
+            return "2.22.1"
+
+    async def override() -> AsyncIterator[ReadySession]:
+        yield ReadySession()
+
+    app.dependency_overrides[get_session] = override
+
+    response = await client.get("/api/v1/health/ready")
+
+    assert response.status_code == 200
+    assert response.json() == {
+        "status": "ready",
+        "database": "reachable",
+        "timescaledb": "2.22.1",
+    }
+
+
+async def test_readiness_returns_503_when_the_extension_is_missing(
+    app: FastAPI, client: AsyncClient
+) -> None:
+    class SessionWithoutExtension:
+        async def scalar(self, *_: object, **__: object) -> None:
+            return None
+
+    async def override() -> AsyncIterator[SessionWithoutExtension]:
+        yield SessionWithoutExtension()
+
+    app.dependency_overrides[get_session] = override
+
+    response = await client.get("/api/v1/health/ready")
+
+    assert response.status_code == 503
+    assert response.json()["detail"] == "Extension TimescaleDB absente"
+
+
 @pytest.mark.parametrize(
     "failure",
     [
@@ -32,7 +70,7 @@ async def test_readiness_returns_503_when_database_is_unreachable(
     app: FastAPI, client: AsyncClient, failure: Exception
 ) -> None:
     class UnreachableSession:
-        async def execute(self, *_: object, **__: object) -> None:
+        async def scalar(self, *_: object, **__: object) -> None:
             raise failure
 
     async def override() -> AsyncIterator[UnreachableSession]:
@@ -49,3 +87,14 @@ async def test_readiness_returns_503_when_database_is_unreachable(
 @pytest.mark.parametrize("path", ["/openapi.json", "/metrics"])
 async def test_technical_endpoints_are_served(client: AsyncClient, path: str) -> None:
     assert (await client.get(path)).status_code == 200
+
+
+@pytest.mark.integration
+async def test_readiness_reaches_the_real_database(client: AsyncClient) -> None:
+    response = await client.get("/api/v1/health/ready")
+
+    assert response.status_code == 200, response.text
+    body = response.json()
+    assert body["status"] == "ready"
+    assert body["database"] == "reachable"
+    assert body["timescaledb"]

apps/backend/tests/conftest.py

@@ -6,6 +6,7 @@ from fastapi import FastAPI
 from httpx import ASGITransport, AsyncClient
 
 from app.core.config import get_settings
+from app.db.session import get_engine, get_session_factory
 from app.main import create_app
 
 
@@ -13,13 +14,24 @@ from app.main import create_app
 def environment() -> Iterator[None]:
     os.environ.setdefault("APP_SECRET_KEY", "secret-de-test")
     os.environ.setdefault(
-        "DATABASE_URL", "postgresql+asyncpg://enervision:enervision@localhost:5432/enervision_test"
+        "DATABASE_URL", "postgresql+asyncpg://enervision:change_me@localhost:5433/enervision_test"
     )
     get_settings.cache_clear()
     yield
     get_settings.cache_clear()
 
 
+# Piege : get_engine est lru_cache et pytest-asyncio ouvre une boucle par test. Sans ce
+# recyclage, le 2e test touchant vraiment la base heriterait d une boucle morte.
+@pytest.fixture(autouse=True)
+async def engine_per_test() -> AsyncIterator[None]:
+    yield
+    if get_engine.cache_info().currsize:
+        await get_engine().dispose()
+    get_engine.cache_clear()
+    get_session_factory.cache_clear()
+
+
 @pytest.fixture
 def app() -> FastAPI:
     return create_app()