forked from mtusi2026/mtusi2026lab2
feat: ЛР2 - PostgreSQL, Redis сессии и keyset-пагинация
This commit is contained in:
@@ -1,13 +1,15 @@
|
||||
PYTHON ?= python3
|
||||
BASE_URL ?= http://localhost:8080
|
||||
CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
ACTION_SCRIPT ?= scripts/restart.sh
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
.PHONY: help check validate test load test-persistence test-student up down restart
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "test-student: run student tests (pytest); test-persistence: test stack restart with data preservation"
|
||||
@echo "up: build and start docker compose stack; down: stop stack; restart: restart stack"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -16,11 +18,23 @@ validate:
|
||||
$(PYTHON) scripts/validate_openapi.py
|
||||
|
||||
test:
|
||||
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
no_proxy=localhost,127.0.0.1 NO_PROXY=localhost,127.0.0.1 $(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
load:
|
||||
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
no_proxy=localhost,127.0.0.1 NO_PROXY=localhost,127.0.0.1 $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-persistence:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
no_proxy=localhost,127.0.0.1 NO_PROXY=localhost,127.0.0.1 $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
test-student:
|
||||
no_proxy=localhost,127.0.0.1 NO_PROXY=localhost,127.0.0.1 BASE_URL="$(BASE_URL)" $(PYTHON) -m pytest tests_student/ -v
|
||||
|
||||
up:
|
||||
docker compose up -d --build
|
||||
|
||||
down:
|
||||
docker compose down
|
||||
|
||||
restart:
|
||||
docker compose restart
|
||||
|
||||
@@ -1,37 +1,122 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Герейханов Ильяс, БВТ2301
|
||||
- Целевая оценка: 4
|
||||
- Commit/PR: ветка `solution/bvt2301-Gereykhanov`. PR: `ЛР 2 — БВТ2301 — Герейханов — на 4`
|
||||
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI, Uvicorn, PostgreSQL 16, Redis 7, asyncpg, argon2-cffi, Pydantic, Pytest, Docker Compose; документация PostgreSQL, Redis, RFC 7617 (Basic Auth), RFC 6750 (Bearer Token). ИИ использовался для генерации кода тестов pytest, отладки конфигурации Docker Compose и формулирования сценариев проверки персистентности данных.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
1. **Версии runtime и базовых образов:**
|
||||
- Локальный runtime: Linux, Docker 29.9.1, Docker Compose 5.6.0
|
||||
- API контейнер: `python:3.12-slim`
|
||||
- PostgreSQL: `postgres:16-alpine`
|
||||
- Redis: `redis:7-alpine`
|
||||
|
||||
2. **Подготовка окружения и запуск стека:**
|
||||
```sh
|
||||
git checkout solution/bvt2301-Gereykhanov
|
||||
cp .env.example .env
|
||||
|
||||
# Сборка и запуск всех сервисов
|
||||
make up
|
||||
```
|
||||
|
||||
3. **Ожидание готовности и запуск тестов:**
|
||||
```sh
|
||||
# Проверка smoke теста
|
||||
make test
|
||||
|
||||
# Проверка сценария сохранности данных и сессий при рестарте
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
|
||||
# Запуск собственных расширенных тестов
|
||||
make test-student
|
||||
```
|
||||
|
||||
4. **Остановка и удаление контейнеров:**
|
||||
```sh
|
||||
# Остановка контейнеров с сохранением постоянных volumes
|
||||
make down
|
||||
|
||||
# Остановка контейнеров с удалением volumes
|
||||
docker compose down -v
|
||||
```
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
- **Схема процессов и хранилищ:**
|
||||
- Клиент $\to$ HTTP REST API (FastAPI, порт 8080) $\to$ PostgreSQL 16 (данные пользователей, чатов, сообщений) + Redis 7 (сессии пользователей).
|
||||
- Вся инфраструктура разворачивается через `compose.yaml`.
|
||||
- **Источник истины:**
|
||||
- **PostgreSQL 16**: постоянное хранение состояния на именованном Docker volume `pg_data`.
|
||||
- **Redis 7**: хранение токенов сессий с TTL на Docker volume `redis_data` с флагом `--appendonly yes` (AOF-журналирование обеспечивает сохранность сессий при падении или перезапуске).
|
||||
- **Безопасность и аутентификация:**
|
||||
- Пароли хэшируются KDF **Argon2id** (`argon2-cffi`).
|
||||
- Вход в систему выполняется через `POST /api/v1/auth/sessions` с заголовком `Authorization: Basic <base64(username:password)>`.
|
||||
- Сессионный токен генерируется с энтропией 256 бит (`secrets.token_urlsafe(32)`).
|
||||
- Бизнес-эндпоинты защищены через `Authorization: Bearer <token>`. Заголовок `X-User-Id` из первой лабы игнорируется и не даёт доступа.
|
||||
- Логаут (`DELETE /api/v1/auth/sessions/current`) отзывает токен из Redis (повторные запросы с этим токеном получают 401).
|
||||
- При ошибке 401 сервер возвращает заголовок `WWW-Authenticate`: для эндпоинта логина `Basic realm="messenger", charset="UTF-8"`, для остальных эндпоинтов `Bearer realm="messenger"`.
|
||||
- **Курсорная пагинация и индексы:**
|
||||
- Порядок истории строго детерминирован составным ключом `(created_at, id)` по возрастанию.
|
||||
- В PostgreSQL создан составной B-Tree индекс:
|
||||
`CREATE INDEX idx_messages_cursor ON messages (chat_id, created_at ASC, id ASC);`
|
||||
- Поиск страницы выполняется через SQL-условие `WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at ASC, id ASC LIMIT $4`. База делает `Index Scan` без полного перебора таблицы.
|
||||
- **Транзакции и работа с БД:**
|
||||
- Создание чата и добавление участников выполняется атомарно внутри транзакции `async with conn.transaction():`. Если хотя бы один участник не найден, происходит rollback, пустые или повреждённые чаты в базу не попадают.
|
||||
- Подключение к PostgreSQL управляется пулом `asyncpg` (от 2 до 20 соединений). Все запросы параметризованы через `$1, $2`.
|
||||
- **Что изменилось относительно ЛР1:**
|
||||
- Из первой лабы перенесена базовая структура роутов FastAPI, схемы Pydantic и Dockerfile.
|
||||
- Хранилище в оперативной памяти Python полностью заменено на постоянные PostgreSQL 16 и Redis 7.
|
||||
- Заголовок `X-User-Id` удалён и заменён на полноценную авторизацию по сессиям.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `make test` | `PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.` | `evidence/smoke_test.log` |
|
||||
| Сохранение данных и сессий при рестарте | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session.` | `evidence/persistence_test.log` |
|
||||
| Негативные тесты | `make test-student` | 16 тестов проходят: пустые сообщения, пароли из пробелов, запрет тела в auth sessions, Basic Auth битый base64, чужой курсор 400, дубликаты, чужой чат 404, неверный пароль, отзыв сессии, гонка 100 сообщений | `evidence/student_tests.log` |
|
||||
| B-Tree Index Scan на 17 000+ сообщениях | `EXPLAIN (ANALYZE, BUFFERS)` в PostgreSQL | `Index Scan using idx_messages_cursor on messages`. Execution Time: 0.109 ms, без `Seq Scan` | `evidence/explain_index.log` |
|
||||
| Redis сессии с AOF-персистентностью | `docker exec highload-redis-lab2 redis-cli config get appendonly` | Сессии сохраняются на `redis_data` volume и выдерживают рестарт контейнеров | `evidence/docker_services.log` |
|
||||
| Защита от гонок: 100 сообщений от 10 клиентов | `pytest tests_student/ -k test_concurrency_race_condition` | Все 100 сообщений успешно записаны и прочитаны, 100 уникальных ID, строгий порядок | `evidence/student_tests.log` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
- **Профиль нагрузки:** скрипт `tests/load.py`, закрытый цикл параллельных POST-запросов отправки сообщений.
|
||||
- **Параметры:** длительность 30 секунд, 4 параллельных потока
|
||||
- **Результаты нагрузки:**
|
||||
```json
|
||||
{
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 30,
|
||||
"elapsed_seconds": 30.008,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 17657,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 588.401,
|
||||
"successful_latency_ms": {
|
||||
"p50": 6.535,
|
||||
"p95": 8.599,
|
||||
"p99": 10.335
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Рестарт стека `docker compose restart` во время активной сессии | Сохранение подтверждённых данных в Postgres и токенов сессий в Redis; восстановление API $\le$ 90 сек | Контейнеры перезапустились за 2.3 сек, токен юзера сохранил валидность, история сообщений не повреждена | Восстановление за 2.3 сек, потеря подтверждённых данных: 0 |
|
||||
| Обращение с отозванным токеном после logout | HTTP 401 с заголовком `WWW-Authenticate: Bearer` | 401 Unauthorized | Потеря данных отсутствует, токен недействителен |
|
||||
| Неверный пароль при входе | HTTP 401 с заголовком `WWW-Authenticate: Basic` | 401 Unauthorized, токен не выпускается | Безопасность соблюдена |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
## Ограничения
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Какие отказы выдерживаются и какие нет:**
|
||||
1. *Выдерживаются:* перезапуск любого или всех контейнеров (`docker compose restart`). Все подтверждённые данные в Postgres и токены сессий в Redis выживают благодаря томам `pg_data` и `redis_data`. Конкурентная нагрузка и параллельная запись сообщений без гонок.
|
||||
2. *Не выдерживаются:* удаление Docker volumes через `docker compose down -v`, физический выход диска из строя, падение хоста во время активной записи без репликации.
|
||||
- **Учебные упрощения:**
|
||||
1. *Одиночные инстансы:* Postgres, Redis и API запущены в одном экземпляре без репликации и кластеризации.
|
||||
2. *Конфигурация:* учетные данные базы зафиксированы в `compose.yaml` для простоты воспроизведения проверки.
|
||||
|
||||
+27
@@ -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)
|
||||
+32
-5
@@ -1,6 +1,33 @@
|
||||
import os
|
||||
from __future__ import annotations
|
||||
|
||||
APP_HOST = os.getenv("APP_HOST", "0.0.0.0")
|
||||
APP_PORT = int(os.getenv("APP_PORT", "8080"))
|
||||
APP_ENV = os.getenv("APP_ENV", "lab")
|
||||
LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
|
||||
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",
|
||||
)
|
||||
|
||||
+21
-17
@@ -1,26 +1,30 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import Header, Request
|
||||
from fastapi import Depends, Header, Request
|
||||
|
||||
from app.errors import UnauthorizedError
|
||||
from app.schemas import UserResponse
|
||||
from app.storage import UnauthorizedError, storage
|
||||
from app.storage import storage
|
||||
|
||||
|
||||
async def get_current_user(
|
||||
request: Request,
|
||||
x_user_id: str | None = Header(default=None, alias="X-User-Id"),
|
||||
) -> UserResponse:
|
||||
if not x_user_id or not x_user_id.strip():
|
||||
raise UnauthorizedError("Отсутствует заголовок X-User-Id")
|
||||
async def get_current_token(
|
||||
authorization: str | None = Header(default=None, alias="Authorization"),
|
||||
) -> str:
|
||||
if not authorization or not authorization.strip():
|
||||
raise UnauthorizedError("Отсутствует заголовок Authorization")
|
||||
|
||||
# валидация формата UUID
|
||||
try:
|
||||
UUID(x_user_id)
|
||||
except ValueError:
|
||||
raise UnauthorizedError("Неверный формат заголовка X-User-Id")
|
||||
parts = authorization.strip().split(maxsplit=1)
|
||||
if len(parts) != 2 or parts[0].lower() != "bearer":
|
||||
raise UnauthorizedError("Неверная схема авторизации (ожидается Bearer)")
|
||||
|
||||
# проверка существования пользователя
|
||||
user = await storage.get_user_by_id(x_user_id)
|
||||
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
|
||||
|
||||
+50
-11
@@ -9,12 +9,27 @@ from fastapi.responses import JSONResponse
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from app.schemas import ErrorCode, ErrorDetail, ErrorResponse
|
||||
from app.storage import (
|
||||
ConflictError,
|
||||
InvalidRequestError,
|
||||
NotFoundError,
|
||||
UnauthorizedError,
|
||||
)
|
||||
|
||||
|
||||
class StorageError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidRequestError(StorageError):
|
||||
pass
|
||||
|
||||
|
||||
class NotFoundError(StorageError):
|
||||
pass
|
||||
|
||||
|
||||
class ConflictError(StorageError):
|
||||
pass
|
||||
|
||||
|
||||
class UnauthorizedError(StorageError):
|
||||
pass
|
||||
|
||||
|
||||
logger = logging.getLogger("app.errors")
|
||||
|
||||
@@ -27,15 +42,22 @@ def get_request_id(request: Request) -> str:
|
||||
|
||||
|
||||
def make_error_response(
|
||||
status_code: int, code: ErrorCode, message: str, request_id: str
|
||||
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={"X-Request-Id": request_id, "Content-Type": "application/json"},
|
||||
headers=resp_headers,
|
||||
)
|
||||
|
||||
|
||||
@@ -54,8 +76,17 @@ def register_error_handlers(app: FastAPI) -> None:
|
||||
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
|
||||
status.HTTP_401_UNAUTHORIZED,
|
||||
ErrorCode.UNAUTHORIZED,
|
||||
str(exc),
|
||||
req_id,
|
||||
headers={"WWW-Authenticate": scheme},
|
||||
)
|
||||
|
||||
@app.exception_handler(NotFoundError)
|
||||
@@ -77,7 +108,6 @@ def register_error_handlers(app: FastAPI) -> None:
|
||||
request: Request, exc: RequestValidationError
|
||||
) -> JSONResponse:
|
||||
req_id = get_request_id(request)
|
||||
# Ошибки валидации входного JSON маппятся на 400
|
||||
errors = exc.errors()
|
||||
messages = []
|
||||
for err in errors:
|
||||
@@ -95,10 +125,17 @@ def register_error_handlers(app: FastAPI) -> None:
|
||||
) -> 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:
|
||||
@@ -113,7 +150,9 @@ def register_error_handlers(app: FastAPI) -> None:
|
||||
code = ErrorCode.UNAVAILABLE
|
||||
|
||||
msg = exc.detail if isinstance(exc.detail, str) else "HTTP ошибка"
|
||||
return make_error_response(exc.status_code, code, msg, req_id)
|
||||
return make_error_response(
|
||||
exc.status_code, code, msg, req_id, headers=extra_headers
|
||||
)
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def unhandled_exception_handler(
|
||||
|
||||
+7
-2
@@ -9,10 +9,12 @@ 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")
|
||||
|
||||
@@ -22,13 +24,15 @@ 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 and cleaning up...")
|
||||
logger.info("Graceful shutdown: closing connections...")
|
||||
await storage.disconnect()
|
||||
|
||||
|
||||
app = FastAPI(
|
||||
title="highload-messenger",
|
||||
version="1.1.0",
|
||||
version="1.2.0",
|
||||
docs_url="/docs",
|
||||
redoc_url=None,
|
||||
lifespan=lifespan,
|
||||
@@ -39,6 +43,7 @@ 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)
|
||||
|
||||
@@ -29,6 +29,21 @@ class RequestIdAndLoggingMiddleware(BaseHTTPMiddleware):
|
||||
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:
|
||||
|
||||
@@ -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)
|
||||
@@ -1,8 +1,10 @@
|
||||
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"])
|
||||
|
||||
@@ -11,6 +13,7 @@ router = APIRouter(tags=["health"])
|
||||
"/health/live", response_model=HealthResponse, status_code=status.HTTP_200_OK
|
||||
)
|
||||
async def health_live() -> HealthResponse:
|
||||
"""Проверка жизни процесса (Liveness)."""
|
||||
return HealthResponse(status="ok")
|
||||
|
||||
|
||||
@@ -18,4 +21,11 @@ async def health_live() -> HealthResponse:
|
||||
"/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")
|
||||
|
||||
@@ -36,7 +36,7 @@ async def create_message(
|
||||
) -> MessageResponse:
|
||||
"""Отправка сообщения в чат."""
|
||||
valid_id = validate_uuid(chat_id, "chat_id")
|
||||
msg = await storage.create_message(
|
||||
msg = await storage.send_message(
|
||||
caller_id=current_user.id,
|
||||
chat_id=valid_id,
|
||||
text=body.text,
|
||||
|
||||
+3
-1
@@ -13,7 +13,9 @@ router = APIRouter(prefix="/api/v1/users", tags=["users"])
|
||||
async def create_user(body: CreateUserRequest) -> UserResponse:
|
||||
"""Регистрация нового пользователя."""
|
||||
user = await storage.create_user(
|
||||
username=body.username, display_name=body.display_name
|
||||
username=body.username,
|
||||
display_name=body.display_name,
|
||||
password=body.password,
|
||||
)
|
||||
return user
|
||||
|
||||
|
||||
+25
-7
@@ -50,6 +50,7 @@ class CreateUserRequest(BaseModel):
|
||||
|
||||
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
|
||||
@@ -61,8 +62,16 @@ class CreateUserRequest(BaseModel):
|
||||
@field_validator("display_name")
|
||||
@classmethod
|
||||
def validate_display_name(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
clean = v.replace("\x00", "")
|
||||
if not clean.strip():
|
||||
raise ValueError("Отображаемое имя не может состоять только из пробелов")
|
||||
return clean
|
||||
|
||||
@field_validator("password")
|
||||
@classmethod
|
||||
def validate_password(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("Пароль не может состоять только из пробелов")
|
||||
return v
|
||||
|
||||
|
||||
@@ -75,6 +84,15 @@ class UserResponse(BaseModel):
|
||||
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")
|
||||
|
||||
@@ -84,17 +102,16 @@ class CreateChatRequest(BaseModel):
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def validate_title(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
clean = v.replace("\x00", "")
|
||||
if not clean.strip():
|
||||
raise ValueError("Название не может состоять только из пробелов")
|
||||
return v
|
||||
return clean
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def validate_member_ids(cls, v: list[str]) -> list[str]:
|
||||
# Проверка уникальности
|
||||
if len(v) != len(set(v)):
|
||||
raise ValueError("Идентификаторы участников должны быть уникальными")
|
||||
# Проверка формата каждого UUID
|
||||
for member_id in v:
|
||||
try:
|
||||
UUID(member_id)
|
||||
@@ -127,9 +144,10 @@ class CreateMessageRequest(BaseModel):
|
||||
@field_validator("text")
|
||||
@classmethod
|
||||
def validate_text(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
clean = v.replace("\x00", "")
|
||||
if not clean.strip():
|
||||
raise ValueError("Текст сообщения не может состоять только из пробелов")
|
||||
return v
|
||||
return clean
|
||||
|
||||
|
||||
class MessageResponse(BaseModel):
|
||||
|
||||
+444
-155
@@ -1,36 +1,36 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import base64
|
||||
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,
|
||||
)
|
||||
|
||||
|
||||
class StorageError(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class InvalidRequestError(StorageError):
|
||||
pass
|
||||
|
||||
|
||||
class NotFoundError(StorageError):
|
||||
pass
|
||||
|
||||
|
||||
class ConflictError(StorageError):
|
||||
pass
|
||||
|
||||
|
||||
class UnauthorizedError(StorageError):
|
||||
pass
|
||||
logger = logging.getLogger("app.storage")
|
||||
|
||||
|
||||
def encode_cursor(data: dict) -> str:
|
||||
@@ -54,188 +54,477 @@ def decode_cursor(cursor_str: str) -> dict:
|
||||
raise InvalidRequestError("Некорректный курсор") from exc
|
||||
|
||||
|
||||
class InMemoryStorage:
|
||||
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")
|
||||
|
||||
|
||||
class PostgresStorage:
|
||||
def __init__(self) -> None:
|
||||
self._lock = asyncio.Lock()
|
||||
self._users_by_id: dict[str, UserResponse] = {}
|
||||
self._users_by_username: dict[str, UserResponse] = {}
|
||||
self._chats_by_id: dict[str, ChatResponse] = {}
|
||||
self._messages_by_chat: dict[str, list[MessageResponse]] = {}
|
||||
self.pg_pool: asyncpg.Pool | None = None
|
||||
self.redis_client: redis.Redis | None = None
|
||||
|
||||
async def create_user(self, username: str, display_name: str) -> UserResponse:
|
||||
async with self._lock:
|
||||
if username in self._users_by_username:
|
||||
raise ConflictError("Имя пользователя уже занято")
|
||||
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=5.0,
|
||||
timeout=5.0,
|
||||
)
|
||||
|
||||
user_id = str(uuid.uuid4())
|
||||
created_at = now_utc_iso()
|
||||
user = UserResponse(
|
||||
id=user_id,
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
created_at=created_at,
|
||||
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,
|
||||
)
|
||||
|
||||
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.pg_pool.acquire() 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)
|
||||
display_name = display_name.replace("\x00", "")
|
||||
|
||||
assert self.pg_pool is not None
|
||||
try:
|
||||
async with self.pg_pool.acquire() 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:
|
||||
assert self.pg_pool is not None
|
||||
async with self.pg_pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
"""
|
||||
SELECT id, username, display_name, password_hash, created_at
|
||||
FROM users
|
||||
WHERE username = $1
|
||||
""",
|
||||
username,
|
||||
)
|
||||
self._users_by_id[user_id] = user
|
||||
self._users_by_username[username] = user
|
||||
return user
|
||||
|
||||
async def get_user_by_id(self, user_id: str) -> UserResponse:
|
||||
async with self._lock:
|
||||
user = self._users_by_id.get(user_id)
|
||||
if not user:
|
||||
raise UnauthorizedError("Пользователь не найден или не авторизован")
|
||||
return user
|
||||
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=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
|
||||
|
||||
assert self.pg_pool is not None
|
||||
async with self.pg_pool.acquire() 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=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:
|
||||
async with self._lock:
|
||||
# Вызывающий обязан быть в списке участников
|
||||
if caller_id not in member_ids:
|
||||
raise InvalidRequestError("Создатель чата должен быть в списке участников member_ids")
|
||||
if caller_id not in member_ids:
|
||||
raise InvalidRequestError("Создатель чата должен быть в списке участников")
|
||||
|
||||
# Все участники обязаны существовать
|
||||
for mid in member_ids:
|
||||
if mid not in self._users_by_id:
|
||||
raise InvalidRequestError(f"Пользователь {mid} не существует")
|
||||
chat_id = uuid.uuid4()
|
||||
now = dt.datetime.now(dt.timezone.utc)
|
||||
title = title.replace("\x00", "")
|
||||
|
||||
chat_id = str(uuid.uuid4())
|
||||
created_at = now_utc_iso()
|
||||
chat = ChatResponse(
|
||||
id=chat_id,
|
||||
title=title,
|
||||
member_ids=list(member_ids),
|
||||
created_at=created_at,
|
||||
member_uuids = [uuid.UUID(m) for m in member_ids]
|
||||
|
||||
assert self.pg_pool is not None
|
||||
async with self.pg_pool.acquire() as conn:
|
||||
# Проверяем существование всех участников
|
||||
found = await conn.fetch(
|
||||
"SELECT id FROM users WHERE id = ANY($1::uuid[])", member_uuids
|
||||
)
|
||||
self._chats_by_id[chat_id] = chat
|
||||
self._messages_by_chat[chat_id] = []
|
||||
return chat
|
||||
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:
|
||||
async with self._lock:
|
||||
chat = self._chats_by_id.get(chat_id)
|
||||
# Если чата нет или вызывающий не участник — строго 404
|
||||
if not chat or caller_id not in chat.member_ids:
|
||||
try:
|
||||
cid = uuid.UUID(chat_id)
|
||||
c_caller = uuid.UUID(caller_id)
|
||||
except ValueError:
|
||||
raise NotFoundError("Чат не найден")
|
||||
|
||||
assert self.pg_pool is not None
|
||||
async with self.pg_pool.acquire() 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("Чат не найден")
|
||||
return chat
|
||||
|
||||
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=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]:
|
||||
async with self._lock:
|
||||
# Фильтруем только чаты, где пользователь — участник
|
||||
user_chats = [
|
||||
chat
|
||||
for chat in self._chats_by_id.values()
|
||||
if caller_id in chat.member_ids
|
||||
]
|
||||
# Сортировка по (created_at, id) по возрастанию
|
||||
user_chats.sort(key=lambda x: (x.created_at, x.id))
|
||||
try:
|
||||
c_caller = uuid.UUID(caller_id)
|
||||
except ValueError:
|
||||
return [], None
|
||||
|
||||
start_idx = 0
|
||||
if cursor is not None:
|
||||
c_data = decode_cursor(cursor)
|
||||
if c_data.get("type") != "chats":
|
||||
raise InvalidRequestError("Курсор недействителен для списка чатов")
|
||||
c_created = c_data.get("created_at")
|
||||
c_id = c_data.get("id")
|
||||
if (
|
||||
not isinstance(c_created, str)
|
||||
or not isinstance(c_id, str)
|
||||
or not c_created.strip()
|
||||
or not c_id.strip()
|
||||
):
|
||||
raise InvalidRequestError("Поврежденный курсор")
|
||||
c_created: dt.datetime | None = None
|
||||
c_id: uuid.UUID | None = None
|
||||
|
||||
# Ищем первый элемент, строго больший курсора
|
||||
start_idx = len(user_chats)
|
||||
for idx, chat in enumerate(user_chats):
|
||||
if (chat.created_at, chat.id) > (c_created, c_id):
|
||||
start_idx = idx
|
||||
break
|
||||
|
||||
items = user_chats[start_idx : start_idx + limit]
|
||||
has_next = (start_idx + limit) < len(user_chats)
|
||||
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}
|
||||
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("Некорректные параметры курсора")
|
||||
|
||||
return items, next_cursor
|
||||
assert self.pg_pool is not None
|
||||
async with self.pg_pool.acquire() 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)
|
||||
|
||||
async def create_message(
|
||||
has_next = len(rows) > limit
|
||||
items_rows = rows[:limit]
|
||||
|
||||
items = [
|
||||
ChatResponse(
|
||||
id=str(r["id"]),
|
||||
title=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:
|
||||
async with self._lock:
|
||||
chat = self._chats_by_id.get(chat_id)
|
||||
if not chat or caller_id not in chat.member_ids:
|
||||
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 = text.replace("\x00", "")
|
||||
|
||||
assert self.pg_pool is not None
|
||||
async with self.pg_pool.acquire() 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("Чат не найден")
|
||||
|
||||
message_id = str(uuid.uuid4())
|
||||
created_at = now_utc_iso()
|
||||
msg = MessageResponse(
|
||||
id=message_id,
|
||||
chat_id=chat_id,
|
||||
sender_id=caller_id,
|
||||
text=text,
|
||||
created_at=created_at,
|
||||
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,
|
||||
now,
|
||||
)
|
||||
self._messages_by_chat[chat_id].append(msg)
|
||||
return msg
|
||||
|
||||
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]:
|
||||
async with self._lock:
|
||||
chat = self._chats_by_id.get(chat_id)
|
||||
if not chat or caller_id not in chat.member_ids:
|
||||
try:
|
||||
cid = uuid.UUID(chat_id)
|
||||
c_caller = uuid.UUID(caller_id)
|
||||
except ValueError:
|
||||
raise NotFoundError("Чат не найден")
|
||||
|
||||
assert self.pg_pool is not None
|
||||
async with self.pg_pool.acquire() 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("Чат не найден")
|
||||
|
||||
all_msgs = self._messages_by_chat.get(chat_id, [])
|
||||
# Сортировка по (created_at, id) по возрастанию
|
||||
sorted_msgs = sorted(all_msgs, key=lambda x: (x.created_at, x.id))
|
||||
c_created: dt.datetime | None = None
|
||||
c_id: uuid.UUID | None = None
|
||||
|
||||
start_idx = 0
|
||||
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 = c_data.get("created_at")
|
||||
c_id = c_data.get("id")
|
||||
c_created_str = c_data.get("created_at")
|
||||
c_id_str = c_data.get("id")
|
||||
if (
|
||||
not isinstance(c_created, str)
|
||||
or not isinstance(c_id, str)
|
||||
or not c_created.strip()
|
||||
or not c_id.strip()
|
||||
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("Некорректные параметры курсора")
|
||||
|
||||
start_idx = len(sorted_msgs)
|
||||
for idx, msg in enumerate(sorted_msgs):
|
||||
if (msg.created_at, msg.id) > (c_created, c_id):
|
||||
start_idx = idx
|
||||
break
|
||||
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)
|
||||
|
||||
items = sorted_msgs[start_idx : start_idx + limit]
|
||||
has_next = (start_idx + limit) < len(sorted_msgs)
|
||||
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,
|
||||
}
|
||||
)
|
||||
has_next = len(rows) > limit
|
||||
items_rows = rows[:limit]
|
||||
|
||||
return items, next_cursor
|
||||
items = [
|
||||
MessageResponse(
|
||||
id=str(r["id"]),
|
||||
chat_id=str(r["chat_id"]),
|
||||
sender_id=str(r["sender_id"]),
|
||||
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 = InMemoryStorage()
|
||||
# Глобальный экземпляр хранилища
|
||||
storage = PostgresStorage()
|
||||
|
||||
@@ -0,0 +1,66 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16-alpine
|
||||
container_name: highload-postgres-lab2
|
||||
environment:
|
||||
POSTGRES_USER: postgres
|
||||
POSTGRES_PASSWORD: postgres
|
||||
POSTGRES_DB: messenger
|
||||
volumes:
|
||||
- pg_data:/var/lib/postgresql/data
|
||||
- ./infra/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U postgres -d messenger"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
ports:
|
||||
- "127.0.0.1:5432:5432"
|
||||
|
||||
redis:
|
||||
image: redis:7-alpine
|
||||
container_name: highload-redis-lab2
|
||||
command: ["redis-server", "--appendonly", "yes"]
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
ports:
|
||||
- "127.0.0.1:6379:6379"
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: highload-messenger:lab2
|
||||
container_name: highload-messenger-lab2
|
||||
environment:
|
||||
APP_HOST: "0.0.0.0"
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: "lab"
|
||||
SESSION_TTL_SECONDS: "3600"
|
||||
DATABASE_URL: "postgresql://postgres:postgres@postgres:5432/messenger"
|
||||
SESSION_STORE: "redis"
|
||||
CACHE_URL: "redis://redis:6379/0"
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/live')"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 5
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
pg_data:
|
||||
redis_data:
|
||||
@@ -0,0 +1,4 @@
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
highload-messenger-lab2 highload-messenger:lab2 "python -m uvicorn a…" api About a minute ago Up 4 seconds (health: starting) 127.0.0.1:8080->8080/tcp
|
||||
highload-postgres-lab2 postgres:16-alpine "docker-entrypoint.s…" postgres 4 minutes ago Up 4 seconds (healthy) 127.0.0.1:5432->5432/tcp
|
||||
highload-redis-lab2 redis:7-alpine "docker-entrypoint.s…" redis 4 minutes ago Up 4 seconds (healthy) 127.0.0.1:6379->6379/tcp
|
||||
@@ -0,0 +1,13 @@
|
||||
QUERY PLAN
|
||||
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|
||||
Limit (cost=0.29..10.08 rows=2 width=67) (actual time=0.016..0.019 rows=0 loops=1)
|
||||
Buffers: shared hit=2
|
||||
-> Index Scan using idx_messages_cursor on messages (cost=0.29..10.08 rows=2 width=67) (actual time=0.015..0.018 rows=0 loops=1)
|
||||
Index Cond: ((chat_id = 'e6eefcbf-9c69-4768-ad96-e44d6338e030'::uuid) AND (ROW(created_at, id) > ROW('2026-10-22 19:24:00+00'::timestamp with time zone, '00000000-0000-0000-0000-000000000000'::uuid)))
|
||||
Buffers: shared hit=2
|
||||
Planning:
|
||||
Buffers: shared hit=106
|
||||
Planning Time: 0.589 ms
|
||||
Execution Time: 0.071 ms
|
||||
(9 rows)
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
no_proxy=localhost,127.0.0.1 NO_PROXY=localhost,127.0.0.1 python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,2 @@
|
||||
no_proxy=localhost,127.0.0.1 NO_PROXY=localhost,127.0.0.1 python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,28 @@
|
||||
no_proxy=localhost,127.0.0.1 NO_PROXY=localhost,127.0.0.1 BASE_URL="http://localhost:8080" .venv/bin/python3 -m pytest tests_student/ -v
|
||||
============================= test session starts ==============================
|
||||
platform linux -- Python 3.12.15, pytest-9.1.1, pluggy-1.7.0 -- /home/ilyas/projects/labs_highload/mtusi2026lab2/.venv/bin/python3
|
||||
cachedir: .pytest_cache
|
||||
rootdir: /home/ilyas/projects/labs_highload/mtusi2026lab2
|
||||
configfile: pytest.ini
|
||||
plugins: anyio-4.15.1, asyncio-1.4.0
|
||||
asyncio: mode=Mode.AUTO, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
|
||||
collecting ... collected 16 items
|
||||
|
||||
tests_student/tests.py::test_invalid_json_and_extra_fields PASSED [ 6%]
|
||||
tests_student/tests.py::test_outsider_chat_access_is_404 PASSED [ 12%]
|
||||
tests_student/tests.py::test_empty_and_whitespace_message PASSED [ 18%]
|
||||
tests_student/tests.py::test_duplicate_username_conflict PASSED [ 25%]
|
||||
tests_student/tests.py::test_wrong_password_and_bad_basic_auth PASSED [ 31%]
|
||||
tests_student/tests.py::test_logout_and_revocation PASSED [ 37%]
|
||||
tests_student/tests.py::test_multi_page_cursor_pagination PASSED [ 43%]
|
||||
tests_student/tests.py::test_concurrency_race_condition PASSED [ 50%]
|
||||
tests_student/tests.py::test_password_whitespace_rejected PASSED [ 56%]
|
||||
tests_student/tests.py::test_auth_sessions_with_body_rejected PASSED [ 62%]
|
||||
tests_student/tests.py::test_unsupported_media_type_415 PASSED [ 68%]
|
||||
tests_student/tests.py::test_nul_byte_in_strings_handled PASSED [ 75%]
|
||||
tests_student/tests.py::test_basic_auth_invalid_base64_returns_401 PASSED [ 81%]
|
||||
tests_student/tests.py::test_cross_chat_cursor_rejected_400 PASSED [ 87%]
|
||||
tests_student/tests.py::test_utf8_password_support PASSED [ 93%]
|
||||
tests_student/tests.py::test_health_readiness_and_liveness PASSED [100%]
|
||||
|
||||
============================== 16 passed in 7.38s ==============================
|
||||
@@ -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 TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_cursor ON messages (chat_id, created_at ASC, id ASC);
|
||||
@@ -1,6 +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
|
||||
|
||||
Executable
+5
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
docker compose restart
|
||||
exit 0
|
||||
@@ -1,15 +1,16 @@
|
||||
import os
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import pytest
|
||||
from httpx import ASGITransport, AsyncClient
|
||||
|
||||
from app.main import app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def client():
|
||||
base_url = os.getenv("BASE_URL", "http://testserver")
|
||||
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
|
||||
|
||||
+349
-198
@@ -1,14 +1,46 @@
|
||||
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 и запрета лишних полей (400 invalid_request)."""
|
||||
# 1. Невалидный синтаксис JSON
|
||||
"""Проверка невалидного JSON, лишних полей, перевода строки и валидации курсора."""
|
||||
# 1. Невалидный синтаксис JSON -> 400
|
||||
res_malformed = await client.post(
|
||||
"/api/v1/users",
|
||||
content="not a valid json {",
|
||||
@@ -23,35 +55,34 @@ async def test_invalid_json_and_extra_fields(client: AsyncClient):
|
||||
== err_malformed["error"]["request_id"]
|
||||
)
|
||||
|
||||
# 2. Лишние поля (additionalProperties: false)
|
||||
# 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
|
||||
err_extra = res_extra.json()
|
||||
assert err_extra["error"]["code"] == "invalid_request"
|
||||
assert res_extra.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
# 3. Запрет завершающего перевода строки в username ("abc\n")
|
||||
# 3. Запрет завершающего перевода строки в username ("abc\n") -> 400
|
||||
res_newline = await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": "abc\n", "display_name": "test_newline"},
|
||||
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=
|
||||
user_res = (
|
||||
await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": f"u_{uuid.uuid4().hex[:8]}", "display_name": "test_cursor_val"},
|
||||
)
|
||||
).json()
|
||||
headers = {"X-User-Id": user_res["id"]}
|
||||
# 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)
|
||||
@@ -67,254 +98,374 @@ async def test_invalid_json_and_extra_fields(client: AsyncClient):
|
||||
@pytest.mark.asyncio
|
||||
async def test_outsider_chat_access_is_404(client: AsyncClient):
|
||||
"""Проверка того, что доступ к чужому чату возвращает строго 404 (а не 403)."""
|
||||
# Создаём двух участников чата
|
||||
test_user1 = (
|
||||
await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": f"u1_{uuid.uuid4().hex[:8]}", "display_name": "test_user1"},
|
||||
)
|
||||
).json()
|
||||
test_user2 = (
|
||||
await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": f"u2_{uuid.uuid4().hex[:8]}", "display_name": "test_user2"},
|
||||
)
|
||||
).json()
|
||||
# Создаём стороннего пользователя
|
||||
test_user3 = (
|
||||
await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": f"u3_{uuid.uuid4().hex[:8]}", "display_name": "test_user3"},
|
||||
)
|
||||
).json()
|
||||
alice = await register_and_login(client, "alice")
|
||||
bob = await register_and_login(client, "bob")
|
||||
eve = await register_and_login(client, "eve")
|
||||
|
||||
# Первый пользователь создаёт чат со вторым
|
||||
chat = (
|
||||
await client.post(
|
||||
"/api/v1/chats",
|
||||
headers={"X-User-Id": test_user1["id"]},
|
||||
json={"title": "Private Chat", "member_ids": [test_user1["id"], test_user2["id"]]},
|
||||
)
|
||||
).json()
|
||||
|
||||
chat_id = chat["id"]
|
||||
|
||||
# Сторонний пользователь пытается получить чат по ID -> 404
|
||||
res_chat = await client.get(
|
||||
f"/api/v1/chats/{chat_id}", headers={"X-User-Id": test_user3["id"]}
|
||||
chat_res = await client.post(
|
||||
"/api/v1/chats",
|
||||
headers=alice["headers"],
|
||||
json={
|
||||
"title": "Private Chat",
|
||||
"member_ids": [alice["user"]["id"], bob["user"]["id"]],
|
||||
},
|
||||
)
|
||||
assert res_chat.status_code == 404
|
||||
assert res_chat.json()["error"]["code"] == "not_found"
|
||||
assert chat_res.status_code == 201
|
||||
chat_id = chat_res.json()["id"]
|
||||
|
||||
# Сторонний пользователь пытается отправить сообщение в чужой чат -> 404
|
||||
res_post = await client.post(
|
||||
# Ева пытается получить чужой чат -> 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={"X-User-Id": test_user3["id"]},
|
||||
json={"text": "Привет извне"},
|
||||
headers=eve["headers"],
|
||||
json={"text": "Шпионское сообщение"},
|
||||
)
|
||||
assert res_post.status_code == 404
|
||||
assert res_post.json()["error"]["code"] == "not_found"
|
||||
assert res_send.status_code == 404
|
||||
assert res_send.json()["error"]["code"] == "not_found"
|
||||
|
||||
# Сторонний пользователь пытается прочитать сообщения чужого чата -> 404
|
||||
res_msgs = await client.get(
|
||||
f"/api/v1/chats/{chat_id}/messages", headers={"X-User-Id": test_user3["id"]}
|
||||
# Ева пытается прочитать сообщения чужого чата -> 404
|
||||
res_list = await client.get(
|
||||
f"/api/v1/chats/{chat_id}/messages", headers=eve["headers"]
|
||||
)
|
||||
assert res_msgs.status_code == 404
|
||||
assert res_msgs.json()["error"]["code"] == "not_found"
|
||||
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)."""
|
||||
user = (
|
||||
await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": f"u_{uuid.uuid4().hex[:8]}", "display_name": "test_user"},
|
||||
)
|
||||
).json()
|
||||
"""Проверка запрета отправки пустого текста или текста из одних пробелов (400)."""
|
||||
alice = await register_and_login(client, "msg_user")
|
||||
chat = (
|
||||
await client.post(
|
||||
"/api/v1/chats",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
json={"title": "Chat", "member_ids": [user["id"]]},
|
||||
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={"X-User-Id": user["id"]},
|
||||
headers=alice["headers"],
|
||||
json={"text": ""},
|
||||
)
|
||||
assert res_empty.status_code == 400
|
||||
assert res_empty.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
# Только пробелы и переводы строк
|
||||
res_spaces = await client.post(
|
||||
# Одни пробелы и переводы строк -> 400
|
||||
res_whitespace = await client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
json={"text": " \t \n "},
|
||||
headers=alice["headers"],
|
||||
json={"text": " \n\t "},
|
||||
)
|
||||
assert res_spaces.status_code == 400
|
||||
assert res_spaces.json()["error"]["code"] == "invalid_request"
|
||||
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)."""
|
||||
uname = f"unique_{uuid.uuid4().hex[:8]}"
|
||||
res1 = await client.post(
|
||||
"/api/v1/users", json={"username": uname, "display_name": "test_user1"}
|
||||
)
|
||||
"""Проверка запрета дублирования 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": "test_user2"}
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": uname,
|
||||
"display_name": "Второй с тем же ником",
|
||||
"password": "AnotherPassword123!",
|
||||
},
|
||||
)
|
||||
assert res2.status_code == 409
|
||||
err = res2.json()
|
||||
assert err["error"]["code"] == "conflict"
|
||||
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-курсору."""
|
||||
user = (
|
||||
await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": f"pag_{uuid.uuid4().hex[:8]}", "display_name": "test_user"},
|
||||
)
|
||||
).json()
|
||||
"""Проверка обхода истории сообщений через keyset-курсор на нескольких страницах."""
|
||||
alice = await register_and_login(client, "pager")
|
||||
chat = (
|
||||
await client.post(
|
||||
"/api/v1/chats",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
json={"title": "Pagination Chat", "member_ids": [user["id"]]},
|
||||
headers=alice["headers"],
|
||||
json={"title": "Pagination Chat", "member_ids": [alice["user"]["id"]]},
|
||||
)
|
||||
).json()
|
||||
chat_id = chat["id"]
|
||||
|
||||
# Отправляем 5 сообщений
|
||||
sent_texts = [f"Message #{i}" for i in range(1, 6)]
|
||||
created_messages = []
|
||||
for txt in sent_texts:
|
||||
res = await client.post(
|
||||
f"/api/v1/chats/{chat_id}/messages",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
json={"text": txt},
|
||||
)
|
||||
assert res.status_code == 201
|
||||
created_messages.append(res.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"])
|
||||
|
||||
# Страница 1: limit=2
|
||||
p1 = (
|
||||
await client.get(
|
||||
f"/api/v1/chats/{chat_id}/messages?limit=2",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
)
|
||||
).json()
|
||||
assert len(p1["items"]) == 2
|
||||
assert p1["next_cursor"] is not None
|
||||
# Читаем страницами по 4 сообщения
|
||||
gathered_ids = []
|
||||
cursor = None
|
||||
pages_count = 0
|
||||
|
||||
# Страница 2: limit=2 с курсором со страницы 1
|
||||
p2 = (
|
||||
await client.get(
|
||||
f"/api/v1/chats/{chat_id}/messages?limit=2&cursor={p1['next_cursor']}",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
)
|
||||
).json()
|
||||
assert len(p2["items"]) == 2
|
||||
assert p2["next_cursor"] is not None
|
||||
while True:
|
||||
url = f"/api/v1/chats/{chat['id']}/messages?limit=4"
|
||||
if cursor:
|
||||
url += f"&cursor={cursor}"
|
||||
|
||||
# Страница 3: limit=2 с курсором со страницы 2 -> остался 1 элемент, next_cursor == None
|
||||
p3 = (
|
||||
await client.get(
|
||||
f"/api/v1/chats/{chat_id}/messages?limit=2&cursor={p2['next_cursor']}",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
)
|
||||
).json()
|
||||
assert len(p3["items"]) == 1
|
||||
assert p3["next_cursor"] is None
|
||||
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"])
|
||||
|
||||
# Проверяем, что все 5 сообщений собраны без повторов и потерь
|
||||
all_retrieved = p1["items"] + p2["items"] + p3["items"]
|
||||
assert len(all_retrieved) == 5
|
||||
assert [m["id"] for m in all_retrieved] == [m["id"] for m in created_messages]
|
||||
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):
|
||||
"""
|
||||
Защита состояния от гонок:
|
||||
Параллельно отправляем 100 сообщений от 10 клиентов,
|
||||
затем получаем ровно 100 уникальных сообщений без повреждений.
|
||||
"""
|
||||
# 1. Создаём 10 клиентов
|
||||
users = []
|
||||
for i in range(10):
|
||||
u = (
|
||||
await client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": f"conc_{i}_{uuid.uuid4().hex[:6]}",
|
||||
"display_name": f"test_user_{i}",
|
||||
},
|
||||
)
|
||||
).json()
|
||||
users.append(u)
|
||||
"""Проверка устойчивости к параллельным гонкам: 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]
|
||||
|
||||
user_ids = [u["id"] for u in users]
|
||||
|
||||
# 2. Создаём чат со всеми 10 участниками
|
||||
# Первый пользователь создаёт общий чат со всеми 10 участниками
|
||||
chat = (
|
||||
await client.post(
|
||||
"/api/v1/chats",
|
||||
headers={"X-User-Id": user_ids[0]},
|
||||
json={"title": "Highload Concurrency Chat", "member_ids": user_ids},
|
||||
headers=users[0]["headers"],
|
||||
json={"title": "Massive Concurrent Chat", "member_ids": all_user_ids},
|
||||
)
|
||||
).json()
|
||||
|
||||
chat_id = chat["id"]
|
||||
|
||||
# 3. Каждый из 10 клиентов отправляет по 10 сообщений параллельно (итого 100 сообщений)
|
||||
async def send_batch(user, client_idx):
|
||||
tasks = []
|
||||
for msg_idx in range(10):
|
||||
text = f"client-{client_idx}-msg-{msg_idx}"
|
||||
tasks.append(
|
||||
client.post(
|
||||
f"/api/v1/chats/{chat_id}/messages",
|
||||
headers={"X-User-Id": user["id"]},
|
||||
json={"text": text},
|
||||
)
|
||||
# Отправляем по 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']}"},
|
||||
)
|
||||
return await asyncio.gather(*tasks)
|
||||
|
||||
# Запускаем отправку от всех 10 клиентов одновременно
|
||||
batch_results = await asyncio.gather(*[send_batch(users[i], i) for i in range(10)])
|
||||
await asyncio.gather(*(sender(u, 10) for u in users))
|
||||
|
||||
# Проверяем, что все 100 запросов завершились со статусом 201 Created
|
||||
all_responses = [resp for batch in batch_results for resp in batch]
|
||||
assert len(all_responses) == 100
|
||||
for resp in all_responses:
|
||||
assert resp.status_code == 201
|
||||
# Считываем все сообщения из чата
|
||||
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
|
||||
|
||||
# 4. Читаем все сообщения из чата (limit=100)
|
||||
history_res = await client.get(
|
||||
f"/api/v1/chats/{chat_id}/messages?limit=100",
|
||||
headers={"X-User-Id": user_ids[0]},
|
||||
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 history_res.status_code == 200
|
||||
history = history_res.json()
|
||||
items = history["items"]
|
||||
assert res.status_code == 400
|
||||
data = res.json()
|
||||
assert data["error"]["code"] == "invalid_request"
|
||||
|
||||
# параллельно отправим 100 сообщений от 10 клиентов, затем получаем ровно 100 уникальных сообщений
|
||||
assert len(items) == 100, f"Expected 100 messages, received {len(items)}"
|
||||
unique_ids = {m["id"] for m in items}
|
||||
assert len(unique_ids) == 100, "Found duplicate message IDs"
|
||||
|
||||
# Проверяем монотонную сортировку (created_at, id)
|
||||
for idx in range(len(items) - 1):
|
||||
assert (items[idx]["created_at"], items[idx]["id"]) <= (
|
||||
items[idx + 1]["created_at"],
|
||||
items[idx + 1]["id"],
|
||||
)
|
||||
@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):
|
||||
"""Символ \\u0000 в строках не должен вызывать 500/503 и должен корректно обрабатываться."""
|
||||
u = f"nul_user_{uuid.uuid4().hex[:6]}"
|
||||
res = await client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": u, "display_name": "Hello\u0000World", "password": "Password123456!"},
|
||||
)
|
||||
assert res.status_code == 201
|
||||
data = res.json()
|
||||
assert data["username"] == u
|
||||
assert data["display_name"] == "HelloWorld"
|
||||
|
||||
|
||||
@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"
|
||||
|
||||
Reference in New Issue
Block a user