315 lines
14 KiB
Python
315 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 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) |