Files
mtusi2026lab4/student-tests/test_race.py
T
ricoromaandClaude Opus 5.5 5d5d8f9d2a chore: carry lab 3 over
- carry the lab 3 solution over from mtusi2026lab3-safronov
  (solution/bvt2301-safronov, ce89eba): src, migrations, student-tests,
  bench, openspec, .claude, infra/haproxy and infra/valkey, own scripts,
  Dockerfile, compose, pyproject and uv lock
- merge Makefile, .gitignore and .dockerignore (the lab 3 versions only
  add lines to the skeleton, which is the same in lab 4) and
  .env.example (lab 4 skeleton names listed in the header)
- rename the compose project to mtusi-lab4 and the image to :lab4 so
  the stand does not reuse the lab 3 containers and volumes
- update AGENTS.md for lab 4: current lab, origin commit, contract and
  test files of the new skeleton

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 17:32:33 +03:00

235 lines
8.8 KiB
Python

"""Гонки: одновременные запросы по отдельным соединениям."""
import threading
import time
from collections import Counter
from collections.abc import Callable
from concurrent.futures import ThreadPoolExecutor
from typing import Any
import httpx
import pytest
from api_client import (
API,
Actor,
Api,
new_key,
order_key,
registration,
unique_username,
)
from contract import (
assert_error,
assert_instance_id,
assert_ok,
assert_replicas,
)
CLIENTS = 10
MESSAGES_PER_CLIENT = 10
HISTORY_PAGE = 30
def run_together[T](work: Callable[[Api, int], T], base_url: str) -> list[T]:
"""`CLIENTS` потоков со своим соединением стартуют за барьером."""
barrier = threading.Barrier(CLIENTS)
def client(number: int) -> T:
with Api(base_url) as own:
# соединение открыто до барьера: после него сразу запросы
own.request("GET", "/health/live")
barrier.wait()
return work(own, number)
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
return list(pool.map(client, range(CLIENTS)))
def max_in_flight(spans: list[tuple[float, float]]) -> int:
"""Сколько запросов максимум было в полёте одновременно."""
# при равенстве времени конец считается раньше начала
events = sorted(
[(start, 1) for start, _ in spans] + [(end, -1) for _, end in spans],
)
current = peak = 0
for _, delta in events:
current += delta
peak = max(peak, current)
return peak
@pytest.mark.spec("data-storage", "100 сообщений от 10 клиентов")
def test_hundred_messages_from_ten_clients(api: Api, base_url: str) -> None:
actors = [
api.register(display_name=f"Racer {number}")
for number in range(CLIENTS)
]
chat = api.create_chat(actors[0], *actors[1:], title="Race")
def send_all(
own: Api,
number: int,
) -> list[tuple[str, httpx.Response, float, float]]:
results = []
for index in range(MESSAGES_PER_CLIENT):
text = f"race-{number}-{index}"
start = time.monotonic()
# у каждой отправки свой ключ: это 100 разных сообщений
resp = own.post_message(
actors[number],
chat["id"],
json={"text": text},
)
results.append((text, resp, start, time.monotonic()))
return results
results = [
row for rows in run_together(send_all, base_url) for row in rows
]
statuses = Counter(resp.status_code for _, resp, _, _ in results)
peak = max_in_flight([(start, end) for _, _, start, end in results])
assert statuses == {201: CLIENTS * MESSAGES_PER_CLIENT}, statuses
created = {}
for text, resp, _, _ in results:
message = assert_ok(resp, 201, "Message")
assert message["text"] == text
created[message["id"]] = message
pages = api.message_pages(actors[0], chat["id"], limits=(HISTORY_PAGE,))
items = [item for page in pages for item in page["items"]]
ids = [item["id"] for item in items]
print(
f"race: {CLIENTS} clients x {MESSAGES_PER_CLIENT} messages, "
f"statuses {dict(statuses)}, max in flight {peak}; "
f"history: {len(items)} messages, {len(set(ids))} unique ids, "
f"{len(pages)} pages by {HISTORY_PAGE}",
)
assert peak >= 2, "requests did not overlap: race is not proven"
assert len(items) == CLIENTS * MESSAGES_PER_CLIENT
assert len(set(ids)) == len(ids)
assert set(ids) == created.keys()
assert items == sorted(created.values(), key=order_key)
senders = {actor.id for actor in actors}
assert {item["sender_id"] for item in items} == senders
@pytest.mark.spec("users", "Одновременная регистрация")
@pytest.mark.spec("data-storage", "Гонка за username")
def test_same_username_at_once(base_url: str) -> None:
username = unique_username()
def register(own: Api, number: int) -> tuple[httpx.Response, float, float]:
start = time.monotonic()
resp = own.request(
"POST",
f"{API}/users",
json=registration(username, f"Racer {number}"),
)
return resp, start, time.monotonic()
results = run_together(register, base_url)
statuses = Counter(resp.status_code for resp, _, _ in results)
peak = max_in_flight([(start, end) for _, start, end in results])
print(
f"username race: {CLIENTS} clients, statuses {dict(statuses)}, "
f"max in flight {peak}",
)
assert peak >= 2, "requests did not overlap: race is not proven"
assert statuses == {201: 1, 409: CLIENTS - 1}, statuses
for resp, _, _ in results:
if resp.status_code == 409:
assert_error(resp, 409)
else:
assert assert_ok(resp, 201, "User")["username"] == username
@pytest.mark.spec("idempotency", "Гонка одного ключа")
def test_same_key_at_once(
api: Api,
alice: Actor,
chat: dict[str, Any],
base_url: str,
) -> None:
"""Спек `student-tests`, сценарий «Гонка одного ключа»: одно тело с
одним ключом от `CLIENTS` клиентов сразу — ровно одно сообщение.
На любом стенде: против одного процесса API гонку решает PostgreSQL
так же, как между репликами. Ответы разных реплик требует
`test_same_key_through_replicas`.
"""
results = race_one_key(api, alice, chat, base_url)
peak = max_in_flight([(start, end) for _, start, end in results])
assert peak >= 2, "requests did not overlap: race is not proven"
@pytest.mark.spec("idempotency", "Гонка одного ключа через реплики")
def test_same_key_through_replicas(
api: Api,
alice: Actor,
chat: dict[str, Any],
base_url: str,
replicas: int,
) -> None:
"""Та же гонка через балансировщик: среди ответов есть пара
пересекающихся по времени запросов, которые обслужили разные реплики.
Это и есть «одновременно через разные реплики», а не просто «разные
реплики за весь прогон». Против одного процесса — пропуск."""
results = race_one_key(api, alice, chat, base_url)
spans = [
(assert_instance_id(resp), start, end) for resp, start, end in results
]
served = Counter(instance for instance, _, _ in spans)
print(f"key race through replicas: {dict(served)}")
assert_replicas(served, replicas)
assert overlap_on_different_replicas(spans), (
f"no overlapping requests on different replicas: {dict(served)}"
)
def race_one_key(
api: Api,
alice: Actor,
chat: dict[str, Any],
base_url: str,
) -> list[tuple[httpx.Response, float, float]]:
"""`CLIENTS` клиентов сразу шлют одно тело с одним ключом: все 201 с
одним `Message`, в истории ровно одно сообщение. Возвращает ответы со
временем начала и конца."""
key = new_key()
body = {"text": "один раз"}
def send(own: Api, _number: int) -> tuple[httpx.Response, float, float]:
start = time.monotonic()
resp = own.post_message(alice, chat["id"], key=key, json=body)
return resp, start, time.monotonic()
results = run_together(send, base_url)
statuses = Counter(resp.status_code for resp, _, _ in results)
peak = max_in_flight([(start, end) for _, start, end in results])
history = api.all_messages(alice, chat["id"])
print(
f"key race: {CLIENTS} clients, statuses {dict(statuses)}, "
f"max in flight {peak}; history: {len(history)} messages",
)
assert statuses == {201: CLIENTS}, statuses
messages = [assert_ok(resp, 201, "Message") for resp, _, _ in results]
assert all(message == messages[0] for message in messages)
assert history == [messages[0]]
return results
def overlap_on_different_replicas(
spans: list[tuple[str, float, float]],
) -> bool:
"""Есть два запроса разных реплик, которые были в полёте одновременно."""
return any(
first[0] != second[0] and first[1] < second[2] and second[1] < first[2]
for number, first in enumerate(spans)
for second in spans[number + 1 :]
)