Перенёс основу приложения из лабораторной 1

This commit is contained in:
2026-10-09 14:01:32 +03:00
parent 65003b6119
commit 6e19f1d9f0
17 changed files with 1721 additions and 15 deletions
+29 -15
View File
@@ -1,20 +1,34 @@
.git
.github
.gitignore
.env
.env.*
!.env.example
secrets
certs
volumes
data
backups
*.key
*.pem
*.p12
*.pfx
*.jks
.env.example
.venv
__pycache__
*.pyc
*.pyo
*.pyd
.Python
*.so
*.egg
*.egg-info
dist
build
.pytest_cache
.mypy_cache
.coverage
htmlcov
node_modules
evidence
.DS_Store
vendor
output
*.md
!README.md
!REPORT.md
!COURSE.md
!CONTRIBUTING.md
contracts/
evidence/
examples/
scripts/
tests/
student-tests/
.github/
+26
View File
@@ -0,0 +1,26 @@
# syntax=docker/dockerfile:1
FROM python:3.11-slim-bookworm
WORKDIR /app
# Create non-root user
RUN groupadd -r appuser && useradd -r -g appuser appuser
# Install dependencies first for layer caching
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Copy application source
COPY src/ ./src/
# Switch to non-root user
USER appuser
# Healthcheck
HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/live')" || exit 1
EXPOSE 8080
# Uvicorn handles SIGTERM gracefully (default timeout 10s)
CMD ["python", "-m", "uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8080", "--log-level", "info"]
+5
View File
@@ -0,0 +1,5 @@
fastapi==0.115.0
uvicorn[standard]==0.32.0
pydantic==2.9.2
python-multipart==0.0.12
matplotlib==3.9.2
View File
+135
View File
@@ -0,0 +1,135 @@
import uuid
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from pydantic import ValidationError as PydanticValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException
from src.models import ErrorResponse
from src.routes import chats, health, messages, users
from src.storage import storage
def create_app() -> FastAPI:
"""Создать и настроить приложение FastAPI."""
app = FastAPI(title="MTUSI Messenger Lab1", version="1.1.0")
@app.middleware("http")
async def add_request_id(request: Request, call_next):
"""Middleware: добавляет X-Request-Id и реализует ограничение очереди запросов (трек 2)."""
request_id = request.headers.get("X-Request-Id", "") or str(uuid.uuid4())
request.state.request_id = request_id
# Трек 2: ограничение очереди запросов — возвращаем 503 при переполнении
if not storage.acquire_request_slot():
return JSONResponse(
status_code=503,
content=ErrorResponse(
error={
"code": "unavailable",
"message": "сервер перегружен, попробуйте позже",
"request_id": request_id,
}
).model_dump(),
headers={"X-Request-Id": request_id},
)
try:
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
finally:
storage.release_request_slot()
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
"""Обработчик HTTPException: возвращает ошибку в формате контракта {"error": ...}."""
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
if isinstance(exc.detail, dict) and "error" in exc.detail:
return JSONResponse(
status_code=exc.status_code,
content=exc.detail,
headers={"X-Request-Id": request_id},
)
return JSONResponse(
status_code=exc.status_code,
content=ErrorResponse(
error={
"code": "internal_error",
"message": str(exc.detail),
"request_id": request_id,
}
).model_dump(),
headers={"X-Request-Id": request_id},
)
@app.exception_handler(RequestValidationError)
async def request_validation_handler(request: Request, exc: RequestValidationError):
"""Перехватываем ошибки валидации запроса (422 -> 400 по контракту)."""
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
errors = exc.errors()
messages = []
for err in errors:
loc = ".".join(str(x) for x in err.get("loc", []))
messages.append(f"{loc}: {err.get('msg', 'invalid')}")
return JSONResponse(
status_code=400,
content=ErrorResponse(
error={
"code": "invalid_request",
"message": "; ".join(messages),
"request_id": request_id,
}
).model_dump(),
headers={"X-Request-Id": request_id},
)
@app.exception_handler(PydanticValidationError)
async def validation_exception_handler(request: Request, exc: PydanticValidationError):
"""Перехватываем ошибки Pydantic (422 -> 400 по контракту)."""
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
errors = exc.errors()
messages = []
for err in errors:
loc = ".".join(str(x) for x in err.get("loc", []))
messages.append(f"{loc}: {err.get('msg', 'invalid')}")
return JSONResponse(
status_code=400,
content=ErrorResponse(
error={
"code": "invalid_request",
"message": "; ".join(messages),
"request_id": request_id,
}
).model_dump(),
headers={"X-Request-Id": request_id},
)
@app.exception_handler(Exception)
async def generic_exception_handler(request: Request, exc: Exception):
"""Обработчик непредвиденных исключений: скрываем детали, возвращаем 500."""
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
return JSONResponse(
status_code=500,
content=ErrorResponse(
error={
"code": "internal_error",
"message": "внутренняя ошибка сервера",
"request_id": request_id,
}
).model_dump(),
headers={"X-Request-Id": request_id},
)
# Подключаем роуты
app.include_router(health.router)
app.include_router(users.router)
app.include_router(chats.router)
app.include_router(messages.router)
return app
# Экземпляр приложения для uvicorn
app = create_app()
+9
View File
@@ -0,0 +1,9 @@
import os
import uvicorn
if __name__ == "__main__":
"""Точка входа: запуск Uvicorn с параметрами из переменных окружения."""
host = os.getenv("APP_HOST", "0.0.0.0")
port = int(os.getenv("APP_PORT", "8080"))
uvicorn.run("src.app:app", host=host, port=port, log_level="info")
+110
View File
@@ -0,0 +1,110 @@
from datetime import datetime, timezone
from typing import Optional
from pydantic import BaseModel, ConfigDict, Field, field_validator
def utc_now() -> str:
"""Возвращает текущее время в формате RFC 3339 UTC с суффиксом Z."""
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
class ErrorDetail(BaseModel):
"""Детали ошибки API."""
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
"""Стандартный ответ об ошибке."""
error: ErrorDetail
class Health(BaseModel):
"""Ответ проверки работоспособности."""
status: str = "ok"
class User(BaseModel):
"""Модель пользователя."""
id: str
username: str
display_name: str
created_at: str
class CreateUser(BaseModel):
"""Данные для создания пользователя."""
model_config = ConfigDict(extra="forbid")
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(..., min_length=1, max_length=100)
@field_validator("display_name")
@classmethod
def display_name_not_whitespace_only(cls, v: str) -> str:
"""Запрещаем display_name, состоящий только из пробельных символов."""
if v.strip() == "":
raise ValueError("display_name не может состоять только из пробелов")
return v
class Chat(BaseModel):
"""Модель чата."""
id: str
title: str
member_ids: list[str]
created_at: str
class CreateChat(BaseModel):
"""Данные для создания чата."""
model_config = ConfigDict(extra="forbid")
title: str = Field(..., min_length=1, max_length=100)
member_ids: list[str] = Field(..., min_length=1, max_length=100)
@field_validator("title")
@classmethod
def title_not_whitespace_only(cls, v: str) -> str:
"""Запрещаем title, состоящий только из пробельных символов."""
if v.strip() == "":
raise ValueError("title не может состоять только из пробелов")
return v
class Message(BaseModel):
"""Модель сообщения."""
id: str
chat_id: str
sender_id: str
text: str
created_at: str
class CreateMessage(BaseModel):
"""Данные для отправки сообщения."""
model_config = ConfigDict(extra="forbid")
text: str = Field(..., min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def text_not_whitespace_only(cls, v: str) -> str:
"""Запрещаем текст, состоящий только из пробельных символов."""
if v.strip() == "":
raise ValueError("текст не может состоять только из пробелов")
return v
class ChatPage(BaseModel):
"""Страница списка чатов с курсорной пагинацией."""
items: list[Chat]
next_cursor: Optional[str] = None
class MessagePage(BaseModel):
"""Страница истории сообщений с курсорной пагинацией."""
items: list[Message]
next_cursor: Optional[str] = None
View File
+82
View File
@@ -0,0 +1,82 @@
from uuid import UUID
from fastapi import APIRouter, Header, HTTPException, Request
from src.models import Chat, ChatPage, CreateChat
from src.routes.common import get_request_id, make_error, require_user
from src.storage import LimitExceeded, ValidationError, storage
router = APIRouter()
@router.post("/api/v1/chats", response_model=Chat, status_code=201)
async def create_chat(
request: Request,
body: CreateChat,
x_user_id: str | None = Header(None, alias="X-User-Id"),
):
"""Создать чат. Создатель обязательно должен входить в member_ids."""
request_id = get_request_id(request)
require_user(request, x_user_id)
try:
chat = storage.create_chat(body.title, body.member_ids, x_user_id)
return chat
except ValidationError as e:
raise HTTPException(
status_code=400,
detail=make_error("invalid_request", str(e), request_id).model_dump(),
)
except LimitExceeded as e:
raise HTTPException(
status_code=429,
detail=make_error("rate_limited", str(e), request_id).model_dump(),
)
@router.get("/api/v1/chats", response_model=ChatPage)
async def list_chats(
request: Request,
x_user_id: str | None = Header(None, alias="X-User-Id"),
limit: int = 50,
cursor: str | None = None,
):
"""Список чатов текущего пользователя с курсорной пагинацией."""
request_id = get_request_id(request)
require_user(request, x_user_id)
if limit < 1 or limit > 100:
raise HTTPException(
status_code=400,
detail=make_error("invalid_request", "limit должен быть от 1 до 100", request_id).model_dump(),
)
try:
items, next_cursor = storage.list_chats_for_user(x_user_id, cursor, limit)
return ChatPage(items=items, next_cursor=next_cursor)
except ValidationError as e:
raise HTTPException(
status_code=400,
detail=make_error("invalid_request", str(e), request_id).model_dump(),
)
@router.get("/api/v1/chats/{chat_id}", response_model=Chat)
async def get_chat(
request: Request,
chat_id: UUID,
x_user_id: str | None = Header(None, alias="X-User-Id"),
):
"""Получить чат по id. Доступен только участникам чата (чужой — 404)."""
request_id = get_request_id(request)
require_user(request, x_user_id)
chat_id_str = str(chat_id)
chat = storage.get_chat(chat_id_str)
if not chat or x_user_id not in chat.member_ids:
raise HTTPException(
status_code=404,
detail=make_error("not_found", "чат не найден", request_id).model_dump(),
)
return chat
+37
View File
@@ -0,0 +1,37 @@
"""Общие утилиты для всех роутов API.
Вынесено сюда, чтобы не повторять в каждом файле роутов (DRY).
"""
from fastapi import HTTPException, Request
from src.models import ErrorResponse
from src.storage import storage
def make_error(code: str, message: str, request_id: str) -> ErrorResponse:
"""Собрать стандартный ответ об ошибке по контракту API."""
return ErrorResponse(error={"code": code, "message": message, "request_id": request_id})
def get_request_id(request: Request) -> str:
"""Достать X-Request-Id из middleware. Если нет — сгенерировать новый."""
return getattr(request.state, "request_id", "") or str(id(request))
def require_user(request: Request, x_user_id: str | None) -> str:
"""Проверить, что пользователь передал валидный X-User-Id.
Возвращает user_id или выбрасывает HTTPException(401).
"""
request_id = get_request_id(request)
if not x_user_id:
raise HTTPException(
status_code=401,
detail=make_error("unauthorized", "отсутствует идентификатор пользователя", request_id).model_dump(),
)
user = storage.get_user(x_user_id)
if not user:
raise HTTPException(
status_code=401,
detail=make_error("unauthorized", "недействительный идентификатор пользователя", request_id).model_dump(),
)
return x_user_id
+30
View File
@@ -0,0 +1,30 @@
from fastapi import APIRouter
from src.models import Health
from src.storage import storage
router = APIRouter()
@router.get("/health/live")
async def liveness() -> Health:
"""Проверка жизни процесса. Всегда возвращает 200, если процесс работает."""
return Health(status="ok")
@router.get("/health/ready")
async def readiness() -> Health:
"""Проверка готовности принимать трафик.
Для lab1 возвращает 200, так как нет внешних зависимостей.
В следующих лабах здесь будет проверка БД и других сервисов.
"""
return Health(status="ok")
@router.get("/stats")
async def stats():
"""Текущая статистика сервера: количество пользователей, чатов, сообщений,
а также метрики rate limiting'а для наблюдения за деградацией.
"""
return storage.get_stats()
+74
View File
@@ -0,0 +1,74 @@
from uuid import UUID
from fastapi import APIRouter, Header, HTTPException, Request
from src.models import CreateMessage, Message, MessagePage
from src.routes.common import get_request_id, make_error, require_user
from src.storage import LimitExceeded, ValidationError, storage
router = APIRouter()
@router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201)
async def create_message(
request: Request,
chat_id: UUID,
body: CreateMessage,
x_user_id: str | None = Header(None, alias="X-User-Id"),
):
"""Отправить сообщение в чат. Отправитель определяется по X-User-Id."""
request_id = get_request_id(request)
require_user(request, x_user_id)
chat_id_str = str(chat_id)
chat = storage.get_chat(chat_id_str)
if not chat or x_user_id not in chat.member_ids:
raise HTTPException(
status_code=404,
detail=make_error("not_found", "чат не найден", request_id).model_dump(),
)
try:
msg = storage.create_message(chat_id_str, x_user_id, body.text)
return msg
except LimitExceeded as e:
raise HTTPException(
status_code=429,
detail=make_error("rate_limited", str(e), request_id).model_dump(),
)
@router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
async def list_messages(
request: Request,
chat_id: UUID,
x_user_id: str | None = Header(None, alias="X-User-Id"),
limit: int = 50,
cursor: str | None = None,
):
"""История сообщений чата с курсорной пагинацией. Доступно только участникам."""
request_id = get_request_id(request)
require_user(request, x_user_id)
chat_id_str = str(chat_id)
chat = storage.get_chat(chat_id_str)
if not chat or x_user_id not in chat.member_ids:
raise HTTPException(
status_code=404,
detail=make_error("not_found", "чат не найден", request_id).model_dump(),
)
if limit < 1 or limit > 100:
raise HTTPException(
status_code=400,
detail=make_error("invalid_request", "limit должен быть от 1 до 100", request_id).model_dump(),
)
try:
items, next_cursor = storage.list_messages(chat_id_str, cursor, limit)
return MessagePage(items=items, next_cursor=next_cursor)
except ValidationError as e:
raise HTTPException(
status_code=400,
detail=make_error("invalid_request", str(e), request_id).model_dump(),
)
+51
View File
@@ -0,0 +1,51 @@
from fastapi import APIRouter, Header, HTTPException, Request
from src.models import CreateUser, User
from src.routes.common import get_request_id, make_error
from src.storage import ConflictError, LimitExceeded, storage
router = APIRouter()
@router.post("/api/v1/users", response_model=User, status_code=201)
async def register_user(request: Request, body: CreateUser):
"""Создать нового пользователя. Публичный endpoint, не требует авторизации."""
request_id = get_request_id(request)
try:
user = storage.create_user(body.username, body.display_name)
return user
except ConflictError as e:
raise HTTPException(
status_code=409,
detail=make_error("conflict", str(e), request_id).model_dump(),
)
except LimitExceeded as e:
raise HTTPException(
status_code=429,
detail=make_error("rate_limited", str(e), request_id).model_dump(),
)
@router.get("/api/v1/users/me", response_model=User)
async def current_user(
request: Request,
x_user_id: str | None = Header(None, alias="X-User-Id"),
):
"""Получить текущего пользователя по заголовку X-User-Id.
Это учебный механизм: любой клиент может выдать себя за другого,
зная UUID пользователя. Настоящая аутентификация появится позже.
"""
request_id = get_request_id(request)
if not x_user_id:
raise HTTPException(
status_code=401,
detail=make_error("unauthorized", "отсутствует идентификатор пользователя", request_id).model_dump(),
)
user = storage.get_user(x_user_id)
if not user:
raise HTTPException(
status_code=401,
detail=make_error("unauthorized", "недействительный идентификатор пользователя", request_id).model_dump(),
)
return user
+339
View File
@@ -0,0 +1,339 @@
import base64
import binascii
from datetime import datetime
import json
import os
import threading
import time
import uuid
from src.models import Chat, Message, User, utc_now
_CURSOR_FIELDS = {"scope", "resource_id", "created_at", "id"}
class StorageLimits:
"""Лимиты хранилища для защиты от перегрузки (трек 2)."""
def __init__(self):
self.max_users = int(os.getenv("MAX_USERS", "1000"))
self.max_chats = int(os.getenv("MAX_CHATS", "1000"))
self.max_messages_total = int(os.getenv("MAX_MESSAGES", "10000"))
self.max_messages_per_chat = int(os.getenv("MAX_MESSAGES_PER_CHAT", "1000"))
self.max_request_queue = int(os.getenv("MAX_REQUEST_QUEUE", "100"))
self.max_messages_per_second = float(os.getenv("MAX_MESSAGES_PER_SECOND", "10.0"))
class InMemoryStorage:
"""Хранилище данных в оперативной памяти.
Все данные живут внутри одного процесса и исчезают при перезапуске.
Это требование текущей лабораторной — научиться работать с контейнерами
без внешних баз данных.
Для защиты от гонок используется threading.RLock.
"""
def __init__(self):
self._users: dict[str, User] = {}
self._users_by_username: dict[str, str] = {}
self._chats: dict[str, Chat] = {}
self._messages: dict[str, Message] = {}
self._chat_messages: dict[str, list[str]] = {}
self._lock = threading.RLock()
self._limits = StorageLimits()
self._request_count = 0
# Token bucket для ограничения сообщений в секунду (трек 2)
self._message_tokens = self._limits.max_messages_per_second
self._last_token_update = time.monotonic()
# Метрики для наблюдения за деградацией
self._rate_limited_count = 0
self._total_message_attempts = 0
@staticmethod
def _encode_cursor(scope: str, resource_id: str, created_at: str, item_id: str) -> str:
"""Собрать непрозрачный курсор, привязанный к конкретному ресурсу."""
payload = {
"scope": scope,
"resource_id": resource_id,
"created_at": created_at,
"id": item_id,
}
raw = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii")
@staticmethod
def _decode_cursor(cursor: str, expected_scope: str, expected_resource_id: str) -> tuple[str, str]:
"""Разобрать и проверить курсор.
Клиент видит курсор как непрозрачную строку, поэтому любые пустые,
повреждённые или относящиеся к другому ресурсу значения отклоняем.
"""
if cursor == "":
raise ValidationError("некорректный cursor")
allowed_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_="
if any(char not in allowed_chars for char in cursor) or "=" in cursor.rstrip("="):
raise ValidationError("некорректный cursor")
try:
raw = base64.b64decode(cursor.encode("ascii"), altchars=b"-_", validate=True)
payload = json.loads(raw.decode("utf-8"))
except (UnicodeEncodeError, UnicodeDecodeError, binascii.Error, json.JSONDecodeError):
raise ValidationError("некорректный cursor")
if not isinstance(payload, dict) or set(payload) != _CURSOR_FIELDS:
raise ValidationError("некорректный cursor")
if not all(isinstance(payload[field], str) for field in _CURSOR_FIELDS):
raise ValidationError("некорректный cursor")
if payload["scope"] != expected_scope or payload["resource_id"] != expected_resource_id:
raise ValidationError("некорректный cursor")
try:
uuid.UUID(payload["resource_id"])
uuid.UUID(payload["id"])
datetime.strptime(payload["created_at"], "%Y-%m-%dT%H:%M:%SZ")
except ValueError:
raise ValidationError("некорректный cursor")
return payload["created_at"], payload["id"]
# --- Пользователи ---
def create_user(self, username: str, display_name: str) -> User:
"""Создать пользователя. Проверяет лимит и уникальность username."""
with self._lock:
if len(self._users) >= self._limits.max_users:
raise LimitExceeded("превышен лимит пользователей")
if username in self._users_by_username:
raise ConflictError(f"username '{username}' уже занят")
user = User(
id=str(uuid.uuid4()),
username=username,
display_name=display_name,
created_at=utc_now(),
)
self._users[user.id] = user
self._users_by_username[user.username] = user.id
return user
def get_user(self, user_id: str) -> User | None:
"""Найти пользователя по UUID."""
with self._lock:
return self._users.get(user_id)
# --- Чаты ---
def create_chat(self, title: str, member_ids: list[str], creator_id: str) -> Chat:
"""Создать чат. Проверяет существование участников и лимиты."""
with self._lock:
if len(self._chats) >= self._limits.max_chats:
raise LimitExceeded("превышен лимит чатов")
seen = set()
for mid in member_ids:
if mid not in self._users:
raise ValidationError(f"пользователь {mid} не существует")
if mid in seen:
raise ValidationError("дублирующиеся member_ids")
seen.add(mid)
if creator_id not in seen:
raise ValidationError("создатель должен входить в member_ids")
chat = Chat(
id=str(uuid.uuid4()),
title=title,
member_ids=member_ids,
created_at=utc_now(),
)
self._chats[chat.id] = chat
self._chat_messages[chat.id] = []
return chat
def get_chat(self, chat_id: str) -> Chat | None:
"""Найти чат по UUID."""
with self._lock:
return self._chats.get(chat_id)
def list_chats_for_user(self, user_id: str, cursor: str | None, limit: int) -> tuple[list[Chat], str | None]:
"""Список чатов пользователя с курсорной пагинацией."""
with self._lock:
chats = [
chat for chat in self._chats.values()
if user_id in chat.member_ids
]
chats.sort(key=lambda c: (c.created_at, c.id))
if cursor is not None:
cursor_time, cursor_id = self._decode_cursor(cursor, "chats", user_id)
cursor_chat = self._chats.get(cursor_id)
if (
cursor_chat is None
or user_id not in cursor_chat.member_ids
or cursor_chat.created_at != cursor_time
):
raise ValidationError("некорректный cursor")
chats = [
c for c in chats
if (c.created_at, c.id) > (cursor_time, cursor_id)
]
page = chats[:limit]
next_cursor = None
if len(page) == limit and len(chats) > limit:
last = page[-1]
next_cursor = self._encode_cursor("chats", user_id, last.created_at, last.id)
return page, next_cursor
# --- Сообщения ---
def _refill_message_tokens(self):
"""Пополнить токены bucket'а пропорционально прошедшему времени."""
now = time.monotonic()
elapsed = now - self._last_token_update
if elapsed > 0:
self._message_tokens = min(
self._limits.max_messages_per_second,
self._message_tokens + elapsed * self._limits.max_messages_per_second,
)
self._last_token_update = now
def acquire_message_token(self) -> bool:
"""Попытаться взять токен из bucket'а для отправки сообщения.
Возвращает True, если токен есть и сообщение можно отправить.
False означает превышение rate limit → 429.
"""
with self._lock:
self._total_message_attempts += 1
self._refill_message_tokens()
if self._message_tokens >= 1.0:
self._message_tokens -= 1.0
return True
self._rate_limited_count += 1
return False
def create_message(self, chat_id: str, sender_id: str, text: str) -> Message:
"""Отправить сообщение. Проверяет лимиты и права доступа."""
with self._lock:
chat = self._chats.get(chat_id)
if not chat:
raise NotFoundError("чат не найден")
if sender_id not in chat.member_ids:
raise NotFoundError("чат не найден")
chat_msg_ids = self._chat_messages.get(chat_id, [])
if len(chat_msg_ids) >= self._limits.max_messages_per_chat:
raise LimitExceeded("превышен лимит сообщений в чате")
if len(self._messages) >= self._limits.max_messages_total:
raise LimitExceeded("превышен общий лимит сообщений")
# Проверяем rate limit (сообщений в секунду)
if not self.acquire_message_token():
raise LimitExceeded("превышен лимит сообщений в секунду")
msg = Message(
id=str(uuid.uuid4()),
chat_id=chat_id,
sender_id=sender_id,
text=text,
created_at=utc_now(),
)
self._messages[msg.id] = msg
chat_msg_ids.append(msg.id)
return msg
def list_messages(self, chat_id: str, cursor: str | None, limit: int) -> tuple[list[Message], str | None]:
"""История сообщений чата с курсорной пагинацией."""
with self._lock:
chat_msg_ids = self._chat_messages.get(chat_id, [])
messages = [self._messages[mid] for mid in chat_msg_ids]
messages.sort(key=lambda m: (m.created_at, m.id))
if cursor is not None:
cursor_time, cursor_id = self._decode_cursor(cursor, "messages", chat_id)
cursor_message = self._messages.get(cursor_id)
if (
cursor_message is None
or cursor_message.chat_id != chat_id
or cursor_message.created_at != cursor_time
):
raise ValidationError("некорректный cursor")
messages = [
m for m in messages
if (m.created_at, m.id) > (cursor_time, cursor_id)
]
page = messages[:limit]
next_cursor = None
if len(page) == limit and len(messages) > limit:
last = page[-1]
next_cursor = self._encode_cursor("messages", chat_id, last.created_at, last.id)
return page, next_cursor
# --- Очередь запросов (трек 2: управляемая деградация) ---
def acquire_request_slot(self) -> bool:
"""Занять слот в очереди запросов. False = переполнение → 503."""
with self._lock:
if self._request_count >= self._limits.max_request_queue:
return False
self._request_count += 1
return True
def release_request_slot(self):
"""Освободить слот в очереди запросов."""
with self._lock:
self._request_count = max(0, self._request_count - 1)
# --- Статистика ---
def get_stats(self) -> dict:
"""Текущая статистика хранилища и метрики деградации."""
with self._lock:
self._refill_message_tokens()
return {
"users": len(self._users),
"chats": len(self._chats),
"messages": len(self._messages),
"requests_in_flight": self._request_count,
"rate_limit": {
"max_messages_per_second": self._limits.max_messages_per_second,
"available_tokens": round(self._message_tokens, 2),
},
"metrics": {
"total_message_attempts": self._total_message_attempts,
"rate_limited_count": self._rate_limited_count,
},
}
class ValidationError(Exception):
"""Неверные входные данные — HTTP 400."""
pass
class NotFoundError(Exception):
"""Ресурс не найден или недоступен — HTTP 404."""
pass
class ConflictError(Exception):
"""Конфликт, например дублирующийся username — HTTP 409."""
pass
class LimitExceeded(Exception):
"""Превышен лимит ресурсов — HTTP 429 или 503."""
pass
# Единственное хранилище на весь процесс
storage = InMemoryStorage()
+217
View File
@@ -0,0 +1,217 @@
#!/usr/bin/env python3
"""Сбор метрик деградации и автоматическая генерация графиков.
Запуск:
# 1. Запустить сервер с лимитами (в отдельном терминале):
export MAX_USERS=100 MAX_CHATS=100 MAX_MESSAGES=1000 MAX_MESSAGES_PER_CHAT=100 MAX_REQUEST_QUEUE=50 MAX_MESSAGES_PER_SECOND=5
python -m uvicorn src.app:app --host 0.0.0.0 --port 8081
# 2. Запустить сборщик:
python student-tests/metrics_collector.py
# 3. CSV и графики появятся в папке metrics/
"""
import csv
import json
import os
import threading
import time
import urllib.request
import uuid
# matplotlib для построения графиков
import matplotlib
matplotlib.use("Agg") # неинтерактивный бэкенд (без GUI)
import matplotlib.pyplot as plt
BASE_URL = "http://localhost:8081"
METRICS_DIR = "metrics"
CSV_FILE = os.path.join(METRICS_DIR, "metrics_data.csv")
DURATION_SECONDS = 15
BURST_INTERVAL = 0.05 # отправлять сообщение каждые 50 мс = 20/сек
def request(method, path, body=None, headers=None):
h = {"Accept": "application/json"}
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
else:
raw = None
h.update(headers or {})
req = urllib.request.Request(BASE_URL + path, data=raw, headers=h, method=method)
try:
resp = urllib.request.urlopen(req)
return json.loads(resp.read().decode()) if resp.read else None
except urllib.error.HTTPError as e:
return {"error": {"code": e.code}}
def get_stats():
"""Получить текущую статистику с сервера."""
req = urllib.request.Request(BASE_URL + "/stats", method="GET")
try:
resp = urllib.request.urlopen(req)
return json.loads(resp.read().decode())
except Exception:
return None
def ensure_dir(path):
"""Создать папку, если её нет."""
os.makedirs(path, exist_ok=True)
def plot_metrics(metrics_log):
"""Построить графики по собранным метрикам и сохранить в metrics/."""
ensure_dir(METRICS_DIR)
times = [m["time"] for m in metrics_log]
# Нормализуем время: начало = 0
t0 = times[0] if times else 0
times_norm = [t - t0 for t in times]
total_attempts = [m["total_attempts"] for m in metrics_log]
rate_limited = [m["rate_limited"] for m in metrics_log]
available_tokens = [m["available_tokens"] for m in metrics_log]
messages = [m["messages"] for m in metrics_log]
# График 1: Нагрузка и ошибки
fig, ax1 = plt.subplots(figsize=(10, 5))
ax1.set_xlabel("Время, сек")
ax1.set_ylabel("Количество")
ax1.plot(times_norm, total_attempts, "b-", label="Всего попыток", linewidth=2)
ax1.plot(times_norm, rate_limited, "r-", label="Отклонено (429)", linewidth=2)
ax1.plot(times_norm, messages, "g-", label="Создано сообщений", linewidth=2)
ax1.legend(loc="upper left")
ax1.grid(True, alpha=0.3)
ax1.set_title("Нагрузка и ошибки при rate limiting")
plt.tight_layout()
path1 = os.path.join(METRICS_DIR, "load_and_errors.png")
fig.savefig(path1, dpi=150)
plt.close(fig)
print(f" Сохранён: {path1}")
# График 2: Токены bucket
fig, ax = plt.subplots(figsize=(10, 5))
ax.set_xlabel("Время, сек")
ax.set_ylabel("Доступные токены")
ax.fill_between(times_norm, available_tokens, alpha=0.4, color="orange")
ax.plot(times_norm, available_tokens, "orange", linewidth=2, label="Токены в bucket")
ax.axhline(y=5, color="gray", linestyle="--", alpha=0.5, label="MAX_MESSAGES_PER_SECOND=5")
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_title("Состояние token bucket")
plt.tight_layout()
path2 = os.path.join(METRICS_DIR, "tokens.png")
fig.savefig(path2, dpi=150)
plt.close(fig)
print(f" Сохранён: {path2}")
# График 3: Соотношение успех/отказ (кумулятивное)
fig, ax = plt.subplots(figsize=(10, 5))
success = [total_attempts[i] - rate_limited[i] for i in range(len(total_attempts))]
ax.set_xlabel("Время, сек")
ax.set_ylabel("Количество")
ax.stackplot(
times_norm,
success,
rate_limited,
labels=["Успешно", "Отклонено (429)"],
colors=["#2ecc71", "#e74c3c"],
alpha=0.8,
)
ax.legend(loc="upper left")
ax.grid(True, alpha=0.3)
ax.set_title("Успешные запросы vs отказы (кумулятивно)")
plt.tight_layout()
path3 = os.path.join(METRICS_DIR, "success_vs_rejected.png")
fig.savefig(path3, dpi=150)
plt.close(fig)
print(f" Сохранён: {path3}")
return path1, path2, path3
def main():
print("=== Сбор метрик деградации и генерация графиков ===")
print(f"Результат: папка {METRICS_DIR}/")
print(f"Длительность: {DURATION_SECONDS} секунд")
print()
# Создаём пользователей и чат
alice = request("POST", "/api/v1/users", body={"username": "metrics_alice_" + uuid.uuid4().hex[:6], "display_name": "Alice"})
bob = request("POST", "/api/v1/users", body={"username": "metrics_bob_" + uuid.uuid4().hex[:6], "display_name": "Bob"})
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Metrics", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
)
chat_id = chat["id"]
# Поток для сбора метрик
metrics_log = []
stop_event = threading.Event()
def collector():
while not stop_event.is_set():
stats = get_stats()
if stats:
metrics_log.append({
"time": round(time.time(), 2),
"total_attempts": stats.get("metrics", {}).get("total_message_attempts", 0),
"rate_limited": stats.get("metrics", {}).get("rate_limited_count", 0),
"available_tokens": stats.get("rate_limit", {}).get("available_tokens", 0),
"messages": stats.get("messages", 0),
"requests_in_flight": stats.get("requests_in_flight", 0),
})
time.sleep(0.1)
collector_thread = threading.Thread(target=collector)
collector_thread.start()
# Нагрузка: отправляем сообщения быстрее лимита
print("Начинаем нагрузку...")
start = time.time()
msg_count = 0
while time.time() - start < DURATION_SECONDS:
request(
"POST",
f"/api/v1/chats/{chat_id}/messages",
body={"text": f"msg{msg_count}"},
headers={"X-User-Id": alice["id"]},
)
msg_count += 1
time.sleep(BURST_INTERVAL)
print(f"Отправлено {msg_count} сообщений. Ждём завершения сбора...")
time.sleep(2) # даём время собрать метрики после нагрузки
stop_event.set()
collector_thread.join()
# Сохраняем CSV
ensure_dir(METRICS_DIR)
with open(CSV_FILE, "w", newline="", encoding="utf-8") as f:
writer = csv.DictWriter(f, fieldnames=[
"time", "total_attempts", "rate_limited", "available_tokens",
"messages", "requests_in_flight",
])
writer.writeheader()
writer.writerows(metrics_log)
print(f"\nСохранено {len(metrics_log)} записей в {CSV_FILE}")
# Строим графики
print("\nСтроим графики...")
paths = plot_metrics(metrics_log)
print("\n=== ГОТОВО ===")
print(f"Папка с графиками: {METRICS_DIR}/")
for p in paths:
print(f" - {p}")
print("\nЭти файлы можно вставить в REPORT.md как доказательства работы rate limiting.")
if __name__ == "__main__":
main()
+244
View File
@@ -0,0 +1,244 @@
#!/usr/bin/env python3
"""Тесты трека 2: управляемая деградация — лимиты и восстановление.
Запуск:
# В одном терминале запустите сервер с агрессивными лимитами:
$env:MAX_USERS="10"; $env:MAX_CHATS="10"; $env:MAX_MESSAGES="50"; $env:MAX_MESSAGES_PER_CHAT="5"; $env:MAX_REQUEST_QUEUE="10"; $env:MAX_MESSAGES_PER_SECOND="10"; .venv\Scripts\python -m uvicorn src.app:app --host 0.0.0.0 --port 8081
ИЛИ
export MAX_USERS=10
export MAX_CHATS=10
export MAX_MESSAGES=50
export MAX_MESSAGES_PER_CHAT=5
export MAX_REQUEST_QUEUE=10
export MAX_MESSAGES_PER_SECOND=10
python -m uvicorn src.app:app --host 0.0.0.0 --port 8081
# В другом терминале:
.venv\Scripts\python student-tests/test_degradation.py
"""
import json
import urllib.error
import urllib.request
import uuid
BASE_URL = "http://localhost:8081"
def request(method, path, body=None, headers=None, expected=200):
"""Выполнить HTTP-запрос и проверить статус ответа."""
h = {"Accept": "application/json"}
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
else:
raw = None
h.update(headers or {})
req = urllib.request.Request(BASE_URL + path, data=raw, headers=h, method=method)
try:
resp = urllib.request.urlopen(req)
except urllib.error.HTTPError as e:
resp = e
if resp.code != expected:
data = resp.read().decode()
raise AssertionError(
f"{method} {path}: ожидался {expected}, получен {resp.code}: {data}"
)
data = resp.read()
return json.loads(data.decode()) if data else None
def test_user_limit():
"""При превышении MAX_USERS сервер возвращает 429."""
# Создаём пользователей до лимита (некоторые уже созданы в main)
for i in range(8):
request(
"POST",
"/api/v1/users",
body={"username": f"u_limit_{i}_" + uuid.uuid4().hex[:8], "display_name": f"User{i}"},
expected=201,
)
# Следующий пользователь должен получить 429
req = urllib.request.Request(
BASE_URL + "/api/v1/users",
data=json.dumps({"username": "u_limit_extra_" + uuid.uuid4().hex[:8], "display_name": "Extra"}).encode(),
headers={"Content-Type": "application/json"},
method="POST",
)
try:
urllib.request.urlopen(req)
raise AssertionError("ожидалась ошибка 429")
except urllib.error.HTTPError as e:
assert e.code == 429, f"ожидался 429, получен {e.code}"
data = json.loads(e.read().decode())
assert data["error"]["code"] == "rate_limited"
print("PASS: user_limit (429 при превышении MAX_USERS)")
def test_message_limit_per_chat(alice, bob):
"""При превышении MAX_MESSAGES_PER_CHAT сервер возвращает 429."""
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Limited", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
# Отправляем сообщения до лимита
for i in range(5):
request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
body={"text": f"msg{i}"},
headers={"X-User-Id": alice["id"]},
expected=201,
)
# Следующее сообщение должно получить 429
req = urllib.request.Request(
BASE_URL + f"/api/v1/chats/{chat['id']}/messages",
data=json.dumps({"text": "overflow"}).encode(),
headers={"Content-Type": "application/json", "X-User-Id": alice["id"]},
method="POST",
)
try:
urllib.request.urlopen(req)
raise AssertionError("ожидалась ошибка 429")
except urllib.error.HTTPError as e:
assert e.code == 429, f"ожидался 429, получен {e.code}"
data = json.loads(e.read().decode())
assert data["error"]["code"] == "rate_limited"
print("PASS: message_limit_per_chat (429 при превышении лимита сообщений)")
def test_recovery_after_load(alice, bob):
"""После снятия нагрузки сервер восстанавливается и принимает новые запросы."""
import time
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Recovery", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
# Заполняем чат до лимита
for i in range(5):
request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
body={"text": f"msg{i}"},
headers={"X-User-Id": alice["id"]},
expected=201,
)
# Проверяем отказ (лимит чата)
req = urllib.request.Request(
BASE_URL + f"/api/v1/chats/{chat['id']}/messages",
data=json.dumps({"text": "overflow"}).encode(),
headers={"Content-Type": "application/json", "X-User-Id": alice["id"]},
method="POST",
)
try:
urllib.request.urlopen(req)
raise AssertionError("ожидалась ошибка 429")
except urllib.error.HTTPError as e:
assert e.code == 429
# Пауза: даём bucket'у rate limit пополниться
time.sleep(1.5)
# Создаём новый чат — в нём лимит сообщений не исчерпан
chat2 = request(
"POST",
"/api/v1/chats",
body={"title": "Recovery2", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
# Новый запрос проходит — сервер восстановился
request(
"POST",
f"/api/v1/chats/{chat2['id']}/messages",
body={"text": "after load"},
headers={"X-User-Id": alice["id"]},
expected=201,
)
print("PASS: recovery_after_load (сервер восстанавливается после снятия нагрузки)")
def test_rate_limit(alice, bob):
"""При превышении MAX_MESSAGES_PER_SECOND сервер возвращает 429,
а после паузы снова принимает сообщения."""
import time
# Создаём несколько чатов, чтобы не упираться в лимит сообщений на чат
chats = []
for c in range(4):
chat = request(
"POST",
"/api/v1/chats",
body={"title": f"RateLimit{c}", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
chats.append(chat)
# Отправляем сообщения подряд быстрее, чем лимит (10/сек)
# Bucket = 10 токенов, отправляем 15 сообщений без задержки
# Распределяем по чатам, чтобы не исчерпать MAX_MESSAGES_PER_CHAT
accepted = 0
rejected = 0
for i in range(15):
chat = chats[i % len(chats)]
req = urllib.request.Request(
BASE_URL + f"/api/v1/chats/{chat['id']}/messages",
data=json.dumps({"text": f"burst{i}"}).encode(),
headers={"Content-Type": "application/json", "X-User-Id": alice["id"]},
method="POST",
)
try:
urllib.request.urlopen(req)
accepted += 1
except urllib.error.HTTPError as e:
if e.code == 429:
rejected += 1
else:
raise AssertionError(f"неожиданный код {e.code}")
assert accepted >= 9, f"ожидали минимум 9 успешных, получили {accepted}"
assert rejected >= 1, f"ожидали минимум 1 отказ (429), получили {rejected}"
print(f"PASS: rate_limit ({accepted} принято, {rejected} отклонено при burst)")
# Ждём, пока bucket пополнится (1 секунды достаточно для 10 токенов)
time.sleep(1.2)
# После паузы сообщение должно пройти — сервер восстановился
request(
"POST",
f"/api/v1/chats/{chats[0]['id']}/messages",
body={"text": "after cooldown"},
headers={"X-User-Id": alice["id"]},
expected=201,
)
print("PASS: rate_limit_recovery (после паузы сервер снова принимает сообщения)")
def main():
print("Проверка деградации на сервере localhost:8081 с лимитами...")
# Создаём двух пользователей для всех тестов
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:8], "display_name": "Alice"}, expected=201)
bob = request("POST", "/api/v1/users", body={"username": "u_bob_" + uuid.uuid4().hex[:8], "display_name": "Bob"}, expected=201)
test_user_limit()
test_message_limit_per_chat(alice, bob)
test_recovery_after_load(alice, bob)
test_rate_limit(alice, bob)
print("\n=== ВСЕ ТЕСТЫ ДЕГРАДАЦИИ ПРОЙДЕНЫ ===")
if __name__ == "__main__":
main()
+333
View File
@@ -0,0 +1,333 @@
#!/usr/bin/env python3
"""Собственные тесты студента для lab1: негативные сценарии и конкурентность."""
import base64
import concurrent.futures
import json
import urllib.error
import urllib.parse
import urllib.request
import uuid
BASE_URL = "http://localhost:8080"
def request(method, path, body=None, headers=None, expected=200):
"""Выполнить HTTP-запрос и проверить статус ответа."""
h = {"Accept": "application/json"}
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
h["Content-Type"] = "application/json"
else:
raw = None
h.update(headers or {})
req = urllib.request.Request(BASE_URL + path, data=raw, headers=h, method=method)
try:
resp = urllib.request.urlopen(req)
except urllib.error.HTTPError as e:
resp = e
if resp.code != expected:
data = resp.read().decode()
raise AssertionError(
f"{method} {path}: ожидался {expected}, получен {resp.code}: {data}"
)
data = resp.read()
return json.loads(data.decode()) if data else None
def test_invalid_json():
"""Некорректный JSON должен возвращать 400."""
req = urllib.request.Request(
BASE_URL + "/api/v1/users",
data=b"{not json",
headers={"Content-Type": "application/json"},
method="POST",
)
try:
urllib.request.urlopen(req)
raise AssertionError("ожидалась ошибка 400")
except urllib.error.HTTPError as e:
assert e.code == 400, f"ожидался 400, получен {e.code}"
data = json.loads(e.read().decode())
assert data["error"]["code"] == "invalid_request"
print("PASS: invalid_json")
def test_empty_message():
"""Пустой или пробельный текст сообщения должен возвращать 400."""
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:12], "display_name": "Alice"}, expected=201)
bob = request("POST", "/api/v1/users", body={"username": "u_bob_" + uuid.uuid4().hex[:12], "display_name": "Bob"}, expected=201)
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Test", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
for text in ["", " ", "\t\n"]:
req = urllib.request.Request(
BASE_URL + f"/api/v1/chats/{chat['id']}/messages",
data=json.dumps({"text": text}).encode(),
headers={"Content-Type": "application/json", "X-User-Id": alice["id"]},
method="POST",
)
try:
urllib.request.urlopen(req)
raise AssertionError(f"ожидалась ошибка 400 для текста {repr(text)}")
except urllib.error.HTTPError as e:
assert e.code == 400, f"ожидался 400, получен {e.code}"
print("PASS: empty_message")
def test_duplicate_username():
"""Дублирующийся username должен возвращать 409."""
username = "u_dup_" + uuid.uuid4().hex[:12]
request(
"POST",
"/api/v1/users",
body={"username": username, "display_name": "First"},
expected=201,
)
req = urllib.request.Request(
BASE_URL + "/api/v1/users",
data=json.dumps({"username": username, "display_name": "Second"}).encode(),
headers={"Content-Type": "application/json"},
method="POST",
)
try:
urllib.request.urlopen(req)
raise AssertionError("ожидалась ошибка 409")
except urllib.error.HTTPError as e:
assert e.code == 409, f"ожидался 409, получен {e.code}"
print("PASS: duplicate_username")
def test_extra_fields_rejected():
"""Лишние JSON-поля в пользователе, чате и сообщении должны возвращать 400."""
request(
"POST",
"/api/v1/users",
body={"username": "u_extra_" + uuid.uuid4().hex[:12], "display_name": "Extra", "role": "admin"},
expected=400,
)
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:12], "display_name": "Alice"}, expected=201)
bob = request("POST", "/api/v1/users", body={"username": "u_bob_" + uuid.uuid4().hex[:12], "display_name": "Bob"}, expected=201)
request(
"POST",
"/api/v1/chats",
body={"title": "Extra", "member_ids": [alice["id"], bob["id"]], "owner_id": alice["id"]},
headers={"X-User-Id": alice["id"]},
expected=400,
)
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Strict", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
body={"text": "hello", "sender_id": bob["id"]},
headers={"X-User-Id": alice["id"]},
expected=400,
)
print("PASS: extra_fields_rejected")
def test_foreign_chat():
"""Посторонний пользователь не должен иметь доступ к чужому чату (404)."""
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:12], "display_name": "Alice"}, expected=201)
bob = request("POST", "/api/v1/users", body={"username": "u_bob_" + uuid.uuid4().hex[:12], "display_name": "Bob"}, expected=201)
eve = request("POST", "/api/v1/users", body={"username": "u_eve_" + uuid.uuid4().hex[:12], "display_name": "Eve"}, expected=201)
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Secret", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
# Eve не может прочитать чат
req = urllib.request.Request(
BASE_URL + f"/api/v1/chats/{chat['id']}",
headers={"X-User-Id": eve["id"]},
method="GET",
)
try:
urllib.request.urlopen(req)
raise AssertionError("ожидалась ошибка 404")
except urllib.error.HTTPError as e:
assert e.code == 404, f"ожидался 404, получен {e.code}"
print("PASS: foreign_chat")
def test_pagination():
"""Курсорная пагинация не должна пропускать или дублировать сообщения."""
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:12], "display_name": "Alice"}, expected=201)
bob = request("POST", "/api/v1/users", body={"username": "u_bob_" + uuid.uuid4().hex[:12], "display_name": "Bob"}, expected=201)
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Pages", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
texts = [f"msg{i}" for i in range(5)]
for t in texts:
request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
body={"text": t},
headers={"X-User-Id": alice["id"]},
expected=201,
)
all_ids = []
cursor = None
while True:
url = f"/api/v1/chats/{chat['id']}/messages?limit=2"
if cursor:
url += f"&cursor={cursor}"
page = request("GET", url, headers={"X-User-Id": alice["id"]})
all_ids.extend([m["id"] for m in page["items"]])
cursor = page.get("next_cursor")
if cursor is None:
break
assert len(all_ids) == 5, f"ожидалось 5 сообщений, получено {len(all_ids)}"
assert len(set(all_ids)) == 5, "обнаружены дублирующиеся сообщения в пагинации"
print("PASS: pagination")
def test_cursor_validation():
"""Курсор должен быть непустым, корректным и привязанным к своему чату."""
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:12], "display_name": "Alice"}, expected=201)
bob = request("POST", "/api/v1/users", body={"username": "u_bob_" + uuid.uuid4().hex[:12], "display_name": "Bob"}, expected=201)
chat1 = request(
"POST",
"/api/v1/chats",
body={"title": "Cursor1", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
chat2 = request(
"POST",
"/api/v1/chats",
body={"title": "Cursor2", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
for text in ["first", "second"]:
request(
"POST",
f"/api/v1/chats/{chat1['id']}/messages",
body={"text": text},
headers={"X-User-Id": alice["id"]},
expected=201,
)
page = request(
"GET",
f"/api/v1/chats/{chat1['id']}/messages?limit=1",
headers={"X-User-Id": alice["id"]},
)
cursor = page["next_cursor"]
quoted_cursor = urllib.parse.quote(cursor, safe="")
request(
"GET",
f"/api/v1/chats/{chat2['id']}/messages?cursor={quoted_cursor}",
headers={"X-User-Id": alice["id"]},
expected=400,
)
bad_content_cursor = base64.urlsafe_b64encode(b"{}").decode("ascii")
for bad_cursor in ["", "not-base64", "abcd", bad_content_cursor]:
request(
"GET",
f"/api/v1/chats/{chat1['id']}/messages?cursor={urllib.parse.quote(bad_cursor, safe='')}",
headers={"X-User-Id": alice["id"]},
expected=400,
)
print("PASS: cursor_validation")
def test_invalid_chat_uuid():
"""Некорректный UUID чата должен давать 400, а не 404."""
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:12], "display_name": "Alice"}, expected=201)
headers = {"X-User-Id": alice["id"]}
request("GET", "/api/v1/chats/not-a-uuid", headers=headers, expected=400)
request("GET", "/api/v1/chats/not-a-uuid/messages", headers=headers, expected=400)
request(
"POST",
"/api/v1/chats/not-a-uuid/messages",
body={"text": "hello"},
headers=headers,
expected=400,
)
print("PASS: invalid_chat_uuid")
def test_concurrent_messages():
"""Конкурентная отправка: 100 сообщений от 10 клиентов, все должны быть уникальны."""
alice = request("POST", "/api/v1/users", body={"username": "u_alice_" + uuid.uuid4().hex[:12], "display_name": "Alice"}, expected=201)
bob = request("POST", "/api/v1/users", body={"username": "u_bob_" + uuid.uuid4().hex[:12], "display_name": "Bob"}, expected=201)
chat = request(
"POST",
"/api/v1/chats",
body={"title": "Concurrent", "member_ids": [alice["id"], bob["id"]]},
headers={"X-User-Id": alice["id"]},
expected=201,
)
def send(i):
actor = alice if i % 2 == 0 else bob
return request(
"POST",
f"/api/v1/chats/{chat['id']}/messages",
body={"text": f"message {i}"},
headers={"X-User-Id": actor["id"]},
expected=201,
)
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as ex:
futures = [ex.submit(send, i) for i in range(100)]
results = [f.result() for f in concurrent.futures.as_completed(futures)]
msg_ids = [r["id"] for r in results]
assert len(set(msg_ids)) == 100, f"ожидалось 100 уникальных сообщений, получено {len(set(msg_ids))}"
# Проверяем, что все 100 сообщений доступны для чтения
page = request(
"GET",
f"/api/v1/chats/{chat['id']}/messages?limit=100",
headers={"X-User-Id": alice["id"]},
)
assert len(page["items"]) == 100, f"ожидалось 100 элементов, получено {len(page['items'])}"
print("PASS: concurrent_messages (100 уникальных сообщений от 10 потоков)")
def main():
test_invalid_json()
test_empty_message()
test_duplicate_username()
test_extra_fields_rejected()
test_foreign_chat()
test_pagination()
test_cursor_validation()
test_invalid_chat_uuid()
test_concurrent_messages()
print("\n=== ВСЕ СОБСТВЕННЫЕ ТЕСТЫ ПРОЙДЕНЫ ===")
if __name__ == "__main__":
main()