Files
mtusi2026lab6/service-tests/db/conftest.py
T
ricoromaandClaude Opus 5.5 9cc6c0c7a6 chore: port lab 5 solution into the lab 6 skeleton
Source: mtusi2026lab5-safronov, solution/bvt2301-safronov, 046ec9e.
Contracts, public tests and evidence of lab 5 are not carried over.
The compose project, image and CI prefix are renamed to lab6; the first
broker start defect is recorded in KNOWN_ISSUES.md; PLAN.md outlines the
OpenSpec changes of lab 6.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 04:46:56 +03:00

258 lines
8.2 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.
"""`make service_test_db`: временная база `test_uow_<db>` в PostgreSQL стенда.
Имя проверяется шаблоном до любых действий (иначе код 2). База создаётся и
мигрирует в начале, удаляется при любом исходе (`pytest_unconfigure`); рабочая база
не затрагивается. Настройки «тесного» API — окружением до импорта `src`, как у
четвёртого API стенда отказов: срок 2 с, пул 1, ожидание пула 1 с, один хэш
одновременно. Единицы работы со своими сроками и пулами тесты собирают сами
(`make_engine`). Design change `unit-of-work`, решение 13.
"""
import asyncio
import os
import re
import subprocess
import sys
from pathlib import Path
import pytest
from dotenv import dotenv_values
ROOT = Path(__file__).resolve().parents[2]
TEST_DB_PATTERN = re.compile(r"^test_uow_[a-z0-9_]+$")
BLOCK_SECONDS = 2.0
# больше любой границы времени в тестах заморозки
FREEZE_LIMIT_SECONDS = 8.0
def _test_db_name() -> str:
override = os.environ.get("SERVICE_TEST_DB")
if override is not None:
return override
env = dotenv_values(ROOT / ".env")
return f"test_uow_{env.get('POSTGRES_DB') or 'messenger'}"
TEST_DB = _test_db_name()
if TEST_DB_PATTERN.fullmatch(TEST_DB) is None:
print(f"service_test_db: bad database name {TEST_DB!r}", file=sys.stderr)
# до импорта src и до любых действий с PostgreSQL
os._exit(2)
os.environ.update(
{
"APP__RUN_MODE": "console",
"DATABASE__NAME": TEST_DB,
"DATABASE__POOL_SIZE": "1",
"DATABASE__MAX_OVERFLOW": "0",
"DATABASE__POOL_TIMEOUT_SECONDS": "1",
"DATABASE__REQUEST_TIMEOUT_SECONDS": str(BLOCK_SECONDS),
"AUTH__KDF_CONCURRENCY": "1",
},
)
import asyncpg # noqa: E402
from sqlalchemy.ext.asyncio import ( # noqa: E402
AsyncEngine,
AsyncSession,
async_sessionmaker, # noqa: E402
)
from src.config import settings # noqa: E402
from src.infra.db import ( # noqa: E402
create_engine,
create_session_factory,
scope,
)
from src.infra.db.models.base import Base # noqa: E402
from src.infra.db.uow import SqlAlchemyUnitOfWork # noqa: E402
_created = False
class DatabaseWarnings:
"""Записи логгера `database`: сколько раз назван отказ."""
def __init__(self) -> None:
self.events: list[str] = []
def warning(self, event_name: str, **_: object) -> None:
self.events.append(event_name)
@pytest.fixture
def warnings(monkeypatch: pytest.MonkeyPatch) -> DatabaseWarnings:
recorder = DatabaseWarnings()
monkeypatch.setattr(scope, "logger", recorder)
return recorder
async def _admin_connection(database: str = "postgres") -> asyncpg.Connection:
source = settings.database
return await asyncpg.connect(
host=source.host,
port=source.port,
user=source.user,
password=source.password.get_secret_value(),
database=database,
timeout=source.connect_timeout_seconds,
)
async def _recreate(*, create: bool) -> None:
connection = await _admin_connection()
try:
await connection.execute(
f'DROP DATABASE IF EXISTS "{TEST_DB}" WITH (FORCE)',
)
if create:
await connection.execute(f'CREATE DATABASE "{TEST_DB}"')
finally:
await connection.close()
def pytest_sessionstart(session: pytest.Session) -> None:
global _created
_created = True
asyncio.run(_recreate(create=True))
subprocess.run(
[sys.executable, "-m", "alembic", "upgrade", "head"],
cwd=ROOT,
check=True,
capture_output=True,
)
def pytest_unconfigure(config: pytest.Config) -> None:
if _created:
asyncio.run(_recreate(create=False))
@pytest.fixture
def anyio_backend() -> str:
return "asyncio"
def make_engine(**overrides: object) -> AsyncEngine:
"""Свой engine к временной базе: тот же `create_engine`, что у процессов."""
return create_engine(settings.database.model_copy(update=overrides))
def make_uow(
factory: async_sessionmaker[AsyncSession],
*,
timeout_seconds: float = 5,
) -> SqlAlchemyUnitOfWork:
return SqlAlchemyUnitOfWork(factory, timeout_seconds=timeout_seconds)
def make_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
return create_session_factory(engine)
async def admin() -> asyncpg.Connection:
"""Соединение с временной базой мимо приложения: блокировки, обрыв, чистка."""
return await _admin_connection(TEST_DB)
async def truncate_all() -> None:
tables = ", ".join(
f'"{table.name}"' for table in Base.metadata.sorted_tables
)
connection = await admin()
try:
await connection.execute(f"TRUNCATE {tables} CASCADE")
finally:
await connection.close()
class TcpProxy:
"""TCP-прокси до PostgreSQL: замороженный сервер без `docker pause` рабочего
PostgreSQL. `freeze` — байты перестают идти в обе стороны, соединения живы;
`drop` — все соединения оборваны; `client_writes` — порции от клиента."""
def __init__(self, host: str, port: int) -> None:
self._target = (host, port)
self._server: asyncio.Server | None = None
self._gate = asyncio.Event()
self._gate.set()
self._writers: set[asyncio.StreamWriter] = set()
self._tasks: set[asyncio.Task[None]] = set()
self.port = 0
self.accepted = 0
self.client_writes = 0
async def __aenter__(self) -> "TcpProxy":
self._server = await asyncio.start_server(
self._handle,
"127.0.0.1",
0,
)
self.port = self._server.sockets[0].getsockname()[1]
return self
async def __aexit__(self, *exc_info: object) -> None:
self.thaw()
self.drop()
if self._server is not None:
self._server.close()
for task in list(self._tasks):
task.cancel()
await asyncio.gather(*self._tasks, return_exceptions=True)
def freeze(self) -> None:
"""Разморозка по сторожу: регрессия (откат вне срока) иначе висела бы
вечно, а так тест доходит до проверки времени и падает."""
self._gate.clear()
asyncio.get_running_loop().call_later(FREEZE_LIMIT_SECONDS, self.thaw)
def thaw(self) -> None:
self._gate.set()
def drop(self) -> None:
for writer in list(self._writers):
writer.transport.abort()
self._writers.clear()
async def _handle(
self,
reader: asyncio.StreamReader,
writer: asyncio.StreamWriter,
) -> None:
self.accepted += 1
upstream_reader, upstream_writer = await asyncio.open_connection(
*self._target,
)
self._writers.update({writer, upstream_writer})
for task in (
self._pump(reader, upstream_writer, counted=True),
self._pump(upstream_reader, writer, counted=False),
):
pump = asyncio.ensure_future(task)
self._tasks.add(pump)
pump.add_done_callback(self._tasks.discard)
async def _pump(
self,
reader: asyncio.StreamReader,
writer: asyncio.StreamWriter,
*,
counted: bool,
) -> None:
try:
while data := await reader.read(65536):
await self._gate.wait()
if counted:
self.client_writes += 1
writer.write(data)
await writer.drain()
except (ConnectionError, OSError):
pass
finally:
writer.transport.abort()
@pytest.fixture
def proxy_target() -> tuple[str, int]:
return settings.database.host, settings.database.port