add async with all functions

This commit is contained in:
2026-10-23 00:20:58 +03:00
parent a85702a30e
commit 7b7ca1b888
42 changed files with 901 additions and 763 deletions
+5 -1
View File
@@ -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
+6 -8
View File
@@ -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
+14 -17
View File
@@ -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,
+19 -30
View File
@@ -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
+26 -8
View File
@@ -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()
+43 -13
View File
@@ -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")
+4 -2
View File
@@ -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.
"""
+27 -21
View File
@@ -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")
+25 -19
View File
@@ -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")
+25 -25
View File
@@ -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")
+14 -10
View File
@@ -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")
+7 -7
View File
@@ -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)
+10 -10
View File
@@ -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)
+17 -18
View File
@@ -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)
+2 -4
View File
@@ -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")
+7 -7
View File
@@ -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)
+5 -5
View File
@@ -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
+3
View File
@@ -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)
+1 -1
View File
@@ -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)
+1 -1
View File
@@ -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
(подумайте, по каким колонкам идёт сортировка и фильтр по участнику)
"""
+3 -3
View File
@@ -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).
"""
+31 -16
View File
@@ -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")
+20 -12
View File
@@ -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")
+34 -14
View File
@@ -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")
+28 -11
View File
@@ -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")
+1 -11
View File
@@ -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:
+24 -13
View File
@@ -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():
+25
View File
@@ -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"}
+3
View File
@@ -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
+5
View File
@@ -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
+52 -32
View File
@@ -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 + база <DB_NAME>_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()
+13 -13
View File
@@ -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},
+60 -56
View File
@@ -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$")
+58 -57
View File
@@ -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)
+78 -96
View File
@@ -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
+13 -13
View File
@@ -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"]},
)
+15 -15
View File
@@ -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")
+17 -16
View File
@@ -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"
+43 -57
View File
@@ -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()
+73 -73
View File
@@ -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]
+27 -31
View File
@@ -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}"
+17 -17
View File
@@ -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