Files
mtusi2026lab2/student-tests/stand.py
T
ArtyomandClaude Opus 5.5 bf8e4e3cd1 Carry over the lab 3 solution
Bring the application, own tests, Dockerfile, toolchain, compose stack,
HAProxy and k6 configuration, migrations, hooks, evidence and level 4
scripts and the CI job from the lab 3 solution commit 61c0c28, merge
the lab 3 Makefile targets into the lab 4 skeleton Makefile without
touching its targets, and append the lab 3 solution variables to the
skeleton .env.example. The package and the application follow the
contract version 1.4.0, and the image and the throwaway test containers
are tagged lab4 so they do not collide with a lab 3 stand on the same
host.

This is the starting point of the lab 4 cycle: lint, own tests and the
offline skeleton check pass before any lab 4 change.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-28 20:17:51 +03:00

133 lines
4.3 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import asyncio
import csv
import os
import subprocess
import time
from base64 import b64encode
from collections.abc import Awaitable, Callable
from pathlib import Path
from typing import Any
from uuid import uuid4
import httpx
from httpx import AsyncClient, Response, TransportError
ROOT = Path(__file__).resolve().parents[1]
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080")
PASSWORD = "Пароль-для-стенда-01"
BASIC = 'Basic realm="messenger", charset="UTF-8"'
BEARER = 'Bearer realm="messenger"'
VALKEY_AUTH = 'REDISCLI_AUTH="$(sed -n "s/^requirepass //p" /run/secrets/valkey.conf)"'
def compose(*args: str, stdin: str | None = None) -> str:
done = subprocess.run(
["docker", "compose", *args],
cwd=ROOT,
check=True,
capture_output=True,
text=True,
input=stdin,
)
return done.stdout.strip()
def psql(sql: str, **variables: str) -> str:
assigned = [item for name, value in variables.items() for item in ("-v", f"{name}={value}")]
command = ["exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-tA"]
return compose(*command, *assigned, stdin=sql)
def valkey(command: str) -> str:
return compose("exec", "-T", "valkey", "sh", "-c", f"{VALKEY_AUTH} valkey-cli {command}")
def started_at(service: str) -> str:
return subprocess.run(
[
"docker",
"inspect",
"--format",
"{{.State.StartedAt}}",
*compose("ps", "-q", service).split(),
],
check=True,
capture_output=True,
text=True,
).stdout.strip()
def inside_replica(path: str) -> int:
replica = compose("ps", "-q", "api").split()[0]
probe = f"import urllib.request as u;print(u.urlopen('http://127.0.0.1:8080{path}').status)"
done = subprocess.run(
["docker", "exec", replica, "python", "-c", probe],
capture_output=True,
text=True,
check=False,
)
return int(done.stdout.strip() or 0)
def lb_up() -> int:
stats = httpx.get(f"http://{compose('port', 'lb', '8404')}/stats;csv", timeout=2).text
rows = csv.DictReader(stats.lstrip("# ").splitlines())
servers = (r for r in rows if r["pxname"] == "api" and r["svname"] != "BACKEND")
return sum(1 for r in servers if r["status"].startswith("UP"))
def basic(username: str, password: str = PASSWORD) -> dict[str, str]:
return {"Authorization": "Basic " + b64encode(f"{username}:{password}".encode()).decode()}
def bearer(token: str) -> dict[str, str]:
return {"Authorization": f"Bearer {token}"}
def new_user(label: str) -> dict[str, str]:
return {
"username": f"u_{label}_{uuid4().hex[:12]}",
"display_name": f"Стенд {label}",
"password": PASSWORD,
}
async def enroll(http: AsyncClient, label: str) -> tuple[dict[str, Any], str]:
body = new_user(label)
created = await http.post("/api/v1/users", json=body)
assert created.status_code == 201, created.text
session = await http.post("/api/v1/auth/sessions", headers=basic(body["username"]))
assert session.status_code == 201, session.text
return created.json(), session.json()["token"]
async def timed(call: Awaitable[Response]) -> tuple[Response, float]:
started = time.perf_counter()
response = await call
return response, time.perf_counter() - started
async def wait_ready(http: AsyncClient, seconds: float = 60) -> float:
started = time.perf_counter()
while time.perf_counter() - started < seconds:
try:
if (await http.get("/health/ready")).status_code == 200:
return time.perf_counter() - started
except TransportError:
pass
await asyncio.sleep(0.25)
raise AssertionError("стенд не вернулся в готовность")
async def waited(condition: Callable[[], bool], seconds: float = 30) -> float:
started = time.perf_counter()
while time.perf_counter() - started < seconds:
if condition():
return time.perf_counter() - started
await asyncio.sleep(0.05)
raise AssertionError("условие не выполнилось за отведённое время")
def report(event: str, response: Response, elapsed: float) -> None:
print(f"{event}: {response.status_code} за {elapsed:.3f} с")