Files
mtusi2026lab2/student-tests/test_lab2_level4.py
T

315 lines
14 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.
Перед запуском:
1) в .env выставить SESSION_TTL_SECONDS=5
2) docker compose --env-file .env up -d --force-recreate api
3) docker exec mtusi-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
# ---------- 1. Конкурентная регистрация одинакового username ----------
def test_concurrent_registration(c):
"""Один и тот же username с 8 потоков — ровно одна 201, остальные 409."""
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:
local.call("POST", "/api/v1/users", 201, body=body, schema="User")
with lock:
results.append(201)
except Failure:
with lock:
results.append(409)
with ThreadPoolExecutor(max_workers=8) as pool:
list(pool.map(one, range(8)))
check(results.count(201) == 1, "expected exactly one 201, got %s" % results)
check(results.count(409) == 7, "expected seven 409, got %s" % results)
# ---------- 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")
# Внутри контейнера хост — host.docker.internal, а не localhost.
return dsn.replace("@localhost:", "@host.docker.internal:").replace(
"@127.0.0.1:", "@host.docker.internal:")
def _psql(dsn_in_container: str, sql: str) -> str:
r = subprocess.run(
[
"docker", "run", "--rm",
"--add-host=host.docker.internal:host-gateway",
"postgres:18-alpine",
"psql", dsn_in_container, "-tA", "-c", sql,
],
capture_output=True, text=True, timeout=120,
)
return r.stdout + r.stderr
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",
"--add-host=host.docker.internal:host-gateway",
"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",
"--add-host=host.docker.internal:host-gateway",
"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):
return subprocess.run(
["docker", "compose", "--env-file", ".env", action, "redis"],
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 секунд после старта Redis" % timeout)
def test_redis_unavailable(c):
"""Останавливаем Redis: /health/ready → 503. Возвращаем обратно."""
print(" (проверка недоступности Redis: docker compose stop redis на ~6 секунд)")
stopped = _compose("stop")
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")
# Бизнес-запрос с любым Bearer — 401 (сессию не находим) или 503,
# но точно не 200.
r = c.call("GET", "/api/v1/users/me", (401, 503),
headers={"Authorization": "Bearer " + "x" * 43})
check(r["status"] in (401, 503),
"запрос с недействительным токеном при мёртвом Redis должен быть 401 или 503")
finally:
# Только восстановление. Никаких return/break/continue внутри finally.
started = _compose("start")
check(started.returncode == 0,
"docker compose start redis не сработал:\n" + (started.stdout + started.stderr))
# Ждём готовности — УЖЕ ВНЕ finally.
_wait_ready(c, timeout=60)
# ---------- 4. 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." % 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")
c = Client(args.base_url, args.ca_file)
# Порядок: сначала тяжёлые/долгие тесты, expiry — последним,
# потому что при коротком TTL он «сжигает» сессии.
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_short_ttl_expiry ===")
test_short_ttl_expiry(c)
print("PASS: session valid before TTL, expires after TTL, 401 on expired token")
print("PASS: all lab2 level-4 checks passed")
if __name__ == "__main__":
run(main)