feat: перенос структуры приложения из второй лабы

This commit is contained in:
Ильяс
2026-10-24 16:58:27 +03:00
parent 0ab3a341aa
commit df42648939
21 changed files with 1974 additions and 0 deletions
+27
View File
@@ -0,0 +1,27 @@
FROM python:3.12-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
APP_HOST=0.0.0.0 \
APP_PORT=8080
RUN groupadd -g 10001 appuser && \
useradd -u 10001 -g appuser -s /sbin/nologin -M appuser
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ ./app/
RUN chown -R appuser:appuser /app
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live')" || exit 1
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "10"]
+1
View File
@@ -0,0 +1 @@
"""Messenger application package."""
+27
View File
@@ -0,0 +1,27 @@
from __future__ import annotations
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
_hasher = PasswordHasher()
def hash_password(password: str) -> str:
"""Хэширует пароль с использованием Argon2id."""
return _hasher.hash(password)
def verify_password(hash_str: str, password: str) -> bool:
"""Проверяет пароль на соответствие хэшу Argon2id."""
try:
return _hasher.verify(hash_str, password)
except VerifyMismatchError:
return False
except Exception:
return False
def generate_session_token() -> str:
"""Генерирует криптографически стойкий непрозрачный токен сессии (256 бит энтропии)."""
return secrets.token_urlsafe(32)
+33
View File
@@ -0,0 +1,33 @@
from __future__ import annotations
import os
from pathlib import Path
def _get_val(env_name: str, file_env_name: str | None = None, default: str = "") -> str:
if file_env_name and file_env_name in os.environ:
file_path = Path(os.environ[file_env_name])
if file_path.is_file():
return file_path.read_text(encoding="utf-8").strip()
return os.getenv(env_name, default)
APP_HOST: str = os.getenv("APP_HOST", "0.0.0.0")
APP_PORT: int = int(os.getenv("APP_PORT", "8080"))
APP_ENV: str = os.getenv("APP_ENV", "lab")
LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
SESSION_TTL_SECONDS: int = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
SESSION_STORE: str = os.getenv("SESSION_STORE", "redis").lower()
DATABASE_URL: str = _get_val(
"DATABASE_URL",
"DATABASE_URL_FILE",
"postgresql://postgres:postgres@postgres:5432/messenger",
)
CACHE_URL: str = _get_val(
"CACHE_URL",
"CACHE_URL_FILE",
"redis://redis:6379/0",
)
+30
View File
@@ -0,0 +1,30 @@
from __future__ import annotations
from fastapi import Depends, Header, Request
from app.errors import UnauthorizedError
from app.schemas import UserResponse
from app.storage import storage
async def get_current_token(
authorization: str | None = Header(default=None, alias="Authorization"),
) -> str:
if not authorization or not authorization.strip():
raise UnauthorizedError("Отсутствует заголовок Authorization")
parts = authorization.strip().split(maxsplit=1)
if len(parts) != 2 or parts[0].lower() != "bearer":
raise UnauthorizedError("Неверная схема авторизации (ожидается Bearer)")
token = parts[1].strip()
if not token:
raise UnauthorizedError("Пустой Bearer токен")
return token
async def get_current_user(token: str = Depends(get_current_token)) -> UserResponse:
user = await storage.get_session_user(token)
if not user:
raise UnauthorizedError("Недействительная или истекшая сессия")
return user
+218
View File
@@ -0,0 +1,218 @@
import asyncio
import logging
import uuid
import asyncpg
from fastapi import FastAPI, Request, status
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
import redis.exceptions
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.schemas import ErrorCode, ErrorDetail, ErrorResponse
class StorageError(Exception):
pass
class UnavailableError(StorageError):
pass
class InvalidRequestError(StorageError):
pass
class NotFoundError(StorageError):
pass
class ConflictError(StorageError):
pass
class UnauthorizedError(StorageError):
pass
logger = logging.getLogger("app.errors")
def get_request_id(request: Request) -> str:
req_id = getattr(request.state, "request_id", None)
if not req_id:
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
return req_id
def make_error_response(
status_code: int,
code: ErrorCode,
message: str,
request_id: str,
headers: dict[str, str] | None = None,
) -> JSONResponse:
payload = ErrorResponse(
error=ErrorDetail(code=code, message=message, request_id=request_id)
).model_dump()
resp_headers = {"X-Request-Id": request_id, "Content-Type": "application/json"}
if headers:
resp_headers.update(headers)
return JSONResponse(
status_code=status_code,
content=payload,
headers=resp_headers,
)
def register_error_handlers(app: FastAPI) -> None:
@app.exception_handler(InvalidRequestError)
async def invalid_request_handler(
request: Request, exc: InvalidRequestError
) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, str(exc), req_id
)
@app.exception_handler(UnauthorizedError)
async def unauthorized_handler(
request: Request, exc: UnauthorizedError
) -> JSONResponse:
req_id = get_request_id(request)
scheme = (
'Basic realm="messenger", charset="UTF-8"'
if request.url.path == "/api/v1/auth/sessions"
else 'Bearer realm="messenger"'
)
return make_error_response(
status.HTTP_401_UNAUTHORIZED,
ErrorCode.UNAUTHORIZED,
str(exc),
req_id,
headers={"WWW-Authenticate": scheme},
)
@app.exception_handler(NotFoundError)
async def not_found_handler(request: Request, exc: NotFoundError) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_404_NOT_FOUND, ErrorCode.NOT_FOUND, str(exc), req_id
)
@app.exception_handler(ConflictError)
async def conflict_handler(request: Request, exc: ConflictError) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_409_CONFLICT, ErrorCode.CONFLICT, str(exc), req_id
)
@app.exception_handler(RequestValidationError)
async def validation_error_handler(
request: Request, exc: RequestValidationError
) -> JSONResponse:
req_id = get_request_id(request)
errors = exc.errors()
messages = []
for err in errors:
loc = ".".join(str(x) for x in err.get("loc", []) if x != "body")
msg = err.get("msg", "invalid")
messages.append(f"{loc}: {msg}" if loc else msg)
detail_msg = "; ".join(messages) or "Некорректное тело запроса или параметры"
return make_error_response(
status.HTTP_400_BAD_REQUEST, ErrorCode.INVALID_REQUEST, detail_msg, req_id
)
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(
request: Request, exc: StarletteHTTPException
) -> JSONResponse:
req_id = get_request_id(request)
code = ErrorCode.INTERNAL_ERROR
extra_headers: dict[str, str] = {}
if exc.status_code == 400:
code = ErrorCode.INVALID_REQUEST
elif exc.status_code == 401:
code = ErrorCode.UNAUTHORIZED
scheme = (
'Basic realm="messenger", charset="UTF-8"'
if request.url.path == "/api/v1/auth/sessions"
else 'Bearer realm="messenger"'
)
extra_headers["WWW-Authenticate"] = scheme
elif exc.status_code == 404:
code = ErrorCode.NOT_FOUND
elif exc.status_code == 409:
code = ErrorCode.CONFLICT
elif exc.status_code == 413:
code = ErrorCode.PAYLOAD_TOO_LARGE
elif exc.status_code == 415:
code = ErrorCode.UNSUPPORTED_MEDIA_TYPE
elif exc.status_code == 429:
code = ErrorCode.RATE_LIMITED
elif exc.status_code == 503:
code = ErrorCode.UNAVAILABLE
msg = exc.detail if isinstance(exc.detail, str) else "HTTP ошибка"
return make_error_response(
exc.status_code, code, msg, req_id, headers=extra_headers
)
async def dependency_unavailable_handler(
request: Request, exc: Exception
) -> JSONResponse:
req_id = get_request_id(request)
logger.warning(
"Upstream storage dependency unavailable for request %s: %s",
req_id,
exc,
)
return make_error_response(
status.HTTP_503_SERVICE_UNAVAILABLE,
ErrorCode.UNAVAILABLE,
"Зависимость недоступна",
req_id,
)
for exc_cls in (
UnavailableError,
asyncpg.PostgresError,
asyncpg.InterfaceError,
redis.exceptions.RedisError,
TimeoutError,
asyncio.TimeoutError,
ConnectionError,
OSError,
):
app.add_exception_handler(exc_cls, dependency_unavailable_handler)
@app.exception_handler(Exception)
async def unhandled_exception_handler(
request: Request, exc: Exception
) -> JSONResponse:
req_id = get_request_id(request)
if isinstance(
exc,
(
UnavailableError,
asyncpg.PostgresError,
asyncpg.InterfaceError,
redis.exceptions.RedisError,
TimeoutError,
asyncio.TimeoutError,
ConnectionError,
OSError,
),
):
return await dependency_unavailable_handler(request, exc)
logger.error(
"Unhandled exception for request %s: %s", req_id, exc, exc_info=True
)
return make_error_response(
status.HTTP_500_INTERNAL_SERVER_ERROR,
ErrorCode.INTERNAL_ERROR,
"Внутренняя ошибка сервера",
req_id,
)
+59
View File
@@ -0,0 +1,59 @@
from __future__ import annotations
import logging
from contextlib import asynccontextmanager
import uvicorn
from fastapi import FastAPI
from app.config import APP_HOST, APP_PORT, LOG_LEVEL
from app.errors import register_error_handlers
from app.middleware import RequestIdAndLoggingMiddleware
from app.routes.auth import router as auth_router
from app.routes.chats import router as chats_router
from app.routes.health import router as health_router
from app.routes.messages import router as messages_router
from app.routes.users import router as users_router
from app.storage import storage
logger = logging.getLogger("app.lifecycle")
@asynccontextmanager
async def lifespan(app: FastAPI):
logger.info(
"Starting messenger server on %s:%d (env: %s)", APP_HOST, APP_PORT, LOG_LEVEL
)
await storage.connect()
yield
logger.info("Graceful shutdown: closing connections...")
await storage.disconnect()
app = FastAPI(
title="highload-messenger",
version="1.2.0",
docs_url="/docs",
redoc_url=None,
lifespan=lifespan,
)
app.add_middleware(RequestIdAndLoggingMiddleware)
register_error_handlers(app)
app.include_router(health_router)
app.include_router(auth_router)
app.include_router(users_router)
app.include_router(chats_router)
app.include_router(messages_router)
if __name__ == "__main__":
uvicorn.run(
"app.main:app",
host=APP_HOST,
port=APP_PORT,
log_level=LOG_LEVEL.lower(),
timeout_graceful_shutdown=10,
)
+74
View File
@@ -0,0 +1,74 @@
from __future__ import annotations
import logging
import sys
import time
import uuid
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.requests import Request
from starlette.responses import Response
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
stream=sys.stdout,
)
logger = logging.getLogger("app.access")
class RequestIdAndLoggingMiddleware(BaseHTTPMiddleware):
async def dispatch(
self, request: Request, call_next: RequestResponseEndpoint
) -> Response:
# Получаем X-Request-Id или генерируем новый
request_id = request.headers.get("X-Request-Id")
if not request_id or not request_id.strip():
request_id = str(uuid.uuid4())
request.state.request_id = request_id
start_time = time.monotonic()
if request.method in ("POST", "PUT", "PATCH") and request.url.path != "/api/v1/auth/sessions":
ct = request.headers.get("content-type")
if ct:
ct_clean = ct.split(";")[0].strip().lower()
if ct_clean != "application/json":
from fastapi import status
from app.errors import make_error_response
from app.schemas import ErrorCode
return make_error_response(
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
f"Неподдерживаемый тип содержимого '{ct}'. Ожидается application/json",
request_id,
)
try:
response = await call_next(request)
except Exception:
# Исключение перехватится exception_handler
duration_ms = (time.monotonic() - start_time) * 1000
logger.error(
"%s %s -> 500 error | duration=%.2fms | request_id=%s",
request.method,
request.url.path,
duration_ms,
request_id,
)
raise
duration_ms = (time.monotonic() - start_time) * 1000
response.headers["X-Request-Id"] = request_id
# лог без логирования тела запросов и текстов сообщений
logger.info(
"%s %s -> %d | duration=%.2fms | request_id=%s",
request.method,
request.url.path,
response.status_code,
duration_ms,
request_id,
)
return response
View File
+63
View File
@@ -0,0 +1,63 @@
from __future__ import annotations
import base64
from fastapi import APIRouter, Depends, Header, Request, Response, status
from app.dependencies import get_current_token
from app.errors import InvalidRequestError, UnauthorizedError
from app.schemas import SessionResponse
from app.storage import storage
router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"])
@router.post("", response_model=SessionResponse, status_code=status.HTTP_201_CREATED)
async def create_session(
request: Request,
authorization: str | None = Header(default=None, alias="Authorization"),
) -> SessionResponse:
"""Аутентификация пользователя через Basic Auth и создание новой сессии."""
body = await request.body()
if body and body.strip():
raise InvalidRequestError("Тело запроса для создания сессии должно быть пустым")
if not authorization or not authorization.strip():
raise UnauthorizedError("Отсутствует заголовок Authorization")
parts = authorization.strip().split(maxsplit=1)
if len(parts) != 2 or parts[0].lower() != "basic":
raise UnauthorizedError("Неверная схема авторизации (ожидается Basic)")
try:
raw_bytes = base64.b64decode(parts[1].strip())
raw_str = raw_bytes.decode("utf-8")
if ":" not in raw_str:
raise UnauthorizedError("Некорректный формат Basic credentials")
username, password = raw_str.split(":", 1)
except Exception:
raise UnauthorizedError("Некорректный заголовок Basic авторизации")
user = await storage.authenticate_user(username, password)
if not user:
raise UnauthorizedError("Неверное имя пользователя или пароль")
session = await storage.create_session(user)
return session
@router.delete("/current", status_code=status.HTTP_204_NO_CONTENT)
async def delete_current_session(
request: Request,
token: str = Depends(get_current_token),
) -> Response:
"""Отзыв текущей сессии."""
body = await request.body()
if body and body.strip():
raise InvalidRequestError("Тело запроса для отзыва сессии должно быть пустым")
user = await storage.get_session_user(token)
if not user:
raise UnauthorizedError("Недействительная или уже отозванная сессия")
await storage.delete_session(token)
return Response(status_code=status.HTTP_204_NO_CONTENT)
+64
View File
@@ -0,0 +1,64 @@
from __future__ import annotations
from uuid import UUID
from fastapi import APIRouter, Depends, Query, status
from app.dependencies import get_current_user
from app.schemas import (
ChatPageResponse,
ChatResponse,
CreateChatRequest,
UserResponse,
)
from app.storage import InvalidRequestError, storage
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
def validate_uuid(value: str, field_name: str = "id") -> str:
try:
UUID(value)
return value
except ValueError as exc:
raise InvalidRequestError(f"Поле '{field_name}' не является валидным UUID") from exc
@router.post("", response_model=ChatResponse, status_code=status.HTTP_201_CREATED)
async def create_chat(
body: CreateChatRequest,
current_user: UserResponse = Depends(get_current_user),
) -> ChatResponse:
"""Создание нового чата."""
chat = await storage.create_chat(
caller_id=current_user.id,
title=body.title,
member_ids=body.member_ids,
)
return chat
@router.get("", response_model=ChatPageResponse, status_code=status.HTTP_200_OK)
async def list_chats(
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: UserResponse = Depends(get_current_user),
) -> ChatPageResponse:
"""Список чатов, в которых состоит текущий пользователь."""
items, next_cursor = await storage.list_chats(
caller_id=current_user.id,
limit=limit,
cursor=cursor,
)
return ChatPageResponse(items=items, next_cursor=next_cursor)
@router.get("/{chat_id}", response_model=ChatResponse, status_code=status.HTTP_200_OK)
async def get_chat(
chat_id: str,
current_user: UserResponse = Depends(get_current_user),
) -> ChatResponse:
"""Получение информации о чате по ID."""
valid_id = validate_uuid(chat_id, "chat_id")
chat = await storage.get_chat(caller_id=current_user.id, chat_id=valid_id)
return chat
+31
View File
@@ -0,0 +1,31 @@
from __future__ import annotations
from fastapi import APIRouter, status
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.schemas import HealthResponse
from app.storage import storage
router = APIRouter(tags=["health"])
@router.get(
"/health/live", response_model=HealthResponse, status_code=status.HTTP_200_OK
)
async def health_live() -> HealthResponse:
"""Проверка жизни процесса (Liveness)."""
return HealthResponse(status="ok")
@router.get(
"/health/ready", response_model=HealthResponse, status_code=status.HTTP_200_OK
)
async def health_ready() -> HealthResponse:
"""Проверка готовности сервиса и его зависимостей (Readiness)."""
is_ready = await storage.check_health()
if not is_ready:
raise StarletteHTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail="Сервис или его хранилища недоступны",
)
return HealthResponse(status="ok")
+66
View File
@@ -0,0 +1,66 @@
from __future__ import annotations
from uuid import UUID
from fastapi import APIRouter, Depends, Query, status
from app.dependencies import get_current_user
from app.schemas import (
CreateMessageRequest,
MessagePageResponse,
MessageResponse,
UserResponse,
)
from app.storage import InvalidRequestError, storage
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
def validate_uuid(value: str, field_name: str = "id") -> str:
try:
UUID(value)
return value
except ValueError as exc:
raise InvalidRequestError(f"Поле '{field_name}' не является валидным UUID") from exc
@router.post(
"/{chat_id}/messages",
response_model=MessageResponse,
status_code=status.HTTP_201_CREATED,
)
async def create_message(
chat_id: str,
body: CreateMessageRequest,
current_user: UserResponse = Depends(get_current_user),
) -> MessageResponse:
"""Отправка сообщения в чат."""
valid_id = validate_uuid(chat_id, "chat_id")
msg = await storage.send_message(
caller_id=current_user.id,
chat_id=valid_id,
text=body.text,
)
return msg
@router.get(
"/{chat_id}/messages",
response_model=MessagePageResponse,
status_code=status.HTTP_200_OK,
)
async def list_messages(
chat_id: str,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: UserResponse = Depends(get_current_user),
) -> MessagePageResponse:
"""Получение истории сообщений чата с keyset-пагинацией."""
valid_id = validate_uuid(chat_id, "chat_id")
items, next_cursor = await storage.list_messages(
caller_id=current_user.id,
chat_id=valid_id,
limit=limit,
cursor=cursor,
)
return MessagePageResponse(items=items, next_cursor=next_cursor)
+28
View File
@@ -0,0 +1,28 @@
from __future__ import annotations
from fastapi import APIRouter, Depends, status
from app.dependencies import get_current_user
from app.schemas import CreateUserRequest, UserResponse
from app.storage import storage
router = APIRouter(prefix="/api/v1/users", tags=["users"])
@router.post("", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
async def create_user(body: CreateUserRequest) -> UserResponse:
"""Регистрация нового пользователя."""
user = await storage.create_user(
username=body.username,
display_name=body.display_name,
password=body.password,
)
return user
@router.get("/me", response_model=UserResponse, status_code=status.HTTP_200_OK)
async def get_me(
current_user: UserResponse = Depends(get_current_user),
) -> UserResponse:
"""Получение профиля текущего пользователя."""
return current_user
+164
View File
@@ -0,0 +1,164 @@
from __future__ import annotations
import datetime as dt
import re
from enum import Enum
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
def now_utc_iso() -> str:
"""Возвращает текущее время в формате RFC 3339 UTC с суффиксом Z."""
return dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
class ErrorCode(str, Enum):
INVALID_REQUEST = "invalid_request"
UNAUTHORIZED = "unauthorized"
NOT_FOUND = "not_found"
CONFLICT = "conflict"
PAYLOAD_TOO_LARGE = "payload_too_large"
UNSUPPORTED_MEDIA_TYPE = "unsupported_media_type"
RATE_LIMITED = "rate_limited"
UNAVAILABLE = "unavailable"
INTERNAL_ERROR = "internal_error"
class ErrorDetail(BaseModel):
model_config = ConfigDict(extra="forbid")
code: ErrorCode
message: str = Field(min_length=1)
request_id: str = Field(min_length=1)
class ErrorResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
error: ErrorDetail
class HealthResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
status: str = Field(default="ok")
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
username: str = Field(min_length=3, max_length=32)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator("username")
@classmethod
def validate_username(cls, v: str) -> str:
if not re.match(r"^[a-z0-9_]{3,32}\Z", v):
raise ValueError("Имя пользователя должно соответствовать шаблону ^[a-z0-9_]{3,32}$")
return v
@field_validator("display_name")
@classmethod
def validate_display_name(cls, v: str) -> str:
if not v.strip():
raise ValueError("Отображаемое имя не может состоять только из пробелов")
return v
@field_validator("password")
@classmethod
def validate_password(cls, v: str) -> str:
if not v.strip():
raise ValueError("Пароль не может состоять только из пробелов")
return v
class UserResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
username: str
display_name: str
created_at: str
class SessionResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
token: str = Field(min_length=32)
token_type: str = Field(default="Bearer")
expires_at: str
user: UserResponse
class CreateChatRequest(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 validate_title(cls, v: str) -> str:
if not v.strip():
raise ValueError("Название не может состоять только из пробелов")
return v
@field_validator("member_ids")
@classmethod
def validate_member_ids(cls, v: list[str]) -> list[str]:
if len(v) != len(set(v)):
raise ValueError("Идентификаторы участников должны быть уникальными")
for member_id in v:
try:
UUID(member_id)
except ValueError:
raise ValueError(f"Идентификатор участника '{member_id}' не является валидным UUID")
return v
class ChatResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
title: str
member_ids: list[str]
created_at: str
class ChatPageResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[ChatResponse]
next_cursor: str | None = None
class CreateMessageRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
text: str = Field(min_length=1, max_length=4000)
@field_validator("text")
@classmethod
def validate_text(cls, v: str) -> str:
if not v.strip():
raise ValueError("Текст сообщения не может состоять только из пробелов")
return v
class MessageResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
chat_id: str
sender_id: str
text: str
created_at: str
class MessagePageResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[MessageResponse]
next_cursor: str | None = None
+551
View File
@@ -0,0 +1,551 @@
import asyncio
import base64
from contextlib import asynccontextmanager
import datetime as dt
import json
import logging
import uuid
from typing import Any
import asyncpg
import redis.asyncio as redis
from app.auth import generate_session_token, hash_password, verify_password
from app.config import (
CACHE_URL,
DATABASE_URL,
SESSION_TTL_SECONDS,
)
from app.errors import (
ConflictError,
InvalidRequestError,
NotFoundError,
UnauthorizedError,
)
from app.schemas import (
ChatResponse,
MessageResponse,
SessionResponse,
UserResponse,
now_utc_iso,
)
logger = logging.getLogger("app.storage")
def encode_cursor(data: dict) -> str:
raw = json.dumps(data, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=")
def decode_cursor(cursor_str: str) -> dict:
if not isinstance(cursor_str, str) or not cursor_str.strip():
raise InvalidRequestError("Некорректный курсор")
try:
padded = cursor_str + "=" * (-len(cursor_str) % 4)
raw = base64.urlsafe_b64decode(padded.encode("utf-8"))
data = json.loads(raw.decode("utf-8"))
if not isinstance(data, dict):
raise InvalidRequestError("Некорректный курсор")
return data
except InvalidRequestError:
raise
except Exception as exc:
raise InvalidRequestError("Некорректный курсор") from exc
def _format_dt(d: dt.datetime) -> str:
if d.tzinfo is None:
d = d.replace(tzinfo=dt.timezone.utc)
return d.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def _to_text(val: Any) -> str:
if isinstance(val, (bytes, bytearray, memoryview)):
return bytes(val).decode("utf-8")
return str(val)
class PostgresStorage:
def __init__(self) -> None:
self.pg_pool: asyncpg.Pool | None = None
self.redis_client: redis.Redis | None = None
@asynccontextmanager
async def acquire_conn(self, timeout: float = 2.0):
if self.pg_pool is None:
raise asyncpg.InterfaceError("Пул подключений к PostgreSQL не инициализирован")
async with asyncio.timeout(4.0):
async with self.pg_pool.acquire(timeout=timeout) as conn:
yield conn
async def connect(self) -> None:
logger.info("Подключение к PostgreSQL: %s", DATABASE_URL.split("@")[-1])
self.pg_pool = await asyncpg.create_pool(
DATABASE_URL,
min_size=2,
max_size=20,
command_timeout=2.0,
timeout=2.0,
)
logger.info("Подключение к Redis: %s", CACHE_URL.split("@")[-1])
self.redis_client = redis.from_url(
CACHE_URL,
decode_responses=True,
socket_connect_timeout=3.0,
socket_timeout=3.0,
)
try:
async with self.acquire_conn() as conn:
col_type = await conn.fetchval(
"SELECT data_type FROM information_schema.columns WHERE table_name = 'messages' AND column_name = 'text'"
)
if col_type in ("text", "character varying"):
await conn.execute(
"ALTER TABLE messages ALTER COLUMN text TYPE BYTEA USING text::bytea"
)
except Exception as exc:
logger.warning("Не удалось проверить/обновить схему messages.text: %s", exc)
async def disconnect(self) -> None:
if self.pg_pool:
await self.pg_pool.close()
self.pg_pool = None
if self.redis_client:
await self.redis_client.close()
self.redis_client = None
async def check_health(self) -> bool:
if not self.pg_pool or not self.redis_client:
return False
try:
async with self.acquire_conn() as conn:
await conn.fetchval("SELECT 1")
await self.redis_client.ping()
return True
except Exception as exc:
logger.warning("Ошибка проверки health: %s", exc)
return False
# ------------------ Пользователи и аутентификация ------------------
async def create_user(
self, username: str, display_name: str, password: str
) -> UserResponse:
user_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
pwd_hash = hash_password(password)
try:
async with self.acquire_conn() as conn:
await conn.execute(
"""
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES ($1, $2, $3, $4, $5)
""",
user_id,
username,
display_name,
pwd_hash,
now,
)
except asyncpg.UniqueViolationError:
raise ConflictError("Имя пользователя уже занято")
return UserResponse(
id=str(user_id),
username=username,
display_name=display_name,
created_at=_format_dt(now),
)
async def authenticate_user(
self, username: str, password: str
) -> UserResponse | None:
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, password_hash, created_at
FROM users
WHERE username = $1
""",
username,
)
if not row:
return None
if not verify_password(row["password_hash"], password):
return None
return UserResponse(
id=str(row["id"]),
username=row["username"],
display_name=_to_text(row["display_name"]),
created_at=_format_dt(row["created_at"]),
)
async def get_user_by_id(self, user_id: str) -> UserResponse | None:
try:
uid = uuid.UUID(user_id)
except ValueError:
return None
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT id, username, display_name, created_at
FROM users
WHERE id = $1
""",
uid,
)
if not row:
return None
return UserResponse(
id=str(row["id"]),
username=row["username"],
display_name=_to_text(row["display_name"]),
created_at=_format_dt(row["created_at"]),
)
# ------------------ Сессии (Redis) ------------------
async def create_session(self, user: UserResponse) -> SessionResponse:
assert self.redis_client is not None
token = generate_session_token()
now = dt.datetime.now(dt.timezone.utc)
expires_at = now + dt.timedelta(seconds=SESSION_TTL_SECONDS)
expires_at_str = _format_dt(expires_at)
session_data = json.dumps(
{
"user_id": user.id,
"expires_at": expires_at_str,
}
)
key = f"session:{token}"
await self.redis_client.set(key, session_data, ex=SESSION_TTL_SECONDS)
return SessionResponse(
token=token,
token_type="Bearer",
expires_at=expires_at_str,
user=user,
)
async def get_session_user(self, token: str) -> UserResponse | None:
if not token or not self.redis_client:
return None
key = f"session:{token}"
raw = await self.redis_client.get(key)
if not raw:
return None
try:
data = json.loads(raw)
user_id = data.get("user_id")
except Exception:
return None
if not user_id:
return None
return await self.get_user_by_id(user_id)
async def delete_session(self, token: str) -> bool:
if not token or not self.redis_client:
return False
key = f"session:{token}"
res = await self.redis_client.delete(key)
return res > 0
# ------------------ Чаты ------------------
async def create_chat(
self, caller_id: str, title: str, member_ids: list[str]
) -> ChatResponse:
if caller_id not in member_ids:
raise InvalidRequestError("Создатель чата должен быть в списке участников")
chat_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
member_uuids = [uuid.UUID(m) for m in member_ids]
async with self.acquire_conn() as conn:
# Проверяем существование всех участников
found = await conn.fetch(
"SELECT id FROM users WHERE id = ANY($1::uuid[])", member_uuids
)
if len(found) != len(member_uuids):
raise InvalidRequestError(
"Один или несколько участников чата не найдены"
)
async with conn.transaction():
await conn.execute(
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)",
chat_id,
title,
now,
)
member_records = [(chat_id, m) for m in member_uuids]
await conn.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
member_records,
)
return ChatResponse(
id=str(chat_id),
title=title,
member_ids=member_ids,
created_at=_format_dt(now),
)
async def get_chat(self, caller_id: str, chat_id: str) -> ChatResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
async with self.acquire_conn() as conn:
# Проверяем членство вызывающего
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
chat_row = await conn.fetchrow(
"SELECT id, title, created_at FROM chats WHERE id = $1", cid
)
if not chat_row:
raise NotFoundError("Чат не найден")
members_rows = await conn.fetch(
"SELECT user_id FROM chat_members WHERE chat_id = $1", cid
)
member_ids = [str(r["user_id"]) for r in members_rows]
return ChatResponse(
id=str(chat_row["id"]),
title=_to_text(chat_row["title"]),
member_ids=member_ids,
created_at=_format_dt(chat_row["created_at"]),
)
async def list_chats(
self, caller_id: str, limit: int = 50, cursor: str | None = None
) -> tuple[list[ChatResponse], str | None]:
try:
c_caller = uuid.UUID(caller_id)
except ValueError:
return [], None
c_created: dt.datetime | None = None
c_id: uuid.UUID | None = None
if cursor is not None:
c_data = decode_cursor(cursor)
if c_data.get("type") != "chats":
raise InvalidRequestError("Недействительный тип курсора")
c_created_str = c_data.get("created_at")
c_id_str = c_data.get("id")
if (
not isinstance(c_created_str, str)
or not isinstance(c_id_str, str)
or not c_created_str.strip()
or not c_id_str.strip()
):
raise InvalidRequestError("Поврежденный курсор")
try:
c_created = dt.datetime.fromisoformat(
c_created_str.replace("Z", "+00:00")
)
c_id = uuid.UUID(c_id_str)
except Exception:
raise InvalidRequestError("Некорректные параметры курсора")
async with self.acquire_conn() as conn:
query = """
SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids
FROM chats c
JOIN chat_members my_m ON c.id = my_m.chat_id AND my_m.user_id = $1
JOIN chat_members cm ON c.id = cm.chat_id
WHERE ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2::timestamptz, $3::uuid))
GROUP BY c.id, c.title, c.created_at
ORDER BY c.created_at ASC, c.id ASC
LIMIT $4
"""
rows = await conn.fetch(query, c_caller, c_created, c_id, limit + 1)
has_next = len(rows) > limit
items_rows = rows[:limit]
items = [
ChatResponse(
id=str(r["id"]),
title=_to_text(r["title"]),
member_ids=list(r["member_ids"]),
created_at=_format_dt(r["created_at"]),
)
for r in items_rows
]
next_cursor = None
if has_next and items:
last = items[-1]
next_cursor = encode_cursor(
{
"type": "chats",
"created_at": last.created_at,
"id": last.id,
}
)
return items, next_cursor
# ------------------ Сообщения ------------------
async def send_message(
self, caller_id: str, chat_id: str, text: str
) -> MessageResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
msg_id = uuid.uuid4()
now = dt.datetime.now(dt.timezone.utc)
text_bytes = text.encode("utf-8")
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
await conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, $5)
""",
msg_id,
cid,
c_caller,
text_bytes,
now,
)
return MessageResponse(
id=str(msg_id),
chat_id=chat_id,
sender_id=caller_id,
text=text,
created_at=_format_dt(now),
)
async def list_messages(
self, caller_id: str, chat_id: str, limit: int = 50, cursor: str | None = None
) -> tuple[list[MessageResponse], str | None]:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
c_created: dt.datetime | None = None
c_id: uuid.UUID | None = None
if cursor is not None:
c_data = decode_cursor(cursor)
if c_data.get("type") != "messages" or c_data.get("chat_id") != chat_id:
raise InvalidRequestError(
"Курсор принадлежит другому чату или недействителен"
)
c_created_str = c_data.get("created_at")
c_id_str = c_data.get("id")
if (
not isinstance(c_created_str, str)
or not isinstance(c_id_str, str)
or not c_created_str.strip()
or not c_id_str.strip()
):
raise InvalidRequestError("Поврежденный курсор")
try:
c_created = dt.datetime.fromisoformat(
c_created_str.replace("Z", "+00:00")
)
c_id = uuid.UUID(c_id_str)
except Exception:
raise InvalidRequestError("Некорректные параметры курсора")
query = """
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2::timestamptz, $3::uuid))
ORDER BY created_at ASC, id ASC
LIMIT $4
"""
rows = await conn.fetch(query, cid, c_created, c_id, limit + 1)
has_next = len(rows) > limit
items_rows = rows[:limit]
def _to_text(val: Any) -> str:
if isinstance(val, (bytes, bytearray, memoryview)):
return bytes(val).decode("utf-8")
return str(val)
items = [
MessageResponse(
id=str(r["id"]),
chat_id=str(r["chat_id"]),
sender_id=str(r["sender_id"]),
text=_to_text(r["text"]),
created_at=_format_dt(r["created_at"]),
)
for r in items_rows
]
next_cursor = None
if has_next and items:
last = items[-1]
next_cursor = encode_cursor(
{
"type": "messages",
"chat_id": chat_id,
"created_at": last.created_at,
"id": last.id,
}
)
return items, next_cursor
# Глобальный экземпляр хранилища
storage = PostgresStorage()
+35
View File
@@ -0,0 +1,35 @@
CREATE TABLE IF NOT EXISTS users (
id UUID PRIMARY KEY,
username VARCHAR(32) NOT NULL UNIQUE,
display_name VARCHAR(100) NOT NULL,
password_hash TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_users_username ON users (username);
CREATE TABLE IF NOT EXISTS chats (
id UUID PRIMARY KEY,
title VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_chats_cursor ON chats (created_at ASC, id ASC);
CREATE TABLE IF NOT EXISTS chat_members (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX IF NOT EXISTS idx_chat_members_user_id ON chat_members (user_id);
CREATE TABLE IF NOT EXISTS messages (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
text BYTEA NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_messages_cursor ON messages (chat_id, created_at ASC, id ASC);
+4
View File
@@ -0,0 +1,4 @@
[pytest]
pythonpath = .
asyncio_mode = auto
python_files = test_*.py *_test.py tests.py test.py
+9
View File
@@ -0,0 +1,9 @@
fastapi==0.141.1
uvicorn[standard]==0.52.4
pydantic==2.13.5
asyncpg==0.30.0
redis==5.2.1
argon2-cffi==23.1.0
pytest==9.1.1
pytest-asyncio==1.4.0
httpx==0.28.1
+19
View File
@@ -0,0 +1,19 @@
from __future__ import annotations
import os
import pytest
from httpx import ASGITransport, AsyncClient
@pytest.fixture
async def client():
base_url = os.getenv("BASE_URL", "http://localhost:8080")
if base_url.startswith("http://testserver"):
from app.main import app
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://testserver") as ac:
yield ac
else:
async with AsyncClient(base_url=base_url) as ac:
yield ac
+471
View File
@@ -0,0 +1,471 @@
from __future__ import annotations
import asyncio
import base64
import uuid
import httpx
import pytest
from httpx import AsyncClient
async def register_and_login(client: AsyncClient, prefix: str = "u") -> dict:
username = f"{prefix}_{uuid.uuid4().hex[:12]}"
password = f"P@ssword_{uuid.uuid4().hex[:8]}"
body = {
"username": username,
"display_name": f"User {prefix}",
"password": password,
}
u_res = await client.post("/api/v1/users", json=body)
assert u_res.status_code == 201, u_res.text
user = u_res.json()
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
s_res = await client.post(
"/api/v1/auth/sessions", headers={"Authorization": f"Basic {cred}"}
)
assert s_res.status_code == 201, s_res.text
session = s_res.json()
return {
"user": user,
"username": username,
"password": password,
"token": session["token"],
"headers": {"Authorization": f"Bearer {session['token']}"},
}
@pytest.mark.asyncio
async def test_invalid_json_and_extra_fields(client: AsyncClient):
"""Проверка невалидного JSON, лишних полей, перевода строки и валидации курсора."""
# 1. Невалидный синтаксис JSON -> 400
res_malformed = await client.post(
"/api/v1/users",
content="not a valid json {",
headers={"Content-Type": "application/json"},
)
assert res_malformed.status_code == 400
err_malformed = res_malformed.json()
assert err_malformed["error"]["code"] == "invalid_request"
assert "request_id" in err_malformed["error"]
assert (
res_malformed.headers.get("X-Request-Id")
== err_malformed["error"]["request_id"]
)
# 2. Лишние поля (additionalProperties: false) -> 400
res_extra = await client.post(
"/api/v1/users",
json={
"username": f"u_{uuid.uuid4().hex[:8]}",
"display_name": "test_user",
"password": "ValidPassword123!",
"unexpected_field": "hacker_payload",
},
)
assert res_extra.status_code == 400
assert res_extra.json()["error"]["code"] == "invalid_request"
# 3. Запрет завершающего перевода строки в username ("abc\n") -> 400
res_newline = await client.post(
"/api/v1/users",
json={
"username": "abc\n",
"display_name": "test_newline",
"password": "ValidPassword123!",
},
)
assert res_newline.status_code == 400
assert res_newline.json()["error"]["code"] == "invalid_request"
# 4. Валидация курсора: не-dict JSON (W10= -> []) и пустой cursor= -> 400
actor = await register_and_login(client, "cur_val")
headers = actor["headers"]
# cursor=W10= (декодируется в list [], а не dict)
res_w10 = await client.get("/api/v1/chats?cursor=W10=", headers=headers)
assert res_w10.status_code == 400
assert res_w10.json()["error"]["code"] == "invalid_request"
# пустой cursor=
res_empty_cursor = await client.get("/api/v1/chats?cursor=", headers=headers)
assert res_empty_cursor.status_code == 400
assert res_empty_cursor.json()["error"]["code"] == "invalid_request"
@pytest.mark.asyncio
async def test_outsider_chat_access_is_404(client: AsyncClient):
"""Проверка того, что доступ к чужому чату возвращает строго 404 (а не 403)."""
alice = await register_and_login(client, "alice")
bob = await register_and_login(client, "bob")
eve = await register_and_login(client, "eve")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={
"title": "Private Chat",
"member_ids": [alice["user"]["id"], bob["user"]["id"]],
},
)
assert chat_res.status_code == 201
chat_id = chat_res.json()["id"]
# Ева пытается получить чужой чат -> 404
res_get = await client.get(f"/api/v1/chats/{chat_id}", headers=eve["headers"])
assert res_get.status_code == 404
assert res_get.json()["error"]["code"] == "not_found"
# Ева пытается отправить сообщение в чужой чат -> 404
res_send = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers=eve["headers"],
json={"text": "Шпионское сообщение"},
)
assert res_send.status_code == 404
assert res_send.json()["error"]["code"] == "not_found"
# Ева пытается прочитать сообщения чужого чата -> 404
res_list = await client.get(
f"/api/v1/chats/{chat_id}/messages", headers=eve["headers"]
)
assert res_list.status_code == 404
assert res_list.json()["error"]["code"] == "not_found"
@pytest.mark.asyncio
async def test_empty_and_whitespace_message(client: AsyncClient):
"""Проверка запрета отправки пустого текста или текста из одних пробелов (400)."""
alice = await register_and_login(client, "msg_user")
chat = (
await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Chat", "member_ids": [alice["user"]["id"]]},
)
).json()
# Пустая строка -> 400
res_empty = await client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=alice["headers"],
json={"text": ""},
)
assert res_empty.status_code == 400
assert res_empty.json()["error"]["code"] == "invalid_request"
# Одни пробелы и переводы строк -> 400
res_whitespace = await client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=alice["headers"],
json={"text": " \n\t "},
)
assert res_whitespace.status_code == 400
assert res_whitespace.json()["error"]["code"] == "invalid_request"
@pytest.mark.asyncio
async def test_duplicate_username_conflict(client: AsyncClient):
"""Проверка запрета дублирования username (409 conflict)."""
uname = f"uniq_{uuid.uuid4().hex[:10]}"
body = {
"username": uname,
"display_name": "Первый",
"password": "ValidPassword123!",
}
res1 = await client.post("/api/v1/users", json=body)
assert res1.status_code == 201
res2 = await client.post(
"/api/v1/users",
json={
"username": uname,
"display_name": "Второй с тем же ником",
"password": "AnotherPassword123!",
},
)
assert res2.status_code == 409
assert res2.json()["error"]["code"] == "conflict"
@pytest.mark.asyncio
async def test_wrong_password_and_bad_basic_auth(client: AsyncClient):
"""Проверка ошибки авторизации 401 и корректного заголовка WWW-Authenticate."""
alice = await register_and_login(client, "auth_test")
# Неверный пароль -> 401
bad_cred = base64.b64encode(f"{alice['username']}:WrongPassword123!".encode()).decode()
res_bad = await client.post(
"/api/v1/auth/sessions", headers={"Authorization": f"Basic {bad_cred}"}
)
assert res_bad.status_code == 401
assert res_bad.json()["error"]["code"] == "unauthorized"
assert "basic" in res_bad.headers.get("WWW-Authenticate", "").lower()
# Несуществующий юзер -> 401
ghost_cred = base64.b64encode(b"ghost_user_123:WrongPassword123!").decode()
res_ghost = await client.post(
"/api/v1/auth/sessions", headers={"Authorization": f"Basic {ghost_cred}"}
)
assert res_ghost.status_code == 401
assert "basic" in res_ghost.headers.get("WWW-Authenticate", "").lower()
@pytest.mark.asyncio
async def test_logout_and_revocation(client: AsyncClient):
"""Проверка отзыва сессии (logout 204) и 401 при обращении с отозванным токеном."""
alice = await register_and_login(client, "logout_test")
# Проверяем, что токен работает
me_res = await client.get("/api/v1/users/me", headers=alice["headers"])
assert me_res.status_code == 200
# Делаем logout -> 204
logout_res = await client.delete(
"/api/v1/auth/sessions/current", headers=alice["headers"]
)
assert logout_res.status_code == 204
# Теперь тот же токен должен возвращать 401
me_after = await client.get("/api/v1/users/me", headers=alice["headers"])
assert me_after.status_code == 401
assert me_after.json()["error"]["code"] == "unauthorized"
assert "bearer" in me_after.headers.get("WWW-Authenticate", "").lower()
# Повторный logout с тем же отозванным токеном -> 401
logout_repeat = await client.delete(
"/api/v1/auth/sessions/current", headers=alice["headers"]
)
assert logout_repeat.status_code == 401
@pytest.mark.asyncio
async def test_multi_page_cursor_pagination(client: AsyncClient):
"""Проверка обхода истории сообщений через keyset-курсор на нескольких страницах."""
alice = await register_and_login(client, "pager")
chat = (
await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Pagination Chat", "member_ids": [alice["user"]["id"]]},
)
).json()
# Отправляем 15 сообщений
sent_ids = []
for i in range(15):
msg = (
await client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=alice["headers"],
json={"text": f"Сообщение {i:02d}"},
)
).json()
sent_ids.append(msg["id"])
# Читаем страницами по 4 сообщения
gathered_ids = []
cursor = None
pages_count = 0
while True:
url = f"/api/v1/chats/{chat['id']}/messages?limit=4"
if cursor:
url += f"&cursor={cursor}"
res = await client.get(url, headers=alice["headers"])
assert res.status_code == 200
data = res.json()
pages_count += 1
items = data["items"]
for item in items:
gathered_ids.append(item["id"])
cursor = data.get("next_cursor")
if not cursor:
break
# Должны быть ровно 15 сообщений в строго том же порядке, без дублей и пропусков
assert len(gathered_ids) == 15
assert gathered_ids == sent_ids
assert pages_count == 4
@pytest.mark.asyncio
async def test_concurrency_race_condition(client: AsyncClient):
"""Проверка устойчивости к параллельным гонкам: 10 клиентов одновременно шлют 100 сообщений."""
# Создаём 10 пользователей
users = await asyncio.gather(
*(register_and_login(client, f"u{i}") for i in range(10))
)
all_user_ids = [u["user"]["id"] for u in users]
# Первый пользователь создаёт общий чат со всеми 10 участниками
chat = (
await client.post(
"/api/v1/chats",
headers=users[0]["headers"],
json={"title": "Massive Concurrent Chat", "member_ids": all_user_ids},
)
).json()
chat_id = chat["id"]
# Отправляем по 10 сообщений от каждого пользователя параллельно (всего 100)
async def sender(user_dict: dict, count: int):
for i in range(count):
await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers=user_dict["headers"],
json={"text": f"Msg {i} from {user_dict['username']}"},
)
await asyncio.gather(*(sender(u, 10) for u in users))
# Считываем все сообщения из чата
all_msgs = []
cursor = None
while True:
url = f"/api/v1/chats/{chat_id}/messages?limit=50"
if cursor:
url += f"&cursor={cursor}"
res = await client.get(url, headers=users[0]["headers"])
assert res.status_code == 200
data = res.json()
all_msgs.extend(data["items"])
cursor = data.get("next_cursor")
if not cursor:
break
assert len(all_msgs) == 100
ids = [m["id"] for m in all_msgs]
# Все ID должны быть уникальными
assert len(ids) == len(set(ids))
@pytest.mark.asyncio
async def test_password_whitespace_rejected(client: httpx.AsyncClient):
"""Пароль из одних пробелов должен строго отклоняться с 400 Invalid Request."""
u = f"space_user_{uuid.uuid4().hex[:6]}"
res = await client.post(
"/api/v1/users",
json={"username": u, "display_name": "Test User", "password": " " * 12},
)
assert res.status_code == 400
data = res.json()
assert data["error"]["code"] == "invalid_request"
@pytest.mark.asyncio
async def test_auth_sessions_with_body_rejected(client: httpx.AsyncClient):
"""POST /api/v1/auth/sessions с телом запроса должен отклоняться с 400 Invalid Request."""
u = f"body_user_{uuid.uuid4().hex[:6]}"
p = "StrongPassword123!"
await client.post(
"/api/v1/users",
json={"username": u, "display_name": "Body Test", "password": p},
)
cred = base64.b64encode(f"{u}:{p}".encode()).decode()
res = await client.post(
"/api/v1/auth/sessions",
headers={"Authorization": f"Basic {cred}"},
json={"extra": "forbidden"},
)
assert res.status_code == 400
data = res.json()
assert data["error"]["code"] == "invalid_request"
@pytest.mark.asyncio
async def test_unsupported_media_type_415(client: httpx.AsyncClient):
"""Запрос с неподдерживаемым Content-Type (text/plain) должен возвращать 415 Unsupported Media Type."""
res = await client.post(
"/api/v1/users",
content='{"username":"ct_test","display_name":"d","password":"Password123456!"}',
headers={"Content-Type": "text/plain"},
)
assert res.status_code == 415
data = res.json()
assert data["error"]["code"] == "unsupported_media_type"
@pytest.mark.asyncio
async def test_nul_byte_in_strings_handled(client: httpx.AsyncClient):
usr = await register_and_login(client, f"nul_msg_{uuid.uuid4().hex[:4]}")
chat = (await client.post("/api/v1/chats", headers=usr["headers"], json={"title": "NulChat", "member_ids": [usr["user"]["id"]]})).json()
test_text = "left\u0000right"
msg_res = await client.post(f"/api/v1/chats/{chat['id']}/messages", headers=usr["headers"], json={"text": test_text})
assert msg_res.status_code == 201
assert msg_res.json()["text"] == test_text
list_res = await client.get(f"/api/v1/chats/{chat['id']}/messages", headers=usr["headers"])
assert list_res.status_code == 200
assert any(m["text"] == test_text for m in list_res.json()["items"])
@pytest.mark.asyncio
async def test_basic_auth_invalid_base64_returns_401(client: httpx.AsyncClient):
"""Authorization: Basic с битым base64 или не-ASCII символами возвращает 401, а не 500."""
res = await client.post(
"/api/v1/auth/sessions",
headers={"Authorization": b"Basic \xe9"},
)
assert res.status_code == 401
assert "Basic" in res.headers.get("www-authenticate", "")
@pytest.mark.asyncio
async def test_cross_chat_cursor_rejected_400(client: httpx.AsyncClient):
"""Курсор от одного чата при попытке использовать в другом чате должен возвращать 400."""
u = await register_and_login(client, f"cc_{uuid.uuid4().hex[:4]}")
chat1 = (await client.post("/api/v1/chats", headers=u["headers"], json={"title": "C1", "member_ids": [u["user"]["id"]]})).json()
chat2 = (await client.post("/api/v1/chats", headers=u["headers"], json={"title": "C2", "member_ids": [u["user"]["id"]]})).json()
# Отправляем 2 сообщения в чат 1
await client.post(f"/api/v1/chats/{chat1['id']}/messages", headers=u["headers"], json={"text": "m1"})
await client.post(f"/api/v1/chats/{chat1['id']}/messages", headers=u["headers"], json={"text": "m2"})
# Получаем страницу с курсором из чата 1
p1 = (await client.get(f"/api/v1/chats/{chat1['id']}/messages?limit=1", headers=u["headers"])).json()
cursor1 = p1.get("next_cursor")
assert cursor1 is not None
# Пытаемся применить курсор чата 1 к чату 2 -> 400!
res = await client.get(f"/api/v1/chats/{chat2['id']}/messages?cursor={cursor1}", headers=u["headers"])
assert res.status_code == 400
assert res.json()["error"]["code"] == "invalid_request"
@pytest.mark.asyncio
async def test_utf8_password_support(client: httpx.AsyncClient):
"""Пароли с символами UTF-8 и emoji корректно регистрируются и аутентифицируются."""
u = f"utf_{uuid.uuid4().hex[:6]}"
p = "СложныйПароль123!🔒"
res1 = await client.post(
"/api/v1/users",
json={"username": u, "display_name": "UTF User", "password": p},
)
assert res1.status_code == 201
cred = base64.b64encode(f"{u}:{p}".encode("utf-8")).decode("utf-8")
res2 = await client.post(
"/api/v1/auth/sessions",
headers={"Authorization": f"Basic {cred}"},
)
assert res2.status_code == 201
assert "token" in res2.json()
@pytest.mark.asyncio
async def test_health_readiness_and_liveness(client: httpx.AsyncClient):
"""Проверка доступности /health/live и готовности хранилищ /health/ready."""
r_live = await client.get("/health/live")
assert r_live.status_code == 200
assert r_live.json()["status"] == "ok"
r_ready = await client.get("/health/ready")
assert r_ready.status_code == 200
assert r_ready.json()["status"] == "ok"