forge-mvc-testing 1.0.0rc2__py3-none-any.whl

forge_mvc_testing/__init__.py

@@ -0,0 +1,15 @@
+"""forge-mvc-testing — infrastructure de test partagée pour Forge (dev only).
+
+Fournit `FakeRequest` et, via un plugin pytest (point d'entrée `pytest11`,
+voir `forge_mvc_testing.plugin`), les fixtures partagées : configuration du
+noyau, nettoyage entre tests, et `fake_request`.
+
+Ce paquet n'est JAMAIS une dépendance runtime ; il n'est installé qu'en
+développement (ADR-041).
+"""
+from __future__ import annotations
+
+from forge_mvc_testing.fake_request import FakeRequest
+
+__all__ = ["FakeRequest"]
+__version__ = "1.0.0rc2"

forge_mvc_testing/fake_request.py

@@ -0,0 +1,128 @@
+"""Requête HTTP simulée pour les tests unitaires de contrôleurs Forge.
+
+Portée depuis `tests/fake_request.py` vers le paquet de test-support
+`forge-mvc-testing` (ADR-041), pour que les tests de chaque paquet opt-in y
+accèdent sans dépendre du `tests/` racine.
+"""
+
+
+class FakeRequest:
+    """
+    Requête HTTP simulée pour les tests unitaires de contrôleurs.
+
+    Usage :
+        req = FakeRequest("GET", "/clients")
+        req = FakeRequest("POST", "/clients", body={"Nom": "Dupont"})
+        req = FakeRequest("POST", "/api/sync", json_body={"ids": [1, 2]})
+        req = FakeRequest("GET", "/clients", session_id="abc123")
+
+    La fixture `fake_request` (plugin pytest) retourne la classe directement.
+    """
+
+    def __init__(self, method="GET", path="/", *,
+                 body=None, json_body=None, params=None,
+                 session_id=None, ip="127.0.0.1", headers=None, files=None):
+        self.original_method = method.upper()
+        self.method       = self.original_method
+        self.path         = path
+        self.ip           = ip
+        self.route_params = {}
+        self.params       = {k: [v] for k, v in (params or {}).items()}
+
+        # body formulaire (format parse_qs : valeurs en liste)
+        self.body      = {k: [v] for k, v in (body or {}).items()}
+        self.json_body = json_body or {}
+        self.files     = files or {}
+        self._apply_method_override()
+
+        # session injectée via le cookie
+        self.headers = _FakeHeaders(session_id, headers=headers)
+
+    def _apply_method_override(self):
+        if self.original_method != "POST":
+            return
+        value = self.body.get("_method", [None])
+        override = value[0] if isinstance(value, list) and value else value
+        if override and str(override).upper() in {"PUT", "PATCH", "DELETE"}:
+            self.method = str(override).upper()
+
+    # ── Convention d'inspection — miroir des accesseurs de `Request` ────────
+    #
+    # Ajouté par STARTER-BONJOUR-FORGE-001 / API-INSPECTABLE-OBJECTS-CONVENTION-001
+    # pour que `FakeRequest` se comporte comme `core.http.request.Request`
+    # dans les tests qui exercent les contrôleurs typés.
+
+    def query(self, key, default=None):
+        values = self.params.get(key)
+        if not values:
+            return default
+        return values[0]
+
+    def header(self, name, default=None):
+        return self.headers.get(name, default)
+
+    def form(self, key, default=None):
+        values = self.body.get(key)
+        if not values:
+            return default
+        if isinstance(values, list):
+            return values[0] if values else default
+        return values
+
+    def json(self, key, default=None):
+        body = self.json_body
+        if not isinstance(body, dict):
+            return default
+        return body.get(key, default)
+
+    def file(self, key, default=None):
+        return self.files.get(key, default)
+
+    def route(self, key, default=None):
+        return self.route_params.get(key, default)
+
+    @property
+    def data(self):
+        """Mini-version de `Request.data` pour les tests de contrôleurs.
+
+        Reproduit les clés canoniques (method, path, ip, params,
+        route_params, headers, body, json_body, files) mais sans le
+        masquage avancé (les tests ne devraient pas avoir besoin de
+        passer par FakeRequest pour vérifier le masquage — `Request`
+        réel est utilisé pour ça)."""
+        headers_view = {}
+        for key in list(getattr(self.headers, "_headers", {})):
+            headers_view[key] = self.headers.get(key)
+        return {
+            "method": self.method,
+            "original_method": self.original_method,
+            "path": self.path,
+            "ip": self.ip,
+            "params": dict(self.params),
+            "route_params": dict(self.route_params),
+            "headers": headers_view,
+            "body": dict(self.body),
+            "json_body": dict(self.json_body) if isinstance(self.json_body, dict) else self.json_body,
+            "files": {k: {"filename": getattr(f, "filename", None),
+                          "size": getattr(f, "size", None),
+                          "content_type": getattr(f, "content_type", None)}
+                      for k, f in self.files.items()},
+        }
+
+
+class _FakeHeaders:
+    """Simule http.client.HTTPMessage pour get("Cookie") et get("Content-Type")."""
+
+    def __init__(self, session_id=None, headers=None):
+        self._session_id = session_id
+        self._headers = dict(headers or {})
+        self._headers_lower = {key.lower(): value for key, value in self._headers.items()}
+
+    def get(self, name, default: str | None = ""):
+        if name in self._headers:
+            return self._headers[name]
+        if name.lower() in self._headers_lower:
+            return self._headers_lower[name.lower()]
+        if name == "Cookie" and self._session_id:
+            return f"__Host-session_id={self._session_id}"
+        return default

forge_mvc_testing/plugin.py

@@ -0,0 +1,108 @@
+"""Plugin pytest de Forge (test-support, ADR-041).
+
+Chargé automatiquement via le point d'entrée `pytest11` dès que
+`forge-mvc-testing` est installé dans l'environnement de test. Fournit les
+fixtures partagées autrefois dans `tests/conftest.py` : configuration du noyau,
+nettoyage entre tests, et `fake_request`.
+
+Réservé au développement : ce paquet n'est jamais une dépendance runtime, donc
+ces fixtures (notamment l'autouse `configure_forge_kernel`) n'affectent pas les
+suites de tests des utilisateurs de Forge.
+"""
+from __future__ import annotations
+
+import pytest
+
+import core.forge as forge
+
+from forge_mvc_testing.fake_request import FakeRequest
+
+
+@pytest.fixture(scope="session", autouse=True)
+def configure_forge_kernel(tmp_path_factory):
+    """Configure le noyau Forge pour tous les tests — vues et SQL dans tmp_path."""
+    views_dir = tmp_path_factory.mktemp("views")
+    sql_dir = tmp_path_factory.mktemp("sql")
+    # ADR-060 : le cœur ne porte plus de config de connexion BDD ; un backend la
+    # lit dans l'environnement. Les tests qui touchent la base posent eux-mêmes
+    # les variables DB_* (voir test_sqlite_adapter_001).
+    forge.configure(
+        app_name="TestForge",
+        app_env="dev",
+        views_dir=str(views_dir),
+        sql_dir=str(sql_dir),
+    )
+    # ADR-032 : UPLOAD_ROOT est lu depuis l'environnement par forge-mvc-files.
+    # Filet de sécurité : un défaut pointant vers un tmp, pour qu'aucun test ne
+    # puisse écrire dans le storage réel du dépôt même sans isolation propre.
+    mp = pytest.MonkeyPatch()
+    mp.setenv("UPLOAD_ROOT", str(tmp_path_factory.mktemp("uploads")))
+    yield
+    mp.undo()
+
+
+@pytest.fixture(autouse=True)
+def clear_sessions():
+    """Vide le store de sessions entre chaque test."""
+    from core.sessions.manager import get_session_store
+
+    def _purge() -> None:
+        # `purge_all` est une capacité réservée aux tests, portée par
+        # MemorySessionStore et hors du protocole SessionStore : on l'appelle
+        # uniquement si le store configuré l'expose.
+        store = get_session_store()
+        purge = getattr(store, "purge_all", None)
+        if callable(purge):
+            purge()
+
+    _purge()
+    yield
+    _purge()
+
+
+@pytest.fixture(autouse=True)
+def clear_rate_limits():
+    """Vide les compteurs de tentatives, anti-replay et échecs d'audit entre tests.
+
+    Compatible core-only : si `forge_mvc_mfa` n'est pas installé, le purge
+    anti-replay devient un no-op.
+    """
+    from core.auth.rate_limit import purge_all_attempts
+    from core.auth.audit import reset_audit_failure_count
+
+    try:
+        from forge_mvc_mfa.totp_replay import purge_all as _purge_replay
+    except ImportError:
+        def _purge_replay():  # type: ignore[misc]
+            """No-op : forge-mvc-mfa n'est pas installé."""
+            return None
+
+    purge_all_attempts()
+    _purge_replay()
+    reset_audit_failure_count()
+    yield
+    purge_all_attempts()
+    _purge_replay()
+    reset_audit_failure_count()
+
+
+@pytest.fixture(autouse=True)
+def clear_upload_rate_limits():
+    """Vide le compteur d'uploads entre chaque test.
+
+    Le rate-limit d'upload vit dans `forge_mvc_files` (ADR-019) ; absent → no-op.
+    """
+    try:
+        from forge_mvc_files import rate_limit as _rl
+    except ImportError:
+        yield
+        return
+    _rl._compteurs.clear()
+    yield
+    _rl._compteurs.clear()
+
+
+@pytest.fixture
+def fake_request():
+    """Retourne la classe `FakeRequest` pour construire des requêtes simulées."""
+    return FakeRequest

forge_mvc_testing-1.0.0rc2.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: forge-mvc-testing
+Version: 1.0.0rc2
+Summary: Forge : infrastructure de test partagée (FakeRequest + plugin pytest) pour tester Forge et ses opt-ins.
+Author: Roger Lequette
+License-Expression: LicenseRef-Forge-Proprietary
+Project-URL: Homepage, https://github.com/caucrogeGit/Forge
+Project-URL: Repository, https://github.com/caucrogeGit/Forge
+Keywords: python,mvc,forge,testing,pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: forge-mvc<2,>=1.0.0rc2
+Requires-Dist: pytest>=7
+Dynamic: license-file
+
+# forge-mvc-testing
+
+Infrastructure de test partagée pour le framework Forge (ADR-041).
+
+Ce paquet réservé au développement fournit de quoi tester Forge, ses opt-ins
+officiels, et les opt-ins ou applications développés par des tiers :
+
+- `FakeRequest` : une fausse requête HTTP pour tester contrôleurs et helpers sans serveur ;
+- un plugin pytest (chargé automatiquement à l'installation) dont les fixtures
+  autouse configurent le noyau Forge et réinitialisent l'état partagé entre
+  tests (compteurs de tentatives, anti-replay, échecs d'audit).
+
+## Statut
+
+`forge-mvc-testing` est en `Development Status :: 4 - Beta`, aligné sur la
+version du cœur. C'est un outil de **développement** : une application ne
+l'importe jamais à l'exécution.
+
+## Installation
+
+```bash
+pip install --pre forge-mvc-testing
+```
+
+En général comme dépendance de développement, par exemple dans
+`requirements-dev.txt` :
+
+```
+forge-mvc-testing
+```
+
+## Utilisation
+
+```python
+from forge_mvc_testing import FakeRequest
+
+def test_mon_controleur():
+    request = FakeRequest(method="GET", query={"page": "2"})
+    response = MonControleur.index(request)
+    assert response.status == 200
+```
+
+Le plugin pytest s'active dès que le paquet est installé : ses fixtures autouse
+préparent le noyau Forge et nettoient l'état partagé avant chaque test, sans
+configuration.
+
+## Licence
+
+Distribué sous licence propriétaire Forge (`LicenseRef-Forge-Proprietary`),
+comme le reste du framework. Voir `LICENSE`.

forge_mvc_testing-1.0.0rc2.dist-info/RECORD

@@ -0,0 +1,10 @@
+forge_mvc_testing/__init__.py,sha256=QQa7_b8Uk3104OhXsDtPD3czYcBpK75yTQjS9QNVSos,532
+forge_mvc_testing/fake_request.py,sha256=0T8p7HtGV4cAspwCXMpkJ1U6ZzIww5xBDWmF8esUpoI,5000
+forge_mvc_testing/plugin.py,sha256=hmc8IFr2kj_-m2Mk8Pzw9Fi40BWu6UmwRec_1Vvjprc,3558
+forge_mvc_testing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forge_mvc_testing-1.0.0rc2.dist-info/licenses/LICENSE,sha256=kT7JQI9x59JeUwpyiFmqyM6hwLhDzdPS0Wczb5iY3G0,1599
+forge_mvc_testing-1.0.0rc2.dist-info/METADATA,sha256=d4euMDkgeca6Qydk4f41wtMTm2WPdg8mQZdO4MUWNPk,2361
+forge_mvc_testing-1.0.0rc2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+forge_mvc_testing-1.0.0rc2.dist-info/entry_points.txt,sha256=aTJtxAa3vA1xJ12PjiSEtjKta0HmRIO-uQHbBXyIypk,56
+forge_mvc_testing-1.0.0rc2.dist-info/top_level.txt,sha256=aSejGBDuvxByKSpU7NM5UoElp8zaglVNI1HBRURevo8,18
+forge_mvc_testing-1.0.0rc2.dist-info/RECORD,,

forge_mvc_testing-1.0.0rc2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

forge_mvc_testing-1.0.0rc2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+forge_mvc_testing = forge_mvc_testing.plugin

forge_mvc_testing-1.0.0rc2.dist-info/licenses/LICENSE

@@ -0,0 +1,36 @@
+Forge — Licence propriétaire / source disponible
+
+Copyright (c) Roger Lequette.
+Tous droits réservés.
+
+Le code source de Forge est mis à disposition uniquement pour lecture, étude,
+évaluation et usage éducatif personnel.
+
+Sauf autorisation écrite préalable de Roger Lequette, il est interdit de :
+
+- utiliser Forge dans un cadre professionnel, commercial ou institutionnel ;
+- utiliser Forge pour une prestation client ;
+- intégrer Forge dans un produit, service, SaaS, application vendue ou solution
+  déployée pour un tiers ;
+- redistribuer Forge, modifié ou non ;
+- publier une version modifiée de Forge ;
+- vendre, louer, sous-licencier ou exploiter commercialement Forge ;
+- supprimer ou modifier les mentions de copyright et de licence.
+
+Les usages autorisés sans autorisation écrite préalable sont limités à :
+
+- lire le code ;
+- étudier son fonctionnement ;
+- tester Forge à titre personnel ;
+- l'utiliser dans un cadre éducatif personnel ou pédagogique non commercial ;
+- évaluer le framework avant une éventuelle demande d'autorisation.
+
+Toute utilisation non explicitement autorisée par cette licence nécessite une
+autorisation écrite préalable de Roger Lequette.
+
+Cette licence pourra évoluer ultérieurement. Toute version publiée de Forge
+reste soumise à la licence présente dans son dépôt au moment de sa récupération.
+
+LE LOGICIEL EST FOURNI « TEL QUEL », SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU
+IMPLICITE. EN AUCUN CAS LE DÉTENTEUR DU COPYRIGHT NE POURRA ÊTRE TENU
+RESPONSABLE DE TOUT DOMMAGE DÉCOULANT DE L'UTILISATION DE CE LOGICIEL.

forge_mvc_testing-1.0.0rc2.dist-info/top_level.txt

@@ -0,0 +1 @@
+forge_mvc_testing