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