forked from mtusi2026/mtusi2026lab5
250 lines
9.1 KiB
Python
250 lines
9.1 KiB
Python
"""Idempotency-Key отправки сообщения: повтор, конфликт, область ключа, гонки"""
|
|
|
|
import asyncio
|
|
import json
|
|
import uuid
|
|
from collections import Counter
|
|
|
|
import httpx
|
|
import pytest
|
|
from helpers import assert_error, auth, message_headers, psql, read_all_messages
|
|
|
|
PARALLEL_REPLAYS = 20
|
|
|
|
|
|
def post_message(
|
|
api: httpx.Client, user: dict, chat: dict, text: str, key: str
|
|
) -> httpx.Response:
|
|
return api.post(
|
|
f"/api/v1/chats/{chat['id']}/messages",
|
|
json={"text": text},
|
|
headers=message_headers(user, key),
|
|
)
|
|
|
|
|
|
def history(api: httpx.Client, user: dict, chat: dict) -> list[dict]:
|
|
items, _ = read_all_messages(api, user, chat["id"], 100)
|
|
return items
|
|
|
|
|
|
def test_replay_returns_same_message(api: httpx.Client, make_user, make_chat) -> None:
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
key = uuid.uuid4().hex
|
|
|
|
first = post_message(api, alice, chat, "один раз", key)
|
|
second = post_message(api, alice, chat, "один раз", key)
|
|
|
|
assert first.status_code == second.status_code == 201, second.text
|
|
assert first.json() == second.json()
|
|
assert history(api, alice, chat) == [first.json()]
|
|
|
|
|
|
def test_replay_ignores_json_formatting(
|
|
api: httpx.Client, make_user, make_chat
|
|
) -> None:
|
|
"""Пробелы и форма записи JSON не меняют смысл тела: это тот же запрос"""
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
headers = {**message_headers(alice), "Content-Type": "application/json"}
|
|
path = f"/api/v1/chats/{chat['id']}/messages"
|
|
|
|
escaped = b'{"text":"\\u041f\\u0440\\u0438"}'
|
|
compact = api.post(path, content=escaped, headers=headers)
|
|
spaced = api.post(path, content='{ "text" : "При" }'.encode(), headers=headers)
|
|
|
|
assert compact.status_code == spaced.status_code == 201, spaced.text
|
|
assert compact.json() == spaced.json()
|
|
assert len(history(api, alice, chat)) == 1
|
|
|
|
|
|
def test_same_key_with_other_body_is_conflict(
|
|
api: httpx.Client, make_user, make_chat
|
|
) -> None:
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
key = uuid.uuid4().hex
|
|
original = post_message(api, alice, chat, "оригинал", key).json()
|
|
|
|
assert_error(post_message(api, alice, chat, "другой", key), 409, "conflict")
|
|
assert history(api, alice, chat) == [original]
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"headers",
|
|
[
|
|
{},
|
|
{"Idempotency-Key": ""},
|
|
{"Idempotency-Key": "with space"},
|
|
{"Idempotency-Key": "ключ".encode()},
|
|
{"Idempotency-Key": "a/b"},
|
|
{"Idempotency-Key": "x" * 129},
|
|
],
|
|
)
|
|
def test_missing_or_invalid_key_is_rejected(
|
|
api: httpx.Client, make_user, make_chat, headers: dict
|
|
) -> None:
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
response = api.post(
|
|
f"/api/v1/chats/{chat['id']}/messages",
|
|
json={"text": "без ключа"},
|
|
headers={**auth(alice), **headers},
|
|
)
|
|
assert_error(response, 400, "invalid_request")
|
|
assert history(api, alice, chat) == []
|
|
|
|
|
|
@pytest.mark.parametrize("key", ["x" * 128, "Az09._:-"])
|
|
def test_key_boundaries_are_accepted(
|
|
api: httpx.Client, make_user, make_chat, key: str
|
|
) -> None:
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
assert post_message(api, alice, chat, "граница", key).status_code == 201
|
|
|
|
|
|
def test_key_scope_is_user_and_chat(api: httpx.Client, make_user, make_chat) -> None:
|
|
"""Один ключ у разных пользователей и в разных чатах — независимые сообщения"""
|
|
alice = make_user("alice")
|
|
bob = make_user("bob")
|
|
chat = make_chat(alice, [alice, bob])
|
|
other_chat = make_chat(alice, [alice])
|
|
key = uuid.uuid4().hex
|
|
|
|
from_alice = post_message(api, alice, chat, "текст", key).json()
|
|
from_bob = post_message(api, bob, chat, "текст", key).json()
|
|
in_other_chat = post_message(api, alice, other_chat, "текст", key).json()
|
|
|
|
assert len({from_alice["id"], from_bob["id"], in_other_chat["id"]}) == 3
|
|
assert from_bob["sender_id"] == bob["id"]
|
|
assert len(history(api, alice, chat)) == 2
|
|
assert len(history(api, alice, other_chat)) == 1
|
|
|
|
|
|
def test_replay_rechecks_session_and_access(
|
|
api: httpx.Client, make_user, make_chat
|
|
) -> None:
|
|
alice = make_user("alice")
|
|
eve = make_user("eve")
|
|
chat = make_chat(alice, [alice])
|
|
key = uuid.uuid4().hex
|
|
post_message(api, alice, chat, "секрет", key)
|
|
|
|
# Чужой с тем же ключом не получает сохранённое сообщение
|
|
assert_error(post_message(api, eve, chat, "секрет", key), 404, "not_found")
|
|
# Отозванная сессия не даёт повтора
|
|
logout = api.delete("/api/v1/auth/sessions/current", headers=auth(alice))
|
|
assert logout.status_code == 204
|
|
replay = post_message(api, alice, chat, "секрет", key)
|
|
assert_error(replay, 401, "unauthorized")
|
|
|
|
|
|
def test_expired_key_can_be_reused(api: httpx.Client, make_user, make_chat) -> None:
|
|
"""После срока хранения (24 ч) ключ снова создаёт сообщение; срок сдвигается в БД"""
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
key = uuid.uuid4().hex
|
|
first = post_message(api, alice, chat, "вчера", key).json()
|
|
psql(
|
|
"UPDATE message_idempotency_keys "
|
|
"SET created_at = now() - interval '2 days', "
|
|
"expires_at = now() - interval '1 day' "
|
|
f"WHERE chat_id = '{chat['id']}' AND idempotency_key = '{key}';"
|
|
)
|
|
|
|
second = post_message(api, alice, chat, "сегодня", key)
|
|
|
|
assert second.status_code == 201, second.text
|
|
assert second.json()["id"] != first["id"]
|
|
assert [item["text"] for item in history(api, alice, chat)] == ["вчера", "сегодня"]
|
|
stored = psql(
|
|
"SELECT count(*) FROM message_idempotency_keys "
|
|
f"WHERE chat_id = '{chat['id']}' AND idempotency_key = '{key}';"
|
|
)
|
|
assert stored == "1"
|
|
|
|
|
|
async def _post_concurrently(
|
|
base_url: str, user: dict, chat: dict, key: str, texts: list[str]
|
|
) -> list[httpx.Response]:
|
|
"""Все запросы стартуют по одному сигналу; отдельные соединения к LB"""
|
|
start = asyncio.Event()
|
|
limits = httpx.Limits(max_connections=len(texts))
|
|
|
|
async with httpx.AsyncClient(
|
|
base_url=base_url, timeout=30, limits=limits
|
|
) as client:
|
|
|
|
async def post(text: str) -> httpx.Response:
|
|
await start.wait()
|
|
return await client.post(
|
|
f"/api/v1/chats/{chat['id']}/messages",
|
|
json={"text": text},
|
|
headers=message_headers(user, key),
|
|
)
|
|
|
|
tasks = [asyncio.create_task(post(text)) for text in texts]
|
|
await asyncio.sleep(0)
|
|
start.set()
|
|
return list(await asyncio.gather(*tasks))
|
|
|
|
|
|
def test_parallel_replays_through_replicas_create_one_message(
|
|
api: httpx.Client, base_url: str, make_user, make_chat
|
|
) -> None:
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
key = uuid.uuid4().hex
|
|
|
|
responses = asyncio.run(
|
|
_post_concurrently(
|
|
base_url, alice, chat, key, ["одно сообщение"] * PARALLEL_REPLAYS
|
|
)
|
|
)
|
|
|
|
statuses = Counter(response.status_code for response in responses)
|
|
instances = Counter(response.headers["X-Instance-Id"] for response in responses)
|
|
bodies = {json.dumps(response.json(), sort_keys=True) for response in responses}
|
|
items = history(api, alice, chat)
|
|
rows = psql(f"SELECT count(*) FROM messages WHERE chat_id = '{chat['id']}';")
|
|
print(
|
|
"\nPARALLEL SAME KEY:",
|
|
json.dumps(
|
|
{
|
|
"requests": len(responses),
|
|
"statuses": dict(statuses),
|
|
"instances": dict(instances),
|
|
"distinct_bodies": len(bodies),
|
|
"messages_in_history": len(items),
|
|
"rows_in_db": int(rows),
|
|
}
|
|
),
|
|
)
|
|
assert statuses == {201: PARALLEL_REPLAYS}
|
|
assert len(instances) >= 2, "запросы не распределились по репликам"
|
|
assert len(bodies) == 1
|
|
assert len(items) == 1 and rows == "1"
|
|
|
|
|
|
def test_parallel_same_key_with_different_bodies(
|
|
api: httpx.Client, base_url: str, make_user, make_chat
|
|
) -> None:
|
|
"""Победитель гонки один; совпавшие с ним тела — 201, остальные — 409"""
|
|
alice = make_user("alice")
|
|
chat = make_chat(alice, [alice])
|
|
key = uuid.uuid4().hex
|
|
texts = ["вариант A", "вариант B"] * (PARALLEL_REPLAYS // 2)
|
|
|
|
responses = asyncio.run(_post_concurrently(base_url, alice, chat, key, texts))
|
|
|
|
items = history(api, alice, chat)
|
|
assert len(items) == 1
|
|
winner = items[0]
|
|
for text, response in zip(texts, responses):
|
|
if text == winner["text"]:
|
|
assert response.status_code == 201, response.text
|
|
assert response.json() == winner
|
|
else:
|
|
assert_error(response, 409, "conflict")
|