Files
mtusi2026lab2/student-tests/test_lab2_level4.py
T
vasyukova 2da4def0ca
Skeleton contracts / contracts (pull_request) Canceled after 0s
* обновила тесты
2026-10-03 01:50:36 +03:00

464 lines
22 KiB
Python

#!/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-слой.
"""
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")
# ---------- 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. Недоступность 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")
# ---------- 4. Недоступность 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")
# ---------- 5. 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 ----------
# ---------- 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_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)