Files
mtusi2026lab6-fork/student-tests/test_storage_idempotency.py

145 lines
6.6 KiB
Python

"""Идемпотентность на уровне хранилища (нужен прямой доступ к PostgreSQL).
* сбой ПОСЛЕ вставки ключа и сообщения внутри транзакции -> не остаётся ни ключа,
ни сообщения, и повтор с тем же ключом создаёт сообщение (5xx не фиксируется);
* 16 потоков с одним ключом -> ровно одна вставка, остальные — повтор;
* истёкший ключ можно занять заново; очистка удаляет только истёкшие строки и
выполняется одной репликой за раз (advisory lock).
Запуск внутри compose-сети (БД наружу не публикуется):
python scripts/ops.py in-network storage
Без DATABASE_URL/DATABASE_URL_FILE тест пропускается.
"""
import hashlib
import os
import sys
import threading
import time
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
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"))
DAY = 86400
class InjectedFailure(RuntimeError):
pass
def fp(text):
return hashlib.sha256(text.encode()).digest()
@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured")
class StorageIdempotencyTests(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
settings = load_settings()
wait_and_migrate(settings)
cls.pool = create_pool(settings)
cls.pool.wait(timeout=10)
cls.storage = Storage(cls.pool)
h = hash_password("Idempotency-test-password")
cls.user = cls.storage.create_user("idm_" + uuid.uuid4().hex[:12], "Idem", h)
cls.chat = cls.storage.create_chat("idem-" + uuid.uuid4().hex[:8], [cls.user.id])
@classmethod
def tearDownClass(cls):
cls.pool.close()
def count(self, sql, params):
with self.pool.connection() as conn:
return conn.execute(sql, params).fetchone()[0]
def keys(self, key):
return self.count("SELECT count(*) FROM idempotency_keys WHERE user_id = %s AND idem_key = %s",
(self.user.id, key))
def test_failure_inside_transaction_stores_nothing(self):
key = "fail-" + uuid.uuid4().hex
text = "сбой " + key
original = self.storage._insert_message
seen = {}
def insert_then_fail(conn, message_id, chat_id, sender_id, body):
original(conn, message_id, chat_id, sender_id, body)
seen["keys"] = conn.execute("SELECT count(*) FROM idempotency_keys WHERE idem_key = %s", (key,)).fetchone()[0]
seen["messages"] = conn.execute("SELECT count(*) FROM messages WHERE id = %s", (message_id,)).fetchone()[0]
raise InjectedFailure("crash after both inserts, before COMMIT")
self.storage._insert_message = insert_then_fail
try:
with self.assertRaises(InjectedFailure):
self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY)
finally:
self.storage._insert_message = original
self.assertEqual((seen["keys"], seen["messages"]), (1, 1), "inserts were visible inside the transaction")
self.assertEqual(self.keys(key), 0)
self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 0)
# Клиент повторяет неподтверждённый запрос с тем же ключом — теперь успешно.
msg, replayed = self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY)
self.assertFalse(replayed)
self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 1)
def test_threads_same_key_single_insert(self):
key = "thr-" + uuid.uuid4().hex
text = "потоки " + key
barrier = threading.Barrier(16)
def call(_):
barrier.wait()
return self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY)
with ThreadPoolExecutor(max_workers=16) as pool:
results = list(pool.map(call, range(16)))
self.assertEqual(sum(1 for _, replayed in results if not replayed), 1)
self.assertEqual(len({m.id for m, _ in results}), 1)
self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 1)
def test_conflict_on_different_body(self):
from src.storage import IdempotencyConflict
key = "cnf-" + uuid.uuid4().hex
self.storage.create_message(self.chat.id, self.user.id, "a", key, fp("a"), DAY)
with self.assertRaises(IdempotencyConflict):
self.storage.create_message(self.chat.id, self.user.id, "b", key, fp("b"), DAY)
def test_expired_key_can_be_reused_and_is_cleaned(self):
key = "exp-" + uuid.uuid4().hex
first, _ = self.storage.create_message(self.chat.id, self.user.id, "старый", key, fp("старый"), 1)
time.sleep(1.2)
# Истёк: другое тело уже не конфликт, создаётся новое сообщение.
second, replayed = self.storage.create_message(self.chat.id, self.user.id, "новый", key, fp("новый"), DAY)
self.assertFalse(replayed)
self.assertNotEqual(first.id, second.id)
self.assertEqual(self.keys(key), 1)
# Очистка удаляет только истёкшие ключи.
k2 = "exp2-" + uuid.uuid4().hex
self.storage.create_message(self.chat.id, self.user.id, "x", k2, fp("x"), 1)
time.sleep(1.2)
while self.storage.delete_expired_idempotency_keys():
pass
self.assertEqual(self.keys(k2), 0)
self.assertEqual(self.keys(key), 1)
def test_cleanup_runs_on_one_replica_at_a_time(self):
from src.storage import IDEMPOTENCY_CLEANUP_LOCK_ID
with self.pool.connection() as conn:
with conn.transaction():
conn.execute("SELECT pg_advisory_xact_lock(%s)", (IDEMPOTENCY_CLEANUP_LOCK_ID,))
self.assertIsNone(self.storage.delete_expired_idempotency_keys())
self.assertIsNotNone(self.storage.delete_expired_idempotency_keys())
if __name__ == "__main__":
unittest.main()