test(architecture): eliminate subprocess pytest/mypy from tests

Quatre tests lançaient pytest ou mypy via subprocess.run :
- tests/docs/test_readme_consistency.py::test_readme_test_count_matches_baseline
- tests/architecture/test_doc_truthfulness.py::TestTestCountSynced
- tests/docs/test_readme_dual_lang.py::test_readme_tables_consistent_with_code
- tests/architecture/test_mypy_domain_strict.py::test_mypy_strict_on_domain_passes

Risques :
- pytest-dans-pytest avec --cov deadlocke sur le lock .coverage (le code
documentait déjà ce risque via -p no:cacheprovider + --no-cov) ;
- subprocess mypy peut skip silencieusement si mypy n'est pas dans le PATH,
faussant l'invariant strict.

Remplacements :
- Le compteur de tests sort de la prose : README/CLAUDE/GOVERNANCE/docs
passent à "5000+ tests" ; gen_readme_tables.py perd collect_test_count,
_replace_test_count et render_test_counts. Le chiffre canonique vit
désormais dans le badge CI.
- test_readme_consistency vérifie maintenant qu'aucun compteur exact
n'a été réintroduit (regex anti-régression).
- test_doc_truthfulness::TestTestCountSynced devient
TestTestCountInProseRemainsApproximate (même esprit, sans subprocess).
- test_readme_dual_lang importe le script directement via importlib et
appelle render_readme(check_only=True).
- test_mypy_domain_strict passe à mypy.api.run ; absence de mypy =
pytest.fail (pas skip silencieux).

Nouveau garde-fou tests/architecture/test_no_subprocess_pytest.py :
empêche structurellement le retour de subprocess pytest/mypy via une
scan AST-ish (retrait des docstrings + commentaires avant match).

Effet mesuré : la suite architecture + docs tombe de 5.89s à 0.78s sur
le sous-ensemble touché (225 passed, 9 skipped, 0 failed sur l'ensemble).

CLAUDE.md

@@ -116,15 +116,13 @@ picarones/
 
 ## État des tests et bugs historiques
 
-`pytest tests/` → **5150 passed, 16 skipped, 8 deselected, 2 xfailed, 0 failed**
-(post-audit code-quality, mai 2026).  Les deselected sont les markers
-`live` (5 tests d'intégration contre vraie API/binaire) + `network`
-(3 tests qui hit le réseau réel), opt-in en local via `pytest -m live`
-ou `pytest -m network`.  Le compteur ``passed`` est synchronisé
-automatiquement par `scripts/gen_readme_tables.py` (CI : job
-``sync-counters`` ; local : `make sync-counters-check`).  Le détail
-``skipped``/``xfailed`` peut dériver de ±2 entre éditions et n'est
-pas verrouillé en CI.
+`pytest tests/` → **5000+ tests collectés, 0 failed** (mai 2026).
+Les markers `live` (tests d'intégration contre vraie API/binaire) et
+`network` (tests qui hit le réseau réel) sont opt-in en local via
+`pytest -m live` ou `pytest -m network`.  Le compteur exact dérive
+de ±10 entre OS selon les binaires optionnels installés (tesseract,
+pero-ocr) — c'est le badge CI qui porte le chiffre canonique, pas
+la prose de ce fichier.
 
 NB : utiliser ``python -m pytest tests/`` plutôt que ``pytest tests/``
 directement — l'installation via ``uv tool install pytest`` masque

GOVERNANCE.md

@@ -19,7 +19,7 @@
 
 ### BDFL / Maintainer principal
 
-À ce stade du projet (mai 2026, ~3 600 tests, 1.x), **Picarones
+À ce stade du projet (mai 2026, 5000+ tests, 1.x), **Picarones
 est maintenu en BDFL** par
 [@maribakulj](https://github.com/maribakulj). Toute décision finale
 sur les contrats d'API publique, les choix éditoriaux (palette,

README.md

@@ -401,12 +401,14 @@ python -m mypy picarones/domain/    # strict mode (Layer 1)
 python -m mypy picarones/           # lax mode (full tree)
 ```
 
-**Test suite**: ~5150 tests, ~3 min on a modern laptop. Coverage
-floor at 85% (currently ~87%). The `network` marker excludes tests
-requiring live HTTP. A handful of tests depend on optional engines
-(`pero-ocr`, `pytesseract`) and are skipped/fail gracefully when
-those binaries are not installed in the local environment — the CI
-matrix runs them in a fully provisioned image.
+**Test suite**: 5000+ tests, ~3 min on a modern laptop (the exact
+count is published by the CI badge — it drifts ±1 depending on which
+optional engines are installed on the runner). Coverage floor at 85%
+(currently ~87%). The `network` marker excludes tests requiring live
+HTTP. A handful of tests depend on optional engines (`pero-ocr`,
+`pytesseract`) and are skipped/fail gracefully when those binaries
+are not installed in the local environment — the CI matrix runs them
+in a fully provisioned image.
 
 For end-to-end developer guides, see
 [`docs/developer/index.md`](docs/developer/index.md) (FR) /

docs/developer/index.md

@@ -80,9 +80,9 @@ pip install -e ".[dev,web]"
 pytest tests/ -q --tb=short
 ```
 
-À la date du Sprint 21 : **1244 tests passent, 2 sont skip** (dépendance
-scipy optionnelle). Toute contribution doit conserver le statut "0
-failed".
+La suite contient **5000+ tests** (le compteur exact dérive selon les
+binaires optionnels installés ; le badge CI fait foi). Toute
+contribution doit conserver le statut "0 failed".
 
 ## Démo rapide
 

scripts/gen_readme_tables.py

@@ -1,15 +1,13 @@
 """Génère les tableaux Markdown du README depuis le code réel.
 
-Sprint A13 (item M-22 / M-23 / M-25 / M-26 du plan de remédiation).
-
-Ce script remplace les listes manuelles qui dérivaient silencieusement
+Le script remplace les listes manuelles qui dérivaient silencieusement
 (le bug typique : un nouvel engine ajouté → README pas mis à jour →
 ``test_readme_consistency`` casse au prochain CI).
 
 Trois tableaux sont produits :
 
-1. **Engines** : un par fichier ``picarones/engines/*.py`` (hors base /
-   factory / __init__).
+1. **Engines** : un par adapter sous ``picarones/adapters/ocr/`` (hors
+   base / factory / __init__).
 2. **CLI commands** : depuis ``picarones --help``.
 3. **API endpoints** : depuis ``app.openapi()["paths"]``.
 
@@ -18,6 +16,12 @@ Le script écrit chaque tableau dans le README entre des balises HTML
 ``cli`` et ``endpoints``). En CI, un job re-exécute ce script et
 échoue si le diff Git est non vide — garantissant l'absence de dérive.
 
+Le compteur de tests n'est PAS géré ici : il dérivait selon l'OS et
+les binaires système installés (4509 vs 4510 selon que tesseract est
+présent ou non), donc on l'a sorti de la prose.  La règle actuelle :
+le README dit ``5000+ tests`` (formulation non quantifiée) et le
+chiffre exact vit dans le badge CI / Codecov.
+
 Usage :
 
 .. code-block:: bash
@@ -30,26 +34,12 @@ from __future__ import annotations
 
 import argparse
 import re
-import subprocess
 import sys
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 README = REPO_ROOT / "README.md"
 
-#: Fichiers où ``N tests`` / ``N passed`` est mentionné en prose et
-#: doit converger vers le compte réel.  L'audit doc S60 avait
-#: identifié 5 chiffres divergents dans 5 docs (1072 / 1244 / 3354 /
-#: ~3600 / ~5030).  Liste explicite plutôt qu'un glob — un mainteneur
-#: qui ajoute un nouveau doc doit l'inscrire ici consciemment.
-TEST_COUNT_FILES: tuple[Path, ...] = (
-    README,
-    REPO_ROOT / "CLAUDE.md",
-    REPO_ROOT / "GOVERNANCE.md",
-    REPO_ROOT / "docs" / "developer" / "index.md",
-    REPO_ROOT / "docs" / "developer" / "index.en.md",
-)
-
 # Permet l'invocation du script en subprocess sans avoir besoin
 # d'un ``pip install -e .`` préalable (cas CI / test pytest).
 if str(REPO_ROOT) not in sys.path:
@@ -174,40 +164,6 @@ def build_endpoints_table() -> str:
     return "\n".join(rows)
 
 
-# ---------------------------------------------------------------------------
-# Test count
-# ---------------------------------------------------------------------------
-
-
-def collect_test_count() -> int | None:
-    """Lance ``pytest --collect-only`` et extrait le compteur."""
-    try:
-        result = subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "pytest",
-                "--collect-only",
-                "-q",
-                "--no-cov",
-                "-p",
-                "no:cacheprovider",
-                "tests/",
-            ],
-            capture_output=True,
-            text=True,
-            cwd=REPO_ROOT,
-            timeout=60,
-        )
-    except subprocess.TimeoutExpired:
-        return None
-    for line in reversed(result.stdout.strip().split("\n")):
-        m = re.search(r"(\d+)\s+tests?\s+collected", line)
-        if m:
-            return int(m.group(1))
-    return None
-
-
 # ---------------------------------------------------------------------------
 # Insertion dans le README
 # ---------------------------------------------------------------------------
@@ -234,44 +190,14 @@ def _replace_section(text: str, marker: str, content: str) -> str:
     return new_text
 
 
-def _replace_test_count(text: str, count: int) -> str:
-    """Remplace les mentions ``N tests`` ou ``N passed`` qui citent un
-    nombre dans la fenêtre [count*0.5, count*2]. Garde la formulation
-    exacte (espace, ponctuation) intacte.
-
-    Le count est **arrondi à la cinquantaine inférieure** pour rendre
-    le résultat OS-déterministe : selon les binaires système (tesseract,
-    pero-ocr) installés sur le runner, certains modules de test sont
-    skipés au niveau ``pytest.skip(allow_module_level=True)`` — ce qui
-    soustrait le fichier entier de la collection.  Exemple observé en
-    S8.7 : Linux CI (avec tesseract) collecte 4510 tests, dev local
-    (sans tesseract) en collecte 4509.  Avec un floor à 10 ces deux
-    valeurs divergent (4510 vs 4500) ; avec un floor à 50, elles
-    convergent toutes deux vers 4500.
-
-    Note : utilise ``(count // 50) * 50`` plutôt que
-    ``round(count, -1)``.  Le ``round()`` Python applique le
-    "banker's rounding" (round half to even) qui n'est pas
-    monotone.  Le floor à 50 garde la propriété de monotonie (un
-    ajout de tests ne fait jamais reculer le compteur) tout en
-    absorbant les écarts de ±49 tests entre environnements.
-    """
-    rounded_count = (count // 50) * 50
-
-    def _sub(match: re.Match) -> str:
-        cited = int(match.group(1))
-        # Ne touche pas si le nombre cité est complètement hors plage —
-        # c'est probablement une autre référence (un chiffre dans une
-        # phrase qui parle d'autre chose).
-        if cited < count * 0.5 or cited > count * 2:
-            return match.group(0)
-        return match.group(0).replace(str(cited), str(rounded_count))
-
-    return re.sub(r"(\d{3,5})\s+(?:tests|passed)\b", _sub, text)
-
-
 def render_readme(check_only: bool = False) -> int:
-    """Met à jour les sections générées du README. Retourne 0 ou 1."""
+    """Met à jour les sections générées du README. Retourne 0 ou 1.
+
+    Le compteur de tests n'est plus injecté en prose : il dérivait
+    selon l'OS et les binaires système installés, et la stratégie
+    actuelle est ``5000+ tests`` (formulation non quantifiée) avec le
+    chiffre exact porté par le badge CI.
+    """
     if not README.exists():
         sys.stderr.write(f"README absent : {README}\n")
         return 1
@@ -282,10 +208,6 @@ def render_readme(check_only: bool = False) -> int:
     text = _replace_section(text, "cli", build_cli_table())
     text = _replace_section(text, "endpoints", build_endpoints_table())
 
-    count = collect_test_count()
-    if count is not None:
-        text = _replace_test_count(text, count)
-
     if check_only:
         if text != original:
             sys.stderr.write(
@@ -304,55 +226,6 @@ def render_readme(check_only: bool = False) -> int:
     return 0
 
 
-def render_test_counts(check_only: bool = False) -> int:
-    """Synchronise le compte de tests dans tous les ``TEST_COUNT_FILES``.
-
-    Audit doc S60 : 5 chiffres divergents (1072 / 1244 / 3354 /
-    ~3600 / ~5030) selon les docs.  Cette fonction lit le compte
-    réel via ``pytest --collect-only`` et l'injecte dans chaque
-    fichier de la liste.
-
-    Returns
-    -------
-    int
-        0 si tout est synchronisé, 1 si divergence (en mode check)
-        ou erreur d'écriture.
-    """
-    count = collect_test_count()
-    if count is None:
-        # ``pytest --collect-only`` indisponible (env CI minimal,
-        # virtualenv dégradé).  On ne casse pas le build pour ça.
-        sys.stderr.write(
-            "[gen_readme_tables] collect_test_count indisponible — "
-            "skip mise à jour des compteurs de tests.\n",
-        )
-        return 0
-
-    divergent = False
-    for path in TEST_COUNT_FILES:
-        if not path.exists():
-            continue
-        original = path.read_text(encoding="utf-8")
-        updated = _replace_test_count(original, count)
-        if updated == original:
-            continue
-        divergent = True
-        if check_only:
-            sys.stderr.write(
-                f"[gen_readme_tables] {path.relative_to(REPO_ROOT)} "
-                "diverge du compteur de tests réel.\n",
-            )
-        else:
-            path.write_text(updated, encoding="utf-8")
-            print(
-                f"[gen_readme_tables] {path.relative_to(REPO_ROOT)} "
-                "test count mis à jour.",
-            )
-    if check_only and divergent:
-        return 1
-    return 0
-
-
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument(
@@ -361,9 +234,7 @@ def main() -> int:
         help="N'écrit rien ; sort 1 si le README diverge du code généré.",
     )
     args = parser.parse_args()
-    rc_readme = render_readme(check_only=args.check)
-    rc_counts = render_test_counts(check_only=args.check)
-    return rc_readme or rc_counts
+    return render_readme(check_only=args.check)
 
 
 if __name__ == "__main__":

tests/architecture/test_doc_truthfulness.py

@@ -22,8 +22,6 @@ from __future__ import annotations
 
 from pathlib import Path
 
-import pytest
-
 REPO_ROOT = Path(__file__).resolve().parents[2]
 ARCHITECTURE_MD = REPO_ROOT / "docs" / "explanation" / "architecture.md"
 CLAUDE_MD = REPO_ROOT / "CLAUDE.md"
@@ -135,90 +133,48 @@ class TestArchitectureManifestoTruthful:
 
 
 # ──────────────────────────────────────────────────────────────────────
-# 2. Compteurs de tests synchronisés
+# 2. Compteurs de tests — pas de chiffre exact en prose
 # ──────────────────────────────────────────────────────────────────────
-
-
-class TestTestCountSynced:
-    """Le compteur ``N tests passed`` cité dans CLAUDE.md / README.md
-    doit rester proche du compte réel.
-
-    Le script ``scripts/gen_readme_tables.py`` est censé maintenir la
-    cohérence ; ce test attrape les cas où il n'a pas tourné.
-
-    Tolérance : ``±5`` tests autour du compte réel (un commit peut
-    introduire 1-3 nouveaux tests sans qu'on regenère immédiatement
-    la doc — au-delà, c'est de la dérive).
-    """
-
-    @pytest.fixture
-    def real_test_count(self) -> int:
-        """Count réel des tests collectés par pytest (hors deselected)."""
-        import subprocess
-        import sys
-
-        result = subprocess.run(
-            [
-                sys.executable, "-m", "pytest",
-                "--collect-only", "-q", "--no-cov",
-                "-p", "no:cacheprovider",
-                str(REPO_ROOT / "tests"),
-            ],
-            capture_output=True, text=True, cwd=REPO_ROOT, timeout=60,
-        )
-        # La dernière ligne pertinente : « X tests collected »
-        import re
-        for line in reversed(result.stdout.strip().split("\n")):
-            m = re.search(r"(\d+)\s+tests?\s+collected", line)
-            if m:
-                return int(m.group(1))
-        pytest.fail(
-            f"Impossible d'extraire le compte de pytest --collect-only.\n"
-            f"stdout: {result.stdout[-500:]}\nstderr: {result.stderr[-200:]}"
+#
+# Historique : ce module comparait ``N tests passed`` cité dans
+# CLAUDE.md / README.md au compte réel via
+# ``subprocess.run([..., "pytest", "--collect-only", ...])``.  Trois
+# problèmes : (a) pytest-dans-pytest avec ``--cov`` deadlocke sur
+# ``.coverage`` ; (b) le compteur réel dérive de ±1 entre OS selon
+# les binaires optionnels installés ; (c) un test qui rate à cause
+# d'un compteur en prose est purement narratif.
+#
+# Stratégie actuelle : la prose dit ``5000+ tests`` (sans nombre
+# exact), le chiffre canonique vit dans le badge CI.  Ces tests
+# verrouillent l'absence de réintroduction d'un compteur exact.
+
+import re
+
+
+class TestTestCountInProseRemainsApproximate:
+    """README et CLAUDE.md ne doivent plus citer de compteur de tests
+    exact.  La formulation canonique est ``N+ tests`` / ``N+ passed``
+    (avec le ``+`` qui marque l'approximation)."""
+
+    _FORBIDDEN = re.compile(
+        r"(?<!\+)\b(\d{4,5})\s+(?:tests|passed)\b",
+        re.IGNORECASE,
+    )
+
+    def test_readme_uses_approximate_formulation(self) -> None:
+        text = README_MD.read_text(encoding="utf-8")
+        offenders = self._FORBIDDEN.findall(text)
+        assert not offenders, (
+            f"README.md cite des compteurs exacts : {offenders}. "
+            "Utiliser ``N+ tests`` (ex. ``5000+ tests``)."
         )
 
-    def _extract_count(self, text: str) -> int | None:
-        """Cherche un nombre près du mot ``passed`` dans ``text``."""
-        import re
-        # Matche « 4189 passed » ou « ~4150 tests » ou « 4150 tests passed ».
-        for pattern in (
-            r"\*\*(\d{3,5})\s+passed",
-            r"(\d{3,5})\s+passed",
-            r"~?(\d{3,5})\s+tests",
-        ):
-            m = re.search(pattern, text)
-            if m:
-                return int(m.group(1))
-        return None
-
-    def test_claude_md_count_close_to_reality(
-        self, real_test_count: int,
-    ) -> None:
+    def test_claude_md_uses_approximate_formulation(self) -> None:
         text = CLAUDE_MD.read_text(encoding="utf-8")
-        claimed = self._extract_count(text)
-        assert claimed is not None, (
-            "CLAUDE.md ne contient aucun compteur de tests (``N passed``)."
-        )
-        delta = abs(claimed - real_test_count)
-        assert delta <= 50, (
-            f"CLAUDE.md annonce {claimed} tests, réalité = "
-            f"{real_test_count} (écart = {delta}).  Tolérance ±50.\n"
-            f"Lancer ``python scripts/gen_readme_tables.py`` puis "
-            f"committer."
-        )
-
-    def test_readme_md_count_close_to_reality(
-        self, real_test_count: int,
-    ) -> None:
-        text = README_MD.read_text(encoding="utf-8")
-        claimed = self._extract_count(text)
-        assert claimed is not None, (
-            "README.md ne contient aucun compteur de tests."
-        )
-        delta = abs(claimed - real_test_count)
-        assert delta <= 50, (
-            f"README.md annonce {claimed} tests, réalité = "
-            f"{real_test_count} (écart = {delta})."
+        offenders = self._FORBIDDEN.findall(text)
+        assert not offenders, (
+            f"CLAUDE.md cite des compteurs exacts : {offenders}. "
+            "Utiliser ``N+ tests`` (ex. ``5000+ tests``)."
         )
 
 

tests/architecture/test_mypy_domain_strict.py

@@ -17,8 +17,7 @@ Après S3.6 :
 
 from __future__ import annotations
 
-import subprocess
-import sys
+import os
 from pathlib import Path
 
 import pytest
@@ -27,20 +26,37 @@ REPO_ROOT = Path(__file__).resolve().parents[2]
 
 
 def test_mypy_strict_on_domain_passes() -> None:
-    """``mypy picarones/domain/`` doit retourner 0 erreur."""
-    result = subprocess.run(
-        [sys.executable, "-m", "mypy", "picarones/domain/"],
-        capture_output=True,
-        text=True,
-        cwd=REPO_ROOT,
-        timeout=120,
-    )
-    if result.returncode != 0:
+    """``mypy picarones/domain/`` doit retourner 0 erreur.
+
+    Utilise l'API programmatique ``mypy.api.run`` plutôt qu'un
+    ``subprocess.run`` : (a) plus rapide (pas de fork), (b) pas de
+    parsing de stdout, (c) si mypy est absent, l'erreur est explicite
+    (``ImportError``) au lieu d'un échec silencieux du subprocess.
+    """
+    try:
+        from mypy import api as mypy_api
+    except ImportError as e:
+        pytest.fail(
+            f"mypy n'est pas installé — ce test ne peut pas être skippé "
+            f"en silence car il verrouille un invariant strict.\n"
+            f"Installer via ``pip install -e .[dev]``.  ImportError: {e}"
+        )
+
+    # Travailler depuis REPO_ROOT pour que pyproject.toml soit
+    # découvert correctement par mypy.
+    prev_cwd = Path.cwd()
+    try:
+        os.chdir(REPO_ROOT)
+        stdout, stderr, exit_code = mypy_api.run(["picarones/domain/"])
+    finally:
+        os.chdir(prev_cwd)
+
+    if exit_code != 0:
         pytest.fail(
             f"mypy strict sur ``picarones/domain`` échoue.\n"
-            f"return code: {result.returncode}\n"
-            f"stdout:\n{result.stdout}\n"
-            f"stderr:\n{result.stderr[-500:]}"
+            f"return code: {exit_code}\n"
+            f"stdout:\n{stdout}\n"
+            f"stderr:\n{stderr[-500:]}"
         )
 
 

tests/architecture/test_no_subprocess_pytest.py

@@ -0,0 +1,150 @@
+"""Garde-fou : aucun test ne doit lancer pytest ou mypy via subprocess.
+
+Pourquoi ce test existe
+-----------------------
+
+Lancer ``subprocess.run([sys.executable, "-m", "pytest", ...])``
+depuis un test pytest cause un deadlock potentiel sur le lock du
+fichier ``.coverage`` quand le test parent tourne lui-même sous
+``pytest --cov`` (cas standard de la CI).
+
+L'historique du repo contient des commentaires comme « ``-p
+no:cacheprovider`` + ``--no-cov`` évitent les deadlocks de récursion »
+— c'est précisément ce que ce test prévient en bloquant la cause
+plutôt qu'en mitigeant les symptômes.
+
+Les outils en ligne de commande (``mypy``, ``pytest``, ``ruff``,
+``bandit``) exposent tous une API programmatique :
+
+- ``from mypy import api ; api.run([...])``
+- ``import pytest ; pytest.main([...])`` (rare, généralement
+  remplaçable par une assertion directe sur ``collect_only``)
+- ``import ruff`` non exposé, mais le besoin est rare en test
+
+Périmètre
+---------
+
+On scanne tous les fichiers ``tests/**/*.py`` à la recherche de
+patterns qui correspondent à un appel subprocess vers ces outils.
+On accepte :
+
+- les ``subprocess`` qui lancent des binaires système (``tesseract``,
+  ``docker``, etc.) ;
+- les ``subprocess`` qui lancent un script Python du repo
+  (``scripts/...``) tant que ce script ne ré-invoque pas pytest.
+
+On refuse :
+
+- ``subprocess.run([..., "pytest", ...])``
+- ``subprocess.run([sys.executable, "-m", "pytest", ...])``
+- ``pytest.main(...)`` (récursion potentielle)
+- ``subprocess.run([..., "mypy", ...])`` (utiliser ``mypy.api.run``)
+
+Exceptions
+----------
+
+Aucune n'est tolérée.  Si un cas vraiment indispensable apparaît,
+l'ajouter ici **avec justification** plutôt que de le laisser
+fragiliser une partie du repo.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+TESTS_DIR = REPO_ROOT / "tests"
+
+#: Fichiers tolérés explicitement.  Le scanner lui-même contient les
+#: patterns qu'il interdit (sinon il ne pourrait pas les chercher) ;
+#: il s'auto-exclut.  Toute autre addition demande une justification
+#: en revue.
+ALLOWLIST: frozenset[str] = frozenset({
+    "tests/architecture/test_no_subprocess_pytest.py",
+})
+
+#: Patterns refusés.  L'ordre importe : on retient le premier match
+#: pour un message d'erreur clair.
+_FORBIDDEN_PATTERNS: tuple[tuple[str, re.Pattern[str]], ...] = (
+    (
+        "subprocess.run([..., 'pytest', ...])",
+        re.compile(
+            r'subprocess\.(?:run|Popen|check_call|check_output|call)'
+            r'\s*\([^)]*["\']pytest["\']',
+            re.DOTALL,
+        ),
+    ),
+    (
+        "subprocess.run([sys.executable, '-m', 'pytest', ...])",
+        re.compile(
+            r'subprocess\.(?:run|Popen|check_call|check_output|call)'
+            r'\s*\(\s*\[[^\]]*sys\.executable[^\]]*["\']pytest["\']',
+            re.DOTALL,
+        ),
+    ),
+    (
+        "subprocess.run([..., 'mypy', ...])",
+        re.compile(
+            r'subprocess\.(?:run|Popen|check_call|check_output|call)'
+            r'\s*\([^)]*["\']mypy["\']',
+            re.DOTALL,
+        ),
+    ),
+    (
+        "pytest.main(...)",
+        re.compile(r'\bpytest\.main\s*\('),
+    ),
+)
+
+
+def _strip_comments_and_docstrings(text: str) -> str:
+    """Retire les commentaires Python et les docstrings triple-quoted
+    pour éviter les faux positifs sur les fichiers qui *décrivent* le
+    motif interdit en prose (cas typique d'un commentaire ``# Historique :
+    ce test lançait subprocess.run(..., 'pytest', ...) ...``).
+
+    L'heuristique est volontairement simple — pas de parser Python
+    complet — parce qu'on ne veut pas matcher un motif qui apparaît
+    uniquement dans du texte non exécutable."""
+    # Triple-quoted strings (docstrings et chaînes multi-lignes)
+    text = re.sub(r'"""[\s\S]*?"""', "", text)
+    text = re.sub(r"'''[\s\S]*?'''", "", text)
+    # Commentaires single-line : tout ce qui suit un ``#`` sur la ligne.
+    # On ignore le cas pathologique d'un ``#`` dans une chaîne car le
+    # fichier scanné est du code de test (pas de littérature
+    # défensive nécessaire à ce stade).
+    text = re.sub(r"#[^\n]*", "", text)
+    return text
+
+
+def _scan_file(path: Path) -> list[str]:
+    """Retourne la liste des patterns interdits trouvés dans ``path``."""
+    text = _strip_comments_and_docstrings(
+        path.read_text(encoding="utf-8")
+    )
+    return [
+        label
+        for label, pattern in _FORBIDDEN_PATTERNS
+        if pattern.search(text)
+    ]
+
+
+def test_no_test_invokes_pytest_or_mypy_via_subprocess() -> None:
+    offenders: list[str] = []
+    for path in sorted(TESTS_DIR.rglob("*.py")):
+        rel = path.relative_to(REPO_ROOT).as_posix()
+        if rel in ALLOWLIST:
+            continue
+        found = _scan_file(path)
+        if found:
+            offenders.append(f"{rel} : {', '.join(found)}")
+
+    assert not offenders, (
+        "Tests qui invoquent pytest/mypy en subprocess (risque de "
+        "deadlock pytest-dans-pytest et / ou de skip silencieux) :\n  "
+        + "\n  ".join(offenders)
+        + "\n\n→ Utiliser l'API programmatique :\n"
+        "    from mypy import api ; stdout, stderr, rc = api.run([...])\n"
+        "    # ou supprimer le test s'il duplique un check existant"
+    )

tests/docs/test_readme_consistency.py

@@ -33,7 +33,6 @@ PR que le README), insérer un commentaire HTML
 from __future__ import annotations
 
 import re
-import subprocess
 from pathlib import Path
 
 import pytest
@@ -51,10 +50,6 @@ ENGINES_DIR = REPO_ROOT / "picarones" / "adapters" / "ocr"
 #: ``<!-- doc-check: skip-engine -->``, ``skip-cli``, ``skip-endpoint``.
 SKIP_PATTERN = re.compile(r"<!--\s*doc-check:\s*skip-([a-z]+)\s*-->")
 
-#: Tolérance sur le compteur de tests (les PR en cours peuvent ajouter
-#: ou retirer 5 % avant que le README soit mis à jour).
-TEST_COUNT_TOLERANCE_RATIO = 0.05
-
 #: Préfixes de "moteurs" du tableau qui ne sont *pas* des moteurs OCR
 #: (ce sont des LLMs/VLMs utilisés via les pipelines). Ils sont
 #: tolérés en attendant la refonte A13 qui scindera le tableau.
@@ -328,62 +323,41 @@ def test_listed_endpoints_exist() -> None:
 
 
 # ---------------------------------------------------------------------------
-# 4. Compteur de tests (M-19, §9.3)
+# 4. Compteur de tests — le README ne pin plus un nombre exact
 # ---------------------------------------------------------------------------
-
-
-def _collected_test_count() -> int:
-    """Retourne le nombre exact de tests collectés par pytest."""
-    # Sprint A5 : ``-p no:cacheprovider`` + ``--no-cov`` évitent les
-    # deadlocks de récursion quand le test parent tourne lui-même sous
-    # ``pytest --cov`` (lock du fichier .coverage).
-    result = subprocess.run(
-        [
-            "python", "-m", "pytest",
-            "--collect-only", "-q",
-            "-p", "no:cacheprovider",
-            "--no-cov",
-            "tests/",
-        ],
-        capture_output=True,
-        text=True,
-        cwd=REPO_ROOT,
-        timeout=60,
-    )
-    # La dernière ligne non vide ressemble à "3419 tests collected in 3.32s"
-    for line in reversed(result.stdout.strip().split("\n")):
-        m = re.search(r"(\d+)\s+tests?\s+collected", line)
-        if m:
-            return int(m.group(1))
-    raise RuntimeError(
-        f"Impossible d'extraire le compteur depuis pytest --collect-only.\n"
-        f"stdout: {result.stdout[-500:]}"
-    )
-
-
-def test_readme_test_count_matches_baseline() -> None:
-    """Les phrases « N tests » ou « N passed » dans le README doivent
-    correspondre au compteur réel de pytest, à ``TEST_COUNT_TOLERANCE_RATIO``
-    près (5 % par défaut)."""
+#
+# Historique : ce test lançait ``subprocess.run([..., "pytest",
+# "--collect-only", ...])`` pour comparer le compteur cité au nombre
+# réel.  Pytest-dans-pytest avec ``--cov`` cause un deadlock sur le
+# lock ``.coverage`` (le commentaire ``-p no:cacheprovider`` + ``--no-cov``
+# documente déjà ce risque).  La stratégie actuelle élimine la classe
+# d'erreur : le README dit ``5000+ tests``, sans nombre figé, et le
+# chiffre exact vit dans le badge CI.
+#
+# Ce test ne fait plus que vérifier qu'aucun compteur exact n'a été
+# réintroduit en prose.
+
+
+def test_readme_does_not_pin_exact_test_count() -> None:
+    """Le README ne doit plus citer un nombre exact (``5150 tests``,
+    ``5159 passed``, etc.).  La formulation canonique est ``N+ tests``
+    (ex. ``5000+ tests``) pour absorber la dérive OS-dépendante du
+    compteur (4509 vs 4510 selon que tesseract est installé)."""
     text = _read_readme()
-    real = _collected_test_count()
-
-    # Cherche les motifs comme "1242 tests" ou "1242 passed"
-    cited_counts: list[int] = []
-    for m in re.finditer(r"(\d{3,5})\s+(?:tests|passed)\b", text, re.IGNORECASE):
-        cited_counts.append(int(m.group(1)))
-
-    if not cited_counts:
-        pytest.skip("Aucun compteur de tests cité dans le README")
 
-    tolerance = max(1, int(real * TEST_COUNT_TOLERANCE_RATIO))
-    out_of_tolerance = [
-        c for c in cited_counts if abs(c - real) > tolerance
-    ]
-    assert not out_of_tolerance, (
-        f"Le README cite des compteurs de tests divergents du baseline "
-        f"réel ({real}, tolérance ±{tolerance}) : {out_of_tolerance}. "
-        f"Mettre à jour le README ou tolérer via skip-marker."
+    # On accepte ``5000+ tests``, ``5000+ passed`` (avec ou sans
+    # caractères de mise en forme markdown autour).  On refuse
+    # ``5150 tests``, ``~5150 tests``, ``5150 passed``.
+    forbidden_pattern = re.compile(
+        r"(?<!\+)\b(\d{4,5})\s+(?:tests|passed)\b",
+        re.IGNORECASE,
+    )
+    offenders = forbidden_pattern.findall(text)
+    assert not offenders, (
+        f"README cite des compteurs de tests exacts : {offenders}. "
+        "Reformuler en ``N+ tests`` (ex. ``5000+ tests``) — le chiffre "
+        "exact dérive selon l'OS / les binaires installés et vit dans "
+        "le badge CI."
     )
 
 

tests/docs/test_readme_dual_lang.py

@@ -16,18 +16,29 @@ Ces tests valident :
 
 from __future__ import annotations
 
+import importlib.util
 import re
-import subprocess
-import sys
 from pathlib import Path
 
-import pytest
-
 REPO_ROOT = Path(__file__).resolve().parents[2]
 README = REPO_ROOT / "README.md"
 GEN_SCRIPT = REPO_ROOT / "scripts" / "gen_readme_tables.py"
 
 
+def _import_gen_script():
+    """Importe ``scripts/gen_readme_tables.py`` en tant que module,
+    sans subprocess.  Le script lui-même ne lance plus rien (le
+    compteur de tests n'est plus injecté en prose), donc l'appel
+    direct à ``render_readme(check_only=True)`` est sûr et rapide."""
+    spec = importlib.util.spec_from_file_location(
+        "_gen_readme_tables", GEN_SCRIPT,
+    )
+    assert spec and spec.loader, f"Impossible de charger {GEN_SCRIPT}"
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
 def _read_readme() -> str:
     return README.read_text(encoding="utf-8")
 
@@ -130,30 +141,20 @@ def test_gen_readme_tables_script_exists() -> None:
     )
 
 
-@pytest.mark.skipif(
-    sys.platform.startswith("win"),
-    reason=(
-        "gen_readme_tables.py compare le compte de tests collectés ; "
-        "le compte diverge entre OS (tests skip différemment selon "
-        "Windows / Linux / macOS).  Le README est généré et committé "
-        "depuis Linux ; ce test n'est pertinent que sur le même OS."
-    ),
-)
 def test_readme_tables_consistent_with_code() -> None:
-    """``python scripts/gen_readme_tables.py --check`` doit retourner 0
-    (le README est synchronisé avec le code)."""
-    result = subprocess.run(
-        [sys.executable, str(GEN_SCRIPT), "--check"],
-        capture_output=True,
-        text=True,
-        cwd=REPO_ROOT,
-        timeout=120,
-    )
-    assert result.returncode == 0, (
-        "Le README diverge du contenu généré par scripts/gen_readme_tables.py.\n"
-        f"stdout: {result.stdout[-500:]}\n"
-        f"stderr: {result.stderr[-500:]}\n"
-        "Lancer ``python scripts/gen_readme_tables.py`` puis committer."
+    """Le README doit être synchronisé avec le contenu généré par
+    ``scripts/gen_readme_tables.py``.
+
+    Appel programmatique direct (pas de ``subprocess.run``) : le script
+    n'invoque plus ``pytest --collect-only`` depuis le retrait du
+    compteur de tests en prose, l'appel direct est donc sûr et n'a
+    plus aucun risque de récursion pytest-dans-pytest."""
+    mod = _import_gen_script()
+    rc = mod.render_readme(check_only=True)
+    assert rc == 0, (
+        "Le README diverge du contenu généré par "
+        "scripts/gen_readme_tables.py.  Lancer le script sans "
+        "``--check`` puis committer."
     )