ЛР 2: мессенджер на PostgreSQL и сессии в Redis
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
2026-10-23 12:16:56 +03:00
parent 65003b6119
commit 1dd701be2b
69 changed files with 2163 additions and 30 deletions
+6 -5
View File
@@ -4,8 +4,9 @@ APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
POSTGRES_USER=messenger
POSTGRES_PASSWORD=change-me-local
POSTGRES_DB=messenger
DATABASE_URL=postgresql+asyncpg://messenger:change-me-local@postgres:5432/messenger
REDIS_URL=redis://redis:6379/0
+17
View File
@@ -0,0 +1,17 @@
FROM python:3.13.15-slim
WORKDIR /app
COPY requirements.txt .
RUN python -m pip install -r requirements.txt \
&& useradd --uid 10001 --user-group --no-create-home --shell /usr/sbin/nologin app
COPY app ./app
COPY alembic ./alembic
COPY alembic.ini .
USER 10001:10001
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-c", "import urllib.request;urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=3).read()"]
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "5"]
+14
View File
@@ -0,0 +1,14 @@
FROM python:3.13.15-slim
WORKDIR /tests
COPY requirements-dev.txt .
RUN python -m pip install --no-cache-dir -r requirements-dev.txt \
&& useradd --uid 10001 --user-group --no-create-home --shell /usr/sbin/nologin tests
COPY lab.json .
COPY contracts ./contracts
COPY tests ./tests
RUN chown -R tests:tests /tests
USER 10001:10001
CMD ["pytest", "-q"]
+14 -3
View File
@@ -1,13 +1,14 @@
PYTHON ?= python3
PYTHON ?= $(if $(wildcard .venv/bin/python),.venv/bin/python,python3)
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
COMPOSE_ENV ?= .env
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test test-docker test-dependencies explain-messages load test-persistence
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "check: offline structure; validate: full OpenAPI; test: running API; test-docker: isolated Docker test stack; test-dependencies: Redis/PostgreSQL outages; explain-messages: 10k-message query plan"
check:
$(PYTHON) scripts/check_contract.py
@@ -18,6 +19,16 @@ validate:
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-docker:
@docker compose -p mtusi2026lab2-tests -f compose.tests.yaml up -d --build --wait api; status=$$?; if [ $$status -eq 0 ]; then docker compose -p mtusi2026lab2-tests -f compose.tests.yaml run --build --rm tests; status=$$?; fi; docker compose -p mtusi2026lab2-tests -f compose.tests.yaml down -v --remove-orphans; exit $$status
test-dependencies:
sh scripts/test-dependencies.sh "$(BASE_URL)" "$(COMPOSE_ENV)"
explain-messages:
@docker compose --env-file "$(COMPOSE_ENV)" exec -T postgres sh -c 'psql -v ON_ERROR_STOP=1 -U "$$POSTGRES_USER" -d "$$POSTGRES_DB"' < scripts/explain-messages.sql > evidence/explain-messages.txt
@echo "Saved EXPLAIN output to evidence/explain-messages.txt"
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
+74 -22
View File
@@ -1,37 +1,89 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Сергей Возжин, БПИ2301
- Целевая оценка: 4
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Библиотеки: FastAPI, SQLAlchemy, Alembic, asyncpg, Redis, argon2-cffi.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker Desktop и Docker Compose. Локальный `.env` создаётся из примера и
не попадает в Git:
```sh
cp .env.example .env
# Заменить POSTGRES_PASSWORD и соответственно DATABASE_URL в .env.
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
docker compose --env-file .env ps
make test
pytest -q
make test-docker
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-dependencies
```
`migrate` один раз запускает `alembic upgrade head` после готовности PostgreSQL.
API доступен на `http://localhost:8080`; его readiness-проверка доступна по
`/health/ready`. Обычная остановка сохраняет данные:
```sh
docker compose --env-file .env down
```
Намеренно удалить учебные данные можно только отдельной командой:
```sh
docker compose --env-file .env down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```text
Client -- Basic/Bearer --> FastAPI
|-- PostgreSQL: users, chats, chat_members, messages
`-- Redis: session:<sha256(token)> с TTL
```
## Доказательства критериев
PostgreSQL — источник истины для пользователей, чатов, членства и сообщений.
`users.username` уникален; `chat_members` имеет составной primary key
`(chat_id, user_id)`; история сообщений использует индекс
`messages(chat_id, created_at, id)` и keyset-пагинацию.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
Сессия — случайный opaque Bearer-токен, не JWT. При логине пароль проверяется
Argon2id, сервер кладёт в Redis только `user_id` по SHA-256 токена с TTL.
Logout удаляет этот ключ. Redis — единственный источник истины для активных
сессий; включены AOF и named volume, поэтому неистёкшая сессия переживает
контролируемый рестарт без удаления volumes. Access/refresh-пары не используются:
их нет в публичном контракте.
Регистрация и отправка сообщения выполняются в транзакциях. Создание чата также
атомарно: проверка всех участников, вставка чата и всех `chat_members` находятся
в одном `session.begin()`. Каждый конкретный репозиторий сам открывает сессию и
свою транзакцию; сервисы содержат только бизнес-правила и не зависят от SQLAlchemy.
## Проверки и доказательства
| Критерий README | Команда/сценарий | Ожидаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный контракт | `make test` | 20.10.2026: PASS, lab2 public API scenario | `evidence/smoke.txt` |
| Гонка username | `pytest` | 20.10.2026: PASS; проверка требует один `201` и семь `409` | `evidence/concurrency.txt` |
| Logout | `pytest` | 20.10.2026: PASS; отозванный token получает `401` | `evidence/own-tests.txt` |
| Expiry | `make test-docker` поднимает изолированные PostgreSQL, Redis и API с TTL=1 | 20.10.2026: PASS; токен получает `401` после TTL | `evidence/own-tests.txt` |
| Пароль и rollback | `make test-docker` | 20.10.2026: PASS; неверный Basic-пароль даёт `401`; чат с неизвестным участником не сохраняется | `evidence/own-tests.txt` |
| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | 23.10.2026: PASS; тот же Bearer-token и сообщения доступны после рестарта. `StartedAt` всех трёх контейнеров до и после хука подтверждает перезапуск API, PostgreSQL и Redis | `evidence/lifecycle.txt` |
| План запроса | `make explain-messages` создаёт 10 000 строк в транзакции и выполняет `EXPLAIN (ANALYZE, BUFFERS)` | 20.10.2026: `Index Scan using messages_history_idx`, 100 строк за 0.025 ms; затем `ROLLBACK` | `evidence/explain-messages.txt` |
| Отказ Redis/БД | `make test-dependencies` | 20.10.2026: PASS; Redis и PostgreSQL по очереди дают `503` на readiness и восстанавливаются; анонимный `401` проверяется smoke-тестом | `evidence/dependency-failure.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
В перечисленных файлах лежит фактический вывод этих команд с датой прогона.
Стенд — один хост (macOS, Docker Desktop), образы `postgres:17.4-alpine` и
`redis:7.4.2-alpine`, API в контейнере из `Dockerfile`. Bearer-токены, пароли и
содержимое `.env` в evidence не попадали: тесты держат токен только в памяти
процесса, а скрипты выводят лишь коды ответов и состояния контейнеров.
## Эксперименты и отказы
## Ограничения
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Это учебный сервис: один экземпляр API, нет rate limiting, MFA, восстановления
пароля и logout-all. При недоступности Redis защищённые endpoint’ы не считают
клиента аутентифицированным и отвечают `503`; при недоступности PostgreSQL API
также возвращает ограниченную ошибку. TTL сессии не скользящий.
+36
View File
@@ -0,0 +1,36 @@
[alembic]
script_location = alembic
prepend_sys_path = .
sqlalchemy.url = placeholder://configured-at-runtime
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
[logger_sqlalchemy]
level = WARN
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
+53
View File
@@ -0,0 +1,53 @@
from __future__ import annotations
import asyncio
from logging.config import fileConfig
from alembic import context
from sqlalchemy import pool
from sqlalchemy.ext.asyncio import async_engine_from_config
from app.config import load_settings
from app.db.postgres import Base
from app import models # noqa: F401 - imports ORM models into Base.metadata
config = context.config
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
def _url() -> str:
return load_settings().database_url
def run_migrations_offline() -> None:
context.configure(url=_url(), target_metadata=target_metadata, literal_binds=True, dialect_opts={'paramstyle': 'named'})
with context.begin_transaction():
context.run_migrations()
def _run_migrations(connection) -> None:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
async def _run_migrations_async() -> None:
configuration = config.get_section(config.config_ini_section, {})
configuration['sqlalchemy.url'] = _url()
connectable = async_engine_from_config(configuration, prefix='sqlalchemy.', poolclass=pool.NullPool)
async with connectable.connect() as connection:
await connection.run_sync(_run_migrations)
await connectable.dispose()
def run_migrations_online() -> None:
asyncio.run(_run_migrations_async())
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+22
View File
@@ -0,0 +1,22 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision = ${repr(up_revision)}
down_revision = ${repr(down_revision)}
branch_labels = ${repr(branch_labels)}
depends_on = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,64 @@
"""Initial PostgreSQL schema for lab 2.
Revision ID: 20261019_0001
Revises:
Create Date: 2026-10-19
"""
from alembic import op
import sqlalchemy as sa
revision = '20261019_0001'
down_revision = None
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
'users',
sa.Column('id', sa.Uuid(), nullable=False),
sa.Column('username', sa.String(length=32), nullable=False),
sa.Column('display_name', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('username'),
)
op.create_table(
'chats',
sa.Column('id', sa.Uuid(), nullable=False),
sa.Column('title', sa.String(length=100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.PrimaryKeyConstraint('id'),
)
op.create_table(
'chat_members',
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('user_id', sa.Uuid(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('chat_id', 'user_id'),
)
op.create_index('chat_members_user_chat_idx', 'chat_members', ['user_id', 'chat_id'])
op.create_table(
'messages',
sa.Column('id', sa.Uuid(), nullable=False),
sa.Column('chat_id', sa.Uuid(), nullable=False),
sa.Column('sender_id', sa.Uuid(), nullable=False),
sa.Column('text', sa.String(length=4000), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id']),
sa.PrimaryKeyConstraint('id'),
)
op.create_index('messages_history_idx', 'messages', ['chat_id', 'created_at', 'id'])
def downgrade() -> None:
op.drop_index('messages_history_idx', table_name='messages')
op.drop_table('messages')
op.drop_index('chat_members_user_chat_idx', table_name='chat_members')
op.drop_table('chat_members')
op.drop_table('chats')
op.drop_table('users')
+1
View File
@@ -0,0 +1 @@
"""Мессенджер на PostgreSQL и Redis, лабораторная 2."""
+1
View File
@@ -0,0 +1 @@
"""HTTP-граница: FastAPI, коды состояния, формат ошибок, курсоры."""
+28
View File
@@ -0,0 +1,28 @@
import base64
import json
from uuid import UUID
from ..domain.errors import Invalid
from ..domain.models import Keyset
from .timefmt import from_rfc3339, to_rfc3339
MAX_LENGTH = 512
def encode(scope: str, position: Keyset) -> str:
payload = {'s': scope, 't': to_rfc3339(position.created_at), 'i': str(position.id)}
raw = json.dumps(payload, separators=(',', ':'), sort_keys=True).encode('utf-8')
return base64.urlsafe_b64encode(raw).decode('ascii').rstrip('=')
def decode(scope: str, value: str) -> Keyset:
if not value or len(value) > MAX_LENGTH:
raise Invalid('cursor недействителен для этого запроса')
try:
raw = base64.urlsafe_b64decode(value + '=' * (-len(value) % 4))
payload = json.loads(raw)
if not isinstance(payload, dict) or payload.get('s') != scope:
raise ValueError('scope mismatch')
return Keyset(created_at=from_rfc3339(payload['t']), id=UUID(payload['i']))
except Exception:
raise Invalid('cursor недействителен для этого запроса') from None
+72
View File
@@ -0,0 +1,72 @@
from __future__ import annotations
from dataclasses import dataclass
from fastapi import Depends, Header, HTTPException, Request, status
from ..db.redis import RedisSessionStore
from ..domain.errors import Unauthorized
from ..domain.models import User
from ..services.chats import ChatService
from ..services.messages import MessageService
from ..services.users import UserService
_BEARER_CHALLENGE = 'Bearer realm="messenger"'
@dataclass(frozen=True, slots=True)
class Services:
users: UserService
chats: ChatService
messages: MessageService
sessions: RedisSessionStore
def services(request: Request) -> Services:
return request.app.state.services
def user_service(container: Services = Depends(services)) -> UserService:
return container.users
def chat_service(container: Services = Depends(services)) -> ChatService:
return container.chats
def message_service(container: Services = Depends(services)) -> MessageService:
return container.messages
def session_store(container: Services = Depends(services)) -> RedisSessionStore:
return container.sessions
def _bearer_error() -> HTTPException:
return HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='требуется действующая Bearer-сессия',
headers={'WWW-Authenticate': _BEARER_CHALLENGE},
)
async def bearer_token(authorization: str | None = Header(None)) -> str:
if not authorization:
raise _bearer_error()
scheme, separator, token = authorization.partition(' ')
if scheme.lower() != 'bearer' or not separator or not token or token.strip() != token:
raise _bearer_error()
return token
async def current_user(
token: str = Depends(bearer_token),
container: Services = Depends(services),
) -> User:
user_id = await container.sessions.get_user_id(token)
if user_id is None:
raise _bearer_error()
try:
return await container.users.identify(user_id)
except Unauthorized:
raise _bearer_error() from None
+96
View File
@@ -0,0 +1,96 @@
import logging
from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from sqlalchemy.exc import SQLAlchemyError
from starlette.exceptions import HTTPException as StarletteHTTPException
from ..domain.errors import Conflict, DomainError, Invalid, NotFound, Unauthorized, Unavailable
logger = logging.getLogger('app.error')
CODE_BY_STATUS = {
400: 'invalid_request',
401: 'unauthorized',
404: 'not_found',
409: 'conflict',
413: 'payload_too_large',
415: 'unsupported_media_type',
429: 'rate_limited',
500: 'internal_error',
503: 'unavailable',
}
STATUS_BY_DOMAIN = {
Invalid: 400,
Unauthorized: 401,
NotFound: 404,
Conflict: 409,
Unavailable: 503,
}
def code_for(status: int) -> str:
if status in CODE_BY_STATUS:
return CODE_BY_STATUS[status]
return 'invalid_request' if status < 500 else 'internal_error'
def error_response(status: int, message: str, request_id: str, code: str = '') -> JSONResponse:
return JSONResponse(
status_code=status,
content={'error': {'code': code or code_for(status), 'message': message, 'request_id': request_id}},
)
def _domain_status(error: DomainError) -> int:
for kind, status in STATUS_BY_DOMAIN.items():
if isinstance(error, kind):
return status
return 500
def _describe(error: RequestValidationError) -> str:
"""Краткое указание на пол, без stack trace и внутреннего устройства"""
for item in error.errors():
if item.get('type') == 'json_invalid':
return 'тело запроса не является корректным JSON'
location = '.'.join(str(part) for part in item.get('loc', ()) if part != 'body')
return f'некорректное поле {location}' if location else 'некорректный запрос'
return 'некорректный запрос'
def request_id(request) -> str:
return getattr(request.state, 'request_id', 'unknown')
def install(app: FastAPI) -> None:
@app.exception_handler(DomainError)
async def _on_domain(request, error: DomainError) -> JSONResponse:
return error_response(_domain_status(error), error.message, request_id(request))
@app.exception_handler(RequestValidationError)
async def _on_validation(request, error: RequestValidationError) -> JSONResponse:
return error_response(400, _describe(error), request_id(request))
@app.exception_handler(SQLAlchemyError)
async def _on_database(request, error: SQLAlchemyError) -> JSONResponse:
logger.warning('database error request_id=%s type=%s', request_id(request), type(error).__name__)
return error_response(503, 'база данных недоступна', request_id(request))
@app.exception_handler(OSError)
async def _on_storage_socket(request, error: OSError) -> JSONResponse:
logger.warning('storage socket error request_id=%s type=%s', request_id(request), type(error).__name__)
return error_response(503, 'обязательное хранилище недоступно', request_id(request))
@app.exception_handler(StarletteHTTPException)
async def _on_http(request, error: StarletteHTTPException) -> JSONResponse:
message = error.detail if isinstance(error.detail, str) and error.detail else 'ошибка запроса'
response = error_response(error.status_code, message, request_id(request))
for name, value in (error.headers or {}).items():
response.headers[name] = value
return response
__all__ = ['code_for', 'error_response', 'install']
+38
View File
@@ -0,0 +1,38 @@
import logging
from uuid import uuid4
from starlette.datastructures import MutableHeaders
from .errors import error_response
logger = logging.getLogger('app')
class RequestContext:
def __init__(self, app) -> None:
self.app = app
async def __call__(self, scope, receive, send) -> None:
if scope['type'] != 'http':
await self.app(scope, receive, send)
return
request_id = uuid4().hex
scope.setdefault('state', {})['request_id'] = request_id
started = False
async def send_wrapper(message) -> None:
nonlocal started
if message['type'] == 'http.response.start':
started = True
MutableHeaders(scope=message)['X-Request-Id'] = request_id
await send(message)
try:
await self.app(scope, receive, send_wrapper)
except Exception:
logger.exception(f'unhandled error request_id={request_id} path={scope.get("path")}')
if started:
raise
response = error_response(500, 'внутренняя ошибка', request_id)
await response(scope, receive, send_wrapper)
+3
View File
@@ -0,0 +1,3 @@
from . import auth, chats, health, messages, users
__all__ = ['auth', 'chats', 'health', 'messages', 'users']
+71
View File
@@ -0,0 +1,71 @@
from __future__ import annotations
import base64
from binascii import Error as Base64Error
from fastapi import APIRouter, Depends, Header, HTTPException, status
from ...auth.tokens import create_token
from ...db.redis import RedisSessionStore
from ...domain.models import User
from ...services.users import UserService
from ..deps import bearer_token, current_user, session_store, user_service
from ..schemas import SessionOut, UserOut
from ..timefmt import to_rfc3339
router = APIRouter(prefix='/api/v1/auth/sessions', tags=['auth'])
_BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
def _unauthorized_basic() -> HTTPException:
return HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail='неверные учётные данные',
headers={'WWW-Authenticate': _BASIC_CHALLENGE},
)
def _parse_basic(authorization: str | None) -> tuple[str, str]:
if not authorization:
raise _unauthorized_basic()
scheme, separator, encoded = authorization.partition(' ')
if scheme.lower() != 'basic' or not separator or not encoded:
raise _unauthorized_basic()
try:
decoded = base64.b64decode(encoded, validate=True).decode('utf-8')
except (Base64Error, UnicodeDecodeError):
raise _unauthorized_basic() from None
username, separator, password = decoded.partition(':')
if not separator or not username:
raise _unauthorized_basic()
return username, password
@router.post('', status_code=status.HTTP_201_CREATED, response_model=SessionOut)
async def create_session(
authorization: str | None = Header(None),
users: UserService = Depends(user_service),
sessions: RedisSessionStore = Depends(session_store),
) -> SessionOut:
username, password = _parse_basic(authorization)
user = await users.authenticate(username, password)
if user is None:
raise _unauthorized_basic()
token = create_token()
expires_at = await sessions.create(user.id, token)
return SessionOut(
token=token,
token_type='Bearer',
expires_at=to_rfc3339(expires_at),
user=UserOut.from_domain(user),
)
@router.delete('/current', status_code=status.HTTP_204_NO_CONTENT, response_model=None)
async def revoke_session(
token: str = Depends(bearer_token),
_: User = Depends(current_user),
sessions: RedisSessionStore = Depends(session_store),
) -> None:
await sessions.revoke(token)
+49
View File
@@ -0,0 +1,49 @@
from typing import Optional
from uuid import UUID
from fastapi import APIRouter, Depends, Query
from ...domain.models import User
from ...services.chats import ChatService
from .. import cursors
from ..deps import chat_service, current_user
from ..schemas import (
LIMIT_DEFAULT,
LIMIT_MAX,
LIMIT_MIN,
ChatOut,
ChatPageOut,
CreateChat,
)
router = APIRouter(prefix='/api/v1/chats', tags=['chats'])
@router.post('', status_code=201, response_model=ChatOut)
async def create(
body: CreateChat,
actor: User = Depends(current_user),
chats: ChatService = Depends(chat_service),
) -> ChatOut:
return ChatOut.from_domain(await chats.create(actor, body.title, body.member_ids))
@router.get('', response_model=ChatPageOut)
async def page(
actor: User = Depends(current_user),
chats: ChatService = Depends(chat_service),
limit: int = Query(LIMIT_DEFAULT, ge=LIMIT_MIN, le=LIMIT_MAX),
cursor: Optional[str] = Query(None, min_length=1, max_length=cursors.MAX_LENGTH),
) -> ChatPageOut:
scope = f'chats:{actor.id}'
after = cursors.decode(scope, cursor) if cursor is not None else None
return ChatPageOut.from_domain(await chats.page(actor, after, limit), scope)
@router.get('/{chat_id}', response_model=ChatOut)
async def get(
chat_id: UUID,
actor: User = Depends(current_user),
chats: ChatService = Depends(chat_service),
) -> ChatOut:
return ChatOut.from_domain(await chats.get(actor, chat_id))
+28
View File
@@ -0,0 +1,28 @@
from fastapi import APIRouter, HTTPException, Request
from redis.exceptions import RedisError
from sqlalchemy import text
from sqlalchemy.exc import SQLAlchemyError
from ...domain.errors import Unavailable
from ..schemas import HealthOut
router = APIRouter(tags=['health'])
@router.get('/health/live', response_model=HealthOut)
async def live() -> HealthOut:
return HealthOut(status='ok')
@router.get('/health/ready', response_model=HealthOut)
async def ready(request: Request) -> HealthOut:
if not request.app.state.ready:
raise HTTPException(status_code=503, detail='приложение не готово принимать трафик')
try:
async with request.app.state.engine.connect() as connection:
await connection.execute(text('SELECT 1'))
await request.app.state.redis.ping()
except (SQLAlchemyError, RedisError, Unavailable, OSError):
raise HTTPException(status_code=503, detail='обязательное хранилище недоступно') from None
return HealthOut(status='ok')
+42
View File
@@ -0,0 +1,42 @@
from typing import Optional
from uuid import UUID
from fastapi import APIRouter, Depends, Query
from ...domain.models import User
from ...services.messages import MessageService
from .. import cursors
from ..deps import current_user, message_service
from ..schemas import (
LIMIT_DEFAULT,
LIMIT_MAX,
LIMIT_MIN,
CreateMessage,
MessageOut,
MessagePageOut,
)
router = APIRouter(prefix='/api/v1/chats/{chat_id}/messages', tags=['messages'])
@router.post('', status_code=201, response_model=MessageOut)
async def send(
chat_id: UUID,
body: CreateMessage,
actor: User = Depends(current_user),
messages: MessageService = Depends(message_service),
) -> MessageOut:
return MessageOut.from_domain(await messages.send(actor, chat_id, body.text))
@router.get('', response_model=MessagePageOut)
async def page(
chat_id: UUID,
actor: User = Depends(current_user),
messages: MessageService = Depends(message_service),
limit: int = Query(LIMIT_DEFAULT, ge=LIMIT_MIN, le=LIMIT_MAX),
cursor: Optional[str] = Query(None, min_length=1, max_length=cursors.MAX_LENGTH),
) -> MessagePageOut:
scope = f'messages:{chat_id}'
after = cursors.decode(scope, cursor) if cursor is not None else None
return MessagePageOut.from_domain(await messages.history(actor, chat_id, after, limit), scope)
+18
View File
@@ -0,0 +1,18 @@
from fastapi import APIRouter, Depends
from ...domain.models import User
from ...services.users import UserService
from ..deps import current_user, user_service
from ..schemas import CreateUser, UserOut
router = APIRouter(prefix='/api/v1', tags=['users'])
@router.post('/users', status_code=201, response_model=UserOut)
async def register(body: CreateUser, users: UserService = Depends(user_service)) -> UserOut:
return UserOut.from_domain(await users.register(body.username, body.display_name, body.password))
@router.get('/users/me', response_model=UserOut)
async def me(actor: User = Depends(current_user)) -> UserOut:
return UserOut.from_domain(actor)
+147
View File
@@ -0,0 +1,147 @@
from typing import Optional
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
from ..domain.models import Chat, Message, Page, User
from . import cursors
from .timefmt import to_rfc3339
NAME_MAX = 100
TEXT_MAX = 4000
MEMBERS_MAX = 100
LIMIT_MIN = 1
LIMIT_MAX = 100
LIMIT_DEFAULT = 50
def not_blank(value: str) -> str:
if not value.strip():
raise ValueError('строка не может состоять только из пробельных символов')
return value
class Strict(BaseModel):
model_config = ConfigDict(extra='forbid')
class HealthOut(Strict):
status: str = 'ok'
class CreateUser(Strict):
username: str = Field(min_length=3, max_length=32, pattern=r'^[a-z0-9_]{3,32}$')
display_name: str = Field(min_length=1, max_length=NAME_MAX)
password: str = Field(min_length=12, max_length=128)
@field_validator('display_name')
@classmethod
def _display_name(cls, value: str) -> str:
return not_blank(value)
class UserOut(Strict):
id: UUID
username: str
display_name: str
created_at: str
@classmethod
def from_domain(cls, user: User) -> 'UserOut':
return cls(
id=user.id,
username=user.username,
display_name=user.display_name,
created_at=to_rfc3339(user.created_at),
)
class SessionOut(Strict):
token: str = Field(min_length=32)
token_type: str = 'Bearer'
expires_at: str
user: UserOut
class CreateChat(Strict):
title: str = Field(min_length=1, max_length=NAME_MAX)
member_ids: list[UUID] = Field(min_length=1, max_length=MEMBERS_MAX)
@field_validator('title')
@classmethod
def _title(cls, value: str) -> str:
return not_blank(value)
@field_validator('member_ids')
@classmethod
def _members_unique(cls, value: list[UUID]) -> list[UUID]:
if len(set(value)) != len(value):
raise ValueError('member_ids не должен содержать дубликаты')
return value
class ChatOut(Strict):
id: UUID
title: str
member_ids: list[UUID]
created_at: str
@classmethod
def from_domain(cls, chat: Chat) -> 'ChatOut':
return cls(
id=chat.id,
title=chat.title,
member_ids=list(chat.member_ids),
created_at=to_rfc3339(chat.created_at),
)
class CreateMessage(Strict):
text: str = Field(min_length=1, max_length=TEXT_MAX)
@field_validator('text')
@classmethod
def _text(cls, value: str) -> str:
return not_blank(value)
class MessageOut(Strict):
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: str
@classmethod
def from_domain(cls, message: Message) -> 'MessageOut':
return cls(
id=message.id,
chat_id=message.chat_id,
sender_id=message.sender_id,
text=message.text,
created_at=to_rfc3339(message.created_at),
)
class ChatPageOut(Strict):
items: list[ChatOut]
next_cursor: Optional[str]
@classmethod
def from_domain(cls, page: Page, scope: str) -> 'ChatPageOut':
return cls(
items=[ChatOut.from_domain(chat) for chat in page.items],
next_cursor=cursors.encode(scope, page.next) if page.next else None,
)
class MessagePageOut(Strict):
items: list[MessageOut]
next_cursor: Optional[str]
@classmethod
def from_domain(cls, page: Page, scope: str) -> 'MessagePageOut':
return cls(
items=[MessageOut.from_domain(message) for message in page.items],
next_cursor=cursors.encode(scope, page.next) if page.next else None,
)
+11
View File
@@ -0,0 +1,11 @@
from datetime import datetime, timezone
def to_rfc3339(value: datetime) -> str:
return value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z')
def from_rfc3339(value: str) -> datetime:
if not isinstance(value, str) or not value.endswith('Z'):
raise ValueError('timestamp must end with Z')
return datetime.fromisoformat(value[:-1]).replace(tzinfo=timezone.utc)
+4
View File
@@ -0,0 +1,4 @@
from .passwords import hash_password, password_matches
from .tokens import create_token
__all__ = ['create_token', 'hash_password', 'password_matches']
+15
View File
@@ -0,0 +1,15 @@
from argon2 import PasswordHasher
from argon2.exceptions import VerificationError, VerifyMismatchError
_hasher = PasswordHasher()
def hash_password(password: str) -> str:
return _hasher.hash(password)
def password_matches(stored_hash: str, password: str) -> bool:
try:
return _hasher.verify(stored_hash, password)
except (VerifyMismatchError, VerificationError):
return False
+11
View File
@@ -0,0 +1,11 @@
import hashlib
import secrets
def create_token() -> str:
return secrets.token_urlsafe(32)
def session_key(token: str) -> str:
digest = hashlib.sha256(token.encode('utf-8')).hexdigest()
return f'session:{digest}'
+3
View File
@@ -0,0 +1,3 @@
from .settings import Settings, load_settings
__all__ = ['Settings', 'load_settings']
+36
View File
@@ -0,0 +1,36 @@
from __future__ import annotations
import os
from dataclasses import dataclass
from pathlib import Path
def _read_value(name: str, file_name: str) -> str:
value = os.getenv(name)
if value:
return value
path = os.getenv(file_name)
if path:
return Path(path).read_text(encoding='utf-8').strip()
raise RuntimeError(f'не задана настройка {name} или {file_name}')
@dataclass(frozen=True, slots=True)
class Settings:
database_url: str
redis_url: str
session_ttl_seconds: int
def load_settings() -> Settings:
try:
ttl = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
except ValueError as exc:
raise RuntimeError('SESSION_TTL_SECONDS должен быть целым числом') from exc
if ttl <= 0:
raise RuntimeError('SESSION_TTL_SECONDS должен быть больше нуля')
return Settings(
database_url=_read_value('DATABASE_URL', 'DATABASE_URL_FILE'),
redis_url=_read_value('REDIS_URL', 'CACHE_URL_FILE'),
session_ttl_seconds=ttl,
)
+4
View File
@@ -0,0 +1,4 @@
from .postgres import Base, create_engine, create_session_factory
from .redis import RedisSessionStore, create_redis
__all__ = ['Base', 'RedisSessionStore', 'create_engine', 'create_redis', 'create_session_factory']
+23
View File
@@ -0,0 +1,23 @@
from __future__ import annotations
from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
pass
def create_engine(url: str) -> AsyncEngine:
return create_async_engine(
url,
pool_size=5,
max_overflow=5,
pool_timeout=5,
pool_pre_ping=True,
connect_args={'server_settings': {'statement_timeout': '5000'}},
)
def create_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
return async_sessionmaker(engine, expire_on_commit=False)
+51
View File
@@ -0,0 +1,51 @@
from __future__ import annotations
from datetime import datetime, timedelta, timezone
from uuid import UUID
from redis.asyncio import Redis
from redis.exceptions import RedisError
from ..auth.tokens import session_key
from ..domain.errors import Unavailable
def create_redis(url: str) -> Redis:
return Redis.from_url(url, decode_responses=True, socket_connect_timeout=3, socket_timeout=3)
class RedisSessionStore:
def __init__(self, client: Redis, ttl_seconds: int) -> None:
self._client = client
self._ttl_seconds = ttl_seconds
async def create(self, user_id: UUID, token: str) -> datetime:
try:
await self._client.set(session_key(token), str(user_id), ex=self._ttl_seconds)
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
return datetime.now(timezone.utc) + timedelta(seconds=self._ttl_seconds)
async def get_user_id(self, token: str) -> UUID | None:
try:
value = await self._client.get(session_key(token))
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
if value is None:
return None
try:
return UUID(value)
except ValueError:
return None
async def revoke(self, token: str) -> None:
try:
await self._client.delete(session_key(token))
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
async def ping(self) -> None:
try:
await self._client.ping()
except RedisError as exc:
raise Unavailable('хранилище сессий недоступно') from exc
View File
+29
View File
@@ -0,0 +1,29 @@
from __future__ import annotations
class DomainError(Exception):
"""Сообщение попадает клиенту, поэтому не содержит внутренних деталей."""
def __init__(self, message: str) -> None:
super().__init__(message)
self.message = message
class Invalid(DomainError):
"""Запрос нарушает правила предметной области."""
class Unauthorized(DomainError):
"""Нет действительной идентификации."""
class NotFound(DomainError):
"""Объекта нет либо он недоступен вызывающему: снаружи это неразличимо."""
class Conflict(DomainError):
"""Состояние не позволяет выполнить операцию."""
class Unavailable(DomainError):
"""Обязательная внешняя зависимость временно недоступна."""
+56
View File
@@ -0,0 +1,56 @@
from dataclasses import dataclass
from datetime import datetime
from typing import Optional
from uuid import UUID
@dataclass(frozen=True, slots=True)
class User:
id: UUID
username: str
display_name: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class Chat:
id: UUID
title: str
member_ids: tuple[UUID, ...]
created_at: datetime
def has_member(self, user_id: UUID) -> bool:
return user_id in self.member_ids
@dataclass(frozen=True, slots=True)
class Message:
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
@dataclass(frozen=True, slots=True)
class Keyset:
created_at: datetime
id: UUID
@property
def order(self) -> tuple[datetime, int]:
return (self.created_at, self.id.int)
@classmethod
def from_item(cls, item) -> 'Keyset':
return cls(created_at=item.created_at, id=item.id)
def order_key(item) -> tuple[datetime, int]:
return (item.created_at, item.id.int)
@dataclass(frozen=True, slots=True)
class Page:
items: tuple
next: Optional[Keyset]
+87
View File
@@ -0,0 +1,87 @@
"""Сборка FastAPI приложения и подключение обязательных хранилищ."""
from __future__ import annotations
import logging
import os
import sys
from contextlib import asynccontextmanager
from fastapi import FastAPI
from sqlalchemy import text
from .api import errors
from .api.deps import Services
from .api.middleware import RequestContext
from .api.routers import auth, chats, health, messages, users
from .config import load_settings
from .db import RedisSessionStore, create_engine, create_redis, create_session_factory
from .repositories import ChatRepository, MessageRepository, UserRepository
from .services.chats import ChatService
from .services.messages import MessageService
from .services.users import UserService
logger = logging.getLogger('app')
DESCRIPTION = 'PostgreSQL хранит данные мессенджера; Redis хранит активные сессии.'
def configure_logging() -> None:
logging.basicConfig(
level=os.getenv('LOG_LEVEL', 'info').upper(),
stream=sys.stdout,
format='%(asctime)s %(levelname)s %(name)s %(message)s',
force=True,
)
def create_app() -> FastAPI:
configure_logging()
@asynccontextmanager
async def lifespan(application: FastAPI):
application.state.ready = False
settings = load_settings()
engine = create_engine(settings.database_url)
redis = create_redis(settings.redis_url)
try:
async with engine.connect() as connection:
await connection.execute(text('SELECT 1'))
session_store = RedisSessionStore(redis, settings.session_ttl_seconds)
await session_store.ping()
session_factory = create_session_factory(engine)
user_repository = UserRepository(session_factory)
chat_repository = ChatRepository(session_factory)
message_repository = MessageRepository(session_factory)
application.state.services = Services(
users=UserService(user_repository),
chats=ChatService(chat_repository),
messages=MessageService(message_repository),
sessions=session_store,
)
application.state.engine = engine
application.state.redis = redis
application.state.ready = True
logger.info('startup storage=postgres redis_sessions=true')
yield
finally:
application.state.ready = False
await redis.aclose()
await engine.dispose()
logger.info('shutdown complete')
api = FastAPI(
title='MTUSI Messenger. LR 2',
version='1.2.0',
description=DESCRIPTION,
lifespan=lifespan,
)
api.router.redirect_slashes = False
api.state.ready = False
api.add_middleware(RequestContext)
errors.install(api)
for router in (health.router, users.router, auth.router, chats.router, messages.router):
api.include_router(router)
return api
app = create_app()
+5
View File
@@ -0,0 +1,5 @@
from .chat import ChatMemberRow, ChatRow
from .message import MessageRow
from .user import UserRow
__all__ = ['ChatMemberRow', 'ChatRow', 'MessageRow', 'UserRow']
+26
View File
@@ -0,0 +1,26 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import DateTime, ForeignKey, Index, String
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy.types import Uuid
from ..db.postgres import Base
class ChatRow(Base):
__tablename__ = 'chats'
id: Mapped[UUID] = mapped_column(Uuid, primary_key=True)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
class ChatMemberRow(Base):
__tablename__ = 'chat_members'
__table_args__ = (Index('chat_members_user_chat_idx', 'user_id', 'chat_id'),)
chat_id: Mapped[UUID] = mapped_column(ForeignKey('chats.id', ondelete='CASCADE'), primary_key=True)
user_id: Mapped[UUID] = mapped_column(ForeignKey('users.id', ondelete='CASCADE'), primary_key=True)
+21
View File
@@ -0,0 +1,21 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import DateTime, ForeignKey, Index, String
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy.types import Uuid
from ..db.postgres import Base
class MessageRow(Base):
__tablename__ = 'messages'
__table_args__ = (Index('messages_history_idx', 'chat_id', 'created_at', 'id'),)
id: Mapped[UUID] = mapped_column(Uuid, primary_key=True)
chat_id: Mapped[UUID] = mapped_column(ForeignKey('chats.id', ondelete='CASCADE'), nullable=False)
sender_id: Mapped[UUID] = mapped_column(ForeignKey('users.id'), nullable=False)
text: Mapped[str] = mapped_column(String(4000), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+20
View File
@@ -0,0 +1,20 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import DateTime, String, Text
from sqlalchemy.orm import Mapped, mapped_column
from sqlalchemy.types import Uuid
from ..db.postgres import Base
class UserRow(Base):
__tablename__ = 'users'
id: Mapped[UUID] = mapped_column(Uuid, primary_key=True)
username: Mapped[str] = mapped_column(String(32), unique=True, nullable=False)
display_name: Mapped[str] = mapped_column(String(100), nullable=False)
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
+5
View File
@@ -0,0 +1,5 @@
from .chats import ChatRepository
from .messages import MessageRepository
from .users import UserRepository
__all__ = ['ChatRepository', 'MessageRepository', 'UserRepository']
+69
View File
@@ -0,0 +1,69 @@
from __future__ import annotations
from datetime import datetime
from typing import Sequence
from uuid import UUID
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from ..domain.errors import Invalid
from ..domain.models import Chat, Keyset
from ..models.chat import ChatMemberRow, ChatRow
from ..models.user import UserRow
class ChatRepository:
def __init__(self, sessions: async_sessionmaker[AsyncSession]) -> None:
self._sessions = sessions
@staticmethod
def _to_domain(row: ChatRow, member_ids: Sequence[UUID]) -> Chat:
return Chat(id=row.id, title=row.title, member_ids=tuple(member_ids), created_at=row.created_at)
@staticmethod
async def _members(session: AsyncSession, chat_id: UUID) -> tuple[UUID, ...]:
result = await session.scalars(
select(ChatMemberRow.user_id)
.where(ChatMemberRow.chat_id == chat_id)
.order_by(ChatMemberRow.user_id)
)
return tuple(result)
async def create(self, chat_id: UUID, title: str, member_ids: Sequence[UUID], created_at: datetime) -> Chat:
async with self._sessions() as session:
async with session.begin():
found = set(await session.scalars(select(UserRow.id).where(UserRow.id.in_(member_ids))))
if len(found) != len(member_ids):
raise Invalid(f'member_ids содержит неизвестных участников: {len(member_ids) - len(found)}')
row = ChatRow(id=chat_id, title=title, created_at=created_at)
session.add(row)
await session.flush()
session.add_all(ChatMemberRow(chat_id=chat_id, user_id=user_id) for user_id in member_ids)
await session.flush()
return self._to_domain(row, member_ids)
async def get_for_member(self, chat_id: UUID, user_id: UUID) -> Chat | None:
async with self._sessions() as session:
row = await session.scalar(
select(ChatRow)
.join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id)
.where(ChatRow.id == chat_id, ChatMemberRow.user_id == user_id)
)
if row is None:
return None
return self._to_domain(row, await self._members(session, row.id))
async def page_for_member(self, user_id: UUID, after: Keyset | None, limit: int) -> list[Chat]:
async with self._sessions() as session:
query = (
select(ChatRow)
.join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id)
.where(ChatMemberRow.user_id == user_id)
.order_by(ChatRow.created_at, ChatRow.id)
.limit(limit)
)
if after is not None:
query = query.where(tuple_(ChatRow.created_at, ChatRow.id) > tuple_(after.created_at, after.id))
rows = list((await session.scalars(query)).all())
return [self._to_domain(row, await self._members(session, row.id)) for row in rows]
+70
View File
@@ -0,0 +1,70 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import select, tuple_
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from ..domain.models import Keyset, Message
from ..models.chat import ChatMemberRow, ChatRow
from ..models.message import MessageRow
class MessageRepository:
def __init__(self, sessions: async_sessionmaker[AsyncSession]) -> None:
self._sessions = sessions
@staticmethod
def _to_domain(row: MessageRow) -> Message:
return Message(
id=row.id,
chat_id=row.chat_id,
sender_id=row.sender_id,
text=row.text,
created_at=row.created_at,
)
@staticmethod
async def _accessible_chat_id(session: AsyncSession, chat_id: UUID, user_id: UUID) -> UUID | None:
return await session.scalar(
select(ChatRow.id)
.join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id)
.where(ChatRow.id == chat_id, ChatMemberRow.user_id == user_id)
)
async def create_for_member(
self, message_id: UUID, chat_id: UUID, sender_id: UUID, text: str, created_at: datetime
) -> Message | None:
async with self._sessions() as session:
async with session.begin():
accessible_chat_id = await self._accessible_chat_id(session, chat_id, sender_id)
if accessible_chat_id is None:
return None
row = MessageRow(
id=message_id,
chat_id=accessible_chat_id,
sender_id=sender_id,
text=text,
created_at=created_at,
)
session.add(row)
await session.flush()
return self._to_domain(row)
async def page_for_member(
self, chat_id: UUID, user_id: UUID, after: Keyset | None, limit: int
) -> list[Message] | None:
async with self._sessions() as session:
accessible_chat_id = await self._accessible_chat_id(session, chat_id, user_id)
if accessible_chat_id is None:
return None
query = (
select(MessageRow)
.where(MessageRow.chat_id == accessible_chat_id)
.order_by(MessageRow.created_at, MessageRow.id)
.limit(limit)
)
if after is not None:
query = query.where(tuple_(MessageRow.created_at, MessageRow.id) > tuple_(after.created_at, after.id))
return [self._to_domain(row) for row in (await session.scalars(query)).all()]
+53
View File
@@ -0,0 +1,53 @@
from __future__ import annotations
from datetime import datetime
from uuid import UUID
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from ..domain.errors import Conflict
from ..domain.models import User
from ..models.user import UserRow
class UserRepository:
def __init__(self, sessions: async_sessionmaker[AsyncSession]) -> None:
self._sessions = sessions
@staticmethod
def _to_domain(row: UserRow) -> User:
return User(id=row.id, username=row.username, display_name=row.display_name, created_at=row.created_at)
async def register(
self, user_id: UUID, username: str, display_name: str, password_hash: str, created_at: datetime
) -> User:
row = UserRow(
id=user_id,
username=username,
display_name=display_name,
password_hash=password_hash,
created_at=created_at,
)
try:
async with self._sessions() as session:
async with session.begin():
session.add(row)
await session.flush()
except IntegrityError as exc:
raise Conflict('username уже занят') from exc
return self._to_domain(row)
async def get_by_id(self, user_id: UUID) -> User | None:
async with self._sessions() as session:
row = await session.get(UserRow, user_id)
return self._to_domain(row) if row is not None else None
async def get_credentials(self, username: str) -> UserRow | None:
async with self._sessions() as session:
return await session.scalar(select(UserRow).where(UserRow.username == username))
@classmethod
def to_domain(cls, row: UserRow) -> User:
return cls._to_domain(row)
View File
+35
View File
@@ -0,0 +1,35 @@
from __future__ import annotations
from datetime import datetime, timezone
from typing import Optional, Sequence
from uuid import UUID, uuid4
from ..domain.errors import Invalid, NotFound
from ..domain.models import Chat, Keyset, Page, User
from ..repositories import ChatRepository
class ChatService:
def __init__(self, repository: ChatRepository) -> None:
self._repository = repository
async def create(self, actor: User, title: str, member_ids: Sequence[UUID]) -> Chat:
if actor.id not in member_ids:
raise Invalid('вызывающий должен входить в member_ids')
return await self._repository.create(
chat_id=uuid4(),
title=title,
member_ids=member_ids,
created_at=datetime.now(timezone.utc),
)
async def get(self, actor: User, chat_id: UUID) -> Chat:
chat = await self._repository.get_for_member(chat_id, actor.id)
if chat is None:
raise NotFound('чат не найден')
return chat
async def page(self, actor: User, after: Optional[Keyset], limit: int) -> Page:
rows = await self._repository.page_for_member(actor.id, after, limit + 1)
items = tuple(rows[:limit])
return Page(items=items, next=Keyset.from_item(items[-1]) if len(rows) > limit else None)
+35
View File
@@ -0,0 +1,35 @@
from __future__ import annotations
from datetime import datetime, timezone
from typing import Optional
from uuid import UUID, uuid4
from ..domain.errors import NotFound
from ..domain.models import Keyset, Message, Page, User
from ..repositories import MessageRepository
class MessageService:
def __init__(self, repository: MessageRepository) -> None:
self._repository = repository
async def send(self, actor: User, chat_id: UUID, text: str) -> Message:
message = await self._repository.create_for_member(
message_id=uuid4(),
chat_id=chat_id,
sender_id=actor.id,
text=text,
created_at=datetime.now(timezone.utc),
)
if message is None:
raise NotFound('чат не найден')
return message
async def history(
self, actor: User, chat_id: UUID, after: Optional[Keyset], limit: int
) -> Page:
rows = await self._repository.page_for_member(chat_id, actor.id, after, limit + 1)
if rows is None:
raise NotFound('чат не найден')
items = tuple(rows[:limit])
return Page(items=items, next=Keyset.from_item(items[-1]) if len(rows) > limit else None)
+35
View File
@@ -0,0 +1,35 @@
from __future__ import annotations
from datetime import datetime, timezone
from uuid import UUID, uuid4
from ..auth.passwords import hash_password, password_matches
from ..domain.errors import Unauthorized
from ..domain.models import User
from ..repositories import UserRepository
class UserService:
def __init__(self, repository: UserRepository) -> None:
self._repository = repository
async def register(self, username: str, display_name: str, password: str) -> User:
return await self._repository.register(
user_id=uuid4(),
username=username,
display_name=display_name,
password_hash=hash_password(password),
created_at=datetime.now(timezone.utc),
)
async def identify(self, user_id: UUID) -> User:
user = await self._repository.get_by_id(user_id)
if user is None:
raise Unauthorized('требуется действующая сессия')
return user
async def authenticate(self, username: str, password: str) -> User | None:
row = await self._repository.get_credentials(username)
if row is None or not password_matches(row.password_hash, password):
return None
return self._repository.to_domain(row)
+62
View File
@@ -0,0 +1,62 @@
services:
postgres:
image: postgres:17.4-alpine
environment:
POSTGRES_USER: messenger_test
POSTGRES_PASSWORD: messenger_test
POSTGRES_DB: messenger_test
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger_test -d messenger_test"]
interval: 2s
timeout: 2s
retries: 30
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 2s
timeout: 2s
retries: 30
migrate:
build: .
command: ["alembic", "upgrade", "head"]
environment:
DATABASE_URL: postgresql+asyncpg://messenger_test:messenger_test@postgres:5432/messenger_test
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: 1
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
build: .
environment:
DATABASE_URL: postgresql+asyncpg://messenger_test:messenger_test@postgres:5432/messenger_test
REDIS_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: 1
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3).read()"]
interval: 2s
timeout: 2s
retries: 30
tests:
build:
context: .
dockerfile: Dockerfile.test
environment:
BASE_URL: http://api:8080
SESSION_TTL_SECONDS: 1
depends_on:
api:
condition: service_healthy
restart: "no"
+61
View File
@@ -0,0 +1,61 @@
services:
postgres:
image: postgres:17.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 20
redis:
image: redis:7.4.2-alpine
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 20
migrate:
build: .
command: ["alembic", "upgrade", "head"]
environment:
DATABASE_URL: ${DATABASE_URL}
REDIS_URL: ${REDIS_URL}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS}
depends_on:
postgres:
condition: service_healthy
restart: "no"
api:
build: .
environment:
DATABASE_URL: ${DATABASE_URL}
REDIS_URL: ${REDIS_URL}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS}
LOG_LEVEL: ${LOG_LEVEL:-info}
ports:
- "${APP_PORT:-8080}:8080"
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3).read()"]
interval: 10s
timeout: 3s
retries: 10
volumes:
postgres_data:
redis_data:
+7
View File
@@ -0,0 +1,7 @@
2026-10-20
В общий pytest-прогон вошёл tests/test_registration_race.py.
Проверка одновременно отправляет 8 регистраций с одинаковым username и требует
ровно один ответ 201 и семь ответов 409.
Результат общего прогона: 18 passed, 1 skipped in 2.92s.
+13
View File
@@ -0,0 +1,13 @@
2026-10-20
Команда:
make test-dependencies
Результат:
PASS: redis outage returned 503 and recovered.
PASS: postgres outage returned 503 and recovered.
PASS: Redis and PostgreSQL dependency checks completed.
`scripts/test-dependencies.sh` по очереди останавливает Redis и PostgreSQL,
проверяет `GET /health/ready = 503`, затем запускает сервис обратно и ждёт
`200`. `trap` запускает остановленный сервис даже при ошибке; volumes не
удаляются. Анонимный доступ (`401`) проверяется в обычном smoke-тесте.
+19
View File
@@ -0,0 +1,19 @@
BEGIN
INSERT 0 1
INSERT 0 1
INSERT 0 1
INSERT 0 10000
QUERY PLAN
-----------------------------------------------------------------------------------------------------
Limit (actual time=0.006..0.015 rows=100 loops=1)
Buffers: shared hit=5
-> Index Scan using messages_history_idx on messages (actual time=0.005..0.012 rows=100 loops=1)
Index Cond: (chat_id = '22222222-2222-2222-2222-222222222222'::uuid)
Buffers: shared hit=5
Planning:
Buffers: shared hit=28 read=4
Planning Time: 0.132 ms
Execution Time: 0.025 ms
(9 rows)
ROLLBACK
+36
View File
@@ -0,0 +1,36 @@
2026-10-23
Команда:
make test-persistence ACTION_SCRIPT=scripts/restart.sh
Результат:
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
`scripts/restart.sh` перезапускает PostgreSQL, Redis и API без удаления volumes.
Тест сохранил Bearer-токен только в памяти процесса и после готовности стека
прочитал тем же токеном ранее подтверждённое сообщение.
Состояния контейнеров сняты вокруг запуска теста, чтобы подтвердить, что хук не
no-op и перезапускает все три сервиса, а не только API:
docker inspect -f '{{.Name}} StartedAt={{.State.StartedAt}}' $(docker compose --env-file .env ps -q)
до:
/mtusi2026lab2-api-1 StartedAt=2026-10-23T09:06:29.105061882Z
/mtusi2026lab2-postgres-1 StartedAt=2026-10-23T08:59:33.863167426Z
/mtusi2026lab2-redis-1 StartedAt=2026-10-23T08:59:33.863795926Z
после:
/mtusi2026lab2-api-1 StartedAt=2026-10-23T09:07:27.961711548Z
/mtusi2026lab2-postgres-1 StartedAt=2026-10-23T09:07:27.419329506Z
/mtusi2026lab2-redis-1 StartedAt=2026-10-23T09:07:27.444252256Z
Все три StartedAt изменились. Named volumes остались те же и не удалялись:
docker volume ls --filter name=mtusi2026lab2 --format '{{.Name}}'
mtusi2026lab2_postgres_data
mtusi2026lab2_redis_data
docker compose --env-file .env ps после теста:
api Up (healthy)
postgres Up (healthy)
redis Up (healthy)
+21
View File
@@ -0,0 +1,21 @@
2026-10-20
Команда:
pytest
Результат:
18 passed, 1 skipped in 2.92s
Пропущен только test_session_expires_with_short_ttl: он намеренно запускается
отдельно со значением SESSION_TTL_SECONDS=1.
2026-10-20
Команда:
make test-docker
Результат:
21 passed in 4.12s
Compose поднял отдельные PostgreSQL, Redis и API с SESSION_TTL_SECONDS=1.
После проверки контейнеры, сеть и временные данные тестового проекта удалены.
В том числе проверены неверный Basic-пароль (`401`) и отсутствие частично
созданного чата после ошибки неизвестного участника.
+6
View File
@@ -0,0 +1,6 @@
2026-10-20
Команда:
make test
Результат:
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+1
View File
@@ -1,2 +1,3 @@
# Only for full OpenAPI/JSON Schema validation; HTTP tests use stdlib.
openapi-spec-validator==0.7.2
pytest==8.3.5
+7
View File
@@ -0,0 +1,7 @@
fastapi==0.115.12
uvicorn[standard]==0.34.2
SQLAlchemy[asyncio]==2.0.40
asyncpg==0.30.0
alembic==1.15.2
redis==5.2.1
argon2-cffi==25.1.0
+38
View File
@@ -0,0 +1,38 @@
BEGIN;
INSERT INTO users (id, username, display_name, password_hash, created_at)
VALUES (
'11111111-1111-1111-1111-111111111111',
'explain_user',
'EXPLAIN user',
'not-used-by-this-query',
TIMESTAMPTZ '2026-01-01 00:00:00+00'
);
INSERT INTO chats (id, title, created_at)
VALUES (
'22222222-2222-2222-2222-222222222222',
'EXPLAIN history',
TIMESTAMPTZ '2026-01-01 00:00:00+00'
);
INSERT INTO chat_members (chat_id, user_id)
VALUES ('22222222-2222-2222-2222-222222222222', '11111111-1111-1111-1111-111111111111');
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT
md5('explain-message-' || number)::uuid,
'22222222-2222-2222-2222-222222222222',
'11111111-1111-1111-1111-111111111111',
'EXPLAIN message ' || number,
TIMESTAMPTZ '2026-01-01 00:00:00+00' + number * INTERVAL '1 second'
FROM generate_series(1, 10000) AS number;
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = '22222222-2222-2222-2222-222222222222'
ORDER BY created_at, id
LIMIT 100;
ROLLBACK;
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
docker compose --env-file .env restart postgres redis
docker compose --env-file .env restart api
docker compose --env-file .env up -d --wait api
+19
View File
@@ -0,0 +1,19 @@
#!/bin/sh
# Checks readiness when one required storage is unavailable.
set -eu
base_url=${1:-http://localhost:8080}
compose_env=${2:-.env}
trap 'docker compose --env-file "$compose_env" start redis postgres >/dev/null 2>&1 || true' EXIT INT TERM
docker compose --env-file "$compose_env" up -d --wait api >/dev/null 2>&1
for service in redis postgres; do
docker compose --env-file "$compose_env" stop "$service" >/dev/null 2>&1
code=$(curl --max-time 10 --silent --output /dev/null --write-out '%{http_code}' "$base_url/health/ready" || true)
test "$code" = 503
docker compose --env-file "$compose_env" start "$service" >/dev/null 2>&1
docker compose --env-file "$compose_env" up -d --wait api >/dev/null 2>&1
echo "PASS: $service outage returned 503 and recovered."
done
echo 'PASS: Redis and PostgreSQL dependency checks completed.'
View File
+15
View File
@@ -0,0 +1,15 @@
import os
import pytest
from tests.client import Client
@pytest.fixture
def client():
return Client(os.environ.get('BASE_URL'), os.environ.get('CA_FILE') or None)
@pytest.fixture
def actors(client):
return (client,) + client.bootstrap()
+9
View File
@@ -0,0 +1,9 @@
def create_chat(client, actor, title):
return client.call(
'POST',
'/api/v1/chats',
201,
actor=actor,
body={'title': title, 'member_ids': [actor['id']]},
schema='Chat',
)['json']
+39
View File
@@ -0,0 +1,39 @@
import base64
from uuid import uuid4
def test_rejects_incorrect_basic_password(client):
actor = client.user('wrong_password')
credentials = base64.b64encode(
(actor['registration']['username'] + ':definitely-wrong-password').encode('utf-8')
).decode('ascii')
client.call(
'POST',
'/api/v1/auth/sessions',
401,
headers={'Authorization': 'Basic ' + credentials},
)
def test_chat_creation_rolls_back_when_a_member_does_not_exist(client):
actor = client.user('chat_rollback')
title = 'Не должен сохраниться ' + uuid4().hex
client.call(
'POST',
'/api/v1/chats',
400,
actor=actor,
body={
'title': title,
'member_ids': [actor['id'], str(uuid4())],
},
)
chats = client.call(
'GET',
'/api/v1/chats?limit=100',
actor=actor,
schema='ChatPage',
)['json']['items']
assert all(chat['title'] != title for chat in chats)
+36
View File
@@ -0,0 +1,36 @@
import os
from concurrent.futures import ThreadPoolExecutor
from threading import Barrier
from tests.client import Client
from tests.helpers import create_chat
def test_keeps_100_concurrent_messages(actors):
_, alice, _, _, _ = actors
base_url = os.environ.get('BASE_URL')
ca_file = os.environ.get('CA_FILE') or None
seed = Client(base_url, ca_file)
chat = create_chat(seed, alice, 'Конкурентная отправка')
start = Barrier(10)
def worker(worker_number):
client = Client(base_url, ca_file)
start.wait()
return [
client.message(alice, chat, 'worker=' + str(worker_number) + '; message=' + str(index))['json']['id']
for index in range(10)
]
with ThreadPoolExecutor(max_workers=10) as pool:
sent = [message_id for batch in pool.map(worker, range(10)) for message_id in batch]
page = seed.call(
'GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=100',
actor=alice, schema='MessagePage',
)['json']
received = [item['id'] for item in page['items']]
assert len(sent) == len(set(sent)) == 100
assert page['next_cursor'] is None
assert len(received) == len(set(received)) == 100
assert set(received) == set(sent)
+42
View File
@@ -0,0 +1,42 @@
from urllib.parse import quote
from tests.helpers import create_chat
def test_walks_all_pages_without_duplicates(actors):
client, alice, _, _, _ = actors
chat = create_chat(client, alice, 'Пагинация')
sent = [client.message(alice, chat, 'страница ' + str(i))['json']['id'] for i in range(5)]
received, cursor = [], None
while True:
suffix = '?limit=2'
if cursor:
suffix += '&cursor=' + quote(cursor, safe='')
page = client.call(
'GET', '/api/v1/chats/' + chat['id'] + '/messages' + suffix,
actor=alice, schema='MessagePage',
)['json']
received.extend(item['id'] for item in page['items'])
cursor = page['next_cursor']
if cursor is None:
break
assert len(received) == 5
assert len(set(received)) == 5
assert set(received) == set(sent)
def test_rejects_cursor_from_another_chat(actors):
client, alice, _, _, _ = actors
first = create_chat(client, alice, 'Первый чат')
second = create_chat(client, alice, 'Второй чат')
client.message(alice, first, 'первое')
client.message(alice, first, 'второе')
page = client.call(
'GET', '/api/v1/chats/' + first['id'] + '/messages?limit=1',
actor=alice, schema='MessagePage',
)['json']
assert page['next_cursor'] is not None
client.call(
'GET', '/api/v1/chats/' + second['id'] + '/messages?cursor=' + quote(page['next_cursor'], safe=''),
400, actor=alice,
)
+26
View File
@@ -0,0 +1,26 @@
from concurrent.futures import ThreadPoolExecutor
from threading import Barrier
from uuid import uuid4
from tests.client import Client
def test_only_one_concurrent_registration_succeeds():
username = 'race_' + uuid4().hex[:16]
body = {
'username': username,
'display_name': 'Race user',
'password': 'Race-password-' + uuid4().hex,
}
barrier = Barrier(8)
def register_once(_: int) -> int:
client = Client()
barrier.wait()
return client.call('POST', '/api/v1/users', expected=[201, 409], body=body)['status']
with ThreadPoolExecutor(max_workers=8) as pool:
statuses = list(pool.map(register_once, range(8)))
assert statuses.count(201) == 1
assert statuses.count(409) == 7
+20
View File
@@ -0,0 +1,20 @@
import os
import time
import pytest
def test_logout_revokes_current_token(client):
actor = client.user('logout')
client.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=actor)
client.call('GET', '/api/v1/users/me', 401, actor=actor)
@pytest.mark.skipif(
int(os.getenv('SESSION_TTL_SECONDS', '3600')) > 2,
reason='run with SESSION_TTL_SECONDS=1 to check automatic session expiry',
)
def test_session_expires_with_short_ttl(client):
actor = client.user('expiry')
time.sleep(int(os.environ['SESSION_TTL_SECONDS']) + 0.25)
client.call('GET', '/api/v1/users/me', 401, actor=actor)
+82
View File
@@ -0,0 +1,82 @@
def test_rejects_malformed_json(client):
client.call(
'POST', '/api/v1/users', 400, raw=b'{"username":',
headers={'Content-Type': 'application/json'},
)
def test_rejects_duplicate_username(actors):
client, alice, _, _, _ = actors
client.call('POST', '/api/v1/users', 409, body=alice['registration'])
def test_hides_chat_from_outsider(actors):
client, _, _, eve, chat = actors
client.call('GET', '/api/v1/chats/' + chat['id'], 404, actor=eve)
def test_rejects_blank_message(actors):
client, alice, _, _, chat = actors
client.call(
'POST', '/api/v1/chats/' + chat['id'] + '/messages', 400,
actor=alice, body={'text': ' \t\n '},
)
def test_requires_user_header(client):
client.call('GET', '/api/v1/users/me', 401)
def test_rejects_invalid_chat_uuid(actors):
client, alice, _, _, _ = actors
client.call('GET', '/api/v1/chats/not-a-uuid', 400, actor=alice)
def test_rejects_title_longer_than_100(actors):
client, alice, _, _, _ = actors
client.call(
'POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'x' * 101, 'member_ids': [alice['id']]},
)
def test_rejects_display_name_longer_than_100(client):
client.call(
'POST', '/api/v1/users', 400,
body={'username': 'long_display_name', 'display_name': 'x' * 101},
)
def test_rejects_chat_without_creator(actors):
client, alice, _, eve, _ = actors
client.call(
'POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Без создателя', 'member_ids': [eve['id']]},
)
def test_rejects_duplicate_chat_members(actors):
client, alice, _, _, _ = actors
client.call(
'POST', '/api/v1/chats', 400, actor=alice,
body={'title': 'Дубликат', 'member_ids': [alice['id'], alice['id']]},
)
def test_rejects_unexpected_json_field(client):
client.call(
'POST', '/api/v1/users', 400,
body={'username': 'extra_field', 'display_name': 'Extra field', 'role': 'admin'},
)
def test_rejects_zero_page_limit(actors):
client, alice, _, _, chat = actors
client.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=0', 400, actor=alice)
def test_rejects_invalid_cursor(actors):
client, alice, _, _, chat = actors
client.call(
'GET', '/api/v1/chats/' + chat['id'] + '/messages?cursor=not-a-cursor', 400, actor=alice,
)