From 7b7ca1b888cd323bfdcfaf0330b3e838fb4c1a50 Mon Sep 17 00:00:00 2001 From: gytall Date: Fri, 23 Oct 2026 00:20:58 +0300 Subject: [PATCH] add async with all functions --- .env.example | 6 +- Makefile | 14 ++- app/core/config.py | 31 +++--- app/core/database.py | 49 ++++------ app/core/request_capacity.py | 34 +++++-- app/core/security.py | 56 ++++++++--- app/domain/__init__.py | 6 +- app/domain/auth.py | 48 ++++++---- app/domain/chats.py | 44 +++++---- app/domain/messages.py | 50 +++++----- app/domain/users.py | 24 +++-- app/endpoints/auth.py | 14 +-- app/endpoints/chats.py | 20 ++-- app/endpoints/dependencies.py | 35 ++++--- app/endpoints/health.py | 6 +- app/endpoints/messages.py | 14 +-- app/endpoints/users.py | 10 +- app/errors/handlers.py | 3 + app/main.py | 2 +- app/models/chat.py | 2 +- app/storage/__init__.py | 6 +- app/storage/chats.py | 47 +++++---- app/storage/messages.py | 32 ++++--- app/storage/sessions.py | 48 +++++++--- app/storage/users.py | 39 +++++--- compose.yaml | 12 +-- migrations/env.py | 37 +++++--- migrations/script.py.mako | 25 +++++ pytest.ini | 3 + requirements.txt | 5 + tests/conftest.py | 84 +++++++++------- tests/helpers.py | 26 ++--- tests/test_auth.py | 116 ++++++++++++----------- tests/test_chats.py | 115 +++++++++++----------- tests/test_concurrency.py | 174 +++++++++++++++------------------- tests/test_constraints.py | 26 ++--- tests/test_errors.py | 30 +++--- tests/test_health.py | 33 +++---- tests/test_limits.py | 100 +++++++++---------- tests/test_messages.py | 146 ++++++++++++++-------------- tests/test_migrations.py | 58 ++++++------ tests/test_users.py | 34 +++---- 42 files changed, 901 insertions(+), 763 deletions(-) create mode 100644 migrations/script.py.mako diff --git a/.env.example b/.env.example index 94838db8..8da2e15a 100644 --- a/.env.example +++ b/.env.example @@ -9,7 +9,11 @@ MAX_IN_FLIGHT=16 SESSION_TTL_SECONDS=3600 SESSION_STORE=postgres -DATABASE_URL_FILE=/run/secrets/database_url +DB_HOST=postgres +DB_PORT=5432 +DB_NAME=messenger +DB_USER=messenger +DB_PASSWORD_FILE=/run/secrets/postgres_password DB_POOL_SIZE=5 DB_MAX_OVERFLOW=10 diff --git a/Makefile b/Makefile index 72e7b402..4f4ba54b 100644 --- a/Makefile +++ b/Makefile @@ -1,19 +1,21 @@ +-include .env + PYTHON ?= python3 BASE_URL ?= http://localhost:8080 CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -TEST_DATABASE_URL ?= $(shell test -f secrets/postgres_password && printf 'postgresql+psycopg://messenger:%s@localhost:5432/messenger_test' "$$(cat secrets/postgres_password)") +TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(DB_PASSWORD)@localhost:5432/$(DB_NAME)_test export TEST_DATABASE_URL .PHONY: help check validate test load test-persistence \ - secrets up down logs db-up migrate migration \ + up down logs db-up migrate migration \ test-own test-limits test-concurrency test-migrations help: @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 "Стенд: up | down | logs | db-up (только PostgreSQL + тестовая БД) | migrate" @echo "Свои: test-own | test-limits | test-concurrency | test-migrations | migration m='описание'" check: @@ -32,10 +34,6 @@ 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: - @mkdir -p secrets - @test -f secrets/postgres_password || (head -c 32 /dev/urandom | od -An -tx1 | tr -d ' \n' > secrets/postgres_password && chmod 644 secrets/postgres_password && echo "создан secrets/postgres_password") - up: docker compose --env-file .env up -d --build @@ -47,7 +45,7 @@ logs: db-up: docker compose up -d --wait postgres - docker compose exec -T postgres sh -c 'createdb -U "$$POSTGRES_USER" messenger_test 2>&1 | grep -v "already exists"; true' + docker compose exec -T postgres sh -c 'createdb -U "$$POSTGRES_USER" "$$POSTGRES_DB"_test 2>&1 | grep -v "already exists"; true' migrate: docker compose run --rm migrate diff --git a/app/core/config.py b/app/core/config.py index fa0a0239..c9d7a168 100644 --- a/app/core/config.py +++ b/app/core/config.py @@ -1,11 +1,12 @@ from enum import StrEnum -from pathlib import Path from typing import Literal, Self -from pydantic import Field, model_validator +from pydantic import Field, SecretStr, model_validator from pydantic_settings import BaseSettings, SettingsConfigDict from sqlalchemy import URL +ASYNC_DRIVER = "postgresql+asyncpg" + class LogLevel(StrEnum): DEBUG = "DEBUG" @@ -27,13 +28,12 @@ class Settings(BaseSettings): session_ttl_seconds: int = Field(default=3600, ge=1) session_store: Literal["postgres"] = "postgres" - database_url: str | None = None + database_url: SecretStr | None = None db_host: str | None = None db_port: int = Field(default=5432, ge=1, le=65535) db_name: str | None = None db_user: str | None = None - db_password: str | None = None - db_password_file: Path | None = None + db_password: SecretStr | None = None db_pool_size: int = Field(default=5, ge=1) db_max_overflow: int = Field(default=5, ge=0) @@ -51,28 +51,25 @@ class Settings(BaseSettings): @model_validator(mode="after") def _require_database_source(self) -> Self: if self.database_url is not None: + if not self.database_url.get_secret_value().startswith(ASYNC_DRIVER): + raise ValueError(f"DATABASE_URL должен начинаться с {ASYNC_DRIVER}://") return self - has_password = self.db_password is not None or self.db_password_file is not None - if not (self.db_host and self.db_name and self.db_user and has_password): + + if not (self.db_host and self.db_name and self.db_user and self.db_password): raise ValueError( - "Задайте DATABASE_URL или DB_HOST, DB_NAME, DB_USER и " - "DB_PASSWORD_FILE (либо DB_PASSWORD)" + "Задайте DATABASE_URL или DB_HOST, DB_NAME, DB_USER и DB_PASSWORD" ) return self def get_database_url(self) -> str: if self.database_url is not None: - return self.database_url - - if self.db_password_file is not None: - password = self.db_password_file.read_text(encoding="utf-8").strip() - else: - password = self.db_password + return self.database_url.get_secret_value() + assert self.db_password is not None url = URL.create( - "postgresql+psycopg", + ASYNC_DRIVER, username=self.db_user, - password=password, + password=self.db_password.get_secret_value(), host=self.db_host, port=self.db_port, database=self.db_name, diff --git a/app/core/database.py b/app/core/database.py index b0c1330f..c87bf430 100644 --- a/app/core/database.py +++ b/app/core/database.py @@ -1,55 +1,44 @@ -"""Engine и фабрика сессий SQLAlchemy. - -Живёт рядом с config.py, но отдельно: Settings только описывает параметры, -а создание ресурсов (engine, пул) — здесь, чтобы тесты могли подменять Settings. -""" - import logging -from sqlalchemy import Engine, create_engine, text +from sqlalchemy import text from sqlalchemy.exc import SQLAlchemyError -from sqlalchemy.orm import Session, sessionmaker +from sqlalchemy.ext.asyncio import ( + AsyncEngine, + AsyncSession, + async_sessionmaker, + create_async_engine, +) 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( +def create_db_engine(settings: Settings) -> AsyncEngine: + return create_async_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}", + "timeout": settings.db_connect_timeout_seconds, + "server_settings": { + "statement_timeout": str(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 create_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]: + return async_sessionmaker(bind=engine, expire_on_commit=False, autoflush=False) -def check_database(engine: Engine) -> bool: - """True, если БД отвечает на SELECT 1. Используется в /health/ready.""" +async def check_database(engine: AsyncEngine) -> bool: try: - with engine.connect() as connection: - connection.execute(text("SELECT 1")) - except SQLAlchemyError: + async with engine.connect() as connection: + await connection.execute(text("SELECT 1")) + except (SQLAlchemyError, OSError, TimeoutError): 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 index 7004d8a6..acfb15a3 100644 --- a/app/core/request_capacity.py +++ b/app/core/request_capacity.py @@ -1,22 +1,40 @@ -from collections.abc import Generator -from threading import BoundedSemaphore +from collections.abc import AsyncIterator 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) +class RequestCapacity: + def __init__(self, max_in_flight: int) -> None: + self._max_in_flight = max_in_flight + self._in_flight = 0 + + @property + def in_flight(self) -> int: + return self._in_flight + + def try_acquire(self) -> bool: + if self._in_flight >= self._max_in_flight: + return False + self._in_flight += 1 + return True + + def release(self) -> None: + self._in_flight -= 1 -def acquire_request_slot(request: Request) -> Generator[None, None, None]: - semaphore: BoundedSemaphore = request.app.state.request_capacity +def create_request_capacity(max_in_flight: int) -> RequestCapacity: + return RequestCapacity(max_in_flight) - if not semaphore.acquire(blocking=False): + +async def acquire_request_slot(request: Request) -> AsyncIterator[None]: + capacity: RequestCapacity = request.app.state.request_capacity + + if not capacity.try_acquire(): raise rate_limited() try: yield finally: - semaphore.release() + capacity.release() diff --git a/app/core/security.py b/app/core/security.py index 92094bd6..184fc146 100644 --- a/app/core/security.py +++ b/app/core/security.py @@ -4,36 +4,66 @@ * пароль имеет низкую энтропию -> нужен медленный KDF с солью (Argon2id); * токен — 256 бит случайности -> брутфорс невозможен, хватает SHA-256, а в БД храним только хеш токена (утечка БД не даёт рабочих токенов). + +Async: Argon2 — CPU-bound и занимает десятки миллисекунд. Вызов прямо из +`async def` блокирует event loop на всё это время, и ВСЕ остальные запросы +стоят. Поэтому hash/verify оборачиваются в `asyncio.to_thread`. +generate_token и hash_token — микросекунды, остаются обычными функциями. """ -def hash_password(password: str) -> str: - """Хеширует пароль библиотечным KDF (рекомендуется argon2-cffi, Argon2id). +def _hash_password_sync(password: str) -> str: + """Синхронный Argon2id-хеш. Вызывается только через asyncio.to_thread. - Возвращает строку с параметрами и солью внутри (формат PHC, "$argon2id$..."). + Алгоритм: + 1. hasher = модульный PasswordHasher() (создать один раз на модуль) + 2. return hasher.hash(password) # "$argon2id$..." с солью и параметрами """ - raise NotImplementedError("TODO: argon2.PasswordHasher().hash(password)") + raise NotImplementedError("TODO") -def verify_password(password: str, password_hash: str) -> bool: - """True, если пароль подходит. Любые ошибки верификации -> False, не исключение.""" - raise NotImplementedError("TODO: PasswordHasher().verify + перехват VerifyMismatchError") +def _verify_password_sync(password: str, password_hash: str) -> bool: + """Синхронная проверка. Вызывается только через asyncio.to_thread. + + Алгоритм: + 1. try: hasher.verify(password_hash, password); return True + 2. except VerifyMismatchError / VerificationError / InvalidHashError: return False + """ + raise NotImplementedError("TODO") -def dummy_verify_password(password: str) -> None: +async def hash_password(password: str) -> str: + """Алгоритм: return await asyncio.to_thread(_hash_password_sync, password).""" + raise NotImplementedError("TODO") + + +async def verify_password(password: str, password_hash: str) -> bool: + """Алгоритм: return await asyncio.to_thread(_verify_password_sync, password, password_hash).""" + raise NotImplementedError("TODO") + + +async def dummy_verify_password(password: str) -> None: """Проверка «вхолостую» для несуществующего пользователя. Нужна, чтобы время ответа на неверный username и на неверный пароль не различалось (иначе по таймингу можно перебирать username). + + Алгоритм: + 1. DUMMY_HASH = hash от случайной строки, посчитан один раз при импорте модуля + (через _hash_password_sync, не через await — на уровне модуля await нельзя) + 2. await verify_password(password, DUMMY_HASH); результат игнорировать """ - raise NotImplementedError("TODO: verify_password(password, заранее посчитанный DUMMY_HASH)") + raise NotImplementedError("TODO") def generate_token() -> str: - """Opaque-токен минимум на 256 бит энтропии (secrets.token_urlsafe(32)).""" - raise NotImplementedError("TODO: secrets.token_urlsafe(32)") + """Opaque-токен минимум на 256 бит энтропии. Алгоритм: secrets.token_urlsafe(32).""" + raise NotImplementedError("TODO") def hash_token(token: str) -> str: - """Детерминированный хеш токена для хранения/поиска в БД (sha256 hexdigest).""" - raise NotImplementedError("TODO: hashlib.sha256(token.encode()).hexdigest()") + """Детерминированный хеш токена для хранения/поиска в БД. + + Алгоритм: hashlib.sha256(token.encode()).hexdigest() + """ + raise NotImplementedError("TODO") diff --git a/app/domain/__init__.py b/app/domain/__init__.py index 7ab2ee1f..2a78e69f 100644 --- a/app/domain/__init__.py +++ b/app/domain/__init__.py @@ -1,10 +1,12 @@ """Бизнес-логика. Здесь решается, какая ошибка API соответствует ситуации. Правила слоя: - * функции принимают sqlalchemy Session первым аргументом; + * функции это `async def`, первым аргументом принимают AsyncSession; + * CPU-тяжёлое (Argon2) — только через security.hash_password/verify_password (они уходят в thread); + * не запускайте asyncio.gather на ОДНОЙ сессии: AsyncSession не потокобезопасна и не рассчитана на параллельные запросы; * возвращают pydantic-схемы (app.schemas), а не ORM-объекты; * вызывают app.storage.* и бросают ApiError из app.errors.exceptions; - * ВЛАДЕЮТ ТРАНЗАКЦИЕЙ: именно здесь session.commit(); при ошибке — rollback + * ВЛАДЕЮТ ТРАНЗАКЦИЕЙ: именно здесь await session.commit(); при ошибке — rollback (незакоммиченная сессия в любом случае откатывается при закрытии в dependency); * никаких Request/Response/HTTP-заголовков — это слой endpoints. """ diff --git a/app/domain/auth.py b/app/domain/auth.py index d8c6a55c..0231fbe2 100644 --- a/app/domain/auth.py +++ b/app/domain/auth.py @@ -1,37 +1,41 @@ -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.schemas.session import AuthSession from app.schemas.user import User -def create_session( - session: Session, +async def create_session( + session: AsyncSession, 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)) - (токен показывается клиенту ровно один раз). + Алгоритм: + 1. user = await storage.users.get_user_by_username(session, username) + 2. если user is None: + await security.dummy_verify_password(password) + raise unauthorized_basic() + 3. если not await security.verify_password(password, user.password_hash): + raise unauthorized_basic() (тот же ответ, что и в п.2) + 4. token = security.generate_token(); token_hash = security.hash_token(token) + 5. expires_at = datetime.now(UTC) + timedelta(seconds=ttl_seconds) + 6. await storage.sessions.create_session(session, user_id=user.id, token_hash=..., expires_at=...) + await session.commit() + 7. 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). +async def authenticate_token(session: AsyncSession, 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() + Алгоритм: + 1. user = await storage.sessions.get_user_by_active_token_hash( + session, security.hash_token(token), datetime.now(UTC)) + 2. user is None (неизвестен/истёк/отозван) -> raise unauthorized_bearer() 3. return to_user_schema(user) Это AUTHENTICATION («кто ты»). «Можно ли тебе в этот чат» (AUTHORIZATION) — отдельная проверка членства в domain.chats; посторонний получает 404, не 403. @@ -39,10 +43,12 @@ def authenticate_token(session: Session, token: str) -> User: raise NotImplementedError("TODO") -def revoke_session(session: Session, token: str) -> None: +async def revoke_session(session: AsyncSession, token: str) -> None: """DELETE /auth/sessions/current. - TODO: storage.sessions.revoke_session(...); False -> raise unauthorized_bearer(); - иначе session.commit(). Повторный logout тем же токеном = 401 (токен уже недействителен). + Алгоритм: + 1. revoked = await storage.sessions.revoke_session(session, security.hash_token(token), datetime.now(UTC)) + 2. not revoked -> raise unauthorized_bearer() (повторный logout = 401) + 3. await session.commit() """ raise NotImplementedError("TODO") diff --git a/app/domain/chats.py b/app/domain/chats.py index 605e14b7..833cf473 100644 --- a/app/domain/chats.py +++ b/app/domain/chats.py @@ -1,6 +1,6 @@ from uuid import UUID -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.domain.pagination import ( KIND_CHATS, @@ -18,8 +18,10 @@ 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) + Алгоритм: Chat(id=chat.id, title=chat.title, + member_ids=[m.user_id for m in chat.members], created_at=chat.created_at) + Синхронная: chat.members уже загружены (selectin / refresh в storage), + ленивой загрузки в async нет. """ raise NotImplementedError("TODO") @@ -35,46 +37,50 @@ def validate_new_chat(creator: User, new_chat: CreateChat) -> None: raise invalid_request("member_ids содержит дубликаты") -def create_chat(session: Session, creator: User, new_chat: CreateChat) -> Chat: +async def create_chat(session: AsyncSession, 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() — одна транзакция: - чат и все участники появляются вместе или не появляются вовсе. + 2. known = await storage.users.get_existing_user_ids(session, new_chat.member_ids) + known != set(new_chat.member_ids) -> raise invalid_request("member_ids содержит неизвестного пользователя") + 3. chat = await storage.chats.create_chat(session, title=new_chat.title, member_ids=new_chat.member_ids) + await session.commit() — чат и все участники появляются вместе или не появляются вовсе + (при исключении между create_chat и commit: await session.rollback(); raise) 4. return to_chat_schema(chat) """ raise NotImplementedError("TODO") -def get_chat(session: Session, user: User, chat_id: UUID) -> Chat: +async def get_chat(session: AsyncSession, user: User, chat_id: UUID) -> Chat: """GET /chats/{id}. - TODO: storage.chats.get_chat_for_member(...); None -> raise not_found() - (и для чужого, и для несуществующего чата — одинаково). + Алгоритм: + 1. chat = await storage.chats.get_chat_for_member(session, chat_id, user.id) + 2. chat is None -> raise not_found() (и для чужого, и для несуществующего чата — одинаково) + 3. return to_chat_schema(chat) """ raise NotImplementedError("TODO") -def list_chats( - session: Session, +async def list_chats( + session: AsyncSession, user: User, cursor: str | None, limit: int, ) -> ChatPage: """GET /chats — keyset-пагинация (логика курсора перенесена из lab1). - TODO: раскомментируйте и подключите storage. + Алгоритм: + 1. after = decode_cursor(cursor, KIND_CHATS, user.id), если cursor не None (битый/чужой -> 400) + 2. rows = await storage.chats.list_chats_for_user(session, user.id, after, limit + 1) + 3. items, has_next = split_page(rows, limit) + 4. next_cursor = build_next_cursor(KIND_CHATS, user.id, items, has_next) + 5. return ChatPage(items=[to_chat_schema(c) for c in items], next_cursor=next_cursor) """ 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 index 7f97cbaa..b84cdc43 100644 --- a/app/domain/messages.py +++ b/app/domain/messages.py @@ -1,6 +1,6 @@ from uuid import UUID -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.domain.pagination import ( KIND_MESSAGES, @@ -13,8 +13,8 @@ from app.schemas.user import User from app.storage.types import Position -def send_message( - session: Session, +async def send_message( + session: AsyncSession, sender: User, chat_id: UUID, new_message: CreateMessage, @@ -22,38 +22,38 @@ def send_message( ) -> Message: """POST /chats/{id}/messages. - TODO: - 1. Доступ: domain.chats.get_chat(...) -> 404 для постороннего. - 2. Лимит трека «управляемая деградация»: - storage.messages.count_messages(session) >= max_messages -> raise unavailable("Достигнут лимит количества сообщений") (503). + Алгоритм: + 1. await domain.chats.get_chat(session, sender, chat_id) -> 404 для постороннего + 2. await storage.messages.count_messages(session) >= max_messages + -> raise unavailable("Достигнут лимит количества сообщений") (503) Ранее подтверждённые сообщения НЕ удаляются. - 3. storage.messages.create_message(...); session.commit(); вернуть схему Message. - Гонка у лимита: два запроса одновременно могут пройти проверку — решите, - допустимо ли превышение на несколько сообщений, и напишите это в отчёте - (или сериализуйте проверку, например pg_advisory_xact_lock). + 3. message = await storage.messages.create_message(session, chat_id=chat_id, sender_id=sender.id, text=new_message.text) + 4. await session.commit() + 5. return Message.model_validate(message) + Гонка у лимита: два запроса могут одновременно пройти п.2. Решите, допустимо ли + превышение на несколько сообщений (напишите в отчёте), либо сериализуйте проверку + через pg_advisory_xact_lock в той же транзакции. """ raise NotImplementedError("TODO") -def list_messages( - session: Session, +async def list_messages( + session: AsyncSession, user: User, chat_id: UUID, cursor: str | None, limit: int, ) -> MessagePage: - """GET /chats/{id}/messages — keyset-пагинация (логика курсора перенесена из lab1). + """GET /chats/{id}/messages — keyset-пагинация. - 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=...) + Алгоритм: + 1. await domain.chats.get_chat(session, user, chat_id) -> 404, если нет доступа + 2. after = decode_cursor(cursor, KIND_MESSAGES, chat_id), если cursor не None + (битый или чужой cursor -> 400) + 3. rows = await storage.messages.list_messages(session, chat_id, after, limit + 1) + 4. items, has_next = split_page(rows, limit) + 5. next_cursor = build_next_cursor(KIND_MESSAGES, chat_id, items, has_next) + 6. return MessagePage(items=[Message.model_validate(m) for m in items], next_cursor=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) + _ = (decode_cursor, KIND_MESSAGES, split_page, build_next_cursor, Position) raise NotImplementedError("TODO") diff --git a/app/domain/users.py b/app/domain/users.py index ed0c90ed..0bbbbb2c 100644 --- a/app/domain/users.py +++ b/app/domain/users.py @@ -1,24 +1,28 @@ -from sqlalchemy.orm import Session +from sqlalchemy.exc import IntegrityError +from sqlalchemy.ext.asyncio import AsyncSession 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).""" + """ORM -> публичная схема (без password_hash). Синхронная: только преобразование.""" return User.model_validate(user) -def register_user(session: Session, new_user: CreateUser) -> User: +async def register_user(session: AsyncSession, 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 уже занят"). + Алгоритм: + 1. password_hash = await security.hash_password(new_user.password) + — ДО обращения к БД: Argon2 идёт в thread, транзакцию из-за него не держим. + 2. try: + user = await storage.users.create_user(session, username=..., display_name=..., password_hash=...) + await session.commit() + 3. except IntegrityError: + await session.rollback() + raise conflict("Username уже занят") + Источник истины для гонки двух одинаковых username — UNIQUE в БД, не SELECT перед INSERT. 4. return to_user_schema(user) """ raise NotImplementedError("TODO") diff --git a/app/endpoints/auth.py b/app/endpoints/auth.py index c9d12fc6..40b3f371 100644 --- a/app/endpoints/auth.py +++ b/app/endpoints/auth.py @@ -1,5 +1,5 @@ from fastapi import APIRouter, Depends, Response -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.core.config import Settings from app.domain.auth import create_session, revoke_session @@ -15,19 +15,19 @@ router = APIRouter(prefix="/api/v1/auth", tags=["auth"]) @router.post("/sessions", status_code=201) -def login( +async def login( credentials: tuple[str, str] = Depends(get_basic_credentials), - session: Session = Depends(get_db), + session: AsyncSession = Depends(get_db), settings: Settings = Depends(get_settings), ) -> AuthSession: username, password = credentials - return create_session(session, username, password, settings.session_ttl_seconds) + return await create_session(session, username, password, settings.session_ttl_seconds) @router.delete("/sessions/current", status_code=204) -def logout( +async def logout( token: str = Depends(get_bearer_token), - session: Session = Depends(get_db), + session: AsyncSession = Depends(get_db), ) -> Response: - revoke_session(session, token) + await revoke_session(session, token) return Response(status_code=204) diff --git a/app/endpoints/chats.py b/app/endpoints/chats.py index e726917e..0c49289a 100644 --- a/app/endpoints/chats.py +++ b/app/endpoints/chats.py @@ -1,7 +1,7 @@ from uuid import UUID from fastapi import APIRouter, Depends, Query -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.domain.chats import create_chat, get_chat, list_chats from app.endpoints.dependencies import get_current_user, get_db @@ -12,28 +12,28 @@ router = APIRouter(prefix="/api/v1/chats", tags=["chats"]) @router.post("", status_code=201) -def create_new_chat( +async def create_new_chat( new_chat: CreateChat, creator: User = Depends(get_current_user), - session: Session = Depends(get_db), + session: AsyncSession = Depends(get_db), ) -> Chat: - return create_chat(session, creator, new_chat) + return await create_chat(session, creator, new_chat) @router.get("") -def list_user_chats( +async 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), + session: AsyncSession = Depends(get_db), ) -> ChatPage: - return list_chats(session, user, cursor, limit) + return await list_chats(session, user, cursor, limit) @router.get("/{chat_id}") -def get_chat_by_id( +async def get_chat_by_id( chat_id: UUID, user: User = Depends(get_current_user), - session: Session = Depends(get_db), + session: AsyncSession = Depends(get_db), ) -> Chat: - return get_chat(session, user, chat_id) + return await get_chat(session, user, chat_id) diff --git a/app/endpoints/dependencies.py b/app/endpoints/dependencies.py index b9033abb..1ff1e43d 100644 --- a/app/endpoints/dependencies.py +++ b/app/endpoints/dependencies.py @@ -1,9 +1,9 @@ import base64 import binascii -from collections.abc import Iterator +from collections.abc import AsyncIterator from fastapi import Depends, Header, Request -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.core.config import Settings from app.domain.auth import authenticate_token @@ -11,21 +11,21 @@ from app.errors.exceptions import unauthorized_basic, unauthorized_bearer from app.schemas.user import User -def get_settings(request: Request) -> Settings: +async def get_settings(request: Request) -> Settings: settings: Settings = request.app.state.settings return settings -def get_db(request: Request) -> Iterator[Session]: - """Одна сессия БД на HTTP-запрос. +async def get_db(request: Request) -> AsyncIterator[AsyncSession]: + """Одна AsyncSession на HTTP-запрос. - Если domain не сделал commit — при закрытии сессии транзакция откатывается, - поэтому «забытый» commit даёт потерю данных, а не полузаписанное состояние. - FastAPI кэширует зависимость в рамках запроса: get_current_user и endpoint - получают ОДНУ И ТУ ЖЕ сессию. + Если domain не вызвал commit, при выходе из `async with` транзакция + откатывается. FastAPI кэширует зависимость в рамках запроса, поэтому + get_current_user и endpoint получают одну и ту же сессию. + Одну сессию нельзя использовать в параллельных задачах (asyncio.gather). """ session_factory = request.app.state.session_factory - with session_factory() as session: + async with session_factory() as session: yield session @@ -38,21 +38,20 @@ def _split_authorization(authorization: str | None) -> tuple[str, str] | None: return scheme.lower(), value.strip() -def get_bearer_token(authorization: str | None = Header(default=None)) -> str: - """Bearer-токен из Authorization. Basic, пустой и чужие схемы -> 401.""" +async def get_bearer_token(authorization: str | None = Header(default=None)) -> str: parts = _split_authorization(authorization) if parts is None or parts[0] != "bearer": raise unauthorized_bearer() return parts[1] -def get_basic_credentials( +async def get_basic_credentials( authorization: str | None = Header(default=None), ) -> tuple[str, str]: """(username, password) из `Authorization: Basic base64(username:password)`. - Пароль может содержать двоеточие, поэтому делим только по первому ':'. - Любая ошибка разбора -> тот же 401, что и неверные учётные данные. + Делим только по первому ':' (пароль может содержать двоеточие). + Любая ошибка разбора даёт тот же 401, что и неверные учётные данные. """ parts = _split_authorization(authorization) if parts is None or parts[0] != "basic": @@ -69,8 +68,8 @@ def get_basic_credentials( return username, password -def get_current_user( +async def get_current_user( token: str = Depends(get_bearer_token), - session: Session = Depends(get_db), + session: AsyncSession = Depends(get_db), ) -> User: - return authenticate_token(session, token) + return await authenticate_token(session, token) diff --git a/app/endpoints/health.py b/app/endpoints/health.py index 23b74108..be6a62c8 100644 --- a/app/endpoints/health.py +++ b/app/endpoints/health.py @@ -9,13 +9,11 @@ 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): +async def readiness(request: Request) -> Health: + if not await check_database(request.app.state.engine): raise unavailable() return Health(status="ok") diff --git a/app/endpoints/messages.py b/app/endpoints/messages.py index 949159c4..a267e253 100644 --- a/app/endpoints/messages.py +++ b/app/endpoints/messages.py @@ -1,7 +1,7 @@ from uuid import UUID from fastapi import APIRouter, Depends, Query -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.core.config import Settings from app.domain.messages import list_messages, send_message @@ -13,22 +13,22 @@ router = APIRouter(prefix="/api/v1/chats", tags=["messages"]) @router.post("/{chat_id}/messages", status_code=201) -def send_new_message( +async def send_new_message( chat_id: UUID, new_message: CreateMessage, sender: User = Depends(get_current_user), - session: Session = Depends(get_db), + session: AsyncSession = Depends(get_db), settings: Settings = Depends(get_settings), ) -> Message: - return send_message(session, sender, chat_id, new_message, settings.max_messages) + return await send_message(session, sender, chat_id, new_message, settings.max_messages) @router.get("/{chat_id}/messages") -def get_history_messages( +async 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), + session: AsyncSession = Depends(get_db), ) -> MessagePage: - return list_messages(session, user, chat_id, cursor, limit) + return await list_messages(session, user, chat_id, cursor, limit) diff --git a/app/endpoints/users.py b/app/endpoints/users.py index 5d6365ca..5cc234e8 100644 --- a/app/endpoints/users.py +++ b/app/endpoints/users.py @@ -1,5 +1,5 @@ from fastapi import APIRouter, Depends -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.domain.users import register_user from app.endpoints.dependencies import get_current_user, get_db @@ -9,13 +9,13 @@ router = APIRouter(prefix="/api/v1/users", tags=["users"]) @router.post("", status_code=201) -def create_user( +async def create_user( new_user: CreateUser, - session: Session = Depends(get_db), + session: AsyncSession = Depends(get_db), ) -> User: - return register_user(session, new_user) + return await register_user(session, new_user) @router.get("/me") -def get_me(user: User = Depends(get_current_user)) -> User: +async def get_me(user: User = Depends(get_current_user)) -> User: return user diff --git a/app/errors/handlers.py b/app/errors/handlers.py index 2ff12cdc..5788337e 100644 --- a/app/errors/handlers.py +++ b/app/errors/handlers.py @@ -119,6 +119,8 @@ async def database_unavailable_handler( ) -> JSONResponse: """БД недоступна, оборвалась или исчерпан пул -> ограниченный 503. + asyncpg при недоступной БД бросает «сырые» OSError/ConnectionError/TimeoutError, + SQLAlchemy их не оборачивает, поэтому обработчик зарегистрирован и на OSError. Детали (хост, SQL, credentials) пишем только в лог, клиенту — общий текст. """ request_id = _get_request_id(request) @@ -168,4 +170,5 @@ def register_exception_handlers(app: FastAPI) -> None: 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(OSError, database_unavailable_handler) app.add_exception_handler(Exception, unhandled_error_handler) diff --git a/app/main.py b/app/main.py index 22c97a4e..77719965 100644 --- a/app/main.py +++ b/app/main.py @@ -33,7 +33,7 @@ def create_app(settings: Settings | None = None) -> FastAPI: @asynccontextmanager async def lifespan(_: FastAPI) -> AsyncIterator[None]: yield - engine.dispose() + await engine.dispose() application = FastAPI(title="Messenger", version="1.3.0", lifespan=lifespan) diff --git a/app/models/chat.py b/app/models/chat.py index 004f7a4a..b7346592 100644 --- a/app/models/chat.py +++ b/app/models/chat.py @@ -12,7 +12,7 @@ class Chat(Base): * 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 запросов + lazy="selectin": ОБЯЗАТЕЛЬНО в async (ленивой загрузки нет -> MissingGreenlet) * индекс для GET /chats: см. storage.chats.list_chats_for_user (подумайте, по каким колонкам идёт сортировка и фильтр по участнику) """ diff --git a/app/storage/__init__.py b/app/storage/__init__.py index 775f46de..3401a6e1 100644 --- a/app/storage/__init__.py +++ b/app/storage/__init__.py @@ -1,10 +1,10 @@ """Слой доступа к данным (CRUD) — по файлу на сущность. Правила слоя: - * функции принимают открытую sqlalchemy Session первым аргументом; + * функции это `async def`, первым аргументом принимают AsyncSession; каждый запрос — через `await session.execute(...)`; * возвращают ORM-объекты (или None), но НЕ HTTP-ошибки: решать, что значит «не найдено» (404) или «занято» (409), — задача domain; - * НЕ вызывают session.commit()/rollback(): границу транзакции задаёт domain; - максимум — session.flush(), чтобы получить ошибки ограничений сразу; + * НЕ вызывают await session.commit()/rollback(): границу транзакции задаёт domain; + максимум — await session.flush(), чтобы получить ошибки ограничений сразу; * только параметризованные запросы через ORM / sqlalchemy.select (никакого f-string SQL). """ diff --git a/app/storage/chats.py b/app/storage/chats.py index 0dada53c..2823c745 100644 --- a/app/storage/chats.py +++ b/app/storage/chats.py @@ -1,51 +1,66 @@ from collections.abc import Sequence from uuid import UUID -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.models.chat import Chat from app.storage.types import Position -def create_chat( - session: Session, +async def create_chat( + session: AsyncSession, *, title: str, member_ids: Sequence[UUID], ) -> Chat: - """INSERT chats + INSERT chat_members для каждого участника, затем flush(). + """INSERT chats + INSERT chat_members для каждого участника, затем flush. - Всё в одной транзакции domain: если упадёт вставка участника — откатится и чат - (требование «составная операция создания чата выполняется атомарно»). - Возвращённый Chat должен иметь доступные участники (chat.members). + Алгоритм: + 1. chat = Chat(title=title); session.add(chat) + 2. await session.flush() (нужен chat.id) + 3. session.add_all(ChatMember(chat_id=chat.id, user_id=uid) for uid in member_ids) + 4. await session.flush() + 5. await session.refresh(chat, attribute_names=["members"]) + — в async нельзя полагаться на ленивую загрузку chat.members + (MissingGreenlet), поэтому либо refresh, либо relationship(lazy="selectin"). + 6. return chat + Всё в одной транзакции domain: упадёт вставка участника — откатится и чат. """ raise NotImplementedError("TODO") -def get_chat_for_member( - session: Session, +async def get_chat_for_member( + session: AsyncSession, chat_id: UUID, user_id: UUID, ) -> Chat | None: """Чат, только если user_id — его участник; иначе None. - Один запрос (JOIN/EXISTS), а не «загрузить чат, потом проверить в Python». - Для постороннего и для несуществующего чата результат одинаков (None -> 404), - чтобы не раскрывать существование чужого чата. + Алгоритм: + 1. stmt = select(Chat).join(ChatMember, ChatMember.chat_id == Chat.id) + .where(Chat.id == chat_id, ChatMember.user_id == user_id) + .options(selectinload(Chat.members)) + 2. result = await session.execute(stmt); return result.scalar_one_or_none() + Посторонний и несуществующий чат дают одинаковый None (-> 404). """ raise NotImplementedError("TODO") -def list_chats_for_user( - session: Session, +async def list_chats_for_user( + session: AsyncSession, 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 + Алгоритм: + 1. stmt = select(Chat).join(ChatMember, ChatMember.chat_id == Chat.id) + .where(ChatMember.user_id == user_id) + 2. если after: stmt = stmt.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after)) + 3. stmt = stmt.order_by(Chat.created_at, Chat.id).limit(limit) + .options(selectinload(Chat.members)) + 4. result = await session.execute(stmt); return list(result.scalars().all()) Вызывающий передаёт limit + 1, чтобы узнать, есть ли следующая страница. - Участников грузите selectinload (без N+1). """ raise NotImplementedError("TODO") diff --git a/app/storage/messages.py b/app/storage/messages.py index 8ce4899a..ca590391 100644 --- a/app/storage/messages.py +++ b/app/storage/messages.py @@ -1,41 +1,49 @@ from uuid import UUID -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.models.message import Message from app.storage.types import Position -def create_message( - session: Session, +async def create_message( + session: AsyncSession, *, chat_id: UUID, sender_id: UUID, text: str, ) -> Message: - """INSERT сообщения и flush(); id и created_at назначает сервер, не клиент.""" + """INSERT сообщения и flush; id и created_at назначает сервер, не клиент. + + Алгоритм: message = Message(...); session.add(message); await session.flush(); return message. + """ raise NotImplementedError("TODO") -def list_messages( - session: Session, +async def list_messages( + session: AsyncSession, chat_id: UUID, after: Position | None, limit: int, ) -> list[Message]: """Сообщения чата по (created_at, id) по возрастанию, строго после `after`. - Это keyset-запрос под индекс (chat_id, created_at, id): никакого OFFSET. - Вызывающий передаёт limit + 1 (признак следующей страницы). + Алгоритм: + 1. stmt = select(Message).where(Message.chat_id == chat_id) + 2. если after: stmt = stmt.where(tuple_(Message.created_at, Message.id) > tuple_(*after)) + 3. stmt = stmt.order_by(Message.created_at, Message.id).limit(limit) + 4. result = await session.execute(stmt); return list(result.scalars().all()) + Keyset под индекс (chat_id, created_at, id), без OFFSET. Вызывающий передаёт limit + 1. """ raise NotImplementedError("TODO") -def count_messages(session: Session) -> int: +async def count_messages(session: AsyncSession) -> int: """Общее число сообщений — для лимита MAX_MESSAGES (503). - Решение для отчёта: SELECT count(*) честный, но O(n) на каждую отправку. - Альтернативы: приблизительная оценка из pg_class.reltuples или отдельная - таблица-счётчик, обновляемая в той же транзакции. Выберите и обоснуйте. + Алгоритм (простой): result = await session.execute(select(func.count()).select_from(Message)); + return result.scalar_one(). + count(*) — O(n) на каждую отправку. Альтернативы: оценка из pg_class.reltuples + или таблица-счётчик в той же транзакции. Выберите и обоснуйте в отчёте. """ raise NotImplementedError("TODO") diff --git a/app/storage/sessions.py b/app/storage/sessions.py index 7cb02916..d00f4de6 100644 --- a/app/storage/sessions.py +++ b/app/storage/sessions.py @@ -1,46 +1,66 @@ from datetime import datetime from uuid import UUID -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.models.session import UserSession from app.models.user import User -def create_session( - session: Session, +async def create_session( + session: AsyncSession, *, user_id: UUID, token_hash: str, expires_at: datetime, ) -> UserSession: - """INSERT сессии (хранится только хеш токена) и flush().""" + """INSERT сессии (хранится только хеш токена) и flush. + + Алгоритм: + 1. row = UserSession(user_id=..., token_hash=..., expires_at=...) + 2. session.add(row); await session.flush(); return row + """ raise NotImplementedError("TODO") -def get_user_by_active_token_hash( - session: Session, +async def get_user_by_active_token_hash( + session: AsyncSession, token_hash: str, now: datetime, ) -> User | None: """Пользователь по хешу токена, если сессия действует. - Действует: revoked_at IS NULL AND expires_at > now. Один запрос с JOIN users. + Алгоритм: + 1. stmt = select(User).join(UserSession, UserSession.user_id == User.id) + .where(UserSession.token_hash == token_hash, + UserSession.revoked_at.is_(None), + UserSession.expires_at > now) + 2. result = await session.execute(stmt); return result.scalar_one_or_none() Истёкший, отозванный и неизвестный токен неразличимы для вызывающего (None). - `now` передаётся параметром (а не SQL now()), чтобы тесты могли управлять временем. + `now` передаётся параметром (а не SQL now()), чтобы тесты управляли временем. """ raise NotImplementedError("TODO") -def revoke_session(session: Session, token_hash: str, now: datetime) -> bool: - """Помечает действующую сессию отозванной (revoked_at = now). +async def revoke_session(session: AsyncSession, token_hash: str, now: datetime) -> bool: + """Помечает действующую сессию отозванной. - True — отозвана, False — такой действующей сессии нет (повторный logout -> 401). - Рекомендуется один атомарный UPDATE ... WHERE ... AND revoked_at IS NULL. + Алгоритм: + 1. stmt = update(UserSession) + .where(UserSession.token_hash == token_hash, + UserSession.revoked_at.is_(None), + UserSession.expires_at > now) + .values(revoked_at=now) + 2. result = await session.execute(stmt) + 3. return result.rowcount == 1 + Один атомарный UPDATE: два параллельных logout не отзовут сессию дважды. """ raise NotImplementedError("TODO") -def delete_expired_sessions(session: Session, now: datetime) -> int: - """(Необязательно) удаляет просроченные сессии, возвращает их число.""" +async def delete_expired_sessions(session: AsyncSession, now: datetime) -> int: + """(Необязательно) удаляет просроченные сессии, возвращает их число. + + Алгоритм: delete(UserSession).where(UserSession.expires_at <= now) -> rowcount. + """ raise NotImplementedError("TODO") diff --git a/app/storage/users.py b/app/storage/users.py index 600ba1ec..9be8aaf3 100644 --- a/app/storage/users.py +++ b/app/storage/users.py @@ -1,37 +1,54 @@ from collections.abc import Collection from uuid import UUID -from sqlalchemy.orm import Session +from sqlalchemy.ext.asyncio import AsyncSession from app.models.user import User -def create_user( - session: Session, +async def create_user( + session: AsyncSession, *, username: str, display_name: str, password_hash: str, ) -> User: - """INSERT пользователя и session.flush(). + """INSERT пользователя и flush. - Нарушение UNIQUE(username) поднимется здесь как sqlalchemy.exc.IntegrityError — - перехватывает его domain.users.register_user и превращает в 409. + Алгоритм: + 1. user = User(username=..., display_name=..., password_hash=...) + 2. session.add(user) (синхронный вызов, без await) + 3. await session.flush() (здесь INSERT уходит в БД, user.id и created_at заполнены) + 4. return user + Нарушение UNIQUE(username) поднимется на flush как IntegrityError — + его перехватывает domain.users.register_user и превращает в 409. + commit здесь НЕ вызывается. """ raise NotImplementedError("TODO") -def get_user_by_id(session: Session, user_id: UUID) -> User | None: +async def get_user_by_id(session: AsyncSession, user_id: UUID) -> User | None: + """Алгоритм: return await session.get(User, user_id).""" raise NotImplementedError("TODO") -def get_user_by_username(session: Session, username: str) -> User | None: +async def get_user_by_username(session: AsyncSession, username: str) -> User | None: + """Алгоритм: + 1. stmt = select(User).where(User.username == username) + 2. result = await session.execute(stmt) + 3. return result.scalar_one_or_none() + """ raise NotImplementedError("TODO") -def get_existing_user_ids(session: Session, user_ids: Collection[UUID]) -> set[UUID]: - """Какие из user_ids реально существуют — ОДНИМ запросом (WHERE id IN (...)). +async def get_existing_user_ids( + session: AsyncSession, user_ids: Collection[UUID] +) -> set[UUID]: + """Какие из user_ids существуют — ОДНИМ запросом. - Нужно для проверки member_ids при создании чата (без цикла из N запросов). + Алгоритм: + 1. stmt = select(User.id).where(User.id.in_(user_ids)) + 2. result = await session.execute(stmt) + 3. return set(result.scalars().all()) """ raise NotImplementedError("TODO") diff --git a/compose.yaml b/compose.yaml index 0794fbe8..40bae0b0 100644 --- a/compose.yaml +++ b/compose.yaml @@ -5,9 +5,7 @@ services: environment: POSTGRES_USER: ${DB_USER} POSTGRES_DB: ${DB_NAME} - POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password - secrets: - - postgres_password + POSTGRES_PASSWORD: ${DB_PASSWORD} volumes: - pgdata:/var/lib/postgresql/data ports: @@ -23,8 +21,6 @@ services: image: mtusi-messenger:lab2 command: ["alembic", "upgrade", "head"] env_file: .env - secrets: - - postgres_password depends_on: postgres: condition: service_healthy @@ -35,8 +31,6 @@ services: image: mtusi-messenger:lab2 restart: unless-stopped env_file: .env - secrets: - - postgres_password ports: - "127.0.0.1:8080:8080" depends_on: @@ -45,9 +39,5 @@ services: migrate: condition: service_completed_successfully -secrets: - postgres_password: - file: ./secrets/postgres_password - volumes: pgdata: \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py index 6e0b921e..d914a274 100644 --- a/migrations/env.py +++ b/migrations/env.py @@ -1,9 +1,10 @@ -"""Alembic: online/offline миграции из метаданных ORM-моделей.""" - +import asyncio from logging.config import fileConfig from alembic import context -from sqlalchemy import engine_from_config, pool +from sqlalchemy import pool +from sqlalchemy.engine import Connection +from sqlalchemy.ext.asyncio import async_engine_from_config from app.core.config import Settings from app.models import Base @@ -34,21 +35,31 @@ def run_migrations_offline() -> None: context.run_migrations() -def run_migrations_online() -> None: +def do_run_migrations(connection: Connection) -> None: + context.configure( + connection=connection, + target_metadata=target_metadata, + compare_type=True, + ) + with context.begin_transaction(): + context.run_migrations() + + +async def run_async_migrations() -> None: section = config.get_section(config.config_ini_section, {}) section["sqlalchemy.url"] = _database_url().replace("%", "%%") - connectable = engine_from_config( + connectable = async_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() + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + + await connectable.dispose() + + +def run_migrations_online() -> None: + asyncio.run(run_async_migrations()) if context.is_offline_mode(): diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..17dcba0e --- /dev/null +++ b/migrations/script.py.mako @@ -0,0 +1,25 @@ +"""${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/pytest.ini b/pytest.ini index 27eec68e..40a21d49 100644 --- a/pytest.ini +++ b/pytest.ini @@ -1,3 +1,6 @@ [pytest] testpaths = tests python_files = test_*.py +asyncio_mode = auto +asyncio_default_fixture_loop_scope = session +asyncio_default_test_loop_scope = session diff --git a/requirements.txt b/requirements.txt index 3da8ea22..c677d4d3 100644 --- a/requirements.txt +++ b/requirements.txt @@ -41,3 +41,8 @@ typing-inspection==0.4.4 typing_extensions==4.16.0 urllib3==2.8.0 uvicorn==0.54.0 +asyncpg +argon2-cffi +greenlet +pydantic-settings +pytest-asyncio diff --git a/tests/conftest.py b/tests/conftest.py index 16eae8de..e03b2950 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,28 +1,32 @@ -"""Фикстуры для тестов с РЕАЛЬНОЙ PostgreSQL (SQLite не подходит — см. README лабы). +"""Фикстуры для async-тестов с РЕАЛЬНОЙ PostgreSQL (SQLite не подходит). -Перед запуском поднимите БД и создайте тестовую базу: - make db-up # docker compose up -d postgres + createdb messenger_test +Перед запуском: `make db-up` (postgres + база _test). Переменные: - TEST_DATABASE_URL по умолчанию postgresql+psycopg://messenger:messenger@localhost:5432/messenger_test + TEST_DATABASE_URL по умолчанию postgresql+asyncpg://messenger:messenger@localhost:5432/messenger_test TEST_USE_MIGRATIONS=1 строить схему через `alembic upgrade head` вместо Base.metadata.create_all + +Все тесты и async-фикстуры живут в ОДНОМ event loop (pytest.ini: loop_scope=session), +поэтому пул соединений, созданный в фикстуре, можно использовать в тестах. """ +import asyncio import os -from collections.abc import Callable, Iterator +from collections.abc import AsyncIterator, Callable +import httpx 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 sqlalchemy import text +from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine +from sqlalchemy.pool import NullPool 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" + "postgresql+asyncpg://messenger:messenger@localhost:5432/messenger_test" ) @@ -36,17 +40,28 @@ def _alembic_config(url: str) -> Config: return config +async def upgrade_head(url: str) -> None: + """alembic command.upgrade внутри вызывает asyncio.run, поэтому — в отдельном потоке.""" + await asyncio.to_thread(command.upgrade, _alembic_config(url), "head") + + +async def reset_schema(engine: AsyncEngine) -> None: + async with engine.begin() as connection: + await connection.run_sync(Base.metadata.drop_all) + await connection.execute(text("DROP TABLE IF EXISTS alembic_version")) + + @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) +async def db_engine(database_url: str) -> AsyncIterator[AsyncEngine]: + engine = create_async_engine(database_url, poolclass=NullPool) try: - with engine.connect() as connection: - connection.execute(text("SELECT 1")) + async with engine.connect() as connection: + await connection.execute(text("SELECT 1")) except Exception as error: # noqa: BLE001 pytest.exit( f"PostgreSQL недоступна по {engine.url.render_as_string(hide_password=True)}: " @@ -54,28 +69,24 @@ def db_engine(database_url: str) -> Iterator[Engine]: returncode=2, ) - # Чистая схема на старте сессии: тесты не зависят от прошлых запусков. - Base.metadata.drop_all(engine) - with engine.begin() as connection: - connection.execute(text("DROP TABLE IF EXISTS alembic_version")) + await reset_schema(engine) if os.environ.get("TEST_USE_MIGRATIONS") == "1": - command.upgrade(_alembic_config(database_url), "head") + await upgrade_head(database_url) else: - Base.metadata.create_all(engine) + async with engine.begin() as connection: + await connection.run_sync(Base.metadata.create_all) yield engine - engine.dispose() + await engine.dispose() @pytest.fixture(autouse=True) -def clean_db(db_engine: Engine) -> Iterator[None]: - """Пустые таблицы перед каждым тестом (приложение коммитит, откат не годится).""" +async def clean_db(db_engine: AsyncEngine) -> 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 + async with db_engine.begin() as connection: + await connection.execute(text(f"TRUNCATE {names} RESTART IDENTITY CASCADE")) def build_settings(database_url: str, **overrides: object) -> Settings: @@ -102,32 +113,41 @@ def settings(database_url: str) -> Settings: @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 +def make_client(app, *, raise_app_exceptions: bool = True, timeout: float = 30) -> httpx.AsyncClient: + """ASGITransport не запускает lifespan, поэтому engine закрывает вызывающий (см. fixtures).""" + return httpx.AsyncClient( + transport=httpx.ASGITransport(app=app, raise_app_exceptions=raise_app_exceptions), + base_url="http://testserver", + timeout=timeout, + ) + + @pytest.fixture def app(settings: Settings): application = create_app(settings) @application.get("/__test__/explode", include_in_schema=False) - def explode() -> None: + async def explode() -> None: raise RuntimeError("test-secret") return application @pytest.fixture -def client(app) -> Iterator[TestClient]: - with TestClient(app) as test_client: +async def client(app) -> AsyncIterator[httpx.AsyncClient]: + async with make_client(app) as test_client: yield test_client + await app.state.engine.dispose() @pytest.fixture -def client_no_raise(app) -> Iterator[TestClient]: - with TestClient(app, raise_server_exceptions=False) as test_client: +async def client_no_raise(app) -> AsyncIterator[httpx.AsyncClient]: + async with make_client(app, raise_app_exceptions=False) as test_client: yield test_client + await app.state.engine.dispose() diff --git a/tests/helpers.py b/tests/helpers.py index f4fd81ae..76dd761a 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -1,7 +1,7 @@ import base64 from uuid import uuid4 -from fastapi.testclient import TestClient +from httpx import AsyncClient PASSWORD = "Correct-horse-battery-1" # синтетический пароль, только для тестов @@ -15,15 +15,15 @@ def bearer(actor: dict) -> dict[str, str]: return {"Authorization": "Bearer " + actor["token"]} -def register( - client: TestClient, +async def register( + client: AsyncClient, 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( + response = await client.post( "/api/v1/users", json={ "username": actual_username, @@ -35,8 +35,8 @@ def register( return {**response.json(), "password": password} -def login(client: TestClient, user: dict) -> dict: - response = client.post( +async def login(client: AsyncClient, user: dict) -> dict: + response = await client.post( "/api/v1/auth/sessions", headers=basic_header(user["username"], user["password"]), ) @@ -44,19 +44,19 @@ def login(client: TestClient, user: dict) -> dict: return {**user, "token": response.json()["token"]} -def create_user(client: TestClient, **kwargs) -> dict: +async def create_user(client: AsyncClient, **kwargs) -> dict: """Регистрация + вход: актор с полями id, username, token, ...""" - return login(client, register(client, **kwargs)) + return await login(client, await register(client, **kwargs)) -def create_chat( - client: TestClient, +async def create_chat( + client: AsyncClient, user: dict, *members: dict, title: str = "Тестовый чат", ) -> dict: member_ids = [user["id"], *(member["id"] for member in members)] - response = client.post( + response = await client.post( "/api/v1/chats", headers=bearer(user), json={"title": title, "member_ids": member_ids}, @@ -65,8 +65,8 @@ def create_chat( return response.json() -def send_message(client: TestClient, user: dict, chat: dict, text: str): - return client.post( +async def send_message(client: AsyncClient, user: dict, chat: dict, text: str): + return await client.post( f"/api/v1/chats/{chat['id']}/messages", headers=bearer(user), json={"text": text}, diff --git a/tests/test_auth.py b/tests/test_auth.py index ddf0eb88..bdd49e69 100644 --- a/tests/test_auth.py +++ b/tests/test_auth.py @@ -1,9 +1,10 @@ -import time +import asyncio from datetime import datetime -from fastapi.testclient import TestClient +from httpx import AsyncClient from app.main import create_app +from tests.conftest import make_client from tests.helpers import ( PASSWORD, assert_request_id, @@ -15,10 +16,10 @@ from tests.helpers import ( ) -def test_login_returns_opaque_bearer_session(client: TestClient): - user = register(client) +async def test_login_returns_opaque_bearer_session(client: AsyncClient): + user = await register(client) - response = client.post( + response = await client.post( "/api/v1/auth/sessions", headers=basic_header(user["username"], user["password"]), ) @@ -35,34 +36,34 @@ def test_login_returns_opaque_bearer_session(client: TestClient): 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) +async def test_each_login_issues_a_different_token(client: AsyncClient): + user = await register(client) + first = await login(client, user) + second = await login(client, user) assert first["token"] != second["token"] -def test_password_with_colon_works(client: TestClient): - user = register(client, password="pass:with:colons-123") +async def test_password_with_colon_works(client: AsyncClient): + user = await register(client, password="pass:with:colons-123") - assert login(client, user)["token"] + assert (await login(client, user))["token"] -def test_unicode_password_works(client: TestClient): - user = register(client, password="Пароль-с-юникодом-🔑-123") +async def test_unicode_password_works(client: AsyncClient): + user = await register(client, password="Пароль-с-юникодом-🔑-123") - assert login(client, user)["token"] + assert (await login(client, user))["token"] -def test_wrong_password_and_unknown_user_look_identical(client: TestClient): - user = register(client) +async def test_wrong_password_and_unknown_user_look_identical(client: AsyncClient): + user = await register(client) - wrong_password = client.post( + wrong_password = await client.post( "/api/v1/auth/sessions", headers=basic_header(user["username"], "wrong-password-123"), ) - unknown_user = client.post( + unknown_user = await client.post( "/api/v1/auth/sessions", headers=basic_header("no_such_user", "wrong-password-123"), ) @@ -75,18 +76,18 @@ def test_wrong_password_and_unknown_user_look_identical(client: TestClient): 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) +async def test_login_requires_basic_scheme(client: AsyncClient): + user = await register(client) + session = await login(client, user) for headers in ({}, bearer(session), {"Authorization": "Basic !!!not-base64"}): - response = client.post("/api/v1/auth/sessions", headers=headers) + response = await 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) +async def test_business_endpoints_require_bearer(client: AsyncClient): + user = await register(client) for headers in ( {}, @@ -95,18 +96,18 @@ def test_business_endpoints_require_bearer(client: TestClient): {"Authorization": "Bearer unknown-token-value"}, {"X-User-Id": user["id"]}, ): - response = client.get("/api/v1/users/me", headers=headers) + response = await 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) +async def test_x_user_id_cannot_override_bearer_identity(client: AsyncClient): + alice = await create_user(client) + eve = await create_user(client) - response = client.get( + response = await client.get( "/api/v1/users/me", headers={**bearer(alice), "X-User-Id": eve["id"]}, ) @@ -115,61 +116,64 @@ def test_x_user_id_cannot_override_bearer_identity(client: TestClient): 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) +async def test_logout_revokes_only_current_session(client: AsyncClient): + user = await register(client) + first = await login(client, user) + second = await login(client, user) - assert client.delete("/api/v1/auth/sessions/current", headers=bearer(first)).status_code == 204 + assert (await 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 + assert (await client.get("/api/v1/users/me", headers=bearer(first))).status_code == 401 + assert (await client.get("/api/v1/users/me", headers=bearer(second))).status_code == 200 -def test_logout_twice_returns_401(client: TestClient): - session = create_user(client) +async def test_logout_twice_returns_401(client: AsyncClient): + session = await 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)) + first = await client.delete("/api/v1/auth/sessions/current", headers=bearer(session)) + again = await 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): +async 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 + async with make_client(app) as client: + session = await create_user(client) + assert (await client.get("/api/v1/users/me", headers=bearer(session))).status_code == 200 - time.sleep(3) + await asyncio.sleep(3) - response = client.get("/api/v1/users/me", headers=bearer(session)) + response = await client.get("/api/v1/users/me", headers=bearer(session)) assert response.status_code == 401 assert response.headers["WWW-Authenticate"].startswith("Bearer") + await app.state.engine.dispose() -def test_token_is_not_stored_in_plaintext(client: TestClient, db_engine): +async def test_token_is_not_stored_in_plaintext(client: AsyncClient, db_engine): from sqlalchemy import text - session = create_user(client) + session = await create_user(client) - with db_engine.connect() as connection: - stored = connection.execute(text("SELECT token_hash FROM sessions")).scalars().all() + async with db_engine.connect() as connection: + result = await connection.execute(text("SELECT token_hash FROM sessions")) + stored = result.scalars().all() assert stored and session["token"] not in stored -def test_password_is_not_stored_in_plaintext(client: TestClient, db_engine): +async def test_password_is_not_stored_in_plaintext(client: AsyncClient, db_engine): from sqlalchemy import text - register(client, username="hash_check") + await register(client, username="hash_check") - with db_engine.connect() as connection: - stored = connection.execute( + async with db_engine.connect() as connection: + result = await connection.execute( text("SELECT password_hash FROM users WHERE username = 'hash_check'") - ).scalar_one() + ) + stored = result.scalar_one() assert PASSWORD not in stored assert stored.startswith("$argon2id$") diff --git a/tests/test_chats.py b/tests/test_chats.py index 3f58d22e..1a94b897 100644 --- a/tests/test_chats.py +++ b/tests/test_chats.py @@ -2,17 +2,17 @@ from urllib.parse import quote from uuid import uuid4 import pytest -from fastapi.testclient import TestClient +from httpx import AsyncClient 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) +async def test_create_and_get_chat(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + chat = await create_chat(client, alice, bob) - response = client.get( + response = await client.get( f"/api/v1/chats/{chat['id']}", headers=bearer(bob), ) @@ -22,13 +22,13 @@ def test_create_and_get_chat(client: TestClient): 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) +async def test_chat_is_not_visible_to_outsider(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + eve = await create_user(client) + chat = await create_chat(client, alice, bob) - response = client.get( + response = await client.get( f"/api/v1/chats/{chat['id']}", headers=bearer(eve), ) @@ -38,11 +38,11 @@ def test_chat_is_not_visible_to_outsider(client: TestClient): assert_request_id(response) -def test_chat_creation_requires_creator_in_members(client: TestClient): - alice = create_user(client) - bob = create_user(client) +async def test_chat_creation_requires_creator_in_members(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) - response = client.post( + response = await client.post( "/api/v1/chats", headers=bearer(alice), json={"title": "Чат", "member_ids": [bob["id"]]}, @@ -59,11 +59,11 @@ def test_chat_creation_requires_creator_in_members(client: TestClient): {"title": " ", "member_ids": []}, ], ) -def test_chat_payload_boundaries(client: TestClient, payload: dict): - alice = create_user(client) +async def test_chat_payload_boundaries(client: AsyncClient, payload: dict): + alice = await create_user(client) payload["member_ids"] = [alice["id"]] - response = client.post( + response = await client.post( "/api/v1/chats", headers=bearer(alice), json=payload, @@ -73,11 +73,11 @@ def test_chat_payload_boundaries(client: TestClient, payload: dict): assert response.json()["error"]["code"] == "invalid_request" -def test_duplicate_members_are_rejected(client: TestClient): - alice = create_user(client) - bob = create_user(client) +async def test_duplicate_members_are_rejected(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) - response = client.post( + response = await client.post( "/api/v1/chats", headers=bearer(alice), json={"title": "Чат", "member_ids": [alice["id"], bob["id"], bob["id"]]}, @@ -87,10 +87,10 @@ def test_duplicate_members_are_rejected(client: TestClient): assert response.json()["error"]["code"] == "invalid_request" -def test_unknown_member_is_rejected(client: TestClient): - alice = create_user(client) +async def test_unknown_member_is_rejected(client: AsyncClient): + alice = await create_user(client) - response = client.post( + response = await client.post( "/api/v1/chats", headers=bearer(alice), json={"title": "Чат", "member_ids": [alice["id"], str(uuid4())]}, @@ -100,9 +100,9 @@ def test_unknown_member_is_rejected(client: TestClient): assert response.json()["error"]["code"] == "invalid_request" -def test_chat_exact_title_limit_is_accepted(client: TestClient): - alice = create_user(client) - response = client.post( +async def test_chat_exact_title_limit_is_accepted(client: AsyncClient): + alice = await create_user(client) + response = await client.post( "/api/v1/chats", headers=bearer(alice), json={"title": "x" * 100, "member_ids": [alice["id"]]}, @@ -112,13 +112,13 @@ def test_chat_exact_title_limit_is_accepted(client: TestClient): 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") +async def test_chat_list_hides_chats_without_membership(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + chat_for_bob = await create_chat(client, bob, title="Only Bob") + chat_for_alice = await create_chat(client, alice, title="Only Alice") - response = client.get( + response = await client.get( "/api/v1/chats?limit=100", headers=bearer(alice), ) @@ -129,10 +129,10 @@ def test_chat_list_hides_chats_without_membership(client: TestClient): assert chat_for_bob["id"] not in ids -def test_nonexistent_chat_returns_404(client: TestClient): - alice = create_user(client) +async def test_nonexistent_chat_returns_404(client: AsyncClient): + alice = await create_user(client) - response = client.get( + response = await client.get( "/api/v1/chats/00000000-0000-4000-8000-000000000000", headers=bearer(alice), ) @@ -142,44 +142,45 @@ def test_nonexistent_chat_returns_404(client: TestClient): assert_request_id(response) -def test_failed_chat_creation_leaves_no_partial_data(client: TestClient, db_engine): +async def test_failed_chat_creation_leaves_no_partial_data(client: AsyncClient, db_engine): """Атомарность: неизвестный участник -> нет ни чата, ни записей членства.""" from sqlalchemy import text - alice = create_user(client) - response = client.post( + alice = await create_user(client) + response = await 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 - ) + async with db_engine.connect() as connection: + chats = (await connection.execute(text("SELECT count(*) FROM chats"))).scalar_one() + members = ( + await connection.execute(text("SELECT count(*) FROM chat_members")) + ).scalar_one() + assert chats == 0 and members == 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)] +async def test_chat_list_pagination_and_order(client: AsyncClient): + alice = await create_user(client) + chats = [await 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( + page1 = (await client.get("/api/v1/chats?limit=2", headers=bearer(alice))).json() + page2 = (await client.get( f"/api/v1/chats?limit=2&cursor={quote(page1['next_cursor'], safe='')}", headers=bearer(alice), - ).json() - page3 = client.get( + )).json() + page3 = (await client.get( f"/api/v1/chats?limit=2&cursor={quote(page2['next_cursor'], safe='')}", headers=bearer(alice), - ).json() + )).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) +async def test_chat_endpoints_require_bearer(client: AsyncClient): + assert (await client.get("/api/v1/chats")).status_code == 401 + assert (await 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 index 253e6228..a45cb03d 100644 --- a/tests/test_concurrency.py +++ b/tests/test_concurrency.py @@ -4,129 +4,111 @@ import asyncio from collections import Counter from uuid import uuid4 -import httpx -from fastapi.testclient import TestClient +from sqlalchemy import text from app.main import create_app -from tests.helpers import PASSWORD, bearer, create_chat, create_user +from tests.conftest import make_client +from tests.helpers import PASSWORD, bearer, create_user -def test_parallel_registration_of_same_username_creates_exactly_one_user(make_settings): - """Источник истины для уникальности — UNIQUE в БД, а не проверка «SELECT, потом INSERT».""" +async def test_parallel_registration_of_same_username_creates_exactly_one_user(make_settings): 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) + async with make_client(app) 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] + ) + await app.state.engine.dispose() - statuses = Counter(asyncio.run(scenario())) - - assert statuses == Counter({201: 1, 409: 15}), statuses # ни одного 500 + statuses = Counter(response.status_code for response in responses) + assert statuses == Counter({201: 1, 409: 15}), statuses -def test_100_messages_from_10_clients(make_settings): +async 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( + async with make_client(app) as client: + users = [ + await create_user(client, username=f"load_{i}_{uuid4().hex[:6]}") + for i in range(10) + ] + created = await client.post( "/api/v1/chats", headers=bearer(users[0]), json={"title": "Concurrency", "member_ids": [u["id"] for u in users]}, - ).json() + ) + chat = created.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: + async def worker(index: int, user: dict) -> list[dict]: responses = await asyncio.gather( *( client.post( - "/api/v1/chats", - headers=bearer(alice), - json={"title": f"c{i}", "member_ids": [alice["id"], bob["id"]]}, + f"/api/v1/chats/{chat['id']}/messages", + headers=bearer(user), + json={"text": f"client-{index}-message-{n}"}, ) - for i in range(10) + for n in range(10) ) ) - assert all(r.status_code == 201 for r in responses) + 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] - asyncio.run(scenario()) + results = await asyncio.gather(*(worker(i, u) for i, u in enumerate(users))) + messages = [m for batch in results for m in batch] - 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 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 + await app.state.engine.dispose() + + +async def test_chat_creation_in_parallel_is_atomic(make_settings, db_engine): + app = create_app(make_settings(max_in_flight=32, db_pool_size=20, db_max_overflow=20)) + + async with make_client(app) as client: + alice = await create_user(client) + bob = await create_user(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) + await app.state.engine.dispose() + + async with db_engine.connect() as connection: + chats = (await connection.execute(text("SELECT count(*) FROM chats"))).scalar_one() + members = ( + await 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 index 23da3cf9..bb1f2a42 100644 --- a/tests/test_constraints.py +++ b/tests/test_constraints.py @@ -7,12 +7,12 @@ 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") +async def test_duplicate_username_is_rejected_by_database(client, db_engine): + await create_user(client, username="unique_name") with pytest.raises(IntegrityError): - with db_engine.begin() as connection: - connection.execute( + async with db_engine.begin() as connection: + await connection.execute( text( "INSERT INTO users (id, username, display_name, password_hash) " "VALUES (gen_random_uuid(), 'unique_name', 'Other', 'hash')" @@ -20,12 +20,12 @@ def test_duplicate_username_is_rejected_by_database(client, db_engine): ) -def test_message_requires_existing_chat(client, db_engine): - alice = create_user(client) +async def test_message_requires_existing_chat(client, db_engine): + alice = await create_user(client) with pytest.raises(IntegrityError): - with db_engine.begin() as connection: - connection.execute( + async with db_engine.begin() as connection: + await connection.execute( text( "INSERT INTO messages (id, chat_id, sender_id, text) " "VALUES (gen_random_uuid(), gen_random_uuid(), :sender, 'x')" @@ -34,13 +34,13 @@ def test_message_requires_existing_chat(client, db_engine): ) -def test_duplicate_membership_is_rejected_by_database(client, db_engine): - alice = create_user(client) - chat = create_chat(client, alice) +async def test_duplicate_membership_is_rejected_by_database(client, db_engine): + alice = await create_user(client) + chat = await create_chat(client, alice) with pytest.raises(IntegrityError): - with db_engine.begin() as connection: - connection.execute( + async with db_engine.begin() as connection: + await 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 index 9e7e47e2..cea533ba 100644 --- a/tests/test_errors.py +++ b/tests/test_errors.py @@ -1,21 +1,21 @@ import logging import json -from fastapi.testclient import TestClient +from httpx import AsyncClient from tests.helpers import assert_request_id -def test_missing_token_returns_401(client: TestClient): - response = client.get("/api/v1/users/me") +async def test_missing_token_returns_401(client: AsyncClient): + response = await 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( +async def test_garbage_token_returns_401(client: AsyncClient): + response = await client.get( "/api/v1/users/me", headers={"Authorization": "Bearer garbage"} ) @@ -24,8 +24,8 @@ def test_garbage_token_returns_401(client: TestClient): assert_request_id(response) -def test_malformed_json_returns_400(client: TestClient): - response = client.post( +async def test_malformed_json_returns_400(client: AsyncClient): + response = await client.post( "/api/v1/users", content='{"username":"alice",', headers={"Content-Type": "application/json"}, @@ -36,25 +36,25 @@ def test_malformed_json_returns_400(client: TestClient): assert_request_id(response) -def test_not_found_returns_404(client: TestClient): - response = client.get("/no-such-path") +async def test_not_found_returns_404(client: AsyncClient): + response = await 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") +async def test_method_not_allowed_preserves_405(client: AsyncClient): + response = await 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): +async def test_unhandled_exception_is_hidden_from_client(client_no_raise: AsyncClient, caplog): with caplog.at_level(logging.ERROR, logger="app.errors.handlers"): - response = client_no_raise.get("/__test__/explode") + response = await client_no_raise.get("/__test__/explode") assert response.status_code == 500 payload = response.json() @@ -67,8 +67,8 @@ def test_unhandled_exception_is_hidden_from_client(client_no_raise: TestClient, assert_request_id(response) -def test_success_response_contains_request_id(client: TestClient): - response = client.get("/health/live") +async def test_success_response_contains_request_id(client: AsyncClient): + response = await 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 index 6b5c46f5..66b7de98 100644 --- a/tests/test_health.py +++ b/tests/test_health.py @@ -1,52 +1,52 @@ -from fastapi.testclient import TestClient +from httpx import AsyncClient from app.main import create_app +from tests.conftest import make_client from tests.helpers import assert_request_id -def test_liveness(client: TestClient): - response = client.get("/health/live") +async def test_liveness(client: AsyncClient): + response = await 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") +async def test_readiness(client: AsyncClient): + response = await 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.""" +async def test_readiness_is_503_when_database_is_down(make_settings): app = create_app( make_settings( - database_url="postgresql+psycopg://nobody:nopass@127.0.0.1:1/none", + database_url="postgresql+asyncpg://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 + async with make_client(app) as client: + assert (await client.get("/health/live")).status_code == 200 - ready = client.get("/health/ready") + ready = await client.get("/health/ready") assert ready.status_code == 503 assert ready.json()["error"]["code"] == "unavailable" assert_request_id(ready) + await app.state.engine.dispose() -def test_business_request_is_503_when_database_is_down(make_settings): - """Недоступность БД не превращается в 500 и не раскрывает детали подключения.""" +async def test_business_request_is_503_when_database_is_down(make_settings): app = create_app( make_settings( - database_url="postgresql+psycopg://nobody:secretpass@127.0.0.1:1/none", + database_url="postgresql+asyncpg://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( + async with make_client(app, raise_app_exceptions=False) as client: + response = await client.post( "/api/v1/users", json={ "username": "alice", @@ -54,6 +54,7 @@ def test_business_request_is_503_when_database_is_down(make_settings): "password": "Correct-horse-battery-1", }, ) + await app.state.engine.dispose() assert response.status_code == 503 assert response.json()["error"]["code"] == "unavailable" diff --git a/tests/test_limits.py b/tests/test_limits.py index 658114a1..01b72f94 100644 --- a/tests/test_limits.py +++ b/tests/test_limits.py @@ -1,12 +1,11 @@ """Остаток трека «управляемая деградация»: 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.conftest import make_client from tests.helpers import assert_request_id, bearer, create_chat, create_user @@ -17,87 +16,74 @@ def _assert_error(response: httpx.Response, status: int, code: str) -> None: assert response.headers.get("X-Request-Id") == body["error"]["request_id"] -def test_message_limit_rejects_without_deleting_confirmed_messages(make_settings): +async 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) + async with make_client(app) as client: + user = await create_user(client) + chat = await 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}"}) + ok = await 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"}) + rejected = await client.post(url, headers=bearer(user), json={"text": "rejected"}) _assert_error(rejected, 503, "unavailable") - history = client.get(f"{url}?limit=100", headers=bearer(user)) + history = await 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"] + await app.state.engine.dispose() -def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypatch): +async 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() + all_slots_taken = asyncio.Event() + release = asyncio.Event() - def blocking_send_message(*args, **kwargs): + async 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) + accepted_count += 1 + if accepted_count == 2: + all_slots_taken.set() + await asyncio.wait_for(release.wait(), timeout=5) + return await original_send_message(*args, **kwargs) - # Подготовка данных до подмены (на ней же проверяем, что слоты освобождаются). - with TestClient(app) as setup_client: - user = create_user(setup_client) - chat = create_chat(setup_client, user) + async with make_client(app, timeout=10) as client: + user = await create_user(client) + chat = await create_chat(client, user) - monkeypatch.setattr(message_endpoint, "send_message", blocking_send_message) - url = f"/api/v1/chats/{chat['id']}/messages" + 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) - ] + 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) + await asyncio.wait_for(all_slots_taken.wait(), timeout=2) - rejected = await asyncio.gather( - *( - client.post(url, headers=bearer(user), json={"text": f"rejected-{i}"}) - for i in range(4) - ) + 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" + ) + 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 + assert (await client.get("/health/live")).status_code == 200 - release.set() - assert all(r.status_code == 201 for r in await asyncio.gather(*held)) + 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()) + recovered = await client.post(url, headers=bearer(user), json={"text": "after"}) + assert recovered.status_code == 201 + assert_request_id(recovered) + await app.state.engine.dispose() diff --git a/tests/test_messages.py b/tests/test_messages.py index 3ab19aaa..fb657b8e 100644 --- a/tests/test_messages.py +++ b/tests/test_messages.py @@ -1,7 +1,7 @@ from urllib.parse import quote import pytest -from fastapi.testclient import TestClient +from httpx import AsyncClient from tests.helpers import ( assert_request_id, @@ -12,16 +12,16 @@ from tests.helpers import ( ) -def _message(client: TestClient, user: dict, chat: dict, text: str): - return send_message(client, user, chat, text) +async def _message(client: AsyncClient, user: dict, chat: dict, text: str): + return await 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) +async def test_send_and_list_message(client: AsyncClient): + alice = await create_user(client) + bob = await create_user(client) + chat = await create_chat(client, alice, bob) - created = _message(client, alice, chat, "Привет, мир 👋") + created = await _message(client, alice, chat, "Привет, мир 👋") assert created.status_code == 201 message = created.json() @@ -29,7 +29,7 @@ def test_send_and_list_message(client: TestClient): assert message["chat_id"] == chat["id"] assert_request_id(created) - listed = client.get( + listed = await client.get( f"/api/v1/chats/{chat['id']}/messages?limit=1", headers=bearer(bob), ) @@ -41,22 +41,22 @@ def test_send_and_list_message(client: TestClient): @pytest.mark.parametrize("text", ["", " ", "x" * 4001]) -def test_invalid_message_text(client: TestClient, text: str): - alice = create_user(client) - chat = create_chat(client, alice) +async def test_invalid_message_text(client: AsyncClient, text: str): + alice = await create_user(client) + chat = await create_chat(client, alice) - response = _message(client, alice, chat, text) + response = await _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) +async def test_extra_message_field_is_rejected(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) - response = client.post( + response = await client.post( f"/api/v1/chats/{chat['id']}/messages", headers=bearer(alice), json={"text": "hello", "sender_id": alice["id"]}, @@ -67,13 +67,13 @@ def test_extra_message_field_is_rejected(client: TestClient): 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, "секрет") +async def test_messages_are_private_to_chat_members(client: AsyncClient): + alice = await create_user(client) + eve = await create_user(client) + chat = await create_chat(client, alice) + await _message(client, alice, chat, "секрет") - response = client.get( + response = await client.get( f"/api/v1/chats/{chat['id']}/messages", headers=bearer(eve), ) @@ -82,26 +82,26 @@ def test_messages_are_private_to_chat_members(client: TestClient): assert response.json()["error"]["code"] == "not_found" -def test_pagination_has_no_duplicates(client: TestClient): - alice = create_user(client) - chat = create_chat(client, alice) +async def test_pagination_has_no_duplicates(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) created = [ - _message(client, alice, chat, f"message-{index}").json() for index in range(5) + (await _message(client, alice, chat, f"message-{index}")).json() for index in range(5) ] - page1 = client.get( + page1 = (await client.get( f"/api/v1/chats/{chat['id']}/messages?limit=2", headers=bearer(alice), - ).json() - page2 = client.get( + )).json() + page2 = (await client.get( f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page1['next_cursor'], safe='')}", headers=bearer(alice), - ).json() - page3 = client.get( + )).json() + page3 = (await client.get( f"/api/v1/chats/{chat['id']}/messages?limit=2&cursor={quote(page2['next_cursor'], safe='')}", headers=bearer(alice), - ).json() + )).json() ids = [item["id"] for page in (page1, page2, page3) for item in page["items"]] assert ids == [item["id"] for item in created] @@ -112,22 +112,22 @@ def test_pagination_has_no_duplicates(client: TestClient): 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") +async def test_cursor_cannot_be_used_for_another_chat(client: AsyncClient): + alice = await create_user(client) + chat_a = await create_chat(client, alice, title="A") + chat_b = await 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") + await _message(client, alice, chat_a, "a1") + await _message(client, alice, chat_a, "a2") + await _message(client, alice, chat_b, "b1") + await _message(client, alice, chat_b, "b2") - page = client.get( + page = (await client.get( f"/api/v1/chats/{chat_a['id']}/messages?limit=1", headers=bearer(alice), - ).json() + )).json() - response = client.get( + response = await client.get( f"/api/v1/chats/{chat_b['id']}/messages?limit=1&cursor={quote(page['next_cursor'], safe='')}", headers=bearer(alice), ) @@ -139,12 +139,12 @@ def test_cursor_cannot_be_used_for_another_chat(client: TestClient): @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") +async def test_limit_boundaries(client: AsyncClient, limit: int, expected_status: int): + alice = await create_user(client) + chat = await create_chat(client, alice) + await _message(client, alice, chat, "one") - response = client.get( + response = await client.get( f"/api/v1/chats/{chat['id']}/messages?limit={limit}", headers=bearer(alice), ) @@ -153,20 +153,20 @@ def test_limit_boundaries(client: TestClient, limit: int, expected_status: int): assert_request_id(response) -def test_message_exact_max_length_is_accepted(client: TestClient): - alice = create_user(client) - chat = create_chat(client, alice) +async def test_message_exact_max_length_is_accepted(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) - response = _message(client, alice, chat, "x" * 4000) + response = await _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) +async def test_nonexistent_chat_messages_return_404(client: AsyncClient): + alice = await create_user(client) - response = client.get( + response = await client.get( "/api/v1/chats/00000000-0000-4000-8000-000000000000/messages", headers=bearer(alice), ) @@ -176,40 +176,40 @@ def test_nonexistent_chat_messages_return_404(client: TestClient): assert_request_id(response) -def test_unauthenticated_requests_are_rejected(client: TestClient): - alice = create_user(client) - chat = create_chat(client, alice) +async def test_unauthenticated_requests_are_rejected(client: AsyncClient): + alice = await create_user(client) + chat = await 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 + assert (await client.get(url)).status_code == 401 + assert (await client.post(url, json={"text": "hi"})).status_code == 401 -def test_messages_survive_new_login(client: TestClient): +async def test_messages_survive_new_login(client: AsyncClient): """Сообщения принадлежат пользователю, а не сессии: после 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 = await create_user(client) + chat = await create_chat(client, alice) + message = (await _message(client, alice, chat, "до выхода")).json() + await client.delete("/api/v1/auth/sessions/current", headers=bearer(alice)) - alice_again = login(client, alice) - listed = client.get( + alice_again = await login(client, alice) + listed = await 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) +async def test_history_order_is_created_at_then_id(client: AsyncClient): + alice = await create_user(client) + chat = await create_chat(client, alice) created = [_message(client, alice, chat, f"m{i}").json() for i in range(10)] - listed = client.get( + listed = (await client.get( f"/api/v1/chats/{chat['id']}/messages?limit=100", headers=bearer(alice) - ).json()["items"] + )).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] diff --git a/tests/test_migrations.py b/tests/test_migrations.py index 0779810b..ef1c3727 100644 --- a/tests/test_migrations.py +++ b/tests/test_migrations.py @@ -1,61 +1,57 @@ """Миграции с нуля: «миграции с нуля и повторный запуск без дублирования данных».""" 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 sqlalchemy import inspect, text from app.models import Base -from tests.conftest import _alembic_config +from tests.conftest import reset_schema, upgrade_head 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")) +async def migrated_engine(database_url, db_engine): + await reset_schema(db_engine) + await upgrade_head(database_url) + yield db_engine - 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() + await reset_schema(db_engine) + async with db_engine.begin() as connection: + await connection.run_sync(Base.metadata.create_all) -def test_upgrade_creates_all_tables(migrated_engine): - assert EXPECTED_TABLES <= set(inspect(migrated_engine).get_table_names()) +async def test_upgrade_creates_all_tables(migrated_engine): + async with migrated_engine.connect() as connection: + tables = await connection.run_sync(lambda sync: set(inspect(sync).get_table_names())) + assert EXPECTED_TABLES <= tables -def test_upgrade_twice_is_idempotent_and_keeps_data(migrated_engine, database_url): - with migrated_engine.begin() as connection: - connection.execute( +async def test_upgrade_twice_is_idempotent_and_keeps_data(migrated_engine, database_url): + async with migrated_engine.begin() as connection: + await 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") # повторный запуск + await upgrade_head(database_url) - with migrated_engine.connect() as connection: - count = connection.execute( - text("SELECT count(*) FROM users WHERE username = 'keep_me'") + async with migrated_engine.connect() as connection: + count = ( + await 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) +async def test_models_and_migrations_are_in_sync(migrated_engine): + def compare(sync_connection): + context = MigrationContext.configure(sync_connection, opts={"compare_type": True}) + return compare_metadata(context, Base.metadata) + + async with migrated_engine.connect() as connection: + diff = await connection.run_sync(compare) assert diff == [], f"Создайте миграцию: alembic revision --autogenerate. Diff: {diff}" diff --git a/tests/test_users.py b/tests/test_users.py index c60af251..996b3006 100644 --- a/tests/test_users.py +++ b/tests/test_users.py @@ -1,11 +1,11 @@ import pytest -from fastapi.testclient import TestClient +from httpx import AsyncClient from tests.helpers import PASSWORD, assert_request_id, bearer, create_user, register -def test_register_does_not_leak_password(client: TestClient): - response = client.post( +async def test_register_does_not_leak_password(client: AsyncClient): + response = await client.post( "/api/v1/users", json={"username": "alice", "display_name": "Алиса 👋", "password": PASSWORD}, ) @@ -17,10 +17,10 @@ def test_register_does_not_leak_password(client: TestClient): assert_request_id(response) -def test_get_current_user(client: TestClient): - user = create_user(client, display_name="Алиса 👋") +async def test_get_current_user(client: AsyncClient): + user = await create_user(client, display_name="Алиса 👋") - response = client.get("/api/v1/users/me", headers=bearer(user)) + response = await client.get("/api/v1/users/me", headers=bearer(user)) assert response.status_code == 200 assert response.json()["id"] == user["id"] @@ -43,17 +43,17 @@ def test_get_current_user(client: TestClient): {"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) +async def test_invalid_user_payloads(client: AsyncClient, body: dict): + response = await 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): +async def test_password_length_boundaries_are_accepted(client: AsyncClient): for index, password in enumerate(["x" * 12, "y" * 128, " " * 12, "п" * 12]): - response = client.post( + response = await client.post( "/api/v1/users", json={ "username": f"pw_user_{index}", @@ -64,8 +64,8 @@ def test_password_length_boundaries_are_accepted(client: TestClient): assert response.status_code == 201, (index, response.text) -def test_extra_user_field_is_rejected(client: TestClient): - response = client.post( +async def test_extra_user_field_is_rejected(client: AsyncClient): + response = await client.post( "/api/v1/users", json={ "username": "alice", @@ -79,10 +79,10 @@ def test_extra_user_field_is_rejected(client: TestClient): assert response.json()["error"]["code"] == "invalid_request" -def test_duplicate_username_returns_conflict(client: TestClient): - user = register(client, username="duplicate_user") +async def test_duplicate_username_returns_conflict(client: AsyncClient): + user = await register(client, username="duplicate_user") - response = client.post( + response = await client.post( "/api/v1/users", json={ "username": user["username"], @@ -96,8 +96,8 @@ def test_duplicate_username_returns_conflict(client: TestClient): assert_request_id(response) -def test_user_exact_length_boundaries_are_accepted(client: TestClient): +async def test_user_exact_length_boundaries_are_accepted(client: AsyncClient): for length in (3, 32): - user = register(client, username=("a" * length), display_name="d" * 100) + user = await register(client, username=("a" * length), display_name="d" * 100) assert len(user["username"]) == length assert len(user["display_name"]) == 100