Files
mtusi2026labs/student-tests/api/test_timeout.py
T

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