forked from mtusi2026/mtusi2026lab3
POST /api/v1/chats/{chat_id}/messages now requires the header, checked
at the HTTP boundary (1-128 of [A-Za-z0-9._:-], else 400). The handler
keeps the lab 2 order under the chat row lock: membership, then text,
then the receipt for (chat, sender, key) younger than
IDEMPOTENCY_TTL_SECONDS. A receipt with the same fingerprint replays
the stored message, a different one is 409 conflict; without a
receipt one statement inserts the message, the key row and the chat
mark, so both commit or neither does. Concurrent retries wait on the
same row lock and then read the committed receipt. The fingerprint is
SHA-256 of the canonical JSON of the parsed body, so layout does not
matter, and only 201 answers are ever stored.
A lock timeout now counts as a dependency failure and answers 503
instead of 500, so a retry with the same key is safe.
Own tests cover replay, a different layout of the same JSON, conflict,
missing and malformed keys, rejected attempts that leave the key free,
scope by user and chat, revalidation after logout and for outsiders,
expiry, and eight concurrent retries through two app instances
sharing one PostgreSQL. Every earlier message post sends a fresh key.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
89 lines
3.4 KiB
Python
89 lines
3.4 KiB
Python
import asyncio
|
|
from urllib.parse import quote
|
|
from uuid import uuid4
|
|
|
|
from httpx import AsyncClient
|
|
|
|
from conftest import PASSWORD, actor, keyed, make_chat, register
|
|
|
|
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_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)
|