115 lines
4.3 KiB
Python
115 lines
4.3 KiB
Python
"""Параллельная идемпотентность: N потоков посылают один POST с одним ключом.
|
|
|
|
Ожидаем: ровно одно сообщение создано, все ответы — одинаковые,
|
|
дубликатов в истории нет.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import json
|
|
import sys
|
|
import threading
|
|
import urllib.error
|
|
import urllib.request
|
|
import uuid
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
|
|
BASE = sys.argv[sys.argv.index("--base-url") + 1] if "--base-url" in sys.argv else "http://localhost:8080"
|
|
THREADS = 10
|
|
|
|
|
|
def call(method, path, headers=None, body=None):
|
|
data = None
|
|
h = dict(headers or {})
|
|
if body is not None:
|
|
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
|
h["Content-Type"] = "application/json"
|
|
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
|
|
try:
|
|
resp = urllib.request.urlopen(req, timeout=15)
|
|
raw = resp.read()
|
|
return resp.status, json.loads(raw) if raw else None, dict(resp.headers)
|
|
except urllib.error.HTTPError as e:
|
|
raw = e.read()
|
|
try:
|
|
return e.code, json.loads(raw) if raw else None, dict(e.headers)
|
|
except Exception:
|
|
return e.code, None, dict(e.headers)
|
|
|
|
|
|
def main():
|
|
username = "pario_" + uuid.uuid4().hex[:10]
|
|
password = "parallel-pass-1234567890"
|
|
|
|
# Регистрация
|
|
code, user, _ = call("POST", "/api/v1/users", body={
|
|
"username": username, "display_name": "Parallel", "password": password,
|
|
})
|
|
assert code == 201, f"register failed: {code} {user}"
|
|
user_id = user["id"]
|
|
|
|
# Логин
|
|
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
|
|
code, session, _ = call("POST", "/api/v1/auth/sessions",
|
|
headers={"Authorization": "Basic " + cred})
|
|
assert code == 201, f"login failed: {code}"
|
|
token = session["token"]
|
|
|
|
# Чат
|
|
code, chat, _ = call("POST", "/api/v1/chats",
|
|
headers={"Authorization": "Bearer " + token},
|
|
body={"title": "Parallel test", "member_ids": [user_id]})
|
|
assert code == 201, f"chat failed: {code}"
|
|
chat_id = chat["id"]
|
|
|
|
# Параллельный POST с одним ключом
|
|
idem_key = "parallel-" + uuid.uuid4().hex
|
|
barrier = threading.Barrier(THREADS)
|
|
results = []
|
|
results_lock = threading.Lock()
|
|
|
|
def worker(i):
|
|
barrier.wait() # стартуют одновременно
|
|
code, body, headers = call(
|
|
"POST", f"/api/v1/chats/{chat_id}/messages",
|
|
headers={
|
|
"Authorization": "Bearer " + token,
|
|
"Idempotency-Key": idem_key,
|
|
},
|
|
body={"text": "parallel-message-same"}, # ← ОДИНАКОВЫЙ текст!
|
|
)
|
|
with results_lock:
|
|
results.append((code, body))
|
|
|
|
with ThreadPoolExecutor(max_workers=THREADS) as pool:
|
|
list(pool.map(worker, range(THREADS)))
|
|
|
|
# Анализ
|
|
print(f"Results: {len(results)} responses")
|
|
codes = {}
|
|
for code, _ in results:
|
|
codes[code] = codes.get(code, 0) + 1
|
|
print(f"Status codes: {codes}")
|
|
|
|
# Проверка: ровно одно сообщение создано
|
|
code, page, _ = call("GET", f"/api/v1/chats/{chat_id}/messages?limit=100",
|
|
headers={"Authorization": "Bearer " + token})
|
|
assert code == 200, f"history failed: {code}"
|
|
messages = page["items"]
|
|
print(f"Messages in history: {len(messages)}")
|
|
|
|
assert len(messages) == 1, f"expected exactly 1 message, got {len(messages)}"
|
|
print("PASS: parallel idempotency — exactly one message created")
|
|
|
|
# Проверка: все ответы должны быть одинаковыми
|
|
codes = [c for c, _ in results]
|
|
bodies = [json.dumps(b, sort_keys=True) for _, b in results if b is not None]
|
|
unique_bodies = set(bodies)
|
|
print(f"Status codes: {dict((c, codes.count(c)) for c in set(codes))}")
|
|
print(f"Unique response bodies: {len(unique_bodies)}")
|
|
assert codes.count(201) == THREADS, f"expected all {THREADS} to be 201, got {codes.count(201)}"
|
|
assert len(unique_bodies) == 1, f"expected same response body, got {len(unique_bodies)}"
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main() |