Добавить тесты отказов, истечения сессии и транзакций

This commit is contained in:
2026-10-08 18:54:35 +03:00
parent 996a8c5a97
commit ef24bc1635
4 changed files with 234 additions and 0 deletions
+39
View File
@@ -0,0 +1,39 @@
"""Управление стендом для тестов отказов: останавливает и запускает сервисы через docker compose."""
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "student-tests"))
from api import BASE_URL, call # noqa: E402
def compose(*args):
command = ["docker", "compose", "--env-file", ".env", *args]
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
def sql(query):
"""Выполняет запрос через psql внутри контейнера postgres и возвращает вывод без оформления."""
return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-At", "-c", query).strip()
def wait_ready(base_url=BASE_URL, seconds=60):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if call("GET", "/health/ready", base_url=base_url)[0] == 200:
return
except OSError:
pass
time.sleep(0.3)
raise AssertionError("стенд не стал готов за %d секунд" % seconds)
def timed(*args, **kwargs):
"""Как call, но первым элементом возвращает время ответа в секундах."""
started = time.monotonic()
result = call(*args, **kwargs)
return (time.monotonic() - started, *result)
@@ -0,0 +1,76 @@
"""Недоступность Redis и PostgreSQL: ограниченная по времени ошибка 503, анониму доступ не открывается."""
import unittest
from stand import call, compose, timed, wait_ready
from api import basic, history, new_chat, new_user, send, user_body
# таймауты в .env.example: 2 с на Redis, 3 с на ожидание соединения с БД; берём запас
MAX_SECONDS = 6
class DependencyDownTest(unittest.TestCase):
def setUp(self):
wait_ready()
self.user = new_user("dep")
self.chat = new_chat(self.user)
send(self.user, self.chat, "сообщение до отказа")
self.messages = "/api/v1/chats/" + self.chat["id"] + "/messages"
def assert_unavailable(self, result):
elapsed, status, body, headers = result
self.assertEqual(status, 503)
self.assertEqual(body["error"]["code"], "unavailable")
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
self.assertLess(elapsed, MAX_SECONDS)
def test_redis_down(self):
compose("stop", "redis")
self.addCleanup(wait_ready)
self.addCleanup(compose, "start", "redis")
# сессию проверить нечем: запрос с настоящим токеном не выполняется, но и чужим не становится
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
self.assert_unavailable(timed("GET", self.messages, user=self.user))
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user))
# поддельный токен тоже не принимается за действующий
self.assert_unavailable(timed("GET", "/api/v1/users/me", user={"token": "x" * 43}))
# без токена ответ прежний, Redis для него не нужен
self.assertEqual(call("GET", "/api/v1/users/me")[0], 401)
self.assertEqual(call("GET", self.messages)[0], 401)
# новую сессию создать негде
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
headers=basic(self.user["username"], self.user["password"])))
self.assert_unavailable(timed("GET", "/health/ready"))
self.assertEqual(call("GET", "/health/live")[0], 200)
compose("start", "redis")
wait_ready()
# прежний токен снова работает: сессия пережила остановку Redis, а сообщение во время отказа не записалось
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
def test_postgres_down(self):
compose("stop", "postgres")
self.addCleanup(wait_ready)
self.addCleanup(compose, "start", "postgres")
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
self.assert_unavailable(timed("GET", self.messages, user=self.user))
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user))
self.assert_unavailable(timed("POST", "/api/v1/users", user_body()))
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
headers=basic(self.user["username"], self.user["password"])))
# проверка токена идёт в Redis, поэтому аноним по-прежнему получает 401
self.assertEqual(call("GET", "/api/v1/users/me")[0], 401)
self.assert_unavailable(timed("GET", "/health/ready"))
self.assertEqual(call("GET", "/health/live")[0], 200)
compose("start", "postgres")
wait_ready()
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
self.assertEqual(send(self.user, self.chat, "после восстановления")[0], 201)
if __name__ == "__main__":
unittest.main()
+54
View File
@@ -0,0 +1,54 @@
"""Истечение сессии. Проверяется на втором экземпляре API с SESSION_TTL_SECONDS=2 (порт 8081)."""
import datetime
import time
import unittest
from stand import call, compose, wait_ready
from api import login, new_user
SHORT_TTL_URL = "http://localhost:8081"
class SessionExpiryTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
compose("--profile", "test", "up", "-d", "api-short-ttl")
cls.addClassCleanup(compose, "--profile", "test", "rm", "-sf", "api-short-ttl")
wait_ready(SHORT_TTL_URL)
def test_session_expires(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 200)
time.sleep(3)
status, body, headers = call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
# logout с истёкшим токеном тоже 401
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user, base_url=SHORT_TTL_URL)[0], 401)
def test_expires_at_matches_ttl(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
_, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
self.assertTrue(0 < left <= 2.5, left)
def test_requests_do_not_extend_session(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
deadline = time.monotonic() + 3
while time.monotonic() < deadline:
call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
time.sleep(0.2)
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 401)
def test_login_after_expiry(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
time.sleep(3)
status, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
self.assertEqual(status, 201)
self.assertEqual(call("GET", "/api/v1/users/me", user=session, base_url=SHORT_TTL_URL)[0], 200)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,65 @@
"""Проверки на уровне БД: откат составной операции, гонка регистрации, повторный запуск миграций."""
import threading
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
from stand import call, compose, sql, wait_ready
from api import new_user, user_body
class TransactionTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
wait_ready()
cls.alice, cls.bob = new_user("alice"), new_user("bob")
def create_chat(self, title, member_ids):
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)
def test_chat_with_unknown_member_is_rolled_back(self):
title = "rollback-" + uuid.uuid4().hex
# Алиса и Боб существуют, третьего участника нет: вставка чата и двух участников уже выполнена,
# на третьем срабатывает внешний ключ, и транзакция должна откатить всё
status, body, _ = self.create_chat(title, [self.alice["id"], self.bob["id"], str(uuid.uuid4())])
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "0")
self.assertEqual(sql("SELECT count(*) FROM chat_members m LEFT JOIN chats c ON c.id = m.chat_id WHERE c.id IS NULL"), "0")
def test_valid_chat_is_committed_whole(self):
title = "commit-" + uuid.uuid4().hex
status, chat, _ = self.create_chat(title, [self.alice["id"], self.bob["id"]])
self.assertEqual(status, 201)
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "1")
self.assertEqual(sql("SELECT count(*) FROM chat_members WHERE chat_id = '%s'" % chat["id"]), "2")
def test_username_race_creates_one_row(self):
body = user_body(username="race_" + uuid.uuid4().hex[:8])
barrier = threading.Barrier(10)
def register(_):
barrier.wait()
return call("POST", "/api/v1/users", body)[0]
with ThreadPoolExecutor(max_workers=10) as pool:
statuses = sorted(pool.map(register, range(10)))
self.assertEqual(statuses, [201] + [409] * 9)
self.assertEqual(sql("SELECT count(*) FROM users WHERE username = '%s'" % body["username"]), "1")
def test_password_is_stored_as_argon2id_hash(self):
stored = sql("SELECT password_hash FROM users WHERE id = '%s'" % self.alice["id"])
self.assertTrue(stored.startswith("$argon2id$"), stored[:12])
self.assertNotIn(self.alice["password"], stored)
def test_migrations_can_be_repeated(self):
before = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
output = compose("run", "--rm", "migrate")
self.assertIn("уже применена: 0001_init.sql", output)
self.assertEqual(sql("SELECT count(*) FROM schema_migrations"), "1")
after = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
self.assertEqual(before, after)
if __name__ == "__main__":
unittest.main()