Spaces:
Runtime error
Runtime error
File size: 6,014 Bytes
893a679 1a3d3f5 893a679 1a3d3f5 893a679 1a3d3f5 893a679 1a3d3f5 893a679 1a3d3f5 893a679 1a3d3f5 893a679 1a3d3f5 893a679 1a3d3f5 893a679 1a3d3f5 893a679 f508b99 1a3d3f5 893a679 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 | """
Tests de l'API de classification.
L'ancienne route `GET /api/v1/classifier/categories` renvoyait un dictionnaire
code en dur qui contredisait `GET /api/v1/categories`, servi depuis la base.
Deux listes de categories concurrentes sur la meme API garantissaient qu'un
client se fie a la mauvaise ; ces tests figent sa disparition.
`POST /classify` coute une requete Groq : elle est reservee aux
administrateurs, et dit 503 (avec Retry-After) quand le modele ne peut pas
repondre, au lieu d'inventer un domaine. Le classifieur est double : ces
tests portent sur la route, pas sur le modele.
Usage:
pytest tests/test_api/test_classifier_routes.py -v
"""
import pytest
from httpx import AsyncClient
from app.main import app
from app.services.legal_domain_classifier import (
CANONICAL_DOMAINS,
FINANCES,
FONCTION_PUBLIQUE,
ClassementIndisponible,
DomainResult,
get_legal_domain_classifier,
)
URL = "/api/v1/classifier/classify"
class _Classeur:
"""Doublure : rend `domaine`, ou leve `erreur`."""
def __init__(self, domaine=FINANCES, erreur=None):
self.domaine = domaine
self.erreur = erreur
self.titres = []
async def classify_async(self, title, content="", doc_type=None):
self.titres.append(title)
if self.erreur:
raise self.erreur
return DomainResult(
domain=self.domaine, confidence=0.9, rule="groq:doublure", source="groq",
runners_up=((FONCTION_PUBLIQUE, 0.72),),
)
def health_check(self):
return {"status": "healthy", "domains": len(CANONICAL_DOMAINS)}
@pytest.fixture
def classeur():
"""Installe la doublure derriere la dependance de la route."""
doublure = _Classeur()
app.dependency_overrides[get_legal_domain_classifier] = lambda: doublure
try:
yield doublure
finally:
app.dependency_overrides.pop(get_legal_domain_classifier, None)
class TestAcces:
async def test_anonyme_refuse(self, client: AsyncClient, classeur):
response = await client.post(URL, json={"title": "Loi de finances"})
assert response.status_code == 401
assert classeur.titres == []
async def test_utilisateur_sans_role_refuse(self, client: AsyncClient, auth_headers, classeur):
response = await client.post(URL, json={"title": "Loi de finances"}, headers=auth_headers)
assert response.status_code == 403
assert classeur.titres == []
class TestClassify:
async def test_domaine_et_identifiant_resolu_en_base(
self, admin_client: AsyncClient, db_session, classeur
):
"""
L'identifiant rendu doit designer, en base, la ligne portant ce nom.
C'est precisement ce que l'ancien code ne faisait pas : il rendait une
position dans un dictionnaire Python.
"""
from sqlalchemy import select
from app.models.law import Category
response = await admin_client.post(
URL, json={"title": "Loi N°2015/019 portant Loi de finances pour l'exercice 2016"}
)
assert response.status_code == 200
body = response.json()
assert body["domain"] == FINANCES
assert body["rule"] == "groq:doublure"
assert body["runners_up"] == [{"domain": FONCTION_PUBLIQUE, "score": 0.72}]
name = (await db_session.execute(
select(Category.name).where(Category.id == body["category_id"])
)).scalar_one()
assert name == body["domain"]
async def test_requete_vide_refusee(self, admin_client: AsyncClient, classeur):
response = await admin_client.post(URL, json={"title": "", "text": " "})
assert response.status_code == 422
assert classeur.titres == []
async def test_texte_reduit_aux_visas_rend_422(self, admin_client: AsyncClient, classeur):
"""Une erreur de la demande, qu'un nouvel essai ne corrigera pas : pas de 503."""
from app.services.legal_domain_classifier import DocumentVide
classeur.erreur = DocumentVide("document vide")
response = await admin_client.post(
URL, json={"title": "", "text": "Vu la Constitution ;\nVu le décret n°2011/408 ;"}
)
assert response.status_code == 422
async def test_classement_indisponible_rend_503(self, admin_client: AsyncClient, classeur):
"""Jamais de domaine invente : l'ancien code rendait Droit Administratif."""
classeur.erreur = ClassementIndisponible("quota Groq", retry_after=41.2, quota=True)
response = await admin_client.post(URL, json={"title": "Loi de finances"})
assert response.status_code == 503
assert response.headers["retry-after"] == "42"
async def test_503_sans_delai_connu(self, admin_client: AsyncClient, classeur):
classeur.erreur = ClassementIndisponible("panne")
response = await admin_client.post(URL, json={"title": "Loi de finances"})
assert response.status_code == 503
assert "retry-after" not in response.headers
class TestRemovedEndpoint:
async def test_hardcoded_categories_endpoint_is_gone(self, client: AsyncClient, db_session):
response = await client.get("/api/v1/classifier/categories")
assert response.status_code == 404
async def test_categories_come_from_the_database(self, client: AsyncClient, db_session):
"""La seule liste de categories servie par l'API est celle de la base."""
response = await client.get("/api/v1/categories")
assert response.status_code == 200
names = {row["name"] for row in response.json()}
assert names == set(CANONICAL_DOMAINS)
class TestHealth:
async def test_health_lists_the_canonical_domains(self, client: AsyncClient):
response = await client.get("/api/v1/classifier/health")
assert response.status_code == 200
body = response.json()
assert body["status"] == "healthy"
assert body["canonical_domains"] == list(CANONICAL_DOMAINS)
|