Files
mtusi2026lab5/student-tests/common.py
T

216 lines
9.0 KiB
Python

from __future__ import annotations
"""Общий HTTP-клиент для собственных тестов (только стандартная библиотека)."""
import base64
import json
import urllib.error
import urllib.request
import uuid
PASSWORD = "Test-password-" + uuid.uuid4().hex[:8]
class Api:
def __init__(self, base: str):
self.base = base.rstrip("/")
def raw(self, method, path, data=None, headers=None, timeout=10):
req = urllib.request.Request(self.base + path, data=data, headers=headers or {}, method=method)
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return r.status, r.read(), r.headers
except urllib.error.HTTPError as e:
return e.code, e.read(), e.headers
def call(self, method, path, body=None, token=None, headers=None, timeout=10):
h = dict(headers or {})
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode()
h["Content-Type"] = "application/json"
if token:
h["Authorization"] = "Bearer " + token
# С lab3 POST сообщения требует Idempotency-Key; если тест не задал свой — новый ключ.
if method == "POST" and path.split("?")[0].endswith("/messages"):
h.setdefault("Idempotency-Key", uuid.uuid4().hex)
st, raw, rh = self.raw(method, path, data, h, timeout=timeout)
try:
return st, json.loads(raw or b"null"), rh
except ValueError:
return st, None, rh
def register(self, prefix: str, password: str = PASSWORD) -> dict:
name = (prefix + "_" + uuid.uuid4().hex[:10])[:32]
st, user, _ = self.call("POST", "/api/v1/users",
{"username": name, "display_name": prefix, "password": password})
assert st == 201, f"register {name}: {st} {user}"
user["password"] = password
return user
def login(self, username: str, password: str):
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
st, body, rh = self.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred})
return st, body, rh
def new_user(self, prefix: str) -> dict:
user = self.register(prefix)
st, sess, _ = self.login(user["username"], user["password"])
assert st == 201, f"login: {st}"
user["token"] = sess["token"]
return user
class Report:
def __init__(self):
self.passed = self.failed = 0
def check(self, cond, name):
if cond:
self.passed += 1
print(f" ok - {name}")
else:
self.failed += 1
print(f" FAIL - {name}")
def finish(self):
print(f"\n{self.passed} passed, {self.failed} failed")
raise SystemExit(1 if self.failed else 0)
# ---------------------------------------------------------------- lab4: файлы
import hashlib
import os
import re
import select
import socket
import struct
import subprocess
import zlib
from pathlib import Path
from urllib.parse import urlparse
ROOT = Path(__file__).resolve().parent.parent
FIXTURES = Path(__file__).resolve().parent / "fixtures"
SAMPLE_PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
SAMPLE_JPG = (FIXTURES / "sample.jpg").read_bytes()
COMPOSE = ["docker", "compose", "--env-file", ".env"]
def sha256(data: bytes) -> str:
return hashlib.sha256(data).hexdigest()
def make_png(width: int, height: int, *, noise: bool = False, color_type: int = 2,
rows: bytes | None = None) -> bytes:
"""Синтетический PNG только средствами stdlib.
noise=True — случайные пиксели (почти не сжимаются: так получаем файл нужного размера).
rows — готовые распакованные данные (для «бомб» и битых файлов)."""
channels = {0: 1, 2: 3, 6: 4}[color_type]
if rows is None:
line = width * channels
rows = b"".join(b"\x00" + (os.urandom(line) if noise else bytes(line)) for _ in range(height))
def chunk(kind: bytes, data: bytes) -> bytes:
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
ihdr = struct.pack(">IIBBBBB", width, height, 8, color_type, 0, 0, 0)
return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr)
+ chunk(b"IDAT", zlib.compress(rows, 1 if noise else 9)) + chunk(b"IEND", b""))
def upload(api, token: str, chat_id: str, data: bytes, filename: str = "image.png",
content_type: str = "image/png", headers: dict | None = None, timeout: int = 60):
from urllib.parse import quote
h = {"Authorization": "Bearer " + token, "Content-Type": content_type, **(headers or {})}
path = f"/api/v1/chats/{chat_id}/attachments?filename={quote(filename, safe='')}"
st, raw, rh = api.raw("POST", path, data, h, timeout=timeout)
try:
body = json.loads(raw or b"null")
except ValueError:
body = None
return st, body, rh
def wait_ready(api, token: str, attachment_id: str, seconds: float = 90) -> dict:
"""lab5: upload отвечает 202 queued; ждём, пока worker доведёт до ready/failed."""
import time
deadline = time.monotonic() + seconds
att = {}
while time.monotonic() < deadline:
st, att, _ = api.call("GET", f"/api/v1/attachments/{attachment_id}", token=token)
if st == 200 and att["status"] in ("ready", "failed"):
return att
time.sleep(0.3)
return att or {}
def raw_http(base: str, method: str, path: str, headers: dict, chunks=(), chunked: bool = False,
close_after_send: bool = False, timeout: float = 30):
"""HTTP/1.1 «руками» через сокет — для сценариев, которые urllib не умеет:
заявить Content-Length и не прислать тело, прислать chunked больше лимита,
оборвать загрузку на середине. Пока шлём тело, следим, не ответил ли сервер
раньше (413 до конца тела) — тогда прекращаем отправку и читаем ответ.
Возвращает (status | None, body_bytes)."""
u = urlparse(base)
sock = socket.create_connection((u.hostname, u.port or 80), timeout=timeout)
try:
lines = [f"{method} {path} HTTP/1.1", f"Host: {u.hostname}:{u.port or 80}", "Connection: close"]
lines += [f"{k}: {v}" for k, v in headers.items()]
if chunked:
lines.append("Transfer-Encoding: chunked")
sock.sendall(("\r\n".join(lines) + "\r\n\r\n").encode("latin-1"))
for part in chunks:
ready, _, _ = select.select([sock], [], [], 0)
if ready:
break # сервер уже ответил — дальше не шлём
try:
sock.sendall(f"{len(part):x}\r\n".encode() + part + b"\r\n" if chunked else part)
except (BrokenPipeError, ConnectionResetError):
break
else:
if chunked and not close_after_send:
try:
sock.sendall(b"0\r\n\r\n")
except OSError:
pass
if close_after_send:
return None, b"" # обрыв загрузки: ответ не ждём
data = b""
try:
while True:
piece = sock.recv(65536)
if not piece:
break
data += piece
except (ConnectionResetError, socket.timeout):
pass
finally:
sock.close()
m = re.match(rb"HTTP/1\.[01] (\d{3})", data)
return (int(m.group(1)) if m else None), data.split(b"\r\n\r\n", 1)[-1]
def compose(*args: str, check: bool = True) -> str:
out = subprocess.run(COMPOSE + list(args), cwd=ROOT, capture_output=True, text=True)
if check and out.returncode != 0:
raise RuntimeError(f"docker compose {' '.join(args)} failed: {out.stderr.strip()[-300:]}")
return out.stdout
def tool(*args: str) -> dict:
"""python -m app.tools … внутри контейнера api → последняя строка JSON."""
out = compose("exec", "-T", "api", "python", "-m", "app.tools", *args)
return json.loads(out.strip().splitlines()[-1])
def janitor(*args: str, attempts: int = 10) -> dict:
"""Один проход очистки внутри api. Если advisory lock занят фоновым
проходом другой реплики — повторяем."""
import time
for _ in range(attempts):
out = compose("exec", "-T", "api", "python", "-m", "app.janitor", "--once", *args)
stats = json.loads(out.strip().splitlines()[-1])
if stats.get("locked"):
return stats
time.sleep(1)
raise RuntimeError("janitor lock is busy")