forked from mtusi2026/mtusi2026lab4
173 lines
8.6 KiB
Python
173 lines
8.6 KiB
Python
"""Idempotency-Key через балансировщик (lab3). Только стандартная библиотека.
|
|
|
|
BASE_URL=http://127.0.0.1:8080 python -m unittest discover -s student-tests -p test_idempotency.py -v
|
|
|
|
Главная проверка — одновременные повторы с одним ключом, которые LB
|
|
раскладывает по РАЗНЫМ репликам (это проверяется по X-Instance-Id),
|
|
создают ровно одно сообщение. Остальное — семантика из contracts/README.md.
|
|
"""
|
|
import json
|
|
import threading
|
|
import unittest
|
|
import uuid
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from urllib.parse import quote
|
|
|
|
from common import actor, create_chat, login, request
|
|
|
|
PARALLEL = 24
|
|
|
|
|
|
def history(token, chat_id):
|
|
items, cursor = [], None
|
|
for _ in range(100):
|
|
path = "/api/v1/chats/%s/messages?limit=100" % chat_id
|
|
if cursor:
|
|
path += "&cursor=" + quote(cursor, safe="")
|
|
page = request("GET", path, token=token).json
|
|
items.extend(page["items"])
|
|
cursor = page["next_cursor"]
|
|
if cursor is None:
|
|
return items
|
|
raise AssertionError("pagination did not finish")
|
|
|
|
|
|
def post(token, chat_id, body, key, raw=None):
|
|
# None -> заголовок не отправляется (см. common.request).
|
|
headers = {"Idempotency-Key": key}
|
|
if raw is not None:
|
|
return request("POST", "/api/v1/chats/%s/messages" % chat_id, token=token, raw=raw, headers=headers)
|
|
return request("POST", "/api/v1/chats/%s/messages" % chat_id, token=token, payload=body, headers=headers)
|
|
|
|
|
|
def parallel(n, fn):
|
|
barrier = threading.Barrier(n)
|
|
|
|
def run(i):
|
|
barrier.wait()
|
|
return fn(i)
|
|
|
|
with ThreadPoolExecutor(max_workers=n) as pool:
|
|
return list(pool.map(run, range(n)))
|
|
|
|
|
|
class IdempotencyTests(unittest.TestCase):
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.alice = actor("ida")
|
|
cls.bob = actor("idb")
|
|
cls.eve = actor("ide")
|
|
cls.chat = create_chat(cls.alice, cls.bob)
|
|
cls.chat2 = create_chat(cls.alice, cls.bob)
|
|
|
|
def test_concurrent_same_key_across_replicas_creates_one_message(self):
|
|
key = "par-" + uuid.uuid4().hex
|
|
text = "одновременно " + key
|
|
results = parallel(PARALLEL, lambda i: post(self.alice["_token"], self.chat["id"], {"text": text}, key))
|
|
statuses = [r.status for r in results]
|
|
self.assertEqual(statuses, [201] * PARALLEL, statuses)
|
|
ids = {r.json["id"] for r in results}
|
|
self.assertEqual(len(ids), 1, "same key produced different messages")
|
|
bodies = {json.dumps(r.json, sort_keys=True) for r in results}
|
|
self.assertEqual(len(bodies), 1, "replays must return the identical Message")
|
|
instances = {r.headers.get("X-Instance-Id") for r in results}
|
|
self.assertGreaterEqual(len(instances), 2, "requests did not reach >= 2 replicas: %s" % instances)
|
|
stored = [m for m in history(self.bob["_token"], self.chat["id"]) if m["text"] == text]
|
|
self.assertEqual(len(stored), 1, "history must contain exactly one message")
|
|
replayed = sum(1 for r in results if r.headers.get("Idempotency-Replayed") == "true")
|
|
self.assertEqual(replayed, PARALLEL - 1)
|
|
print("\n %d parallel POSTs, one key -> 1 message; replicas: %s" % (PARALLEL, sorted(instances)))
|
|
|
|
def test_concurrent_same_key_different_bodies_one_winner(self):
|
|
key = "race-" + uuid.uuid4().hex
|
|
results = parallel(12, lambda i: post(self.alice["_token"], self.chat["id"], {"text": "вариант %d" % i}, key))
|
|
winners = [r for r in results if r.status == 201]
|
|
losers = [r for r in results if r.status == 409]
|
|
self.assertEqual(len(winners) + len(losers), 12, [r.status for r in results])
|
|
self.assertGreaterEqual(len(winners), 1)
|
|
self.assertEqual(len({r.json["id"] for r in winners}), 1, "two bodies won with one key")
|
|
for r in losers:
|
|
self.assertEqual(r.json["error"]["code"], "conflict")
|
|
texts = [m["text"] for m in history(self.alice["_token"], self.chat["id"]) if m["text"].startswith("вариант ")]
|
|
self.assertEqual(len([t for t in texts if t == winners[0].json["text"]]), 1)
|
|
|
|
def test_sequential_replay_and_conflict(self):
|
|
key = "seq-" + uuid.uuid4().hex
|
|
first = post(self.alice["_token"], self.chat["id"], {"text": "раз"}, key)
|
|
self.assertEqual(first.status, 201)
|
|
again = post(self.alice["_token"], self.chat["id"], {"text": "раз"}, key)
|
|
self.assertEqual((again.status, again.json), (201, first.json))
|
|
other = post(self.alice["_token"], self.chat["id"], {"text": "два"}, key)
|
|
self.assertEqual(other.status, 409)
|
|
self.assertEqual(other.json["error"]["code"], "conflict")
|
|
|
|
def test_json_formatting_and_key_order_do_not_matter(self):
|
|
key = "fmt-" + uuid.uuid4().hex
|
|
first = post(self.alice["_token"], self.chat["id"], None, key, raw=b'{"text":"format"}')
|
|
spaced = post(self.alice["_token"], self.chat["id"], None, key, raw=b'{ \n "text" : "format"\n}')
|
|
self.assertEqual(first.status, 201)
|
|
self.assertEqual((spaced.status, spaced.json), (201, first.json))
|
|
|
|
def test_missing_or_invalid_key_is_400(self):
|
|
token, chat_id = self.alice["_token"], self.chat["id"]
|
|
# Не-ASCII ключ передаём сырыми UTF-8 байтами (urllib пропускает только latin-1).
|
|
non_ascii = "ключ".encode("utf-8").decode("latin-1")
|
|
bad_keys = [None, "", " ", "a" * 129, non_ascii, "has space", "semi;colon", "slash/key"]
|
|
for key in bad_keys:
|
|
with self.subTest(key=key):
|
|
r = post(token, chat_id, {"text": "x"}, key)
|
|
self.assertEqual(r.status, 400, r.json)
|
|
self.assertEqual(r.json["error"]["code"], "invalid_request")
|
|
ok = post(token, chat_id, {"text": "x"}, "A" * 128)
|
|
self.assertEqual(ok.status, 201)
|
|
ok2 = post(token, chat_id, {"text": "y"}, "a.b_c:d-1")
|
|
self.assertEqual(ok2.status, 201)
|
|
|
|
def test_auth_checked_before_key(self):
|
|
r = post(None, self.chat["id"], {"text": "x"}, None)
|
|
self.assertEqual(r.status, 401)
|
|
|
|
def test_scope_is_user_and_chat(self):
|
|
key = "scope-" + uuid.uuid4().hex
|
|
a1 = post(self.alice["_token"], self.chat["id"], {"text": "scope"}, key)
|
|
b1 = post(self.bob["_token"], self.chat["id"], {"text": "scope"}, key)
|
|
a2 = post(self.alice["_token"], self.chat2["id"], {"text": "scope"}, key)
|
|
self.assertEqual([a1.status, b1.status, a2.status], [201, 201, 201])
|
|
self.assertEqual(len({a1.json["id"], b1.json["id"], a2.json["id"]}), 3)
|
|
# Другое тело другим пользователем с тем же ключом — не конфликт.
|
|
b2 = post(self.bob["_token"], self.chat2["id"], {"text": "другое"}, key)
|
|
self.assertEqual(b2.status, 201)
|
|
|
|
def test_key_survives_new_session_of_same_user(self):
|
|
key = "sess-" + uuid.uuid4().hex
|
|
first = post(self.alice["_token"], self.chat["id"], {"text": "до перелогина"}, key)
|
|
token2 = login(self.alice)
|
|
replay = post(token2, self.chat["id"], {"text": "до перелогина"}, key)
|
|
self.assertEqual((replay.status, replay.json), (201, first.json))
|
|
|
|
def test_failed_access_does_not_burn_key(self):
|
|
key = "burn-" + uuid.uuid4().hex
|
|
denied = post(self.eve["_token"], self.chat["id"], {"text": "чужое"}, key)
|
|
self.assertEqual(denied.status, 404)
|
|
# Тот же ключ у участника и даже у того же постороннего позже — не занят.
|
|
mine = post(self.alice["_token"], self.chat["id"], {"text": "своё"}, key)
|
|
self.assertEqual(mine.status, 201)
|
|
invalid = post(self.alice["_token"], self.chat2["id"], {"text": ""}, key)
|
|
self.assertEqual(invalid.status, 400)
|
|
valid = post(self.alice["_token"], self.chat2["id"], {"text": "после 400"}, key)
|
|
self.assertEqual(valid.status, 201)
|
|
|
|
def test_replay_rechecks_session(self):
|
|
key = "revoked-" + uuid.uuid4().hex
|
|
token = login(self.bob)
|
|
first = post(token, self.chat["id"], {"text": "до logout"}, key)
|
|
self.assertEqual(first.status, 201)
|
|
self.assertEqual(request("DELETE", "/api/v1/auth/sessions/current", token=token).status, 204)
|
|
replay = post(token, self.chat["id"], {"text": "до logout"}, key)
|
|
self.assertEqual(replay.status, 401)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|