forked from mtusi2026/mtusi2026lab3
126 lines
4.1 KiB
Python
126 lines
4.1 KiB
Python
"""Minimal stdlib HTTP client for student black-box tests (no extra deps)."""
|
|
from __future__ import annotations
|
|
|
|
import base64
|
|
import json
|
|
import os
|
|
import urllib.error
|
|
import urllib.request
|
|
from dataclasses import dataclass
|
|
from typing import Optional
|
|
|
|
|
|
@dataclass
|
|
class Response:
|
|
status: int
|
|
headers: object
|
|
body: bytes
|
|
|
|
@property
|
|
def json(self):
|
|
if not self.body:
|
|
return None
|
|
return json.loads(self.body.decode("utf-8"))
|
|
|
|
@property
|
|
def content_type(self) -> str:
|
|
return self.headers.get_content_type()
|
|
|
|
@property
|
|
def request_id(self) -> Optional[str]:
|
|
return self.headers.get("X-Request-Id")
|
|
|
|
@property
|
|
def instance_id(self) -> Optional[str]:
|
|
return self.headers.get("X-Instance-Id")
|
|
|
|
|
|
class Client:
|
|
def __init__(self, base_url: str):
|
|
self.base = base_url.rstrip("/")
|
|
|
|
def request(
|
|
self,
|
|
method: str,
|
|
path: str,
|
|
body=None,
|
|
raw: Optional[bytes] = None,
|
|
token: Optional[str] = None,
|
|
basic: Optional[str] = None,
|
|
headers: Optional[dict] = None,
|
|
) -> Response:
|
|
data = raw
|
|
request_headers = {"Accept": "application/json"}
|
|
if body is not None:
|
|
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
|
request_headers["Content-Type"] = "application/json"
|
|
if raw is not None:
|
|
request_headers.setdefault("Content-Type", "application/json")
|
|
if token is not None:
|
|
request_headers["Authorization"] = "Bearer " + token
|
|
if basic is not None:
|
|
request_headers["Authorization"] = "Basic " + basic
|
|
if headers:
|
|
request_headers.update(headers)
|
|
request = urllib.request.Request(
|
|
self.base + path, data=data, headers=request_headers, method=method
|
|
)
|
|
try:
|
|
with urllib.request.urlopen(request, timeout=15) as response:
|
|
return Response(response.status, response.headers, response.read())
|
|
except urllib.error.HTTPError as error:
|
|
return Response(error.code, error.headers, error.read())
|
|
|
|
# -- convenience --------------------------------------------------------
|
|
def register(self, username: str, password: str, display_name: str = "Студент") -> Response:
|
|
return self.request(
|
|
"POST",
|
|
"/api/v1/users",
|
|
body={"username": username, "display_name": display_name, "password": password},
|
|
)
|
|
|
|
def login(self, username: str, password: str) -> Response:
|
|
credential = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode()
|
|
return self.request("POST", "/api/v1/auth/sessions", basic=credential)
|
|
|
|
def me(self, token: str) -> Response:
|
|
return self.request("GET", "/api/v1/users/me", token=token)
|
|
|
|
def create_chat(self, token: str, member_ids, title: str = "Чат") -> Response:
|
|
return self.request(
|
|
"POST",
|
|
"/api/v1/chats",
|
|
body={"title": title, "member_ids": list(member_ids)},
|
|
token=token,
|
|
)
|
|
|
|
def send(
|
|
self,
|
|
token: str,
|
|
chat_id: str,
|
|
text: str,
|
|
key: Optional[str] = None,
|
|
headers: Optional[dict] = None,
|
|
) -> Response:
|
|
# lab3 requires an Idempotency-Key on every message POST.
|
|
request_headers = dict(headers or {})
|
|
request_headers.setdefault("Idempotency-Key", key or os.urandom(16).hex())
|
|
return self.request(
|
|
"POST",
|
|
f"/api/v1/chats/{chat_id}/messages",
|
|
body={"text": text},
|
|
token=token,
|
|
headers=request_headers,
|
|
)
|
|
|
|
def list_messages(self, token: str, chat_id: str, limit: int = 50, cursor=None) -> Response:
|
|
path = f"/api/v1/chats/{chat_id}/messages?limit={limit}"
|
|
if cursor is not None:
|
|
from urllib.parse import quote
|
|
|
|
path += "&cursor=" + quote(cursor, safe="")
|
|
return self.request("GET", path, token=token)
|
|
|
|
def logout(self, token: str) -> Response:
|
|
return self.request("DELETE", "/api/v1/auth/sessions/current", token=token)
|