This commit is contained in:
Evgeny Bushkov
2026-11-06 13:32:02 +03:00
parent 302b10cc38
commit e5dde9ea29
18 changed files with 1464 additions and 3 deletions
+1
View File
@@ -30,3 +30,4 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
.aider*
+2 -2
View File
@@ -1,4 +1,4 @@
PYTHON ?= python3
PYTHON ?= python
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
@@ -16,7 +16,7 @@ validate:
$(PYTHON) scripts/validate_openapi.py
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) tests/smoke.py --base-url $(BASE_URL) $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
+242
View File
@@ -0,0 +1,242 @@
"""HTTP-обработчики FastAPI для lab2: Basic/Bearer, PostgreSQL, Redis-кэш сессий."""
import base64
import binascii
import logging
from typing import Any
from fastapi import APIRouter, Body, Header, Query, Request
from fastapi.responses import JSONResponse, Response
from .errors import ApiError
from .security import hash_password, verify_password
from .sessions import SessionStore
from .store import Store
from .validation import (
encode_cursor,
parse_cursor,
parse_limit,
validate_chat_id,
validate_create_chat,
validate_create_message,
validate_create_user,
)
router = APIRouter()
logger = logging.getLogger("messenger.handlers")
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
def get_store(request: Request) -> Store:
return request.app.state.store
def get_sessions(request: Request) -> SessionStore:
return request.app.state.sessions
def _unauthorized(message: str, challenge: str) -> ApiError:
err = ApiError(401, "unauthorized", message)
err.challenge = challenge # type: ignore[attr-defined]
return err
def current_user_id(request: Request, authorization: str | None) -> str:
"""lab2: только Bearer. X-User-Id игнорируется."""
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token:
raise _unauthorized("Пустой Bearer-токен", BEARER_CHALLENGE)
user_id = get_sessions(request).resolve(token)
if user_id is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user_id
def _parse_basic(authorization: str | None) -> tuple[str, str]:
if not authorization or not authorization.lower().startswith("basic "):
raise _unauthorized("Требуется Basic-аутентификация", BASIC_CHALLENGE)
try:
decoded = base64.b64decode(authorization[6:].strip(), validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
if ":" not in decoded:
raise _unauthorized("Некорректный Basic", BASIC_CHALLENGE)
username, password = decoded.split(":", 1)
return username, password
@router.get("/health/live")
def health_live() -> dict[str, str]:
return {"status": "ok"}
@router.get("/health/ready")
def health_ready(request: Request) -> JSONResponse:
"""Ready, если доступна БД (обязательный синхронный путь). Redis — кэш."""
try:
with get_store(request).pool.connection() as conn:
with conn.cursor() as cur:
cur.execute("SELECT 1")
cur.fetchone()
except Exception as exc: # noqa: BLE001
logger.warning("readiness failed: %s", type(exc).__name__)
raise ApiError(503, "unavailable", "Зависимость недоступна")
return JSONResponse({"status": "ok"})
@router.post("/api/v1/users", status_code=201)
def register_user(request: Request, body: Any = Body(...)) -> JSONResponse:
username, display_name, password = validate_create_user(body)
store = get_store(request)
user = store.create_user(username, display_name, hash_password(password))
if user is None:
raise ApiError(409, "conflict", "username уже занят")
return JSONResponse(user, status_code=201)
@router.post("/api/v1/auth/sessions", status_code=201)
def create_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
username, password = _parse_basic(authorization)
store = get_store(request)
found = store.get_user_by_username(username)
if found is None:
# Одинаковый 401 для неверного username и пароля.
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
user, password_hash = found
if not verify_password(password_hash, password):
raise _unauthorized("Неверные учётные данные", BASIC_CHALLENGE)
session = get_sessions(request).create(user["id"])
return JSONResponse(
{
"token": session["token"],
"token_type": "Bearer",
"expires_at": session["expires_at"],
"user": user,
},
status_code=201,
)
@router.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(
request: Request,
authorization: str | None = Header(default=None),
) -> JSONResponse:
if not authorization or not authorization.lower().startswith("bearer "):
raise _unauthorized("Требуется Bearer-токен", BEARER_CHALLENGE)
token = authorization[7:].strip()
if not token or get_sessions(request).resolve(token) is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
get_sessions(request).revoke(token)
return Response(status_code=204)
@router.get("/api/v1/users/me")
def current_user(
request: Request, authorization: str | None = Header(default=None)
) -> dict[str, Any]:
user_id = current_user_id(request, authorization)
user = get_store(request).get_user(user_id)
if user is None:
raise _unauthorized("Недействительная сессия", BEARER_CHALLENGE)
return user
@router.post("/api/v1/chats", status_code=201)
def create_chat(
request: Request,
body: Any = Body(...),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, authorization)
title, member_ids = validate_create_chat(body, caller)
store = get_store(request)
for mid in member_ids:
if store.get_user(mid) is None:
raise ApiError(400, "invalid_request", "Неизвестный участник чата")
chat = store.create_chat(title, member_ids)
return JSONResponse(chat, status_code=201)
@router.get("/api/v1/chats")
def list_chats(
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
page_size = parse_limit(limit)
scope = f"chats:{caller}"
after = parse_cursor(cursor, scope)
items, has_more = get_store(request).list_chats_for(caller, page_size, after)
next_cursor = None
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": items, "next_cursor": next_cursor}
@router.get("/api/v1/chats/{chat_id}")
def get_chat(
chat_id: str,
request: Request,
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
chat = store.get_chat(chat_id)
if chat is None:
raise ApiError(404, "not_found", "Чат не найден")
return chat
@router.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def create_message(
chat_id: str,
request: Request,
body: Any = Body(...),
authorization: str | None = Header(default=None),
) -> JSONResponse:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
text = validate_create_message(body)
message = store.add_message(chat_id, caller, text)
return JSONResponse(message, status_code=201)
@router.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: str,
request: Request,
limit: str | None = Query(default=None),
cursor: str | None = Query(default=None),
authorization: str | None = Header(default=None),
) -> dict[str, Any]:
caller = current_user_id(request, authorization)
chat_id = validate_chat_id(chat_id)
store = get_store(request)
if not store.is_member(chat_id, caller):
raise ApiError(404, "not_found", "Чат не найден")
page_size = parse_limit(limit)
scope = f"messages:{chat_id}"
after = parse_cursor(cursor, scope)
items, has_more = store.list_messages(chat_id, page_size, after)
next_cursor = None
if has_more and items:
last = items[-1]
next_cursor = encode_cursor(last["created_at"], last["id"], scope)
return {"items": items, "next_cursor": next_cursor}
+1 -1
View File
@@ -15,7 +15,7 @@ from .routers import auth, chats, health, messages, users
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
log = logging.getLogger("app")
app = FastAPI(title="Messenger", version="1.3.0", docs_url=None, redoc_url=None, openapi_url=None)
app = FastAPI(title="Messenger", version="1.3.0")
@app.middleware("http")
+129
View File
@@ -0,0 +1,129 @@
"""Сессии: PostgreSQL — источник истины, Redis — кэш с TTL.
При недоступности Redis работаем напрямую с БД (не принимаем анонимов).
При logout инвалидируем и БД, и кэш.
"""
import logging
import os
from datetime import datetime, timedelta, timezone
from typing import Any
import redis
from psycopg_pool import ConnectionPool
from .security import new_token, token_hash
logger = logging.getLogger("messenger.sessions")
def _now() -> datetime:
return datetime.now(timezone.utc)
def _ttl_seconds() -> int:
return int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
class SessionStore:
def __init__(self, pool: ConnectionPool, cache: redis.Redis | None) -> None:
self.pool = pool
self.cache = cache
# --- кэш --------------------------------------------------------------
def _cache_get(self, th: str) -> dict[str, Any] | None:
if self.cache is None:
return None
try:
raw = self.cache.hgetall("session:" + th)
except redis.RedisError as exc:
logger.warning("redis get failed: %s", type(exc).__name__)
return None
if not raw:
return None
return {
"user_id": raw[b"user_id"].decode(),
"expires_at": raw[b"expires_at"].decode(),
}
def _cache_put(self, th: str, user_id: str, expires_at: datetime) -> None:
if self.cache is None:
return
ttl = max(1, int((expires_at - _now()).total_seconds()))
try:
pipe = self.cache.pipeline()
pipe.hset(
"session:" + th,
mapping={
"user_id": user_id,
"expires_at": expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
},
)
pipe.expire("session:" + th, ttl)
pipe.execute()
except redis.RedisError as exc:
logger.warning("redis put failed: %s", type(exc).__name__)
def _cache_del(self, th: str) -> None:
if self.cache is None:
return
try:
self.cache.delete("session:" + th)
except redis.RedisError as exc:
logger.warning("redis del failed: %s", type(exc).__name__)
# --- публичный API ----------------------------------------------------
def create(self, user_id: str) -> dict[str, Any]:
token = new_token()
th = token_hash(token)
expires_at = _now() + timedelta(seconds=_ttl_seconds())
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO sessions(token_hash, user_id, created_at, expires_at)"
" VALUES (%s, %s, now(), %s)",
(th, user_id, expires_at),
)
conn.commit()
self._cache_put(th, user_id, expires_at)
return {
"token": token,
"expires_at": expires_at.strftime("%Y-%m-%dT%H:%M:%SZ"),
}
def resolve(self, token: str) -> str | None:
"""Возвращает user_id для действующей сессии или None."""
th = token_hash(token)
cached = self._cache_get(th)
if cached is not None:
try:
exp = datetime.strptime(cached["expires_at"], "%Y-%m-%dT%H:%M:%SZ").replace(
tzinfo=timezone.utc
)
except ValueError:
exp = None
if exp is not None and exp > _now():
return cached["user_id"]
self._cache_del(th)
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT user_id, expires_at FROM sessions WHERE token_hash = %s",
(th,),
)
row = cur.fetchone()
if row is None:
return None
user_id, expires_at = row
if expires_at <= _now():
self.revoke(token)
return None
self._cache_put(th, str(user_id), expires_at)
return str(user_id)
def revoke(self, token: str) -> None:
th = token_hash(token)
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute("DELETE FROM sessions WHERE token_hash = %s", (th,))
conn.commit()
self._cache_del(th)
+204
View File
@@ -0,0 +1,204 @@
"""Хранилище на PostgreSQL: пользователи, чаты, участники, сообщения."""
import uuid
from datetime import datetime, timezone
from typing import Any
import psycopg
from psycopg_pool import ConnectionPool
def utc_now() -> str:
"""RFC 3339 UTC с суффиксом Z, секунды — как в примерах контракта."""
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
def new_id() -> str:
return str(uuid.uuid4())
def _iso(dt: datetime) -> str:
"""RFC 3339 UTC с суффиксом Z, микросекунды сохраняются для keyset-пагинации."""
return dt.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def _user_row(row: tuple) -> dict[str, Any]:
uid, username, display_name, created_at = row
return {
"id": str(uid),
"username": username,
"display_name": display_name,
"created_at": _iso(created_at),
}
def _chat_row(row: tuple, member_ids: list[str]) -> dict[str, Any]:
cid, title, created_at = row
return {
"id": str(cid),
"title": title,
"member_ids": member_ids,
"created_at": _iso(created_at),
}
def _message_row(row: tuple) -> dict[str, Any]:
mid, chat_id, sender_id, text, created_at = row
return {
"id": str(mid),
"chat_id": str(chat_id),
"sender_id": str(sender_id),
"text": text,
"created_at": _iso(created_at),
}
class Store:
"""Все данные в PostgreSQL; соединения берутся из пула."""
def __init__(self, pool: ConnectionPool) -> None:
self.pool = pool
# --- пользователи -----------------------------------------------------
def create_user(
self, username: str, display_name: str, password_hash: str
) -> dict[str, Any] | None:
user_id = new_id()
try:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO users(id, username, display_name, password_hash, created_at)"
" VALUES (%s, %s, %s, %s, now())"
" RETURNING id, username, display_name, created_at",
(user_id, username, display_name, password_hash),
)
row = cur.fetchone()
conn.commit()
except psycopg.errors.UniqueViolation:
return None
return _user_row(row)
def get_user(self, user_id: str) -> dict[str, Any] | None:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
(user_id,),
)
row = cur.fetchone()
return _user_row(row) if row else None
def get_user_by_username(self, username: str) -> tuple[dict[str, Any], str] | None:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, username, display_name, created_at, password_hash"
" FROM users WHERE username = %s",
(username,),
)
row = cur.fetchone()
if row is None:
return None
return _user_row(row[:4]), row[4]
# --- чаты -------------------------------------------------------------
def create_chat(self, title: str, member_ids: list[str]) -> dict[str, Any]:
chat_id = new_id()
with self.pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
cur.execute(
"INSERT INTO chats(id, title, created_at) VALUES (%s, %s, now())"
" RETURNING id, title, created_at",
(chat_id, title),
)
row = cur.fetchone()
cur.executemany(
"INSERT INTO chat_members(chat_id, user_id) VALUES (%s, %s)",
[(chat_id, mid) for mid in member_ids],
)
return _chat_row(row, list(member_ids))
def _members(self, cur, chat_id: str) -> list[str]:
cur.execute(
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id",
(chat_id,),
)
return [str(r[0]) for r in cur.fetchall()]
def get_chat(self, chat_id: str) -> dict[str, Any] | None:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT id, title, created_at FROM chats WHERE id = %s", (chat_id,)
)
row = cur.fetchone()
if row is None:
return None
members = self._members(cur, chat_id)
return _chat_row(row, members)
def is_member(self, chat_id: str, user_id: str) -> bool:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat_id, user_id),
)
return cur.fetchone() is not None
def list_chats_for(
self, user_id: str, limit: int, after: tuple[str, str] | None
) -> tuple[list[dict[str, Any]], bool]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
sql = (
"SELECT c.id, c.title, c.created_at FROM chats c"
" JOIN chat_members m ON m.chat_id = c.id"
" WHERE m.user_id = %s"
)
params: list[Any] = [user_id]
if after is not None:
sql += " AND (c.created_at, c.id) > (%s, %s)"
params.extend(after)
sql += " ORDER BY c.created_at, c.id LIMIT %s"
params.append(limit + 1)
cur.execute(sql, params)
rows = cur.fetchall()
items = []
for row in rows[:limit]:
items.append(_chat_row(row, self._members(cur, str(row[0]))))
return items, len(rows) > limit
# --- сообщения --------------------------------------------------------
def add_message(self, chat_id: str, sender_id: str, text: str) -> dict[str, Any]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
cur.execute(
"INSERT INTO messages(id, chat_id, sender_id, text, created_at)"
" VALUES (%s, %s, %s, %s, now())"
" RETURNING id, chat_id, sender_id, text, created_at",
(new_id(), chat_id, sender_id, text),
)
row = cur.fetchone()
conn.commit()
return _message_row(row)
def list_messages(
self, chat_id: str, limit: int, after: tuple[str, str] | None
) -> tuple[list[dict[str, Any]], bool]:
with self.pool.connection() as conn:
with conn.cursor() as cur:
sql = (
"SELECT id, chat_id, sender_id, text, created_at FROM messages"
" WHERE chat_id = %s"
)
params: list[Any] = [chat_id]
if after is not None:
sql += " AND (created_at, id) > (%s, %s)"
params.extend(after)
sql += " ORDER BY created_at, id LIMIT %s"
params.append(limit + 1)
cur.execute(sql, params)
rows = cur.fetchall()
return [_message_row(r) for r in rows[:limit]], len(rows) > limit
+122
View File
@@ -0,0 +1,122 @@
"""Валидация тел запросов и параметров вручную, без pydantic-моделей контракта."""
import base64
import re
import uuid
from typing import Any
from .errors import ApiError
USERNAME_RE = re.compile(r"\A[a-z0-9_]{3,32}\Z")
def _is_blank(value: str) -> bool:
return value.strip() == ""
def require_object(body: Any) -> dict[str, Any]:
if not isinstance(body, dict):
raise ApiError(400, "invalid_request", "Тело запроса должно быть JSON-объектом")
return body
def reject_extra(body: dict[str, Any], allowed: set[str]) -> None:
if set(body) - allowed:
raise ApiError(400, "invalid_request", "Неизвестные поля в теле запроса")
def validate_create_user(body: Any) -> tuple[str, str, str]:
body = require_object(body)
reject_extra(body, {"username", "display_name", "password"})
username = body.get("username")
display_name = body.get("display_name")
password = body.get("password")
if not isinstance(username, str) or not USERNAME_RE.match(username):
raise ApiError(400, "invalid_request", "Некорректный username")
if not isinstance(display_name, str) or not (1 <= len(display_name) <= 100) or _is_blank(display_name):
raise ApiError(400, "invalid_request", "Некорректный display_name")
if not isinstance(password, str) or not (12 <= len(password) <= 128):
raise ApiError(400, "invalid_request", "Пароль должен быть 12..128 символов")
return username, display_name, password
def validate_create_chat(body: Any, caller_id: str) -> tuple[str, list[str]]:
body = require_object(body)
reject_extra(body, {"title", "member_ids"})
title = body.get("title")
member_ids = body.get("member_ids")
if not isinstance(title, str) or not (1 <= len(title) <= 100) or _is_blank(title):
raise ApiError(400, "invalid_request", "Некорректный title")
if not isinstance(member_ids, list) or not (1 <= len(member_ids) <= 100):
raise ApiError(400, "invalid_request", "member_ids должен быть непустым массивом")
seen: set[str] = set()
for mid in member_ids:
if not isinstance(mid, str):
raise ApiError(400, "invalid_request", "member_ids содержит не строку")
try:
uuid.UUID(mid)
except ValueError:
raise ApiError(400, "invalid_request", "member_ids содержит не UUID")
if mid in seen:
raise ApiError(400, "invalid_request", "member_ids содержит дубликаты")
seen.add(mid)
if caller_id not in seen:
raise ApiError(400, "invalid_request", "Вызывающий должен входить в member_ids")
return title, list(member_ids)
def validate_create_message(body: Any) -> str:
body = require_object(body)
reject_extra(body, {"text"})
text = body.get("text")
if not isinstance(text, str) or not (1 <= len(text) <= 4000) or _is_blank(text):
raise ApiError(400, "invalid_request", "Некорректный text")
return text
def validate_chat_id(raw: str) -> str:
"""chat_id в пути должен быть UUID, иначе 400 invalid_request."""
try:
uuid.UUID(raw)
except (ValueError, TypeError):
raise ApiError(400, "invalid_request", "Некорректный chat_id")
return raw
def parse_limit(raw: str | None, default: int = 50) -> int:
if raw is None:
return default
try:
value = int(raw)
except (TypeError, ValueError):
raise ApiError(400, "invalid_request", "limit должен быть целым числом")
if not (1 <= value <= 100):
raise ApiError(400, "invalid_request", "limit вне диапазона 1..100")
return value
def parse_cursor(raw: str | None, scope: str) -> tuple[str, str] | None:
"""Cursor — непрозрачная строка base64url от 'scope|created_at|id'.
Cursor привязан к ресурсу (scope). Значения created_at/id — из БД,
поэтому cursor переживает рестарт процесса.
"""
if raw is None:
return None
try:
decoded = base64.urlsafe_b64decode(raw.encode("ascii")).decode("utf-8")
except Exception:
raise ApiError(400, "invalid_request", "Некорректный cursor")
parts = decoded.split("|")
if len(parts) != 3:
raise ApiError(400, "invalid_request", "Некорректный cursor")
cursor_scope, created_at, item_id = parts
if cursor_scope != scope:
raise ApiError(400, "invalid_request", "Некорректный cursor")
if not created_at or not item_id:
raise ApiError(400, "invalid_request", "Некорректный cursor")
return created_at, item_id
def encode_cursor(created_at: str, item_id: str, scope: str) -> str:
raw = "|".join([scope, created_at, item_id]).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii")
+32
View File
@@ -0,0 +1,32 @@
CREATE TABLE users (
id UUID PRIMARY KEY,
username TEXT NOT NULL UNIQUE,
display_name TEXT NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chats (
id UUID PRIMARY KEY,
title TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members(user_id);
CREATE TABLE messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id),
text TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
-- Индекс под keyset-пагинацию истории чата: (chat_id, created_at, id).
CREATE INDEX messages_chat_created_idx ON messages(chat_id, created_at, id);
+9
View File
@@ -0,0 +1,9 @@
CREATE TABLE sessions (
token_hash TEXT PRIMARY KEY,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
created_at TIMESTAMPTZ NOT NULL,
expires_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX sessions_user_idx ON sessions(user_id);
CREATE INDEX sessions_expires_idx ON sessions(expires_at);
+8
View File
@@ -0,0 +1,8 @@
-- Ожидаем Index Scan по messages_chat_created_idx, без Seq Scan всей истории.
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '00000000-0000-4000-8000-000000000000'
AND (created_at, id) > ('2026-01-01T00:00:00Z', '00000000-0000-4000-8000-000000000000')
ORDER BY created_at, id
LIMIT 51;
+100
View File
@@ -0,0 +1,100 @@
#!/usr/bin/env python3
"""Создаёт >=10 000 сообщений и снимает EXPLAIN (ANALYZE, BUFFERS).
Запуск: python3 scripts/seed_history.py --count 10000 --output evidence/explain.txt
Требует запущенный API (BASE_URL) и доступ к psql через docker compose exec.
"""
import argparse
import base64
import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def request(base, method, path, body=None, token=None, basic=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(base + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=30) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
def main():
p = argparse.ArgumentParser(description="Seed history and run EXPLAIN")
p.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://localhost:8080"))
p.add_argument("--count", type=int, default=10000)
p.add_argument("--output", default="evidence/explain.txt")
p.add_argument("--psql", default="docker compose exec -T postgres psql -U messenger -d messenger")
args = p.parse_args()
base = args.base_url.rstrip("/")
username = "u_seed_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, alice = request(base, "POST", "/api/v1/users",
{"username": username, "display_name": "Seed", "password": password})
assert status == 201, (status, alice)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request(base, "POST", "/api/v1/auth/sessions", basic=basic)
assert status == 201, (status, session)
token = session["token"]
status, chat = request(base, "POST", "/api/v1/chats",
{"title": "Seed history", "member_ids": [alice["id"]]}, token=token)
assert status == 201, (status, chat)
chat_id = chat["id"]
started = time.monotonic()
for i in range(args.count):
status, _ = request(base, "POST", "/api/v1/chats/" + chat_id + "/messages",
{"text": "seed-%d" % i}, token=token)
if status != 201:
raise SystemExit("failed to insert message %d: %s" % (i, status))
if (i + 1) % 1000 == 0:
print("inserted %d/%d" % (i + 1, args.count), file=sys.stderr)
elapsed = time.monotonic() - started
print("inserted %d messages in %.1fs" % (args.count, elapsed), file=sys.stderr)
sql = (
"EXPLAIN (ANALYZE, BUFFERS) "
"SELECT id, chat_id, sender_id, text, created_at FROM messages "
"WHERE chat_id = '%s' "
"AND (created_at, id) > ('1970-01-01T00:00:00Z', '00000000-0000-0000-0000-000000000000') "
"ORDER BY created_at, id LIMIT 51;" % chat_id
)
proc = subprocess.run(args.psql.split() + ["-c", sql], cwd=str(ROOT),
capture_output=True, text=True, timeout=120)
if proc.returncode != 0:
raise SystemExit("psql failed: " + proc.stderr[:500])
out = proc.stdout
dest = (ROOT / args.output).resolve()
dest.parent.mkdir(parents=True, exist_ok=True)
dest.write_text(
"# chat_id=%s count=%d\n%s\n" % (chat_id, args.count, out),
encoding="utf-8",
)
print(out)
print("saved to " + str(dest), file=sys.stderr)
if __name__ == "__main__":
main()
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
# Поднимает PostgreSQL обратно и ждёт готовности.
docker compose start postgres
i=0
while [ "$i" -lt 60 ]; do
if docker compose exec -T postgres pg_isready -U messenger -d messenger >/dev/null 2>&1; then
exit 0
fi
i=$((i+1))
sleep 1
done
echo "postgres did not become ready" >&2
exit 1
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
# Поднимает Redis обратно и ждёт готовности.
docker compose start redis
i=0
while [ "$i" -lt 30 ]; do
if docker compose exec -T redis redis-cli ping >/dev/null 2>&1; then
exit 0
fi
i=$((i+1))
sleep 1
done
echo "redis did not become ready" >&2
exit 1
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
# Останавливает PostgreSQL, сохраняя volume. Используется тестом недоступности.
docker compose stop postgres
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
# Останавливает Redis, сохраняя volume. Используется тестом недоступности.
docker compose stop redis
+147
View File
@@ -0,0 +1,147 @@
#!/usr/bin/env python3
"""Проверка недоступности Redis и PostgreSQL.
Управление контейнерами — через скрипты scripts/stop-*.sh / start-*.sh,
чтобы тест не зависел от Docker напрямую.
"""
import argparse
import base64
import json
import os
import shutil
import subprocess
import sys
import time
import unittest
import urllib.error
import urllib.request
import uuid
from pathlib import Path
_parser = argparse.ArgumentParser(description="Dependency failure tests")
_parser.add_argument("--base-url", default=None)
_parser.add_argument("--stop-redis", default="scripts/stop-redis.sh")
_parser.add_argument("--start-redis", default="scripts/start-redis.sh")
_parser.add_argument("--stop-postgres", default="scripts/stop-postgres.sh")
_parser.add_argument("--start-postgres", default="scripts/start-postgres.sh")
_args, _unknown = _parser.parse_known_args()
sys.argv = [sys.argv[0]] + _unknown
BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/")
ROOT = Path(__file__).resolve().parents[1]
def _script_command(full: Path) -> list[str]:
"""Windows не умеет запускать .sh напрямую — вызываем через sh (Git Bash/WSL)."""
if os.name == "nt":
sh = shutil.which("sh") or shutil.which("bash")
if not sh:
raise unittest.SkipTest(
"sh/bash not found in PATH; install Git for Windows or run under WSL"
)
return [sh, str(full)]
return [str(full)]
def run_script(path):
full = (ROOT / path).resolve()
if not full.is_file():
raise unittest.SkipTest("script not found: " + str(full))
cmd = _script_command(full)
proc = subprocess.run(cmd, cwd=str(ROOT), capture_output=True, timeout=120)
if proc.returncode != 0:
raise AssertionError(
"script failed: " + path + " rc=" + str(proc.returncode)
+ " stderr=" + proc.stderr.decode("utf-8", "replace")[:500]
)
def request(method, path, body=None, token=None, basic=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
def make_user(label):
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, user = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Dep " + label, "password": password},
)
assert status == 201, (status, user)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
assert status == 201, (status, session)
return {"user": user, "token": session["token"]}
def wait_ready(timeout=60):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
status, _ = request("GET", "/health/ready")
if status == 200:
return
except Exception:
pass
time.sleep(0.5)
raise AssertionError("API did not become ready within " + str(timeout) + "s")
class DependencyFailureTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice = make_user("alice")
def test_redis_down_falls_back_to_db(self):
run_script(_args.stop_redis)
try:
# Валидный токен продолжает работать (fallback на БД).
status, body = request("GET", "/api/v1/users/me", token=self.alice["token"])
self.assertEqual(status, 200, body)
self.assertEqual(body["id"], self.alice["user"]["id"])
# Аноним не принимается.
status, body = request("GET", "/api/v1/users/me")
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
# /health/ready не зависит от Redis.
status, _ = request("GET", "/health/ready")
self.assertEqual(status, 200)
finally:
run_script(_args.start_redis)
wait_ready()
def test_postgres_down_returns_503(self):
run_script(_args.stop_postgres)
try:
status, body = request("GET", "/health/ready")
self.assertEqual(status, 503)
self.assertEqual(body["error"]["code"], "unavailable")
# Бизнес-запрос не должен отдавать 200 и не должен раскрывать детали.
status, body = request("GET", "/api/v1/users/me", token=self.alice["token"])
self.assertIn(status, (500, 503))
self.assertIn("error", body)
self.assertNotIn("psycopg", json.dumps(body).lower())
finally:
run_script(_args.start_postgres)
wait_ready()
if __name__ == "__main__":
unittest.main(verbosity=2)
+93
View File
@@ -0,0 +1,93 @@
#!/usr/bin/env python3
"""Проверка expiry сессии при коротком SESSION_TTL_SECONDS.
Запускается против стенда с SESSION_TTL_SECONDS <= 10 (например, 2).
Если TTL больше — тест скипается, чтобы не ждать минуты.
"""
import argparse
import base64
import json
import os
import sys
import time
import unittest
import urllib.error
import urllib.request
import uuid
_parser = argparse.ArgumentParser(description="Expiry test")
_parser.add_argument("--base-url", default=None)
_parser.add_argument("--ttl", type=int, default=None)
_args, _unknown = _parser.parse_known_args()
sys.argv = [sys.argv[0]] + _unknown
BASE_URL = (_args.base_url or os.environ.get("BASE_URL") or "http://localhost:8080").rstrip("/")
TTL = _args.ttl or int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
def request(method, path, body=None, token=None, basic=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
data = None
if body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
@unittest.skipIf(
TTL > 10,
"SESSION_TTL_SECONDS > 10; запустите стенд с коротким TTL и передайте "
"SESSION_TTL_SECONDS=2 make test-expiry",
)
class ExpiryTests(unittest.TestCase):
def test_session_expires(self):
username = "u_exp_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, user = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Expiry", "password": password},
)
self.assertEqual(status, 201, user)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
self.assertEqual(status, 201, session)
token = session["token"]
# Проверяем, что API реально запущен с коротким TTL: иначе тест
# будет ждать час и всё равно упадёт.
expires_at = session["expires_at"]
from datetime import datetime, timezone
exp = datetime.strptime(expires_at, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
actual_ttl = (exp - datetime.now(timezone.utc)).total_seconds()
self.assertLessEqual(
actual_ttl,
10,
"API запущен с TTL=" + str(int(actual_ttl)) + "s; перезапустите стенд с "
"SESSION_TTL_SECONDS=2 (например: SESSION_TTL_SECONDS=2 docker compose up -d api)",
)
status, _ = request("GET", "/api/v1/users/me", token=token)
self.assertEqual(status, 200)
time.sleep(actual_ttl + 2)
status, body = request("GET", "/api/v1/users/me", token=token)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
# Повторный вход с теми же credentials снова работает.
status, session2 = request("POST", "/api/v1/auth/sessions", basic=basic)
self.assertEqual(status, 201, session2)
status, _ = request("GET", "/api/v1/users/me", token=session2["token"])
self.assertEqual(status, 200)
if __name__ == "__main__":
unittest.main(verbosity=2)
+338
View File
@@ -0,0 +1,338 @@
#!/usr/bin/env python3
"""Собственные тесты уровня 4: негативные сценарии и конкурентная запись.
Запуск: python3 tests/test_unit.py
Требует запущенный сервер (по умолчанию http://localhost:8080).
"""
import argparse
import base64
import json
import os
import sys
import threading
import unittest
import urllib.error
import urllib.request
import uuid
_parser = argparse.ArgumentParser(description="Собственные тесты уровня 4")
_parser.add_argument("--base-url", default=None)
_args, _unknown = _parser.parse_known_args()
# unittest.main() читает sys.argv сам и не знает про --base-url — убираем его.
sys.argv = [sys.argv[0]] + _unknown
BASE_URL = (
_args.base_url
or os.environ.get("BASE_URL")
or "http://localhost:8080"
).rstrip("/")
def request(method, path, body=None, token=None, raw=None, content_type="application/json",
basic=None, extra_headers=None):
headers = {"Accept": "application/json"}
if token:
headers["Authorization"] = "Bearer " + token
if basic:
headers["Authorization"] = "Basic " + basic
if extra_headers:
headers.update(extra_headers)
data = None
if raw is not None:
data = raw
headers["Content-Type"] = content_type
elif body is not None:
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
headers["Content-Type"] = "application/json"
req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
payload = resp.read()
return resp.status, json.loads(payload) if payload else None
except urllib.error.HTTPError as err:
payload = err.read()
return err.code, json.loads(payload) if payload else None
def make_user(label):
username = "u_" + label + "_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
status, user = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Тест " + label, "password": password},
)
assert status == 201, (status, user)
basic = base64.b64encode((username + ":" + password).encode()).decode()
status, session = request("POST", "/api/v1/auth/sessions", basic=basic)
assert status == 201, (status, session)
return {"user": user, "token": session["token"], "basic": basic, "password": password}
class MessengerTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice = make_user("alice")
cls.bob = make_user("bob")
cls.eve = make_user("eve")
status, chat = request(
"POST",
"/api/v1/chats",
{"title": "Тестовый чат", "member_ids": [cls.alice["user"]["id"], cls.bob["user"]["id"]]},
token=cls.alice["token"],
)
assert status == 201, (status, chat)
cls.chat = chat
def test_invalid_json(self):
status, body = request(
"POST",
"/api/v1/chats/" + self.chat["id"] + "/messages",
raw=b"{not json",
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_foreign_chat_returns_404(self):
status, body = request("GET", "/api/v1/chats/" + self.chat["id"], token=self.eve["token"])
self.assertEqual(status, 404)
self.assertEqual(body["error"]["code"], "not_found")
def test_empty_message_rejected(self):
status, body = request(
"POST",
"/api/v1/chats/" + self.chat["id"] + "/messages",
{"text": " "},
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_duplicate_username(self):
username = "u_dup_" + uuid.uuid4().hex[:10]
password = "T3st-" + uuid.uuid4().hex
first = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Первый", "password": password},
)
self.assertEqual(first[0], 201)
second = request(
"POST",
"/api/v1/users",
{"username": username, "display_name": "Второй", "password": password},
)
self.assertEqual(second[0], 409)
self.assertEqual(second[1]["error"]["code"], "conflict")
def test_short_password_rejected(self):
status, body = request(
"POST",
"/api/v1/users",
{"username": "u_short_" + uuid.uuid4().hex[:8], "display_name": "X", "password": "short"},
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_wrong_password_returns_401(self):
bad = base64.b64encode(
(self.alice["user"]["username"] + ":wrong-password-123").encode()
).decode()
status, body = request("POST", "/api/v1/auth/sessions", basic=bad)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_basic_not_accepted_on_business_endpoint(self):
status, body = request("GET", "/api/v1/users/me", basic=self.alice["basic"])
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_x_user_id_ignored(self):
status, body = request(
"GET",
"/api/v1/users/me",
token=self.alice["token"],
extra_headers={"X-User-Id": self.eve["user"]["id"]},
)
self.assertEqual(status, 200)
self.assertEqual(body["id"], self.alice["user"]["id"])
def test_logout_revokes_session(self):
user = make_user("logout")
status, _ = request("DELETE", "/api/v1/auth/sessions/current", token=user["token"])
self.assertEqual(status, 204)
status, body = request("GET", "/api/v1/users/me", token=user["token"])
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
def test_pagination_walks_all_pages(self):
chat = request(
"POST",
"/api/v1/chats",
{"title": "Пагинация", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
sent = []
for i in range(7):
status, msg = request(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "msg-%d" % i},
token=self.alice["token"],
)
self.assertEqual(status, 201)
sent.append(msg["id"])
collected = []
cursor = None
while True:
path = "/api/v1/chats/" + chat["id"] + "/messages?limit=2"
if cursor:
path += "&cursor=" + cursor
status, page = request("GET", path, token=self.bob["token"])
self.assertEqual(status, 200)
collected.extend(m["id"] for m in page["items"])
cursor = page["next_cursor"]
if not cursor:
break
self.assertEqual(collected, sent)
def test_cursor_bound_to_resource(self):
chat_a = request(
"POST",
"/api/v1/chats",
{"title": "Cursor A", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
chat_b = request(
"POST",
"/api/v1/chats",
{"title": "Cursor B", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
for i in range(3):
request(
"POST",
"/api/v1/chats/" + chat_a["id"] + "/messages",
{"text": "a-%d" % i},
token=self.alice["token"],
)
status, page = request(
"GET",
"/api/v1/chats/" + chat_a["id"] + "/messages?limit=1",
token=self.alice["token"],
)
self.assertEqual(status, 200)
cursor = page["next_cursor"]
self.assertIsNotNone(cursor)
status, body = request(
"GET",
"/api/v1/chats/" + chat_b["id"] + "/messages?limit=1&cursor=" + cursor,
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_cursor_bound_to_endpoint(self):
status, page = request(
"GET", "/api/v1/chats?limit=1", token=self.alice["token"]
)
self.assertEqual(status, 200)
cursor = page["next_cursor"]
self.assertIsNotNone(cursor)
status, body = request(
"GET",
"/api/v1/chats/" + self.chat["id"] + "/messages?limit=1&cursor=" + cursor,
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_cursor_garbage_rejected(self):
garbage = base64.urlsafe_b64encode(b"x|y").decode("ascii")
status, body = request(
"GET",
"/api/v1/chats/" + self.chat["id"] + "/messages?cursor=" + garbage,
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_invalid_chat_id_returns_400(self):
status, body = request("GET", "/api/v1/chats/not-a-uuid", token=self.alice["token"])
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
status, body = request(
"POST",
"/api/v1/chats/not-a-uuid/messages",
{"text": "hi"},
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
status, body = request(
"GET", "/api/v1/chats/not-a-uuid/messages", token=self.alice["token"]
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_username_with_trailing_newline_rejected(self):
status, body = request(
"POST",
"/api/v1/users",
{"username": "abc\n", "display_name": "Имя", "password": "T3st-" + uuid.uuid4().hex},
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_invalid_body_bytes_contract_error(self):
status, body = request(
"POST",
"/api/v1/users",
raw=b"\xff",
token=self.alice["token"],
)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
self.assertIn("message", body["error"])
self.assertIn("request_id", body["error"])
def test_concurrent_writes_are_unique(self):
chat = request(
"POST",
"/api/v1/chats",
{"title": "Конкурентность", "member_ids": [self.alice["user"]["id"], self.bob["user"]["id"]]},
token=self.alice["token"],
)[1]
errors = []
lock = threading.Lock()
def worker(worker_id):
for i in range(10):
status, body = request(
"POST",
"/api/v1/chats/" + chat["id"] + "/messages",
{"text": "w%d-%d" % (worker_id, i)},
token=self.alice["token"],
)
if status != 201:
with lock:
errors.append((status, body))
threads = [threading.Thread(target=worker, args=(w,)) for w in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
self.assertEqual(errors, [])
status, page = request(
"GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", token=self.alice["token"]
)
self.assertEqual(status, 200)
ids = [m["id"] for m in page["items"]]
self.assertEqual(len(ids), 100)
self.assertEqual(len(set(ids)), 100)
if __name__ == "__main__":
unittest.main(verbosity=2)