feat(backend): expose GET /api/v1/sites/{site_id}/current pour l'issue #29

Ajoute la dernière mesure d'un site (SiteService.current), en réutilisant
la vérification d'existence déjà en place pour GET /sites/{site_id} :
SiteService gagne une dépendance ReadingRepository, sur le modèle de
composition déjà utilisé par StatsService/SensorService. Un site connu
sans lecture rend 200 avec les champs de mesure à null et
data_quality="critical" ; seul un site_id absent rend 404.

apps/backend/tests/api/test_openapi.py

@@ -31,6 +31,7 @@ ROUTES_A_ROLE = {
     ("POST", "/api/v1/users/{id}/password-reset"),
     ("GET", "/api/v1/sites"),
     ("GET", "/api/v1/sites/{site_id}"),
+    ("GET", "/api/v1/sites/{site_id}/current"),
     ("GET", "/api/v1/alerts"),
     ("GET", "/api/v1/recommendations"),
     ("GET", "/api/v1/recommendations/{recommendation_id}"),

apps/backend/tests/api/test_sites.py

@@ -1,4 +1,5 @@
 from collections.abc import Callable, Iterator
+from datetime import UTC, datetime
 from uuid import uuid4
 
 import pytest
@@ -9,7 +10,9 @@ from app.api.deps import get_current_principal, get_site_service
 from app.core.principal import Principal
 from app.core.roles import AccountKind, Role
 from app.models.energy import Site
-from app.services.site import SiteNotFoundError
+from app.services.site import SiteCurrentReading, SiteNotFoundError
+
+TIMESTAMP = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
 
 
 def principal(role: Role = Role.LECTEUR) -> Principal:
@@ -33,10 +36,28 @@ def site(site_id: str = "site-1") -> Site:
     )
 
 
+def lecture_actuelle(site_id: str = "site-1") -> SiteCurrentReading:
+    return SiteCurrentReading(
+        timestamp=TIMESTAMP,
+        site_id=site_id,
+        site_type="industriel",
+        consumption_kw=87.34,
+        consumption_kwh=87.34,
+        voltage_v=401.2,
+        current_a=132.5,
+        power_factor=0.923,
+        temperature_celsius=22.1,
+        humidity_percent=58.4,
+        null_reasons=[],
+        data_quality="good",
+    )
+
+
 class FauxService:
     def __init__(self, erreur: Exception | None = None) -> None:
         self._erreur = erreur
         self.site = site()
+        self.actuel = lecture_actuelle()
 
     async def list_all(self) -> list[Site]:
         return [self.site]
@@ -46,6 +67,11 @@ class FauxService:
             raise self._erreur
         return self.site
 
+    async def current(self, site_id: str) -> SiteCurrentReading:
+        if self._erreur is not None:
+            raise self._erreur
+        return self.actuel
+
 
 @pytest.fixture
 def lecteur_connecte(app: FastAPI) -> Iterator[None]:
@@ -109,6 +135,30 @@ async def test_get_site_returns_404_for_an_unknown_site(
     assert response.status_code == 404
 
 
+async def test_get_current_returns_the_latest_reading(
+    servi: Callable[..., FauxService], client: AsyncClient
+) -> None:
+    servi()
+
+    response = await client.get("/api/v1/sites/site-1/current")
+
+    assert response.status_code == 200
+    corps = response.json()
+    assert corps["site_id"] == "site-1"
+    assert corps["data_quality"] == "good"
+    assert corps["consumption_kw"] == 87.34
+
+
+async def test_get_current_returns_404_for_an_unknown_site(
+    servi: Callable[..., FauxService], client: AsyncClient
+) -> None:
+    servi(SiteNotFoundError("site-inconnu"))
+
+    response = await client.get("/api/v1/sites/site-inconnu/current")
+
+    assert response.status_code == 404
+
+
 async def test_list_sites_reaches_the_repository_through_the_session(
     lecteur_connecte: None, fake_session: Callable[..., None], client: AsyncClient
 ) -> None:

apps/backend/tests/services/test_site.py

@@ -1,8 +1,13 @@
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+
 import pytest
 
 from app.models.energy import Site
 from app.services.site import SiteNotFoundError, SiteService
 
+TIMESTAMP = datetime(2026, 9, 16, 12, 0, tzinfo=UTC)
+
 
 def site(site_id: str = "site-1") -> Site:
     return Site(
@@ -15,6 +20,21 @@ def site(site_id: str = "site-1") -> Site:
     )
 
 
+@dataclass
+class FauxLecture:
+    site_id: str
+    timestamp: datetime = TIMESTAMP
+    consumption_kw: float | None = 87.34
+    consumption_kwh: float | None = 87.34
+    voltage_v: float | None = 401.2
+    current_a: float | None = 132.5
+    power_factor: float | None = 0.923
+    temperature_celsius: float | None = 22.1
+    humidity_percent: float | None = 58.4
+    null_reasons: list[str] | None = field(default_factory=list)
+    data_quality: str | None = "good"
+
+
 class FakeRepository:
     def __init__(self, sites: list[Site]) -> None:
         self._sites = sites
@@ -26,24 +46,79 @@ class FakeRepository:
         return next((s for s in self._sites if s.site_id == site_id), None)
 
 
-async def test_list_all_returns_the_repository_sites() -> None:
-    service = SiteService(sites=FakeRepository([site("a"), site("b")]))
+class FauxDepotLectures:
+    def __init__(self, lectures: dict[str, FauxLecture]) -> None:
+        self._lectures = lectures
 
-    sites = await service.list_all()
+    async def latest_for_site(self, site_id: str) -> FauxLecture | None:
+        return self._lectures.get(site_id)
+
+
+def service(
+    sites: list[Site], lectures: dict[str, FauxLecture] | None = None
+) -> SiteService:
+    return SiteService(
+        sites=FakeRepository(sites),  # type: ignore[arg-type]
+        readings=FauxDepotLectures(lectures or {}),  # type: ignore[arg-type]
+    )
+
+
+async def test_list_all_returns_the_repository_sites() -> None:
+    svc = service([site("a"), site("b")])
+
+    sites = await svc.list_all()
 
     assert [s.site_id for s in sites] == ["a", "b"]
 
 
 async def test_get_by_id_returns_the_matching_site() -> None:
-    service = SiteService(sites=FakeRepository([site("a")]))
+    svc = service([site("a")])
 
-    trouve = await service.get_by_id("a")
+    trouve = await svc.get_by_id("a")
 
     assert trouve.site_id == "a"
 
 
 async def test_get_by_id_raises_when_the_site_is_unknown() -> None:
-    service = SiteService(sites=FakeRepository([]))
+    svc = service([])
 
     with pytest.raises(SiteNotFoundError):
-        await service.get_by_id("inconnu")
+        await svc.get_by_id("inconnu")
+
+
+async def test_current_raises_when_the_site_is_unknown() -> None:
+    svc = service([])
+
+    with pytest.raises(SiteNotFoundError):
+        await svc.current("inconnu")
+
+
+async def test_current_returns_every_field_as_null_when_the_site_has_no_reading() -> None:
+    svc = service([site("a")])
+
+    actuel = await svc.current("a")
+
+    assert actuel.timestamp is None
+    assert actuel.consumption_kw is None
+    assert actuel.data_quality == "critical"
+    assert actuel.null_reasons == []
+
+
+async def test_current_copies_every_field_from_the_latest_reading() -> None:
+    svc = service([site("a")], {"a": FauxLecture(site_id="a")})
+
+    actuel = await svc.current("a")
+
+    assert actuel.timestamp == TIMESTAMP
+    assert actuel.site_type == "industriel"
+    assert actuel.consumption_kw == 87.34
+    assert actuel.voltage_v == 401.2
+    assert actuel.data_quality == "good"
+
+
+async def test_current_treats_an_unknown_data_quality_as_critical() -> None:
+    svc = service([site("a")], {"a": FauxLecture(site_id="a", data_quality=None)})
+
+    actuel = await svc.current("a")
+
+    assert actuel.data_quality == "critical"