Files
mtusi2026lab4/student-tests/test_idempotency.py
T
ricoromaandClaude Opus 5.5 116d8d3bf0 feat: add image attachments to messages
- upload, metadata and download endpoints for PNG/JPEG attachments:
  limits before reading and decompression, type by content,
  structural integrity check without decoding pixels, safe filename
- write order: pending row with object key -> PUT to S3 -> ready;
  per-step DB sessions so no pool connection is held during transfers
- attachment_ids in messages (validation, idempotency hash, history);
  whitespace-only text allowed with an attachment (teacher, 2026-10-20)
- migration: attachments and message_attachments tables, text length
  CHECK relaxed with NOT VALID
- student tests, fault checks and driver commands for attachments;
  rollout profile starts from e1161f7 and checks the commit first
- sync attachments deltas into main specs; rules, AGENTS.md, PLAN.md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 01:08:56 +03:00

406 lines
13 KiB
Python

"""Спек `idempotency`: повторная отправка сообщения с `Idempotency-Key`.
Сценарии, которым нужен особый стенд (сбой записи, остановка БД, короткий
срок ключа), — в `test_failures.py`; гонка одного ключа — в
`test_race.py`; повтор после рестарта API — исключение с evidence.
Повтору через другую реплику нужны ≥ 2 реплики за `BASE_URL` (фикстура
`replicas`), против одного процесса он пропускается.
"""
from typing import Any
import pytest
import images
from api_client import (
API,
IDEMPOTENCY_KEY,
Actor,
Api,
key_headers,
new_key,
)
from contract import (
BEARER_CHALLENGE,
assert_error,
assert_instance_id,
assert_ok,
assert_replicas,
assert_unauthorized,
)
# 128 символов, в том числе все допустимые знаки, кроме букв и цифр
LONGEST_KEY = "a1.B_:-Z" * 16
def texts(api: Api, actor: Actor, chat_id: str) -> list[str]:
return [item["text"] for item in api.all_messages(actor, chat_id)]
@pytest.mark.spec("idempotency", "Нет ключа")
def test_no_key(api: Api, alice: Actor, chat: dict[str, Any]) -> None:
resp = api.post_message(alice, chat["id"], key=None, json={"text": "x"})
assert_error(resp, 400)
assert texts(api, alice, chat["id"]) == []
@pytest.mark.spec("idempotency", "Неверный ключ")
def test_bad_key(api: Api, alice: Actor, chat: dict[str, Any]) -> None:
for key in ("", "a" * 129, "a b", "a/b", "ключ"):
# не-ASCII заголовок httpx шлёт только байтами
resp = api.post_message(
alice,
chat["id"],
key=None,
headers={IDEMPOTENCY_KEY: key.encode()},
json={"text": "x"},
)
assert_error(resp, 400)
if key:
assert key not in resp.text, f"key {key!r} echoed in response"
assert texts(api, alice, chat["id"]) == []
@pytest.mark.spec("idempotency", "Граница длины ключа")
def test_longest_key(api: Api, alice: Actor, chat: dict[str, Any]) -> None:
assert len(LONGEST_KEY) == 128
message = api.send_message(
alice,
chat["id"],
"длинный ключ",
key=LONGEST_KEY,
)
assert texts(api, alice, chat["id"]) == [message["text"]]
@pytest.mark.spec("idempotency", "Ключ у других запросов")
def test_key_on_other_requests(api: Api, alice: Actor, bob: Actor) -> None:
headers = key_headers()
created = [
assert_ok(
api.request(
"POST",
f"{API}/chats",
actor=alice,
headers=headers,
json={
"title": "Тот же ключ",
"member_ids": [alice.id, bob.id],
},
),
201,
"Chat",
)
for _ in range(2)
]
assert created[0]["id"] != created[1]["id"]
@pytest.mark.spec("idempotency", "Повтор того же тела")
def test_replay_same_body(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
first = api.send_message(alice, chat["id"], "Привет, мир 👋", key=key)
again = api.send_message(alice, chat["id"], "Привет, мир 👋", key=key)
assert again == first
assert texts(api, alice, chat["id"]) == ["Привет, мир 👋"]
@pytest.mark.spec("idempotency", "Тот же JSON в другой записи")
def test_replay_other_json_spelling(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
first = api.send_message(alice, chat["id"], "Привет", key=key)
# те же поле и текст: пробелы и \u-экранирование вместо UTF-8
raw = b'{ "text" :\n "\\u041f\\u0440\\u0438\\u0432\\u0435\\u0442" }'
resp = api.post_message(
alice,
chat["id"],
key=key,
headers={"Content-Type": "application/json"},
content=raw,
)
assert assert_ok(resp, 201, "Message") == first
assert texts(api, alice, chat["id"]) == ["Привет"]
@pytest.mark.spec("idempotency", "Другой текст")
def test_other_body_conflict(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
first = api.send_message(alice, chat["id"], "первое", key=key)
resp = api.post_message(
alice,
chat["id"],
key=key,
json={"text": "второе"},
)
assert_error(resp, 409)
assert texts(api, alice, chat["id"]) == ["первое"]
assert api.send_message(alice, chat["id"], "первое", key=key) == first
def two_attachments(api: Api, actor: Actor, chat_id: str) -> list[str]:
return [
api.upload(actor, chat_id, images.sample_png())["id"] for _ in range(2)
]
@pytest.mark.spec("idempotency", "Вложения по умолчанию")
def test_replay_with_default_attachments(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
first = api.send_message(alice, chat["id"], "без файлов", key=key)
again = api.send_message(
alice,
chat["id"],
"без файлов",
key=key,
attachment_ids=[],
)
assert again == first
assert texts(api, alice, chat["id"]) == ["без файлов"]
@pytest.mark.spec("idempotency", "Повтор сообщения с вложениями")
def test_replay_with_attachments(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
first_id, second_id = two_attachments(api, alice, chat["id"])
key = new_key()
ids = [first_id, second_id]
first = api.send_message(
alice,
chat["id"],
"файлы",
key=key,
attachment_ids=ids,
)
again = api.send_message(
alice,
chat["id"],
"файлы",
key=key,
attachment_ids=ids,
)
upper = api.send_message(
alice,
chat["id"],
"файлы",
key=key,
attachment_ids=[item.upper() for item in ids],
)
assert first == again == upper
assert first["attachment_ids"] == ids
history = api.all_messages(alice, chat["id"])
assert [item["id"] for item in history] == [first["id"]]
@pytest.mark.spec("idempotency", "Другие вложения")
def test_other_attachments_conflict(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
first_id, second_id = two_attachments(api, alice, chat["id"])
key = new_key()
first = api.send_message(
alice,
chat["id"],
"файлы",
key=key,
attachment_ids=[first_id, second_id],
)
for body in (
{"text": "файлы", "attachment_ids": [second_id, first_id]},
{"text": "файлы"},
):
assert_error(
api.post_message(alice, chat["id"], key=key, json=body),
409,
)
history = api.all_messages(alice, chat["id"])
assert history == [first]
assert history[0]["attachment_ids"] == [first_id, second_id]
@pytest.mark.spec("idempotency", "Другой пользователь")
def test_same_key_other_user(
api: Api,
alice: Actor,
bob: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
from_alice = api.send_message(alice, chat["id"], "от Алисы", key=key)
from_bob = api.send_message(bob, chat["id"], "от Боба", key=key)
assert from_alice["id"] != from_bob["id"]
assert sorted(texts(api, alice, chat["id"])) == ["от Алисы", "от Боба"]
@pytest.mark.spec("idempotency", "Другой чат")
def test_same_key_other_chat(
api: Api,
alice: Actor,
bob: Actor,
chat: dict[str, Any],
) -> None:
other = api.create_chat(alice, bob, title="Второй чат")
key = new_key()
first = api.send_message(alice, chat["id"], "одно и то же", key=key)
second = api.send_message(alice, other["id"], "одно и то же", key=key)
assert first["id"] != second["id"]
assert second["chat_id"] == other["id"]
for chat_id in (chat["id"], other["id"]):
assert texts(api, alice, chat_id) == ["одно и то же"]
@pytest.mark.spec("idempotency", "Отозванный токен")
def test_replay_with_revoked_token(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
api.send_message(alice, chat["id"], "до выхода", key=key)
assert api.logout(alice).status_code == 204
resp = api.post_message(
alice,
chat["id"],
key=key,
json={"text": "до выхода"},
)
assert_unauthorized(resp, BEARER_CHALLENGE)
@pytest.mark.spec("idempotency", "Новая сессия того же пользователя")
def test_replay_with_new_session(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
first = api.send_message(alice, chat["id"], "одна сессия", key=key)
again = api.login(alice.user, alice.password)
assert again.token != alice.token
assert api.send_message(again, chat["id"], "одна сессия", key=key) == first
@pytest.mark.spec("idempotency", "Посторонний с чужим ключом")
def test_outsider_with_members_key(
api: Api,
alice: Actor,
eve: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
first = api.send_message(alice, chat["id"], "только участникам", key=key)
resp = api.post_message(
eve,
chat["id"],
key=key,
json={"text": "только участникам"},
)
assert_error(resp, 404)
assert (
api.send_message(
alice,
chat["id"],
"только участникам",
key=key,
)
== first
)
assert texts(api, alice, chat["id"]) == ["только участникам"]
@pytest.mark.spec("idempotency", "Без сессии и без ключа")
def test_no_session_and_no_key(api: Api, chat: dict[str, Any]) -> None:
resp = api.post_message(None, chat["id"], key=None, json={"text": "x"})
assert_unauthorized(resp, BEARER_CHALLENGE)
@pytest.mark.spec("idempotency", "Посторонний без ключа")
def test_outsider_without_key(
api: Api,
eve: Actor,
chat: dict[str, Any],
) -> None:
resp = api.post_message(eve, chat["id"], key=None, json={"text": "x"})
assert_error(resp, 400)
@pytest.mark.spec("idempotency", "Невалидное тело с занятым ключом")
def test_invalid_body_with_used_key(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
api.send_message(alice, chat["id"], "первое", key=key)
resp = api.post_message(alice, chat["id"], key=key, json={"text": ""})
assert_error(resp, 400)
@pytest.mark.spec("idempotency", "Невалидный запрос не занимает ключ")
def test_invalid_request_keeps_key_free(
api: Api,
alice: Actor,
chat: dict[str, Any],
) -> None:
key = new_key()
resp = api.post_message(alice, chat["id"], key=key, json={"text": ""})
assert_error(resp, 400)
message = api.send_message(alice, chat["id"], "теперь валидно", key=key)
assert texts(api, alice, chat["id"]) == [message["text"]]
@pytest.mark.spec("idempotency", "Повтор через другую реплику")
def test_replay_on_other_replica(
api: Api,
alice: Actor,
chat: dict[str, Any],
replicas: int,
) -> None:
"""Повтор с тем же ключом, который обслужила другая реплика, — тот же
`Message`; другое тело с этим ключом — 409 от разных реплик."""
key = new_key()
body = {"text": "повтор через реплики"}
resp = api.post_message(alice, chat["id"], key=key, json=body)
first = assert_ok(resp, 201, "Message")
origin = assert_instance_id(resp)
replays: dict[str, Any] = {}
for _ in range(2 * replicas):
resp = api.post_message(alice, chat["id"], key=key, json=body)
replays[assert_instance_id(resp)] = assert_ok(resp, 201, "Message")
if replays.keys() - {origin}:
break
print(f"sent via {origin}, replayed via {sorted(replays)}")
# повтор через другую реплику: среди отправки и повторов ≥ 2 значения
assert_replicas({origin, *replays}, replicas)
assert all(message == first for message in replays.values())
conflicts = set()
for _ in range(2 * replicas):
resp = api.post_message(alice, chat["id"], key=key, json={"text": "?"})
assert_error(resp, 409)
conflicts.add(assert_instance_id(resp))
print(f"409 via {sorted(conflicts)}")
assert_replicas(conflicts, replicas)
assert texts(api, alice, chat["id"]) == [body["text"]]