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 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 == 201, uploaded.text assert loop.time() - started > 1.0 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