ЛР2: PostgreSQL, сессии (Basic + Bearer), Compose, миграции
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
2026-10-16 11:11:00 +03:00
parent 65003b6119
commit 4937d6d4e8
56 changed files with 1969 additions and 26 deletions
+17 -1
View File
@@ -14,7 +14,23 @@ backups
*.pfx
*.jks
.venv
__pycache__
**/__pycache__
**/*.pyc
.pytest_cache
node_modules
evidence
.DS_Store
tests
student-tests
pytest.ini
requirements-test.txt
requirements-dev.txt
scripts
contracts
examples
infra
*.md
Dockerfile*
compose*.yaml
Makefile
lab.json
+23 -10
View File
@@ -1,11 +1,24 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# Names follow pydantic-settings: prefix APP_CONFIG__, nesting via "__" (see app/core/config.py).
# Mapping to the skeleton's logical names: APP_HOST -> APP_CONFIG__RUN__HOST, APP_PORT -> APP_CONFIG__RUN__PORT,
# DATABASE_URL_FILE -> APP_CONFIG__DB__* (host/port/name/user + password file),
# SESSION_TTL_SECONDS -> APP_CONFIG__JWT__SESSION_TTL_SECONDS, SESSION_STORE=postgres (sessions table).
APP_CONFIG__RUN__HOST=0.0.0.0
APP_CONFIG__RUN__PORT=8080
APP_CONFIG__LOGGING__LEVEL=INFO
# PostgreSQL. Values below are for running the API from the venv on the host;
# inside Compose the defaults (host=postgres, /run/secrets/postgres_password) are used.
APP_CONFIG__DB__HOST=127.0.0.1
APP_CONFIG__DB__PORT=5432
APP_CONFIG__DB__NAME=messenger
APP_CONFIG__DB__USER=messenger
# Path only, never the password itself. Relative paths are resolved from the project root.
APP_CONFIG__DB__PASSWORD_FILE=secrets/postgres_password
# Sessions: JWT signed with a key from a secret file + server-side session row in PostgreSQL.
APP_CONFIG__JWT__SECRET_FILE=secrets/jwt_secret
APP_CONFIG__JWT__SESSION_TTL_SECONDS=3600
# Used by compose.yaml: host port for PostgreSQL (bound to 127.0.0.1 only).
POSTGRES_HOST_PORT=5432
+2
View File
@@ -0,0 +1,2 @@
*.sh text eol=lf
*.cmd text eol=crlf
+3
View File
@@ -28,5 +28,8 @@ coverage/
.DS_Store
.idea/
.vscode/
.pytest_cache/
# Personal study notes, not part of the submission
report_help.md
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
+22
View File
@@ -0,0 +1,22 @@
FROM python:3.14.3-slim@sha256:5e59aae31ff0e87511226be8e2b94d78c58f05216efda3b07dbbed938ec8583b
ENV PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app/ .
RUN useradd --no-create-home --shell /usr/sbin/nologin appuser
USER appuser
EXPOSE 8080
# Liveness не зависит от БД; готовность (/health/ready) проверяют тесты и restart-скрипт.
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s \
CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live')"
CMD ["python", "main.py"]
+13 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
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-own migrate up down
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,15 @@ load:
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)
test-own:
$(PYTHON) -m pytest -v
migrate:
cd app && $(PYTHON) -m alembic upgrade head
up:
docker compose up -d --build --wait
down:
docker compose down
+50 -14
View File
@@ -1,37 +1,73 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Мякишев Владислав, БПИ2302
- Целевая оценка: 3
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Источники и библиотеки: FastAPI, SQLAlchemy 2.1 (ORM), Alembic, psycopg 3, argon2-cffi, PyJWT; документация PostgreSQL, Alembic, RFC 7617. При разработке использовался ИИ-ассистент (Claude).
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужно: Docker с Compose v2, Python 3.9+ (для тестов). Образы: `postgres:17.10-alpine`, `python:3.14.3-slim` (закреплены digest в `compose.yaml`/`Dockerfile`).
```sh
sh scripts/init-secrets.sh # Windows: powershell -File scripts\init-secrets.ps1
docker compose up -d --build --wait # postgres (healthy) -> migrate (exit 0) -> api (healthy)
make test # публичный smoke
chmod +x scripts/restart.sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
- `init-secrets` создаёт `secrets/postgres_password`, `secrets/jwt_secret` (случайные, не выводятся, вне Git) и `.env` из `.env.example`.
- Миграции применяет разовый сервис `migrate` (`alembic upgrade head`) при каждом `up`; повторный запуск ничего не меняет.
- Остановка без потери данных: `docker compose down`. Намеренное удаление учебных данных: `docker compose down -v`.
- Свои тесты (нужен запущенный `postgres`, используют отдельную базу `messenger_test`):
`python -m venv .venv && .venv/bin/pip install -r requirements-test.txt && .venv/bin/python -m pytest`
- На Windows тест сохранности: `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` (`restart.cmd` — те же команды, что `restart.sh`).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → API (FastAPI, `api`) → PostgreSQL 17 (`postgres`, volume `postgres_data`). PostgreSQL — источник истины для пользователей, чатов, участников, сообщений и сессий (`SESSION_STORE=postgres`).
| Роль | Сервис | Готовность | Хранилище | Порт | Credentials |
| --- | --- | --- | --- | --- | --- |
| база | `postgres` | `pg_isready` | volume `postgres_data` | 127.0.0.1:5432 | secret `postgres_password` |
| миграции | `migrate` | exit 0 | — | — | secret `postgres_password` |
| API | `api` | `/health/live` (Docker), `/health/ready` (проверяет БД) | нет | 127.0.0.1:8080 | secrets `postgres_password`, `jwt_secret` |
- **Схема** (миграция `0001`): `users` (UNIQUE username, CHECK формата), `sessions` (PK = SHA-256 токена, `expires_at`), `chats`, `chat_members` (PK `(chat_id, user_id)`), `messages` (составной FK `(chat_id, sender_id)` → `chat_members`, индекс `(chat_id, created_at, id)` для keyset-пагинации).
- **Транзакции:** создание чата — одна транзакция (чат + все участники); 201 возвращается только после COMMIT. Дубль username отсекается ограничением `users_username_key` → 409.
- **Аутентификация:** регистрация с паролем (Argon2id). `POST /auth/sessions` принимает только Basic и выдаёт JWT (HS256, `sub`/`iat`/`exp`/`jti`, `jti` — 256 бит случайности). На сервере хранится сессия (хеш токена + срок). Bearer проверяется по подписи, `exp` и наличию сессии в БД; logout удаляет сессию. `X-User-Id` не читается.
- **Из lab1 перенесено:** весь API, формат ошибок, `X-Request-Id`, cursor-пагинация, Dockerfile. **Изменено:** хранилище в памяти → PostgreSQL (`app/models`, `app/database_functions`), X-User-Id → Basic/Bearer, добавлены Compose и миграции.
- **Переменные** (`.env.example` курса → наши): `APP_HOST/APP_PORT` → `APP_CONFIG__RUN__HOST/PORT`; `DATABASE_URL_FILE` → `APP_CONFIG__DB__HOST/PORT/NAME/USER` + `APP_CONFIG__DB__PASSWORD_FILE`; `SESSION_TTL_SECONDS` → `APP_CONFIG__JWT__SESSION_TTL_SECONDS` (3600).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` против стенда в Compose | `PASS: lab2 public API scenario` | вывод команды |
| Данные и действующие сессии переживают рестарт API и БД без удаления volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (на Windows — `restart.cmd`) | `PASS: persistence preserved confirmed data and existing session`; у `api` и `postgres` новый StartedAt при тех же id контейнеров и том же volume | `evidence/persistence.txt` |
| Таблицы, PK/FK, UNIQUE username, миграции с нуля | `alembic downgrade base` → `alembic upgrade head`; `alembic check` | схема создаётся заново; `No new upgrade operations detected` | `app/migrations/versions/0001_initial_schema.py` |
| Повторные миграции без дублей | `docker compose up` при существующей схеме | `migrate` завершается с кодом 0 без `Running upgrade`, данные не меняются | `docker compose logs migrate` |
| Атомарное создание чата | `pytest student-tests/test_chats_api.py` | при неизвестном участнике — 400 и 0 строк в `chats`/`chat_members` | `student-tests/test_chats_api.py` |
| Basic только на входе, Bearer, expiry, logout, X-User-Id не работает | `pytest student-tests/test_auth_api.py` + smoke | 401 с корректным `WWW-Authenticate`; токен после logout и после TTL → 401 | `student-tests/test_auth_api.py` |
| Пароли — password KDF | `pytest student-tests/test_users_api.py` | в БД `$argon2id$…`, в ответах пароля нет | `student-tests/test_users_api.py` |
| Секреты/volumes вне Git | `git status --ignored` | `.env`, `secrets/` в игноре | `.gitignore` |
| Свои тесты | `python -m pytest` | `30 passed` | `student-tests/` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Проверка истечения на стенде: `APP_CONFIG__JWT__SESSION_TTL_SECONDS=2 docker compose up -d --wait api` → войти, подождать 3 с → запрос с токеном даёт 401. Вернуть: `docker compose up -d --wait api`.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `scripts/restart.sh`: stop + up API и PostgreSQL | данные и сессии сохраняются | test-persistence PASS, тот же токен работает | ~22 с на весь сценарий; потерь нет |
| `docker compose stop postgres` при работающем API | `/health/ready` → 503, бизнес-запросы → 503 без деталей | 503 через ~3 с (connect_timeout); после `start` — 200 без рестарта API (`pool_pre_ping`) | несколько секунд; потерь нет |
| SIGTERM API (`docker compose stop api`) | корректное завершение | `Shutting down` → `Соединения с базой данных закрыты` → `Finished server process` | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один экземпляр API и одна PostgreSQL без реплик и бэкапов: потеря volume = потеря данных.
- Токен — JWT: payload (UUID пользователя, время) читается клиентом, секретов в нём нет; отзыв обеспечивается серверной сессией.
- При одновременной записи курсор может пропустить сообщение, чьё `created_at` меньше уже выданного (окно — время между INSERT и COMMIT); повторное чтение с начала его показывает. Время назначает PostgreSQL.
- Истёкшие сессии из таблицы не удаляются автоматически (индекс по `expires_at` есть).
- Не сделано (уровень 4): Redis/Valkey, EXPLAIN на ≥10 000 сообщений, тест гонки регистрации.
+43
View File
@@ -0,0 +1,43 @@
# ASCII only: Alembic reads this file in the OS locale encoding.
# Database URL is built in env.py from app/core/config.py.
[alembic]
script_location = %(here)s/migrations
file_template = %%(rev)s_%%(slug)s
prepend_sys_path = .
path_separator = os
output_encoding = utf-8
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARNING
handlers = console
qualname =
[logger_sqlalchemy]
level = WARNING
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
+51
View File
@@ -0,0 +1,51 @@
from fastapi import Depends, HTTPException, Request, Security
from fastapi.security import HTTPBasic, HTTPBearer
from sqlalchemy.orm import Session
from core.db import get_db
from database_functions.sessions_functions import get_active_session
from models import AuthSession, User
from utils.security import decode_access_token, token_hash
BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'}
# Security-схемы нужны, чтобы в Swagger появилась кнопка Authorize.
# Заголовок разбираем сами: стандартный HTTPBasic понимает пароль только в ASCII.
class RawBasicHeader(HTTPBasic):
async def __call__(self, request: Request) -> str | None:
return request.headers.get("Authorization")
class RawBearerHeader(HTTPBearer):
async def __call__(self, request: Request) -> str | None:
return request.headers.get("Authorization")
basic_scheme = RawBasicHeader(scheme_name="basicAuth", auto_error=False)
bearer_scheme = RawBearerHeader(scheme_name="bearerAuth", auto_error=False)
def unauthorized() -> HTTPException:
return HTTPException(status_code=401, detail="Нужен действительный Bearer-токен", headers=BEARER_CHALLENGE)
def get_current_session(authorization: str | None = Security(bearer_scheme),
db: Session = Depends(get_db)) -> AuthSession:
scheme, _, token = (authorization or "").partition(" ")
if scheme.lower() != "bearer" or not token:
raise unauthorized()
# Подпись и exp проверяются без базы, отзыв (logout) — по таблице sessions.
payload = decode_access_token(token)
if payload is None:
raise unauthorized()
auth_session = get_active_session(db, token_hash(token))
if auth_session is None or str(auth_session.user_id) != payload["sub"]:
raise unauthorized()
return auth_session
def get_current_user(auth_session: AuthSession = Depends(get_current_session)) -> User:
return auth_session.user
+19
View File
@@ -0,0 +1,19 @@
from fastapi import APIRouter, HTTPException
from core.db import check_database
from schemas.health_schemas import HealthResponse
router = APIRouter(prefix="/health", tags=["health"])
@router.get("/live", response_model=HealthResponse)
def live_api():
return HealthResponse(status="ok")
# В отличие от live, ready зависит от PostgreSQL.
@router.get("/ready", response_model=HealthResponse)
def ready_api():
if not check_database():
raise HTTPException(status_code=503, detail="База данных недоступна")
return HealthResponse(status="ok")
+65
View File
@@ -0,0 +1,65 @@
import base64
import binascii
from fastapi import APIRouter, Depends, HTTPException, Response, Security
from sqlalchemy.orm import Session
from api.dependencies import basic_scheme, get_current_session
from core.config import settings
from core.db import get_db
from core.logger import logger
from database_functions.sessions_functions import create_session, delete_session
from database_functions.users_functions import get_user_by_username
from models import AuthSession
from schemas.auth_schemas import SessionResponse
from schemas.users_schemas import UserResponse
from utils.security import create_access_token, token_hash, verify_password
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.auth,
tags=["auth"],
)
BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
def invalid_credentials() -> HTTPException:
# Один ответ и для неизвестного username, и для неверного пароля.
return HTTPException(status_code=401, detail="Неверное имя пользователя или пароль", headers=BASIC_CHALLENGE)
def parse_basic(authorization: str | None) -> tuple[str, str]:
scheme, _, encoded = (authorization or "").partition(" ")
if scheme.lower() != "basic" or not encoded:
raise invalid_credentials()
try:
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
raise invalid_credentials()
# По первому двоеточию: в пароле двоеточие допустимо.
username, separator, password = decoded.partition(":")
if not separator:
raise invalid_credentials()
return username, password
@roter.post("/sessions", status_code=201, response_model=SessionResponse)
def create_session_api(authorization: str | None = Security(basic_scheme), db: Session = Depends(get_db)):
username, password = parse_basic(authorization)
user = get_user_by_username(db, username)
if not verify_password(user.password_hash if user else None, password):
logger.info("Неудачная попытка входа")
raise invalid_credentials()
token, issued_at, expires_at = create_access_token(user.id)
create_session(db, token_hash(token), user.id, created_at=issued_at, expires_at=expires_at)
logger.info(f"Вход выполнен: user_id={user.id}")
return SessionResponse(token=token, expires_at=expires_at, user=UserResponse.model_validate(user))
@roter.delete("/sessions/current", status_code=204)
def delete_session_api(auth_session: AuthSession = Depends(get_current_session), db: Session = Depends(get_db)):
delete_session(db, auth_session.token_hash)
logger.info(f"Выход выполнен: user_id={auth_session.user_id}")
return Response(status_code=204)
+54
View File
@@ -0,0 +1,54 @@
import uuid
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from api.dependencies import get_current_user
from core.config import settings
from core.db import get_db
from core.logger import logger
from database_functions.chats_functions import create_chat, get_member_chat, list_user_chats
from models import User
from schemas.chats_schemas import ChatPageResponse, ChatResponse, CreateChatRequest
from utils.pagination import read_cursor, split_page
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.chats,
tags=["chats"],
)
@roter.post("", status_code=201, response_model=ChatResponse)
def create_chat_api(request: CreateChatRequest, current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)):
if current_user.id not in request.member_ids:
raise HTTPException(status_code=400, detail="Создатель должен быть участником чата")
chat = create_chat(db, title=request.title, member_ids=request.member_ids)
if chat is None:
raise HTTPException(status_code=400, detail="Неизвестный участник")
logger.info(f"Чат создан: id={chat.id} участников={len(request.member_ids)}")
return ChatResponse.model_validate(chat)
@roter.get("", response_model=ChatPageResponse)
def list_chats_api(
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
scope = f"chats:{current_user.id}"
chats = list_user_chats(db, current_user.id, limit=limit, after=read_cursor(scope, cursor))
page, next_cursor = split_page(chats, limit, scope)
return ChatPageResponse(items=[ChatResponse.model_validate(chat) for chat in page], next_cursor=next_cursor)
@roter.get("/{chat_id}", response_model=ChatResponse)
def get_chat_api(chat_id: uuid.UUID, current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)):
chat = get_member_chat(db, chat_id, current_user.id)
if chat is None:
# Чужой чат неотличим от несуществующего.
raise HTTPException(status_code=404, detail="Чат не найден")
return ChatResponse.model_validate(chat)
+46
View File
@@ -0,0 +1,46 @@
import uuid
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy.orm import Session
from api.dependencies import get_current_user
from core.config import settings
from core.db import get_db
from database_functions.chats_functions import is_chat_member
from database_functions.messages_functions import create_message, list_messages
from models import User
from schemas.messages_schemas import CreateMessageRequest, MessagePageResponse, MessageResponse
from utils.pagination import read_cursor, split_page
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.chats,
tags=["messages"],
)
def ensure_member(db: Session, chat_id: uuid.UUID, user: User):
if not is_chat_member(db, chat_id, user.id):
raise HTTPException(status_code=404, detail="Чат не найден")
@roter.post("/{chat_id}/messages", status_code=201, response_model=MessageResponse)
def create_message_api(chat_id: uuid.UUID, request: CreateMessageRequest,
current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
ensure_member(db, chat_id, current_user)
message = create_message(db, chat_id=chat_id, sender_id=current_user.id, text=request.text)
return MessageResponse.model_validate(message)
@roter.get("/{chat_id}/messages", response_model=MessagePageResponse)
def list_messages_api(
chat_id: uuid.UUID,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None, min_length=1),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db),
):
ensure_member(db, chat_id, current_user)
scope = f"chat:{chat_id}"
messages = list_messages(db, chat_id, limit=limit, after=read_cursor(scope, cursor))
page, next_cursor = split_page(messages, limit, scope)
return MessagePageResponse(items=[MessageResponse.model_validate(m) for m in page], next_cursor=next_cursor)
+31
View File
@@ -0,0 +1,31 @@
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from api.dependencies import get_current_user
from core.config import settings
from core.db import get_db
from core.logger import logger
from database_functions.users_functions import create_user
from models import User
from schemas.users_schemas import CreateUserRequest, UserResponse
from utils.security import hash_password
roter = APIRouter(
prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.users,
tags=["users"],
)
@roter.post("", status_code=201, response_model=UserResponse)
def register_user_api(request: CreateUserRequest, db: Session = Depends(get_db)):
user = create_user(db, username=request.username, display_name=request.display_name,
password_hash=hash_password(request.password))
if user is None:
raise HTTPException(status_code=409, detail="Username уже занят")
logger.info(f"Пользователь создан: id={user.id}")
return UserResponse.model_validate(user)
@roter.get("/me", response_model=UserResponse)
def get_me_api(current_user: User = Depends(get_current_user)):
return UserResponse.model_validate(current_user)
+86
View File
@@ -0,0 +1,86 @@
from pathlib import Path
from typing import Literal
from pydantic import BaseModel
from pydantic_settings import BaseSettings, SettingsConfigDict
# Корень проекта (в контейнере код лежит в /app, и это будет "/").
BASE_DIR = Path(__file__).resolve().parents[2]
class RunConfig(BaseModel):
host: str = "0.0.0.0"
port: int = 8080
graceful_timeout: int = 5
class LoggingConfig(BaseModel):
level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
format: str = "[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s"
datefmt: str = "%Y-%m-%d %H:%M:%S"
class DatabaseConfig(BaseModel):
# Значения по умолчанию — для запуска внутри Compose.
host: str = "postgres"
port: int = 5432
name: str = "messenger"
user: str = "messenger"
password_file: Path = Path("/run/secrets/postgres_password")
pool_size: int = 5
max_overflow: int = 5
pool_timeout: int = 5
connect_timeout: int = 3
statement_timeout_ms: int = 5000
echo: bool = False
def read_password(self) -> str:
return read_secret(self.password_file)
class JWTConfig(BaseModel):
# Ключ должен сохраняться между перезапусками, иначе выданные токены станут недействительны.
secret_file: Path = Path("/run/secrets/jwt_secret")
algorithm: str = "HS256"
session_ttl_seconds: int = 3600
def read_secret_key(self) -> str:
return read_secret(self.secret_file)
def read_secret(path: Path) -> str:
"""Прочитать файл-секрет. Относительный путь считается от корня проекта."""
full_path = path if path.is_absolute() else BASE_DIR / path
return full_path.read_text(encoding="utf-8").strip()
class ApiV1Prefix(BaseModel):
prefix: str = "/v1"
users: str = "/users"
chats: str = "/chats"
auth: str = "/auth"
class ApiPrefix(BaseModel):
prefix: str = "/api"
v1: ApiV1Prefix = ApiV1Prefix()
class Settings(BaseSettings):
model_config = SettingsConfigDict(
env_file=BASE_DIR / ".env",
case_sensitive=False,
env_nested_delimiter="__",
env_prefix="APP_CONFIG__",
extra="ignore",
)
run: RunConfig = RunConfig()
api: ApiPrefix = ApiPrefix()
logging: LoggingConfig = LoggingConfig()
db: DatabaseConfig = DatabaseConfig()
jwt: JWTConfig = JWTConfig()
settings = Settings()
+57
View File
@@ -0,0 +1,57 @@
from collections.abc import Iterator
from sqlalchemy import URL, create_engine, text
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session, sessionmaker
from core.config import settings
from core.logger import logger
def build_url() -> URL:
return URL.create(
drivername="postgresql+psycopg",
username=settings.db.user,
password=settings.db.read_password(),
host=settings.db.host,
port=settings.db.port,
database=settings.db.name,
)
engine = create_engine(
build_url(),
pool_size=settings.db.pool_size,
max_overflow=settings.db.max_overflow,
pool_timeout=settings.db.pool_timeout,
# Проверять соединение перед выдачей из пула (нужно после рестарта PostgreSQL).
pool_pre_ping=True,
connect_args={
"connect_timeout": settings.db.connect_timeout,
"options": f"-c statement_timeout={settings.db.statement_timeout_ms}",
},
echo=settings.db.echo,
)
SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
def get_db() -> Iterator[Session]:
"""Одна ORM-сессия на HTTP-запрос."""
with SessionLocal() as session:
yield session
def check_database() -> bool:
try:
with engine.connect() as connection:
connection.execute(text("SELECT 1"))
return True
except SQLAlchemyError as exc:
# Только тип ошибки: в тексте может оказаться адрес БД.
logger.warning(f"PostgreSQL недоступен: {type(exc).__name__}")
return False
def log_database_target():
logger.info(f"База данных: {engine.url.render_as_string(hide_password=True)}")
+15
View File
@@ -0,0 +1,15 @@
import logging
from core.config import settings
def setup_logger():
logging.basicConfig(
level=settings.logging.level,
format=settings.logging.format,
datefmt=settings.logging.datefmt,
)
return logging.getLogger("messenger")
logger = setup_logger()
+50
View File
@@ -0,0 +1,50 @@
import uuid
from sqlalchemy import func, select, tuple_
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from models import Chat, ChatMember, User
from utils.pagination import Position
def create_chat(db: Session, title: str, member_ids: list[uuid.UUID]) -> Chat | None:
"""Чат и участники — одна транзакция. None — есть несуществующий участник."""
found = db.scalar(select(func.count()).select_from(User).where(User.id.in_(member_ids)))
if found != len(member_ids):
return None
chat = Chat(title=title, members=[ChatMember(user_id=user_id) for user_id in sorted(member_ids)])
db.add(chat)
try:
db.commit()
except IntegrityError:
db.rollback()
return None
return chat
def is_chat_member(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> bool:
return db.get(ChatMember, (chat_id, user_id)) is not None
def get_member_chat(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> Chat | None:
query = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
return db.scalar(query)
def list_user_chats(db: Session, user_id: uuid.UUID, limit: int, after: Position | None) -> list[Chat]:
query = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
.order_by(Chat.created_at, Chat.id)
.limit(limit + 1)
)
if after is not None:
query = query.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after))
return list(db.scalars(query))
@@ -0,0 +1,27 @@
import uuid
from sqlalchemy import select, tuple_
from sqlalchemy.orm import Session
from models import Message
from utils.pagination import Position
def create_message(db: Session, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str) -> Message:
message = Message(chat_id=chat_id, sender_id=sender_id, text=text)
db.add(message)
db.commit()
return message
def list_messages(db: Session, chat_id: uuid.UUID, limit: int, after: Position | None) -> list[Message]:
# Keyset-пагинация по индексу messages_chat_history_idx (chat_id, created_at, id).
query = (
select(Message)
.where(Message.chat_id == chat_id)
.order_by(Message.created_at, Message.id)
.limit(limit + 1)
)
if after is not None:
query = query.where(tuple_(Message.created_at, Message.id) > tuple_(*after))
return list(db.scalars(query))
@@ -0,0 +1,29 @@
import uuid
from datetime import datetime
from sqlalchemy import delete, func, select
from sqlalchemy.orm import Session
from models import AuthSession
def create_session(db: Session, token_hash: bytes, user_id: uuid.UUID,
created_at: datetime, expires_at: datetime) -> AuthSession:
auth_session = AuthSession(token_hash=token_hash, user_id=user_id, created_at=created_at, expires_at=expires_at)
db.add(auth_session)
db.commit()
return auth_session
def get_active_session(db: Session, token_hash: bytes) -> AuthSession | None:
query = select(AuthSession).where(
AuthSession.token_hash == token_hash,
AuthSession.expires_at > func.now(),
)
return db.scalar(query)
def delete_session(db: Session, token_hash: bytes) -> bool:
result = db.execute(delete(AuthSession).where(AuthSession.token_hash == token_hash))
db.commit()
return result.rowcount > 0
+30
View File
@@ -0,0 +1,30 @@
import uuid
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session
from models import User
def create_user(db: Session, username: str, display_name: str, password_hash: str) -> User | None:
"""None — username уже занят."""
user = User(username=username, display_name=display_name, password_hash=password_hash)
db.add(user)
try:
db.commit()
except IntegrityError as exc:
db.rollback()
# Уникальность проверяет сама БД, поэтому гонка регистрации невозможна.
if exc.orig.diag.constraint_name == "users_username_key":
return None
raise
return user
def get_user(db: Session, user_id: uuid.UUID) -> User | None:
return db.get(User, user_id)
def get_user_by_username(db: Session, username: str) -> User | None:
return db.scalar(select(User).where(User.username == username))
+48
View File
@@ -0,0 +1,48 @@
from contextlib import asynccontextmanager
import uvicorn
from fastapi import FastAPI
from starlette.middleware.base import BaseHTTPMiddleware
from api.health import router as health_router
from api.v1.auth_rout import roter as auth_router
from api.v1.chats_rout import roter as chats_router
from api.v1.messages_rout import roter as messages_router
from api.v1.users_rout import roter as users_router
from core.config import settings
from core.db import engine, log_database_target
from core.logger import logger
from utils.errors import register_error_handlers
from utils.middleware import request_id_middleware
@asynccontextmanager
async def lifespan(app: FastAPI):
log_database_target()
yield
# Остановка (в том числе по SIGTERM): закрываем соединения пула.
engine.dispose()
logger.info("Соединения с базой данных закрыты")
app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan)
app.add_middleware(BaseHTTPMiddleware, dispatch=request_id_middleware)
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__":
logger.info(f"Запуск сервера на {settings.run.host}:{settings.run.port}")
uvicorn.run(
"main:app",
host=settings.run.host,
port=settings.run.port,
timeout_graceful_shutdown=settings.run.graceful_timeout,
access_log=False, # запросы логирует наш middleware
)
+52
View File
@@ -0,0 +1,52 @@
from logging.config import fileConfig
from alembic import context
from sqlalchemy import create_engine, pool, text
from core.config import settings
from core.db import build_url
from models import Base
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
# Ключ advisory lock: параллельные запуски миграций выполнятся по очереди.
MIGRATION_LOCK_KEY = 2_026_002
def run_migrations_offline() -> None:
context.configure(
url=build_url(),
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def run_migrations_online() -> None:
engine = create_engine(
build_url(),
poolclass=pool.NullPool,
connect_args={"connect_timeout": settings.db.connect_timeout},
)
with engine.connect() as connection:
context.configure(
connection=connection,
target_metadata=target_metadata,
compare_server_default=True,
)
with context.begin_transaction():
connection.execute(text("SELECT pg_advisory_xact_lock(:key)"), {"key": MIGRATION_LOCK_KEY})
context.run_migrations()
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+28
View File
@@ -0,0 +1,28 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
# revision identifiers, used by Alembic.
revision: str = ${repr(up_revision)}
down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
"""Upgrade schema."""
${upgrades if upgrades else "pass"}
def downgrade() -> None:
"""Downgrade schema."""
${downgrades if downgrades else "pass"}
@@ -0,0 +1,85 @@
"""initial schema
Revision ID: 0001
Revises:
Create Date: 2026-10-15 17:30:37.825446
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision: str = '0001'
down_revision: Union[str, Sequence[str], None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
"""Upgrade schema."""
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('chats',
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('title', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.CheckConstraint('char_length(title) BETWEEN 1 AND 100', name=op.f('chats_title_len')),
sa.PrimaryKeyConstraint('id', name=op.f('chats_pkey'))
)
op.create_table('users',
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('username', sa.Text(), nullable=False),
sa.Column('display_name', sa.Text(), nullable=False),
sa.Column('password_hash', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name=op.f('users_username_format')),
sa.CheckConstraint('char_length(display_name) BETWEEN 1 AND 100', name=op.f('users_display_name_len')),
sa.PrimaryKeyConstraint('id', name=op.f('users_pkey')),
sa.UniqueConstraint('username', name=op.f('users_username_key'))
)
op.create_table('chat_members',
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('user_id', sa.Uuid(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], name=op.f('chat_members_chat_id_fkey')),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('chat_members_user_id_fkey')),
sa.PrimaryKeyConstraint('chat_id', 'user_id', name=op.f('chat_members_pkey'))
)
op.create_index(op.f('chat_members_user_id_chat_id_idx'), 'chat_members', ['user_id', 'chat_id'], unique=False)
op.create_table('sessions',
sa.Column('token_hash', sa.LargeBinary(), nullable=False),
sa.Column('user_id', sa.Uuid(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
sa.CheckConstraint('expires_at > created_at', name=op.f('sessions_expiry_after_creation')),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('sessions_user_id_fkey'), ondelete='CASCADE'),
sa.PrimaryKeyConstraint('token_hash', name=op.f('sessions_pkey'))
)
op.create_index(op.f('sessions_expires_at_idx'), 'sessions', ['expires_at'], unique=False)
op.create_table('messages',
sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('sender_id', sa.Uuid(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False),
sa.Column('text', sa.Text(), nullable=False),
sa.CheckConstraint('char_length(text) BETWEEN 1 AND 4000', name=op.f('messages_text_len')),
sa.ForeignKeyConstraint(['chat_id', 'sender_id'], ['chat_members.chat_id', 'chat_members.user_id'], name='messages_sender_is_member'),
sa.PrimaryKeyConstraint('id', name=op.f('messages_pkey'))
)
op.create_index('messages_chat_history_idx', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
# ### end Alembic commands ###
def downgrade() -> None:
"""Downgrade schema."""
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index('messages_chat_history_idx', table_name='messages')
op.drop_table('messages')
op.drop_index(op.f('sessions_expires_at_idx'), table_name='sessions')
op.drop_table('sessions')
op.drop_index(op.f('chat_members_user_id_chat_id_idx'), table_name='chat_members')
op.drop_table('chat_members')
op.drop_table('users')
op.drop_table('chats')
# ### end Alembic commands ###
+8
View File
@@ -0,0 +1,8 @@
# Все модели импортируются здесь, чтобы Base.metadata (и Alembic) видел все таблицы.
from models.base import Base
from models.chats_models import Chat, ChatMember
from models.messages_models import Message
from models.sessions_models import AuthSession
from models.users_models import User
__all__ = ["Base", "User", "AuthSession", "Chat", "ChatMember", "Message"]
+15
View File
@@ -0,0 +1,15 @@
from sqlalchemy import MetaData
from sqlalchemy.orm import DeclarativeBase
# Предсказуемые имена ограничений: по ним разбираем ошибки БД (users_username_key -> 409).
NAMING_CONVENTION = {
"pk": "%(table_name)s_pkey",
"uq": "%(table_name)s_%(column_0_name)s_key",
"ck": "%(table_name)s_%(constraint_name)s",
"fk": "%(table_name)s_%(column_0_name)s_fkey",
"ix": "%(table_name)s_%(column_0_N_name)s_idx",
}
class Base(DeclarativeBase):
metadata = MetaData(naming_convention=NAMING_CONVENTION)
+35
View File
@@ -0,0 +1,35 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, Text, Uuid, text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from models.base import Base
class Chat(Base):
__tablename__ = "chats"
__table_args__ = (
CheckConstraint("char_length(title) BETWEEN 1 AND 100", name="title_len"),
)
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=text("gen_random_uuid()"))
title: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
# selectin: участники всех чатов страницы грузятся одним запросом (без N+1).
members: Mapped[list["ChatMember"]] = relationship(lazy="selectin", order_by="ChatMember.user_id")
@property
def member_ids(self) -> list[uuid.UUID]:
return [member.user_id for member in self.members]
class ChatMember(Base):
__tablename__ = "chat_members"
__table_args__ = (
Index(None, "user_id", "chat_id"), # для «моих чатов»
)
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), primary_key=True)
user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), primary_key=True)
+30
View File
@@ -0,0 +1,30 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, ForeignKeyConstraint, Index, Text, Uuid
# Псевдоним: столбец `text` ниже перекрыл бы функцию text().
from sqlalchemy import text as sql_text
from sqlalchemy.orm import Mapped, mapped_column
from models.base import Base
class Message(Base):
__tablename__ = "messages"
__table_args__ = (
CheckConstraint("char_length(text) BETWEEN 1 AND 4000", name="text_len"),
# Отправитель обязан быть участником чата.
ForeignKeyConstraint(
["chat_id", "sender_id"],
["chat_members.chat_id", "chat_members.user_id"],
name="messages_sender_is_member",
),
Index("messages_chat_history_idx", "chat_id", "created_at", "id"),
)
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=sql_text("gen_random_uuid()"))
chat_id: Mapped[uuid.UUID] = mapped_column(Uuid)
sender_id: Mapped[uuid.UUID] = mapped_column(Uuid)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=sql_text("clock_timestamp()"))
text: Mapped[str] = mapped_column(Text)
+25
View File
@@ -0,0 +1,25 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, LargeBinary, Uuid, text
from sqlalchemy.orm import Mapped, mapped_column, relationship
from models.base import Base
from models.users_models import User
class AuthSession(Base):
"""Сессия входа (не путать с ORM-сессией SQLAlchemy)."""
__tablename__ = "sessions"
__table_args__ = (
CheckConstraint("expires_at > created_at", name="expiry_after_creation"),
Index(None, "expires_at"),
)
# SHA-256 от токена, сам токен не храним.
token_hash: Mapped[bytes] = mapped_column(LargeBinary, primary_key=True)
user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id", ondelete="CASCADE"))
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
user: Mapped[User] = relationship(lazy="joined")
+21
View File
@@ -0,0 +1,21 @@
import uuid
from datetime import datetime
from sqlalchemy import CheckConstraint, DateTime, Text, Uuid, text
from sqlalchemy.orm import Mapped, mapped_column
from models.base import Base
class User(Base):
__tablename__ = "users"
__table_args__ = (
CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name="username_format"),
CheckConstraint("char_length(display_name) BETWEEN 1 AND 100", name="display_name_len"),
)
id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=text("gen_random_uuid()"))
username: Mapped[str] = mapped_column(Text, unique=True)
display_name: Mapped[str] = mapped_column(Text)
password_hash: Mapped[str] = mapped_column(Text)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()"))
+13
View File
@@ -0,0 +1,13 @@
from typing import Literal
from pydantic import BaseModel
from schemas.users_schemas import UserResponse
from utils.dates import UtcDatetime
class SessionResponse(BaseModel):
token: str
token_type: Literal["Bearer"] = "Bearer"
expires_at: UtcDatetime
user: UserResponse
+38
View File
@@ -0,0 +1,38 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
from utils.dates import UtcDatetime
class CreateChatRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
title: StrictStr = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
@field_validator("title")
def validate_title(cls, v):
if not v.strip():
raise ValueError("title must not be blank")
return v
@field_validator("member_ids")
def validate_member_ids(cls, v):
if len(set(v)) != len(v):
raise ValueError("member_ids must be unique")
return v
class ChatResponse(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: UUID
title: str
member_ids: list[UUID]
created_at: UtcDatetime
class ChatPageResponse(BaseModel):
items: list[ChatResponse]
next_cursor: str | None
+11
View File
@@ -0,0 +1,11 @@
from pydantic import BaseModel
class ErrorBody(BaseModel):
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
error: ErrorBody
+7
View File
@@ -0,0 +1,7 @@
from typing import Literal
from pydantic import BaseModel
class HealthResponse(BaseModel):
status: Literal["ok"]
+33
View File
@@ -0,0 +1,33 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
from utils.dates import UtcDatetime
class CreateMessageRequest(BaseModel):
# extra="forbid": клиент не может прислать sender_id.
model_config = ConfigDict(extra="forbid")
text: StrictStr = Field(min_length=1, max_length=4000)
@field_validator("text")
def validate_text(cls, v):
if not v.strip():
raise ValueError("text must not be blank")
return v
class MessageResponse(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: UtcDatetime
class MessagePageResponse(BaseModel):
items: list[MessageResponse]
next_cursor: str | None
+29
View File
@@ -0,0 +1,29 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
from utils.dates import UtcDatetime
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
username: StrictStr = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: StrictStr = Field(min_length=1, max_length=100)
password: StrictStr = Field(min_length=12, max_length=128)
@field_validator("display_name")
def validate_display_name(cls, v):
if not v.strip():
raise ValueError("display_name must not be blank")
return v
class UserResponse(BaseModel):
# Собирается из ORM-объекта; password_hash сюда не попадает.
model_config = ConfigDict(from_attributes=True)
id: UUID
username: str
display_name: str
created_at: UtcDatetime
+18
View File
@@ -0,0 +1,18 @@
from datetime import datetime, timezone
from typing import Annotated
from pydantic import PlainSerializer
TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
def format_utc(value: datetime) -> str:
return value.astimezone(timezone.utc).strftime(TIME_FORMAT)
def parse_utc(value: str) -> datetime:
return datetime.strptime(value, TIME_FORMAT).replace(tzinfo=timezone.utc)
# datetime, который в JSON превращается в строку вида 2026-09-01T12:00:00.123456Z.
UtcDatetime = Annotated[datetime, PlainSerializer(format_utc, return_type=str)]
+50
View File
@@ -0,0 +1,50 @@
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from sqlalchemy.exc import OperationalError
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
from starlette.exceptions import HTTPException
from core.logger import logger
from schemas.error_schemas import ErrorBody, ErrorResponse
ERROR_CODES = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
500: "internal_error",
503: "unavailable",
}
def error_response(request: Request, status_code: int, message: str,
headers: dict[str, str] | None = None) -> JSONResponse:
code = ERROR_CODES.get(status_code, "internal_error" if status_code >= 500 else "invalid_request")
body = ErrorResponse(error=ErrorBody(code=code, message=message, request_id=request.state.request_id))
return JSONResponse(status_code=status_code, content=body.model_dump(), headers=headers)
def http_error_handler(request: Request, exc: HTTPException) -> JSONResponse:
message = exc.detail if isinstance(exc.detail, str) and exc.detail else "Ошибка запроса"
return error_response(request, exc.status_code, message, headers=exc.headers)
def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
return error_response(request, 400, "Неверный запрос")
# БД недоступна, statement_timeout или пул исчерпан -> 503 без подробностей.
def database_error_handler(request: Request, exc: Exception) -> JSONResponse:
logger.warning(f"Ошибка базы данных: {type(exc).__name__} request_id={request.state.request_id}")
return error_response(request, 503, "База данных недоступна")
def register_error_handlers(app: FastAPI):
app.add_exception_handler(HTTPException, http_error_handler)
app.add_exception_handler(RequestValidationError, validation_error_handler)
app.add_exception_handler(OperationalError, database_error_handler)
app.add_exception_handler(PoolTimeoutError, database_error_handler)
+27
View File
@@ -0,0 +1,27 @@
import time
import uuid
from fastapi import Request
from core.logger import logger
from utils.errors import error_response
async def request_id_middleware(request: Request, call_next):
request.state.request_id = str(uuid.uuid4())
start = time.monotonic()
try:
response = await call_next(request)
except Exception:
# Подробности пишем только в лог сервера, клиенту — общий текст.
logger.exception(f"Непредвиденная ошибка request_id={request.state.request_id}")
response = error_response(request, 500, "Внутренняя ошибка сервера")
response.headers["X-Request-Id"] = request.state.request_id
# Тело запроса не логируем, чтобы текст сообщений не попадал в логи.
duration_ms = (time.monotonic() - start) * 1000
logger.info(f"{request.method} {request.url.path} {response.status_code} "
f"{duration_ms:.1f}ms request_id={request.state.request_id}")
return response
+35
View File
@@ -0,0 +1,35 @@
import base64
import json
import uuid
from datetime import datetime
from fastapi import HTTPException
from utils.dates import format_utc, parse_utc
# Позиция в списке: (created_at, id) последнего выданного элемента.
Position = tuple[datetime, uuid.UUID]
def make_cursor(scope: str, created_at: datetime, item_id: uuid.UUID) -> str:
data = json.dumps({"scope": scope, "created_at": format_utc(created_at), "id": str(item_id)})
return base64.urlsafe_b64encode(data.encode()).decode()
def read_cursor(scope: str, cursor: str | None) -> Position | None:
if cursor is None:
return None
try:
data = json.loads(base64.urlsafe_b64decode(cursor.encode()))
if data["scope"] != scope:
raise ValueError("cursor from another resource")
return parse_utc(data["created_at"]), uuid.UUID(data["id"])
except Exception:
raise HTTPException(status_code=400, detail="Неверный cursor")
def split_page(rows: list, limit: int, scope: str) -> tuple[list, str | None]:
"""rows получены с LIMIT limit + 1: лишняя строка значит, что есть следующая страница."""
page = rows[:limit]
next_cursor = make_cursor(scope, page[-1].created_at, page[-1].id) if len(rows) > limit else None
return page, next_cursor
+63
View File
@@ -0,0 +1,63 @@
import hashlib
import secrets
import uuid
from datetime import datetime, timedelta, timezone
import jwt
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from core.config import settings
password_hasher = PasswordHasher() # Argon2id
# Проверяется, когда пользователя нет: время ответа такое же, как при неверном пароле.
DUMMY_PASSWORD_HASH = password_hasher.hash(secrets.token_urlsafe(16))
def hash_password(password: str) -> str:
return password_hasher.hash(password)
def verify_password(password_hash: str | None, password: str) -> bool:
try:
password_hasher.verify(password_hash or DUMMY_PASSWORD_HASH, password)
return password_hash is not None
except (VerificationError, InvalidHashError):
return False
JWT_SECRET_KEY = settings.jwt.read_secret_key()
def create_access_token(user_id: uuid.UUID) -> tuple[str, datetime, datetime]:
"""Возвращает (токен, время выдачи, время истечения)."""
# Целые секунды, чтобы expires_at совпадал с exp в токене.
issued_at = datetime.now(timezone.utc).replace(microsecond=0)
expires_at = issued_at + timedelta(seconds=settings.jwt.session_ttl_seconds)
payload = {
"sub": str(user_id),
"iat": issued_at,
"exp": expires_at,
"jti": secrets.token_urlsafe(32), # 256 бит случайности, токен всегда уникален
}
token = jwt.encode(payload, JWT_SECRET_KEY, algorithm=settings.jwt.algorithm)
return token, issued_at, expires_at
def decode_access_token(token: str) -> dict | None:
"""None — подпись неверна, токен испорчен или истёк."""
try:
return jwt.decode(
token,
JWT_SECRET_KEY,
algorithms=[settings.jwt.algorithm], # явно, чтобы не принять alg=none
options={"require": ["sub", "exp", "iat", "jti"]},
)
except jwt.InvalidTokenError:
return None
def token_hash(token: str) -> bytes:
# В БД хранится только хеш токена.
return hashlib.sha256(token.encode()).digest()
+74
View File
@@ -0,0 +1,74 @@
# docker compose up -d --build --wait — запуск
# docker compose down — остановка (данные остаются в volume)
# docker compose down -v — удалить данные намеренно
name: mtusi-lab2
services:
postgres:
image: postgres:17.10-alpine@sha256:979c4379dd698aba0b890599a6104e082035f98ef31d9b9291ec22f2b13059ca
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- postgres_data:/var/lib/postgresql/data
ports:
- "127.0.0.1:${POSTGRES_HOST_PORT:-5432}:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
start_period: 10s
restart: unless-stopped
# Разовая задача: применить миграции и завершиться с кодом 0.
migrate:
build: .
image: mtusi-messenger:lab2
command: ["python", "-m", "alembic", "upgrade", "head"]
environment: &app-env
APP_CONFIG__DB__HOST: postgres
APP_CONFIG__DB__PORT: "5432"
APP_CONFIG__DB__NAME: messenger
APP_CONFIG__DB__USER: messenger
APP_CONFIG__DB__PASSWORD_FILE: /run/secrets/postgres_password
APP_CONFIG__JWT__SECRET_FILE: /run/secrets/jwt_secret
APP_CONFIG__JWT__SESSION_TTL_SECONDS: ${APP_CONFIG__JWT__SESSION_TTL_SECONDS:-3600}
APP_CONFIG__LOGGING__LEVEL: ${APP_CONFIG__LOGGING__LEVEL:-INFO}
secrets:
- postgres_password
- jwt_secret
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
build: .
image: mtusi-messenger:lab2
# Без env_file: в .env адреса для запуска из venv, а не из контейнера.
environment: *app-env
secrets:
- postgres_password
- jwt_secret
depends_on:
postgres:
condition: service_healthy
migrate:
condition: service_completed_successfully
ports:
- "127.0.0.1:8080:8080"
stop_grace_period: 10s
restart: unless-stopped
volumes:
postgres_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
jwt_secret:
file: ./secrets/jwt_secret
+20
View File
@@ -0,0 +1,20 @@
# test-persistence (Windows: scripts\restart.cmd = same commands as scripts/restart.sh)
date: 2026-10-16T10:05:33
## containers BEFORE
/mtusi-lab2-api-1 id=4dcf421abd1d started=2026-10-16T07:04:52.820712243Z status=running
/mtusi-lab2-postgres-1 id=64cc9db56db3 started=2026-10-16T07:04:41.833181321Z status=running
## test output (exit 0, 22.3s)
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
## containers AFTER (new StartedAt = really restarted)
/mtusi-lab2-api-1 id=4dcf421abd1d started=2026-10-16T07:05:25.634228444Z status=running
/mtusi-lab2-postgres-1 id=64cc9db56db3 started=2026-10-16T07:05:15.448515673Z status=running
## volume (same, not recreated)
mtusi-lab2_postgres_data created=2026-10-15T14:23:31Z
## rows in PostgreSQL after restart
users=15 chats=5 messages=9 active_sessions=8
+5
View File
@@ -0,0 +1,5 @@
[pytest]
testpaths = student-tests
pythonpath = app
filterwarnings =
ignore:Using .httpx. with .starlette.testclient. is deprecated
+3
View File
@@ -0,0 +1,3 @@
-r requirements.txt
pytest==9.1.1
httpx==0.28.1
+26
View File
@@ -0,0 +1,26 @@
fastapi==0.141.1
starlette==1.7.0
pydantic==2.13.5
pydantic_core==2.46.5
pydantic-settings==2.15.0
python-dotenv==1.2.3
uvicorn==0.54.0
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
click==8.5.0
h11==0.16.0
idna==3.20
typing-inspection==0.4.4
typing_extensions==4.16.0
SQLAlchemy==2.1.4
psycopg==3.3.6
psycopg-binary==3.3.6
alembic==1.20.0
Mako==1.4.3
MarkupSafe==3.0.4
argon2-cffi==25.1.0
argon2-cffi-bindings==26.1.0
cffi==2.1.1
pycparser==3.11
PyJWT==2.15.1
+19
View File
@@ -0,0 +1,19 @@
# Windows twin of scripts/init-secrets.sh. Existing files are kept.
$ErrorActionPreference = 'Stop'
Set-Location (Join-Path $PSScriptRoot '..')
New-Item -ItemType Directory -Force secrets | Out-Null
function New-Secret($name, $bytes) {
$path = Join-Path 'secrets' $name
if ((Test-Path $path) -and (Get-Item $path).Length -gt 0) { "kept secrets/$name"; return }
$buffer = New-Object byte[] $bytes
[Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($buffer)
$value = [Convert]::ToBase64String($buffer) -replace '[+/=]', ''
# ASCII, no BOM, no trailing newline.
[IO.File]::WriteAllText((Join-Path (Get-Location) $path), $value, [Text.Encoding]::ASCII)
"created secrets/$name"
}
New-Secret 'postgres_password' 32
New-Secret 'jwt_secret' 64
if (-not (Test-Path .env)) { Copy-Item .env.example .env; 'created .env' }
+18
View File
@@ -0,0 +1,18 @@
#!/bin/sh
# Создать локальные секреты после clone. Существующие файлы не перезаписываются.
set -eu
cd "$(dirname "$0")/.."
mkdir -p secrets
make_secret() {
if [ ! -s "secrets/$1" ]; then
head -c "$2" /dev/urandom | base64 | tr -d '\n+/=' > "secrets/$1"
echo "created secrets/$1"
else
echo "kept secrets/$1"
fi
}
make_secret postgres_password 32
make_secret jwt_secret 64
[ -f .env ] || { cp .env.example .env; echo "created .env"; }
+8
View File
@@ -0,0 +1,8 @@
@echo off
rem Windows twin of scripts/restart.sh: the test cannot execute .sh on Windows.
setlocal
cd /d "%~dp0.."
docker compose stop api postgres || exit /b 1
docker compose up -d --wait || exit /b 1
docker compose ps --format "{{.Name}} {{.Status}}"
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
# Hook для make test-persistence: перезапуск API и PostgreSQL с сохранением volumes.
set -eu
cd "$(dirname "$0")/.."
docker compose stop api postgres
# Порядок: postgres (healthy) -> migrate (exit 0) -> api (healthy).
docker compose up -d --wait
docker compose ps --format '{{.Name}} {{.Status}}'
+102
View File
@@ -0,0 +1,102 @@
import base64
import os
from pathlib import Path
# Отдельная тестовая база; задаётся до импорта приложения (настройки читаются при импорте).
TEST_DB_NAME = "messenger_test"
os.environ["APP_CONFIG__DB__NAME"] = TEST_DB_NAME
import pytest
from alembic import command
from alembic.config import Config
from fastapi.testclient import TestClient
from sqlalchemy import create_engine, text
from core.db import build_url, engine
from main import app
APP_DIR = Path(__file__).resolve().parents[1] / "app"
PASSWORD = "Test-password-123"
@pytest.fixture(scope="session", autouse=True)
def test_database():
# CREATE DATABASE нельзя выполнить в транзакции, поэтому AUTOCOMMIT.
admin = create_engine(build_url().set(database="postgres"), isolation_level="AUTOCOMMIT")
with admin.connect() as connection:
exists = connection.scalar(text("SELECT 1 FROM pg_database WHERE datname = :name"), {"name": TEST_DB_NAME})
if not exists:
connection.execute(text(f'CREATE DATABASE "{TEST_DB_NAME}"'))
admin.dispose()
command.upgrade(Config(str(APP_DIR / "alembic.ini")), "head")
yield
engine.dispose()
@pytest.fixture(autouse=True)
def clean_database():
with engine.begin() as connection:
connection.execute(text("TRUNCATE users, sessions, chats, chat_members, messages"))
@pytest.fixture
def client():
return TestClient(app)
def basic(username, password):
credential = base64.b64encode(f"{username}:{password}".encode()).decode()
return {"Authorization": "Basic " + credential}
def login(client, username, password=PASSWORD):
response = client.post("/api/v1/auth/sessions", headers=basic(username, password))
assert response.status_code == 201
return response.json()
def bearer(token):
return {"Authorization": "Bearer " + token}
def create_user(client, username):
"""Регистрация + вход; заголовок авторизации — в поле "auth"."""
response = client.post("/api/v1/users", json={"username": username, "display_name": "Имя " + username,
"password": PASSWORD})
assert response.status_code == 201
user = response.json()
user["token"] = login(client, username)["token"]
user["auth"] = bearer(user["token"])
return user
@pytest.fixture
def alice(client):
return create_user(client, "alice")
@pytest.fixture
def bob(client):
return create_user(client, "bob")
@pytest.fixture
def eve(client):
return create_user(client, "eve")
@pytest.fixture
def chat(client, alice, bob):
"""Чат alice и bob; eve в него не входит."""
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "Тестовый чат", "member_ids": [alice["id"], bob["id"]]})
assert response.status_code == 201
return response.json()
def assert_error(response, status_code, code):
assert response.status_code == status_code
body = response.json()
assert body["error"]["code"] == code
assert body["error"]["request_id"] == response.headers["X-Request-Id"]
+92
View File
@@ -0,0 +1,92 @@
import time
import jwt
from conftest import PASSWORD, assert_error, basic, bearer, login
from core.config import settings
def assert_challenge(response, scheme):
assert response.headers["WWW-Authenticate"].startswith(scheme + ' realm="messenger"')
def test_login_returns_session(client, alice):
session = login(client, "alice")
assert session["token_type"] == "Bearer"
assert len(session["token"]) >= 32
assert session["expires_at"].endswith("Z")
assert session["user"]["id"] == alice["id"]
assert "password" not in session["user"] and "password_hash" not in session["user"]
assert login(client, "alice")["token"] != session["token"]
def test_jwt_payload_contains_sub_exp_jti(client, alice):
payload = jwt.decode(alice["token"], options={"verify_signature": False})
assert payload["sub"] == alice["id"]
assert payload["exp"] - payload["iat"] == settings.jwt.session_ttl_seconds
assert len(payload["jti"]) >= 43
def test_wrong_password_and_unknown_user_give_same_401(client, alice):
wrong = client.post("/api/v1/auth/sessions", headers=basic("alice", "Wrong-password-1"))
unknown = client.post("/api/v1/auth/sessions", headers=basic("nobody", PASSWORD))
for response in (wrong, unknown):
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Basic")
assert 'charset="UTF-8"' in response.headers["WWW-Authenticate"]
assert wrong.json()["error"]["message"] == unknown.json()["error"]["message"]
def test_malformed_basic_returns_401(client):
for header in ("", "Basic", "Basic !!!not-base64!!!", "Bearer abc", "Basic " + "YWxpY2U="): # последний — без ':'
response = client.post("/api/v1/auth/sessions", headers={"Authorization": header})
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Basic")
def test_password_with_colon_and_unicode(client):
password = "пароль:с:двоеточиями 👋"
client.post("/api/v1/users", json={"username": "colon", "display_name": "C", "password": password})
assert login(client, "colon", password)["user"]["username"] == "colon"
def test_protected_endpoint_requires_bearer(client, alice):
cases = [{}, basic("alice", PASSWORD), bearer("not-a-jwt"), {"Authorization": "Bearer"}]
for headers in cases:
response = client.get("/api/v1/users/me", headers=headers)
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Bearer")
def test_x_user_id_does_not_override_token(client, alice, eve):
response = client.get("/api/v1/users/me", headers={**alice["auth"], "X-User-Id": eve["id"]})
assert response.json()["id"] == alice["id"]
def test_forged_token_is_rejected(client, alice):
payload = jwt.decode(alice["token"], options={"verify_signature": False})
forged = jwt.encode(payload, "attacker-key-attacker-key-attacker-key!!", algorithm="HS256")
assert_error(client.get("/api/v1/users/me", headers=bearer(forged)), 401, "unauthorized")
unsigned = jwt.encode(payload, None, algorithm="none")
assert_error(client.get("/api/v1/users/me", headers=bearer(unsigned)), 401, "unauthorized")
def test_logout_revokes_only_current_token(client, alice):
second = login(client, "alice")["token"]
response = client.delete("/api/v1/auth/sessions/current", headers=alice["auth"])
assert response.status_code == 204
assert response.content == b""
assert_error(client.get("/api/v1/users/me", headers=alice["auth"]), 401, "unauthorized")
assert_error(client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]), 401, "unauthorized")
# Другая сессия того же пользователя продолжает работать.
assert client.get("/api/v1/users/me", headers=bearer(second)).status_code == 200
def test_session_expires(client, alice, monkeypatch):
monkeypatch.setattr(settings.jwt, "session_ttl_seconds", 1)
token = login(client, "alice")["token"]
assert client.get("/api/v1/users/me", headers=bearer(token)).status_code == 200
time.sleep(2.1)
response = client.get("/api/v1/users/me", headers=bearer(token))
assert_error(response, 401, "unauthorized")
assert_challenge(response, "Bearer")
+54
View File
@@ -0,0 +1,54 @@
import uuid
from sqlalchemy import text
from conftest import assert_error
from core.db import engine
def count_rows(table):
with engine.connect() as connection:
return connection.scalar(text(f"SELECT count(*) FROM {table}"))
def test_unknown_member_returns_400_and_nothing_is_saved(client, alice):
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "С призраком", "member_ids": [alice["id"], str(uuid.uuid4())]})
assert_error(response, 400, "invalid_request")
assert count_rows("chats") == 0
assert count_rows("chat_members") == 0
def test_created_chat_is_stored_with_members(client, chat, alice, bob):
assert sorted(chat["member_ids"]) == sorted([alice["id"], bob["id"]])
assert count_rows("chats") == 1
assert count_rows("chat_members") == 2
again = client.get("/api/v1/chats/" + chat["id"], headers=bob["auth"]).json()
assert again == chat
def test_foreign_chat_returns_404(client, chat, eve):
headers = eve["auth"]
path = "/api/v1/chats/" + chat["id"]
assert_error(client.get(path, headers=headers), 404, "not_found")
assert_error(client.get(path + "/messages", headers=headers), 404, "not_found")
assert_error(client.post(path + "/messages", headers=headers, json={"text": "чужое"}), 404, "not_found")
assert client.get("/api/v1/chats", headers=headers).json()["items"] == []
def test_member_sees_chat(client, chat, bob):
response = client.get("/api/v1/chats", headers=bob["auth"])
assert [c["id"] for c in response.json()["items"]] == [chat["id"]]
def test_creator_must_be_member(client, alice, bob):
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "Без меня", "member_ids": [bob["id"]]})
assert_error(response, 400, "invalid_request")
def test_duplicate_members_return_400(client, alice):
response = client.post("/api/v1/chats", headers=alice["auth"],
json={"title": "Дубли", "member_ids": [alice["id"], alice["id"]]})
assert_error(response, 400, "invalid_request")
+66
View File
@@ -0,0 +1,66 @@
from conftest import assert_error
def test_empty_message_returns_400(client, chat, alice):
path = "/api/v1/chats/" + chat["id"] + "/messages"
headers = alice["auth"]
assert_error(client.post(path, headers=headers, json={"text": ""}), 400, "invalid_request")
assert_error(client.post(path, headers=headers, json={"text": " \n\t"}), 400, "invalid_request")
def test_sender_is_taken_from_token(client, chat, alice, bob):
path = "/api/v1/chats/" + chat["id"] + "/messages"
response = client.post(path, headers=bob["auth"], json={"text": "Привет 👋"})
assert response.status_code == 201
assert response.json()["sender_id"] == bob["id"]
assert response.json()["text"] == "Привет 👋"
spoof = client.post(path, headers=bob["auth"], json={"text": "x", "sender_id": alice["id"]})
assert_error(spoof, 400, "invalid_request")
def test_pagination_over_several_pages(client, chat, alice):
path = "/api/v1/chats/" + chat["id"] + "/messages"
headers = alice["auth"]
sent = [client.post(path, headers=headers, json={"text": f"сообщение {i}"}).json() for i in range(7)]
received = []
pages = 0
cursor = None
while True:
params = {"limit": 3}
if cursor:
params["cursor"] = cursor
page = client.get(path, headers=headers, params=params).json()
received += page["items"]
pages += 1
cursor = page["next_cursor"]
if cursor is None:
break
assert pages == 3 # 3 + 3 + 1
assert received == sent # тот же порядок, ничего не потеряно
assert len({m["id"] for m in received}) == 7 # без повторов
def test_cursor_from_another_chat_returns_400(client, chat, alice):
headers = alice["auth"]
path = "/api/v1/chats/" + chat["id"] + "/messages"
for i in range(2):
client.post(path, headers=headers, json={"text": f"m{i}"})
cursor = client.get(path, headers=headers, params={"limit": 1}).json()["next_cursor"]
other = client.post("/api/v1/chats", headers=headers, json={"title": "Другой", "member_ids": [alice["id"]]}).json()
response = client.get("/api/v1/chats/" + other["id"] + "/messages", headers=headers, params={"cursor": cursor})
assert_error(response, 400, "invalid_request")
response = client.get(path, headers=headers, params={"cursor": "мусор"})
assert_error(response, 400, "invalid_request")
def test_invalid_limit_returns_400(client, chat, alice):
path = "/api/v1/chats/" + chat["id"] + "/messages"
for limit in (0, 101, "abc"):
response = client.get(path, headers=alice["auth"], params={"limit": limit})
assert_error(response, 400, "invalid_request")
+69
View File
@@ -0,0 +1,69 @@
import uuid
from sqlalchemy import text
from conftest import PASSWORD, assert_error
from core.db import engine
def test_invalid_json_returns_400(client):
response = client.post("/api/v1/users", content=b'{"username": "bob",',
headers={"Content-Type": "application/json"})
assert_error(response, 400, "invalid_request")
def test_extra_field_and_wrong_type_return_400(client):
response = client.post("/api/v1/users", json={"username": "bob", "display_name": "Bob", "password": PASSWORD,
"admin": True})
assert_error(response, 400, "invalid_request")
response = client.post("/api/v1/users", json={"username": "bob", "display_name": 123, "password": PASSWORD})
assert_error(response, 400, "invalid_request")
def test_duplicate_username_returns_409(client, alice):
response = client.post("/api/v1/users", json={"username": "alice", "display_name": "Другая Алиса",
"password": PASSWORD})
assert_error(response, 409, "conflict")
def test_unicode_display_name_is_kept(client):
response = client.post("/api/v1/users", json={"username": "uni", "display_name": "Алиса 👋",
"password": PASSWORD})
assert response.status_code == 201
assert response.json()["display_name"] == "Алиса 👋"
def test_password_is_required_and_length_checked(client):
for password in (None, "short", "x" * 129):
body = {"username": "pwd", "display_name": "P"}
if password is not None:
body["password"] = password
assert_error(client.post("/api/v1/users", json=body), 400, "invalid_request")
# 12 символов (не байт) — допустимо.
response = client.post("/api/v1/users", json={"username": "pwd", "display_name": "P", "password": "пароль123456"})
assert response.status_code == 201
def test_password_is_hashed_and_never_returned(client, alice):
assert "password" not in alice and "password_hash" not in alice
with engine.connect() as connection:
stored = connection.scalar(text("SELECT password_hash FROM users WHERE username = 'alice'"))
assert stored.startswith("$argon2id$")
assert PASSWORD not in stored
def test_me_returns_current_user(client, alice):
response = client.get("/api/v1/users/me", headers=alice["auth"])
assert response.status_code == 200
assert response.json() == {key: alice[key] for key in ("id", "username", "display_name", "created_at")}
def test_x_user_id_no_longer_authenticates(client, alice):
assert_error(client.get("/api/v1/users/me", headers={"X-User-Id": alice["id"]}), 401, "unauthorized")
assert_error(client.get("/api/v1/users/me", headers={"X-User-Id": str(uuid.uuid4())}), 401, "unauthorized")
def test_every_response_has_request_id(client):
assert client.get("/health/live").headers["X-Request-Id"]
assert client.get("/health/ready").headers["X-Request-Id"]
assert_error(client.get("/no/such/path"), 404, "not_found")