forked from mtusi2026/mtusi2026lab5
191 lines
7.4 KiB
Python
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
|