forked from mtusi2026/mtusi2026lab2
ЛР2: PostgreSQL, сессии (Basic + Bearer), Compose, миграции
This commit is contained in:
+17
-1
@@ -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
@@ -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
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
*.sh text eol=lf
|
||||
*.cmd text eol=crlf
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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
|
||||
|
||||
@@ -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 сообщений, тест гонки регистрации.
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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")
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)}")
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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
@@ -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
|
||||
)
|
||||
@@ -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()
|
||||
@@ -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 ###
|
||||
@@ -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"]
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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")
|
||||
@@ -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()"))
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,11 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class ErrorBody(BaseModel):
|
||||
code: str
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
error: ErrorBody
|
||||
@@ -0,0 +1,7 @@
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class HealthResponse(BaseModel):
|
||||
status: Literal["ok"]
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)]
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,5 @@
|
||||
[pytest]
|
||||
testpaths = student-tests
|
||||
pythonpath = app
|
||||
filterwarnings =
|
||||
ignore:Using .httpx. with .starlette.testclient. is deprecated
|
||||
@@ -0,0 +1,3 @@
|
||||
-r requirements.txt
|
||||
pytest==9.1.1
|
||||
httpx==0.28.1
|
||||
@@ -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
|
||||
@@ -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' }
|
||||
Executable
+18
@@ -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"; }
|
||||
@@ -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}}"
|
||||
Executable
+9
@@ -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}}'
|
||||
@@ -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"]
|
||||
@@ -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")
|
||||
@@ -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")
|
||||
@@ -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")
|
||||
@@ -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")
|
||||
Reference in New Issue
Block a user