import asyncio import re import socket import subprocess import time from base64 import b64encode from collections.abc import AsyncIterator, Iterator from contextlib import asynccontextmanager from pathlib import Path from typing import Any from uuid import uuid4 import pytest from alembic import command from alembic.config import Config from fastapi import FastAPI from httpx import ASGITransport, AsyncClient from sqlalchemy import make_url from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine from sqlalchemy.pool import NullPool from fakes import MemoryStorageProvider from messenger.attachments.config import AttachmentsSettings from messenger.identity.config import IdentitySettings from messenger.main import create_app from messenger.messaging.config import MessagingSettings from messenger.shared.config import PlatformSettings from messenger.shared.entrypoints.config import TransportSettings from messenger.shared.infrastructure.postgres import unavailable ROOT = Path(__file__).resolve().parents[1] POSTGRES_IMAGE = re.compile(r"image: (postgres:\S+)") VALKEY_IMAGE = re.compile(r"image: (valkey/valkey:\S+)") STARTUP_SECONDS = 60 PASSWORD = "Пароль-для-тестов-01" APPS: dict[int, FastAPI] = {} TOKENS: dict[str, str] = {} DATABASE: dict[str, str] = {} def docker(*args: str) -> str: done = subprocess.run(["docker", *args], check=True, capture_output=True, text=True) return done.stdout.strip() def migration_config(dsn: str) -> Config: config = Config(str(ROOT / "alembic.ini")) config.attributes["database_url"] = dsn return config async def upgrade(dsn: str, revision: str = "head") -> None: await asyncio.to_thread(command.upgrade, migration_config(dsn), revision) async def migrated(dsn: str) -> None: deadline = time.monotonic() + STARTUP_SECONDS while True: try: await upgrade(dsn) return except Exception as error: if not unavailable(error) or time.monotonic() > deadline: raise await asyncio.sleep(0.5) @asynccontextmanager async def sql_connection(dsn: str | None = None) -> AsyncIterator[AsyncConnection]: engine = create_async_engine( make_url(dsn or DATABASE["url"]).set(drivername="postgresql+asyncpg"), poolclass=NullPool, hide_parameters=True, ) try: async with engine.begin() as connection: yield connection finally: await engine.dispose() def free_port() -> int: for port in range(25000, 26000): with socket.socket() as probe: try: probe.bind(("127.0.0.1", port)) return port except OSError: continue raise RuntimeError("No free test port in 25000–25999") @pytest.fixture(autouse=True) def database_for_api(request: pytest.FixtureRequest) -> None: if "api" in request.node.path.parts: request.getfixturevalue("database") def image(pattern: re.Pattern[str]) -> str: found = pattern.search((ROOT / "compose.yaml").read_text()) assert found is not None return found[1] def published(name: str, port: int) -> int: return int(docker("port", name, f"{port}/tcp").splitlines()[0].rsplit(":", 1)[1]) def container(name: str, *args: str) -> None: docker("run", "-d", "--rm", "--name", name, *args) def answering(name: str, *probe: str) -> bool: done = subprocess.run(["docker", "exec", name, *probe], capture_output=True, check=False) return done.returncode == 0 and b"PONG" in done.stdout @pytest.fixture(scope="session") def valkey() -> Iterator[dict[str, str]]: name = f"mtusi-lab5-test-valkey-{uuid4().hex[:8]}" container(name, "-p", f"127.0.0.1:{free_port()}:6379", image(VALKEY_IMAGE)) try: deadline = time.monotonic() + STARTUP_SECONDS while not answering(name, "valkey-cli", "ping"): assert time.monotonic() < deadline time.sleep(0.2) yield {"name": name, "url": f"redis://127.0.0.1:{published(name, 6379)}/0"} finally: subprocess.run(["docker", "rm", "-fv", name], capture_output=True, check=False) @pytest.fixture(scope="session") def database() -> Iterator[str]: name = f"mtusi-lab5-test-{uuid4().hex[:8]}" tuning = ["-c", "fsync=off", "-c", "synchronous_commit=off", "-c", "full_page_writes=off"] environment = ["-e", "POSTGRES_PASSWORD=test", "-e", "POSTGRES_DB=messenger"] container( name, *environment, "-p", f"127.0.0.1:{free_port()}:5432", image(POSTGRES_IMAGE), *tuning ) try: dsn = f"postgresql://postgres:test@127.0.0.1:{published(name, 5432)}/messenger" asyncio.run(migrated(dsn)) DATABASE["url"] = dsn yield dsn finally: subprocess.run(["docker", "rm", "-fv", name], capture_output=True, check=False) def split_settings(**overrides: Any) -> dict[str, Any]: base: dict[str, Any] = { "log_level": "CRITICAL", "cursor_secret": "test-secret-for-cursors", "database_url": DATABASE.get("url", "postgresql://unused@127.0.0.1:1/unused"), "s3_access_key_id": "test-key", "s3_secret_access_key": "test-secret-key", } base.update(overrides) groups = { "platform": PlatformSettings, "transport": TransportSettings, "identity": IdentitySettings, "messaging": MessagingSettings, "attachments": AttachmentsSettings, } return { name: kind.model_validate( {key: value for key, value in base.items() if key in kind.model_fields} ) for name, kind in groups.items() } @asynccontextmanager async def running_app(**overrides: Any) -> AsyncIterator[AsyncClient]: app = create_app(**split_settings(**overrides), overrides=(MemoryStorageProvider(),)) async with ( app.router.lifespan_context(app), AsyncClient(transport=ASGITransport(app=app), base_url="http://testserver") as http, ): APPS[id(http)] = app try: yield http finally: APPS.pop(id(http), None) async def resolve[DependencyT](http: AsyncClient, dependency: type[DependencyT]) -> DependencyT: return await APPS[id(http)].state.dishka_container.get(dependency) @pytest.fixture async def client() -> AsyncIterator[AsyncClient]: async with running_app() as http: yield http async def scalar(statement: Any, *args: Any) -> Any: async with sql_connection() as connection: if isinstance(statement, str): result = await connection.exec_driver_sql(statement, args) return result.scalar() if result.returns_rows else None return await connection.scalar(statement) def basic(username: str, password: str) -> dict[str, str]: encoded = b64encode(f"{username}:{password}".encode()).decode() return {"Authorization": f"Basic {encoded}"} def bearer(token: str) -> dict[str, str]: return {"Authorization": f"Bearer {token}"} def new_user(label: str, password: str = PASSWORD) -> dict[str, str]: return { "username": f"u_{label}_{uuid4().hex[:12]}", "display_name": f"Студент {label}", "password": password, } async def login(http: AsyncClient, username: str, password: str = PASSWORD) -> dict[str, Any]: response = await http.post("/api/v1/auth/sessions", headers=basic(username, password)) assert response.status_code == 201, response.text return response.json() async def register(http: AsyncClient, label: str, password: str = PASSWORD) -> dict[str, Any]: body = new_user(label, password) response = await http.post("/api/v1/users", json=body) assert response.status_code == 201, response.text user = response.json() TOKENS[user["id"]] = (await login(http, body["username"], password))["token"] return user async def make_chat( http: AsyncClient, owner: dict[str, Any], *members: dict[str, Any] ) -> dict[str, Any]: member_ids = [owner["id"], *[member["id"] for member in members]] response = await http.post( "/api/v1/chats", json={"title": "Тестовый чат", "member_ids": member_ids}, headers=actor(owner), ) assert response.status_code == 201, response.text return response.json() def actor(user: dict[str, Any]) -> dict[str, str]: return bearer(TOKENS[user["id"]]) def keyed(user: dict[str, Any], key: str | None = None) -> dict[str, str]: return {**actor(user), "Idempotency-Key": key or uuid4().hex}