diff --git a/student-tests/test_lab2_level4.py b/student-tests/test_lab2_level4.py index a1dbb85c..fa183a82 100644 --- a/student-tests/test_lab2_level4.py +++ b/student-tests/test_lab2_level4.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Уровень 4 lab2: expiry TTL, конкурентная регистрация, EXPLAIN, недоступность Redis. +"""Уровень 4 lab2: expiry TTL, конкурентная регистрация, EXPLAIN, недоступность Redis/PostgreSQL. Перед запуском: 1) в .env выставить SESSION_TTL_SECONDS=5 @@ -35,7 +35,13 @@ COMPOSE_NETWORK = os.environ.get("COMPOSE_NETWORK", "mtuci2026lab2_default") # ---------- 1. Конкурентная регистрация одинакового username ---------- def test_concurrent_registration(c): - """Один и тот же username с 8 потоков — ровно одна 201, остальные 409.""" + """Один и тот же 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} @@ -45,17 +51,31 @@ def test_concurrent_registration(c): 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) + 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))) - check(results.count(201) == 1, "expected exactly one 201, got %s" % results) - check(results.count(409) == 7, "expected seven 409, got %s" % results) + + 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 на реальной БД ---------- @@ -88,6 +108,20 @@ def _psql(dsn_in_container: str, sql: str) -> str: 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 строк. @@ -190,10 +224,10 @@ END $$; "EXPLAIN не показал использования индекса:\n" + out) -# ---------- 3. Недоступность Redis ---------- -def _compose(action): +# ---------- 3. Недоступность Redis (с действующим токеном) ---------- +def _compose(action, service="redis"): return subprocess.run( - ["docker", "compose", "--env-file", ".env", action, "redis"], + ["docker", "compose", "--env-file", ".env", action, service], capture_output=True, text=True, timeout=60, ) @@ -206,14 +240,38 @@ def _wait_ready(c, timeout=60): return except Failure: time.sleep(1) - raise Failure("API не вернулся в ready за %d секунд после старта Redis" % timeout) + raise Failure("API не вернулся в ready за %d секунд после восстановления зависимости" % timeout) def test_redis_unavailable(c): - """Останавливаем Redis: /health/ready → 503. Возвращаем обратно.""" + """Останавливаем Redis: /health/ready → 503, действующий токен не работает. + + Важно: используем ЗАРАНЕЕ полученную рабочую сессию, а не заведомо + неправильный Bearer. Иначе 401 мог бы получиться и без обращения к Redis. + После восстановления Redis прежняя сессия снова должна работать. + """ print(" (проверка недоступности Redis: docker compose stop redis на ~6 секунд)") - stopped = _compose("stop") + # Готовим рабочую сессию ДО остановки 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)) @@ -222,23 +280,90 @@ def test_redis_unavailable(c): # /health/ready должен стать 503. ready = c.call("GET", "/health/ready", 503) check(ready["status"] == 503, "readiness must be 503 without Redis") - # Бизнес-запрос с любым Bearer — 401 (сессию не находим) или 503, - # но точно не 200. + + # Действующий токен при мёртвом Redis не должен давать доступ: + # сервер не может проверить сессию и обязан ответить 503. r = c.call("GET", "/api/v1/users/me", (401, 503), - headers={"Authorization": "Bearer " + "x" * 43}) - check(r["status"] in (401, 503), - "запрос с недействительным токеном при мёртвом Redis должен быть 401 или 503") + headers={"Authorization": "Bearer " + token}) + check(r["status"] == 503, + "запрос с действующим токеном при мёртвом Redis должен быть 503, получено %s" % r["status"]) finally: # Только восстановление. Никаких return/break/continue внутри finally. - started = _compose("start") + 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") -# ---------- 4. Expiry TTL ---------- + +# ---------- 4. Недоступность 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") + + +# ---------- 5. Expiry TTL ---------- def test_short_ttl_expiry(c): """TTL=5. Проверяем полный цикл: токен валиден -> истекает -> 401. @@ -288,30 +413,51 @@ def test_short_ttl_expiry(c): schema="User") +# ---------- main ---------- # ---------- main ---------- def main(): - args = arguments("Lab2 level 4 checks") + args = arguments("Lab2 level 4 checks", configure=_configure) 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") + # Порядок и режимы: + # --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 - print("=== test_explain ===") - test_explain(c) - print("PASS: EXPLAIN uses idx_messages_chat_created") + if run_others: + print("=== test_concurrent_registration ===") + test_concurrent_registration(c) + print("PASS: concurrent registration produces exactly one user") - print("=== test_redis_unavailable ===") - test_redis_unavailable(c) - print("PASS: readiness 503 без Redis, затем восстановление") + print("=== test_explain ===") + test_explain(c) + print("PASS: EXPLAIN uses idx_messages_chat_created") - print("=== test_short_ttl_expiry ===") - test_short_ttl_expiry(c) - print("PASS: session valid before TTL, expires after TTL, 401 on expired token") + print("=== test_redis_unavailable ===") + test_redis_unavailable(c) + print("PASS: readiness 503 без Redis, действующий токен отвергнут, затем восстановление") - print("PASS: all lab2 level-4 checks passed") + 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__":