Files
mtusi2026lab6/service-tests/db/test_uow.py
T

519 lines
19 KiB
Python

"""Настоящая единица работы: граница транзакции, соединение на шаг, срок блока,
отказ PostgreSQL и обрыв соединения с дешёвой проверкой при выдаче (спек
`unit-of-work`, design, решения 2, 4, 7)."""
import asyncio
import time
import pytest
from sqlalchemy import event, exc, text
from builders import NOW, PASSWORD_HASH, attachment_dto, user_dto
from conftest import (
DatabaseWarnings,
TcpProxy,
admin,
make_engine,
make_factory,
make_uow,
truncate_all,
)
from src.core import exceptions
from src.core.ports.uow import UnitOfWorkError
from src.infra.db import scope
from src.infra.db.engine import _ping_once
from src.infra.db.uow import SqlAlchemyUnitOfWork
from src.schemas.enums import AttachmentStatus
from src.utils.constants import (
DB_APPLICATION_NAME,
DB_CLOSE_TIMEOUT_SECONDS,
)
pytestmark = pytest.mark.anyio
SECONDS_MARGIN = 0.7
# сервер замечает закрытый сокет не сразу
SESSIONS_SETTLE_SECONDS = 3.0
@pytest.fixture
async def engine():
await truncate_all()
created = make_engine(pool_size=1)
yield created
await created.dispose()
@pytest.fixture
def uow(engine) -> SqlAlchemyUnitOfWork:
return make_uow(make_factory(engine))
def _other(engine) -> SqlAlchemyUnitOfWork:
return make_uow(make_factory(engine))
async def _pid(uow: SqlAlchemyUnitOfWork) -> int:
result = await uow._current_session().execute(
text("SELECT pg_backend_pid()"),
)
return result.scalar_one()
async def _user_visible(engine, username: str) -> bool:
async with _other(engine) as other:
found = await other.users.get_user_credentials(username=username)
return found is not None
async def test_exit_without_commit(uow, engine) -> None:
"""Сценарий «Выход без фиксации»."""
user = user_dto()
async with uow:
await uow.users.insert_user(user=user, password_hash=PASSWORD_HASH)
assert not await _user_visible(engine, user.username)
async def test_exception_inside_block(uow, engine) -> None:
"""Сценарий «Исключение внутри блока»: то же исключение, запись откачена."""
user = user_dto()
with pytest.raises(exceptions.UsernameTaken):
async with uow:
await uow.users.insert_user(user=user, password_hash=PASSWORD_HASH)
raise exceptions.UsernameTaken
assert not await _user_visible(engine, user.username)
async def test_commit_visible_to_other_connection(uow, engine) -> None:
"""Сценарий «Фиксация»."""
user = user_dto()
async with uow:
await uow.users.insert_user(user=user, password_hash=PASSWORD_HASH)
await uow.commit()
assert await _user_visible(engine, user.username)
async def test_work_after_commit_is_an_error(uow) -> None:
"""Сценарий «Работа после фиксации»: не молчаливая вторая транзакция."""
async with uow:
await uow.commit()
with pytest.raises(UnitOfWorkError):
_ = uow.users
with pytest.raises(UnitOfWorkError):
await uow.commit()
async def test_nested_block_without_second_connection(uow, engine) -> None:
"""Сценарий «Вложенный блок»."""
async with uow:
await uow.users.get_user_credentials(username="nobody")
with pytest.raises(UnitOfWorkError):
await uow.__aenter__()
assert engine.pool.checkedout() == 1
async def test_repo_outside_block_no_query(uow, engine) -> None:
"""Сценарий «Repo вне блока»: запроса нет."""
with pytest.raises(UnitOfWorkError):
_ = uow.users
assert engine.pool.checkedout() == 0
async def test_blocks_opened(uow) -> None:
for _ in range(3):
async with uow:
pass
assert uow.blocks_opened == 3
async def test_connection_taken_only_inside_block(uow, engine) -> None:
pool = engine.pool
assert pool.checkedout() == 0
async with uow:
# выдача ленивая: сессия без выражения соединения не берёт
assert pool.checkedout() == 0
await uow.users.get_user_credentials(username="nobody")
assert pool.checkedout() == 1
assert pool.checkedout() == 0
async def test_commit_returns_connection_after_exit(uow, engine) -> None:
async with uow:
await uow.users.get_user_credentials(username="nobody")
await uow.commit()
assert engine.pool.checkedout() == 0
async def test_statement_longer_than_block(
engine,
warnings: DatabaseWarnings,
) -> None:
"""Сценарий «Запрос дольше срока»."""
uow = make_uow(make_factory(engine), timeout_seconds=0.3)
async with uow:
first_pid = await _pid(uow)
started = time.monotonic()
with pytest.raises(exceptions.ServiceUnavailable):
async with uow:
await uow._current_session().execute(
text("SELECT pg_sleep(4)"),
)
assert time.monotonic() - started < 0.3 + DB_CLOSE_TIMEOUT_SECONDS
assert warnings.events == ["Database is unavailable"]
assert engine.pool.checkedout() == 0
# следующий блок — рабочее соединение, а не прежнее
async with uow:
assert await _pid(uow) != first_pid
async def test_frozen_on_rollback(
proxy_target,
warnings: DatabaseWarnings,
) -> None:
"""Сценарий «PostgreSQL заморожен при откате»."""
async with TcpProxy(*proxy_target) as proxy:
engine = make_engine(host="127.0.0.1", port=proxy.port, pool_size=1)
uow = make_uow(make_factory(engine), timeout_seconds=0.5)
started = None
with pytest.raises(exceptions.ServiceUnavailable):
async with uow:
await uow.users.get_user_credentials(username="nobody")
proxy.freeze()
started = time.monotonic()
elapsed = time.monotonic() - started
assert elapsed < 0.5 + DB_CLOSE_TIMEOUT_SECONDS + SECONDS_MARGIN
assert warnings.events == ["Database is unavailable"]
assert engine.pool.checkedout() == 0
proxy.thaw()
await engine.dispose()
async def test_frozen_at_exception_in_block(proxy_target) -> None:
"""Исключение при замороженном сервере: откат под сроком блока, отказ БД
заменяет доменное исключение, а не висит до разморозки."""
async with TcpProxy(*proxy_target) as proxy:
engine = make_engine(host="127.0.0.1", port=proxy.port, pool_size=1)
uow = make_uow(make_factory(engine), timeout_seconds=0.5)
started = time.monotonic()
with pytest.raises(exceptions.ServiceUnavailable):
async with uow:
await uow.users.get_user_credentials(username="nobody")
proxy.freeze()
started = time.monotonic()
raise exceptions.ChatNotFound
elapsed = time.monotonic() - started
assert elapsed < 0.5 + DB_CLOSE_TIMEOUT_SECONDS + SECONDS_MARGIN
proxy.thaw()
await engine.dispose()
async def test_cancel_with_open_transaction(proxy_target) -> None:
"""Сценарий «Отмена при открытой транзакции»."""
async with TcpProxy(*proxy_target) as proxy:
engine = make_engine(host="127.0.0.1", port=proxy.port, pool_size=1)
uow = make_uow(make_factory(engine), timeout_seconds=30)
inside = asyncio.Event()
async def block() -> None:
async with uow:
await uow.users.get_user_credentials(username="nobody")
inside.set()
await asyncio.sleep(60)
task = asyncio.create_task(block())
await inside.wait()
accepted = proxy.accepted
proxy.freeze()
started = time.monotonic()
task.cancel()
with pytest.raises(asyncio.CancelledError):
await task
elapsed = time.monotonic() - started
assert elapsed < DB_CLOSE_TIMEOUT_SECONDS + SECONDS_MARGIN
assert engine.pool.checkedout() == 0
proxy.thaw()
# соединение в пул не вернулось: следующий блок открывает новое
async with uow:
await uow.users.get_user_credentials(username="nobody")
assert proxy.accepted == accepted + 1
await engine.dispose()
async def test_child_task_under_deadline_keeps_block_timer(engine) -> None:
"""Общий срок снимает таймер только у своей задачи: дочернюю его отмена не
достанет, а копия контекста у неё та же."""
uow = make_uow(make_factory(engine), timeout_seconds=0.3)
async def slow_block() -> None:
async with uow:
await uow._current_session().execute(text("SELECT pg_sleep(4)"))
started = time.monotonic()
async with scope.deadline_scope(timeout_seconds=30):
with pytest.raises(exceptions.ServiceUnavailable):
await asyncio.create_task(slow_block())
assert time.monotonic() - started < 0.3 + DB_CLOSE_TIMEOUT_SECONDS
async def _app_sessions(connection) -> int:
"""Сессии приложения во временной базе; соединение теста — без его имени."""
return await connection.fetchval(
"SELECT count(*) FROM pg_stat_activity "
"WHERE datname = current_database() AND application_name = $1",
DB_APPLICATION_NAME,
)
async def _settled_sessions(connection, *, limit: int) -> int:
"""Сессии, когда их стало не больше `limit` или вышел срок ожидания."""
deadline = time.monotonic() + SESSIONS_SETTLE_SECONDS
while True:
sessions = await _app_sessions(connection)
if sessions <= limit or time.monotonic() > deadline:
return sessions
await asyncio.sleep(0.1)
async def test_no_sessions_over_pool_after_freeze(proxy_target) -> None:
"""Сценарий «После заморозки PostgreSQL сессий сверх пула нет»: заморозка на
проверке соединения при выдаче (транзакции нет, и срок простоя транзакции
сессию не снимет), три раза подряд."""
pool_size = 2
connection = await admin()
try:
baseline = await _app_sessions(connection)
async with TcpProxy(*proxy_target) as proxy:
engine = make_engine(
host="127.0.0.1",
port=proxy.port,
pool_size=pool_size,
)
factory = make_factory(engine)
async def step() -> None:
uow = make_uow(factory, timeout_seconds=0.3)
async with uow:
await uow._current_session().execute(
text("SELECT pg_sleep(0.05)"),
)
for _ in range(3):
# прогрев: открыты все соединения пула, запросы идут вместе
await asyncio.gather(*(step() for _ in range(pool_size)))
proxy.freeze()
results = await asyncio.gather(
*(step() for _ in range(pool_size)),
return_exceptions=True,
)
assert all(
isinstance(result, exceptions.ServiceUnavailable)
for result in results
), results
proxy.thaw()
# соединения этой пачки сброшены, в пуле их нет
assert engine.pool.checkedout() == 0
sessions = await _settled_sessions(connection, limit=baseline)
assert sessions <= baseline, f"{sessions} > {baseline}"
# пул рабочий: новые соединения вместо сброшенных
await step()
await engine.dispose()
finally:
await connection.close()
async def test_soft_close_is_graceful(proxy_target) -> None:
"""Мягкое закрытие без отказа: сервер получил Terminate и закрыл сессию сам,
обрыв транспорта после него ничего не меняет."""
connection = await admin()
try:
baseline = await _app_sessions(connection)
async with TcpProxy(*proxy_target) as proxy:
engine = make_engine(
host="127.0.0.1",
port=proxy.port,
pool_size=1,
)
async with engine.connect():
pass
assert await _app_sessions(connection) == baseline + 1
before = proxy.client_writes
await engine.dispose()
sessions = await _settled_sessions(connection, limit=baseline)
assert sessions == baseline
# единственная порция клиента после проверки — Terminate
assert proxy.client_writes == before + 1
finally:
await connection.close()
async def test_constraint_violation(
uow,
engine,
warnings: DatabaseWarnings,
) -> None:
"""Сценарий «Нарушение ограничения»."""
async with uow:
first_pid = await _pid(uow)
with pytest.raises(exc.IntegrityError):
async with uow:
# owner не участник: внешний ключ на chat_members
await uow.attachments.insert_attachment(
attachment=attachment_dto(
chat_id=user_dto().id,
owner_id=user_dto().id,
),
)
assert warnings.events == []
assert engine.pool.checkedout() == 0
async with uow:
assert await _pid(uow) == first_pid
async def test_terminated_connection_replaced(uow) -> None:
"""`pg_terminate_backend`: следующий блок получает новое без ошибки."""
async with uow:
pid = await _pid(uow)
connection = await admin()
try:
await connection.fetchval("SELECT pg_terminate_backend($1)", pid)
finally:
await connection.close()
async with uow:
assert await _pid(uow) != pid
async def test_ping_is_replaced(engine) -> None:
assert engine.dialect.do_ping is _ping_once
async def test_ping_detects_dropped_connection_through_proxy(
proxy_target,
) -> None:
"""Обрыв при подменённой проверке: `_connection`, `fetchrow` и
`_handle_exception` адаптера настоящие. Смена их имён ломает разбор обрыва, и
следующий блок падает ошибкой вместо нового соединения (design, решение 7)."""
async with TcpProxy(*proxy_target) as proxy:
engine = make_engine(host="127.0.0.1", port=proxy.port, pool_size=1)
pings: list[bool] = []
real_ping = engine.dialect.do_ping
def spy(connection) -> bool:
result = False
try:
result = real_ping(connection)
finally:
pings.append(result)
return result
engine.dialect.do_ping = spy
uow = make_uow(make_factory(engine))
async with uow:
first = await _pid(uow)
accepted = proxy.accepted
proxy.drop()
await asyncio.sleep(0)
async with uow:
second = await _pid(uow)
# проверка выполнялась и нашла обрыв; новое соединение через прокси
assert pings == [False]
assert second != first
assert proxy.accepted == accepted + 1
await engine.dispose()
async def test_ping_is_one_exchange(proxy_target) -> None:
"""Проверка при выдаче — один обмен, а не `BEGIN`, `;`, `ROLLBACK`."""
async with TcpProxy(*proxy_target) as proxy:
engine = make_engine(host="127.0.0.1", port=proxy.port, pool_size=1)
async with engine.connect():
pass
# первая проверка готовит выражение, вторая — повторная
async with engine.connect():
pass
before = proxy.client_writes
async with engine.connect():
pass
assert proxy.client_writes - before == 1
await engine.dispose()
async def test_ping_with_real_postgres_rejected_connection(engine) -> None:
"""Живое соединение: проверка не падает и возвращает пул в рабочий вид."""
async with engine.connect() as connection:
await connection.execute(text("SELECT 1"))
assert engine.pool.checkedout() == 0
async def _statements(engine, action) -> list[str]:
captured: list[str] = []
def before_cursor_execute(_c, _cursor, statement, _p, _ctx, _many) -> None:
captured.append(statement)
event.listen(
engine.sync_engine,
"before_cursor_execute",
before_cursor_execute,
)
try:
await action()
finally:
event.remove(
engine.sync_engine,
"before_cursor_execute",
before_cursor_execute,
)
return captured
@pytest.mark.parametrize(
("method", "constant"),
[
("lock_due_jobs", "'queued'"),
("count_published", "'queued'"),
("count_unfinished", "'processing'"),
("count_unfinished", "'queued'"),
("queue_snapshot", "'processing'"),
("queue_snapshot", "'queued'"),
("lock_stale_pending", "'pending'"),
("get_staging_candidates", "'ready'"),
],
)
async def test_status_is_a_constant_in_statement(
uow,
engine,
method: str,
constant: str,
) -> None:
async def action() -> None:
async with uow:
if method == "lock_due_jobs":
await uow.jobs.lock_due_jobs(now=NOW, limit=1)
elif method == "count_published":
await uow.jobs.count_published()
elif method == "count_unfinished":
await uow.jobs.count_unfinished(limit=1)
elif method == "queue_snapshot":
await uow.jobs.queue_snapshot(now=NOW)
elif method == "lock_stale_pending":
await uow.attachments.lock_stale_pending(
attachment_id=user_dto().id,
older_than=NOW,
)
else:
await uow.attachments.get_staging_candidates(
status=AttachmentStatus.READY,
updated_before=None,
after=None,
limit=1,
)
statements = await _statements(engine, action)
relevant = [
item
for item in statements
if "attachment" in item.lower() and "select" in item.lower()
]
assert relevant
assert all(constant in item for item in relevant), relevant