diff --git a/student-tests/failures/stand.py b/student-tests/failures/stand.py new file mode 100644 index 0000000..44092c3 --- /dev/null +++ b/student-tests/failures/stand.py @@ -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) diff --git a/student-tests/failures/test_dependencies.py b/student-tests/failures/test_dependencies.py new file mode 100644 index 0000000..ef222a6 --- /dev/null +++ b/student-tests/failures/test_dependencies.py @@ -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() diff --git a/student-tests/failures/test_expiry.py b/student-tests/failures/test_expiry.py new file mode 100644 index 0000000..c826b69 --- /dev/null +++ b/student-tests/failures/test_expiry.py @@ -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() diff --git a/student-tests/failures/test_transactions.py b/student-tests/failures/test_transactions.py new file mode 100644 index 0000000..466e015 --- /dev/null +++ b/student-tests/failures/test_transactions.py @@ -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()