Files
mtusi2026lab6-fork/student-tests/test_session_cache.py
T

150 lines
6.4 KiB
Python

"""Отзыв сессии при сбое инвалидации кэша (регрессия замечания ревью №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)