318 lines
14 KiB
Python
318 lines
14 KiB
Python
#!/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 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."""
|
|
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")
|
|
# 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 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):
|
|
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) |