forked from mtusi2026/mtusi2026lab5
274 lines
8.9 KiB
Python
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
|