Files
mtusi2026lab3/student-tests/helpers.py
T

245 lines
9.5 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.
"""Короткие обёртки над API. Проверка формы ответа — здесь, а не в каждом тесте.
Пользователь теста — «актёр»: словарь `User` из ответа API плюс его
синтетический пароль (`password`) и токен текущей сессии (`token`).
Для сравнения с ответами API — `public(actor)`. Пароли и токены
синтетические и никуда не печатаются.
С лабы 3 отправка сообщения — только через `send()`: по умолчанию новый
`Idempotency-Key` на каждый вызов, `key=None` — без заголовка, строка —
этот ключ. Прямой POST без ключа получил бы 400 раньше проверки, которую
хочет увидеть тест (404 постороннему, 401 после выхода).
"""
import base64
from collections.abc import Callable, Iterable
from typing import Any
from uuid import uuid4
import httpx
USERS = "/api/v1/users"
ME = f"{USERS}/me"
CHATS = "/api/v1/chats"
SESSIONS = "/api/v1/auth/sessions"
CURRENT_SESSION = f"{SESSIONS}/current"
# WWW-Authenticate у 401 (contracts/README.md): вход и остальные запросы
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
USER_FIELDS = frozenset({"id", "username", "display_name", "created_at"})
IDEMPOTENCY_KEY = "Idempotency-Key"
INSTANCE_ID = "X-Instance-Id"
# «нет аргумента» у send(): None значит «без заголовка ключа»
NEW_KEY = object()
# фикстура new_client: каждый вызов — новый клиент со своим соединением
type ClientFactory = Callable[[], httpx.Client]
def headers(actor: dict[str, Any]) -> dict[str, str]:
"""Идентификация с лабы 2: Bearer-токен сессии. Собирается только здесь."""
return bearer_header(actor["token"])
def bearer_header(token: str) -> dict[str, str]:
return {"Authorization": f"Bearer {token}"}
def basic_header(username: str, password: str) -> dict[str, str]:
"""`Authorization: Basic` из username и пароля в UTF-8."""
return basic_raw(f"{username}:{password}".encode())
def basic_raw(raw: bytes) -> dict[str, str]:
"""`Authorization: Basic` из произвольных байтов, в том числе битых."""
return {"Authorization": "Basic " + base64.b64encode(raw).decode("ascii")}
def unique_username(label: str) -> str:
# состояние стенда общее: username не должен повторяться
return f"{label}_{uuid4().hex[:12]}"
def unique_password() -> str:
"""Синтетический пароль 12–128 символов, свой у каждого вызова."""
return f"pw-{uuid4().hex}"
def public(actor: dict[str, Any]) -> dict[str, Any]:
"""Поля `User` из контракта: без пароля и токена теста."""
return {key: actor[key] for key in USER_FIELDS}
def login_response(
client: httpx.Client, username: str, password: str
) -> httpx.Response:
return client.post(SESSIONS, headers=basic_header(username, password))
def login(client: httpx.Client, actor: dict[str, Any]) -> str:
"""Новая сессия пользователя; ответ проверяется по форме `Session`."""
response = login_response(client, actor["username"], actor["password"])
assert response.status_code == 201, response.text
session = response.json()
assert set(session) == {"token", "token_type", "expires_at", "user"}
assert session["token_type"] == "Bearer"
assert session["expires_at"].endswith("Z")
assert session["user"] == public(actor)
assert len(session["token"]) >= 32
return session["token"]
def logout(client: httpx.Client, actor: dict[str, Any]) -> httpx.Response:
return client.delete(CURRENT_SESSION, headers=headers(actor))
def register(
client: httpx.Client,
label: str = "user",
*,
password: str | None = None,
) -> dict[str, Any]:
"""Регистрация с паролем и сразу вход: у актёра есть токен."""
password = password or unique_password()
body = {
"username": unique_username(label),
"display_name": f"Тест {label}",
"password": password,
}
response = client.post(USERS, json=body)
assert response.status_code == 201, response.text
user = response.json()
# пароля и его хэша в ответе нет: только поля User
assert set(user) == USER_FIELDS
assert user["username"] == body["username"]
actor = {**user, "password": password}
actor["token"] = login(client, actor)
return actor
def create_chat(
client: httpx.Client,
owner: dict[str, Any],
*others: dict[str, Any],
title: str = "Тестовый чат",
) -> dict[str, Any]:
member_ids = [owner["id"], *(user["id"] for user in others)]
response = client.post(
CHATS,
json={"title": title, "member_ids": member_ids},
headers=headers(owner),
)
assert response.status_code == 201, response.text
return response.json()
def messages_path(chat: dict[str, Any]) -> str:
return f"{CHATS}/{chat['id']}/messages"
def new_key() -> str:
"""Свой Idempotency-Key у каждого вызова: ASCII из шаблона контракта."""
return f"key-{uuid4().hex}"
def send(
client: httpx.Client,
user: dict[str, Any],
chat: dict[str, Any],
text: str,
*,
key: Any = NEW_KEY,
) -> httpx.Response:
"""POST сообщения с ключом идемпотентности (лаба 3).
`key` не задан — новый ключ; `None` — без заголовка; строка или байты
— этот ключ (байты — для не-ASCII значений, httpx шлёт их как есть).
"""
request_headers = headers(user)
if key is NEW_KEY:
key = new_key()
if key is not None:
request_headers[IDEMPOTENCY_KEY] = key
return client.post(
messages_path(chat), json={"text": text}, headers=request_headers
)
def instance_id(response: httpx.Response) -> str:
"""X-Instance-Id ответа API: непустой у каждого ответа (с лабы 3)."""
value = response.headers.get(INSTANCE_ID, "")
assert value, f"missing {INSTANCE_ID} on {response.status_code}"
return value
def assert_replicas(seen: Iterable[str], expected: int) -> None:
"""Ответы пришли не меньше чем от двух реплик (если их ≥ 2 за BASE_URL)."""
distinct = set(seen)
assert len(distinct) >= min(expected, 2), (
f"{len(distinct)} replica(s) answered, expected at least "
f"{min(expected, 2)} of {expected}"
)
def read_history(
client: httpx.Client,
user: dict[str, Any],
chat: dict[str, Any],
*,
limit: int,
) -> tuple[list[dict[str, Any]], list[int]]:
"""Вся история обходом по курсору: сообщения и размеры страниц."""
items: list[dict[str, Any]] = []
sizes: list[int] = []
params: dict[str, Any] = {"limit": limit}
while True:
response = client.get(messages_path(chat), params=params, headers=headers(user))
assert response.status_code == 200, response.text
page = response.json()
assert set(page) == {"items", "next_cursor"}
items.extend(page["items"])
sizes.append(len(page["items"]))
if page["next_cursor"] is None:
return items, sizes
params = {"limit": limit, "cursor": page["next_cursor"]}
def chat_ids(client: httpx.Client, user: dict[str, Any]) -> list[str]:
"""Id всех чатов пользователя обходом списка по курсору."""
ids: list[str] = []
params: dict[str, Any] = {"limit": 100}
while True:
response = client.get(CHATS, params=params, headers=headers(user))
assert response.status_code == 200, response.text
page = response.json()
ids.extend(item["id"] for item in page["items"])
if page["next_cursor"] is None:
return ids
params = {"limit": 100, "cursor": page["next_cursor"]}
def assert_error(response: httpx.Response, status: int, code: str) -> dict[str, Any]:
"""Ошибка API в формате контракта; request_id совпадает с заголовком.
Ошибку создаёт API, поэтому у неё есть и X-Instance-Id (ответы самого
HAProxy — 502/503/504 — тесты здесь не проверяют).
"""
assert response.status_code == status, response.text
assert response.headers["content-type"].startswith("application/json")
body = response.json()
assert set(body) == {"error"}
error = body["error"]
assert set(error) == {"code", "message", "request_id"}
assert error["code"] == code
assert error["message"]
assert error["request_id"] == response.headers["X-Request-Id"]
instance_id(response)
return error
def assert_unauthorized(response: httpx.Response, challenge: str) -> dict[str, Any]:
"""401 в формате контракта с нужным вызовом в `WWW-Authenticate`."""
error = assert_error(response, 401, "unauthorized")
assert response.headers.get("WWW-Authenticate") == challenge
return error