150 lines
6.4 KiB
Python
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)
|