Files
mtusi2026lab3/student-tests/test_cache.py
T
2026-11-02 20:05:33 +03:00

259 lines
12 KiB
Python

"""Кэш сессий в Redis: попадания, TTL, отзыв и недоступность Redis."""
import hashlib
import json
import time
import uuid
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_user_profile_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
@pytest.mark.parametrize("redis_down_at_startup", [False, True])
def test_lost_revocation_survives_api_restart(store, redis_down_at_startup):
"""Старый ключ Redis не даёт читать и писать после потери флага dirty."""
settings = make_settings(cache_retry_seconds=0)
with TestClient(create_app(settings), raise_server_exceptions=False) as first:
person = register_and_login(first, "restart")
chat_reply = first.post(
"/api/v1/chats", json={"title": "Отзыв", "member_ids": [person.id]},
headers=person.headers,
)
assert chat_reply.status_code == 201
chat_id = chat_reply.json()["id"]
cache = first.app.state.cache
stale = store.get(key_for(person))
assert stale is not None and stale != "revoked"
working = cache.client
failed = AsyncRedis.from_url(DEAD_REDIS, socket_connect_timeout=0.2, socket_timeout=0.2)
cache.client = failed
try:
assert first.delete(
"/api/v1/auth/sessions/current", headers=person.headers
).status_code == 204
assert cache.dirty is True
assert store.get(key_for(person)) == stale
assert not run_sql(
"SELECT 1 FROM sessions WHERE token_hash = $1",
hashlib.sha256(person.token.encode()).hexdigest(),
)
finally:
first.portal.call(failed.aclose)
cache.client = working
restarted_settings = replace(settings, cache_url=DEAD_REDIS) if redis_down_at_startup else settings
with TestClient(create_app(restarted_settings), raise_server_exceptions=False) as restarted:
cache = restarted.app.state.cache
assert cache.dirty is False
if redis_down_at_startup:
assert_error(restarted.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
restarted.portal.call(cache.client.aclose)
cache.client = AsyncRedis.from_url(CACHE_URL, decode_responses=True)
assert store.get(key_for(person)) == stale
assert store.pttl(key_for(person)) > 0
assert_error(restarted.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
assert_error(
restarted.post(
f"/api/v1/chats/{chat_id}/messages", json={"text": "Не записывать"},
headers=person.headers,
),
401, "unauthorized",
)
assert_error(
restarted.delete("/api/v1/auth/sessions/current", headers=person.headers),
401, "unauthorized",
)
assert not run_sql("SELECT 1 FROM messages WHERE chat_id = $1", uuid.UUID(chat_id))
assert store.get(key_for(person)) == stale
def test_cached_session_deleted_in_database_is_rejected_immediately(cached, store):
person = register_and_login(cached, "deleted")
assert cached.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())
assert store.pttl(key_for(person)) > 0
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")