diff --git a/.dockerignore b/.dockerignore index bc16e556..ebf87519 100644 --- a/.dockerignore +++ b/.dockerignore @@ -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/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..17aaadbb --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..c2ddff62 --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app.py b/src/app.py new file mode 100644 index 00000000..31ab0839 --- /dev/null +++ b/src/app.py @@ -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() diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..38862ac0 --- /dev/null +++ b/src/main.py @@ -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") diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..17793696 --- /dev/null +++ b/src/models.py @@ -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 diff --git a/src/routes/__init__.py b/src/routes/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/routes/chats.py b/src/routes/chats.py new file mode 100644 index 00000000..8484a934 --- /dev/null +++ b/src/routes/chats.py @@ -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 diff --git a/src/routes/common.py b/src/routes/common.py new file mode 100644 index 00000000..a99fb871 --- /dev/null +++ b/src/routes/common.py @@ -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 diff --git a/src/routes/health.py b/src/routes/health.py new file mode 100644 index 00000000..1940e52a --- /dev/null +++ b/src/routes/health.py @@ -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() diff --git a/src/routes/messages.py b/src/routes/messages.py new file mode 100644 index 00000000..d9af564d --- /dev/null +++ b/src/routes/messages.py @@ -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(), + ) diff --git a/src/routes/users.py b/src/routes/users.py new file mode 100644 index 00000000..2f7aee76 --- /dev/null +++ b/src/routes/users.py @@ -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 diff --git a/src/storage.py b/src/storage.py new file mode 100644 index 00000000..6fc74edf --- /dev/null +++ b/src/storage.py @@ -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() diff --git a/student-tests/metrics_collector.py b/student-tests/metrics_collector.py new file mode 100644 index 00000000..085b1164 --- /dev/null +++ b/student-tests/metrics_collector.py @@ -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() diff --git a/student-tests/test_degradation.py b/student-tests/test_degradation.py new file mode 100644 index 00000000..8783a312 --- /dev/null +++ b/student-tests/test_degradation.py @@ -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() diff --git a/student-tests/test_lab1.py b/student-tests/test_lab1.py new file mode 100644 index 00000000..d5830887 --- /dev/null +++ b/student-tests/test_lab1.py @@ -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()