add async with all functions
This commit is contained in:
+5
-1
@@ -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
|
||||
|
||||
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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
@@ -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")
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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")
|
||||
|
||||
@@ -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
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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
@@ -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
|
||||
(подумайте, по каким колонкам идёт сортировка и фильтр по участнику)
|
||||
"""
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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():
|
||||
|
||||
@@ -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"}
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user