#!/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)