Files
Artyom 12db77133f Forward the lab 5 foundation while preserving lab 6 telemetry
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.
2026-11-06 12:29:35 +03:00

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