"""Отзыв сессии при сбое инвалидации кэша (регрессия замечания ревью №1). Сценарий ревью: прогретый кэш -> связь API с Redis разорвана -> logout (204) -> связь восстановлена с ТЕМ ЖЕ Redis, без его рестарта, положительная запись отозванного токена ещё жива. Ожидание: токен отклоняется сразу, а не через SESSION_CACHE_TTL_SECONDS. Redis здесь заменён управляемой заглушкой с тем же интерфейсом, что и SessionCache (get/put/revoke): «разрыв» = операции падают, но данные заглушки сохраняются — ровно как у живого Redis за сетевым разрывом. PostgreSQL — настоящая (нужен DATABASE_URL/DATABASE_URL_FILE, иначе тест пропускается): make test-storage """ import os import sys import time import unittest import uuid from datetime import datetime, timezone from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parents[1])) HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE")) class PartitionableCache: """Кэш, который «помнит» данные во время разрыва, но недоступен для API.""" def __init__(self): self.data = {} self.partitioned = False def get(self, digest): from src.sessions import REVOKED if self.partitioned: return None value = self.data.get(digest) if value is None: return None if value == REVOKED: return REVOKED user, expires_at = value return (user, expires_at) if expires_at > datetime.now(timezone.utc) else None def put(self, digest, user, expires_at): if not self.partitioned: self.data.setdefault(digest, (user, expires_at)) # SET NX def revoke(self, digest): from src.sessions import REVOKED if self.partitioned: return False self.data[digest] = REVOKED return True @unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured") class SessionRevocationCacheTests(unittest.TestCase): @classmethod def setUpClass(cls): from src.config import load_settings from src.db import create_pool, wait_and_migrate from src.security import hash_password from src.storage import Storage cls.settings = load_settings() wait_and_migrate(cls.settings) cls.pool = create_pool(cls.settings) cls.pool.wait(timeout=10) cls.storage = Storage(cls.pool) cls.user = cls.storage.create_user("rvk_" + uuid.uuid4().hex[:12], "Revoke", hash_password("Revoke-test-password")) @classmethod def tearDownClass(cls): cls.pool.close() def service(self, cache): from src.sessions import SessionService return SessionService(self.storage, cache, self.settings) def pending(self, digest): with self.pool.connection() as conn: return conn.execute("SELECT count(*) FROM session_cache_invalidations WHERE token_hash = %s", (digest,)).fetchone()[0] def warm(self, svc, cache, token): from src.security import token_digest self.assertEqual(svc.resolve(token).id, self.user.id) self.assertIsInstance(cache.data.get(token_digest(token)), tuple, "cache was not warmed") def test_revoked_token_rejected_after_partition_heals(self): from src.security import token_digest cache = PartitionableCache() svc = self.service(cache) token, _ = svc.create(self.user) digest = token_digest(token) self.warm(svc, cache, token) cache.partitioned = True self.assertTrue(svc.revoke(token), "logout must succeed (PostgreSQL is the source of truth)") self.assertIsInstance(cache.data[digest], tuple, "precondition: stale positive entry survived") self.assertEqual(self.pending(digest), 1, "invalidation debt must be committed with revoked_at") self.assertIsNone(svc.resolve(token), "during partition") cache.partitioned = False # тот же «Redis», данные не потеряны self.assertIsNone(svc.resolve(token), "immediately after partition heals") time.sleep(svc.RECHECK_SECONDS + 0.1) self.assertIsNone(svc.resolve(token), "after reconciliation") self.assertEqual(cache.data[digest], "revoked", "reconciliation must write the tombstone") self.assertEqual(self.pending(digest), 0, "debt must be cleared after the tombstone") # После погашения долга кэшу снова доверяют: другой токен обслуживается из кэша. other, _ = svc.create(self.user) self.warm(svc, cache, other) def test_debt_survives_api_restart(self): """Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу.""" from src.security import token_digest cache = PartitionableCache() svc = self.service(cache) token, _ = svc.create(self.user) self.warm(svc, cache, token) cache.partitioned = True self.assertTrue(svc.revoke(token)) del svc # «рестарт API»: состояние процесса потеряно cache.partitioned = False restarted = self.service(cache) self.assertIsNone(restarted.resolve(token)) self.assertEqual(cache.data[token_digest(token)], "revoked") def test_normal_logout_leaves_no_debt(self): from src.security import token_digest cache = PartitionableCache() svc = self.service(cache) token, _ = svc.create(self.user) self.warm(svc, cache, token) self.assertTrue(svc.revoke(token)) self.assertEqual(cache.data[token_digest(token)], "revoked") self.assertEqual(self.pending(token_digest(token)), 0) self.assertIsNone(svc.resolve(token)) self.assertFalse(svc.revoke(token), "second logout must fail") if __name__ == "__main__": unittest.main(verbosity=2)