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
from collections.abc import Callable, Generator
from typing import Any, TypeVar

from flask.testing import FlaskClient

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")
# "Mes assets" (voir auth/user_assets_dir.py, db/constants.py::USER_ASSETS_DIR) :
# même raison que FORGE_USERS_DB_PATH ci-dessus — jamais écrire dans le
# vrai user_assets/ du poste pendant les tests.
os.environ["FORGE_USER_ASSETS_DIR"] = os.path.join(_TEST_AUTH_DIR, "user_assets")

import pytest  # noqa: E402 - doit venir apres les variables d'environnement ci-dessus

import auth  # noqa: E402 - doit venir apres les variables d'environnement ci-dessus
import db  # noqa: E402 - doit venir apres les variables d'environnement ci-dessus
import routes  # noqa: F401, E402 - enregistre toutes les routes sur flask_app
from core import (  # noqa: E402 - doit venir apres les variables d'environnement ci-dessus
    auth_guard,  # noqa: F401 - enregistre la garde de connexion (après les routes)
    csrf,  # noqa: F401 - enregistre csrf_token() comme variable globale Jinja
    csrf_guard,  # noqa: F401 - enregistre la vérification du jeton CSRF (désactivée en TESTING, voir test_csrf.py)
    db_teardown_guard,  # noqa: F401 - enregistre la fermeture des connexions SQLite fuitées
    jinja_filters,  # noqa: F401 - enregistre les filtres Jinja (colname, truncatesentences)
    recovery_codes_flash,  # noqa: F401 - enregistre pop_recovery_codes() comme variable globale Jinja
)
from core.flask_app import app as flask_app  # noqa: E402 - doit venir apres les variables d'environnement ci-dessus

# Onglet "IA" (voir ai/) : jamais un vrai appel réseau depuis les tests,
# même si un .env réel existe sur ce poste avec de vraies clés —
# load_dotenv() (core.flask_app, importé ci-dessus) les aurait déjà
# chargées dans os.environ à ce stade ; on les retire explicitement pour
# que CHAQUE test parte de "IA non configurée" par défaut. Un test qui
# veut simuler une IA configurée monkeypatche directement
# ai.client.get_client/ai.scenario_client.generate_image_url — jamais via
# une vraie clé, quel que soit le contenu du .env local.
for _ai_env_key in ("ANTHROPIC_API_KEY", "SCENARIO_API_KEY", "SCENARIO_API_SECRET", "SCENARIO_MODEL_ID"):
    os.environ.pop(_ai_env_key, None)

# 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)

_T = TypeVar("_T")


def not_none(value: _T | None) -> _T:
    """Pour les endroits où Mypy voit un `X | None` (ex. db.get_xxx) mais où
    le test sait, par construction, que la valeur existe forcément (vient
    d'être créée/insérée juste au-dessus) — lève AssertionError (message
    clair) plutôt qu'un TypeError cru si jamais cette hypothèse était fausse."""
    assert value is not None
    return value


@pytest.fixture
def tmp_game_slug_cleanup() -> Generator[Callable[[str], str], None, None]:
    """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: str) -> str:
        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(autouse=True)
def _cleanup_admin_assets() -> Generator[None, None, None]:
    """Filet de sécurité : le compte admin (`_TEST_ADMIN_ID`) est PARTAGÉ
    par toute la session de tests (voir plus haut) — un test qui crée un
    "asset" dessus (upload, outil IA...) sans le nettoyer lui-même pollue
    tous les tests suivants. Complète (ne remplace pas) les nettoyages
    ponctuels déjà faits dans le corps de certains tests : ceux-ci restent
    nécessaires quand le test vérifie un invariant sur la liste des assets
    AVANT sa propre fin (ce filet ne rattrape qu'après coup). `_TEST_ADMIN_ID`
    est fixe pour toute la session (un seul admin existe, voir plus haut) —
    pas besoin de le résoudre dynamiquement par test."""
    before = {asset["id"] for asset in auth.list_user_assets(_TEST_ADMIN_ID)}
    yield
    for asset in auth.list_user_assets(_TEST_ADMIN_ID):
        if asset["id"] not in before:
            auth.delete_user_asset(asset["id"], _TEST_ADMIN_ID)


@pytest.fixture
def client() -> Generator[FlaskClient, None, None]:
    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


_TEST_USER_COUNTER = [0]


@pytest.fixture
def user_client() -> Generator[FlaskClient, None, None]:
    """Un compte "user" (jamais le premier de la session de tests, donc
    jamais admin — voir auth/create_user.py), connecté mais SANS projet
    assigné pour l'instant (voir la fixture `user_game` ci-dessous) —
    pour les tests qui vérifient qu'un rôle non-admin voit/peut moins de
    choses qu'un admin (ex. galerie de sprites animaux CraftPix, voir
    core/sprite_gate.py)."""
    _TEST_USER_COUNTER[0] += 1
    email = f"pytest-user-{_TEST_USER_COUNTER[0]}@pytest.local"
    user_id = auth.create_user(email, "Test1234!", "Test", "User")
    auth.confirm_totp(user_id)
    flask_app.config["TESTING"] = True
    with flask_app.test_client() as c:
        with c.session_transaction() as sess:
            sess["user_id"] = user_id
        yield c


@pytest.fixture
def user_game(user_client: FlaskClient) -> Generator[str, None, None]:
    """Un jeu appartenant réellement au compte `user_client` — le dossier
    PROPRIÉTAIRE (voir db/games/project_slug.py) doit correspondre à
    l'id de CE compte (core/auth_guard.py compare désormais les deux) :
    créé directement avec `owner_folder=str(user_id)`, jamais via le
    client ADMIN (qui produirait un projet appartenant à l'admin, avec
    juste `project_slug` réassigné dessus côté "user" — cassait
    l'isolation par propriétaire dès qu'elle a cessé d'être une simple
    comparaison de chaîne)."""
    with user_client.session_transaction() as sess:
        user_id = sess["user_id"]
    slug = db.create_game("pytest_user_game", owner_folder=str(user_id))
    auth.set_project_slug(user_id, slug)
    yield slug
    if os.path.isdir(db.game_dir(slug)):
        db.delete_game(slug)


@pytest.fixture
def game(client: FlaskClient) -> Generator[str, None, None]:
    """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
    if os.path.isdir(db.game_dir(slug)):
        db.delete_game(slug)


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


def _js_bundle(directory: str) -> str:
    parts = []
    for name in sorted(os.listdir(directory)):
        path = os.path.join(directory, 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)


def play_js_bundle() -> str:
    """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."""
    return _js_bundle(_PLAY_JS_DIR)


def screen_edit_js_bundle() -> str:
    """Même principe que play_js_bundle(), pour l'éditeur (static/js/
    screen_edit/, extrait de templates/screen_edit.html)."""
    return _js_bundle(_SCREEN_EDIT_JS_DIR)


@pytest.fixture
def mail_object(client: FlaskClient, game: str) -> dict[str, Any]:
    """Un objet "Mail" avec deux champs texte (sujet, expediteur)."""
    definition_id = db.create_definition(
        game,
        "Mail",
        [
            {"name": "sujet", "type": "texte"},
            {"name": "expediteur", "type": "texte"},
        ],
    )
    return {"slug": game, "definition_id": definition_id}