File size: 12,755 Bytes
893a679
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5ae5d91
893a679
 
baaafb1
893a679
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5ae5d91
893a679
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
baaafb1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
"""
Le titre passe devant le corps du texte, et les fautes de frappe passent.

Ces tests figent trois comportements qui n'existaient pas :

1. Un document dont le TITRE porte le mot cherche arrive avant un document qui
   ne le porte que dans son corps. Mesure avant correctif, requete
   « nomination » : le document dont le titre ne contient PAS le mot sortait
   PREMIER (ts_rank_cd 0,4000) devant cinq documents dont le titre le porte
   (0,2000), parce qu'il le repete dans son corps.
2. Une faute de frappe trouve quand meme, sans jamais devancer une
   correspondance exacte.
3. Une seule loi ne peut plus prendre tout le budget de chunks. Mesure avant
   correctif : « avancement de grade » rendait 60 chunks issus de la MEME loi,
   donc UN SEUL document affiche.

Le principe de ces tests : ils assertent un ORDRE et des IDENTIFIANTS. Le test
qu'ils remplacent (`test_text_search_typo_tolerance`) n'assertait que
`isinstance(results, list)`, ne demandait meme pas de donnees, et passait sur une
base vide.

Usage:
    pytest tests/test_services/test_title_priority.py -v
"""

from datetime import date

import pytest

from app.models.law import Article, Law
from app.schemas.search import SearchRequest
from app.services.legal_domain_classifier import AFFAIRES
from app.services.postgres_search_service import (
    MAX_CHUNKS_PER_LAW,
    mots_significatifs,
    search_articles_pg,
)
from app.services.search_service import SearchService
from app.services.search_vectors import REINDEX_ARTICLES_SQL, REINDEX_LAWS_SQL

# Loi 200-204 : le mot « nomination » est dans le TITRE.
# Loi 210-211 : il n'est QUE dans le corps, et repete, ce qui suffisait a les
# faire passer devant.
TITLE_LAWS = (200, 201, 202, 203, 204)
BODY_LAWS = (210, 211)


@pytest.fixture
async def ranking_corpus(db_session, category_ids):
    """Cinq lois « nomination » par le titre, deux par le corps seulement."""
    from sqlalchemy import text as sql_text

    laws = []
    for offset, law_id in enumerate(TITLE_LAWS):
        laws.append(Law(
            id=law_id, reference=f"DEC-2024-{law_id}",
            title=f"Décret N°2024/{law_id} portant nomination d'un Directeur",
            content="Le présent décret sera enregistré et publié au Journal Officiel.",
            type="décret", language="fr", status="published",
            category_id=category_ids["Fonction Publique"],
            publication_date=date(2024, 1, 1 + offset),
        ))
    for offset, law_id in enumerate(BODY_LAWS):
        laws.append(Law(
            id=law_id, reference=f"DEC-2024-{law_id}",
            title=f"Décret N°2024/{law_id} portant approbation des statuts",
            # « nomination » repete : c'est ce qui faisait gagner ces lois.
            content=("La nomination des dirigeants, la nomination du président et "
                     "la nomination des commissaires obéissent aux statuts."),
            type="décret", language="fr", status="published",
            category_id=category_ids[AFFAIRES],
            publication_date=date(2024, 2, 1 + offset),
        ))
    db_session.add_all(laws)
    await db_session.flush()

    # 25 articles par loi : sans plafond par loi, UNE SEULE loi remplirait les
    # 60 chunks du budget et le front n'afficherait qu'un document. C'est le
    # comportement mesure sur le corpus reel avant correctif.
    articles = []
    for law in laws:
        for number in range(1, 26):
            articles.append(Article(
                law_id=law.id, number=str(number),
                content=(f"Article {number} du texte. " + (law.content or "")) * 2,
                order=number, kind="article", embed=True,
            ))
    db_session.add_all(articles)
    await db_session.commit()

    await db_session.execute(sql_text(REINDEX_LAWS_SQL))
    await db_session.execute(sql_text(REINDEX_ARTICLES_SQL))
    await db_session.commit()
    return laws


@pytest.fixture
def service(db_session):
    return SearchService(db_session, use_cache=False)


class TestTitleBeforeBody:
    @pytest.mark.asyncio
    async def test_a_title_match_leads_a_body_only_match(self, service, ranking_corpus):
        results = await service.text_search("nomination", limit=20)

        assert results, "aucun resultat"
        assert results[0].law_id in TITLE_LAWS, (
            f"le premier resultat est {results[0].law_id}, qui ne porte pas le mot "
            "dans son titre"
        )

    @pytest.mark.asyncio
    async def test_no_body_match_appears_before_a_title_match(self, service, ranking_corpus):
        scopes = [r.match_scope for r in await service.text_search("nomination", limit=20)]

        assert scopes, "aucun resultat"
        assert scopes == sorted(scopes, key=lambda s: s != "title"), (
            f"ordre des portees obtenu : {scopes}"
        )

    @pytest.mark.asyncio
    async def test_nothing_is_lost(self, service, ranking_corpus):
        """« Titre d'abord » ne veut pas dire « titre seulement »."""
        found = {r.law_id for r in await service.text_search("nomination", limit=20)}

        assert set(TITLE_LAWS) <= found
        assert set(BODY_LAWS) <= found, "les correspondances de corps ont disparu"

    @pytest.mark.asyncio
    async def test_match_scope_is_exact_not_guessed(self, service, ranking_corpus):
        by_law = {r.law_id: r.match_scope for r in await service.text_search("nomination", limit=20)}

        for law_id in TITLE_LAWS:
            assert by_law[law_id] == "title"
        for law_id in BODY_LAWS:
            assert by_law[law_id] == "body"

    @pytest.mark.asyncio
    async def test_a_word_absent_from_every_title_still_returns_results(
        self, service, ranking_corpus
    ):
        """La branche titre s'ajoute a la recherche de corps, elle ne la remplace pas."""
        results = await service.text_search("commissaires", limit=20)

        assert {r.law_id for r in results} >= set(BODY_LAWS)
        assert all(r.match_scope == "body" for r in results)

    @pytest.mark.asyncio
    async def test_the_stored_vector_carries_the_A_weight(self, db_session, ranking_corpus):
        """Sans `setweight`, tout ce qui precede est indecidable."""
        from sqlalchemy import text as sql_text

        vector = (await db_session.execute(sql_text(
            "SELECT search_vector::text FROM laws WHERE id = :i"), {"i": TITLE_LAWS[0]}
        )).scalar_one()

        assert "A" in vector, "aucun lexeme de poids A : la ponderation est absente"


class TestTypoTolerance:
    @pytest.mark.asyncio
    async def test_a_typo_finds_exactly_the_right_laws(self, service, ranking_corpus):
        """« nominaton » ne rend RIEN en plein texte ; le trigramme rattrape."""
        results = await service.text_search("nominaton", limit=20)

        assert {r.law_id for r in results} == set(TITLE_LAWS)
        assert all(r.match_scope == "title" for r in results)

    @pytest.mark.asyncio
    async def test_a_typo_below_the_default_threshold_is_still_caught(
        self, service, ranking_corpus
    ):
        """
        word_similarity('nominasion', <titre>) = 0,571 : SOUS le defaut de
        session de l'operateur %> (0,6), au-dessus du seuil configure (0,5).
        Ce test echoue si le `SET LOCAL` disparait — la faute moyenne serait
        alors silencieusement perdue.
        """
        results = await service.text_search("nominasion", limit=20)

        assert {r.law_id for r in results} == set(TITLE_LAWS)

    @pytest.mark.asyncio
    async def test_noise_is_not_a_typo(self, service, ranking_corpus):
        """« fonciere » plafonne a 0,333 sur ce corpus : du bruit, pas une faute."""
        assert await service.text_search("fonciere", limit=20) == []

    @pytest.mark.asyncio
    async def test_an_exact_match_is_never_pushed_down_by_a_fuzzy_one(
        self, service, ranking_corpus
    ):
        results = await service.text_search("nomination", limit=20)

        assert results[0].law_id in TITLE_LAWS
        assert results[0].relevance_score >= max(r.relevance_score for r in results)


class TestMotsSignificatifs:
    """La passe floue compare chaque mot qui designe quelque chose, et eux seuls."""

    @pytest.mark.parametrize("requete, attendus", [
        ("peine de mort au cameroun", ["peine", "mort"]),
        ("Loi portant Code Minier du Cameroun", ["code", "minier"]),
        ("nominaton", ["nominaton"]),
        ("Fonction Publique : statut général", ["fonction", "publique", "statut", "general"]),
        ("code code minier", ["code", "minier"]),
        ("de la République du Cameroun", []),
        ("", []),
    ])
    def test_mots_retenus(self, requete, attendus):
        assert mots_significatifs(requete) == attendus


# Loi 300 : titre en « ... de Base au Cameroun », sans rapport avec la requete.
# Loi 301 : les articles parlent de la peine de mort.
DECRET_DE_PRET, CODE_PENAL = 300, 301


@pytest.fixture
async def peine_corpus(db_session, category_ids):
    from sqlalchemy import text as sql_text

    db_session.add_all([
        Law(
            id=DECRET_DE_PRET, reference="PRC-10703",
            # Titre reel du corpus : word_similarity avec la requete entiere,
            # 0,516, au-dessus du seuil de 0,5.
            title=("Décret N°2026/176 du 4 mai 2026 ratifiant l'Accord de Prêt pour le "
                   "financement du Projet d'Appui à l'Education de Base au Cameroun (PAEBC)"),
            content="Est ratifié l'Accord de Prêt conclu entre la République du Cameroun et la Banque.",
            type="décret", language="fr", status="published",
            category_id=category_ids["Fonction Publique"], publication_date=date(2026, 5, 4),
        ),
        Law(
            id=CODE_PENAL, reference="LOI-2016-007",
            title="Loi N° 2016/007 du 12 juillet 2016 portant Code Pénal",
            content="Au Cameroun, la peine de mort est exécutée par les armes.",
            type="loi", language="fr", status="published",
            category_id=category_ids[AFFAIRES], publication_date=date(2016, 7, 12),
        ),
    ])
    await db_session.flush()
    db_session.add(Article(
        law_id=CODE_PENAL, number="22", order=1, kind="article", embed=True,
        content="Au Cameroun, la peine de mort est exécutée par les armes ou par pendaison.",
    ))
    await db_session.commit()
    await db_session.execute(sql_text(REINDEX_LAWS_SQL))
    await db_session.execute(sql_text(REINDEX_ARTICLES_SQL))
    await db_session.commit()


class TestPhraseRequest:
    @pytest.mark.asyncio
    async def test_common_words_do_not_make_a_title_match(self, service, peine_corpus):
        """
        Requete reelle. Comparee d'un bloc, elle passait le seuil sur « de »,
        « au » et « cameroun » : le decret de pret sortait PREMIER, comme
        correspondance de titre, devant le Code penal.
        """
        results = await service.text_search("peine de mort au cameroun", limit=20)

        assert results, "aucun resultat"
        assert results[0].law_id == CODE_PENAL
        assert DECRET_DE_PRET not in {r.law_id for r in results}

    @pytest.mark.asyncio
    async def test_a_typo_in_a_phrase_is_still_caught(self, service, peine_corpus):
        """Mot par mot, la tolerance aux fautes reste : « penal » mal ecrit."""
        results = await service.text_search("code penall", limit=20)

        assert results and results[0].law_id == CODE_PENAL


class TestPerLawCap:
    @pytest.mark.asyncio
    async def test_one_law_cannot_take_the_whole_budget(self, db_session, ranking_corpus):
        """
        Sans plafond, une loi dont le titre correspond marque le meme score sur
        TOUS ses articles et rafle le budget. Mesure sur le corpus reel :
        « avancement de grade » rendait 60 chunks, tous de la meme loi.
        """
        from collections import Counter

        chunks = await search_articles_pg(db_session, "nomination", None, 60, 0)
        per_law = Counter(c.law_id for c in chunks)

        assert per_law, "aucun chunk"
        assert max(per_law.values()) <= MAX_CHUNKS_PER_LAW
        assert len(per_law) >= 4, f"un seul document remonte : {dict(per_law)}"


class TestTotalCount:
    @pytest.mark.asyncio
    async def test_total_counts_documents_not_the_page(self, service, ranking_corpus):
        """
        `total` valait `len(results)` APRES la decoupe de page, donc toujours
        <= limit : le front calcule `Math.ceil(total / 20)` et n'affichait
        jamais plus d'une page.
        """
        response = await service.search(
            SearchRequest(query="nomination", mode="text", limit=3)
        )

        assert len(response.results) == 3
        assert response.total >= 7, f"total={response.total}, attendu au moins 7"