Files
mtusi2026lab5/student-tests/test_concurrency.py
T

274 lines
8.9 KiB
Python

"""Конкурентность на реальной БД: гонка регистрации и параллельная запись."""
import asyncio
from collections import Counter
from uuid import uuid4
from sqlalchemy import text
from app.main import create_app
from conftest import close_app, make_client
from helpers import (
PASSWORD,
basic_header,
bearer,
create_user,
idempotency_header,
register,
)
async def test_parallel_registration_of_same_username_creates_exactly_one_user(
make_settings,
):
app = create_app(
make_settings(max_in_flight=64, db_pool_size=20, db_max_overflow=20)
)
async with make_client(app) as client:
responses = await asyncio.gather(
*(
client.post(
"/api/v1/users",
json={
"username": "race_user",
"display_name": "Race",
"password": PASSWORD,
},
)
for _ in range(16)
)
)
await close_app(app)
statuses = Counter(response.status_code for response in responses)
assert statuses == Counter({201: 1, 409: 15}), statuses
async def test_100_messages_from_10_clients(make_settings):
app = create_app(
make_settings(
max_messages=1000, max_in_flight=100, db_pool_size=20, db_max_overflow=20
)
)
async with make_client(app) as client:
users = [
await create_user(client, username=f"load_{i}_{uuid4().hex[:6]}")
for i in range(10)
]
created = await client.post(
"/api/v1/chats",
headers=bearer(users[0]),
json={"title": "Concurrency", "member_ids": [u["id"] for u in users]},
)
chat = created.json()
async def worker(index: int, user: dict) -> list[dict]:
responses = await asyncio.gather(
*(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers={**bearer(user), **idempotency_header()},
json={"text": f"client-{index}-message-{n}"},
)
for n in range(10)
)
)
assert all(r.status_code == 201 for r in responses), [
r.text for r in responses if r.status_code != 201
]
return [r.json() for r in responses]
results = await asyncio.gather(*(worker(i, u) for i, u in enumerate(users)))
messages = [m for batch in results for m in batch]
assert len(messages) == 100
assert len({m["id"] for m in messages}) == 100
assert Counter(m["sender_id"] for m in messages) == Counter(
{u["id"]: 10 for u in users}
)
history = await client.get(
f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(users[0])
)
items = history.json()["items"]
assert len(items) == 100
assert len({m["id"] for m in items}) == 100
await close_app(app)
async def test_chat_creation_in_parallel_is_atomic(make_settings, db_engine):
app = create_app(
make_settings(max_in_flight=32, db_pool_size=20, db_max_overflow=20)
)
async with make_client(app) as client:
alice = await create_user(client)
bob = await create_user(client)
responses = await asyncio.gather(
*(
client.post(
"/api/v1/chats",
headers=bearer(alice),
json={"title": f"c{i}", "member_ids": [alice["id"], bob["id"]]},
)
for i in range(10)
)
)
assert all(r.status_code == 201 for r in responses)
await close_app(app)
async with db_engine.connect() as connection:
chats = (
await connection.execute(text("SELECT count(*) FROM chats"))
).scalar_one()
members = (
await connection.execute(text("SELECT count(*) FROM chat_members"))
).scalar_one()
assert chats == 10 and members == 20
async def test_parallel_registration_of_distinct_usernames_all_succeed(make_settings):
app = create_app(make_settings(max_in_flight=64))
async with make_client(app) as client:
responses = await asyncio.gather(
*(
client.post(
"/api/v1/users",
json={
"username": f"distinct_{i}",
"display_name": "D",
"password": PASSWORD,
},
)
for i in range(12)
)
)
await close_app(app)
assert [r.status_code for r in responses] == [201] * 12
assert len({r.json()["id"] for r in responses}) == 12
async def test_parallel_logins_issue_distinct_valid_tokens(make_settings):
app = create_app(make_settings(max_in_flight=64))
async with make_client(app) as client:
user = await register(client)
responses = await asyncio.gather(
*(
client.post(
"/api/v1/auth/sessions",
headers=basic_header(user["username"], user["password"]),
)
for _ in range(10)
)
)
tokens = [r.json()["token"] for r in responses]
checks = await asyncio.gather(
*(
client.get(
"/api/v1/users/me", headers={"Authorization": f"Bearer {token}"}
)
for token in tokens
)
)
await close_app(app)
assert all(r.status_code == 201 for r in responses)
assert len(set(tokens)) == 10
assert all(r.status_code == 200 for r in checks)
async def test_parallel_logout_of_same_token_succeeds_once(make_settings):
app = create_app(make_settings(max_in_flight=64))
async with make_client(app) as client:
session = await create_user(client)
responses = await asyncio.gather(
*(
client.delete("/api/v1/auth/sessions/current", headers=bearer(session))
for _ in range(10)
)
)
await close_app(app)
assert Counter(r.status_code for r in responses) == Counter({204: 1, 401: 9})
async def test_message_limit_is_exact_under_concurrency(make_settings, db_engine):
app = create_app(
make_settings(
max_messages=5, max_in_flight=64, db_pool_size=20, db_max_overflow=20
)
)
async with make_client(app) as client:
user = await create_user(client)
chat = (
await client.post(
"/api/v1/chats",
headers=bearer(user),
json={"title": "limit", "member_ids": [user["id"]]},
)
).json()
responses = await asyncio.gather(
*(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers={**bearer(user), **idempotency_header()},
json={"text": f"m{i}"},
)
for i in range(20)
)
)
await close_app(app)
assert Counter(r.status_code for r in responses) == Counter({201: 5, 503: 15})
async with db_engine.connect() as connection:
stored = (
await connection.execute(text("SELECT count(*) FROM messages"))
).scalar_one()
counter = (
await connection.execute(
text("SELECT value FROM counters WHERE name = 'messages'")
)
).scalar_one()
assert stored == counter == 5
async def test_failed_chat_insert_rolls_back_whole_transaction(
make_settings, db_engine, monkeypatch
):
import app.domain.chats as chats_domain
async def accept_everyone(_session, user_ids):
return set(user_ids)
app = create_app(make_settings())
async with make_client(app) as client:
alice = await create_user(client)
monkeypatch.setattr(
chats_domain.users_storage, "get_existing_user_ids", accept_everyone
)
response = await client.post(
"/api/v1/chats",
headers=bearer(alice),
json={"title": "broken", "member_ids": [alice["id"], str(uuid4())]},
)
monkeypatch.undo()
after = await client.post(
"/api/v1/chats",
headers=bearer(alice),
json={"title": "ok", "member_ids": [alice["id"]]},
)
await close_app(app)
assert response.status_code == 400
assert after.status_code == 201
async with db_engine.connect() as connection:
titles = (await connection.execute(text("SELECT title FROM chats"))).scalars()
members = (
await connection.execute(text("SELECT count(*) FROM chat_members"))
).scalar_one()
assert list(titles) == ["ok"]
assert members == 1