Files
mtusi2026lab5-fork/student-tests/test_idempotency.py
T

191 lines
7.4 KiB
Python

"""Повторы сообщений через приложения с общими хранилищами."""
import asyncio
from contextlib import AsyncExitStack
import pytest
from sqlalchemy import text
from app.errors.exceptions import unavailable
from app.main import create_app
from app.storage import idempotency as key_storage
from conftest import close_app, make_client
from helpers import bearer, create_chat, create_user, idempotency_header, send_message
@pytest.fixture
async def replicas(request, make_settings):
overrides = getattr(request, "param", {})
apps = [
create_app(make_settings(instance_id=name, **overrides))
for name in ("api-a", "api-b")
]
try:
async with AsyncExitStack() as stack:
clients = [
await stack.enter_async_context(make_client(app)) for app in apps
]
yield clients
finally:
for app in apps:
await close_app(app)
@pytest.mark.parametrize("key", [None, "", "a b", "a/b", "x" * 129])
async def test_invalid_key_returns_400(client, key):
user = await create_user(client)
chat = await create_chat(client, user)
headers = bearer(user)
if key is not None:
headers["Idempotency-Key"] = key
response = await client.post(
f"/api/v1/chats/{chat['id']}/messages", headers=headers, json={"text": "hello"}
)
assert response.status_code == 400
assert response.json()["error"]["code"] == "invalid_request"
@pytest.mark.parametrize("key", ["a", "x" * 128, "key_1.2:3-4"])
async def test_valid_key_boundaries(client, key):
user = await create_user(client)
chat = await create_chat(client, user)
assert (await send_message(client, user, chat, "hello", key)).status_code == 201
async def test_replay_and_conflict_across_replicas(replicas, db_engine):
first, second = replicas
user = await create_user(first)
chat = await create_chat(first, user)
original = await send_message(first, user, chat, "Привет", "same-key")
repeated = await second.post(
f"/api/v1/chats/{chat['id']}/messages",
headers={
**bearer(user),
**idempotency_header("same-key"),
"Content-Type": "application/json",
},
content='{ "text" : "\\u041f\\u0440\\u0438\\u0432\\u0435\\u0442" }',
)
conflict = await send_message(second, user, chat, "другой текст", "same-key")
assert original.status_code == repeated.status_code == 201
assert original.json() == repeated.json()
assert original.headers["X-Instance-Id"] != repeated.headers["X-Instance-Id"]
assert conflict.status_code == 409
async with db_engine.connect() as connection:
assert (
await connection.execute(text("SELECT count(*) FROM messages"))
).scalar_one() == 1
assert (
await connection.execute(
text("SELECT value FROM counters WHERE name='messages'")
)
).scalar_one() == 1
async def test_parallel_replays_create_one_message(replicas, db_engine):
user = await create_user(replicas[0])
chat = await create_chat(replicas[0], user)
responses = await asyncio.gather(
*(
send_message(replicas[index % 2], user, chat, "parallel", "one-key")
for index in range(24)
)
)
assert all(response.status_code == 201 for response in responses)
assert len({response.json()["id"] for response in responses}) == 1
assert {response.headers["X-Instance-Id"] for response in responses} == {
"api-a",
"api-b",
}
async with db_engine.connect() as connection:
assert (
await connection.execute(text("SELECT count(*) FROM messages"))
).scalar_one() == 1
assert (
await connection.execute(text("SELECT count(*) FROM idempotency_keys"))
).scalar_one() == 1
async def test_key_scope_separates_users_and_chats(client):
alice = await create_user(client)
bob = await create_user(client)
shared = await create_chat(client, alice, bob)
other = await create_chat(client, alice)
responses = [
await send_message(client, alice, shared, "a", "shared-key"),
await send_message(client, bob, shared, "b", "shared-key"),
await send_message(client, alice, other, "c", "shared-key"),
]
assert all(response.status_code == 201 for response in responses)
assert len({response.json()["id"] for response in responses}) == 3
async def test_expired_key_can_be_reused_without_removing_message(client, db_engine):
user = await create_user(client)
chat = await create_chat(client, user)
first = await send_message(client, user, chat, "old", "expiring-key")
async with db_engine.begin() as connection:
await connection.execute(
text(
"UPDATE idempotency_keys SET created_at = clock_timestamp() - interval '25 hours'"
)
)
second = await send_message(client, user, chat, "new", "expiring-key")
assert first.status_code == second.status_code == 201
assert first.json()["id"] != second.json()["id"]
history = await client.get(
f"/api/v1/chats/{chat['id']}/messages", headers=bearer(user)
)
assert [item["text"] for item in history.json()["items"]] == ["old", "new"]
async def test_failed_transaction_does_not_poison_key(client, db_engine, monkeypatch):
user = await create_user(client)
chat = await create_chat(client, user)
original = key_storage.save_result
async def fail_after_insert(*args):
await original(*args)
raise unavailable()
monkeypatch.setattr(key_storage, "save_result", fail_after_insert)
failed = await send_message(client, user, chat, "retry", "retry-key")
assert failed.status_code == 503
async with db_engine.connect() as connection:
for table in ("messages", "idempotency_keys", "counters"):
assert (
await connection.execute(text(f"SELECT count(*) FROM {table}"))
).scalar_one() == 0
monkeypatch.setattr(key_storage, "save_result", original)
recovered = await send_message(client, user, chat, "retry", "retry-key")
assert recovered.status_code == 201
@pytest.mark.parametrize("replicas", [{"max_messages": 1}], indirect=True)
async def test_replay_works_when_message_limit_is_full(replicas):
user = await create_user(replicas[0])
chat = await create_chat(replicas[0], user)
first = await send_message(replicas[0], user, chat, "last", "last-key")
replay = await send_message(replicas[1], user, chat, "last", "last-key")
rejected = await send_message(replicas[1], user, chat, "extra", "other-key")
assert first.status_code == replay.status_code == 201
assert first.json() == replay.json()
assert rejected.status_code == 503
async def test_replay_checks_session_and_membership(client, db_engine):
user = await create_user(client)
chat = await create_chat(client, user)
assert (
await send_message(client, user, chat, "private", "private-key")
).status_code == 201
async with db_engine.begin() as connection:
await connection.execute(text("DELETE FROM chat_members"))
assert (
await send_message(client, user, chat, "private", "private-key")
).status_code == 404
await client.delete("/api/v1/auth/sessions/current", headers=bearer(user))
assert (
await send_message(client, user, chat, "private", "private-key")
).status_code == 401