Files
mtusi2026lab2/student-tests/conftest.py
T
Artyom 8e4532f6f5 Forward-port lab3 SQLAlchemy and Alembic foundation
Carry source f591fa64e5 forward from 72a1e57. Preserve lab4 attachment transactions, reconciliation locks, quarantine, and existing schema data through verified legacy adoption. Keep report and evidence work in progress untouched.
2026-11-06 01:47:30 +03:00

255 lines
8.3 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
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(24000, 25000):
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 24000–24999")
@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-lab4-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-lab4-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):
return (await connection.exec_driver_sql(statement, args)).scalar()
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}