ForbiddenStarsApp/backend/tests/conftest.py

"""Фикстуры тестов: изолированная in-memory БД + TestClient + помощники."""
from __future__ import annotations

import os

# Тесты НИКОГДА не работают с БД дева/прода. Форсируем тестовое окружение и
# in-memory БД для ГЛОБАЛЬНОГО движка ещё ДО импорта приложения — даже случайное
# обращение к app.db.session.engine не затронет файлы дева/прода, какой бы
# APP_ENV ни был унаследован из окружения.
os.environ["APP_ENV"] = "development"
os.environ["LOCAL_PUBLIC"] = "local"  # cookie_secure=False детерминированно (не зависит от .env разработчика)
os.environ["DEV_DATABASE_URL"] = "sqlite://"
os.environ["FS_STARTUP_BOOTSTRAP"] = "0"  # тесты сами поднимают схему/данные

import pytest  # noqa: E402
from fastapi.testclient import TestClient  # noqa: E402
from sqlalchemy.pool import StaticPool  # noqa: E402
from sqlmodel import Session, SQLModel, create_engine, select  # noqa: E402

import app.models  # noqa: F401,E402  (регистрация моделей)
from app.core.security import hash_password  # noqa: E402
from app.db.session import get_session  # noqa: E402
from app.main import app  # noqa: E402
from app.models import AuthIdentity, GroupMember, User  # noqa: E402
from app.seed.reference_data import seed_reference_data  # noqa: E402


@pytest.fixture()
def engine():
    eng = create_engine(
        "sqlite://",
        connect_args={"check_same_thread": False},
        poolclass=StaticPool,
    )
    SQLModel.metadata.create_all(eng)
    with Session(eng) as s:
        seed_reference_data(s)
    yield eng
    # In-memory БД исчезает с закрытием соединения StaticPool; drop_all не нужен
    # (и невозможен из-за циклической FK users↔groups в SQLite).
    eng.dispose()


@pytest.fixture()
def client(engine):
    def _get_session():
        with Session(engine) as s:
            yield s

    app.dependency_overrides[get_session] = _get_session
    with TestClient(app) as c:
        yield c
    app.dependency_overrides.clear()


@pytest.fixture()
def make_admin(engine):
    def _make(username: str = "admin", password: str = "secret123") -> int:
        with Session(engine) as s:
            admin = User(
                nickname=username,
                role="admin",
                auth_provider="local",
                password_hash=hash_password(password),
            )
            s.add(admin)
            s.commit()
            s.refresh(admin)
            return admin.id

    return _make


# ─── Помощники ────────────────────────────────────────────────────────────────

def csrf_headers(client: TestClient) -> dict:
    token = client.cookies.get("csrf_token")
    return {"X-CSRF-Token": token} if token else {}


def login(client: TestClient, nickname: str) -> dict:
    # csrf_headers пуст при первом входе и содержит токен при смене пользователя
    # (когда уже есть сессионная cookie и middleware требует заголовок).
    r = client.post("/api/auth/dev/login", json={"nickname": nickname}, headers=csrf_headers(client))
    assert r.status_code == 200, r.text
    return r.json()


def add_group_member(engine, group_id: int, nickname: str, role: str = "member") -> int:
    """Подготовка данных: добавить игрока в группу напрямую (в обход приглашений).

    Создаёт пользователя при отсутствии. Возвращает user_id. Нужен, т.к. через HTTP
    прямого добавления больше нет — только приглашения (см. invitation_service)."""
    with Session(engine) as s:
        user = s.exec(select(User).where(User.nickname == nickname)).first()
        if user is None:
            user = User(nickname=nickname, role="player", auth_provider="stub")
            s.add(user)
            s.commit()
            s.refresh(user)
            # AuthIdentity нужен, чтобы dev-вход (login) нашёл того же игрока, а не создал дубль.
            s.add(AuthIdentity(user_id=user.id, provider="stub", external_id=nickname))
            s.commit()
        exists = s.exec(
            select(GroupMember).where(
                GroupMember.group_id == group_id, GroupMember.user_id == user.id
            )
        ).first()
        if exists is None:
            s.add(GroupMember(group_id=group_id, user_id=user.id, role=role))
            s.commit()
        return user.id  # type: ignore[return-value]


def start_match(client: TestClient, group_id: int, roster: list[dict]):
    """roster: [{user_id, faction_id, was_random?}] → ответ старта (in_progress)."""
    return client.post(
        "/api/matches",
        json={"group_id": group_id, "participants": roster},
        headers=csrf_headers(client),
    )


def finish_match(
    client: TestClient,
    match_id: int,
    results: list[dict],
    win_reason: str = "objectives",
    overall_comment: str | None = None,
):
    """results: [{user_id, place, comment?, faction_id?}]."""
    body: dict = {"participants": results, "win_reason": win_reason}
    if overall_comment is not None:
        body["overall_comment"] = overall_comment
    return client.post(
        f"/api/matches/{match_id}/finish", json=body, headers=csrf_headers(client)
    )


def create_finished_match(
    client: TestClient, group_id: int, players: list[dict], win_reason: str = "objectives"
) -> dict:
    """players: [{user_id, faction_id, place, comment?, was_random?}] → завершённая партия."""
    roster = [
        {
            "user_id": p["user_id"],
            "faction_id": p["faction_id"],
            "was_random": p.get("was_random", False),
        }
        for p in players
    ]
    started = start_match(client, group_id, roster)
    assert started.status_code == 200, started.text
    results = [
        {"user_id": p["user_id"], "place": p["place"], "comment": p.get("comment")}
        for p in players
    ]
    r = finish_match(client, started.json()["id"], results, win_reason)
    assert r.status_code == 200, r.text
    return r.json()