williamandClaude Sonnet 5
9efe119936
10 codes à usage unique (format "xxxx-xxxx-xxxx") sont générés à
l'instant même où la 2FA est confirmée (auth/recovery_codes.py, table
_recovery_codes séparée pour marquer/consommer chaque code un par un) —
seul leur hash (werkzeug, comme les mots de passe) est stocké, ils ne
sont visibles en clair qu'à cet instant précis.
Plutôt que d'interrompre la redirection habituelle après confirmation de
la 2FA, les codes sont posés en session ("recovery_codes_to_show") et
affichés une seule fois, en modal, dès le premier rendu de base.html qui
suit (core/recovery_codes_flash.py, session.pop) — préserve tel quel le
comportement de redirection déjà couvert par les tests existants.
Sur /login/2fa, un code de récupération est accepté à la place du code
TOTP habituel (routes/auth/login_2fa.py) : verify_totp est essayé en
premier (verify_recovery_code consomme le code dès qu'il correspond, on
ne veut pas en griller un pour rien sur une saisie qui aurait en fait
été un TOTP valide). Compte toujours vers le même compteur anti-bruteforce
que le code TOTP (déjà en place, voir auth/rate_limit.py).
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
108 lines
4.3 KiB
Python
108 lines
4.3 KiB
Python
"""
|
|
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)
|
|
|
|
|
|
@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)}
|