Files
mtusi2026lab2/student-tests/api/test_concurrency.py
T
ArtyomandClaude Opus 5.5 22f0e6244d Post a message with one statement under the chat lock
Sending a message used to be BEGIN, a SELECT ... FOR UPDATE of the
chat with its members, a lookup of the idempotency key, the insert CTE
and COMMIT. Three of those round trips ran under the chat row lock, and
each one waited for the replica's event loop, so under load the lock
holders sat idle in transaction while everyone else queued behind
them.

The new MessageLog port has one PostgreSQL adapter that does it all in
a single statement with an implicit transaction: lock the chat row
joined with the sender's membership, stamp the message with the later
of the replica clock and the last message plus one microsecond, claim
the key (overwriting it only if it has expired), insert the message
only when the key was claimed, and move last_message_at. The foreign
key from the key to the message is checked at the end of the statement,
so the key may be written first. When the key is already taken the
adapter reads the stored result with a second statement outside the
lock, which also covers a concurrent duplicate that waited for the
first one; the handler then replays it or answers 409 as before.

The chat aggregate no longer takes part in posting, so its post,
membership and last_message_at members and their unit tests are gone;
Message.posted() builds the event. An invalid text is still answered
404 for an outsider: only then the handler reads the membership. A new
API test pins the clock rule against a real database: a lagging
replica clock gets the last stamp plus one microsecond, a clock ahead
is kept. The concurrency, same-key race, expiry and access tests pass
unchanged.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
2026-10-29 01:06:49 +03:00

108 lines
4.2 KiB
Python

import asyncio
from datetime import UTC, datetime, timedelta
from urllib.parse import quote
from uuid import uuid4
import pytest
from httpx import AsyncClient
from conftest import PASSWORD, actor, keyed, make_chat, register
from messenger.shared.infrastructure.clock import MonotonicUtcClock
CLIENTS = 10
PER_CLIENT = 10
TOTAL = CLIENTS * PER_CLIENT
async def drain(client: AsyncClient, chat: dict, reader: dict) -> list[dict]:
collected: list[dict] = []
cursor: str | None = None
while True:
query = "?limit=100" + (f"&cursor={quote(cursor, safe='')}" if cursor else "")
page = (
await client.get(f"/api/v1/chats/{chat['id']}/messages{query}", headers=actor(reader))
).json()
collected.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
return collected
async def flood(client: AsyncClient, chat: dict, sender: dict) -> list[int]:
async def writer(worker: int) -> list[int]:
codes = []
for index in range(PER_CLIENT):
response = await client.post(
f"/api/v1/chats/{chat['id']}/messages",
json={"text": f"нагрузка-{worker}-{index}"},
headers=keyed(sender),
)
codes.append(response.status_code)
return codes
batches = await asyncio.gather(*(writer(worker) for worker in range(CLIENTS)))
return [code for batch in batches for code in batch]
async def test_hundred_messages_from_ten_clients(client: AsyncClient) -> None:
alice = await register(client, "alice")
bob = await register(client, "bob")
chat = await make_chat(client, alice, bob)
codes = await flood(client, chat, alice)
assert codes.count(201) == TOTAL, f"неуспешные ответы: {set(codes) - {201}}"
history = await drain(client, chat, bob)
assert len(history) == TOTAL
assert len({item["id"] for item in history}) == TOTAL
assert len({item["text"] for item in history}) == TOTAL
keys = [(item["created_at"], item["id"]) for item in history]
assert keys == sorted(keys), "история не упорядочена по (created_at, id)"
stamps = [item["created_at"] for item in history]
assert len(set(stamps)) == TOTAL, "created_at внутри чата обязан строго возрастать"
async def test_history_follows_the_clock_but_never_moves_back(
monkeypatch: pytest.MonkeyPatch, client: AsyncClient
) -> None:
alice = await register(client, "alice")
chat = await make_chat(client, alice)
base = datetime.now(UTC) + timedelta(minutes=10)
stamps = []
for moment in (base, base - timedelta(minutes=5), base + timedelta(seconds=5)):
monkeypatch.setattr(MonotonicUtcClock, "now", lambda _self, moment=moment: moment)
response = await client.post(
f"/api/v1/chats/{chat['id']}/messages", json={"text": "часы"}, headers=keyed(alice)
)
stamps.append(datetime.fromisoformat(response.json()["created_at"]))
assert stamps == [base, base + timedelta(microseconds=1), base + timedelta(seconds=5)]
async def test_parallel_registration_keeps_username_unique(client: AsyncClient) -> None:
body = {"username": f"race_{uuid4().hex[:12]}", "display_name": "Гонка", "password": PASSWORD}
responses = await asyncio.gather(*(client.post("/api/v1/users", json=body) for _ in range(20)))
codes = [response.status_code for response in responses]
assert codes.count(201) == 1
assert codes.count(409) == len(codes) - 1
async def test_parallel_chat_creation_is_atomic(client: AsyncClient) -> None:
alice = await register(client, "alice")
bob = await register(client, "bob")
responses = await asyncio.gather(
*(
client.post(
"/api/v1/chats",
json={"title": f"Чат {index}", "member_ids": [alice["id"], bob["id"]]},
headers=actor(alice),
)
for index in range(20)
)
)
assert all(response.status_code == 201 for response in responses)
listed = (await client.get("/api/v1/chats?limit=100", headers=actor(bob))).json()
assert len(listed["items"]) == 20
keys = [(item["created_at"], item["id"]) for item in listed["items"]]
assert keys == sorted(keys)