diff --git a/.env.example b/.env.example index 714c807..94838db 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/.gitignore b/.gitignore index b5a7189..d3561ad 100644 --- a/.gitignore +++ b/.gitignore @@ -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 \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..0e140a1 --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/Makefile b/Makefile index 9ecb223..1a16cfa 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 0000000..7ed8c3b --- /dev/null +++ b/alembic.ini @@ -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 diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 0000000..ee20995 --- /dev/null +++ b/app/__main__.py @@ -0,0 +1,4 @@ +from app.main import main + +if __name__ == "__main__": + main() diff --git a/app/core/__init__.py b/app/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/core/config.py b/app/core/config.py new file mode 100644 index 0000000..dd84376 --- /dev/null +++ b/app/core/config.py @@ -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() diff --git a/app/core/database.py b/app/core/database.py new file mode 100644 index 0000000..b0c1330 --- /dev/null +++ b/app/core/database.py @@ -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 diff --git a/app/core/request_capacity.py b/app/core/request_capacity.py new file mode 100644 index 0000000..7004d8a --- /dev/null +++ b/app/core/request_capacity.py @@ -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() diff --git a/app/core/request_id.py b/app/core/request_id.py new file mode 100644 index 0000000..a78a860 --- /dev/null +++ b/app/core/request_id.py @@ -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 diff --git a/app/core/security.py b/app/core/security.py new file mode 100644 index 0000000..92094bd --- /dev/null +++ b/app/core/security.py @@ -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()") diff --git a/app/domain/__init__.py b/app/domain/__init__.py new file mode 100644 index 0000000..7ab2ee1 --- /dev/null +++ b/app/domain/__init__.py @@ -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. +""" diff --git a/app/domain/auth.py b/app/domain/auth.py new file mode 100644 index 0000000..d8c6a55 --- /dev/null +++ b/app/domain/auth.py @@ -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") diff --git a/app/domain/chats.py b/app/domain/chats.py new file mode 100644 index 0000000..605e14b --- /dev/null +++ b/app/domain/chats.py @@ -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") diff --git a/app/domain/messages.py b/app/domain/messages.py new file mode 100644 index 0000000..7f97cba --- /dev/null +++ b/app/domain/messages.py @@ -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") diff --git a/app/domain/pagination.py b/app/domain/pagination.py new file mode 100644 index 0000000..9a06e83 --- /dev/null +++ b/app/domain/pagination.py @@ -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) diff --git a/app/domain/users.py b/app/domain/users.py new file mode 100644 index 0000000..ed0c90e --- /dev/null +++ b/app/domain/users.py @@ -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") diff --git a/app/endpoints/__init__.py b/app/endpoints/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/endpoints/auth.py b/app/endpoints/auth.py new file mode 100644 index 0000000..c9d12fc --- /dev/null +++ b/app/endpoints/auth.py @@ -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) diff --git a/app/endpoints/chats.py b/app/endpoints/chats.py new file mode 100644 index 0000000..e726917 --- /dev/null +++ b/app/endpoints/chats.py @@ -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) diff --git a/app/endpoints/dependencies.py b/app/endpoints/dependencies.py new file mode 100644 index 0000000..b9033ab --- /dev/null +++ b/app/endpoints/dependencies.py @@ -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) diff --git a/app/endpoints/health.py b/app/endpoints/health.py new file mode 100644 index 0000000..23b7410 --- /dev/null +++ b/app/endpoints/health.py @@ -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") diff --git a/app/endpoints/messages.py b/app/endpoints/messages.py new file mode 100644 index 0000000..949159c --- /dev/null +++ b/app/endpoints/messages.py @@ -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) diff --git a/app/endpoints/users.py b/app/endpoints/users.py new file mode 100644 index 0000000..5d6365c --- /dev/null +++ b/app/endpoints/users.py @@ -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 diff --git a/app/errors/__init__.py b/app/errors/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/errors/exceptions.py b/app/errors/exceptions.py new file mode 100644 index 0000000..92aa282 --- /dev/null +++ b/app/errors/exceptions.py @@ -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", "Внутренняя ошибка сервера") diff --git a/app/errors/handlers.py b/app/errors/handlers.py new file mode 100644 index 0000000..2ff12cd --- /dev/null +++ b/app/errors/handlers.py @@ -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) diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..22c97a4 --- /dev/null +++ b/app/main.py @@ -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() diff --git a/app/models/__init__.py b/app/models/__init__.py new file mode 100644 index 0000000..342d675 --- /dev/null +++ b/app/models/__init__.py @@ -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"] diff --git a/app/models/base.py b/app/models/base.py new file mode 100644 index 0000000..0f19ee8 --- /dev/null +++ b/app/models/base.py @@ -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 + } diff --git a/app/models/chat.py b/app/models/chat.py new file mode 100644 index 0000000..004f7a4 --- /dev/null +++ b/app/models/chat.py @@ -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) diff --git a/app/models/chat_member.py b/app/models/chat_member.py new file mode 100644 index 0000000..0453219 --- /dev/null +++ b/app/models/chat_member.py @@ -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) diff --git a/app/models/message.py b/app/models/message.py new file mode 100644 index 0000000..98fb340 --- /dev/null +++ b/app/models/message.py @@ -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) diff --git a/app/models/session.py b/app/models/session.py new file mode 100644 index 0000000..6a6338f --- /dev/null +++ b/app/models/session.py @@ -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) diff --git a/app/models/user.py b/app/models/user.py new file mode 100644 index 0000000..e52e791 --- /dev/null +++ b/app/models/user.py @@ -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) diff --git a/app/schemas/__init__.py b/app/schemas/__init__.py new file mode 100644 index 0000000..ac3ac2a --- /dev/null +++ b/app/schemas/__init__.py @@ -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"] diff --git a/app/schemas/base.py b/app/schemas/base.py new file mode 100644 index 0000000..4f86f81 --- /dev/null +++ b/app/schemas/base.py @@ -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") diff --git a/app/schemas/chat.py b/app/schemas/chat.py new file mode 100644 index 0000000..806cf13 --- /dev/null +++ b/app/schemas/chat.py @@ -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 diff --git a/app/schemas/message.py b/app/schemas/message.py new file mode 100644 index 0000000..5c64c40 --- /dev/null +++ b/app/schemas/message.py @@ -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 diff --git a/app/schemas/session.py b/app/schemas/session.py new file mode 100644 index 0000000..1cae0d2 --- /dev/null +++ b/app/schemas/session.py @@ -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 diff --git a/app/schemas/user.py b/app/schemas/user.py new file mode 100644 index 0000000..94e94a9 --- /dev/null +++ b/app/schemas/user.py @@ -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) diff --git a/app/storage/__init__.py b/app/storage/__init__.py new file mode 100644 index 0000000..775f46d --- /dev/null +++ b/app/storage/__init__.py @@ -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). +""" diff --git a/app/storage/chats.py b/app/storage/chats.py new file mode 100644 index 0000000..0dada53 --- /dev/null +++ b/app/storage/chats.py @@ -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") diff --git a/app/storage/messages.py b/app/storage/messages.py new file mode 100644 index 0000000..8ce4899 --- /dev/null +++ b/app/storage/messages.py @@ -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") diff --git a/app/storage/sessions.py b/app/storage/sessions.py new file mode 100644 index 0000000..7cb0291 --- /dev/null +++ b/app/storage/sessions.py @@ -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") diff --git a/app/storage/types.py b/app/storage/types.py new file mode 100644 index 0000000..ff32c4a --- /dev/null +++ b/app/storage/types.py @@ -0,0 +1,5 @@ +from datetime import datetime +from uuid import UUID + +# Позиция в keyset-пагинации: (created_at, id) последнего виденного элемента. +Position = tuple[datetime, UUID] diff --git a/app/storage/users.py b/app/storage/users.py new file mode 100644 index 0000000..600ba1e --- /dev/null +++ b/app/storage/users.py @@ -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") diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..e76a593 --- /dev/null +++ b/compose.yaml @@ -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: diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 0000000..6e0b921 --- /dev/null +++ b/migrations/env.py @@ -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() diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 0000000..590f5b3 --- /dev/null +++ b/migrations/script.py.mako @@ -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"} diff --git a/migrations/versions/.gitkeep b/migrations/versions/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 0000000..27eec68 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,3 @@ +[pytest] +testpaths = tests +python_files = test_*.py diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3da8ea2 --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 0000000..b662807 --- /dev/null +++ b/scripts/init-secrets.sh @@ -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 созданы" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..1913171 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,6 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +docker compose restart postgres +docker compose restart api diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..16eae8d --- /dev/null +++ b/tests/conftest.py @@ -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 diff --git a/tests/helpers.py b/tests/helpers.py new file mode 100644 index 0000000..f4fd81a --- /dev/null +++ b/tests/helpers.py @@ -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 diff --git a/tests/test_auth.py b/tests/test_auth.py new file mode 100644 index 0000000..ddf0eb8 --- /dev/null +++ b/tests/test_auth.py @@ -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$") diff --git a/tests/test_chats.py b/tests/test_chats.py new file mode 100644 index 0000000..3f58d22 --- /dev/null +++ b/tests/test_chats.py @@ -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) diff --git a/tests/test_concurrency.py b/tests/test_concurrency.py new file mode 100644 index 0000000..253e622 --- /dev/null +++ b/tests/test_concurrency.py @@ -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 diff --git a/tests/test_constraints.py b/tests/test_constraints.py new file mode 100644 index 0000000..23da3cf --- /dev/null +++ b/tests/test_constraints.py @@ -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"]}, + ) diff --git a/tests/test_errors.py b/tests/test_errors.py new file mode 100644 index 0000000..9e7e47e --- /dev/null +++ b/tests/test_errors.py @@ -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") diff --git a/tests/test_health.py b/tests/test_health.py new file mode 100644 index 0000000..6b5c46f --- /dev/null +++ b/tests/test_health.py @@ -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) diff --git a/tests/test_limits.py b/tests/test_limits.py new file mode 100644 index 0000000..658114a --- /dev/null +++ b/tests/test_limits.py @@ -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()) diff --git a/tests/test_messages.py b/tests/test_messages.py new file mode 100644 index 0000000..3ab19aa --- /dev/null +++ b/tests/test_messages.py @@ -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) diff --git a/tests/test_migrations.py b/tests/test_migrations.py new file mode 100644 index 0000000..0779810 --- /dev/null +++ b/tests/test_migrations.py @@ -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}" diff --git a/tests/test_users.py b/tests/test_users.py new file mode 100644 index 0000000..c60af25 --- /dev/null +++ b/tests/test_users.py @@ -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