init commit: create skeleton from lab1

This commit is contained in:
2026-10-16 22:39:23 +03:00
parent 65003b6119
commit aecd8d2957
70 changed files with 3205 additions and 8 deletions
+13 -6
View File
@@ -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
+1
View File
@@ -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
View File
@@ -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"]
+44 -2
View File
@@ -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
View File
@@ -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
View File
+4
View File
@@ -0,0 +1,4 @@
from app.main import main
if __name__ == "__main__":
main()
View File
+56
View File
@@ -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()
+55
View File
@@ -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
+22
View File
@@ -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()
+22
View File
@@ -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
+39
View File
@@ -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()")
+10
View File
@@ -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.
"""
+48
View File
@@ -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")
+80
View File
@@ -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")
+59
View File
@@ -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")
+79
View File
@@ -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)
+24
View File
@@ -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")
View File
+33
View File
@@ -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)
+39
View File
@@ -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)
+76
View File
@@ -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)
+21
View File
@@ -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")
+34
View File
@@ -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)
+21
View File
@@ -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
View File
+85
View File
@@ -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", "Внутренняя ошибка сервера")
+171
View File
@@ -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
View File
@@ -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()
+11
View File
@@ -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"]
+26
View File
@@ -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
}
+22
View File
@@ -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)
+22
View File
@@ -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)
+24
View File
@@ -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)
+23
View File
@@ -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)
+21
View File
@@ -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)
+6
View File
@@ -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"]
+37
View File
@@ -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")
+21
View File
@@ -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
+21
View File
@@ -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
+17
View File
@@ -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
+20
View File
@@ -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)
+10
View File
@@ -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).
"""
+51
View File
@@ -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")
+41
View File
@@ -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")
+46
View File
@@ -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")
+5
View File
@@ -0,0 +1,5 @@
from datetime import datetime
from uuid import UUID
# Позиция в keyset-пагинации: (created_at, id) последнего виденного элемента.
Position = tuple[datetime, UUID]
+37
View File
@@ -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")
+55
View File
@@ -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:
+57
View File
@@ -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()
+24
View File
@@ -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"}
View File
+3
View File
@@ -0,0 +1,3 @@
[pytest]
testpaths = tests
python_files = test_*.py
+43
View File
@@ -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
+16
View File
@@ -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 созданы"
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose restart postgres
docker compose restart api
View File
+133
View File
@@ -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
+81
View File
@@ -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
+175
View File
@@ -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$")
+185
View File
@@ -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)
+132
View File
@@ -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
+46
View File
@@ -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"]},
)
+74
View File
@@ -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")
+61
View File
@@ -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)
+103
View File
@@ -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())
+216
View File
@@ -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)
+61
View File
@@ -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}"
+103
View File
@@ -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