Files
mtusi2026lab3/student-tests/test_idempotency.py
T

252 lines
10 KiB
Python

"""Idempotency-Key отправки сообщения (лаба 3, contracts/README.md).
Повтор того же тела с тем же ключом — тот же 201 и то же `Message`, в
истории одно сообщение; другое тело — 409; область ключа — автор, чат и
ключ; повтор заново проверяет сессию и доступ; порядок кодов 401 → 400 →
404 → 409. Гонка одного ключа — `test_race.py`; сбой записи, отказ БД и
срок ключа — проверки отказов (`test_failures.py`). Повтору через другую
реплику нужны ≥ 2 реплики за `BASE_URL` (фикстура `replicas`).
"""
from typing import Any
import httpx
import pytest
from helpers import (
BEARER_CHALLENGE,
CHATS,
IDEMPOTENCY_KEY,
assert_error,
assert_replicas,
assert_unauthorized,
create_chat,
headers,
instance_id,
login,
logout,
messages_path,
new_key,
read_history,
register,
send,
)
# 128 символов, в том числе все допустимые знаки, кроме букв и цифр
LONGEST_KEY = "a1.B_:-Z" * 16
def texts(client: httpx.Client, actor: dict[str, Any], chat: dict[str, Any]) -> list:
items, _ = read_history(client, actor, chat, limit=100)
return [item["text"] for item in items]
@pytest.fixture
def pair(client: httpx.Client) -> tuple[dict[str, Any], dict[str, Any], dict]:
"""Алиса, Боб и их общий чат."""
alice, bob = register(client, "alice"), register(client, "bob")
return alice, bob, create_chat(client, alice, bob)
def test_missing_key_is_400(client: httpx.Client, pair: tuple) -> None:
alice, _, chat = pair
assert_error(
send(client, alice, chat, "без ключа", key=None), 400, "invalid_request"
)
assert texts(client, alice, chat) == []
@pytest.mark.parametrize(
"key",
[b"", b"a" * 129, b"a b", b"a/b", "ключ".encode()],
ids=["empty", "too-long", "space", "slash", "non-ascii"],
)
def test_invalid_key_is_400(client: httpx.Client, pair: tuple, key: bytes) -> None:
alice, _, chat = pair
response = send(client, alice, chat, "x", key=key)
assert_error(response, 400, "invalid_request")
# значение ключа в ответ не попадает
if len(key) > 1:
assert key.decode(errors="replace") not in response.text
assert texts(client, alice, chat) == []
def test_longest_key_is_accepted(client: httpx.Client, pair: tuple) -> None:
alice, _, chat = pair
assert len(LONGEST_KEY) == 128
response = send(client, alice, chat, "длинный ключ", key=LONGEST_KEY)
assert response.status_code == 201, response.text
assert texts(client, alice, chat) == ["длинный ключ"]
def test_replay_returns_same_message(client: httpx.Client, pair: tuple) -> None:
alice, bob, chat = pair
key = new_key()
first = send(client, alice, chat, "Привет, мир 👋", key=key)
again = send(client, alice, chat, "Привет, мир 👋", key=key)
assert first.status_code == again.status_code == 201
# тот же id, created_at до микросекунды, тот же текст
assert again.json() == first.json()
assert texts(client, bob, chat) == ["Привет, мир 👋"]
def test_same_json_in_other_spelling_is_replay(
client: httpx.Client,
pair: tuple,
) -> None:
"""Пробелы и \\u-экранирование вместо UTF-8 — тот же JSON."""
alice, _, chat = pair
key = new_key()
first = send(client, alice, chat, "Привет", key=key).json()
raw = b'{ "text" :\n "\\u041f\\u0440\\u0438\\u0432\\u0435\\u0442" }'
response = client.post(
messages_path(chat),
content=raw,
headers={
**headers(alice),
IDEMPOTENCY_KEY: key,
"Content-Type": "application/json",
},
)
assert response.status_code == 201, response.text
assert response.json() == first
assert texts(client, alice, chat) == ["Привет"]
def test_other_body_is_409(client: httpx.Client, pair: tuple) -> None:
alice, _, chat = pair
key = new_key()
first = send(client, alice, chat, "первое", key=key).json()
assert_error(send(client, alice, chat, "второе", key=key), 409, "conflict")
assert texts(client, alice, chat) == ["первое"]
# 409 ключ не портит: прежнее тело по-прежнему повторяется
assert send(client, alice, chat, "первое", key=key).json() == first
def test_same_key_other_user_is_new_message(client: httpx.Client, pair: tuple) -> None:
alice, bob, chat = pair
key = new_key()
from_alice = send(client, alice, chat, "от Алисы", key=key).json()
from_bob = send(client, bob, chat, "от Боба", key=key).json()
assert from_alice["id"] != from_bob["id"]
assert sorted(texts(client, alice, chat)) == ["от Алисы", "от Боба"]
def test_same_key_other_chat_is_new_message(client: httpx.Client, pair: tuple) -> None:
alice, bob, chat = pair
other = create_chat(client, alice, bob, title="Второй чат")
key = new_key()
first = send(client, alice, chat, "одно и то же", key=key).json()
second = send(client, alice, other, "одно и то же", key=key).json()
assert first["id"] != second["id"]
assert second["chat_id"] == other["id"]
for target in (chat, other):
assert texts(client, alice, target) == ["одно и то же"]
def test_key_on_other_post_is_ignored(client: httpx.Client, pair: tuple) -> None:
"""Ключ обязателен только для сообщений: создание чата он не защищает."""
alice, bob, _ = pair
key = new_key()
created = []
for _ in range(2):
response = client.post(
CHATS,
json={"title": "Тот же ключ", "member_ids": [alice["id"], bob["id"]]},
headers={**headers(alice), IDEMPOTENCY_KEY: key},
)
assert response.status_code == 201, response.text
created.append(response.json()["id"])
assert created[0] != created[1]
def test_replay_with_revoked_token_is_401(client: httpx.Client, pair: tuple) -> None:
alice, _, chat = pair
key = new_key()
assert send(client, alice, chat, "до выхода", key=key).status_code == 201
assert logout(client, alice).status_code == 204
assert_unauthorized(
send(client, alice, chat, "до выхода", key=key), BEARER_CHALLENGE
)
def test_replay_with_new_session_of_same_user(
client: httpx.Client, pair: tuple
) -> None:
alice, _, chat = pair
key = new_key()
first = send(client, alice, chat, "одна сессия", key=key).json()
again = {**alice, "token": login(client, alice)}
assert again["token"] != alice["token"]
assert send(client, again, chat, "одна сессия", key=key).json() == first
def test_outsider_with_members_key_is_404(client: httpx.Client, pair: tuple) -> None:
alice, _, chat = pair
eve = register(client, "eve")
key = new_key()
first = send(client, alice, chat, "только участникам", key=key).json()
assert_error(
send(client, eve, chat, "только участникам", key=key), 404, "not_found"
)
assert send(client, alice, chat, "только участникам", key=key).json() == first
assert texts(client, alice, chat) == ["только участникам"]
def test_codes_order_401_400_404_409(client: httpx.Client, pair: tuple) -> None:
"""Сначала сессия, затем ключ и тело, затем доступ, затем ключ занят."""
alice, _, chat = pair
eve = register(client, "eve")
no_session = client.post(messages_path(chat), json={"text": "x"})
assert_unauthorized(no_session, BEARER_CHALLENGE)
# посторонний без ключа: 400 раньше 404
assert_error(send(client, eve, chat, "x", key=None), 400, "invalid_request")
# невалидное тело с занятым ключом: 400 раньше 409
key = new_key()
assert send(client, alice, chat, "первое", key=key).status_code == 201
assert_error(send(client, alice, chat, "", key=key), 400, "invalid_request")
# посторонний с чужим занятым ключом и другим телом: 404 раньше 409
assert_error(send(client, eve, chat, "другое", key=key), 404, "not_found")
assert_error(send(client, alice, chat, "другое", key=key), 409, "conflict")
def test_invalid_request_keeps_key_free(client: httpx.Client, pair: tuple) -> None:
alice, _, chat = pair
key = new_key()
assert_error(send(client, alice, chat, "", key=key), 400, "invalid_request")
response = send(client, alice, chat, "теперь валидно", key=key)
assert response.status_code == 201, response.text
assert texts(client, alice, chat) == ["теперь валидно"]
def test_replay_through_other_replica(
client: httpx.Client,
pair: tuple,
replicas: int,
) -> None:
"""Повтор, который обслужила другая реплика, — тот же `Message`; 409 —
от разных реплик: ключ живёт в PostgreSQL, а не в памяти процесса."""
alice, _, chat = pair
key = new_key()
response = send(client, alice, chat, "повтор через реплики", key=key)
first = response.json()
origin = instance_id(response)
replays: dict[str, Any] = {}
for _ in range(2 * replicas):
response = send(client, alice, chat, "повтор через реплики", key=key)
assert response.status_code == 201, response.text
replays[instance_id(response)] = response.json()
print(f"sent via {origin}, replayed via {sorted(replays)}")
assert_replicas({origin, *replays}, replicas)
assert all(message == first for message in replays.values())
conflicts = set()
for _ in range(2 * replicas):
response = send(client, alice, chat, "другое тело", key=key)
assert_error(response, 409, "conflict")
conflicts.add(instance_id(response))
print(f"409 via {sorted(conflicts)}")
assert_replicas(conflicts, replicas)
assert texts(client, alice, chat) == ["повтор через реплики"]