259 lines
12 KiB
Python
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")
|