"""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/ 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()