Files
mtusi2026lab2-fork/student-tests/test_cache.py
T
2026-10-23 14:09:32 +03:00

191 lines
8.5 KiB
Python

"""Кэш сессий в Redis: попадания, TTL, отзыв и недоступность Redis."""
import hashlib
import json
import time
from dataclasses import replace
import pytest
import redis
from fastapi.testclient import TestClient
from redis.asyncio import Redis as AsyncRedis
from app.main import create_app
from conftest import CACHE_URL, assert_error, make_settings, register_and_login, run_sql
pytestmark = pytest.mark.skipif(
not CACHE_URL, reason="TEST_CACHE_URL не задан (запускайте тесты в контейнере)"
)
DEAD_REDIS = "redis://127.0.0.1:1/0"
def key_for(person) -> str:
"""Ключ Redis для токена пользователя."""
return "session:" + hashlib.sha256(person.token.encode()).hexdigest()
@pytest.fixture
def store():
"""Синхронный клиент тестовой базы Redis."""
client = redis.Redis.from_url(CACHE_URL, decode_responses=True)
client.flushdb()
yield client
client.close()
@pytest.fixture
def cached(store):
"""Клиент приложения с включённым кэшем."""
with TestClient(create_app(make_settings()), raise_server_exceptions=False) as app_client:
yield app_client
def test_token_check_is_served_from_cache_with_bounded_ttl(cached, store):
person = register_and_login(cached, "cache")
stats = cached.app.state.cache.stats
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert stats["misses"] == 1 and stats["hits"] == 0
ttl_ms = store.pttl(key_for(person))
assert 0 < ttl_ms <= 60_000
value = json.loads(store.get(key_for(person)))
assert set(value) == {"id", "username", "display_name", "created_at"}
assert (value["id"], value["username"]) == (person.id, person.username)
for _ in range(5):
reply = cached.get("/api/v1/users/me", headers=person.headers)
assert reply.status_code == 200 and reply.json() == person.data
assert stats["hits"] == 5
def test_cache_never_stores_raw_tokens_or_passwords(cached, store):
person = register_and_login(cached, "secret")
cached.get("/api/v1/users/me", headers=person.headers)
dump = " ".join(k + "=" + (store.get(k) or "") for k in store.scan_iter())
assert person.token not in dump
assert person.password not in dump
assert "scrypt" not in dump
def test_logout_revokes_cached_session(cached, store):
person = register_and_login(cached, "logout")
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert store.get(key_for(person)) is not None
assert cached.delete("/api/v1/auth/sessions/current", headers=person.headers).status_code == 204
assert store.get(key_for(person)) == "revoked"
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
assert_error(
cached.delete("/api/v1/auth/sessions/current", headers=person.headers), 401, "unauthorized"
)
def test_late_cache_fill_cannot_resurrect_revoked_session(cached, store):
"""Запоздалая запись в кэш не отменяет отзыв сессии."""
person = register_and_login(cached, "race")
cached.delete("/api/v1/auth/sessions/current", headers=person.headers)
token_hash = hashlib.sha256(person.token.encode()).hexdigest()
stale = {k: person.data[k] for k in ("id", "username", "display_name", "created_at")}
cached.portal.call(cached.app.state.cache.put, token_hash, stale, 3600.0)
assert store.get(key_for(person)) == "revoked"
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
def test_flushed_cache_loses_nothing(cached, store):
"""После очистки Redis сессия читается из PostgreSQL."""
person = register_and_login(cached, "flush")
cached.get("/api/v1/users/me", headers=person.headers)
store.flushdb()
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert store.exists(key_for(person))
def test_cache_does_not_extend_short_session():
"""TTL записи в кэше не больше остатка сессии."""
settings = make_settings(session_ttl_seconds=1)
with TestClient(create_app(settings), raise_server_exceptions=False) as short:
person = register_and_login(short, "short")
assert short.get("/api/v1/users/me", headers=person.headers).status_code == 200
time.sleep(2.2)
reply = short.get("/api/v1/users/me", headers=person.headers)
assert_error(reply, 401, "unauthorized")
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
def test_staleness_after_out_of_band_delete_is_bounded_by_cache_ttl(store):
"""Удаление сессии мимо API видно не позже CACHE_TTL_SECONDS."""
settings = make_settings(cache_ttl_seconds=1)
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
person = register_and_login(app_client, "bounded")
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
run_sql("DELETE FROM sessions WHERE token_hash = $1",
hashlib.sha256(person.token.encode()).hexdigest())
time.sleep(1.3)
assert_error(app_client.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
def test_redis_down_requests_bypass_cache_and_stay_fast():
settings = make_settings(cache_url=DEAD_REDIS)
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
assert app_client.get("/health/ready").status_code == 200
alice = register_and_login(app_client, "nocache_a")
bob = register_and_login(app_client, "nocache_b")
started = time.monotonic()
assert app_client.get("/api/v1/users/me", headers=alice.headers).json() == alice.data
chat = app_client.post(
"/api/v1/chats", json={"title": "без кэша", "member_ids": [alice.id, bob.id]},
headers=alice.headers,
)
assert chat.status_code == 201
path = "/api/v1/chats/%s/messages" % chat.json()["id"]
assert app_client.post(path, json={"text": "привет"}, headers=alice.headers).status_code == 201
assert len(app_client.get(path, headers=bob.headers).json()["items"]) == 1
assert time.monotonic() - started < 3
assert app_client.app.state.cache.stats["errors"] >= 1
assert app_client.delete("/api/v1/auth/sessions/current", headers=alice.headers).status_code == 204
assert_error(app_client.get("/api/v1/users/me", headers=alice.headers), 401, "unauthorized")
def test_redis_down_never_trusts_anonymous_or_unknown_tokens():
settings = make_settings(cache_url=DEAD_REDIS)
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
person = register_and_login(app_client, "anon")
for headers in (
{},
{"X-User-Id": person.id},
{"Authorization": "Bearer " + "B" * 43},
{"Authorization": "Basic " + "eDp5"},
):
reply = app_client.get("/api/v1/users/me", headers=headers)
assert_error(reply, 401, "unauthorized")
def test_revocation_lost_while_redis_down_is_flushed_on_recovery(cached, store):
"""Отзыв, потерянный при сбое Redis, приводит к очистке кэша."""
cache = cached.app.state.cache
person = register_and_login(cached, "lost")
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert store.exists(key_for(person))
working = cache.client
cache.client = AsyncRedis.from_url(DEAD_REDIS, socket_connect_timeout=0.2, socket_timeout=0.2)
cache.retry_seconds = 0
assert cached.delete("/api/v1/auth/sessions/current", headers=person.headers).status_code == 204
assert cache.dirty is True
assert store.exists(key_for(person)), "старая запись осталась в Redis -- ровно опасный случай"
cache.client = working
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
assert cache.dirty is False
assert not store.exists(key_for(person))
def test_without_cache_url_cache_is_off():
settings = replace(make_settings(), cache_url="")
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
assert app_client.app.state.cache.enabled is False
person = register_and_login(app_client, "off")
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200