Files
mtusi2026lab2/student-tests/test_lab2_level4.py
T

587 lines
28 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Уровень 4 lab2: expiry TTL, конкурентная регистрация, EXPLAIN, недоступность Redis/PostgreSQL.
Перед запуском:
1) в .env выставить SESSION_TTL_SECONDS=5
2) docker compose --env-file .env up -d --force-recreate api
3) docker exec mtuci-redis redis-cli flushdb
4) python student-tests/test_lab2_level4.py --base-url http://localhost:8080
5) перед smoke/persistence вернуть SESSION_TTL_SECONDS=3600 и снова up -d --force-recreate api
Порядок тестов: тяжёлые по данным и конкурентные — ДО expiry-теста,
потому что при коротком TTL любой долгий шаг съедает окно жизни сессии.
Expiry-тест запускается последним и использует свежие сессии.
test_explain не зависит от TTL вообще: он сидирует данные напрямую
через psql и проверяет план SQL-запроса, а не HTTP-слой.
test_chat_rollback проверяет транзакционную границу create_chat: он
запускает патч-скрипт ВНУТРИ контейнера API (там есть psycopg и
DATABASE_URL), monkey-patch-ит psycopg.Cursor.executemany так, чтобы
INSERT в chat_members упал ПОСЛЕ успешного INSERT в chats. Затем через
psql проверяется, что ни chat, ни chat_members не сохранились.
"""
import base64
import datetime as dt
import os
import subprocess
import sys
import threading
import time
import uuid
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client, Failure, arguments, check, run # noqa: E402
# Имя compose-сети проекта: mtuci2026lab2_default (зафиксировано в compose.yaml networks.default.name).
COMPOSE_NETWORK = os.environ.get("COMPOSE_NETWORK", "mtuci2026lab2_default")
# Имя контейнера API (зафиксировано в compose.yaml container_name).
API_CONTAINER = os.environ.get("API_CONTAINER", "mtuci-messenger-lab2")
# ---------- 1. Конкурентная регистрация одинакового username ----------
def test_concurrent_registration(c):
"""Один и тот же username с 8 потоков — ровно одна 201, остальные 409.
Проверяем ФАКТИЧЕСКИЕ HTTP-коды, а не факт исключения: timeout, 500
или неверный формат ответа должны проваливать тест, а не выдаваться
за ожидаемый конфликт. Дополнительно сверяем, что в БД создана
ровно одна строка пользователя.
"""
username = "race_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
body = {"username": username, "display_name": "Race", "password": password}
results = []
lock = threading.Lock()
def one(_):
local = Client(c.base, timeout=10)
try:
r = local.call("POST", "/api/v1/users", (201, 409),
body=body, schema="User" if True else None)
# schema валидируется только для 2xx; при 409 приходит Error.
status = r["status"]
except Failure as exc:
# Любая иная ошибка (timeout, 500, bad schema) — это не 409.
status = "failure:%s" % exc
with lock:
results.append(status)
with ThreadPoolExecutor(max_workers=8) as pool:
list(pool.map(one, range(8)))
ok = [r for r in results if r == 201]
conflict = [r for r in results if r == 409]
bad = [r for r in results if r not in (201, 409)]
check(not bad, "unexpected results under concurrent registration: %s" % results)
check(len(ok) == 1, "expected exactly one 201, got %s" % results)
check(len(conflict) == 7, "expected seven 409, got %s" % results)
# В БД должна быть ровно одна строка с этим username.
dsn = _read_dsn()
rows = _scalar(dsn, "SELECT count(*) FROM users WHERE username = '%s';" % username)
check(int(rows) == 1,
"ожидалась ровно одна строка users для %s, получено %s" % (username, rows))
# ---------- 2. EXPLAIN на реальной БД ----------
def _read_dsn() -> str:
dsn = os.environ.get("DATABASE_URL")
if not dsn:
env_file = Path(__file__).resolve().parents[1] / ".env"
if env_file.is_file():
for line in env_file.read_text(encoding="utf-8").splitlines():
line = line.strip()
if line.startswith("DATABASE_URL="):
dsn = line.split("=", 1)[1].strip()
break
check(dsn, "DATABASE_URL не найден ни в окружении, ни в .env")
# Postgres доступен только внутри compose-сети; одноразовые psql-контейнеры
# запускаются в этой же сети, поэтому имя хоста postgres резолвится как есть.
return dsn
def _psql(dsn_in_container: str, sql: str) -> str:
r = subprocess.run(
[
"docker", "run", "--rm",
"--network", COMPOSE_NETWORK,
"postgres:18-alpine",
"psql", dsn_in_container, "-tA", "-c", sql,
],
capture_output=True, text=True, timeout=120,
)
return r.stdout + r.stderr
def _scalar(dsn: str, sql: str) -> str:
r = subprocess.run(
[
"docker", "run", "--rm",
"--network", COMPOSE_NETWORK,
"postgres:18-alpine",
"psql", dsn, "-tA", "-v", "ON_ERROR_STOP=1", "-c", sql,
],
capture_output=True, text=True, timeout=120,
)
check(r.returncode == 0, "psql failed:\n" + r.stdout + r.stderr)
return r.stdout.strip().splitlines()[-1]
def test_explain(c):
"""EXPLAIN (ANALYZE, BUFFERS) истории сообщений на >=10 000 строк.
Методичка: индекс истории обоснован запросом и EXPLAIN на >=10 000
сообщениях. На пустой таблице планировщик выбирает Seq Scan, поэтому
тест сам доводит messages до >=10 000 строк и делает ANALYZE.
Данные сидируются напрямую через psql, без API: тест не зависит от
SESSION_TTL_SECONDS и скорости scrypt. Это корректно, потому что
EXPLAIN проверяет план SQL-запроса, а не HTTP-слой.
"""
dsn_in_container = _read_dsn()
# Смотрим, сколько строк уже есть.
have_raw = _psql(dsn_in_container, "SELECT count(*) FROM messages;")
have = int(have_raw.strip().splitlines()[-1])
print(" в таблице messages сейчас: %d строк" % have)
target_total = 10_000
if have < target_total:
need = target_total - have
print(" сидируем %d сообщений напрямую через psql ..." % need)
# Один чат: берём существующий или создаём минимальный.
# gen_random_uuid() доступен в PG13+ без расширений.
seed_sql = """
DO $$
DECLARE
v_user UUID;
v_chat UUID;
BEGIN
SELECT id INTO v_user FROM users LIMIT 1;
IF v_user IS NULL THEN
v_user := gen_random_uuid();
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (v_user, 'seed_' || substr(v_user::text, 1, 8), 'Seed',
'scrypt$16384$8$1$00$00', now());
END IF;
SELECT id INTO v_chat FROM chats LIMIT 1;
IF v_chat IS NULL THEN
v_chat := gen_random_uuid();
INSERT INTO chats (id, title, created_at) VALUES (v_chat, 'Seed chat', now());
INSERT INTO chat_members (chat_id, user_id) VALUES (v_chat, v_user);
END IF;
-- Доливаем ровно need строк в этот чат.
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), v_chat, v_user,
'seed-' || g, now() - (g || ' milliseconds')::interval
FROM generate_series(1, %d) AS g;
END $$;
""" % need
r = subprocess.run(
[
"docker", "run", "--rm",
"--network", COMPOSE_NETWORK,
"postgres:18-alpine",
"psql", dsn_in_container, "-c", seed_sql,
],
capture_output=True, text=True, timeout=120,
)
seed_out = r.stdout + r.stderr
check("ERROR" not in seed_out, "сидирование не удалось:\n" + seed_out)
# ANALYZE обязателен: без него планировщик не знает реальных размеров.
_psql(dsn_in_container, "ANALYZE messages;")
_psql(dsn_in_container, "ANALYZE chat_members;")
_psql(dsn_in_container, "ANALYZE chats;")
print(" сидирование завершено")
# EXPLAIN по САМОМУ БОЛЬШОМУ чату, чтобы планировщик имел основания
# выбрать индекс, а не Seq Scan.
biggest = _psql(
dsn_in_container,
"SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1;",
).strip().splitlines()[-1]
check(biggest and len(biggest) >= 32, "не удалось выбрать самый большой чат: %r" % biggest)
sql = (
"EXPLAIN (ANALYZE, BUFFERS) "
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
"WHERE chat_id = '%s' "
"ORDER BY created_at, id LIMIT 51;" % biggest
)
r = subprocess.run(
[
"docker", "run", "--rm",
"--network", COMPOSE_NETWORK,
"postgres:18-alpine",
"psql", dsn_in_container, "-c", sql,
],
capture_output=True, text=True, timeout=120,
)
out = r.stdout + r.stderr
print("EXPLAIN (фрагмент):")
for line in out.splitlines()[:12]:
print(" ", line)
check("Index" in out or "Bitmap Index" in out or "idx_messages_chat_created" in out,
"EXPLAIN не показал использования индекса:\n" + out)
# ---------- 3. Rollback составной операции create_chat ----------
def test_chat_rollback(c):
"""Проверяем, что при падении INSERT в chat_members ПОСЛЕ успешного
INSERT в chats не остаётся ни строки чата, ни частичного членства.
Как добиться ошибки именно на вставке участников, а не на предварительной
проверке unknown_member? Проверка `SELECT id FROM users WHERE id = ANY(...)`
в postgres.py отсекает неизвестных до INSERT. Значит, нужен сбой именно
в executemany.
Решение: запускаем патч-скрипт ВНУТРИ контейнера API через docker exec —
там уже установлен psycopg и доступен DATABASE_URL. Скрипт monkey-patch-ит
psycopg.Cursor.executemany так, чтобы он бросил исключение, и вызывает
storage.create_chat с двумя реально существующими пользователями.
Транзакция дойдёт до INSERT в chats, упадёт на executemany и должна
откатиться.
После этого через psql проверяем:
- в таблице chats нет строки с этим title;
- в таблице chat_members нет строк с этим chat_id;
- через API GET /api/v1/chats пользователь не видит этот чат.
"""
dsn = _read_dsn()
# Готовим двух валидных пользователей через API, чтобы FK был валиден.
suffix = uuid.uuid4().hex[:10]
alice_username = "rb_a_" + suffix
bob_username = "rb_b_" + suffix
alice_password = "T3st-" + uuid.uuid4().hex
bob_password = "T3st-" + uuid.uuid4().hex
alice = c.call("POST", "/api/v1/users", 201,
body={"username": alice_username, "display_name": "RB-A",
"password": alice_password},
schema="User")["json"]
bob = c.call("POST", "/api/v1/users", 201,
body={"username": bob_username, "display_name": "RB-B",
"password": bob_password},
schema="User")["json"]
# Уникальный title, чтобы точно найти строку, если rollback не сработает.
marker_title = "rollback-chat-" + uuid.uuid4().hex
# Скрипт запускается ВНУТРИ контейнера API: там есть psycopg и DATABASE_URL.
# Патчит executemany так, чтобы он упал после успешного INSERT в chats.
patch_script = r'''
import os, sys, psycopg
from uuid import UUID
_orig = psycopg.Cursor.executemany
def boom(self, *args, **kwargs):
raise RuntimeError("patched_executemany_failure")
psycopg.Cursor.executemany = boom
sys.path.insert(0, "/app/src")
from app.storage.postgres import storage
try:
storage.create_chat(os.environ["RB_TITLE"],
[UUID(os.environ["RB_ALICE"]), UUID(os.environ["RB_BOB"])])
except RuntimeError as exc:
if "patched_executemany_failure" in str(exc):
print("PATCHED_FAILURE_OK"); sys.exit(0)
raise
except Exception as exc:
print("UNEXPECTED:%s:%s" % (type(exc).__name__, exc)); sys.exit(2)
print("NO_FAILURE"); sys.exit(3)
'''
proc = subprocess.run(
["docker", "exec",
"-e", "RB_TITLE=" + marker_title,
"-e", "RB_ALICE=" + alice["id"],
"-e", "RB_BOB=" + bob["id"],
API_CONTAINER,
"python", "-c", patch_script],
capture_output=True, text=True, timeout=60,
)
out = (proc.stdout + proc.stderr).strip()
print(" rollback-процесс: exit=%d, out=%r" % (proc.returncode, out[:200]))
check("PATCHED_FAILURE_OK" in out,
"не удалось вызвать ошибку именно на executemany: %s" % out)
# Проверяем в БД: ни chats, ни chat_members с этим маркером не осталось.
chats_count = _scalar(
dsn,
"SELECT count(*) FROM chats WHERE title = '%s';" % marker_title,
)
check(int(chats_count) == 0,
"rollback не сработал: строка chats с title=%s осталась (%s)" % (marker_title, chats_count))
members_count = _scalar(
dsn,
"SELECT count(*) FROM chat_members cm "
"JOIN chats c ON c.id = cm.chat_id "
"WHERE c.title = '%s';" % marker_title,
)
check(int(members_count) == 0,
"rollback не сработал: остались строки chat_members (%s)" % members_count)
# Дополнительно: у пользователя нет чата с таким title через API.
cred = base64.b64encode((alice_username + ":" + alice_password).encode()).decode()
session = c.call("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": "Basic " + cred},
schema="Session")["json"]
listed = c.call("GET", "/api/v1/chats?limit=100",
headers={"Authorization": "Bearer " + session["token"]},
schema="ChatPage")["json"]
check(all(item["title"] != marker_title for item in listed["items"]),
"чат с маркером rollback виден в списке чатов пользователя")
# ---------- 4. Недоступность Redis (с действующим токеном) ----------
def _compose(action, service="redis"):
return subprocess.run(
["docker", "compose", "--env-file", ".env", action, service],
capture_output=True, text=True, timeout=60,
)
def _wait_ready(c, timeout=60):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
c.call("GET", "/health/ready", 200)
return
except Failure:
time.sleep(1)
raise Failure("API не вернулся в ready за %d секунд после восстановления зависимости" % timeout)
def test_redis_unavailable(c):
"""Останавливаем Redis: /health/ready → 503, действующий токен не работает.
Важно: используем ЗАРАНЕЕ полученную рабочую сессию, а не заведомо
неправильный Bearer. Иначе 401 мог бы получиться и без обращения к Redis.
После восстановления Redis прежняя сессия снова должна работать.
"""
print(" (проверка недоступности Redis: docker compose stop redis на ~6 секунд)")
# Готовим рабочую сессию ДО остановки Redis.
suffix = uuid.uuid4().hex[:10]
username = "redis_" + suffix
password = "T3st-" + uuid.uuid4().hex
c.call("POST", "/api/v1/users", 201,
body={"username": username, "display_name": "Redis", "password": password},
schema="User")
cred = base64.b64encode((username + ":" + password).encode()).decode()
session = c.call("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": "Basic " + cred},
schema="Session")["json"]
token = session["token"]
# Контроль: до остановки Redis токен рабочий.
me = c.call("GET", "/api/v1/users/me", 200,
headers={"Authorization": "Bearer " + token},
schema="User")["json"]
check(me["username"] == username, "токен должен принадлежать созданному пользователю")
stopped = _compose("stop", "redis")
check(stopped.returncode == 0,
"docker compose stop redis не сработал:\n" + (stopped.stdout + stopped.stderr))
try:
time.sleep(3)
# /health/ready должен стать 503.
ready = c.call("GET", "/health/ready", 503)
check(ready["status"] == 503, "readiness must be 503 without Redis")
# Действующий токен при мёртвом Redis не должен давать доступ:
# сервер не может проверить сессию и обязан ответить 503.
r = c.call("GET", "/api/v1/users/me", (401, 503),
headers={"Authorization": "Bearer " + token})
check(r["status"] == 503,
"запрос с действующим токеном при мёртвом Redis должен быть 503, получено %s" % r["status"])
finally:
# Только восстановление. Никаких return/break/continue внутри finally.
started = _compose("start", "redis")
check(started.returncode == 0,
"docker compose start redis не сработал:\n" + (started.stdout + started.stderr))
# Ждём готовности — УЖЕ ВНЕ finally.
_wait_ready(c, timeout=60)
# Прежний токен снова должен работать: сессия пережила рестарт Redis (AOF).
me2 = c.call("GET", "/api/v1/users/me", 200,
headers={"Authorization": "Bearer " + token},
schema="User")["json"]
check(me2["id"] == me["id"], "прежняя сессия должна снова работать после восстановления Redis")
# ---------- 5. Недоступность PostgreSQL ----------
def test_postgres_unavailable(c):
"""Останавливаем PostgreSQL: /health/ready → 503, действующий токен → 503.
Проверяем:
- /health/ready возвращает 503;
- запрос с действующим токеном возвращает 503 в пределах таймаута;
- анонимный запрос не получает доступ;
- после запуска БД прежний токен работает, ранее записанные данные сохранены.
Восстановление БД выполняется в finally, чтобы не оставлять стенд остановленным.
"""
print(" (проверка недоступности PostgreSQL: docker compose stop postgres на ~6 секунд)")
# Готовим рабочую сессию и сообщение ДО остановки БД.
alice, bob, eve, chat = c.bootstrap()
marker = "pgdown-" + uuid.uuid4().hex
sent = c.message(alice, chat, marker)["json"]
# Контроль: до остановки всё работает.
c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
stopped = _compose("stop", "postgres")
check(stopped.returncode == 0,
"docker compose stop postgres не сработал:\n" + (stopped.stdout + stopped.stderr))
try:
time.sleep(3)
# /health/ready должен стать 503.
ready = c.call("GET", "/health/ready", 503)
check(ready["status"] == 503, "readiness must be 503 without PostgreSQL")
# Запрос с действующим токеном: 503 в пределах таймаута.
t0 = time.monotonic()
r = c.call("GET", "/api/v1/users/me", 503, actor=alice)
elapsed = time.monotonic() - t0
check(r["status"] == 503,
"запрос с действующим токеном при мёртвой БД должен быть 503")
# statement_timeout=5000 + пул timeout=5.0: укладываемся в разумный предел.
check(elapsed < 30, "ответ при мёртвой БД занял %.1f c, ожидался в пределах таймаута" % elapsed)
# Анонимный запрос не получает доступ.
anon = c.call("GET", "/api/v1/users/me", (401, 503))
check(anon["status"] in (401, 503),
"анонимный запрос при мёртвой БД должен быть 401 или 503, получено %s" % anon["status"])
finally:
started = _compose("start", "postgres")
check(started.returncode == 0,
"docker compose start postgres не сработал:\n" + (started.stdout + started.stderr))
# Ждём готовности — УЖЕ ВНЕ finally.
_wait_ready(c, timeout=60)
# Прежний токен работает, ранее записанное сообщение сохранено.
c.call("GET", "/api/v1/users/me", 200, actor=alice, schema="User")
messages = c.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100",
actor=bob, schema="MessagePage")["json"]["items"]
check(any(m["id"] == sent["id"] and m["text"] == marker for m in messages),
"ранее записанное сообщение не найдено после восстановления PostgreSQL")
# ---------- 6. Expiry TTL ----------
def test_short_ttl_expiry(c):
"""TTL=5. Проверяем полный цикл: токен валиден -> истекает -> 401.
Идёт ПОСЛЕДНИМ: при коротком TTL любая долгая подготовка съедает
окно жизни сессии, поэтому соседние тесты работают раньше.
"""
suffix = uuid.uuid4().hex[:10]
username = "ttl_" + suffix
password = "T3st-" + uuid.uuid4().hex
user = c.call("POST", "/api/v1/users", 201,
body={"username": username, "display_name": "TTL", "password": password},
schema="User")["json"]
cred = base64.b64encode((username + ":" + password).encode()).decode()
session = c.call("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": "Basic " + cred},
schema="Session")["json"]
token = session["token"]
# Контроль: сервер выдал короткий TTL, иначе тест бессмыслен.
expires_at = dt.datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
ttl_actual = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
check(3.0 <= ttl_actual <= 10,
"SESSION_TTL_SECONDS не короткий (получено %.1f c). "
"Поставьте, пожалуйста, SESSION_TTL_SECONDS=5 в .env и перезапустите API (команда: docker compose --env-file .env up -d api)." % ttl_actual)
# До истечения токен должен работать.
me = c.call("GET", "/api/v1/users/me", 200,
headers={"Authorization": "Bearer " + token},
schema="User")["json"]
check(me["id"] == user["id"], "token must identify its owner before expiry")
# Ждём гарантированного истечения TTL + запас.
remaining = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
time.sleep(max(remaining, 0.0) + 1.0)
# Истёкший токен — 401.
c.call("GET", "/api/v1/users/me", 401,
headers={"Authorization": "Bearer " + token})
# Второй вход тем же пользователем даёт рабочий токен: истёк именно
# первый токен, а не пользователь/хранилище целиком.
session2 = c.call("POST", "/api/v1/auth/sessions", 201,
headers={"Authorization": "Basic " + cred},
schema="Session")["json"]
c.call("GET", "/api/v1/users/me", 200,
headers={"Authorization": "Bearer " + session2["token"]},
schema="User")
# ---------- main ----------
def main():
args = arguments("Lab2 level 4 checks", configure=_configure)
c = Client(args.base_url, args.ca_file)
# Порядок и режимы:
# --only-expiry — ТОЛЬКО expiry-тест (запускать при SESSION_TTL_SECONDS=5)
# --skip-expiry — все тяжёлые тесты, без expiry (при SESSION_TTL_SECONDS=3600)
# без флагов — сначала тяжёлые, expiry последним (при SESSION_TTL_SECONDS=5
# это сработает только если тяжёлые тесты успевают до истечения TTL,
# поэтому на практике используйте --only-expiry/--skip-expiry)
run_expiry = not args.skip_expiry
run_others = not args.only_expiry
if run_others:
print("=== test_concurrent_registration ===")
test_concurrent_registration(c)
print("PASS: concurrent registration produces exactly one user")
print("=== test_chat_rollback ===")
test_chat_rollback(c)
print("PASS: create_chat rollback leaves no chat and no partial membership")
print("=== test_explain ===")
test_explain(c)
print("PASS: EXPLAIN uses idx_messages_chat_created")
print("=== test_redis_unavailable ===")
test_redis_unavailable(c)
print("PASS: readiness 503 без Redis, действующий токен отвергнут, затем восстановление")
print("=== test_postgres_unavailable ===")
test_postgres_unavailable(c)
print("PASS: readiness 503 без PostgreSQL, данные и сессия сохранены")
if run_expiry:
print("=== test_short_ttl_expiry ===")
test_short_ttl_expiry(c)
print("PASS: session valid before TTL, expires after TTL, 401 on expired token")
print("PASS: all requested lab2 level-4 checks passed")
def _configure(p):
p.add_argument("--only-expiry", action="store_true",
help="запустить только expiry-тест (SESSION_TTL_SECONDS=5)")
p.add_argument("--skip-expiry", action="store_true",
help="запустить всё, кроме expiry (SESSION_TTL_SECONDS=3600)")
if __name__ == "__main__":
run(main)