Forge-Engine/tests/conftest.py

"""
Fixtures pytest partagées.

Les tests utilisent le VRAI client de test Flask (`app.test_client()`) et de
VRAIES bases SQLite créées sous projects/ (comme en production) — rien n'est
simulé. Chaque jeu de test est créé avec un nom préfixé "pytest_" et son
dossier est supprimé automatiquement à la fin du test (fixture `game`),
pour ne jamais laisser de données de test dans projects/.
"""
import os
import shutil
import sys
import tempfile

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# Base de comptes (auth/) et clé de session ISOLÉES du poste réel — posé
# AVANT tout import de core.flask_app/auth (chemin résolu à chaque appel,
# voir auth/connection.py, mais réglé ici une bonne fois pour toute la
# session de tests, jamais data/users.db). Sans ça, faire tourner la
# suite de tests écrirait de vrais comptes dans la vraie base de comptes,
# et la logique "premier compte = admin" (auth/create_user.py) serait déjà
# consommée par un run précédent.
_TEST_AUTH_DIR = tempfile.mkdtemp(prefix="forge_test_auth_")
os.environ["FORGE_USERS_DB_PATH"] = os.path.join(_TEST_AUTH_DIR, "users.db")
os.environ["FORGE_SECRET_KEY_PATH"] = os.path.join(_TEST_AUTH_DIR, "secret_key")

import pytest

from core.flask_app import app as flask_app
from core import jinja_filters  # noqa: F401 - enregistre les filtres Jinja (elabel, elstyle, colname)
import routes  # noqa: F401 - enregistre toutes les routes sur flask_app
from core import auth_guard  # noqa: F401 - enregistre la garde de connexion (après les routes)
from core import csrf  # noqa: F401 - enregistre csrf_token() comme variable globale Jinja
from core import csrf_guard  # noqa: F401 - enregistre la vérification du jeton CSRF (désactivée en TESTING, voir test_csrf.py)
from core import recovery_codes_flash  # noqa: F401 - enregistre pop_recovery_codes() comme variable globale Jinja
import auth
import db

# Un seul compte admin pour toute la session de tests : les ~80 routes
# existantes s'attendent (comportement d'avant l'authentification) à un
# accès sans restriction — "admin" est le seul rôle illimité (voir
# core/auth_guard.py). Créé directement en Python (pas via /register) :
# ces tests exercent le RESTE du moteur, pas le parcours d'inscription
# lui-même (qui a ses propres tests dédiés, voir test_auth.py).
_TEST_ADMIN_ID = auth.create_user("admin@pytest.local", "Test1234!", "Test", "Admin")
auth.confirm_totp(_TEST_ADMIN_ID)


@pytest.fixture
def tmp_game_slug_cleanup():
    """Pour les tests qui appellent db.create_game(...) directement (sans
    passer par une route Flask) : enregistre un slug à nettoyer à la fin du
    test, quel que soit son résultat."""
    slugs = []

    def register(slug):
        slugs.append(slug)
        return slug

    yield register
    for slug in slugs:
        game_dir = db.game_dir(slug)
        if os.path.isdir(game_dir):
            shutil.rmtree(game_dir)


@pytest.fixture
def client():
    flask_app.config["TESTING"] = True
    with flask_app.test_client() as c:
        with c.session_transaction() as sess:
            sess["user_id"] = _TEST_ADMIN_ID
        yield c


@pytest.fixture
def game(client):
    """Crée un jeu de test frais et le supprime après le test, quel que
    soit son résultat (succès ou échec)."""
    resp = client.post("/games/new", data={"name": "pytest_test_game"}, follow_redirects=False)
    assert resp.status_code == 302
    slug = resp.headers["Location"].rstrip("/").split("/")[-1]
    yield slug
    game_dir = db.game_dir(slug)
    if os.path.isdir(game_dir):
        shutil.rmtree(game_dir)


_PLAY_JS_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "static", "js", "play")


def play_js_bundle():
    """Concatène tout le JS du moteur jouable (voir le plan de
    modularisation — static/js/play/, un fichier par responsabilité,
    extrait de l'ancien <script> unique de templates/play.html). Plusieurs
    tests vérifient que "le JS livré au joueur" contient telle fonction/
    telle chaîne, sans dépendre d'un navigateur — avant le découpage, ça
    revenait à chercher dans le HTML de /game/<slug>/play (tout était
    inline) ; maintenant la logique vit dans ces fichiers statiques."""
    parts = []
    for name in sorted(os.listdir(_PLAY_JS_DIR)):
        path = os.path.join(_PLAY_JS_DIR, name)
        if os.path.isfile(path) and name.endswith(".js"):
            with open(path, encoding="utf-8") as f:
                parts.append(f.read())
    return "\n".join(parts)


@pytest.fixture
def mail_object(client, game):
    """Un objet "Mail" avec deux champs texte (sujet, expediteur), pour les
    tests de Répéteur / élément de jeu lié à un objet."""
    resp = client.post(
        f"/game/{game}/objects/new",
        data={
            "object_name": "Mail",
            "field_name[]": ["sujet", "expediteur"],
            "field_type[]": ["texte", "texte"],
            "field_relation[]": ["", ""],
            "field_required[]": ["0", "0"],
        },
        follow_redirects=False,
    )
    assert resp.status_code == 302
    definition_id = resp.headers["Location"].rstrip("/").split("/")[-1]
    return {"slug": game, "definition_id": int(definition_id)}