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)