forked from mtusi2026/mtusi2026lab3
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
108 lines
4.2 KiB
Python
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)
|