"""Кэш сессий в 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")