diff --git a/.dockerignore b/.dockerignore index bc16e556..45a17f3d 100644 --- a/.dockerignore +++ b/.dockerignore @@ -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 diff --git a/.env.example b/.env.example index 714c8076..cb58e6a7 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..f4609ace --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +*.sh text eol=lf +*.cmd text eol=crlf diff --git a/.gitignore b/.gitignore index b5a71896..07adb7b5 100644 --- a/.gitignore +++ b/.gitignore @@ -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. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..e41e2329 --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/Makefile b/Makefile index 9ecb223e..23d09285 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/REPORT.md b/REPORT.md index e42f2b05..84be683b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 сообщений, тест гонки регистрации. diff --git a/app/alembic.ini b/app/alembic.ini new file mode 100644 index 00000000..26749615 --- /dev/null +++ b/app/alembic.ini @@ -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 diff --git a/app/api/dependencies.py b/app/api/dependencies.py new file mode 100644 index 00000000..5cbbbba1 --- /dev/null +++ b/app/api/dependencies.py @@ -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 diff --git a/app/api/health.py b/app/api/health.py new file mode 100644 index 00000000..d2386218 --- /dev/null +++ b/app/api/health.py @@ -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") diff --git a/app/api/v1/auth_rout.py b/app/api/v1/auth_rout.py new file mode 100644 index 00000000..bce0828e --- /dev/null +++ b/app/api/v1/auth_rout.py @@ -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) diff --git a/app/api/v1/chats_rout.py b/app/api/v1/chats_rout.py new file mode 100644 index 00000000..c09b080f --- /dev/null +++ b/app/api/v1/chats_rout.py @@ -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) diff --git a/app/api/v1/messages_rout.py b/app/api/v1/messages_rout.py new file mode 100644 index 00000000..ff6091a5 --- /dev/null +++ b/app/api/v1/messages_rout.py @@ -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) diff --git a/app/api/v1/users_rout.py b/app/api/v1/users_rout.py new file mode 100644 index 00000000..59b2d3a8 --- /dev/null +++ b/app/api/v1/users_rout.py @@ -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) diff --git a/app/core/config.py b/app/core/config.py new file mode 100644 index 00000000..f1079fe6 --- /dev/null +++ b/app/core/config.py @@ -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() diff --git a/app/core/db.py b/app/core/db.py new file mode 100644 index 00000000..655b3de8 --- /dev/null +++ b/app/core/db.py @@ -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)}") diff --git a/app/core/logger.py b/app/core/logger.py new file mode 100644 index 00000000..5c1d8d8f --- /dev/null +++ b/app/core/logger.py @@ -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() diff --git a/app/database_functions/chats_functions.py b/app/database_functions/chats_functions.py new file mode 100644 index 00000000..2f307f34 --- /dev/null +++ b/app/database_functions/chats_functions.py @@ -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)) diff --git a/app/database_functions/messages_functions.py b/app/database_functions/messages_functions.py new file mode 100644 index 00000000..9bbf2571 --- /dev/null +++ b/app/database_functions/messages_functions.py @@ -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)) diff --git a/app/database_functions/sessions_functions.py b/app/database_functions/sessions_functions.py new file mode 100644 index 00000000..092d87e7 --- /dev/null +++ b/app/database_functions/sessions_functions.py @@ -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 diff --git a/app/database_functions/users_functions.py b/app/database_functions/users_functions.py new file mode 100644 index 00000000..2aa8c1d4 --- /dev/null +++ b/app/database_functions/users_functions.py @@ -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)) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..951a5139 --- /dev/null +++ b/app/main.py @@ -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 + ) diff --git a/app/migrations/env.py b/app/migrations/env.py new file mode 100644 index 00000000..e5f91aa3 --- /dev/null +++ b/app/migrations/env.py @@ -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() diff --git a/app/migrations/script.py.mako b/app/migrations/script.py.mako new file mode 100644 index 00000000..11016301 --- /dev/null +++ b/app/migrations/script.py.mako @@ -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"} diff --git a/app/migrations/versions/0001_initial_schema.py b/app/migrations/versions/0001_initial_schema.py new file mode 100644 index 00000000..254d2257 --- /dev/null +++ b/app/migrations/versions/0001_initial_schema.py @@ -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 ### diff --git a/app/models/__init__.py b/app/models/__init__.py new file mode 100644 index 00000000..91e29388 --- /dev/null +++ b/app/models/__init__.py @@ -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"] diff --git a/app/models/base.py b/app/models/base.py new file mode 100644 index 00000000..2f98d6c4 --- /dev/null +++ b/app/models/base.py @@ -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) diff --git a/app/models/chats_models.py b/app/models/chats_models.py new file mode 100644 index 00000000..a086d791 --- /dev/null +++ b/app/models/chats_models.py @@ -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) diff --git a/app/models/messages_models.py b/app/models/messages_models.py new file mode 100644 index 00000000..6b44d42f --- /dev/null +++ b/app/models/messages_models.py @@ -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) diff --git a/app/models/sessions_models.py b/app/models/sessions_models.py new file mode 100644 index 00000000..ca350258 --- /dev/null +++ b/app/models/sessions_models.py @@ -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") diff --git a/app/models/users_models.py b/app/models/users_models.py new file mode 100644 index 00000000..07884a16 --- /dev/null +++ b/app/models/users_models.py @@ -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()")) diff --git a/app/schemas/auth_schemas.py b/app/schemas/auth_schemas.py new file mode 100644 index 00000000..9f45dfb7 --- /dev/null +++ b/app/schemas/auth_schemas.py @@ -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 diff --git a/app/schemas/chats_schemas.py b/app/schemas/chats_schemas.py new file mode 100644 index 00000000..fbc3eb43 --- /dev/null +++ b/app/schemas/chats_schemas.py @@ -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 diff --git a/app/schemas/error_schemas.py b/app/schemas/error_schemas.py new file mode 100644 index 00000000..b93b00af --- /dev/null +++ b/app/schemas/error_schemas.py @@ -0,0 +1,11 @@ +from pydantic import BaseModel + + +class ErrorBody(BaseModel): + code: str + message: str + request_id: str + + +class ErrorResponse(BaseModel): + error: ErrorBody diff --git a/app/schemas/health_schemas.py b/app/schemas/health_schemas.py new file mode 100644 index 00000000..9b69dec6 --- /dev/null +++ b/app/schemas/health_schemas.py @@ -0,0 +1,7 @@ +from typing import Literal + +from pydantic import BaseModel + + +class HealthResponse(BaseModel): + status: Literal["ok"] diff --git a/app/schemas/messages_schemas.py b/app/schemas/messages_schemas.py new file mode 100644 index 00000000..57b7b698 --- /dev/null +++ b/app/schemas/messages_schemas.py @@ -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 diff --git a/app/schemas/users_schemas.py b/app/schemas/users_schemas.py new file mode 100644 index 00000000..ff37a7b8 --- /dev/null +++ b/app/schemas/users_schemas.py @@ -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 diff --git a/app/utils/dates.py b/app/utils/dates.py new file mode 100644 index 00000000..851217bc --- /dev/null +++ b/app/utils/dates.py @@ -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)] diff --git a/app/utils/errors.py b/app/utils/errors.py new file mode 100644 index 00000000..d3066681 --- /dev/null +++ b/app/utils/errors.py @@ -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) diff --git a/app/utils/middleware.py b/app/utils/middleware.py new file mode 100644 index 00000000..09695f8e --- /dev/null +++ b/app/utils/middleware.py @@ -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 diff --git a/app/utils/pagination.py b/app/utils/pagination.py new file mode 100644 index 00000000..9cc34214 --- /dev/null +++ b/app/utils/pagination.py @@ -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 diff --git a/app/utils/security.py b/app/utils/security.py new file mode 100644 index 00000000..76ea0703 --- /dev/null +++ b/app/utils/security.py @@ -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() diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..a6229738 --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..bde26374 --- /dev/null +++ b/evidence/persistence.txt @@ -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 diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..78b8685f --- /dev/null +++ b/pytest.ini @@ -0,0 +1,5 @@ +[pytest] +testpaths = student-tests +pythonpath = app +filterwarnings = + ignore:Using .httpx. with .starlette.testclient. is deprecated diff --git a/requirements-test.txt b/requirements-test.txt new file mode 100644 index 00000000..9b5d2815 --- /dev/null +++ b/requirements-test.txt @@ -0,0 +1,3 @@ +-r requirements.txt +pytest==9.1.1 +httpx==0.28.1 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..8bbaec33 --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/init-secrets.ps1 b/scripts/init-secrets.ps1 new file mode 100644 index 00000000..fa3fe6d5 --- /dev/null +++ b/scripts/init-secrets.ps1 @@ -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' } diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 00000000..192ccba3 --- /dev/null +++ b/scripts/init-secrets.sh @@ -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"; } diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..636349c7 --- /dev/null +++ b/scripts/restart.cmd @@ -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}}" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..100578c9 --- /dev/null +++ b/scripts/restart.sh @@ -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}}' diff --git a/student-tests/conftest.py b/student-tests/conftest.py new file mode 100644 index 00000000..8043a3b6 --- /dev/null +++ b/student-tests/conftest.py @@ -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"] diff --git a/student-tests/test_auth_api.py b/student-tests/test_auth_api.py new file mode 100644 index 00000000..a3c7fda1 --- /dev/null +++ b/student-tests/test_auth_api.py @@ -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") diff --git a/student-tests/test_chats_api.py b/student-tests/test_chats_api.py new file mode 100644 index 00000000..7296617a --- /dev/null +++ b/student-tests/test_chats_api.py @@ -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") diff --git a/student-tests/test_messages_api.py b/student-tests/test_messages_api.py new file mode 100644 index 00000000..c7346699 --- /dev/null +++ b/student-tests/test_messages_api.py @@ -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") diff --git a/student-tests/test_users_api.py b/student-tests/test_users_api.py new file mode 100644 index 00000000..8593c408 --- /dev/null +++ b/student-tests/test_users_api.py @@ -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")