587 lines
28 KiB
Python
587 lines
28 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-слой.
|
||
|
||
test_chat_rollback проверяет транзакционную границу create_chat: он
|
||
запускает патч-скрипт ВНУТРИ контейнера API (там есть psycopg и
|
||
DATABASE_URL), monkey-patch-ит psycopg.Cursor.executemany так, чтобы
|
||
INSERT в chat_members упал ПОСЛЕ успешного INSERT в chats. Затем через
|
||
psql проверяется, что ни chat, ни chat_members не сохранились.
|
||
"""
|
||
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")
|
||
|
||
# Имя контейнера API (зафиксировано в compose.yaml container_name).
|
||
API_CONTAINER = os.environ.get("API_CONTAINER", "mtuci-messenger-lab2")
|
||
|
||
|
||
# ---------- 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. Rollback составной операции create_chat ----------
|
||
def test_chat_rollback(c):
|
||
"""Проверяем, что при падении INSERT в chat_members ПОСЛЕ успешного
|
||
INSERT в chats не остаётся ни строки чата, ни частичного членства.
|
||
|
||
Как добиться ошибки именно на вставке участников, а не на предварительной
|
||
проверке unknown_member? Проверка `SELECT id FROM users WHERE id = ANY(...)`
|
||
в postgres.py отсекает неизвестных до INSERT. Значит, нужен сбой именно
|
||
в executemany.
|
||
|
||
Решение: запускаем патч-скрипт ВНУТРИ контейнера API через docker exec —
|
||
там уже установлен psycopg и доступен DATABASE_URL. Скрипт monkey-patch-ит
|
||
psycopg.Cursor.executemany так, чтобы он бросил исключение, и вызывает
|
||
storage.create_chat с двумя реально существующими пользователями.
|
||
Транзакция дойдёт до INSERT в chats, упадёт на executemany и должна
|
||
откатиться.
|
||
|
||
После этого через psql проверяем:
|
||
- в таблице chats нет строки с этим title;
|
||
- в таблице chat_members нет строк с этим chat_id;
|
||
- через API GET /api/v1/chats пользователь не видит этот чат.
|
||
"""
|
||
dsn = _read_dsn()
|
||
|
||
# Готовим двух валидных пользователей через API, чтобы FK был валиден.
|
||
suffix = uuid.uuid4().hex[:10]
|
||
alice_username = "rb_a_" + suffix
|
||
bob_username = "rb_b_" + suffix
|
||
alice_password = "T3st-" + uuid.uuid4().hex
|
||
bob_password = "T3st-" + uuid.uuid4().hex
|
||
alice = c.call("POST", "/api/v1/users", 201,
|
||
body={"username": alice_username, "display_name": "RB-A",
|
||
"password": alice_password},
|
||
schema="User")["json"]
|
||
bob = c.call("POST", "/api/v1/users", 201,
|
||
body={"username": bob_username, "display_name": "RB-B",
|
||
"password": bob_password},
|
||
schema="User")["json"]
|
||
|
||
# Уникальный title, чтобы точно найти строку, если rollback не сработает.
|
||
marker_title = "rollback-chat-" + uuid.uuid4().hex
|
||
|
||
# Скрипт запускается ВНУТРИ контейнера API: там есть psycopg и DATABASE_URL.
|
||
# Патчит executemany так, чтобы он упал после успешного INSERT в chats.
|
||
patch_script = r'''
|
||
import os, sys, psycopg
|
||
from uuid import UUID
|
||
|
||
_orig = psycopg.Cursor.executemany
|
||
def boom(self, *args, **kwargs):
|
||
raise RuntimeError("patched_executemany_failure")
|
||
psycopg.Cursor.executemany = boom
|
||
|
||
sys.path.insert(0, "/app/src")
|
||
from app.storage.postgres import storage
|
||
|
||
try:
|
||
storage.create_chat(os.environ["RB_TITLE"],
|
||
[UUID(os.environ["RB_ALICE"]), UUID(os.environ["RB_BOB"])])
|
||
except RuntimeError as exc:
|
||
if "patched_executemany_failure" in str(exc):
|
||
print("PATCHED_FAILURE_OK"); sys.exit(0)
|
||
raise
|
||
except Exception as exc:
|
||
print("UNEXPECTED:%s:%s" % (type(exc).__name__, exc)); sys.exit(2)
|
||
print("NO_FAILURE"); sys.exit(3)
|
||
'''
|
||
|
||
proc = subprocess.run(
|
||
["docker", "exec",
|
||
"-e", "RB_TITLE=" + marker_title,
|
||
"-e", "RB_ALICE=" + alice["id"],
|
||
"-e", "RB_BOB=" + bob["id"],
|
||
API_CONTAINER,
|
||
"python", "-c", patch_script],
|
||
capture_output=True, text=True, timeout=60,
|
||
)
|
||
out = (proc.stdout + proc.stderr).strip()
|
||
print(" rollback-процесс: exit=%d, out=%r" % (proc.returncode, out[:200]))
|
||
check("PATCHED_FAILURE_OK" in out,
|
||
"не удалось вызвать ошибку именно на executemany: %s" % out)
|
||
|
||
# Проверяем в БД: ни chats, ни chat_members с этим маркером не осталось.
|
||
chats_count = _scalar(
|
||
dsn,
|
||
"SELECT count(*) FROM chats WHERE title = '%s';" % marker_title,
|
||
)
|
||
check(int(chats_count) == 0,
|
||
"rollback не сработал: строка chats с title=%s осталась (%s)" % (marker_title, chats_count))
|
||
|
||
members_count = _scalar(
|
||
dsn,
|
||
"SELECT count(*) FROM chat_members cm "
|
||
"JOIN chats c ON c.id = cm.chat_id "
|
||
"WHERE c.title = '%s';" % marker_title,
|
||
)
|
||
check(int(members_count) == 0,
|
||
"rollback не сработал: остались строки chat_members (%s)" % members_count)
|
||
|
||
# Дополнительно: у пользователя нет чата с таким title через API.
|
||
cred = base64.b64encode((alice_username + ":" + alice_password).encode()).decode()
|
||
session = c.call("POST", "/api/v1/auth/sessions", 201,
|
||
headers={"Authorization": "Basic " + cred},
|
||
schema="Session")["json"]
|
||
listed = c.call("GET", "/api/v1/chats?limit=100",
|
||
headers={"Authorization": "Bearer " + session["token"]},
|
||
schema="ChatPage")["json"]
|
||
check(all(item["title"] != marker_title for item in listed["items"]),
|
||
"чат с маркером rollback виден в списке чатов пользователя")
|
||
|
||
|
||
# ---------- 4. Недоступность 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")
|
||
|
||
|
||
# ---------- 5. Недоступность 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")
|
||
|
||
|
||
# ---------- 6. 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 ----------
|
||
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_chat_rollback ===")
|
||
test_chat_rollback(c)
|
||
print("PASS: create_chat rollback leaves no chat and no partial membership")
|
||
|
||
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) |