Files
mtusi2026lab2/student-tests/api/test_consistency.py
T
Artyom 12db77133f Forward the lab 5 foundation while preserving lab 6 telemetry
Source: immutable lab5 snapshot f88e9ba43cdfd7eb6a5a7ae5feb4247b4e820071; forward the allowed diff from 64d5c67. Carry SQLAlchemy, Alembic, reliability fixes, versioned jobs, infrastructure and student tests without changing protected coursework files.

Validation: make check, validate, lint; 515 student tests passed with one Linux-only skip; public smoke with telemetry enabled and repeat migration passed. Stop the owned stack and retain volumes. Preserve the existing OTel work in progress; grade implementation remains a separate phase.
2026-11-06 12:29:35 +03:00

198 lines
7.6 KiB
Python

import asyncio
from urllib.parse import quote
from uuid import UUID, uuid4
from httpx import AsyncClient
from sqlalchemy import func, select
from conftest import PASSWORD, actor, keyed, make_chat, new_user, register, running_app, scalar
from messenger.identity.infrastructure.postgres import UserRow
from messenger.messaging.infrastructure.postgres import ChatMemberRow, ChatRow
REGISTRATIONS = 25
async def drain_history(client: AsyncClient, chat: dict, reader: dict) -> list[dict]:
collected: list[dict] = []
cursor: str | None = None
while True:
query = "?limit=100" + (f"&cursor={quote(cursor, safe='')}" if cursor else "")
page = (
await client.get(f"/api/v1/chats/{chat['id']}/messages{query}", headers=actor(reader))
).json()
collected.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
return collected
async def test_registration_is_visible_to_chats_immediately() -> None:
async with running_app() as client:
for _ in range(REGISTRATIONS):
user = await register(client, "race")
response = await client.post(
"/api/v1/chats",
json={"title": "Сразу после регистрации", "member_ids": [user["id"]]},
headers=actor(user),
)
assert response.status_code == 201, response.text
async def test_parallel_registrations_are_all_usable_as_members() -> None:
async with running_app() as client:
alice = await register(client, "alice")
bodies = [new_user(f"par{index}") for index in range(REGISTRATIONS)]
responses = await asyncio.gather(
*(client.post("/api/v1/users", json=body) for body in bodies)
)
assert all(response.status_code == 201 for response in responses)
created = [response.json()["id"] for response in responses]
chat = await client.post(
"/api/v1/chats",
json={"title": "Все параллельные", "member_ids": [alice["id"], *created]},
headers=actor(alice),
)
assert chat.status_code == 201, chat.text
assert len(chat.json()["member_ids"]) == REGISTRATIONS + 1
async def test_rejected_registration_leaves_no_trace() -> None:
async with running_app() as client:
alice = await register(client, "alice")
duplicate = await client.post(
"/api/v1/users",
json={"username": alice["username"], "display_name": "Двойник", "password": PASSWORD},
)
assert duplicate.status_code == 409
invalid = await client.post(
"/api/v1/users", json={"username": "AB", "display_name": "", "password": PASSWORD}
)
assert invalid.status_code == 400
sql = select(func.count()).select_from(UserRow).where(UserRow.username == alice["username"])
assert await scalar(sql) == 1
async def test_failed_chat_creation_rolls_back_both_tables() -> None:
title = f"Откат {uuid4().hex}"
async with running_app() as client:
alice = await register(client, "alice")
before = (await client.get("/api/v1/chats?limit=100", headers=actor(alice))).json()
rejected = await client.post(
"/api/v1/chats",
json={"title": title, "member_ids": [alice["id"], str(uuid4())]},
headers=actor(alice),
)
assert rejected.status_code == 400
assert rejected.json()["error"]["code"] == "invalid_request"
after = (await client.get("/api/v1/chats?limit=100", headers=actor(alice))).json()
assert after["items"] == before["items"]
assert (
await scalar(select(func.count()).select_from(ChatRow).where(ChatRow.title == title)) == 0
)
members = (
select(func.count())
.select_from(ChatMemberRow)
.where(ChatMemberRow.user_id == UUID(alice["id"]))
)
assert await scalar(members) == 0
async def test_rejected_message_does_not_enter_history() -> None:
async with running_app() as client:
alice = await register(client, "alice")
eve = await register(client, "eve")
chat = await make_chat(client, alice)
assert (
await client.post(
f"/api/v1/chats/{chat['id']}/messages",
json={"text": " "},
headers=keyed(alice),
)
).status_code == 400
assert (
await client.post(
f"/api/v1/chats/{chat['id']}/messages",
json={"text": "чужое"},
headers=keyed(eve),
)
).status_code == 404
assert await drain_history(client, chat, alice) == []
async def test_confirmed_write_is_visible_to_next_read() -> None:
async with running_app() as client:
alice = await register(client, "alice")
bob = await register(client, "bob")
chat = await make_chat(client, alice, bob)
for index in range(30):
posted = await client.post(
f"/api/v1/chats/{chat['id']}/messages",
json={"text": f"подтверждение {index}"},
headers=keyed(alice),
)
assert posted.status_code == 201
history = await drain_history(client, chat, bob)
assert history[-1]["id"] == posted.json()["id"]
assert len(history) == index + 1
async def test_parallel_writes_across_zones_keep_counts_consistent() -> None:
async with running_app() as client:
alice = await register(client, "alice")
chats = [await make_chat(client, alice) for _ in range(4)]
async def writer(chat: dict, worker: int) -> None:
for index in range(10):
response = await client.post(
f"/api/v1/chats/{chat['id']}/messages",
json={"text": f"поток-{worker}-{index}"},
headers=keyed(alice),
)
assert response.status_code == 201
async def registrar(index: int) -> str:
return (await register(client, f"parallel{index}"))["id"]
results = await asyncio.gather(
*(writer(chat, number) for number, chat in enumerate(chats)),
*(registrar(index) for index in range(10)),
)
registered = [item for item in results if isinstance(item, str)]
assert len(set(registered)) == 10
for chat in chats:
history = await drain_history(client, chat, alice)
assert len(history) == 10
assert len({item["id"] for item in history}) == 10
keys = [(item["created_at"], item["id"]) for item in history]
assert keys == sorted(keys)
async def test_chat_membership_survives_parallel_reads_and_writes() -> None:
async with running_app() as client:
alice = await register(client, "alice")
bob = await register(client, "bob")
eve = await register(client, "eve")
chat = await make_chat(client, alice, bob)
async def write(index: int) -> None:
await client.post(
f"/api/v1/chats/{chat['id']}/messages",
json={"text": f"параллельно {index}"},
headers=keyed(alice),
)
async def intruder() -> int:
response = await client.get(f"/api/v1/chats/{chat['id']}/messages", headers=actor(eve))
return response.status_code
results = await asyncio.gather(
*(write(index) for index in range(20)),
*(intruder() for _ in range(20)),
)
assert {code for code in results if isinstance(code, int)} == {404}
assert len(await drain_history(client, chat, bob)) == 20