Перенёс основу приложения из лабораторной 1
This commit is contained in:
+29
-15
@@ -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
@@ -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"]
|
||||
@@ -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
|
||||
+135
@@ -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()
|
||||
@@ -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
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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(),
|
||||
)
|
||||
@@ -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
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user