forked from mtusi2026/mtusi2026lab3
274 lines
8.0 KiB
Python
274 lines
8.0 KiB
Python
"""Общие фикстуры тестов.
|
||
|
||
Тесты работают с настоящим PostgreSQL (отдельная БД messenger_test) и,
|
||
если задан TEST_CACHE_URL, с Redis.
|
||
"""
|
||
|
||
import asyncio
|
||
import base64
|
||
import os
|
||
import uuid
|
||
from pathlib import Path
|
||
from typing import Optional
|
||
|
||
import asyncpg
|
||
import pytest
|
||
from fastapi.testclient import TestClient
|
||
|
||
from app.config import Settings
|
||
from app.main import create_app
|
||
from app.db import create_engine
|
||
from app.migrate import run_migrations
|
||
|
||
ROOT = Path(__file__).resolve().parents[1]
|
||
TEST_DB_NAME = "messenger_test"
|
||
|
||
|
||
def read_dotenv() -> dict:
|
||
"""Прочитать .env из корня проекта в словарь."""
|
||
values = {}
|
||
path = ROOT / ".env"
|
||
if path.exists():
|
||
for line in path.read_text(encoding="utf-8").splitlines():
|
||
line = line.strip()
|
||
if line and not line.startswith("#") and "=" in line:
|
||
key, _, value = line.partition("=")
|
||
values[key.strip()] = value.strip()
|
||
return values
|
||
|
||
|
||
def database_parts() -> dict:
|
||
"""Параметры подключения к тестовой БД из TEST_DB_* или .env."""
|
||
env = read_dotenv()
|
||
return {
|
||
"user": os.environ.get("TEST_DB_USER", env.get("POSTGRES_USER", "messenger")),
|
||
"password": os.environ.get(
|
||
"TEST_DB_PASSWORD", env.get("POSTGRES_PASSWORD", "")
|
||
),
|
||
"host": os.environ.get("TEST_DB_HOST", "127.0.0.1"),
|
||
"port": int(os.environ.get("TEST_DB_PORT", "5433")),
|
||
}
|
||
|
||
|
||
def sqlalchemy_url(database: str = TEST_DB_NAME) -> str:
|
||
"""URL тестовой БД для SQLAlchemy."""
|
||
p = database_parts()
|
||
return "postgresql+asyncpg://%s:%s@%s:%d/%s" % (
|
||
p["user"],
|
||
p["password"],
|
||
p["host"],
|
||
p["port"],
|
||
database,
|
||
)
|
||
|
||
|
||
@pytest.fixture(scope="session", autouse=True)
|
||
def test_database():
|
||
"""Проверить доступность PostgreSQL и создать тестовую БД."""
|
||
p = database_parts()
|
||
|
||
async def prepare():
|
||
conn = await asyncpg.connect(
|
||
user=p["user"],
|
||
password=p["password"],
|
||
host=p["host"],
|
||
port=p["port"],
|
||
database="postgres",
|
||
timeout=5,
|
||
)
|
||
try:
|
||
exists = await conn.fetchval(
|
||
"SELECT 1 FROM pg_database WHERE datname = $1", TEST_DB_NAME
|
||
)
|
||
if not exists:
|
||
await conn.execute(
|
||
"CREATE DATABASE \"%s\" TEMPLATE template0 ENCODING 'UTF8'"
|
||
% TEST_DB_NAME
|
||
)
|
||
finally:
|
||
await conn.close()
|
||
|
||
try:
|
||
asyncio.run(prepare())
|
||
|
||
async def migrate():
|
||
engine = create_engine(make_settings())
|
||
try:
|
||
await run_migrations(engine)
|
||
finally:
|
||
await engine.dispose()
|
||
|
||
asyncio.run(migrate())
|
||
except Exception as error:
|
||
pytest.exit(
|
||
"PostgreSQL недоступен на %s:%s (%s). Запустите БД: "
|
||
"docker compose --env-file .env up -d db"
|
||
% (p["host"], p["port"], type(error).__name__),
|
||
returncode=2,
|
||
)
|
||
|
||
|
||
CACHE_URL = os.environ.get("TEST_CACHE_URL", "")
|
||
|
||
|
||
def make_settings(**overrides) -> Settings:
|
||
"""Настройки приложения для тестов с переопределением полей."""
|
||
base = Settings.from_env(
|
||
{
|
||
"DATABASE_URL": sqlalchemy_url(),
|
||
"DB_STARTUP_WAIT_SECONDS": "5",
|
||
"LOG_LEVEL": "INFO",
|
||
"CACHE_URL": CACHE_URL,
|
||
}
|
||
)
|
||
return Settings(**{**base.__dict__, **overrides})
|
||
|
||
|
||
def run_sql(query: str, *args):
|
||
"""Выполнить SQL в тестовой БД напрямую и вернуть строки."""
|
||
p = database_parts()
|
||
|
||
async def go():
|
||
conn = await asyncpg.connect(
|
||
user=p["user"],
|
||
password=p["password"],
|
||
host=p["host"],
|
||
port=p["port"],
|
||
database=TEST_DB_NAME,
|
||
timeout=5,
|
||
)
|
||
try:
|
||
return await conn.fetch(query, *args)
|
||
finally:
|
||
await conn.close()
|
||
|
||
return asyncio.run(go())
|
||
|
||
|
||
@pytest.fixture(scope="session")
|
||
def client(test_database):
|
||
"""Клиент приложения, общий для всего прогона."""
|
||
with TestClient(
|
||
create_app(make_settings()), raise_server_exceptions=False
|
||
) as test_client:
|
||
yield test_client
|
||
|
||
|
||
class Person:
|
||
"""Зарегистрированный пользователь с токеном и заголовками."""
|
||
|
||
def __init__(self, data: dict, password: str, token: str):
|
||
self.data = data
|
||
self.id = data["id"]
|
||
self.username = data["username"]
|
||
self.password = password
|
||
self.token = token
|
||
self._headers = {"Authorization": "Bearer " + token}
|
||
|
||
@property
|
||
def headers(self):
|
||
"""Новый ключ на новую операцию; тесты повторов задают ключ явно."""
|
||
return {**self._headers, "Idempotency-Key": uuid.uuid4().hex}
|
||
|
||
|
||
def basic_header(username: str, password: str) -> dict:
|
||
"""Заголовок Authorization: Basic."""
|
||
raw = (username + ":" + password).encode("utf-8")
|
||
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
|
||
|
||
|
||
def register_and_login(client: TestClient, name: str = "") -> Person:
|
||
"""Зарегистрировать уникального пользователя и войти."""
|
||
username = ("u_" + name + "_" + uuid.uuid4().hex[:10]).lower()
|
||
password = "T3st-pass-" + uuid.uuid4().hex
|
||
created = client.post(
|
||
"/api/v1/users",
|
||
json={
|
||
"username": username,
|
||
"display_name": "Тест " + name,
|
||
"password": password,
|
||
},
|
||
)
|
||
assert created.status_code == 201, created.text
|
||
session = client.post(
|
||
"/api/v1/auth/sessions", headers=basic_header(username, password)
|
||
)
|
||
assert session.status_code == 201, session.text
|
||
return Person(created.json(), password, session.json()["token"])
|
||
|
||
|
||
@pytest.fixture
|
||
def make_user(client):
|
||
"""Фабрика пользователей."""
|
||
return lambda name="": register_and_login(client, name)
|
||
|
||
|
||
@pytest.fixture
|
||
def make_chat(client):
|
||
"""Фабрика чатов."""
|
||
|
||
def factory(owner: Person, *others: Person, title: str = "Чат") -> dict:
|
||
members = [owner.id] + [p.id for p in others]
|
||
reply = client.post(
|
||
"/api/v1/chats",
|
||
json={"title": title, "member_ids": members},
|
||
headers=owner.headers,
|
||
)
|
||
assert reply.status_code == 201, reply.text
|
||
return reply.json()
|
||
|
||
return factory
|
||
|
||
|
||
@pytest.fixture
|
||
def alice(make_user):
|
||
"""Пользователь alice."""
|
||
return make_user("alice")
|
||
|
||
|
||
@pytest.fixture
|
||
def bob(make_user):
|
||
"""Пользователь bob."""
|
||
return make_user("bob")
|
||
|
||
|
||
@pytest.fixture
|
||
def eve(make_user):
|
||
"""Пользователь eve, не состоящий в чате."""
|
||
return make_user("eve")
|
||
|
||
|
||
@pytest.fixture
|
||
def chat(make_chat, alice, bob):
|
||
"""Чат alice и bob."""
|
||
return make_chat(alice, bob)
|
||
|
||
|
||
@pytest.fixture
|
||
def log_lines():
|
||
"""Собрать сообщения лога приложения."""
|
||
import logging
|
||
|
||
lines = []
|
||
|
||
class Collector(logging.Handler):
|
||
def emit(self, record):
|
||
lines.append(record.getMessage())
|
||
|
||
handler = Collector()
|
||
logger = logging.getLogger("messenger")
|
||
logger.addHandler(handler)
|
||
yield lines
|
||
logger.removeHandler(handler)
|
||
|
||
|
||
def assert_error(reply, status: int, code: str):
|
||
"""Проверить статус, код и формат тела ошибки."""
|
||
assert reply.status_code == status, reply.text
|
||
body = reply.json()
|
||
assert set(body) == {"error"}
|
||
assert set(body["error"]) == {"code", "message", "request_id"}
|
||
assert body["error"]["code"] == code
|
||
assert body["error"]["message"]
|
||
assert body["error"]["request_id"] == reply.headers["X-Request-Id"]
|