forked from mtusi2026/mtusi2026lab2
init commit: create skeleton from lab1
This commit is contained in:
+13
-6
@@ -1,11 +1,18 @@
|
||||
# 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
|
||||
LOG_LEVEL=INFO
|
||||
|
||||
MAX_MESSAGES=100000
|
||||
MAX_IN_FLIGHT=16
|
||||
|
||||
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
|
||||
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
|
||||
DB_POOL_SIZE=5
|
||||
DB_MAX_OVERFLOW=10
|
||||
DB_POOL_TIMEOUT_SECONDS=3
|
||||
DB_CONNECT_TIMEOUT_SECONDS=3
|
||||
DB_STATEMENT_TIMEOUT_MS=5000
|
||||
|
||||
@@ -30,3 +30,4 @@ coverage/
|
||||
.vscode/
|
||||
# Keep small, sanitized evidence summaries in evidence/ under version control.
|
||||
# Inspect git diff --cached: ignore rules are not a secret scanner.
|
||||
/venv
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
FROM python:3.12.15-slim-bookworm
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_DISABLE_PIP_VERSION_CHECK=1
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
RUN useradd --system --uid 10001 --no-create-home appuser
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install -r requirements.txt
|
||||
|
||||
COPY alembic.ini ./
|
||||
COPY migrations ./migrations
|
||||
COPY app ./app
|
||||
|
||||
USER appuser
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/live', timeout=2)"]
|
||||
|
||||
CMD ["python", "-m", "app"]
|
||||
@@ -4,10 +4,17 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
TEST_DATABASE_URL ?= $(shell sed -e 's|@postgres:|@localhost:|' -e 's|/messenger$$|/messenger_test|' secrets/database_url 2>/dev/null)
|
||||
export TEST_DATABASE_URL
|
||||
|
||||
.PHONY: help check validate test load test-persistence \
|
||||
secrets up down logs db-up migrate migration \
|
||||
test-own test-limits test-concurrency test-migrations
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "Курс: check | validate | test (smoke по BASE_URL) | load | test-persistence ACTION_SCRIPT=scripts/restart.sh"
|
||||
@echo "Стенд: secrets | up | down | logs | db-up (только PostgreSQL + тестовая БД) | migrate"
|
||||
@echo "Свои: test-own | test-limits | test-concurrency | test-migrations | migration m='описание'"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -24,3 +31,38 @@ 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)
|
||||
|
||||
secrets:
|
||||
sh scripts/init-secrets.sh
|
||||
|
||||
up:
|
||||
docker compose --env-file .env up -d --build
|
||||
|
||||
down:
|
||||
docker compose down # без -v: volumes с данными сохраняются
|
||||
|
||||
logs:
|
||||
docker compose logs -f api
|
||||
|
||||
db-up:
|
||||
docker compose up -d --wait postgres
|
||||
docker compose exec -T postgres sh -c \
|
||||
"psql -U messenger -d postgres -tc \"SELECT 1 FROM pg_database WHERE datname='messenger_test'\" | grep -q 1 || createdb -U messenger messenger_test"
|
||||
|
||||
migrate:
|
||||
docker compose run --rm migrate
|
||||
|
||||
migration:
|
||||
$(PYTHON) -m alembic revision --autogenerate -m "$(m)"
|
||||
|
||||
test-own:
|
||||
$(PYTHON) -m pytest tests -q
|
||||
|
||||
test-limits:
|
||||
$(PYTHON) -m pytest tests/test_limits.py -q
|
||||
|
||||
test-concurrency:
|
||||
$(PYTHON) -m pytest tests/test_concurrency.py -q
|
||||
|
||||
test-migrations:
|
||||
$(PYTHON) -m pytest tests/test_migrations.py -q
|
||||
|
||||
+37
@@ -0,0 +1,37 @@
|
||||
[alembic]
|
||||
script_location = migrations
|
||||
prepend_sys_path = .
|
||||
|
||||
[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,4 @@
|
||||
from app.main import main
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,56 @@
|
||||
from enum import StrEnum
|
||||
from pathlib import Path
|
||||
from typing import Literal, Self
|
||||
|
||||
from pydantic import Field, model_validator
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
|
||||
|
||||
class LogLevel(StrEnum):
|
||||
DEBUG = "DEBUG"
|
||||
INFO = "INFO"
|
||||
WARNING = "WARNING"
|
||||
ERROR = "ERROR"
|
||||
CRITICAL = "CRITICAL"
|
||||
|
||||
|
||||
class Settings(BaseSettings):
|
||||
app_host: str
|
||||
app_port: int = Field(ge=1, le=65535)
|
||||
app_env: str
|
||||
log_level: LogLevel = LogLevel.INFO
|
||||
|
||||
max_messages: int = Field(ge=1)
|
||||
max_in_flight: int = Field(ge=1)
|
||||
|
||||
session_ttl_seconds: int = Field(default=3600, ge=1)
|
||||
session_store: Literal["postgres"] = "postgres"
|
||||
|
||||
database_url: str | None = None
|
||||
database_url_file: Path | None = None
|
||||
|
||||
db_pool_size: int = Field(default=5, ge=1)
|
||||
db_max_overflow: int = Field(default=5, ge=0)
|
||||
db_pool_timeout_seconds: float = Field(default=3.0, gt=0)
|
||||
db_connect_timeout_seconds: int = Field(default=3, ge=1)
|
||||
db_statement_timeout_ms: int = Field(default=5000, ge=1)
|
||||
|
||||
model_config = SettingsConfigDict(
|
||||
env_file=".env",
|
||||
env_file_encoding="utf-8",
|
||||
case_sensitive=False,
|
||||
extra="ignore",
|
||||
)
|
||||
|
||||
@model_validator(mode="after")
|
||||
def _require_database_source(self) -> Self:
|
||||
if self.database_url is None and self.database_url_file is None:
|
||||
raise ValueError("Задайте DATABASE_URL или DATABASE_URL_FILE")
|
||||
return self
|
||||
|
||||
def get_database_url(self) -> str:
|
||||
"""Возвращает строку подключения; секрет из файла читается на каждый вызов."""
|
||||
if self.database_url is not None:
|
||||
return self.database_url
|
||||
assert self.database_url_file is not None
|
||||
return self.database_url_file.read_text(encoding="utf-8").strip()
|
||||
@@ -0,0 +1,55 @@
|
||||
"""Engine и фабрика сессий SQLAlchemy.
|
||||
|
||||
Живёт рядом с config.py, но отдельно: Settings только описывает параметры,
|
||||
а создание ресурсов (engine, пул) — здесь, чтобы тесты могли подменять Settings.
|
||||
"""
|
||||
|
||||
import logging
|
||||
|
||||
from sqlalchemy import Engine, create_engine, text
|
||||
from sqlalchemy.exc import SQLAlchemyError
|
||||
from sqlalchemy.orm import Session, sessionmaker
|
||||
|
||||
from app.core.config import Settings
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def create_db_engine(settings: Settings) -> Engine:
|
||||
"""Создаёт engine с ограниченным пулом и таймаутами.
|
||||
|
||||
create_engine ленивый: подключение к БД происходит при первом запросе,
|
||||
поэтому приложение стартует и без доступной БД (ready вернёт 503).
|
||||
"""
|
||||
return create_engine(
|
||||
settings.get_database_url(),
|
||||
pool_size=settings.db_pool_size,
|
||||
max_overflow=settings.db_max_overflow,
|
||||
pool_timeout=settings.db_pool_timeout_seconds,
|
||||
pool_pre_ping=True,
|
||||
connect_args={
|
||||
"connect_timeout": settings.db_connect_timeout_seconds,
|
||||
"options": f"-c statement_timeout={settings.db_statement_timeout_ms}",
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def create_session_factory(engine: Engine) -> sessionmaker[Session]:
|
||||
"""Фабрика сессий: одна сессия на HTTP-запрос (см. endpoints/dependencies.py).
|
||||
|
||||
expire_on_commit=False — после commit объекты остаются читаемыми, и domain
|
||||
может собрать ответ без повторного SELECT.
|
||||
autoflush=False — flush вызываем явно, поведение предсказуемо.
|
||||
"""
|
||||
return sessionmaker(bind=engine, expire_on_commit=False, autoflush=False)
|
||||
|
||||
|
||||
def check_database(engine: Engine) -> bool:
|
||||
"""True, если БД отвечает на SELECT 1. Используется в /health/ready."""
|
||||
try:
|
||||
with engine.connect() as connection:
|
||||
connection.execute(text("SELECT 1"))
|
||||
except SQLAlchemyError:
|
||||
logger.warning("database readiness check failed", exc_info=True)
|
||||
return False
|
||||
return True
|
||||
@@ -0,0 +1,22 @@
|
||||
from collections.abc import Generator
|
||||
from threading import BoundedSemaphore
|
||||
|
||||
from fastapi import Request
|
||||
|
||||
from app.errors.exceptions import rate_limited
|
||||
|
||||
|
||||
def create_request_capacity(max_in_flight: int) -> BoundedSemaphore:
|
||||
return BoundedSemaphore(max_in_flight)
|
||||
|
||||
|
||||
def acquire_request_slot(request: Request) -> Generator[None, None, None]:
|
||||
semaphore: BoundedSemaphore = request.app.state.request_capacity
|
||||
|
||||
if not semaphore.acquire(blocking=False):
|
||||
raise rate_limited()
|
||||
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
semaphore.release()
|
||||
@@ -0,0 +1,22 @@
|
||||
from uuid import uuid4
|
||||
|
||||
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
|
||||
REQUEST_ID_HEADER = "X-Request-Id"
|
||||
|
||||
|
||||
class RequestIdMiddleware(BaseHTTPMiddleware):
|
||||
async def dispatch(
|
||||
self,
|
||||
request: Request,
|
||||
call_next: RequestResponseEndpoint,
|
||||
) -> Response:
|
||||
request_id = str(uuid4())
|
||||
request.state.request_id = request_id
|
||||
|
||||
response = await call_next(request)
|
||||
response.headers[REQUEST_ID_HEADER] = request_id
|
||||
|
||||
return response
|
||||
@@ -0,0 +1,39 @@
|
||||
"""Пароли и токены сессий. ВСЁ ЗДЕСЬ — ЗАГЛУШКИ ДЛЯ САМОСТОЯТЕЛЬНОЙ РЕАЛИЗАЦИИ.
|
||||
|
||||
Вопрос защиты: «Почему hash пароля и быстрый checksum имеют разные задачи?»
|
||||
* пароль имеет низкую энтропию -> нужен медленный KDF с солью (Argon2id);
|
||||
* токен — 256 бит случайности -> брутфорс невозможен, хватает SHA-256,
|
||||
а в БД храним только хеш токена (утечка БД не даёт рабочих токенов).
|
||||
"""
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
"""Хеширует пароль библиотечным KDF (рекомендуется argon2-cffi, Argon2id).
|
||||
|
||||
Возвращает строку с параметрами и солью внутри (формат PHC, "$argon2id$...").
|
||||
"""
|
||||
raise NotImplementedError("TODO: argon2.PasswordHasher().hash(password)")
|
||||
|
||||
|
||||
def verify_password(password: str, password_hash: str) -> bool:
|
||||
"""True, если пароль подходит. Любые ошибки верификации -> False, не исключение."""
|
||||
raise NotImplementedError("TODO: PasswordHasher().verify + перехват VerifyMismatchError")
|
||||
|
||||
|
||||
def dummy_verify_password(password: str) -> None:
|
||||
"""Проверка «вхолостую» для несуществующего пользователя.
|
||||
|
||||
Нужна, чтобы время ответа на неверный username и на неверный пароль
|
||||
не различалось (иначе по таймингу можно перебирать username).
|
||||
"""
|
||||
raise NotImplementedError("TODO: verify_password(password, заранее посчитанный DUMMY_HASH)")
|
||||
|
||||
|
||||
def generate_token() -> str:
|
||||
"""Opaque-токен минимум на 256 бит энтропии (secrets.token_urlsafe(32))."""
|
||||
raise NotImplementedError("TODO: secrets.token_urlsafe(32)")
|
||||
|
||||
|
||||
def hash_token(token: str) -> str:
|
||||
"""Детерминированный хеш токена для хранения/поиска в БД (sha256 hexdigest)."""
|
||||
raise NotImplementedError("TODO: hashlib.sha256(token.encode()).hexdigest()")
|
||||
@@ -0,0 +1,10 @@
|
||||
"""Бизнес-логика. Здесь решается, какая ошибка API соответствует ситуации.
|
||||
|
||||
Правила слоя:
|
||||
* функции принимают sqlalchemy Session первым аргументом;
|
||||
* возвращают pydantic-схемы (app.schemas), а не ORM-объекты;
|
||||
* вызывают app.storage.* и бросают ApiError из app.errors.exceptions;
|
||||
* ВЛАДЕЮТ ТРАНЗАКЦИЕЙ: именно здесь session.commit(); при ошибке — rollback
|
||||
(незакоммиченная сессия в любом случае откатывается при закрытии в dependency);
|
||||
* никаких Request/Response/HTTP-заголовков — это слой endpoints.
|
||||
"""
|
||||
@@ -0,0 +1,48 @@
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.schemas.session import AuthSession
|
||||
from app.schemas.user import User
|
||||
|
||||
|
||||
def create_session(
|
||||
session: Session,
|
||||
username: str,
|
||||
password: str,
|
||||
ttl_seconds: int,
|
||||
) -> AuthSession:
|
||||
"""POST /auth/sessions (username/password уже извлечены из Basic в endpoints).
|
||||
|
||||
TODO:
|
||||
1. user = storage.users.get_user_by_username(...)
|
||||
2. Нет пользователя ИЛИ пароль неверен -> ОДИНАКОВЫЙ raise unauthorized_basic().
|
||||
Для несуществующего username вызовите security.dummy_verify_password(password),
|
||||
чтобы время ответа совпадало.
|
||||
3. token = security.generate_token(); хранить только security.hash_token(token).
|
||||
4. expires_at = now(UTC) + timedelta(seconds=ttl_seconds);
|
||||
storage.sessions.create_session(...); session.commit().
|
||||
5. return AuthSession(token=token, expires_at=expires_at, user=to_user_schema(user))
|
||||
(токен показывается клиенту ровно один раз).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def authenticate_token(session: Session, token: str) -> User:
|
||||
"""Bearer-токен -> текущий пользователь (используется как dependency на всех бизнес-endpoint).
|
||||
|
||||
TODO:
|
||||
1. storage.sessions.get_user_by_active_token_hash(session, hash_token(token), now(UTC))
|
||||
2. None (неизвестен/истёк/отозван) -> raise unauthorized_bearer()
|
||||
3. return to_user_schema(user)
|
||||
Это AUTHENTICATION («кто ты»). «Можно ли тебе в этот чат» (AUTHORIZATION) —
|
||||
отдельная проверка членства в domain.chats; посторонний получает 404, не 403.
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def revoke_session(session: Session, token: str) -> None:
|
||||
"""DELETE /auth/sessions/current.
|
||||
|
||||
TODO: storage.sessions.revoke_session(...); False -> raise unauthorized_bearer();
|
||||
иначе session.commit(). Повторный logout тем же токеном = 401 (токен уже недействителен).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,80 @@
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.domain.pagination import (
|
||||
KIND_CHATS,
|
||||
build_next_cursor,
|
||||
decode_cursor,
|
||||
split_page,
|
||||
)
|
||||
from app.errors.exceptions import invalid_request
|
||||
from app.models.chat import Chat as ChatModel
|
||||
from app.schemas.chat import Chat, ChatPage, CreateChat
|
||||
from app.schemas.user import User
|
||||
from app.storage.types import Position
|
||||
|
||||
|
||||
def to_chat_schema(chat: ChatModel) -> Chat:
|
||||
"""ORM -> схема. member_ids собираются из chat.members (relationship).
|
||||
|
||||
TODO: Chat(id=chat.id, title=chat.title,
|
||||
member_ids=[m.user_id for m in chat.members], created_at=chat.created_at)
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def validate_new_chat(creator: User, new_chat: CreateChat) -> None:
|
||||
"""Проверки, не требующие БД (перенесено из lab1 как есть)."""
|
||||
member_ids = new_chat.member_ids
|
||||
|
||||
if creator.id not in member_ids:
|
||||
raise invalid_request("Создатель чата должен входить в member_ids")
|
||||
|
||||
if len(set(member_ids)) != len(member_ids):
|
||||
raise invalid_request("member_ids содержит дубликаты")
|
||||
|
||||
|
||||
def create_chat(session: Session, creator: User, new_chat: CreateChat) -> Chat:
|
||||
"""POST /chats.
|
||||
|
||||
TODO:
|
||||
1. validate_new_chat(creator, new_chat)
|
||||
2. known = storage.users.get_existing_user_ids(session, new_chat.member_ids);
|
||||
если known != set(member_ids) -> invalid_request("member_ids содержит неизвестного пользователя")
|
||||
3. storage.chats.create_chat(...) + session.commit() — одна транзакция:
|
||||
чат и все участники появляются вместе или не появляются вовсе.
|
||||
4. return to_chat_schema(chat)
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def get_chat(session: Session, user: User, chat_id: UUID) -> Chat:
|
||||
"""GET /chats/{id}.
|
||||
|
||||
TODO: storage.chats.get_chat_for_member(...); None -> raise not_found()
|
||||
(и для чужого, и для несуществующего чата — одинаково).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def list_chats(
|
||||
session: Session,
|
||||
user: User,
|
||||
cursor: str | None,
|
||||
limit: int,
|
||||
) -> ChatPage:
|
||||
"""GET /chats — keyset-пагинация (логика курсора перенесена из lab1).
|
||||
|
||||
TODO: раскомментируйте и подключите storage.
|
||||
"""
|
||||
after: Position | None = None
|
||||
if cursor is not None:
|
||||
after = decode_cursor(cursor, KIND_CHATS, user.id)
|
||||
|
||||
# rows = storage.chats.list_chats_for_user(session, user.id, after, limit + 1)
|
||||
# items, has_next = split_page(rows, limit)
|
||||
# next_cursor = build_next_cursor(KIND_CHATS, user.id, items, has_next)
|
||||
# return ChatPage(items=[to_chat_schema(c) for c in items], next_cursor=next_cursor)
|
||||
_ = (split_page, build_next_cursor, after)
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,59 @@
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.domain.pagination import (
|
||||
KIND_MESSAGES,
|
||||
build_next_cursor,
|
||||
decode_cursor,
|
||||
split_page,
|
||||
)
|
||||
from app.schemas.message import CreateMessage, Message, MessagePage
|
||||
from app.schemas.user import User
|
||||
from app.storage.types import Position
|
||||
|
||||
|
||||
def send_message(
|
||||
session: Session,
|
||||
sender: User,
|
||||
chat_id: UUID,
|
||||
new_message: CreateMessage,
|
||||
max_messages: int,
|
||||
) -> Message:
|
||||
"""POST /chats/{id}/messages.
|
||||
|
||||
TODO:
|
||||
1. Доступ: domain.chats.get_chat(...) -> 404 для постороннего.
|
||||
2. Лимит трека «управляемая деградация»:
|
||||
storage.messages.count_messages(session) >= max_messages -> raise unavailable("Достигнут лимит количества сообщений") (503).
|
||||
Ранее подтверждённые сообщения НЕ удаляются.
|
||||
3. storage.messages.create_message(...); session.commit(); вернуть схему Message.
|
||||
Гонка у лимита: два запроса одновременно могут пройти проверку — решите,
|
||||
допустимо ли превышение на несколько сообщений, и напишите это в отчёте
|
||||
(или сериализуйте проверку, например pg_advisory_xact_lock).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def list_messages(
|
||||
session: Session,
|
||||
user: User,
|
||||
chat_id: UUID,
|
||||
cursor: str | None,
|
||||
limit: int,
|
||||
) -> MessagePage:
|
||||
"""GET /chats/{id}/messages — keyset-пагинация (логика курсора перенесена из lab1).
|
||||
|
||||
TODO: подключите storage.
|
||||
1. domain.chats.get_chat(...) -> 404, если нет доступа
|
||||
2. after = decode_cursor(cursor, KIND_MESSAGES, chat_id) (чужой cursor -> 400)
|
||||
3. rows = storage.messages.list_messages(session, chat_id, after, limit + 1)
|
||||
4. items, has_next = split_page(rows, limit); next_cursor = build_next_cursor(...)
|
||||
5. MessagePage(items=[Message.model_validate(m) for m in items], next_cursor=...)
|
||||
"""
|
||||
after: Position | None = None
|
||||
if cursor is not None:
|
||||
after = decode_cursor(cursor, KIND_MESSAGES, chat_id)
|
||||
|
||||
_ = (split_page, build_next_cursor, after)
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,79 @@
|
||||
import base64
|
||||
import json
|
||||
from collections.abc import Sequence
|
||||
from datetime import datetime
|
||||
from typing import Protocol, TypeVar
|
||||
from uuid import UUID
|
||||
|
||||
from app.errors.exceptions import invalid_request
|
||||
from app.storage.types import Position
|
||||
|
||||
KIND_CHATS = "chats"
|
||||
KIND_MESSAGES = "messages"
|
||||
|
||||
T = TypeVar("T")
|
||||
|
||||
|
||||
class Positioned(Protocol):
|
||||
"""Всё, у чего есть позиция в порядке (created_at, id): ORM-модели и схемы."""
|
||||
|
||||
@property
|
||||
def id(self) -> UUID: ...
|
||||
|
||||
@property
|
||||
def created_at(self) -> datetime: ...
|
||||
|
||||
|
||||
def encode_cursor(
|
||||
kind: str,
|
||||
resource_id: UUID,
|
||||
created_at: datetime,
|
||||
item_id: UUID,
|
||||
) -> str:
|
||||
payload = {
|
||||
"kind": kind,
|
||||
"resource_id": str(resource_id),
|
||||
"created_at": created_at.isoformat(),
|
||||
"item_id": str(item_id),
|
||||
}
|
||||
raw = json.dumps(payload).encode()
|
||||
return base64.urlsafe_b64encode(raw).decode()
|
||||
|
||||
|
||||
def decode_cursor(cursor: str, kind: str, resource_id: UUID) -> Position:
|
||||
try:
|
||||
payload = json.loads(base64.urlsafe_b64decode(cursor))
|
||||
cursor_kind = payload["kind"]
|
||||
cursor_resource_id = UUID(payload["resource_id"])
|
||||
created_at = datetime.fromisoformat(payload["created_at"])
|
||||
item_id = UUID(payload["item_id"])
|
||||
except (ValueError, KeyError, TypeError, AttributeError):
|
||||
raise invalid_request("Некорректный cursor") from None
|
||||
|
||||
if (
|
||||
cursor_kind != kind
|
||||
or cursor_resource_id != resource_id
|
||||
or created_at.tzinfo is None
|
||||
):
|
||||
raise invalid_request("Некорректный cursor")
|
||||
|
||||
return created_at, item_id
|
||||
|
||||
|
||||
def split_page(rows: list[T], limit: int) -> tuple[list[T], bool]:
|
||||
has_next = len(rows) > limit
|
||||
items = rows[:limit]
|
||||
return items, has_next
|
||||
|
||||
|
||||
def build_next_cursor(
|
||||
kind: str,
|
||||
resource_id: UUID,
|
||||
items: Sequence[Positioned],
|
||||
has_next: bool,
|
||||
) -> str | None:
|
||||
if not has_next:
|
||||
return None
|
||||
|
||||
last_item = items[-1]
|
||||
return encode_cursor(kind, resource_id, last_item.created_at, last_item.id)
|
||||
@@ -0,0 +1,24 @@
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.models.user import User as UserModel
|
||||
from app.schemas.user import CreateUser, User
|
||||
|
||||
|
||||
def to_user_schema(user: UserModel) -> User:
|
||||
"""ORM -> публичная схема (без password_hash)."""
|
||||
return User.model_validate(user)
|
||||
|
||||
|
||||
def register_user(session: Session, new_user: CreateUser) -> User:
|
||||
"""POST /users.
|
||||
|
||||
TODO:
|
||||
1. password_hash = security.hash_password(new_user.password)
|
||||
— ДО обращения к БД: Argon2 занимает десятки мс, не держим из-за него транзакцию.
|
||||
2. storage.users.create_user(...); session.commit().
|
||||
3. Гонка «два запроса с одним username одновременно»: проверка
|
||||
«сначала SELECT, потом INSERT» не спасает. Источник истины — UNIQUE в БД:
|
||||
поймайте sqlalchemy.exc.IntegrityError, session.rollback(), raise conflict("Username уже занят").
|
||||
4. return to_user_schema(user)
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,33 @@
|
||||
from fastapi import APIRouter, Depends, Response
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.core.config import Settings
|
||||
from app.domain.auth import create_session, revoke_session
|
||||
from app.endpoints.dependencies import (
|
||||
get_basic_credentials,
|
||||
get_bearer_token,
|
||||
get_db,
|
||||
get_settings,
|
||||
)
|
||||
from app.schemas.session import AuthSession
|
||||
|
||||
router = APIRouter(prefix="/api/v1/auth", tags=["auth"])
|
||||
|
||||
|
||||
@router.post("/sessions", status_code=201)
|
||||
def login(
|
||||
credentials: tuple[str, str] = Depends(get_basic_credentials),
|
||||
session: Session = Depends(get_db),
|
||||
settings: Settings = Depends(get_settings),
|
||||
) -> AuthSession:
|
||||
username, password = credentials
|
||||
return create_session(session, username, password, settings.session_ttl_seconds)
|
||||
|
||||
|
||||
@router.delete("/sessions/current", status_code=204)
|
||||
def logout(
|
||||
token: str = Depends(get_bearer_token),
|
||||
session: Session = Depends(get_db),
|
||||
) -> Response:
|
||||
revoke_session(session, token)
|
||||
return Response(status_code=204)
|
||||
@@ -0,0 +1,39 @@
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, Query
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.domain.chats import create_chat, get_chat, list_chats
|
||||
from app.endpoints.dependencies import get_current_user, get_db
|
||||
from app.schemas.chat import Chat, ChatPage, CreateChat
|
||||
from app.schemas.user import User
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
|
||||
|
||||
|
||||
@router.post("", status_code=201)
|
||||
def create_new_chat(
|
||||
new_chat: CreateChat,
|
||||
creator: User = Depends(get_current_user),
|
||||
session: Session = Depends(get_db),
|
||||
) -> Chat:
|
||||
return create_chat(session, creator, new_chat)
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_user_chats(
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = Query(None, min_length=1),
|
||||
user: User = Depends(get_current_user),
|
||||
session: Session = Depends(get_db),
|
||||
) -> ChatPage:
|
||||
return list_chats(session, user, cursor, limit)
|
||||
|
||||
|
||||
@router.get("/{chat_id}")
|
||||
def get_chat_by_id(
|
||||
chat_id: UUID,
|
||||
user: User = Depends(get_current_user),
|
||||
session: Session = Depends(get_db),
|
||||
) -> Chat:
|
||||
return get_chat(session, user, chat_id)
|
||||
@@ -0,0 +1,76 @@
|
||||
import base64
|
||||
import binascii
|
||||
from collections.abc import Iterator
|
||||
|
||||
from fastapi import Depends, Header, Request
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.core.config import Settings
|
||||
from app.domain.auth import authenticate_token
|
||||
from app.errors.exceptions import unauthorized_basic, unauthorized_bearer
|
||||
from app.schemas.user import User
|
||||
|
||||
|
||||
def get_settings(request: Request) -> Settings:
|
||||
settings: Settings = request.app.state.settings
|
||||
return settings
|
||||
|
||||
|
||||
def get_db(request: Request) -> Iterator[Session]:
|
||||
"""Одна сессия БД на HTTP-запрос.
|
||||
|
||||
Если domain не сделал commit — при закрытии сессии транзакция откатывается,
|
||||
поэтому «забытый» commit даёт потерю данных, а не полузаписанное состояние.
|
||||
FastAPI кэширует зависимость в рамках запроса: get_current_user и endpoint
|
||||
получают ОДНУ И ТУ ЖЕ сессию.
|
||||
"""
|
||||
session_factory = request.app.state.session_factory
|
||||
with session_factory() as session:
|
||||
yield session
|
||||
|
||||
|
||||
def _split_authorization(authorization: str | None) -> tuple[str, str] | None:
|
||||
if authorization is None:
|
||||
return None
|
||||
scheme, _, value = authorization.partition(" ")
|
||||
if not value.strip():
|
||||
return None
|
||||
return scheme.lower(), value.strip()
|
||||
|
||||
|
||||
def get_bearer_token(authorization: str | None = Header(default=None)) -> str:
|
||||
"""Bearer-токен из Authorization. Basic, пустой и чужие схемы -> 401."""
|
||||
parts = _split_authorization(authorization)
|
||||
if parts is None or parts[0] != "bearer":
|
||||
raise unauthorized_bearer()
|
||||
return parts[1]
|
||||
|
||||
|
||||
def get_basic_credentials(
|
||||
authorization: str | None = Header(default=None),
|
||||
) -> tuple[str, str]:
|
||||
"""(username, password) из `Authorization: Basic base64(username:password)`.
|
||||
|
||||
Пароль может содержать двоеточие, поэтому делим только по первому ':'.
|
||||
Любая ошибка разбора -> тот же 401, что и неверные учётные данные.
|
||||
"""
|
||||
parts = _split_authorization(authorization)
|
||||
if parts is None or parts[0] != "basic":
|
||||
raise unauthorized_basic()
|
||||
|
||||
try:
|
||||
decoded = base64.b64decode(parts[1], validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeDecodeError, ValueError):
|
||||
raise unauthorized_basic() from None
|
||||
|
||||
username, separator, password = decoded.partition(":")
|
||||
if not separator or not username:
|
||||
raise unauthorized_basic()
|
||||
return username, password
|
||||
|
||||
|
||||
def get_current_user(
|
||||
token: str = Depends(get_bearer_token),
|
||||
session: Session = Depends(get_db),
|
||||
) -> User:
|
||||
return authenticate_token(session, token)
|
||||
@@ -0,0 +1,21 @@
|
||||
from fastapi import APIRouter, Request
|
||||
|
||||
from app.core.database import check_database
|
||||
from app.errors.exceptions import unavailable
|
||||
from app.schemas.base import Health
|
||||
|
||||
router = APIRouter(prefix="/health", tags=["health"])
|
||||
|
||||
|
||||
@router.get("/live")
|
||||
async def liveness() -> Health:
|
||||
# Только «процесс жив»: БД намеренно не трогаем.
|
||||
return Health(status="ok")
|
||||
|
||||
|
||||
@router.get("/ready")
|
||||
def readiness(request: Request) -> Health:
|
||||
# Готовность = приложение может обслужить синхронный путь, а он требует БД.
|
||||
if not check_database(request.app.state.engine):
|
||||
raise unavailable()
|
||||
return Health(status="ok")
|
||||
@@ -0,0 +1,34 @@
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, Query
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.core.config import Settings
|
||||
from app.domain.messages import list_messages, send_message
|
||||
from app.endpoints.dependencies import get_current_user, get_db, get_settings
|
||||
from app.schemas.message import CreateMessage, Message, MessagePage
|
||||
from app.schemas.user import User
|
||||
|
||||
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
|
||||
|
||||
|
||||
@router.post("/{chat_id}/messages", status_code=201)
|
||||
def send_new_message(
|
||||
chat_id: UUID,
|
||||
new_message: CreateMessage,
|
||||
sender: User = Depends(get_current_user),
|
||||
session: Session = Depends(get_db),
|
||||
settings: Settings = Depends(get_settings),
|
||||
) -> Message:
|
||||
return send_message(session, sender, chat_id, new_message, settings.max_messages)
|
||||
|
||||
|
||||
@router.get("/{chat_id}/messages")
|
||||
def get_history_messages(
|
||||
chat_id: UUID,
|
||||
limit: int = Query(50, ge=1, le=100),
|
||||
cursor: str | None = Query(None, min_length=1),
|
||||
user: User = Depends(get_current_user),
|
||||
session: Session = Depends(get_db),
|
||||
) -> MessagePage:
|
||||
return list_messages(session, user, chat_id, cursor, limit)
|
||||
@@ -0,0 +1,21 @@
|
||||
from fastapi import APIRouter, Depends
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.domain.users import register_user
|
||||
from app.endpoints.dependencies import get_current_user, get_db
|
||||
from app.schemas.user import CreateUser, User
|
||||
|
||||
router = APIRouter(prefix="/api/v1/users", tags=["users"])
|
||||
|
||||
|
||||
@router.post("", status_code=201)
|
||||
def create_user(
|
||||
new_user: CreateUser,
|
||||
session: Session = Depends(get_db),
|
||||
) -> User:
|
||||
return register_user(session, new_user)
|
||||
|
||||
|
||||
@router.get("/me")
|
||||
def get_me(user: User = Depends(get_current_user)) -> User:
|
||||
return user
|
||||
@@ -0,0 +1,85 @@
|
||||
from collections.abc import Mapping
|
||||
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(
|
||||
self,
|
||||
status_code: int,
|
||||
code: str,
|
||||
message: str,
|
||||
headers: Mapping[str, str] | None = None,
|
||||
) -> None:
|
||||
super().__init__(message)
|
||||
self.status_code = status_code
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.headers = headers
|
||||
|
||||
|
||||
def invalid_request(message: str = "Неверный запрос") -> ApiError:
|
||||
"""Создаёт ошибку некорректного или недопустимого запроса."""
|
||||
return ApiError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def unauthorized(
|
||||
message: str = "Нет действительной аутентификации",
|
||||
www_authenticate: str | None = None,
|
||||
) -> ApiError:
|
||||
"""Создаёт ошибку отсутствующей или недействительной аутентификации."""
|
||||
headers = {"WWW-Authenticate": www_authenticate} if www_authenticate else None
|
||||
return ApiError(401, "unauthorized", message, headers)
|
||||
|
||||
|
||||
def unauthorized_basic(message: str = "Неверные учётные данные") -> ApiError:
|
||||
"""401 для POST /auth/sessions (одинаковый для неверного username и пароля)."""
|
||||
return unauthorized(message, BASIC_CHALLENGE)
|
||||
|
||||
|
||||
def unauthorized_bearer(message: str = "Нет действительной сессии") -> ApiError:
|
||||
"""401 для бизнес-endpoint: нет, истёк, отозван или неизвестен токен."""
|
||||
return unauthorized(message, BEARER_CHALLENGE)
|
||||
|
||||
|
||||
def not_found(message: str = "Объект не найден") -> ApiError:
|
||||
"""Создаёт ошибку, указывающую на отсутствие запрошенного ресурса."""
|
||||
return ApiError(404, "not_found", message)
|
||||
|
||||
|
||||
def conflict(message: str = "Конфликт") -> ApiError:
|
||||
"""Создаёт ошибку конфликта с текущим состоянием ресурса."""
|
||||
return ApiError(409, "conflict", message)
|
||||
|
||||
|
||||
def payload_too_large(message: str = "Слишком большое тело запроса") -> ApiError:
|
||||
"""Создаёт ошибку, указывающую на превышение допустимого размера запроса."""
|
||||
return ApiError(413, "payload_too_large", message)
|
||||
|
||||
|
||||
def unsupported_media_type(
|
||||
message: str = "Требуется Content-Type: application/json",
|
||||
) -> ApiError:
|
||||
"""Создаёт ошибку неподдерживаемого формата или типа содержимого запроса."""
|
||||
return ApiError(415, "unsupported_media_type", message)
|
||||
|
||||
|
||||
def rate_limited(retry_after: int = 1) -> ApiError:
|
||||
"""Создаёт ошибку превышения допустимой частоты запросов."""
|
||||
return ApiError(
|
||||
429,
|
||||
"rate_limited",
|
||||
"Слишком много запросов",
|
||||
{"Retry-After": str(max(1, retry_after))},
|
||||
)
|
||||
|
||||
|
||||
def unavailable(message: str = "Сервис временно недоступен") -> ApiError:
|
||||
"""Создаёт ошибку временной недоступности сервиса."""
|
||||
return ApiError(503, "unavailable", message)
|
||||
|
||||
|
||||
def internal_error() -> ApiError:
|
||||
"""Создаёт ошибку внутренней ошибки сервера."""
|
||||
return ApiError(500, "internal_error", "Внутренняя ошибка сервера")
|
||||
@@ -0,0 +1,171 @@
|
||||
import logging
|
||||
from collections.abc import Mapping
|
||||
from uuid import uuid4
|
||||
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse
|
||||
from sqlalchemy.exc import InterfaceError, OperationalError
|
||||
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from app.core.request_id import REQUEST_ID_HEADER
|
||||
from app.errors.exceptions import ApiError, internal_error, unavailable
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _get_request_id(request: Request) -> str:
|
||||
request_id = getattr(request.state, "request_id", None)
|
||||
|
||||
if request_id is None:
|
||||
request_id = str(uuid4())
|
||||
request.state.request_id = request_id
|
||||
|
||||
return request_id
|
||||
|
||||
|
||||
def _build_response(
|
||||
request: Request,
|
||||
status_code: int,
|
||||
code: str,
|
||||
message: str,
|
||||
headers: Mapping[str, str] | None = None,
|
||||
) -> JSONResponse:
|
||||
request_id = _get_request_id(request)
|
||||
|
||||
response_headers = {
|
||||
**(headers or {}),
|
||||
REQUEST_ID_HEADER: request_id,
|
||||
}
|
||||
|
||||
body = {
|
||||
"error": {
|
||||
"code": code,
|
||||
"message": message,
|
||||
"request_id": request_id,
|
||||
}
|
||||
}
|
||||
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content=body,
|
||||
headers=response_headers,
|
||||
)
|
||||
|
||||
|
||||
async def api_error_handler(
|
||||
request: Request,
|
||||
exc: Exception,
|
||||
) -> JSONResponse:
|
||||
assert isinstance(exc, ApiError)
|
||||
|
||||
return _build_response(
|
||||
request,
|
||||
exc.status_code,
|
||||
exc.code,
|
||||
exc.message,
|
||||
exc.headers,
|
||||
)
|
||||
|
||||
|
||||
async def routing_error_handler(
|
||||
request: Request,
|
||||
exc: Exception,
|
||||
) -> JSONResponse:
|
||||
assert isinstance(exc, StarletteHTTPException)
|
||||
|
||||
if exc.status_code == 404:
|
||||
return _build_response(
|
||||
request,
|
||||
404,
|
||||
"not_found",
|
||||
"Объект не найден",
|
||||
exc.headers,
|
||||
)
|
||||
|
||||
return _build_response(
|
||||
request,
|
||||
exc.status_code,
|
||||
"invalid_request",
|
||||
"Неверный запрос",
|
||||
exc.headers,
|
||||
)
|
||||
|
||||
|
||||
async def validation_error_handler(
|
||||
request: Request,
|
||||
exc: Exception,
|
||||
) -> JSONResponse:
|
||||
assert isinstance(exc, RequestValidationError)
|
||||
|
||||
fields = sorted({".".join(map(str, error["loc"])) for error in exc.errors()})
|
||||
message = "Неверный запрос"
|
||||
|
||||
if fields:
|
||||
message = f"{message}: {', '.join(fields)}"
|
||||
|
||||
return _build_response(
|
||||
request,
|
||||
400,
|
||||
"invalid_request",
|
||||
message,
|
||||
)
|
||||
|
||||
|
||||
async def database_unavailable_handler(
|
||||
request: Request,
|
||||
exc: Exception,
|
||||
) -> JSONResponse:
|
||||
"""БД недоступна, оборвалась или исчерпан пул -> ограниченный 503.
|
||||
|
||||
Детали (хост, SQL, credentials) пишем только в лог, клиенту — общий текст.
|
||||
"""
|
||||
request_id = _get_request_id(request)
|
||||
logger.error(
|
||||
"Database unavailable request_id=%s: %s",
|
||||
request_id,
|
||||
type(exc).__name__,
|
||||
exc_info=exc,
|
||||
)
|
||||
|
||||
error = unavailable()
|
||||
return _build_response(
|
||||
request,
|
||||
error.status_code,
|
||||
error.code,
|
||||
error.message,
|
||||
{"Retry-After": "1"},
|
||||
)
|
||||
|
||||
|
||||
async def unhandled_error_handler(
|
||||
request: Request,
|
||||
exc: Exception,
|
||||
) -> JSONResponse:
|
||||
request_id = _get_request_id(request)
|
||||
|
||||
logger.error(
|
||||
"Unhandled error request_id=%s",
|
||||
request_id,
|
||||
exc_info=exc,
|
||||
)
|
||||
|
||||
error = internal_error()
|
||||
|
||||
return _build_response(
|
||||
request,
|
||||
error.status_code,
|
||||
error.code,
|
||||
error.message,
|
||||
)
|
||||
|
||||
|
||||
def register_exception_handlers(app: FastAPI) -> None:
|
||||
app.add_exception_handler(ApiError, api_error_handler)
|
||||
app.add_exception_handler(StarletteHTTPException, routing_error_handler)
|
||||
app.add_exception_handler(RequestValidationError, validation_error_handler)
|
||||
app.add_exception_handler(OperationalError, database_unavailable_handler)
|
||||
app.add_exception_handler(InterfaceError, database_unavailable_handler)
|
||||
app.add_exception_handler(PoolTimeoutError, database_unavailable_handler)
|
||||
app.add_exception_handler(Exception, unhandled_error_handler)
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
import logging
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
import uvicorn
|
||||
from fastapi import Depends, FastAPI
|
||||
|
||||
from app.core.config import Settings
|
||||
from app.core.database import create_db_engine, create_session_factory
|
||||
from app.core.request_capacity import acquire_request_slot, create_request_capacity
|
||||
from app.core.request_id import RequestIdMiddleware
|
||||
from app.endpoints.auth import router as auth_router
|
||||
from app.endpoints.chats import router as chats_router
|
||||
from app.endpoints.health import router as health_router
|
||||
from app.endpoints.messages import router as messages_router
|
||||
from app.endpoints.users import router as users_router
|
||||
from app.errors.handlers import register_exception_handlers
|
||||
|
||||
|
||||
def configure_logging(settings: Settings) -> None:
|
||||
logging.basicConfig(
|
||||
level=settings.log_level,
|
||||
format="%(asctime)s %(levelname)s %(name)s %(message)s",
|
||||
)
|
||||
|
||||
|
||||
def create_app(settings: Settings | None = None) -> FastAPI:
|
||||
settings = settings or Settings() # type: ignore
|
||||
configure_logging(settings)
|
||||
|
||||
engine = create_db_engine(settings)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_: FastAPI) -> AsyncIterator[None]:
|
||||
yield
|
||||
engine.dispose()
|
||||
|
||||
application = FastAPI(title="Messenger", version="1.3.0", lifespan=lifespan)
|
||||
|
||||
application.state.settings = settings
|
||||
application.state.engine = engine
|
||||
application.state.session_factory = create_session_factory(engine)
|
||||
application.state.request_capacity = create_request_capacity(settings.max_in_flight)
|
||||
|
||||
application.add_middleware(RequestIdMiddleware)
|
||||
register_exception_handlers(application)
|
||||
|
||||
limited = [Depends(acquire_request_slot)]
|
||||
application.include_router(health_router)
|
||||
application.include_router(users_router, dependencies=limited)
|
||||
application.include_router(auth_router, dependencies=limited)
|
||||
application.include_router(chats_router, dependencies=limited)
|
||||
application.include_router(messages_router, dependencies=limited)
|
||||
|
||||
return application
|
||||
|
||||
|
||||
def main() -> None:
|
||||
settings = Settings() # type: ignore
|
||||
uvicorn.run(
|
||||
"app.main:create_app",
|
||||
factory=True,
|
||||
host=settings.app_host,
|
||||
port=settings.app_port,
|
||||
log_level=settings.log_level.lower(),
|
||||
timeout_graceful_shutdown=5,
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,11 @@
|
||||
"""Импорт всех моделей нужен, чтобы Base.metadata знала обо всех таблицах
|
||||
(create_all в тестах, autogenerate в Alembic)."""
|
||||
|
||||
from app.models.base import Base
|
||||
from app.models.chat import Chat
|
||||
from app.models.chat_member import ChatMember
|
||||
from app.models.message import Message
|
||||
from app.models.session import UserSession
|
||||
from app.models.user import User
|
||||
|
||||
__all__ = ["Base", "User", "Chat", "ChatMember", "Message", "UserSession"]
|
||||
@@ -0,0 +1,26 @@
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import DateTime, MetaData
|
||||
from sqlalchemy.dialects.postgresql import UUID as PG_UUID
|
||||
from sqlalchemy.orm import DeclarativeBase
|
||||
|
||||
NAMING_CONVENTION = {
|
||||
"ix": "ix_%(column_0_label)s",
|
||||
"uq": "uq_%(table_name)s_%(column_0_name)s",
|
||||
"ck": "ck_%(table_name)s_%(constraint_name)s",
|
||||
"fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
|
||||
"pk": "pk_%(table_name)s",
|
||||
}
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
"""Общий базовый класс всех ORM-моделей."""
|
||||
|
||||
metadata = MetaData(naming_convention=NAMING_CONVENTION)
|
||||
|
||||
# Python-типы в Mapped[...] -> типы PostgreSQL.
|
||||
type_annotation_map = {
|
||||
uuid.UUID: PG_UUID(as_uuid=True),
|
||||
datetime: DateTime(timezone=True), # всегда timestamptz, время в UTC
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.models.base import Base
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
"""Таблица chats.
|
||||
|
||||
TODO:
|
||||
* title: str(100), NOT NULL
|
||||
* created_at: datetime(timezone), NOT NULL, server_default=now()
|
||||
* relationship members -> ChatMember (cascade="all, delete-orphan"),
|
||||
lazy="selectin": чтобы получать member_ids без N+1 запросов
|
||||
* индекс для GET /chats: см. storage.chats.list_chats_for_user
|
||||
(подумайте, по каким колонкам идёт сортировка и фильтр по участнику)
|
||||
"""
|
||||
|
||||
__tablename__ = "chats"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
||||
@@ -0,0 +1,22 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.models.base import Base
|
||||
|
||||
|
||||
class ChatMember(Base):
|
||||
"""Таблица chat_members — членство пользователя в чате (many-to-many).
|
||||
|
||||
TODO:
|
||||
* chat_id: ForeignKey("chats.id", ondelete="CASCADE")
|
||||
* user_id: ForeignKey("users.id")
|
||||
* составной PRIMARY KEY (chat_id, user_id) — он же гарантирует отсутствие дублей
|
||||
* индекс по user_id: нужен для «все чаты пользователя»
|
||||
(PK (chat_id, user_id) этот запрос не ускоряет — объясните почему)
|
||||
"""
|
||||
|
||||
__tablename__ = "chat_members"
|
||||
|
||||
chat_id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
|
||||
@@ -0,0 +1,24 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.models.base import Base
|
||||
|
||||
|
||||
class Message(Base):
|
||||
"""Таблица messages.
|
||||
|
||||
TODO:
|
||||
* chat_id: ForeignKey("chats.id"), NOT NULL
|
||||
* sender_id: ForeignKey("users.id"), NOT NULL
|
||||
* text: Text, NOT NULL, CHECK (char_length(text) BETWEEN 1 AND 4000)
|
||||
* created_at: datetime(timezone), NOT NULL, server_default=clock_timestamp()
|
||||
(now() внутри одной транзакции постоянен — выберите осознанно)
|
||||
* ИНДЕКС ИСТОРИИ: (chat_id, created_at, id) — ровно под keyset-запрос
|
||||
WHERE chat_id = :c AND (created_at, id) > (:t, :i) ORDER BY created_at, id LIMIT :n
|
||||
Для уровня 4 потребуется EXPLAIN (ANALYZE, BUFFERS) на >= 10 000 сообщений.
|
||||
"""
|
||||
|
||||
__tablename__ = "messages"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
||||
@@ -0,0 +1,23 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.models.base import Base
|
||||
|
||||
|
||||
class UserSession(Base):
|
||||
"""Таблица sessions (класс назван UserSession, чтобы не путать с sqlalchemy Session).
|
||||
|
||||
TODO:
|
||||
* token_hash: str(64), NOT NULL, UNIQUE — sha256(token); сам токен не хранится
|
||||
* user_id: ForeignKey("users.id", ondelete="CASCADE"), NOT NULL
|
||||
* created_at: datetime(timezone), NOT NULL, server_default=now()
|
||||
* expires_at: datetime(timezone), NOT NULL
|
||||
* revoked_at: datetime(timezone), NULL — заполняется при logout
|
||||
* индекс по expires_at — для фоновой очистки просроченных сессий
|
||||
Сессия «действует», если revoked_at IS NULL AND expires_at > now().
|
||||
"""
|
||||
|
||||
__tablename__ = "sessions"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
||||
@@ -0,0 +1,21 @@
|
||||
import uuid
|
||||
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from app.models.base import Base
|
||||
|
||||
|
||||
class User(Base):
|
||||
"""Таблица users.
|
||||
|
||||
TODO (колонки и ограничения — ваша работа, до написания запросов):
|
||||
* username: str, UNIQUE, NOT NULL; CHECK по regex ^[a-z0-9_]{3,32}$ (по желанию)
|
||||
* display_name: str(100), NOT NULL
|
||||
* password_hash: str, NOT NULL (PHC-строка Argon2id; в API никогда не отдаётся)
|
||||
* created_at: datetime(timezone), NOT NULL, server_default=now()
|
||||
Отношения (relationship) добавляйте по необходимости.
|
||||
"""
|
||||
|
||||
__tablename__ = "users"
|
||||
|
||||
id: Mapped[uuid.UUID] = mapped_column(primary_key=True, default=uuid.uuid4)
|
||||
@@ -0,0 +1,6 @@
|
||||
from app.schemas.chat import Chat
|
||||
from app.schemas.message import Message
|
||||
from app.schemas.session import AuthSession
|
||||
from app.schemas.user import User
|
||||
|
||||
__all__ = ["User", "Chat", "Message", "AuthSession"]
|
||||
@@ -0,0 +1,37 @@
|
||||
from typing import ClassVar, Literal
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, ValidationInfo, field_validator
|
||||
|
||||
|
||||
class Base(BaseModel):
|
||||
# from_attributes: схемы можно собирать прямо из ORM-объектов.
|
||||
model_config = ConfigDict(extra="forbid", from_attributes=True)
|
||||
|
||||
id: UUID
|
||||
|
||||
|
||||
class Health(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
status: Literal["ok"]
|
||||
|
||||
|
||||
class BaseCreate(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
# Поля, где пробелы допустимы: пароль состоит из любых 12-128 code points.
|
||||
blank_allowed_fields: ClassVar[frozenset[str]] = frozenset({"password"})
|
||||
|
||||
@field_validator("*", mode="before")
|
||||
@classmethod
|
||||
def reject_blank_strings(cls, value: object, info: ValidationInfo) -> object:
|
||||
if info.field_name in cls.blank_allowed_fields:
|
||||
return value
|
||||
if isinstance(value, str) and not value.strip():
|
||||
raise ValueError("Строка не может состоять только из пробелов")
|
||||
return value
|
||||
|
||||
|
||||
class BasePage(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
@@ -0,0 +1,21 @@
|
||||
from uuid import UUID
|
||||
from datetime import datetime
|
||||
from pydantic import Field
|
||||
|
||||
from app.schemas.base import Base, BaseCreate, BasePage
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: list[UUID] = Field(min_length=1, max_length=100)
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class CreateChat(BaseCreate):
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: list[UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class ChatPage(BasePage):
|
||||
items: list[Chat]
|
||||
next_cursor: str | None
|
||||
@@ -0,0 +1,21 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
from pydantic import Field
|
||||
|
||||
from app.schemas.base import Base, BaseCreate, BasePage
|
||||
|
||||
|
||||
class Message(Base):
|
||||
chat_id: UUID
|
||||
sender_id: UUID
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class CreateMessage(BaseCreate):
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
|
||||
class MessagePage(BasePage):
|
||||
items: list[Message]
|
||||
next_cursor: str | None
|
||||
@@ -0,0 +1,17 @@
|
||||
from datetime import datetime
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
from app.schemas.user import User
|
||||
|
||||
|
||||
class AuthSession(BaseModel):
|
||||
"""Ответ POST /auth/sessions (в OpenAPI — Session)."""
|
||||
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
token: str = Field(min_length=32)
|
||||
token_type: Literal["Bearer"] = "Bearer"
|
||||
expires_at: datetime
|
||||
user: User
|
||||
@@ -0,0 +1,20 @@
|
||||
from datetime import datetime
|
||||
|
||||
from pydantic import Field
|
||||
|
||||
from app.schemas.base import Base, BaseCreate
|
||||
|
||||
|
||||
class User(Base):
|
||||
"""Публичное представление пользователя. Пароль/хеш сюда не попадают никогда."""
|
||||
|
||||
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
created_at: datetime
|
||||
|
||||
|
||||
class CreateUser(BaseCreate):
|
||||
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
# 12-128 Unicode code points (pydantic считает именно code points).
|
||||
password: str = Field(min_length=12, max_length=128, repr=False)
|
||||
@@ -0,0 +1,10 @@
|
||||
"""Слой доступа к данным (CRUD) — по файлу на сущность.
|
||||
|
||||
Правила слоя:
|
||||
* функции принимают открытую sqlalchemy Session первым аргументом;
|
||||
* возвращают ORM-объекты (или None), но НЕ HTTP-ошибки: решать, что значит
|
||||
«не найдено» (404) или «занято» (409), — задача domain;
|
||||
* НЕ вызывают session.commit()/rollback(): границу транзакции задаёт domain;
|
||||
максимум — session.flush(), чтобы получить ошибки ограничений сразу;
|
||||
* только параметризованные запросы через ORM / sqlalchemy.select (никакого f-string SQL).
|
||||
"""
|
||||
@@ -0,0 +1,51 @@
|
||||
from collections.abc import Sequence
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.models.chat import Chat
|
||||
from app.storage.types import Position
|
||||
|
||||
|
||||
def create_chat(
|
||||
session: Session,
|
||||
*,
|
||||
title: str,
|
||||
member_ids: Sequence[UUID],
|
||||
) -> Chat:
|
||||
"""INSERT chats + INSERT chat_members для каждого участника, затем flush().
|
||||
|
||||
Всё в одной транзакции domain: если упадёт вставка участника — откатится и чат
|
||||
(требование «составная операция создания чата выполняется атомарно»).
|
||||
Возвращённый Chat должен иметь доступные участники (chat.members).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def get_chat_for_member(
|
||||
session: Session,
|
||||
chat_id: UUID,
|
||||
user_id: UUID,
|
||||
) -> Chat | None:
|
||||
"""Чат, только если user_id — его участник; иначе None.
|
||||
|
||||
Один запрос (JOIN/EXISTS), а не «загрузить чат, потом проверить в Python».
|
||||
Для постороннего и для несуществующего чата результат одинаков (None -> 404),
|
||||
чтобы не раскрывать существование чужого чата.
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def list_chats_for_user(
|
||||
session: Session,
|
||||
user_id: UUID,
|
||||
after: Position | None,
|
||||
limit: int,
|
||||
) -> list[Chat]:
|
||||
"""Чаты пользователя по (created_at, id) по возрастанию, строго после `after`.
|
||||
|
||||
Keyset: WHERE (created_at, id) > (:t, :i) — sqlalchemy.tuple_(Chat.created_at, Chat.id) > after
|
||||
Вызывающий передаёт limit + 1, чтобы узнать, есть ли следующая страница.
|
||||
Участников грузите selectinload (без N+1).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,41 @@
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.models.message import Message
|
||||
from app.storage.types import Position
|
||||
|
||||
|
||||
def create_message(
|
||||
session: Session,
|
||||
*,
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
) -> Message:
|
||||
"""INSERT сообщения и flush(); id и created_at назначает сервер, не клиент."""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def list_messages(
|
||||
session: Session,
|
||||
chat_id: UUID,
|
||||
after: Position | None,
|
||||
limit: int,
|
||||
) -> list[Message]:
|
||||
"""Сообщения чата по (created_at, id) по возрастанию, строго после `after`.
|
||||
|
||||
Это keyset-запрос под индекс (chat_id, created_at, id): никакого OFFSET.
|
||||
Вызывающий передаёт limit + 1 (признак следующей страницы).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def count_messages(session: Session) -> int:
|
||||
"""Общее число сообщений — для лимита MAX_MESSAGES (503).
|
||||
|
||||
Решение для отчёта: SELECT count(*) честный, но O(n) на каждую отправку.
|
||||
Альтернативы: приблизительная оценка из pg_class.reltuples или отдельная
|
||||
таблица-счётчик, обновляемая в той же транзакции. Выберите и обоснуйте.
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,46 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.models.session import UserSession
|
||||
from app.models.user import User
|
||||
|
||||
|
||||
def create_session(
|
||||
session: Session,
|
||||
*,
|
||||
user_id: UUID,
|
||||
token_hash: str,
|
||||
expires_at: datetime,
|
||||
) -> UserSession:
|
||||
"""INSERT сессии (хранится только хеш токена) и flush()."""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def get_user_by_active_token_hash(
|
||||
session: Session,
|
||||
token_hash: str,
|
||||
now: datetime,
|
||||
) -> User | None:
|
||||
"""Пользователь по хешу токена, если сессия действует.
|
||||
|
||||
Действует: revoked_at IS NULL AND expires_at > now. Один запрос с JOIN users.
|
||||
Истёкший, отозванный и неизвестный токен неразличимы для вызывающего (None).
|
||||
`now` передаётся параметром (а не SQL now()), чтобы тесты могли управлять временем.
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def revoke_session(session: Session, token_hash: str, now: datetime) -> bool:
|
||||
"""Помечает действующую сессию отозванной (revoked_at = now).
|
||||
|
||||
True — отозвана, False — такой действующей сессии нет (повторный logout -> 401).
|
||||
Рекомендуется один атомарный UPDATE ... WHERE ... AND revoked_at IS NULL.
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def delete_expired_sessions(session: Session, now: datetime) -> int:
|
||||
"""(Необязательно) удаляет просроченные сессии, возвращает их число."""
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,5 @@
|
||||
from datetime import datetime
|
||||
from uuid import UUID
|
||||
|
||||
# Позиция в keyset-пагинации: (created_at, id) последнего виденного элемента.
|
||||
Position = tuple[datetime, UUID]
|
||||
@@ -0,0 +1,37 @@
|
||||
from collections.abc import Collection
|
||||
from uuid import UUID
|
||||
|
||||
from sqlalchemy.orm import Session
|
||||
|
||||
from app.models.user import User
|
||||
|
||||
|
||||
def create_user(
|
||||
session: Session,
|
||||
*,
|
||||
username: str,
|
||||
display_name: str,
|
||||
password_hash: str,
|
||||
) -> User:
|
||||
"""INSERT пользователя и session.flush().
|
||||
|
||||
Нарушение UNIQUE(username) поднимется здесь как sqlalchemy.exc.IntegrityError —
|
||||
перехватывает его domain.users.register_user и превращает в 409.
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def get_user_by_id(session: Session, user_id: UUID) -> User | None:
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def get_user_by_username(session: Session, username: str) -> User | None:
|
||||
raise NotImplementedError("TODO")
|
||||
|
||||
|
||||
def get_existing_user_ids(session: Session, user_ids: Collection[UUID]) -> set[UUID]:
|
||||
"""Какие из user_ids реально существуют — ОДНИМ запросом (WHERE id IN (...)).
|
||||
|
||||
Нужно для проверки member_ids при создании чата (без цикла из N запросов).
|
||||
"""
|
||||
raise NotImplementedError("TODO")
|
||||
@@ -0,0 +1,55 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.10-bookworm
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets:
|
||||
- postgres_password
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "127.0.0.1:5432:5432"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
command: ["alembic", "upgrade", "head"]
|
||||
env_file: .env
|
||||
secrets:
|
||||
- database_url
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
restart: unless-stopped
|
||||
env_file: .env
|
||||
secrets:
|
||||
- database_url
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,57 @@
|
||||
"""Alembic: online/offline миграции из метаданных ORM-моделей."""
|
||||
|
||||
from logging.config import fileConfig
|
||||
|
||||
from alembic import context
|
||||
from sqlalchemy import engine_from_config, pool
|
||||
|
||||
from app.core.config import Settings
|
||||
from app.models import Base
|
||||
|
||||
config = context.config
|
||||
|
||||
if config.config_file_name is not None:
|
||||
fileConfig(config.config_file_name, disable_existing_loggers=False)
|
||||
|
||||
target_metadata = Base.metadata
|
||||
|
||||
|
||||
def _database_url() -> str:
|
||||
explicit = config.get_main_option("sqlalchemy.url")
|
||||
if explicit:
|
||||
return explicit
|
||||
return Settings().get_database_url() # type: ignore
|
||||
|
||||
|
||||
def run_migrations_offline() -> None:
|
||||
context.configure(
|
||||
url=_database_url(),
|
||||
target_metadata=target_metadata,
|
||||
literal_binds=True,
|
||||
compare_type=True,
|
||||
)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
def run_migrations_online() -> None:
|
||||
section = config.get_section(config.config_ini_section, {})
|
||||
section["sqlalchemy.url"] = _database_url().replace("%", "%%")
|
||||
connectable = engine_from_config(
|
||||
section, prefix="sqlalchemy.", poolclass=pool.NullPool
|
||||
)
|
||||
|
||||
with connectable.connect() as connection:
|
||||
context.configure(
|
||||
connection=connection,
|
||||
target_metadata=target_metadata,
|
||||
compare_type=True,
|
||||
)
|
||||
with context.begin_transaction():
|
||||
context.run_migrations()
|
||||
|
||||
|
||||
if context.is_offline_mode():
|
||||
run_migrations_offline()
|
||||
else:
|
||||
run_migrations_online()
|
||||
@@ -0,0 +1,24 @@
|
||||
"""${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: str = ${repr(up_revision)}
|
||||
down_revision: Union[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:
|
||||
${upgrades if upgrades else "pass"}
|
||||
|
||||
|
||||
def downgrade() -> None:
|
||||
${downgrades if downgrades else "pass"}
|
||||
@@ -0,0 +1,3 @@
|
||||
[pytest]
|
||||
testpaths = tests
|
||||
python_files = test_*.py
|
||||
@@ -0,0 +1,43 @@
|
||||
alembic==1.20.0
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
attrs==26.1.0
|
||||
certifi==2026.7.22
|
||||
charset-normalizer==3.5.2
|
||||
click==8.5.0
|
||||
fastapi==0.143.3
|
||||
h11==0.16.0
|
||||
httpcore2==2.13.1
|
||||
httpx2==2.13.1
|
||||
idna==3.20
|
||||
iniconfig==2.3.1
|
||||
jsonschema==4.26.0
|
||||
jsonschema-path==0.3.4
|
||||
jsonschema-specifications==2025.9.1
|
||||
lazy-object-proxy==1.12.0
|
||||
Mako==1.4.3
|
||||
MarkupSafe==3.0.4
|
||||
openapi-schema-validator==0.6.3
|
||||
openapi-spec-validator==0.7.2
|
||||
opentelemetry-api==1.45.1
|
||||
packaging==26.3
|
||||
pathable==0.4.4
|
||||
pluggy==1.7.0
|
||||
pydantic==2.14.1
|
||||
pydantic_core==2.50.1
|
||||
Pygments==2.21.0
|
||||
pytest==9.1.1
|
||||
PyYAML==6.0.3
|
||||
referencing==0.36.2
|
||||
requests==2.34.2
|
||||
rfc3339-validator==0.1.4
|
||||
rpds-py==2026.9.1
|
||||
six==1.17.0
|
||||
SQLAlchemy==2.1.4
|
||||
starlette==1.8.0
|
||||
truststore==0.10.5
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
urllib3==2.8.0
|
||||
uvicorn==0.54.0
|
||||
Executable
+16
@@ -0,0 +1,16 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
mkdir -p secrets
|
||||
|
||||
if [ -f secrets/postgres_password ]; then
|
||||
echo "secrets/ уже существует — оставляю как есть"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
password="$(head -c 32 /dev/urandom | od -An -tx1 | tr -d ' \n')"
|
||||
printf '%s' "$password" > secrets/postgres_password
|
||||
printf 'postgresql+psycopg://messenger:%s@postgres:5432/messenger' "$password" > secrets/database_url
|
||||
|
||||
chmod 644 secrets/postgres_password secrets/database_url
|
||||
echo "OK: secrets/postgres_password и secrets/database_url созданы"
|
||||
Executable
+6
@@ -0,0 +1,6 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
docker compose restart postgres
|
||||
docker compose restart api
|
||||
@@ -0,0 +1,133 @@
|
||||
"""Фикстуры для тестов с РЕАЛЬНОЙ PostgreSQL (SQLite не подходит — см. README лабы).
|
||||
|
||||
Перед запуском поднимите БД и создайте тестовую базу:
|
||||
make db-up # docker compose up -d postgres + createdb messenger_test
|
||||
Переменные:
|
||||
TEST_DATABASE_URL по умолчанию postgresql+psycopg://messenger:messenger@localhost:5432/messenger_test
|
||||
TEST_USE_MIGRATIONS=1 строить схему через `alembic upgrade head` вместо Base.metadata.create_all
|
||||
"""
|
||||
|
||||
import os
|
||||
from collections.abc import Callable, Iterator
|
||||
|
||||
import pytest
|
||||
from alembic import command
|
||||
from alembic.config import Config
|
||||
from fastapi.testclient import TestClient
|
||||
from sqlalchemy import create_engine, text
|
||||
from sqlalchemy.engine import Engine
|
||||
|
||||
from app.core.config import Settings
|
||||
from app.main import create_app
|
||||
from app.models import Base
|
||||
|
||||
DEFAULT_TEST_DATABASE_URL = (
|
||||
"postgresql+psycopg://messenger:messenger@localhost:5432/messenger_test"
|
||||
)
|
||||
|
||||
|
||||
def _database_url() -> str:
|
||||
return os.environ.get("TEST_DATABASE_URL", DEFAULT_TEST_DATABASE_URL)
|
||||
|
||||
|
||||
def _alembic_config(url: str) -> Config:
|
||||
config = Config("alembic.ini")
|
||||
config.set_main_option("sqlalchemy.url", url.replace("%", "%%"))
|
||||
return config
|
||||
|
||||
|
||||
@pytest.fixture(scope="session")
|
||||
def database_url() -> str:
|
||||
return _database_url()
|
||||
|
||||
|
||||
@pytest.fixture(scope="session")
|
||||
def db_engine(database_url: str) -> Iterator[Engine]:
|
||||
engine = create_engine(database_url)
|
||||
try:
|
||||
with engine.connect() as connection:
|
||||
connection.execute(text("SELECT 1"))
|
||||
except Exception as error: # noqa: BLE001
|
||||
pytest.exit(
|
||||
f"PostgreSQL недоступна по {engine.url.render_as_string(hide_password=True)}: "
|
||||
f"{type(error).__name__}. Выполните `make db-up`.",
|
||||
returncode=2,
|
||||
)
|
||||
|
||||
# Чистая схема на старте сессии: тесты не зависят от прошлых запусков.
|
||||
Base.metadata.drop_all(engine)
|
||||
with engine.begin() as connection:
|
||||
connection.execute(text("DROP TABLE IF EXISTS alembic_version"))
|
||||
|
||||
if os.environ.get("TEST_USE_MIGRATIONS") == "1":
|
||||
command.upgrade(_alembic_config(database_url), "head")
|
||||
else:
|
||||
Base.metadata.create_all(engine)
|
||||
|
||||
yield engine
|
||||
engine.dispose()
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def clean_db(db_engine: Engine) -> Iterator[None]:
|
||||
"""Пустые таблицы перед каждым тестом (приложение коммитит, откат не годится)."""
|
||||
names = ", ".join(f'"{table.name}"' for table in Base.metadata.sorted_tables)
|
||||
if names:
|
||||
with db_engine.begin() as connection:
|
||||
connection.execute(text(f"TRUNCATE {names} RESTART IDENTITY CASCADE"))
|
||||
yield
|
||||
|
||||
|
||||
def build_settings(database_url: str, **overrides: object) -> Settings:
|
||||
values: dict[str, object] = {
|
||||
"app_host": "127.0.0.1",
|
||||
"app_port": 8080,
|
||||
"app_env": "test",
|
||||
"max_messages": 1000,
|
||||
"max_in_flight": 32,
|
||||
"log_level": "CRITICAL",
|
||||
"database_url": database_url,
|
||||
"session_ttl_seconds": 300,
|
||||
"db_pool_size": 10,
|
||||
"db_max_overflow": 10,
|
||||
}
|
||||
values.update(overrides)
|
||||
return Settings(_env_file=None, **values) # type: ignore[arg-type]
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def settings(database_url: str) -> Settings:
|
||||
return build_settings(database_url)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def make_settings(database_url: str) -> Callable[..., Settings]:
|
||||
"""Settings с переопределениями: make_settings(session_ttl_seconds=1)."""
|
||||
|
||||
def factory(**overrides: object) -> Settings:
|
||||
return build_settings(database_url, **overrides)
|
||||
|
||||
return factory
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def app(settings: Settings):
|
||||
application = create_app(settings)
|
||||
|
||||
@application.get("/__test__/explode", include_in_schema=False)
|
||||
def explode() -> None:
|
||||
raise RuntimeError("test-secret")
|
||||
|
||||
return application
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client(app) -> Iterator[TestClient]:
|
||||
with TestClient(app) as test_client:
|
||||
yield test_client
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def client_no_raise(app) -> Iterator[TestClient]:
|
||||
with TestClient(app, raise_server_exceptions=False) as test_client:
|
||||
yield test_client
|
||||
@@ -0,0 +1,81 @@
|
||||
import base64
|
||||
from uuid import uuid4
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
PASSWORD = "Correct-horse-battery-1" # синтетический пароль, только для тестов
|
||||
|
||||
|
||||
def basic_header(username: str, password: str) -> dict[str, str]:
|
||||
raw = f"{username}:{password}".encode()
|
||||
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
|
||||
|
||||
|
||||
def bearer(actor: dict) -> dict[str, str]:
|
||||
return {"Authorization": "Bearer " + actor["token"]}
|
||||
|
||||
|
||||
def register(
|
||||
client: TestClient,
|
||||
username: str | None = None,
|
||||
display_name: str = "Тестовый пользователь",
|
||||
password: str = PASSWORD,
|
||||
) -> dict:
|
||||
"""Регистрация без входа. Возвращает User + password (нужен для login)."""
|
||||
actual_username = username or "user_" + uuid4().hex[:12]
|
||||
response = client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": actual_username,
|
||||
"display_name": display_name,
|
||||
"password": password,
|
||||
},
|
||||
)
|
||||
assert response.status_code == 201, response.text
|
||||
return {**response.json(), "password": password}
|
||||
|
||||
|
||||
def login(client: TestClient, user: dict) -> dict:
|
||||
response = client.post(
|
||||
"/api/v1/auth/sessions",
|
||||
headers=basic_header(user["username"], user["password"]),
|
||||
)
|
||||
assert response.status_code == 201, response.text
|
||||
return {**user, "token": response.json()["token"]}
|
||||
|
||||
|
||||
def create_user(client: TestClient, **kwargs) -> dict:
|
||||
"""Регистрация + вход: актор с полями id, username, token, ..."""
|
||||
return login(client, register(client, **kwargs))
|
||||
|
||||
|
||||
def create_chat(
|
||||
client: TestClient,
|
||||
user: dict,
|
||||
*members: dict,
|
||||
title: str = "Тестовый чат",
|
||||
) -> dict:
|
||||
member_ids = [user["id"], *(member["id"] for member in members)]
|
||||
response = client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(user),
|
||||
json={"title": title, "member_ids": member_ids},
|
||||
)
|
||||
assert response.status_code == 201, response.text
|
||||
return response.json()
|
||||
|
||||
|
||||
def send_message(client: TestClient, user: dict, chat: dict, text: str):
|
||||
return client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers=bearer(user),
|
||||
json={"text": text},
|
||||
)
|
||||
|
||||
|
||||
def assert_request_id(response) -> str:
|
||||
header_id = response.headers.get("X-Request-Id")
|
||||
assert header_id
|
||||
if response.status_code >= 400:
|
||||
assert response.json()["error"]["request_id"] == header_id
|
||||
return header_id
|
||||
@@ -0,0 +1,175 @@
|
||||
import time
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.main import create_app
|
||||
from tests.helpers import (
|
||||
PASSWORD,
|
||||
assert_request_id,
|
||||
basic_header,
|
||||
bearer,
|
||||
create_user,
|
||||
login,
|
||||
register,
|
||||
)
|
||||
|
||||
|
||||
def test_login_returns_opaque_bearer_session(client: TestClient):
|
||||
user = register(client)
|
||||
|
||||
response = client.post(
|
||||
"/api/v1/auth/sessions",
|
||||
headers=basic_header(user["username"], user["password"]),
|
||||
)
|
||||
|
||||
assert response.status_code == 201
|
||||
body = response.json()
|
||||
assert set(body) == {"token", "token_type", "expires_at", "user"}
|
||||
assert body["token_type"] == "Bearer"
|
||||
assert len(body["token"]) >= 43 # 256 бит в base64url
|
||||
assert body["token"] not in (user["id"], user["username"])
|
||||
assert body["user"]["id"] == user["id"]
|
||||
assert body["expires_at"].endswith("Z")
|
||||
assert datetime.fromisoformat(body["expires_at"].replace("Z", "+00:00"))
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_each_login_issues_a_different_token(client: TestClient):
|
||||
user = register(client)
|
||||
first = login(client, user)
|
||||
second = login(client, user)
|
||||
|
||||
assert first["token"] != second["token"]
|
||||
|
||||
|
||||
def test_password_with_colon_works(client: TestClient):
|
||||
user = register(client, password="pass:with:colons-123")
|
||||
|
||||
assert login(client, user)["token"]
|
||||
|
||||
|
||||
def test_unicode_password_works(client: TestClient):
|
||||
user = register(client, password="Пароль-с-юникодом-🔑-123")
|
||||
|
||||
assert login(client, user)["token"]
|
||||
|
||||
|
||||
def test_wrong_password_and_unknown_user_look_identical(client: TestClient):
|
||||
user = register(client)
|
||||
|
||||
wrong_password = client.post(
|
||||
"/api/v1/auth/sessions",
|
||||
headers=basic_header(user["username"], "wrong-password-123"),
|
||||
)
|
||||
unknown_user = client.post(
|
||||
"/api/v1/auth/sessions",
|
||||
headers=basic_header("no_such_user", "wrong-password-123"),
|
||||
)
|
||||
|
||||
for response in (wrong_password, unknown_user):
|
||||
assert response.status_code == 401
|
||||
assert response.json()["error"]["code"] == "unauthorized"
|
||||
assert response.headers["WWW-Authenticate"].startswith('Basic realm="messenger"')
|
||||
assert_request_id(response)
|
||||
assert wrong_password.json()["error"]["message"] == unknown_user.json()["error"]["message"]
|
||||
|
||||
|
||||
def test_login_requires_basic_scheme(client: TestClient):
|
||||
user = register(client)
|
||||
session = login(client, user)
|
||||
|
||||
for headers in ({}, bearer(session), {"Authorization": "Basic !!!not-base64"}):
|
||||
response = client.post("/api/v1/auth/sessions", headers=headers)
|
||||
assert response.status_code == 401
|
||||
assert response.headers["WWW-Authenticate"].startswith("Basic")
|
||||
|
||||
|
||||
def test_business_endpoints_require_bearer(client: TestClient):
|
||||
user = register(client)
|
||||
|
||||
for headers in (
|
||||
{},
|
||||
basic_header(user["username"], user["password"]),
|
||||
{"Authorization": "Bearer "},
|
||||
{"Authorization": "Bearer unknown-token-value"},
|
||||
{"X-User-Id": user["id"]},
|
||||
):
|
||||
response = client.get("/api/v1/users/me", headers=headers)
|
||||
assert response.status_code == 401, headers
|
||||
assert response.json()["error"]["code"] == "unauthorized"
|
||||
assert response.headers["WWW-Authenticate"].startswith('Bearer realm="messenger"')
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_x_user_id_cannot_override_bearer_identity(client: TestClient):
|
||||
alice = create_user(client)
|
||||
eve = create_user(client)
|
||||
|
||||
response = client.get(
|
||||
"/api/v1/users/me",
|
||||
headers={**bearer(alice), "X-User-Id": eve["id"]},
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json()["id"] == alice["id"]
|
||||
|
||||
|
||||
def test_logout_revokes_only_current_session(client: TestClient):
|
||||
user = register(client)
|
||||
first = login(client, user)
|
||||
second = login(client, user)
|
||||
|
||||
assert client.delete("/api/v1/auth/sessions/current", headers=bearer(first)).status_code == 204
|
||||
|
||||
assert client.get("/api/v1/users/me", headers=bearer(first)).status_code == 401
|
||||
assert client.get("/api/v1/users/me", headers=bearer(second)).status_code == 200
|
||||
|
||||
|
||||
def test_logout_twice_returns_401(client: TestClient):
|
||||
session = create_user(client)
|
||||
|
||||
first = client.delete("/api/v1/auth/sessions/current", headers=bearer(session))
|
||||
again = client.delete("/api/v1/auth/sessions/current", headers=bearer(session))
|
||||
|
||||
assert first.status_code == 204
|
||||
assert first.content == b""
|
||||
assert again.status_code == 401
|
||||
|
||||
|
||||
def test_session_expires_after_ttl(make_settings):
|
||||
app = create_app(make_settings(session_ttl_seconds=2))
|
||||
with TestClient(app) as client:
|
||||
session = create_user(client)
|
||||
assert client.get("/api/v1/users/me", headers=bearer(session)).status_code == 200
|
||||
|
||||
time.sleep(3)
|
||||
|
||||
response = client.get("/api/v1/users/me", headers=bearer(session))
|
||||
assert response.status_code == 401
|
||||
assert response.headers["WWW-Authenticate"].startswith("Bearer")
|
||||
|
||||
|
||||
def test_token_is_not_stored_in_plaintext(client: TestClient, db_engine):
|
||||
from sqlalchemy import text
|
||||
|
||||
session = create_user(client)
|
||||
|
||||
with db_engine.connect() as connection:
|
||||
stored = connection.execute(text("SELECT token_hash FROM sessions")).scalars().all()
|
||||
|
||||
assert stored and session["token"] not in stored
|
||||
|
||||
|
||||
def test_password_is_not_stored_in_plaintext(client: TestClient, db_engine):
|
||||
from sqlalchemy import text
|
||||
|
||||
register(client, username="hash_check")
|
||||
|
||||
with db_engine.connect() as connection:
|
||||
stored = connection.execute(
|
||||
text("SELECT password_hash FROM users WHERE username = 'hash_check'")
|
||||
).scalar_one()
|
||||
|
||||
assert PASSWORD not in stored
|
||||
assert stored.startswith("$argon2id$")
|
||||
@@ -0,0 +1,185 @@
|
||||
from urllib.parse import quote
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from tests.helpers import assert_request_id, bearer, create_chat, create_user
|
||||
|
||||
|
||||
def test_create_and_get_chat(client: TestClient):
|
||||
alice = create_user(client)
|
||||
bob = create_user(client)
|
||||
chat = create_chat(client, alice, bob)
|
||||
|
||||
response = client.get(
|
||||
f"/api/v1/chats/{chat['id']}",
|
||||
headers=bearer(bob),
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json() == chat
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_chat_is_not_visible_to_outsider(client: TestClient):
|
||||
alice = create_user(client)
|
||||
bob = create_user(client)
|
||||
eve = create_user(client)
|
||||
chat = create_chat(client, alice, bob)
|
||||
|
||||
response = client.get(
|
||||
f"/api/v1/chats/{chat['id']}",
|
||||
headers=bearer(eve),
|
||||
)
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_chat_creation_requires_creator_in_members(client: TestClient):
|
||||
alice = create_user(client)
|
||||
bob = create_user(client)
|
||||
|
||||
response = client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
json={"title": "Чат", "member_ids": [bob["id"]]},
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"payload",
|
||||
[
|
||||
{"title": "", "member_ids": []},
|
||||
{"title": " ", "member_ids": []},
|
||||
],
|
||||
)
|
||||
def test_chat_payload_boundaries(client: TestClient, payload: dict):
|
||||
alice = create_user(client)
|
||||
payload["member_ids"] = [alice["id"]]
|
||||
|
||||
response = client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
json=payload,
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
|
||||
def test_duplicate_members_are_rejected(client: TestClient):
|
||||
alice = create_user(client)
|
||||
bob = create_user(client)
|
||||
|
||||
response = client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
json={"title": "Чат", "member_ids": [alice["id"], bob["id"], bob["id"]]},
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
|
||||
def test_unknown_member_is_rejected(client: TestClient):
|
||||
alice = create_user(client)
|
||||
|
||||
response = client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
json={"title": "Чат", "member_ids": [alice["id"], str(uuid4())]},
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
|
||||
def test_chat_exact_title_limit_is_accepted(client: TestClient):
|
||||
alice = create_user(client)
|
||||
response = client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
json={"title": "x" * 100, "member_ids": [alice["id"]]},
|
||||
)
|
||||
|
||||
assert response.status_code == 201
|
||||
assert len(response.json()["title"]) == 100
|
||||
|
||||
|
||||
def test_chat_list_hides_chats_without_membership(client: TestClient):
|
||||
alice = create_user(client)
|
||||
bob = create_user(client)
|
||||
chat_for_bob = create_chat(client, bob, title="Only Bob")
|
||||
chat_for_alice = create_chat(client, alice, title="Only Alice")
|
||||
|
||||
response = client.get(
|
||||
"/api/v1/chats?limit=100",
|
||||
headers=bearer(alice),
|
||||
)
|
||||
|
||||
assert response.status_code == 200
|
||||
ids = {item["id"] for item in response.json()["items"]}
|
||||
assert chat_for_alice["id"] in ids
|
||||
assert chat_for_bob["id"] not in ids
|
||||
|
||||
|
||||
def test_nonexistent_chat_returns_404(client: TestClient):
|
||||
alice = create_user(client)
|
||||
|
||||
response = client.get(
|
||||
"/api/v1/chats/00000000-0000-4000-8000-000000000000",
|
||||
headers=bearer(alice),
|
||||
)
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_failed_chat_creation_leaves_no_partial_data(client: TestClient, db_engine):
|
||||
"""Атомарность: неизвестный участник -> нет ни чата, ни записей членства."""
|
||||
from sqlalchemy import text
|
||||
|
||||
alice = create_user(client)
|
||||
response = client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
json={"title": "Чат", "member_ids": [alice["id"], str(uuid4())]},
|
||||
)
|
||||
assert response.status_code == 400
|
||||
|
||||
with db_engine.connect() as connection:
|
||||
assert connection.execute(text("SELECT count(*) FROM chats")).scalar_one() == 0
|
||||
assert (
|
||||
connection.execute(text("SELECT count(*) FROM chat_members")).scalar_one() == 0
|
||||
)
|
||||
|
||||
|
||||
def test_chat_list_pagination_and_order(client: TestClient):
|
||||
alice = create_user(client)
|
||||
chats = [create_chat(client, alice, title=f"chat-{i}") for i in range(5)]
|
||||
|
||||
page1 = client.get("/api/v1/chats?limit=2", headers=bearer(alice)).json()
|
||||
page2 = client.get(
|
||||
f"/api/v1/chats?limit=2&cursor={quote(page1['next_cursor'], safe='')}",
|
||||
headers=bearer(alice),
|
||||
).json()
|
||||
page3 = client.get(
|
||||
f"/api/v1/chats?limit=2&cursor={quote(page2['next_cursor'], safe='')}",
|
||||
headers=bearer(alice),
|
||||
).json()
|
||||
|
||||
ids = [c["id"] for page in (page1, page2, page3) for c in page["items"]]
|
||||
assert ids == [c["id"] for c in chats]
|
||||
assert page3["next_cursor"] is None
|
||||
|
||||
|
||||
def test_chat_endpoints_require_bearer(client: TestClient):
|
||||
assert client.get("/api/v1/chats").status_code == 401
|
||||
assert client.post("/api/v1/chats", json={"title": "x", "member_ids": []}).status_code in (401, 400)
|
||||
@@ -0,0 +1,132 @@
|
||||
"""Конкурентность на реальной БД: гонка регистрации и параллельная запись."""
|
||||
|
||||
import asyncio
|
||||
from collections import Counter
|
||||
from uuid import uuid4
|
||||
|
||||
import httpx
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.main import create_app
|
||||
from tests.helpers import PASSWORD, bearer, create_chat, create_user
|
||||
|
||||
|
||||
def test_parallel_registration_of_same_username_creates_exactly_one_user(make_settings):
|
||||
"""Источник истины для уникальности — UNIQUE в БД, а не проверка «SELECT, потом INSERT»."""
|
||||
app = create_app(make_settings(max_in_flight=64, db_pool_size=20, db_max_overflow=20))
|
||||
|
||||
async def scenario() -> list[int]:
|
||||
async with httpx.AsyncClient(
|
||||
transport=httpx.ASGITransport(app=app),
|
||||
base_url="http://testserver",
|
||||
timeout=30,
|
||||
) as client:
|
||||
responses = await asyncio.gather(
|
||||
*(
|
||||
client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": "race_user",
|
||||
"display_name": "Race",
|
||||
"password": PASSWORD,
|
||||
},
|
||||
)
|
||||
for _ in range(16)
|
||||
)
|
||||
)
|
||||
return [response.status_code for response in responses]
|
||||
|
||||
statuses = Counter(asyncio.run(scenario()))
|
||||
|
||||
assert statuses == Counter({201: 1, 409: 15}), statuses # ни одного 500
|
||||
|
||||
|
||||
def test_100_messages_from_10_clients(make_settings):
|
||||
app = create_app(
|
||||
make_settings(
|
||||
max_messages=1000, max_in_flight=100, db_pool_size=20, db_max_overflow=20
|
||||
)
|
||||
)
|
||||
|
||||
with TestClient(app) as setup:
|
||||
users = [create_user(setup, username=f"load_{i}_{uuid4().hex[:6]}") for i in range(10)]
|
||||
chat = setup.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(users[0]),
|
||||
json={"title": "Concurrency", "member_ids": [u["id"] for u in users]},
|
||||
).json()
|
||||
|
||||
async def scenario() -> None:
|
||||
async with httpx.AsyncClient(
|
||||
transport=httpx.ASGITransport(app=app),
|
||||
base_url="http://testserver",
|
||||
timeout=30,
|
||||
) as client:
|
||||
|
||||
async def worker(index: int, user: dict) -> list[dict]:
|
||||
responses = await asyncio.gather(
|
||||
*(
|
||||
client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers=bearer(user),
|
||||
json={"text": f"client-{index}-message-{n}"},
|
||||
)
|
||||
for n in range(10)
|
||||
)
|
||||
)
|
||||
assert all(r.status_code == 201 for r in responses), [
|
||||
r.text for r in responses if r.status_code != 201
|
||||
]
|
||||
return [r.json() for r in responses]
|
||||
|
||||
results = await asyncio.gather(*(worker(i, u) for i, u in enumerate(users)))
|
||||
messages = [m for batch in results for m in batch]
|
||||
|
||||
assert len(messages) == 100
|
||||
assert len({m["id"] for m in messages}) == 100
|
||||
assert Counter(m["sender_id"] for m in messages) == Counter(
|
||||
{u["id"]: 10 for u in users}
|
||||
)
|
||||
|
||||
history = await client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(users[0])
|
||||
)
|
||||
items = history.json()["items"]
|
||||
assert len(items) == 100
|
||||
assert len({m["id"] for m in items}) == 100
|
||||
|
||||
asyncio.run(scenario())
|
||||
|
||||
|
||||
def test_chat_creation_in_parallel_is_atomic(make_settings, db_engine):
|
||||
from sqlalchemy import text
|
||||
|
||||
app = create_app(make_settings(max_in_flight=32, db_pool_size=20, db_max_overflow=20))
|
||||
with TestClient(app) as setup:
|
||||
alice = create_user(setup)
|
||||
bob = create_user(setup)
|
||||
|
||||
async def scenario() -> None:
|
||||
async with httpx.AsyncClient(
|
||||
transport=httpx.ASGITransport(app=app),
|
||||
base_url="http://testserver",
|
||||
timeout=30,
|
||||
) as client:
|
||||
responses = await asyncio.gather(
|
||||
*(
|
||||
client.post(
|
||||
"/api/v1/chats",
|
||||
headers=bearer(alice),
|
||||
json={"title": f"c{i}", "member_ids": [alice["id"], bob["id"]]},
|
||||
)
|
||||
for i in range(10)
|
||||
)
|
||||
)
|
||||
assert all(r.status_code == 201 for r in responses)
|
||||
|
||||
asyncio.run(scenario())
|
||||
|
||||
with db_engine.connect() as connection:
|
||||
chats = connection.execute(text("SELECT count(*) FROM chats")).scalar_one()
|
||||
members = connection.execute(text("SELECT count(*) FROM chat_members")).scalar_one()
|
||||
assert chats == 10 and members == 20
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Ограничения на уровне БД: приложение — не единственный защитник данных."""
|
||||
|
||||
import pytest
|
||||
from sqlalchemy import text
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
|
||||
from tests.helpers import create_chat, create_user
|
||||
|
||||
|
||||
def test_duplicate_username_is_rejected_by_database(client, db_engine):
|
||||
create_user(client, username="unique_name")
|
||||
|
||||
with pytest.raises(IntegrityError):
|
||||
with db_engine.begin() as connection:
|
||||
connection.execute(
|
||||
text(
|
||||
"INSERT INTO users (id, username, display_name, password_hash) "
|
||||
"VALUES (gen_random_uuid(), 'unique_name', 'Other', 'hash')"
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def test_message_requires_existing_chat(client, db_engine):
|
||||
alice = create_user(client)
|
||||
|
||||
with pytest.raises(IntegrityError):
|
||||
with db_engine.begin() as connection:
|
||||
connection.execute(
|
||||
text(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text) "
|
||||
"VALUES (gen_random_uuid(), gen_random_uuid(), :sender, 'x')"
|
||||
),
|
||||
{"sender": alice["id"]},
|
||||
)
|
||||
|
||||
|
||||
def test_duplicate_membership_is_rejected_by_database(client, db_engine):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
|
||||
with pytest.raises(IntegrityError):
|
||||
with db_engine.begin() as connection:
|
||||
connection.execute(
|
||||
text("INSERT INTO chat_members (chat_id, user_id) VALUES (:c, :u)"),
|
||||
{"c": chat["id"], "u": alice["id"]},
|
||||
)
|
||||
@@ -0,0 +1,74 @@
|
||||
import logging
|
||||
import json
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from tests.helpers import assert_request_id
|
||||
|
||||
|
||||
def test_missing_token_returns_401(client: TestClient):
|
||||
response = client.get("/api/v1/users/me")
|
||||
|
||||
assert response.status_code == 401
|
||||
assert response.json()["error"]["code"] == "unauthorized"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_garbage_token_returns_401(client: TestClient):
|
||||
response = client.get(
|
||||
"/api/v1/users/me", headers={"Authorization": "Bearer garbage"}
|
||||
)
|
||||
|
||||
assert response.status_code == 401
|
||||
assert response.json()["error"]["code"] == "unauthorized"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_malformed_json_returns_400(client: TestClient):
|
||||
response = client.post(
|
||||
"/api/v1/users",
|
||||
content='{"username":"alice",',
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_not_found_returns_404(client: TestClient):
|
||||
response = client.get("/no-such-path")
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_method_not_allowed_preserves_405(client: TestClient):
|
||||
response = client.delete("/api/v1/users")
|
||||
|
||||
assert response.status_code == 405
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_unhandled_exception_is_hidden_from_client(client_no_raise: TestClient, caplog):
|
||||
with caplog.at_level(logging.ERROR, logger="app.errors.handlers"):
|
||||
response = client_no_raise.get("/__test__/explode")
|
||||
|
||||
assert response.status_code == 500
|
||||
payload = response.json()
|
||||
assert payload["error"]["code"] == "internal_error"
|
||||
assert payload["error"]["message"] == "Внутренняя ошибка сервера"
|
||||
assert "test-secret" not in json.dumps(payload, ensure_ascii=False)
|
||||
assert "Traceback" not in json.dumps(payload, ensure_ascii=False)
|
||||
assert "Unhandled error request_id=" in caplog.text
|
||||
assert "test-secret" in caplog.text
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_success_response_contains_request_id(client: TestClient):
|
||||
response = client.get("/health/live")
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.headers.get("X-Request-Id")
|
||||
@@ -0,0 +1,61 @@
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.main import create_app
|
||||
from tests.helpers import assert_request_id
|
||||
|
||||
|
||||
def test_liveness(client: TestClient):
|
||||
response = client.get("/health/live")
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json() == {"status": "ok"}
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_readiness(client: TestClient):
|
||||
response = client.get("/health/ready")
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json() == {"status": "ok"}
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_readiness_is_503_when_database_is_down(make_settings):
|
||||
"""БД недоступна: live по-прежнему 200, ready — ограниченный 503."""
|
||||
app = create_app(
|
||||
make_settings(
|
||||
database_url="postgresql+psycopg://nobody:nopass@127.0.0.1:1/none",
|
||||
db_connect_timeout_seconds=1,
|
||||
)
|
||||
)
|
||||
with TestClient(app) as client:
|
||||
assert client.get("/health/live").status_code == 200
|
||||
|
||||
ready = client.get("/health/ready")
|
||||
assert ready.status_code == 503
|
||||
assert ready.json()["error"]["code"] == "unavailable"
|
||||
assert_request_id(ready)
|
||||
|
||||
|
||||
def test_business_request_is_503_when_database_is_down(make_settings):
|
||||
"""Недоступность БД не превращается в 500 и не раскрывает детали подключения."""
|
||||
app = create_app(
|
||||
make_settings(
|
||||
database_url="postgresql+psycopg://nobody:secretpass@127.0.0.1:1/none",
|
||||
db_connect_timeout_seconds=1,
|
||||
)
|
||||
)
|
||||
with TestClient(app, raise_server_exceptions=False) as client:
|
||||
response = client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": "alice",
|
||||
"display_name": "Alice",
|
||||
"password": "Correct-horse-battery-1",
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 503
|
||||
assert response.json()["error"]["code"] == "unavailable"
|
||||
assert "secretpass" not in response.text
|
||||
assert_request_id(response)
|
||||
@@ -0,0 +1,103 @@
|
||||
"""Остаток трека «управляемая деградация»: MAX_IN_FLIGHT -> 429, MAX_MESSAGES -> 503."""
|
||||
|
||||
import asyncio
|
||||
import threading
|
||||
|
||||
import httpx
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.main import create_app
|
||||
from tests.helpers import assert_request_id, bearer, create_chat, create_user
|
||||
|
||||
|
||||
def _assert_error(response: httpx.Response, status: int, code: str) -> None:
|
||||
assert response.status_code == status
|
||||
body = response.json()
|
||||
assert body["error"]["code"] == code
|
||||
assert response.headers.get("X-Request-Id") == body["error"]["request_id"]
|
||||
|
||||
|
||||
def test_message_limit_rejects_without_deleting_confirmed_messages(make_settings):
|
||||
app = create_app(make_settings(max_messages=2))
|
||||
with TestClient(app) as client:
|
||||
user = create_user(client)
|
||||
chat = create_chat(client, user)
|
||||
url = f"/api/v1/chats/{chat['id']}/messages"
|
||||
|
||||
for index in range(2):
|
||||
ok = client.post(url, headers=bearer(user), json={"text": f"confirmed-{index}"})
|
||||
assert ok.status_code == 201
|
||||
|
||||
rejected = client.post(url, headers=bearer(user), json={"text": "rejected"})
|
||||
_assert_error(rejected, 503, "unavailable")
|
||||
|
||||
history = client.get(f"{url}?limit=100", headers=bearer(user))
|
||||
assert history.status_code == 200
|
||||
assert [m["text"] for m in history.json()["items"]] == ["confirmed-0", "confirmed-1"]
|
||||
|
||||
|
||||
def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypatch):
|
||||
import app.endpoints.messages as message_endpoint
|
||||
|
||||
app = create_app(make_settings(max_in_flight=2))
|
||||
|
||||
original_send_message = message_endpoint.send_message
|
||||
accepted_count = 0
|
||||
accepted_lock = threading.Lock()
|
||||
all_slots_taken = threading.Event()
|
||||
release = threading.Event()
|
||||
|
||||
def blocking_send_message(*args, **kwargs):
|
||||
nonlocal accepted_count
|
||||
with accepted_lock:
|
||||
accepted_count += 1
|
||||
if accepted_count == 2:
|
||||
all_slots_taken.set()
|
||||
if not release.wait(timeout=5):
|
||||
raise AssertionError("test release event was not set")
|
||||
return original_send_message(*args, **kwargs)
|
||||
|
||||
# Подготовка данных до подмены (на ней же проверяем, что слоты освобождаются).
|
||||
with TestClient(app) as setup_client:
|
||||
user = create_user(setup_client)
|
||||
chat = create_chat(setup_client, user)
|
||||
|
||||
monkeypatch.setattr(message_endpoint, "send_message", blocking_send_message)
|
||||
url = f"/api/v1/chats/{chat['id']}/messages"
|
||||
|
||||
async def scenario() -> None:
|
||||
async with httpx.AsyncClient(
|
||||
transport=httpx.ASGITransport(app=app),
|
||||
base_url="http://testserver",
|
||||
timeout=10,
|
||||
) as client:
|
||||
held = [
|
||||
asyncio.create_task(
|
||||
client.post(url, headers=bearer(user), json={"text": f"held-{i}"})
|
||||
)
|
||||
for i in range(2)
|
||||
]
|
||||
|
||||
assert await asyncio.to_thread(all_slots_taken.wait, 2)
|
||||
|
||||
rejected = await asyncio.gather(
|
||||
*(
|
||||
client.post(url, headers=bearer(user), json={"text": f"rejected-{i}"})
|
||||
for i in range(4)
|
||||
)
|
||||
)
|
||||
for response in rejected:
|
||||
_assert_error(response, 429, "rate_limited")
|
||||
assert response.headers.get("Retry-After") == "1"
|
||||
|
||||
# Health не ограничивается лимитом.
|
||||
assert (await client.get("/health/live")).status_code == 200
|
||||
|
||||
release.set()
|
||||
assert all(r.status_code == 201 for r in await asyncio.gather(*held))
|
||||
|
||||
recovered = await client.post(url, headers=bearer(user), json={"text": "after"})
|
||||
assert recovered.status_code == 201
|
||||
assert_request_id(recovered)
|
||||
|
||||
asyncio.run(scenario())
|
||||
@@ -0,0 +1,216 @@
|
||||
from urllib.parse import quote
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from tests.helpers import (
|
||||
assert_request_id,
|
||||
bearer,
|
||||
create_chat,
|
||||
create_user,
|
||||
send_message,
|
||||
)
|
||||
|
||||
|
||||
def _message(client: TestClient, user: dict, chat: dict, text: str):
|
||||
return send_message(client, user, chat, text)
|
||||
|
||||
|
||||
def test_send_and_list_message(client: TestClient):
|
||||
alice = create_user(client)
|
||||
bob = create_user(client)
|
||||
chat = create_chat(client, alice, bob)
|
||||
|
||||
created = _message(client, alice, chat, "Привет, мир 👋")
|
||||
|
||||
assert created.status_code == 201
|
||||
message = created.json()
|
||||
assert message["sender_id"] == alice["id"]
|
||||
assert message["chat_id"] == chat["id"]
|
||||
assert_request_id(created)
|
||||
|
||||
listed = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit=1",
|
||||
headers=bearer(bob),
|
||||
)
|
||||
|
||||
assert listed.status_code == 200
|
||||
assert listed.json()["items"] == [message]
|
||||
assert listed.json()["next_cursor"] is None
|
||||
assert_request_id(listed)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text", ["", " ", "x" * 4001])
|
||||
def test_invalid_message_text(client: TestClient, text: str):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
|
||||
response = _message(client, alice, chat, text)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_extra_message_field_is_rejected(client: TestClient):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
|
||||
response = client.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers=bearer(alice),
|
||||
json={"text": "hello", "sender_id": alice["id"]},
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_messages_are_private_to_chat_members(client: TestClient):
|
||||
alice = create_user(client)
|
||||
eve = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
_message(client, alice, chat, "секрет")
|
||||
|
||||
response = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
headers=bearer(eve),
|
||||
)
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
|
||||
|
||||
def test_pagination_has_no_duplicates(client: TestClient):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
|
||||
created = [
|
||||
_message(client, alice, chat, f"message-{index}").json() for index in range(5)
|
||||
]
|
||||
|
||||
page1 = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit=2",
|
||||
headers=bearer(alice),
|
||||
).json()
|
||||
page2 = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page1['next_cursor'], safe='')}",
|
||||
headers=bearer(alice),
|
||||
).json()
|
||||
page3 = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page2['next_cursor'], safe='')}",
|
||||
headers=bearer(alice),
|
||||
).json()
|
||||
|
||||
ids = [item["id"] for page in (page1, page2, page3) for item in page["items"]]
|
||||
assert ids == [item["id"] for item in created]
|
||||
assert len(ids) == len(set(ids)) == 5
|
||||
assert len(page1["items"]) == 2
|
||||
assert len(page2["items"]) == 2
|
||||
assert len(page3["items"]) == 1
|
||||
assert page3["next_cursor"] is None
|
||||
|
||||
|
||||
def test_cursor_cannot_be_used_for_another_chat(client: TestClient):
|
||||
alice = create_user(client)
|
||||
chat_a = create_chat(client, alice, title="A")
|
||||
chat_b = create_chat(client, alice, title="B")
|
||||
|
||||
_message(client, alice, chat_a, "a1")
|
||||
_message(client, alice, chat_a, "a2")
|
||||
_message(client, alice, chat_b, "b1")
|
||||
_message(client, alice, chat_b, "b2")
|
||||
|
||||
page = client.get(
|
||||
f"/api/v1/chats/{chat_a['id']}/messages?limit=1",
|
||||
headers=bearer(alice),
|
||||
).json()
|
||||
|
||||
response = client.get(
|
||||
f"/api/v1/chats/{chat_b['id']}/messages?limit=1&cursor={quote(page['next_cursor'], safe='')}",
|
||||
headers=bearer(alice),
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"limit, expected_status", [(0, 400), (1, 200), (100, 200), (101, 400)]
|
||||
)
|
||||
def test_limit_boundaries(client: TestClient, limit: int, expected_status: int):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
_message(client, alice, chat, "one")
|
||||
|
||||
response = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit={limit}",
|
||||
headers=bearer(alice),
|
||||
)
|
||||
|
||||
assert response.status_code == expected_status
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_message_exact_max_length_is_accepted(client: TestClient):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
|
||||
response = _message(client, alice, chat, "x" * 4000)
|
||||
|
||||
assert response.status_code == 201
|
||||
assert len(response.json()["text"]) == 4000
|
||||
|
||||
|
||||
def test_nonexistent_chat_messages_return_404(client: TestClient):
|
||||
alice = create_user(client)
|
||||
|
||||
response = client.get(
|
||||
"/api/v1/chats/00000000-0000-4000-8000-000000000000/messages",
|
||||
headers=bearer(alice),
|
||||
)
|
||||
|
||||
assert response.status_code == 404
|
||||
assert response.json()["error"]["code"] == "not_found"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_unauthenticated_requests_are_rejected(client: TestClient):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
url = f"/api/v1/chats/{chat['id']}/messages"
|
||||
|
||||
assert client.get(url).status_code == 401
|
||||
assert client.post(url, json={"text": "hi"}).status_code == 401
|
||||
|
||||
|
||||
def test_messages_survive_new_login(client: TestClient):
|
||||
"""Сообщения принадлежат пользователю, а не сессии: после logout/login видны."""
|
||||
from tests.helpers import login
|
||||
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
message = _message(client, alice, chat, "до выхода").json()
|
||||
client.delete("/api/v1/auth/sessions/current", headers=bearer(alice))
|
||||
|
||||
alice_again = login(client, alice)
|
||||
listed = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages", headers=bearer(alice_again)
|
||||
)
|
||||
|
||||
assert listed.json()["items"] == [message]
|
||||
|
||||
|
||||
def test_history_order_is_created_at_then_id(client: TestClient):
|
||||
alice = create_user(client)
|
||||
chat = create_chat(client, alice)
|
||||
created = [_message(client, alice, chat, f"m{i}").json() for i in range(10)]
|
||||
|
||||
listed = client.get(
|
||||
f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(alice)
|
||||
).json()["items"]
|
||||
|
||||
assert [m["id"] for m in listed] == [m["id"] for m in created]
|
||||
keys = [(m["created_at"], m["id"]) for m in listed]
|
||||
assert keys == sorted(keys)
|
||||
@@ -0,0 +1,61 @@
|
||||
"""Миграции с нуля: «миграции с нуля и повторный запуск без дублирования данных»."""
|
||||
|
||||
import pytest
|
||||
from alembic import command
|
||||
from alembic.autogenerate import compare_metadata
|
||||
from alembic.migration import MigrationContext
|
||||
from sqlalchemy import create_engine, inspect, text
|
||||
|
||||
from app.models import Base
|
||||
from tests.conftest import _alembic_config
|
||||
|
||||
EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "sessions"}
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def migrated_engine(database_url, db_engine):
|
||||
# db_engine гарантирует, что БД доступна; переключаем схему на «только миграции».
|
||||
engine = create_engine(database_url)
|
||||
Base.metadata.drop_all(engine)
|
||||
with engine.begin() as connection:
|
||||
connection.execute(text("DROP TABLE IF EXISTS alembic_version"))
|
||||
|
||||
command.upgrade(_alembic_config(database_url), "head")
|
||||
yield engine
|
||||
|
||||
Base.metadata.drop_all(engine)
|
||||
with engine.begin() as connection:
|
||||
connection.execute(text("DROP TABLE IF EXISTS alembic_version"))
|
||||
Base.metadata.create_all(engine) # вернуть схему для остальных тестов
|
||||
engine.dispose()
|
||||
|
||||
|
||||
def test_upgrade_creates_all_tables(migrated_engine):
|
||||
assert EXPECTED_TABLES <= set(inspect(migrated_engine).get_table_names())
|
||||
|
||||
|
||||
def test_upgrade_twice_is_idempotent_and_keeps_data(migrated_engine, database_url):
|
||||
with migrated_engine.begin() as connection:
|
||||
connection.execute(
|
||||
text(
|
||||
"INSERT INTO users (id, username, display_name, password_hash) "
|
||||
"VALUES (gen_random_uuid(), 'keep_me', 'Keep', 'hash')"
|
||||
)
|
||||
)
|
||||
|
||||
command.upgrade(_alembic_config(database_url), "head") # повторный запуск
|
||||
|
||||
with migrated_engine.connect() as connection:
|
||||
count = connection.execute(
|
||||
text("SELECT count(*) FROM users WHERE username = 'keep_me'")
|
||||
).scalar_one()
|
||||
assert count == 1
|
||||
|
||||
|
||||
def test_models_and_migrations_are_in_sync(migrated_engine):
|
||||
"""Нет расхождений между ORM-моделями и схемой, созданной миграциями."""
|
||||
with migrated_engine.connect() as connection:
|
||||
context = MigrationContext.configure(connection, opts={"compare_type": True})
|
||||
diff = compare_metadata(context, Base.metadata)
|
||||
|
||||
assert diff == [], f"Создайте миграцию: alembic revision --autogenerate. Diff: {diff}"
|
||||
@@ -0,0 +1,103 @@
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from tests.helpers import PASSWORD, assert_request_id, bearer, create_user, register
|
||||
|
||||
|
||||
def test_register_does_not_leak_password(client: TestClient):
|
||||
response = client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": "alice", "display_name": "Алиса 👋", "password": PASSWORD},
|
||||
)
|
||||
|
||||
assert response.status_code == 201
|
||||
body = response.json()
|
||||
assert set(body) == {"id", "username", "display_name", "created_at"}
|
||||
assert PASSWORD not in response.text
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_get_current_user(client: TestClient):
|
||||
user = create_user(client, display_name="Алиса 👋")
|
||||
|
||||
response = client.get("/api/v1/users/me", headers=bearer(user))
|
||||
|
||||
assert response.status_code == 200
|
||||
assert response.json()["id"] == user["id"]
|
||||
assert response.json()["username"] == user["username"]
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
{"username": "alice", "display_name": "", "password": PASSWORD},
|
||||
{"username": "alice", "display_name": " ", "password": PASSWORD},
|
||||
{"username": "alice", "display_name": "a" * 101, "password": PASSWORD},
|
||||
{"username": "ab", "display_name": "Alice", "password": PASSWORD},
|
||||
{"username": "alice-123", "display_name": "Alice", "password": PASSWORD},
|
||||
{"username": "AlicE", "display_name": "Alice", "password": PASSWORD},
|
||||
{"username": "a" * 33, "display_name": "Alice", "password": PASSWORD},
|
||||
{"username": "alice", "display_name": "Alice"}, # нет пароля
|
||||
{"username": "alice", "display_name": "Alice", "password": "x" * 11},
|
||||
{"username": "alice", "display_name": "Alice", "password": "x" * 129},
|
||||
],
|
||||
)
|
||||
def test_invalid_user_payloads(client: TestClient, body: dict):
|
||||
response = client.post("/api/v1/users", json=body)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_password_length_boundaries_are_accepted(client: TestClient):
|
||||
for index, password in enumerate(["x" * 12, "y" * 128, " " * 12, "п" * 12]):
|
||||
response = client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": f"pw_user_{index}",
|
||||
"display_name": "Alice",
|
||||
"password": password,
|
||||
},
|
||||
)
|
||||
assert response.status_code == 201, (index, response.text)
|
||||
|
||||
|
||||
def test_extra_user_field_is_rejected(client: TestClient):
|
||||
response = client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": "alice",
|
||||
"display_name": "Alice",
|
||||
"password": PASSWORD,
|
||||
"extra": True,
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 400
|
||||
assert response.json()["error"]["code"] == "invalid_request"
|
||||
|
||||
|
||||
def test_duplicate_username_returns_conflict(client: TestClient):
|
||||
user = register(client, username="duplicate_user")
|
||||
|
||||
response = client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": user["username"],
|
||||
"display_name": "Другой",
|
||||
"password": PASSWORD,
|
||||
},
|
||||
)
|
||||
|
||||
assert response.status_code == 409
|
||||
assert response.json()["error"]["code"] == "conflict"
|
||||
assert_request_id(response)
|
||||
|
||||
|
||||
def test_user_exact_length_boundaries_are_accepted(client: TestClient):
|
||||
for length in (3, 32):
|
||||
user = register(client, username=("a" * length), display_name="d" * 100)
|
||||
assert len(user["username"]) == length
|
||||
assert len(user["display_name"]) == 100
|
||||
Reference in New Issue
Block a user