Forge-Engine/tests/test_player_state.py

"""Tests de la couche db/ pour l'état par joueur (Phase 1 du plan
d'extension du moteur) : une variable globale/un objet marqué per_player=1
(par défaut) donne une valeur/des lignes indépendantes par joueur ; marqué
per_player=0, la valeur/les lignes restent partagées entre tous les
joueurs. L'aperçu créateur (PLAYER_SHARED, le défaut de tous les
paramètres player_id) doit continuer de fonctionner exactement comme
avant ces changements — voir tests/test_confort.py, test_flow.py etc., qui
n'ont pas eu besoin d'être modifiés."""

from flask.testing import FlaskClient

import db
from tests.conftest import not_none


def test_global_variable_per_player_gives_independent_values(game: str) -> None:
    db.create_global_variable(game, "score", "nombre_entier", "0", per_player=True)
    db.update_global_variable_value(game, "score", "10", player_id="alice")
    db.update_global_variable_value(game, "score", "99", player_id="bob")

    assert not_none(db.get_global_variable(game, "score", player_id="alice"))["value"] == "10"
    assert not_none(db.get_global_variable(game, "score", player_id="bob"))["value"] == "99"
    # Le créateur (PLAYER_SHARED, la ligne "modèle") garde la valeur par
    # défaut — jamais écrasée par les joueurs.
    assert not_none(db.get_global_variable(game, "score"))["value"] == "0"


def test_global_variable_new_player_falls_back_to_default_value(game: str) -> None:
    db.create_global_variable(game, "vies", "nombre_entier", "3", per_player=True)
    assert not_none(db.get_global_variable(game, "vies", player_id="charlie"))["value"] == "3"


def test_global_variable_shared_ignores_player_id(game: str) -> None:
    db.create_global_variable(game, "compteur_visites", "nombre_entier", "0", per_player=False)
    db.update_global_variable_value(game, "compteur_visites", "1", player_id="alice")
    db.update_global_variable_value(game, "compteur_visites", "2", player_id="bob")
    # Même valeur pour tout le monde, y compris un 3e joueur qui n'a jamais écrit.
    assert not_none(db.get_global_variable(game, "compteur_visites", player_id="alice"))["value"] == "2"
    assert not_none(db.get_global_variable(game, "compteur_visites", player_id="bob"))["value"] == "2"
    assert not_none(db.get_global_variable(game, "compteur_visites", player_id="charlie"))["value"] == "2"


def test_global_variable_list_only_shows_template_row(game: str) -> None:
    db.create_global_variable(game, "score", "nombre_entier", "0", per_player=True)
    db.update_global_variable_value(game, "score", "10", player_id="alice")
    variables = db.list_global_variables(game)
    assert len(variables) == 1
    assert variables[0]["value"] == "0"


def test_global_variable_delete_by_id_cascades_all_players(game: str) -> None:
    var_id = not_none(db.create_global_variable(game, "score", "nombre_entier", "0", per_player=True))
    db.update_global_variable_value(game, "score", "10", player_id="alice")
    db.delete_global_variable_by_id(game, var_id)
    assert db.get_global_variable(game, "score", player_id="alice") is None
    assert db.get_global_variable(game, "score") is None


def test_object_per_player_gives_independent_rows(game: str) -> None:
    definition_id = db.create_definition(
        game, "Inventaire", [{"name": "objet", "type": "texte", "required": False}], per_player=True
    )
    definition = not_none(db.get_definition(game, definition_id))
    db.insert_row(game, definition, {"objet": "épée"}, player_id="alice")
    db.insert_row(game, definition, {"objet": "bouclier"}, player_id="bob")

    alice_rows = db.list_rows(game, definition, player_id="alice")
    bob_rows = db.list_rows(game, definition, player_id="bob")
    assert [r["objet"] for r in alice_rows] == ["épée"]
    assert [r["objet"] for r in bob_rows] == ["bouclier"]
    # Un nouveau joueur qui n'a encore rien démarre VIDE (pas de valeur par
    # défaut à copier pour une LISTE, contrairement à une variable scalaire).
    assert db.list_rows(game, definition, player_id="charlie") == []


def test_object_shared_gives_same_rows_to_every_player(game: str) -> None:
    definition_id = db.create_definition(
        game, "Catalogue", [{"name": "nom", "type": "texte", "required": False}], per_player=False
    )
    definition = not_none(db.get_definition(game, definition_id))
    db.insert_row(game, definition, {"nom": "Potion"})
    alice_rows = db.list_rows(game, definition, player_id="alice")
    bob_rows = db.list_rows(game, definition, player_id="bob")
    assert [r["nom"] for r in alice_rows] == ["Potion"]
    assert [r["nom"] for r in bob_rows] == ["Potion"]


def test_get_row_does_not_leak_across_players(game: str) -> None:
    definition_id = db.create_definition(
        game, "Inventaire", [{"name": "objet", "type": "texte", "required": False}], per_player=True
    )
    definition = not_none(db.get_definition(game, definition_id))
    row_id = db.insert_row(game, definition, {"objet": "épée"}, player_id="alice")
    # Bob ne doit jamais pouvoir lire/modifier/supprimer la ligne d'Alice,
    # même en devinant son row_id (garde-fou de sécurité pour la route
    # publique /jouer/<slug>).
    assert db.get_row(game, definition, row_id, player_id="bob") is None
    db.update_row_field(game, definition, row_id, definition["fields"][0], "hache", player_id="bob")
    assert not_none(db.get_row(game, definition, row_id, player_id="alice"))["objet"] == "épée"
    db.delete_row(game, definition, row_id, player_id="bob")
    assert db.get_row(game, definition, row_id, player_id="alice") is not None


def test_create_global_var_route_respects_per_player_checkbox(client: FlaskClient, game: str) -> None:
    client.post(
        f"/game/{game}/variables/new",
        data={
            "name": "score",
            "type": "nombre_entier",
            "default_value": "0",
        },
    )
    assert db.list_global_variables(game)[0]["per_player"] == 1

    client.post(
        f"/game/{game}/variables/new",
        data={
            "name": "compteur_visites",
            "type": "nombre_entier",
            "default_value": "0",
            "per_player": "0",
        },
    )
    variables = {v["name"]: v for v in db.list_global_variables(game)}
    assert variables["compteur_visites"]["per_player"] == 0


def test_creator_preview_default_matches_shared_definition_behavior(game: str) -> None:
    """L'aperçu créateur (aucun player_id passé nulle part, donc
    PLAYER_SHARED partout) doit continuer de fonctionner exactement comme
    avant l'état par joueur — un seul appelant, un seul jeu de lignes."""
    definition_id = db.create_definition(game, "Notes", [{"name": "texte", "type": "texte", "required": False}])
    definition = not_none(db.get_definition(game, definition_id))
    db.insert_row(game, definition, {"texte": "bonjour"})
    rows = db.list_rows(game, definition)
    assert [r["texte"] for r in rows] == ["bonjour"]