forked from mtusi2026/mtusi2026lab2
Гонка регистрации (ровно 1x201 + 7x409, одна строка), rollback после первого INSERT, повтор миграций, 10x10 сообщений, отказ/пауза PostgreSQL и Valkey с действующим токеном (503 в пределах дедлайна, восстановление в finally), lock_timeout, logout при отказе Valkey, короткий TTL, SESSION_STORE=postgres, EXPLAIN поздней страницы при generic plan. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
227 lines
9.7 KiB
Python
227 lines
9.7 KiB
Python
"""Shared helpers for the student tests.
|
|
|
|
* `unit/` — pure functions (validation, cursor, auth headers, Argon2id); no services.
|
|
* `test_*` in this folder — marker `stack`: black-box HTTP against the running compose
|
|
stand (BASE_URL, default http://127.0.0.1:8080) plus `docker compose` for database
|
|
checks (psql inside the postgres container) and failure injection. Every failure
|
|
test restores the stopped/paused service in `finally`.
|
|
|
|
python -m pytest student-tests # everything (stand must be up)
|
|
python -m pytest student-tests -m "not stack" # unit only
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import contextlib
|
|
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import uuid
|
|
from pathlib import Path
|
|
|
|
import httpx2 as httpx
|
|
import pytest
|
|
from jsonschema import Draft202012Validator
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(ROOT / "src"))
|
|
|
|
SPEC = json.loads((ROOT / "contracts" / "openapi.json").read_text(encoding="utf-8"))
|
|
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
|
|
PASSWORD = "Test-password-Ω-12345" # synthetic; 12+ code points, non-ASCII on purpose
|
|
|
|
|
|
def pytest_configure(config):
|
|
config.addinivalue_line("markers", "stack: needs the running compose stand (docker compose up -d --wait)")
|
|
|
|
|
|
def schema_errors(value, name: str) -> list[str]:
|
|
"""Validate against components/schemas/<name> of the course contract (JSON Schema 2020-12)."""
|
|
schema = {"$ref": f"#/components/schemas/{name}", "components": SPEC["components"]}
|
|
validator = Draft202012Validator(schema, format_checker=Draft202012Validator.FORMAT_CHECKER)
|
|
return [e.message for e in validator.iter_errors(value)]
|
|
|
|
|
|
def basic(username: str, password: str) -> str:
|
|
return "Basic " + base64.b64encode(f"{username}:{password}".encode()).decode()
|
|
|
|
|
|
# ------------------------------------------------------------------ docker / psql
|
|
def compose(*args: str, check: bool = True, timeout: float = 120) -> subprocess.CompletedProcess:
|
|
return subprocess.run(["docker", "compose", *args], cwd=ROOT, capture_output=True, text=True,
|
|
encoding="utf-8", check=check, timeout=timeout)
|
|
|
|
|
|
def psql(sql: str) -> str:
|
|
"""Run SQL inside the postgres container (no DB port is published) and return unaligned output."""
|
|
result = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger",
|
|
"-At", "-v", "ON_ERROR_STOP=1", "-c", sql)
|
|
return result.stdout.strip()
|
|
|
|
|
|
def wait_ready(timeout: float = 90) -> None:
|
|
deadline = time.monotonic() + timeout
|
|
while time.monotonic() < deadline:
|
|
try:
|
|
if httpx.get(BASE_URL + "/health/ready", timeout=2).status_code == 200:
|
|
return
|
|
except httpx.HTTPError:
|
|
pass
|
|
time.sleep(0.3)
|
|
raise AssertionError("stand did not become ready")
|
|
|
|
|
|
def wait_healthy(*services: str, timeout: float = 120) -> None:
|
|
"""Poll Docker health until every service is healthy again. `compose up --wait` is not used:
|
|
it gives up at once on a container that was marked unhealthy while paused."""
|
|
deadline = time.monotonic() + timeout
|
|
pending = set(services)
|
|
while pending and time.monotonic() < deadline:
|
|
for service in list(pending):
|
|
ids = compose("ps", "-q", service, check=False).stdout.split()
|
|
if ids:
|
|
state = subprocess.run(["docker", "inspect", "-f", "{{.State.Health.Status}}", ids[0]],
|
|
capture_output=True, text=True).stdout.strip()
|
|
if state == "healthy":
|
|
pending.discard(service)
|
|
time.sleep(0.5)
|
|
assert not pending, f"not healthy: {pending}"
|
|
|
|
|
|
def restart_services(*services: str) -> None:
|
|
compose("restart", *services)
|
|
wait_healthy(*services)
|
|
wait_ready()
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def service_down(service: str, how: str = "stop"):
|
|
"""Stop or pause a compose service; ALWAYS bring it back and wait for readiness."""
|
|
assert how in {"stop", "pause"}
|
|
compose(how, service)
|
|
try:
|
|
yield
|
|
finally:
|
|
compose("unpause" if how == "pause" else "start", service)
|
|
wait_healthy(service)
|
|
wait_ready()
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def api_with_env(**overrides: str):
|
|
"""Recreate the api container with environment overrides (e.g. SESSION_TTL_SECONDS=2),
|
|
then ALWAYS recreate it with the normal configuration."""
|
|
env = {**os.environ, **overrides}
|
|
subprocess.run(["docker", "compose", "up", "-d", "--wait", "api"], cwd=ROOT, env=env,
|
|
capture_output=True, text=True, check=True, timeout=180)
|
|
wait_ready()
|
|
try:
|
|
yield
|
|
finally:
|
|
clean = {k: v for k, v in os.environ.items() if k not in overrides}
|
|
subprocess.run(["docker", "compose", "up", "-d", "--wait", "api"], cwd=ROOT, env=clean,
|
|
capture_output=True, text=True, check=True, timeout=180)
|
|
wait_ready()
|
|
|
|
|
|
def api_env(name: str) -> str:
|
|
"""Current value of an environment variable inside the running api container."""
|
|
return compose("exec", "-T", "api", "printenv", name).stdout.strip()
|
|
|
|
|
|
# ------------------------------------------------------------------ HTTP
|
|
class Api:
|
|
"""HTTP helper that checks the invariants every response must satisfy."""
|
|
|
|
def __init__(self, base_url: str = BASE_URL):
|
|
self.client = httpx.Client(base_url=base_url, timeout=15)
|
|
|
|
def call(self, method: str, path: str, expected: int | tuple[int, ...], *, token: str | None = None,
|
|
json_body=None, raw: bytes | None = None, headers: dict | None = None, schema: str | None = None):
|
|
h = dict(headers or {})
|
|
if token is not None:
|
|
h["Authorization"] = "Bearer " + token
|
|
if json_body is not None:
|
|
raw = json.dumps(json_body, ensure_ascii=False).encode("utf-8")
|
|
h.setdefault("Content-Type", "application/json")
|
|
response = self.client.request(method, path, content=raw, headers=h)
|
|
allowed = (expected,) if isinstance(expected, int) else expected
|
|
assert response.status_code in allowed, (method, path, response.status_code, response.text[:300])
|
|
request_id = response.headers.get("x-request-id")
|
|
assert request_id, "every response must carry X-Request-Id"
|
|
if response.status_code >= 400:
|
|
body = response.json()
|
|
assert schema_errors(body, "Error") == [], response.text
|
|
assert body["error"]["request_id"] == request_id
|
|
assert "Traceback" not in response.text and "psycopg" not in response.text
|
|
if response.status_code == 401:
|
|
challenge = "basic" if path == "/api/v1/auth/sessions" else "bearer"
|
|
assert response.headers.get("www-authenticate", "").lower().startswith(challenge)
|
|
elif schema:
|
|
assert schema_errors(response.json(), schema) == [], response.text
|
|
return response
|
|
|
|
def register(self, label: str = "u", *, password: str = PASSWORD, display_name: str | None = None) -> dict:
|
|
username = f"{label}_{uuid.uuid4().hex[:12]}"[:32]
|
|
body = {"username": username, "display_name": display_name or f"Студент {label}", "password": password}
|
|
user = self.call("POST", "/api/v1/users", 201, json_body=body, schema="User").json()
|
|
return {"id": user["id"], "user": user, "username": username, "password": password}
|
|
|
|
def login(self, actor: dict) -> str:
|
|
session = self.call("POST", "/api/v1/auth/sessions", 201,
|
|
headers={"Authorization": basic(actor["username"], actor["password"])},
|
|
schema="Session").json()
|
|
assert session["user"] == actor["user"] and session["token_type"] == "Bearer"
|
|
return session["token"]
|
|
|
|
def user(self, label: str = "u", **kwargs) -> dict:
|
|
actor = self.register(label, **kwargs)
|
|
actor["token"] = self.login(actor)
|
|
return actor
|
|
|
|
def chat(self, owner: dict, *members: dict, title: str = "Тестовый чат") -> dict:
|
|
ids = [owner["id"], *(m["id"] for m in members)]
|
|
return self.call("POST", "/api/v1/chats", 201, token=owner["token"],
|
|
json_body={"title": title, "member_ids": ids}, schema="Chat").json()
|
|
|
|
def send(self, actor: dict, chat: dict, text: str) -> dict:
|
|
return self.call("POST", f"/api/v1/chats/{chat['id']}/messages", 201, token=actor["token"],
|
|
json_body={"text": text}, schema="Message").json()
|
|
|
|
def history(self, actor: dict, chat: dict, limit: int) -> tuple[list[dict], int]:
|
|
"""Walk all pages; returns (items, number_of_pages)."""
|
|
items, pages, cursor = [], 0, None
|
|
while True:
|
|
query = f"?limit={limit}" + (f"&cursor={cursor}" if cursor else "")
|
|
page = self.call("GET", f"/api/v1/chats/{chat['id']}/messages{query}", 200,
|
|
token=actor["token"], schema="MessagePage").json()
|
|
pages += 1
|
|
items.extend(page["items"])
|
|
cursor = page["next_cursor"]
|
|
if cursor is None:
|
|
return items, pages
|
|
assert len(page["items"]) == limit, "a non-final page must be full"
|
|
assert len(items) < 100_000, "cursor loop"
|
|
|
|
|
|
def _stand_is_up() -> bool:
|
|
try:
|
|
return httpx.get(BASE_URL + "/health/ready", timeout=3).status_code == 200
|
|
except httpx.HTTPError:
|
|
return False
|
|
|
|
|
|
def pytest_collection_modifyitems(config, items):
|
|
if any("stack" in item.keywords for item in items) and not _stand_is_up():
|
|
skip = pytest.mark.skip(reason=f"stand is not running at {BASE_URL}: docker compose up -d --wait")
|
|
for item in items:
|
|
if "stack" in item.keywords:
|
|
item.add_marker(skip)
|
|
|
|
|
|
@pytest.fixture(scope="session")
|
|
def api() -> Api:
|
|
return Api()
|