forked from mtusi2026/mtusi2026lab4
148 lines
5.5 KiB
Python
148 lines
5.5 KiB
Python
#!/usr/bin/env python3
|
|
"""Проверка недоступности Redis и PostgreSQL.
|
|
|
|
Управление контейнерами — через скрипты scripts/stop-*.sh / start-*.sh,
|
|
чтобы тест не зависел от Docker напрямую.
|
|
"""
|
|
import argparse
|
|
import base64
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import unittest
|
|
import urllib.error
|
|
import urllib.request
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
_parser = argparse.ArgumentParser(description="Dependency failure tests")
|
|
_parser.add_argument("--base-url", default=None)
|
|
_parser.add_argument("--stop-redis", default="scripts/stop-redis.sh")
|
|
_parser.add_argument("--start-redis", default="scripts/start-redis.sh")
|
|
_parser.add_argument("--stop-postgres", default="scripts/stop-postgres.sh")
|
|
_parser.add_argument("--start-postgres", default="scripts/start-postgres.sh")
|
|
_args, _unknown = _parser.parse_known_args()
|
|
sys.argv = [sys.argv[0]] + _unknown
|
|
|
|
BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/")
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
|
|
|
|
def _script_command(full: Path) -> list[str]:
|
|
"""Windows не умеет запускать .sh напрямую — вызываем через sh (Git Bash/WSL)."""
|
|
if os.name == "nt":
|
|
sh = shutil.which("sh") or shutil.which("bash")
|
|
if not sh:
|
|
raise unittest.SkipTest(
|
|
"sh/bash not found in PATH; install Git for Windows or run under WSL"
|
|
)
|
|
return [sh, str(full)]
|
|
return [str(full)]
|
|
|
|
|
|
def run_script(path):
|
|
full = (ROOT / path).resolve()
|
|
if not full.is_file():
|
|
raise unittest.SkipTest("script not found: " + str(full))
|
|
cmd = _script_command(full)
|
|
proc = subprocess.run(cmd, cwd=str(ROOT), capture_output=True, timeout=120)
|
|
if proc.returncode != 0:
|
|
raise AssertionError(
|
|
"script failed: " + path + " rc=" + str(proc.returncode)
|
|
+ " stderr=" + proc.stderr.decode("utf-8", "replace")[:500]
|
|
)
|
|
|
|
|
|
def request(method, path, body=None, token=None, basic=None):
|
|
headers = {"Accept": "application/json"}
|
|
if token:
|
|
headers["Authorization"] = "Bearer " + token
|
|
if basic:
|
|
headers["Authorization"] = "Basic " + basic
|
|
data = None
|
|
if body is not None:
|
|
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
|
headers["Content-Type"] = "application/json"
|
|
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=10) as resp:
|
|
payload = resp.read()
|
|
return resp.status, json.loads(payload) if payload else None
|
|
except urllib.error.HTTPError as err:
|
|
payload = err.read()
|
|
return err.code, json.loads(payload) if payload else None
|
|
|
|
|
|
def make_user(label):
|
|
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
|
|
password = "T3st-" + uuid.uuid4().hex
|
|
status, user = request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
{"username": username, "display_name": "Dep " + label, "password": password},
|
|
)
|
|
assert status == 201, (status, user)
|
|
basic = base64.b64encode((username + ":" + password).encode()).decode()
|
|
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
|
|
assert status == 201, (status, session)
|
|
return {"user": user, "token": session["token"]}
|
|
|
|
|
|
def wait_ready(timeout=60):
|
|
deadline = time.monotonic() + timeout
|
|
while time.monotonic() < deadline:
|
|
try:
|
|
status, _ = request("GET", "/health/ready")
|
|
if status == 200:
|
|
return
|
|
except Exception:
|
|
pass
|
|
time.sleep(0.5)
|
|
raise AssertionError("API did not become ready within " + str(timeout) + "s")
|
|
|
|
|
|
class DependencyFailureTests(unittest.TestCase):
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.alice = make_user("alice")
|
|
|
|
def test_redis_down_falls_back_to_db(self):
|
|
run_script(_args.stop_redis)
|
|
try:
|
|
# Валидный токен продолжает работать (fallback на БД).
|
|
status, body = request("GET", "/api/v1/users/me", token=self.alice["token"])
|
|
self.assertEqual(status, 200, body)
|
|
self.assertEqual(body["id"], self.alice["user"]["id"])
|
|
# Аноним не принимается.
|
|
status, body = request("GET", "/api/v1/users/me")
|
|
self.assertEqual(status, 401)
|
|
self.assertEqual(body["error"]["code"], "unauthorized")
|
|
# /health/ready не зависит от Redis.
|
|
status, _ = request("GET", "/health/ready")
|
|
self.assertEqual(status, 200)
|
|
finally:
|
|
run_script(_args.start_redis)
|
|
wait_ready()
|
|
|
|
def test_postgres_down_returns_503(self):
|
|
run_script(_args.stop_postgres)
|
|
try:
|
|
status, body = request("GET", "/health/ready")
|
|
self.assertEqual(status, 503)
|
|
self.assertEqual(body["error"]["code"], "unavailable")
|
|
# Бизнес-запрос не должен отдавать 200 и не должен раскрывать детали.
|
|
status, body = request("GET", "/api/v1/users/me", token=self.alice["token"])
|
|
self.assertIn(status, (500, 503))
|
|
self.assertIn("error", body)
|
|
self.assertNotIn("psycopg", json.dumps(body).lower())
|
|
finally:
|
|
run_script(_args.start_postgres)
|
|
wait_ready()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main(verbosity=2)
|