forked from mtusi2026/mtusi2026lab2
Source: immutable lab5 snapshot f88e9ba43cdfd7eb6a5a7ae5feb4247b4e820071; forward the allowed diff from 64d5c67. Carry SQLAlchemy, Alembic, reliability fixes, versioned jobs, infrastructure and student tests without changing protected coursework files.
Validation: make check, validate, lint; 515 student tests passed with one Linux-only skip; public smoke with telemetry enabled and repeat migration passed. Stop the owned stack and retain volumes. Preserve the existing OTel work in progress; grade implementation remains a separate phase.
149 lines
5.9 KiB
Python
149 lines
5.9 KiB
Python
import asyncio
|
|
from collections.abc import AsyncIterator, Callable
|
|
from contextlib import asynccontextmanager
|
|
|
|
from httpx import AsyncClient
|
|
|
|
from conftest import actor, keyed, make_chat, register, resolve, running_app, scalar
|
|
from fakes import MemoryObjectStorage
|
|
from messenger.attachments.application.ports import ObjectStorage
|
|
from messenger.messaging.application import handlers
|
|
from messenger.messaging.domain.events import MessagePosted
|
|
from messenger.shared.application.messagebus import EventBus
|
|
from pictures import SAMPLE, png
|
|
from pipeline import settle
|
|
|
|
MARKER = "текст-который-не-должен-утечь-при-таймауте"
|
|
|
|
|
|
@asynccontextmanager
|
|
async def slow_post(delay: float) -> AsyncIterator[None]:
|
|
original: Callable = handlers.PostMessageHandler.__call__
|
|
|
|
async def stalled(self, command):
|
|
await asyncio.sleep(delay)
|
|
return await original(self, command)
|
|
|
|
handlers.PostMessageHandler.__call__ = stalled
|
|
try:
|
|
yield
|
|
finally:
|
|
handlers.PostMessageHandler.__call__ = original
|
|
|
|
|
|
async def post(client: AsyncClient, chat: dict, sender: dict, text: str):
|
|
return await client.post(
|
|
f"/api/v1/chats/{chat['id']}/messages", json={"text": text}, headers=keyed(sender)
|
|
)
|
|
|
|
|
|
async def prepared(client: AsyncClient) -> tuple[dict, dict]:
|
|
alice = await register(client, "alice")
|
|
return alice, await make_chat(client, alice)
|
|
|
|
|
|
async def test_timeout_returns_unavailable_error_body() -> None:
|
|
async with running_app(request_timeout_seconds=0.15) as client:
|
|
alice, chat = await prepared(client)
|
|
async with slow_post(1.0):
|
|
response = await post(client, chat, alice, "медленная запись")
|
|
assert response.status_code == 503
|
|
body = response.json()
|
|
assert body["error"]["code"] == "unavailable"
|
|
assert body["error"]["request_id"] == response.headers["X-Request-Id"]
|
|
|
|
|
|
async def test_timeout_does_not_break_following_requests() -> None:
|
|
async with running_app(request_timeout_seconds=0.15) as client:
|
|
alice, chat = await prepared(client)
|
|
async with slow_post(1.0):
|
|
assert (await post(client, chat, alice, "зависшая запись")).status_code == 503
|
|
assert (await post(client, chat, alice, "нормальная запись")).status_code == 201
|
|
assert (await client.get("/health/ready")).status_code == 200
|
|
|
|
|
|
async def test_timeout_is_logged_without_message_text(capsys) -> None:
|
|
async with running_app(request_timeout_seconds=0.15, log_level="INFO") as client:
|
|
alice, chat = await prepared(client)
|
|
async with slow_post(1.0):
|
|
assert (await post(client, chat, alice, MARKER)).status_code == 503
|
|
captured = capsys.readouterr()
|
|
assert "request.timeout" in captured.out
|
|
assert MARKER not in captured.out
|
|
assert MARKER not in captured.err
|
|
|
|
|
|
async def test_normal_request_is_not_affected_by_timeout() -> None:
|
|
async with running_app(request_timeout_seconds=5.0) as client:
|
|
alice, chat = await prepared(client)
|
|
assert (await post(client, chat, alice, "обычная запись")).status_code == 201
|
|
|
|
|
|
async def test_slow_event_handler_does_not_trigger_timeout() -> None:
|
|
async with running_app(request_timeout_seconds=0.3) as client:
|
|
alice, chat = await prepared(client)
|
|
blocked = asyncio.Event()
|
|
bus = await resolve(client, EventBus)
|
|
|
|
async def stall(_event: MessagePosted) -> None:
|
|
await blocked.wait()
|
|
|
|
bus.subscribe(MessagePosted, stall)
|
|
response = await post(client, chat, alice, "ответ не ждёт обработчик")
|
|
blocked.set()
|
|
assert response.status_code == 201
|
|
|
|
|
|
async def test_healthcheck_stays_fast(client: AsyncClient) -> None:
|
|
loop = asyncio.get_running_loop()
|
|
started = loop.time()
|
|
assert (await client.get("/health/live")).status_code == 200
|
|
assert loop.time() - started < 1.0
|
|
|
|
|
|
async def trickled(data: bytes, size: int, delay: float) -> AsyncIterator[bytes]:
|
|
for start in range(0, len(data), size):
|
|
await asyncio.sleep(delay)
|
|
yield data[start : start + size]
|
|
|
|
|
|
async def upload(client: AsyncClient, user: dict, chat: dict, body: AsyncIterator[bytes]):
|
|
return await client.post(
|
|
f"/api/v1/chats/{chat['id']}/attachments?filename=slow.png",
|
|
content=body,
|
|
headers={**actor(user), "Content-Type": "image/png"},
|
|
)
|
|
|
|
|
|
async def test_steady_slow_transfer_outlives_the_request_timeout() -> None:
|
|
picture = png(16, 16, size=1 << 20)
|
|
async with running_app(request_timeout_seconds=0.4, min_transfer_rate_bytes=16_384) as client:
|
|
alice, chat = await prepared(client)
|
|
loop = asyncio.get_running_loop()
|
|
started = loop.time()
|
|
uploaded = await upload(client, alice, chat, trickled(picture, 65_536, 0.1))
|
|
assert uploaded.status_code == 202, uploaded.text
|
|
assert loop.time() - started > 1.0
|
|
await settle(client)
|
|
store = await resolve(client, ObjectStorage)
|
|
assert isinstance(store, MemoryObjectStorage)
|
|
store.delay = 0.1
|
|
started = loop.time()
|
|
content = await client.get(
|
|
f"/api/v1/attachments/{uploaded.json()['id']}/content", headers=actor(alice)
|
|
)
|
|
assert (content.status_code, content.content) == (200, picture)
|
|
assert loop.time() - started > 1.0
|
|
|
|
|
|
async def test_body_slower_than_the_minimal_rate_is_cut() -> None:
|
|
async with running_app(request_timeout_seconds=0.3, min_transfer_rate_bytes=1 << 20) as client:
|
|
alice, chat = await prepared(client)
|
|
before = await scalar("SELECT count(*) FROM attachments")
|
|
loop = asyncio.get_running_loop()
|
|
started = loop.time()
|
|
response = await upload(client, alice, chat, trickled(SAMPLE, 4_096, 0.1))
|
|
assert (response.status_code, response.json()["error"]["code"]) == (503, "unavailable")
|
|
assert loop.time() - started < 1.0
|
|
assert await scalar("SELECT count(*) FROM attachments") == before
|