Etape 14 : tests du code ajoute (54 nouveaux tests)

Le code ecrit pendant ce chantier n'avait aucun test.

tests/test_api/test_auth_routes.py (16) — connexion JSON et formulaire, mot de
passe faux, email inconnu avec message IDENTIQUE (verifie explicitement : les
distinguer permettrait d'enumerer les comptes), last_login_at, /auth/me avec et
sans jeton, jeton malforme, matrice d'autorisation 401/403/200.
Un test parcourt les routes montees et echoue si un chemin sous /admin/ ou
/ocr/ n'a aucune dependance d'authentification : c'est lui qui rattrapera le
prochain endpoint ajoute sans garde.

tests/test_services/test_llama_parse_service.py (18) — respx intercepte httpx,
donc aucun appel reseau et aucun credit consomme. Couvre le nettoyage des
cachets (bloc multiligne, cachet condense sur une ligne, en-tete legitime
CONSERVE, filigrane, tableaux preserves, <sup> retire), le cache sha256
(verifie qu'un second appel ne repart pas sur le reseau), l'echec de job,
l'absence de retry sur 401, et les quatre formes de reponse de l'API v2.

tests/test_utils/test_chunk_refiner.py (20) — les 7 regles. Notamment :
l'en-tete de contexte est dans embed_text et jamais dans content ; PARA_n n'est
pas annonce comme un numero d'article (sinon le chatbot citerait des references
inexistantes) ; une suite de page n'est pas confondue avec des visas ; 20
personnes donnent 1 vecteur et non 20, avec appariement nom/matricule verifie ;
un tableau n'est jamais coupe ; et rien n'est jamais supprime, seulement
hierarchise.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tests/test_api/test_auth_routes.py

@@ -0,0 +1,168 @@
+"""
+Tests des routes d'authentification.
+
+Aucun test ne couvrait l'authentification : elle n'existait pas (les endpoints
+d'administration passaient par des stubs renvoyant un dictionnaire en dur).
+"""
+
+import pytest
+from httpx import AsyncClient
+
+PASSWORD = "MotDePasseTest123"
+
+
+class TestLogin:
+    """Connexion."""
+
+    @pytest.mark.asyncio
+    async def test_login_json_succeeds(self, client: AsyncClient, test_admin_user):
+        r = await client.post(
+            "/api/v1/auth/login/json",
+            json={"email": test_admin_user.email, "password": PASSWORD},
+        )
+        assert r.status_code == 200
+        body = r.json()
+        assert body["access_token"]
+        assert body["token_type"] == "bearer"
+        assert body["role"] == "admin"
+
+    @pytest.mark.asyncio
+    async def test_login_form_succeeds(self, client: AsyncClient, test_admin_user):
+        """Le formulaire OAuth2 alimente le bouton Authorize de /docs."""
+        r = await client.post(
+            "/api/v1/auth/login",
+            data={"username": test_admin_user.email, "password": PASSWORD},
+        )
+        assert r.status_code == 200
+        assert r.json()["access_token"]
+
+    @pytest.mark.asyncio
+    async def test_wrong_password_is_rejected(self, client: AsyncClient, test_user):
+        r = await client.post(
+            "/api/v1/auth/login/json",
+            json={"email": test_user.email, "password": "mauvais"},
+        )
+        assert r.status_code == 401
+
+    @pytest.mark.asyncio
+    async def test_unknown_email_gives_same_message(
+        self, client: AsyncClient, test_user
+    ):
+        """
+        Message identique pour email inconnu et mot de passe faux.
+
+        Les distinguer permettrait d'énumérer les comptes existants.
+        """
+        wrong_pw = await client.post(
+            "/api/v1/auth/login/json",
+            json={"email": test_user.email, "password": "mauvais"},
+        )
+        unknown = await client.post(
+            "/api/v1/auth/login/json",
+            json={"email": "personne@nulle-part.cm", "password": "mauvais"},
+        )
+        assert wrong_pw.status_code == unknown.status_code == 401
+        assert wrong_pw.json()["detail"] == unknown.json()["detail"]
+
+    @pytest.mark.asyncio
+    async def test_last_login_is_recorded(
+        self, client: AsyncClient, test_admin_user, db_session
+    ):
+        assert test_admin_user.last_login_at is None
+        await client.post(
+            "/api/v1/auth/login/json",
+            json={"email": test_admin_user.email, "password": PASSWORD},
+        )
+        await db_session.refresh(test_admin_user)
+        assert test_admin_user.last_login_at is not None
+
+
+class TestMe:
+    """Identité associée au jeton."""
+
+    @pytest.mark.asyncio
+    async def test_me_requires_a_token(self, client: AsyncClient):
+        assert (await client.get("/api/v1/auth/me")).status_code == 401
+
+    @pytest.mark.asyncio
+    async def test_me_rejects_a_bogus_token(self, client: AsyncClient):
+        r = await client.get(
+            "/api/v1/auth/me", headers={"Authorization": "Bearer pas-un-jeton"}
+        )
+        assert r.status_code == 401
+
+    @pytest.mark.asyncio
+    async def test_me_returns_the_account(
+        self, client: AsyncClient, test_user, auth_headers
+    ):
+        r = await client.get("/api/v1/auth/me", headers=auth_headers)
+        assert r.status_code == 200
+        assert r.json()["email"] == test_user.email
+
+
+class TestAuthorization:
+    """Contrôle d'accès par rôle."""
+
+    # (méthode, chemin) — endpoints qui ne doivent jamais être publics
+    PROTECTED = [
+        ("get", "/api/v1/admin/users"),
+        ("post", "/api/v1/search/reindex"),
+        ("get", "/api/v1/search/stats"),
+        ("post", "/api/v1/upload/cleanup"),
+        ("get", "/api/v1/batch-upload/status"),
+    ]
+
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize("method,path", PROTECTED)
+    async def test_anonymous_access_is_refused(self, client: AsyncClient, method, path):
+        r = await getattr(client, method)(path)
+        assert r.status_code == 401, f"{path} accessible sans jeton"
+
+    @pytest.mark.asyncio
+    async def test_plain_user_cannot_reach_admin(
+        self, client: AsyncClient, auth_headers
+    ):
+        """Un jeton valide mais sans privilège doit donner 403, pas 200."""
+        r = await client.get("/api/v1/admin/users", headers=auth_headers)
+        assert r.status_code == 403
+
+    @pytest.mark.asyncio
+    async def test_admin_reaches_admin(self, client: AsyncClient, admin_headers):
+        r = await client.get("/api/v1/admin/users", headers=admin_headers)
+        assert r.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_no_protected_route_lacks_a_guard(self):
+        """
+        Filet de sécurité : parcourt les routes montées et échoue si l'une des
+        préfixes protégés n'a aucune dépendance d'authentification.
+
+        C'est ce test qui rattrapera le prochain endpoint ajouté sans garde.
+        """
+        from fastapi.routing import APIRoute
+
+        from app.main import app
+
+        prefixes = ("/api/v1/admin/", "/api/v1/ocr/")
+        exempt = {"/api/v1/admin/health"}
+
+        unguarded = []
+        for route in _iter_routes(app):
+            if not isinstance(route, APIRoute):
+                continue
+            if route.path in exempt or not route.path.startswith(prefixes):
+                continue
+            names = {d.name for d in route.dependant.dependencies}
+            if not any("current" in (n or "") for n in names):
+                unguarded.append(f"{sorted(route.methods)} {route.path}")
+
+        assert not unguarded, f"routes sans garde : {unguarded}"
+
+
+def _iter_routes(app):
+    """Parcourt les routes, y compris celles imbriquées dans les routeurs inclus."""
+    stack = list(app.routes)
+    while stack:
+        route = stack.pop()
+        yield route
+        stack.extend(getattr(route, "routes", []) or [])

tests/test_services/test_llama_parse_service.py

@@ -0,0 +1,201 @@
+"""
+Tests du service d'extraction LlamaParse.
+
+Aucun appel réseau : `respx` intercepte httpx. Sans cela ces tests
+consommeraient des crédits LlamaParse à chaque exécution.
+"""
+
+import json
+
+import httpx
+import pytest
+import respx
+
+from app.services.llama_parse_service import (
+    LlamaParseError,
+    LlamaParseService,
+    _strip_stamp_blocks,
+)
+
+BASE = "https://api.cloud.llamaindex.ai/api/v2/parse"
+
+
+@pytest.fixture
+def service(tmp_path):
+    return LlamaParseService(api_key="cle-de-test", cache_dir=tmp_path / "cache")
+
+
+@pytest.fixture
+def pdf(tmp_path):
+    p = tmp_path / "doc.pdf"
+    p.write_bytes(b"%PDF-1.4\ncontenu\n%%EOF")
+    return p
+
+
+class TestNettoyageDesCachets:
+    """
+    Retrait du cachet officiel apposé sur chaque page du corpus prc.cm.
+
+    LlamaParse restitue ce cachet en texte ; sans nettoyage il pollue le FTS et
+    les embeddings de tous les documents.
+    """
+
+    def test_bloc_multiligne_retire(self):
+        md = (
+            "Article 1er. Contenu juridique réel.\n\n"
+            "PRESIDENCE DE LA REPUBLIQUE\n"
+            "SERVICE DU FICHIER LEGISLATIF ET REGLEMENTAIRE\n"
+            "COPIE CERTIFIEE CONFORME\n"
+            "CERTIFIED TRUE COPY\n\n"
+            "Article 2. Autre contenu."
+        )
+        out = _strip_stamp_blocks(md)
+        assert "COPIE CERTIFIEE CONFORME" not in out
+        assert "Article 1er. Contenu juridique réel." in out
+        assert "Article 2. Autre contenu." in out
+
+    def test_cachet_sur_une_seule_ligne_retire(self):
+        """LlamaParse condense parfois tout le cachet sur une ligne."""
+        md = (
+            "Article 1er. Contenu.\n"
+            "[signature: PRESIDENCE DE LA REPUBLIQUE SECRETARIAT GENERAL "
+            "COPIE CERTIFIEE CONFORME CERTIFIED TRUE COPY]\n"
+        )
+        out = _strip_stamp_blocks(md)
+        assert "CERTIFIED TRUE COPY" not in out
+        assert "Article 1er. Contenu." in out
+
+    def test_en_tete_legitime_conserve(self):
+        """
+        Beaucoup de décrets portent « PRESIDENCE DE LA REPUBLIQUE » comme
+        autorité émettrice : c'est du contenu, pas un tampon. Une seule phrase
+        du vocabulaire ne doit donc rien déclencher.
+        """
+        md = "PRESIDENCE DE LA REPUBLIQUE\n\nDECRET N° 2024/191 du 4 juin 2024"
+        out = _strip_stamp_blocks(md)
+        assert "PRESIDENCE DE LA REPUBLIQUE" in out
+        assert "DECRET N° 2024/191" in out
+
+    def test_filigrane_retire(self):
+        md = "Article 1er.\nw\nw\nw\n.prc\n.cm\nContenu."
+        out = _strip_stamp_blocks(md)
+        assert "Article 1er." in out and "Contenu." in out
+        assert "\nw\n" not in f"\n{out}\n"
+
+    def test_tableaux_conserves(self):
+        """Les <table> portent du sens (annexes budgétaires) — jamais retirés."""
+        md = "<table><tr><td>Recettes</td><td>66 900 000</td></tr></table>"
+        assert "<table>" in _strip_stamp_blocks(md)
+
+    def test_balises_inline_retirees(self):
+        """<sup> casse la détection d'article : ARTICLE 1<sup>ER</sup>."""
+        assert _strip_stamp_blocks("**ARTICLE 1<sup>ER</sup>**") == "**ARTICLE 1ER**"
+
+
+class TestDisponibilite:
+    def test_indisponible_sans_cle(self, tmp_path, monkeypatch):
+        # api_key="" retombe volontairement sur settings.LLAMA_CLOUD_API_KEY :
+        # il faut donc neutraliser aussi la configuration pour tester ce cas.
+        monkeypatch.setattr(
+            "app.services.llama_parse_service.settings.LLAMA_CLOUD_API_KEY", ""
+        )
+        assert not LlamaParseService(api_key="", cache_dir=tmp_path).is_available()
+
+    def test_disponible_avec_cle(self, service):
+        assert service.is_available()
+
+
+class TestExtraction:
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_extraction_et_marqueurs_de_page(self, service, pdf):
+        respx.post(f"{BASE}/upload").mock(
+            return_value=httpx.Response(200, json={"job": {"id": "job-1"}})
+        )
+        respx.get(f"{BASE}/job-1").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "job": {"status": "COMPLETED"},
+                    "markdown": [{"markdown": "Page une"}, {"markdown": "Page deux"}],
+                },
+            )
+        )
+        service.POLL_INTERVAL = 0
+        text = await service.extract_text(pdf)
+        # Les marqueurs alimentent Article.page_number via text_chunker
+        assert "<<PAGE:1>>" in text and "<<PAGE:2>>" in text
+        assert "Page une" in text and "Page deux" in text
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_cache_evite_un_second_appel(self, service, pdf):
+        upload = respx.post(f"{BASE}/upload").mock(
+            return_value=httpx.Response(200, json={"job": {"id": "job-1"}})
+        )
+        respx.get(f"{BASE}/job-1").mock(
+            return_value=httpx.Response(
+                200,
+                json={"job": {"status": "COMPLETED"}, "markdown": [{"markdown": "Texte"}]},
+            )
+        )
+        service.POLL_INTERVAL = 0
+        first = await service.extract_text(pdf)
+        second = await service.extract_text(pdf)
+        assert first == second
+        assert upload.call_count == 1, "le second appel aurait dû être servi par le cache"
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_job_en_echec_leve(self, service, pdf):
+        respx.post(f"{BASE}/upload").mock(
+            return_value=httpx.Response(200, json={"job": {"id": "job-1"}})
+        )
+        respx.get(f"{BASE}/job-1").mock(
+            return_value=httpx.Response(
+                200,
+                json={"job": {"status": "FAILED", "error_message": "document illisible"}},
+            )
+        )
+        service.POLL_INTERVAL = 0
+        with pytest.raises(LlamaParseError, match="document illisible"):
+            await service.extract_text(pdf)
+
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_cle_refusee_ne_declenche_pas_de_retry(self, service, pdf):
+        """Un 401 est définitif : réessayer 4 fois ne ferait que perdre du temps."""
+        route = respx.post(f"{BASE}/upload").mock(
+            return_value=httpx.Response(401, text="cle invalide")
+        )
+        service.POLL_INTERVAL = 0
+        with pytest.raises(LlamaParseError):
+            await service.extract_text(pdf)
+        assert route.call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_fichier_absent(self, service, tmp_path):
+        with pytest.raises(LlamaParseError, match="introuvable"):
+            await service.extract_text(tmp_path / "absent.pdf")
+
+
+class TestNormalisationDesReponses:
+    """L'API v2 renvoie le markdown sous plusieurs formes selon les options."""
+
+    def test_liste_de_pages(self):
+        pages = LlamaParseService._pages_from(
+            {"markdown": [{"markdown": "a"}, {"markdown": "b"}]}
+        )
+        assert pages == ["a", "b"]
+
+    def test_chaine_unique(self):
+        assert LlamaParseService._pages_from({"markdown": "seule"}) == ["seule"]
+
+    def test_champ_pages(self):
+        assert LlamaParseService._pages_from({"pages": [{"markdown": "x"}]}) == ["x"]
+
+    def test_markdown_full(self):
+        assert LlamaParseService._pages_from({"markdown_full": "tout"}) == ["tout"]
+
+    def test_reponse_vide(self):
+        assert LlamaParseService._pages_from({}) == []

tests/test_utils/test_chunk_refiner.py

@@ -0,0 +1,232 @@
+"""
+Tests du raffineur de chunks (règles R2 à R7).
+
+Le module n'avait aucun test. Ces règles déterminent directement ce que le
+modèle reçoit en contexte : une erreur ici se traduit par des réponses sans
+fondement, sans qu'aucune exception ne soit levée.
+"""
+
+import pytest
+
+from app.utils.chunk_refiner import (
+    DocumentContext,
+    normalize_for_chunking,
+    refine,
+)
+
+
+@pytest.fixture
+def contexte():
+    return DocumentContext(
+        reference="Décret n° 2024/191",
+        title="portant ratification de la Convention de Crédit-Acheteur",
+        doc_type="decret",
+        date="4 juin 2024",
+        category="Finances publiques",
+        language="fr",
+    )
+
+
+def chunk(number, content, **kw):
+    """Construit un chunk au format produit par text_chunker."""
+    base = {
+        "number": number,
+        "title": None,
+        "content": content,
+        "position": 0,
+        "parent_id": None,
+        "section": None,
+        "word_count": len(content.split()),
+        "char_count": len(content),
+        "page_number": 1,
+    }
+    base.update(kw)
+    return base
+
+
+class TestNormalisation:
+    """Prépare le markdown OCR pour text_chunker."""
+
+    def test_gras_markdown_retire(self):
+        """**ARTICLE 1ER** empêche la détection : le motif attend « Article »
+        en début de ligne, pas « **Article »."""
+        assert "ARTICLE 1ER" in normalize_for_chunking("**ARTICLE 1ER**: Contenu")
+        assert "**" not in normalize_for_chunking("**ARTICLE 1ER**: Contenu")
+
+    def test_titre_markdown_retire(self):
+        assert normalize_for_chunking("# Titre").strip() == "Titre"
+
+    def test_lettres_espacees_recollees(self):
+        """L'OCR restitue l'interlettrage des titres : « A R R Ê T E »."""
+        assert "ARRÊTE" in normalize_for_chunking("A R R Ê T E :")
+
+    def test_marqueurs_de_page_preserves(self):
+        assert "<<PAGE:3>>" in normalize_for_chunking("<<PAGE:3>>\nTexte")
+
+    def test_tableaux_preserves(self):
+        out = normalize_for_chunking("<table><tr><td>a</td></tr></table>")
+        assert "<table>" in out
+
+
+class TestR2Contextualisation:
+    def test_embed_text_porte_le_contexte(self, contexte):
+        r = refine([chunk("3", "La dépense résultant des présentes dispositions." * 5)], contexte)
+        embeddable = r.embeddable
+        assert embeddable, "le chunk aurait dû être vectorisable"
+        texte = embeddable[0]["embed_text"]
+        # Sans en-tête, « La dépense résultant des présentes dispositions » est
+        # un chunk orphelin : ni le lecteur ni l'embedding ne savent de quoi il parle.
+        assert "Décret n° 2024/191" in texte
+        assert "Finances publiques" in texte
+        assert "Article 3" in texte
+
+    def test_pas_de_libelle_article_pour_un_repli_paragraphe(self, contexte):
+        """PARA_n n'est pas un vrai numéro : l'annoncer ferait citer au chatbot
+        des références inexistantes."""
+        r = refine([chunk("PARA_2", "Contenu quelconque suffisamment long." * 4)], contexte)
+        assert "Article PARA_2" not in r.embeddable[0]["embed_text"]
+
+    def test_contenu_non_modifie(self, contexte):
+        """Le contexte va dans embed_text, jamais dans content (affichage/citation)."""
+        contenu = "Article utile avec un contenu suffisamment long pour être conservé."
+        r = refine([chunk("1", contenu)], contexte)
+        assert r.chunks[0]["content"] == contenu
+
+
+class TestR3Visas:
+    def test_visas_hors_index_et_cites(self, contexte):
+        visas = (
+            "Vu la Constitution ;\n"
+            "Vu la loi n° 2007-006 du 26 décembre 2007 portant régime financier ;\n"
+            "Vu le décret n° 2011/412 du 09 décembre 2011 portant réorganisation ;"
+        )
+        r = refine([chunk("LEGAL_BASIS", visas)], contexte)
+        assert r.legal_basis is not None
+        assert not r.embeddable, "les visas ne doivent pas être vectorisés"
+        # Présents dans chaque document, ils domineraient le FTS et écraseraient
+        # la similarité cosinus.
+        assert any("2007-006" in c for c in r.citations)
+        assert any("2011/412" in c for c in r.citations)
+
+    def test_suite_de_page_reste_indexee(self, contexte):
+        """
+        text_chunker étiquette LEGAL_BASIS tout le texte précédant le premier
+        article. Sur une page qui ne commence pas par un article, c'est du
+        contenu juridique réel : l'exclure le ferait disparaître de la recherche.
+        """
+        suite = "la délivrance des titres de passeports ; l'obtention d'une carte grise." * 3
+        r = refine([chunk("LEGAL_BASIS", suite)], contexte)
+        assert r.legal_basis is None
+        assert r.chunks[0]["kind"] == "continuation"
+        assert r.chunks[0]["embed"] is True
+
+
+class TestR4ListesNominatives:
+    TABLE = "<table><tbody>" + "".join(
+        f"<tr><td>{i}.</td><td>NOM PRENOM{i:02d}</td><td>765 6{i:02d}-Y</td></tr>"
+        for i in range(1, 21)
+    ) + "</tbody></table>"
+
+    def test_liste_effondree_en_un_chunk(self, contexte):
+        contenu = (
+            "Les anciens Gardiens de la Paix dont les noms suivent sont nommés "
+            "Élèves-Inspecteurs de Police, indice 230.\n" + self.TABLE
+        )
+        r = refine([chunk("1", contenu)], contexte)
+        assert len(r.roster) == 20
+        assert len(r.embeddable) == 1, "20 personnes ne doivent pas donner 20 vecteurs"
+        # L'enveloppe juridique est conservée, la liste ne l'est pas
+        assert "Élèves-Inspecteurs" in r.chunks[0]["content"]
+        assert "NOM PRENOM05" not in r.chunks[0]["content"]
+        assert "20 personnes concernées" in r.chunks[0]["content"]
+
+    def test_appariement_nom_matricule(self, contexte):
+        contenu = "Sont nommés :\n" + self.TABLE
+        r = refine([chunk("1", contenu)], contexte)
+        entree = r.roster[4]
+        assert entree.name == "NOM PRENOM05"
+        assert entree.identifier == "765 605-Y"
+
+    def test_entete_de_tableau_ignoree(self, contexte):
+        table = (
+            "<table><thead><tr><th>N°</th><th>Nom</th><th>Indice</th></tr></thead>"
+            "<tbody>" + "".join(
+                f"<tr><td>{i}.</td><td>NOM PRENOM{i:02d}</td><td>765 6{i:02d}-Y</td></tr>"
+                for i in range(1, 8)
+            ) + "</tbody></table>"
+        )
+        r = refine([chunk("1", "Sont nommés :\n" + table)], contexte)
+        assert all(e.name != "Nom" for e in r.roster), "« Nom » compté comme personne"
+        assert len(r.roster) == 7
+
+    def test_article_normatif_non_traite_comme_liste(self, contexte):
+        contenu = (
+            "L'administration fiscale met en œuvre l'assistance internationale "
+            "en matière de recouvrement des créances fiscales, qu'elle soit "
+            "sollicitée par une autorité étrangère ou qu'elle en fasse la demande."
+        )
+        r = refine([chunk("L 94 septies", contenu)], contexte)
+        assert not r.roster
+        assert r.chunks[0]["kind"] == "article"
+
+
+class TestR5R6TaillesEtTableaux:
+    def test_tableau_jamais_coupe(self, contexte):
+        table = "<table>" + "".join(
+            f"<tr><td>ligne {i}</td><td>{i * 1000}</td></tr>" for i in range(200)
+        ) + "</table>"
+        r = refine([chunk("86", "Les charges sont évaluées ainsi :\n" + table)], contexte)
+        # Une ligne isolée ne répond à aucune question : le tableau reste entier
+        assert len(r.chunks) == 1
+        assert r.chunks[0]["oversized"] is True
+
+    def test_article_long_coupe_aux_alineas(self, contexte):
+        contenu = "Dispositions générales.\n" + "\n".join(
+            f"({i}) " + "Texte de l'alinéa suffisamment long pour compter. " * 12
+            for i in range(1, 6)
+        )
+        r = refine([chunk("94", contenu)], contexte, target_max_chars=800)
+        assert len(r.chunks) > 1
+        assert all(c["parent_id"] == "94" for c in r.chunks[1:])
+
+    def test_article_d_execution_hors_index(self, contexte):
+        boilerplate = (
+            "Le présent décret sera enregistré, publié selon la procédure "
+            "d'urgence, puis inséré au Journal Officiel en français et en anglais."
+        )
+        r = refine([chunk("5", boilerplate)], contexte)
+        # Présent dans presque chaque texte : indexé, il produirait des milliers
+        # de quasi-doublons. Conservé en base, retiré du vectoriel.
+        assert r.chunks[0]["kind"] == "boilerplate"
+        assert r.chunks[0]["embed"] is False
+        assert r.chunks[0]["content"] == boilerplate
+
+    def test_fragment_trop_court_hors_index(self, contexte):
+        r = refine([chunk("PARA_9", "45")], contexte)
+        assert r.chunks[0]["embed"] is False
+        assert r.chunks[0]["kind"] == "fragment"
+
+
+class TestR7Deduplication:
+    def test_chunks_identiques_fusionnes(self, contexte):
+        contenu = "Le présent texte entre en application immédiate sur tout le territoire."
+        r = refine([chunk("1", contenu), chunk("2", contenu)], contexte)
+        assert r.stats["duplicates_removed"] == 1
+        assert len(r.chunks) == 1
+
+
+class TestRienNEstPerdu:
+    def test_aucun_chunk_supprime(self, contexte):
+        """
+        Principe directeur du module : les chunks écartés du vectoriel gardent
+        embed=False mais restent en base et cherchables en FTS.
+        """
+        chunks = [
+            chunk("LEGAL_BASIS", "Vu la Constitution ;"),
+            chunk("1", "Contenu normatif suffisamment long pour être conservé." * 3),
+            chunk("5", "Le présent décret sera enregistré et publié au Journal Officiel."),
+            chunk("PARA_9", "12"),
+        ]
+        r = refine(chunks, contexte)
+        assert len(r.chunks) == len(chunks)
+        assert r.stats["embeddable"] < len(chunks), "tout ne doit pas être vectorisé"