Files
mtusi2026lab2/student-tests/test_session_cache.py
T
vest1ter ac1317d22e
Skeleton contracts / contracts (pull_request) Canceled after 0s
ЛР2 на 5: Redis-кэш сессий, отказоустойчивость, трек 2 (индексы и восстановление)
Уровень 4:
- Redis как кэш сессий (cache-aside, источник истины — PostgreSQL): TTL <= остатка сессии,
  метка revoked при logout + SET NX против гонки, при отказе Redis — работа через базу
  и фоновая проверка доступности
- тесты: гонка регистрации, откат посреди транзакции, недоступность БД и Redis (44 теста)
- EXPLAIN (ANALYZE, BUFFERS) на 22 000 сообщений, history_query общий для API и скрипта
- эксперименты отказа Redis/PostgreSQL под нагрузкой; dns_opt у API, чтобы отказ БД
  давал быстрый 503, а не зависание на поиске имени остановленного контейнера

Уровень 5, трек 2:
- 105 000 сообщений в неравномерных чатах, 4 варианта индекса + OFFSET против keyset,
  стоимость записи (время, WAL), два независимых прогона
- pg_dump -> pg_restore в новый контейнер -> сверка md5 всех таблиц и выборки сообщений,
  RTO 14 с, демонстрация RPO
2026-10-29 15:42:37 +03:00

143 lines
7.3 KiB
Python

import json
import time
import pytest
import api.dependencies
from conftest import PASSWORD, assert_error, bearer, login
from core.config import settings
from core.db import SessionLocal
from core.redis_client import redis_client
from database_functions.sessions_cache import REVOKED, cache_key, store_session
from database_functions.sessions_functions import get_active_session
from utils.security import token_hash
@pytest.fixture
def redis():
"""Прямой доступ к Redis для проверок; тесты кэша требуют запущенного Redis."""
client = redis_client.run(lambda r: r)
assert client is not None and client.ping(), "Redis не запущен: docker compose up -d redis"
return client
@pytest.fixture
def no_database_lookup(monkeypatch):
"""Если запрос пойдёт за сессией в PostgreSQL, тест упадёт."""
def forbidden(*args, **kwargs):
raise AssertionError("сессия читалась из PostgreSQL, а должна была из кэша")
monkeypatch.setattr(api.dependencies, "get_active_session", forbidden)
@pytest.fixture
def count_database_lookups(monkeypatch):
calls = []
def counting(db, digest):
calls.append(digest)
return get_active_session(db, digest)
monkeypatch.setattr(api.dependencies, "get_active_session", counting)
return calls
def test_login_puts_session_into_cache_without_secrets(client, alice, redis):
key = cache_key(token_hash(alice["token"]))
raw = redis.get(key)
assert raw is not None
data = json.loads(raw)
assert data["user_id"] == alice["id"] and data["username"] == "alice"
# Ни токена, ни хеша пароля в кэше.
assert alice["token"] not in raw and "argon2" not in raw and "password" not in raw
# Запись не переживёт ни сессию, ни верхнюю границу кэша.
assert 0 < redis.ttl(key) <= min(settings.jwt.session_ttl_seconds, settings.redis.max_ttl_seconds)
def test_cached_session_is_served_without_database(client, alice, redis, no_database_lookup):
response = client.get("/api/v1/users/me", headers=alice["auth"])
assert response.status_code == 200
assert response.json() == {k: alice[k] for k in ("id", "username", "display_name", "created_at")}
def test_cache_miss_reads_database_once_and_fills_cache(client, alice, redis, count_database_lookups):
redis.flushdb() # например, Redis перезапустили
for _ in range(3):
assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200
assert len(count_database_lookups) == 1 # первый запрос — из базы, дальше из кэша
assert redis.get(cache_key(token_hash(alice["token"]))) is not None
def test_logout_revokes_cached_session(client, alice, redis):
assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200
assert client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]).status_code == 204
key = cache_key(token_hash(alice["token"]))
assert redis.get(key) == REVOKED
assert_error(client.get("/api/v1/users/me", headers=alice["auth"]), 401, "unauthorized")
def test_slow_reader_cannot_resurrect_session_after_logout(client, alice, redis):
digest = token_hash(alice["token"])
# «Медленный» запрос успел прочитать сессию из базы до logout...
with SessionLocal() as db:
stale = get_active_session(db, digest)
user, expires_at = stale.user, stale.expires_at
assert client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]).status_code == 204
# ...и пытается положить её в кэш уже после logout: SET NX не перезаписывает метку отзыва.
assert store_session(digest, user, expires_at) is False
assert_error(client.get("/api/v1/users/me", headers=alice["auth"]), 401, "unauthorized")
def test_revoked_token_from_database_is_not_cached(client, alice, redis):
other = login(client, "alice")["token"]
redis.flushdb()
client.delete("/api/v1/auth/sessions/current", headers=bearer(other))
redis.flushdb()
# Отозванный токен с верной подписью: в базе его нет, кэш не должен его запомнить.
assert_error(client.get("/api/v1/users/me", headers=bearer(other)), 401, "unauthorized")
assert redis.get(cache_key(token_hash(other))) is None
@pytest.fixture
def redis_down(monkeypatch):
"""Redis «упал»: подключение идёт на закрытый порт."""
monkeypatch.setattr(settings.redis, "port", 1)
redis_client.reset()
def test_redis_down_falls_back_to_database(client, redis_down):
client.post("/api/v1/users", json={"username": "dora", "display_name": "D", "password": PASSWORD})
token = login(client, "dora")["token"] # вход работает без кэша
headers = bearer(token)
assert client.get("/api/v1/users/me", headers=headers).json()["username"] == "dora"
assert client.delete("/api/v1/auth/sessions/current", headers=headers).status_code == 204
# Отзыв работает через базу, аноним и отозванный токен не проходят.
assert_error(client.get("/api/v1/users/me", headers=headers), 401, "unauthorized")
assert_error(client.get("/api/v1/users/me"), 401, "unauthorized")
def test_redis_down_does_not_slow_every_request(client, alice, redis_down, count_database_lookups):
started = time.monotonic()
for _ in range(10):
assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200
# Таймаут Redis (0.25 с) платится максимум один раз; дальше запросы Redis не трогают,
# доступность проверяет фоновый поток.
assert time.monotonic() - started < 10 * settings.redis.timeout_seconds
assert len(count_database_lookups) == 10
def test_cache_comes_back_after_redis_recovers(client, alice, redis, monkeypatch, count_database_lookups):
monkeypatch.setattr(settings.redis, "retry_after_seconds", 0.2)
real_port = settings.redis.port
monkeypatch.setattr(settings.redis, "port", 1) # Redis «упал»
redis_client.reset()
assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200
monkeypatch.setattr(settings.redis, "port", real_port) # Redis «поднялся»
deadline = time.monotonic() + 3
while redis_client.run(lambda r: r.ping()) is None: # фоновая проверка включит кэш сама
assert time.monotonic() < deadline, "кэш не восстановился после возврата Redis"
time.sleep(0.05)
for _ in range(3):
assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200
# Из базы читал только запрос во время отказа; после возврата Redis — снова из кэша
# (запись положена при входе и в «упавшем» по настройкам, но живом Redis сохранилась).
assert len(count_database_lookups) == 1