42 changed files with 2700 additions and 17 deletions
+16
View File
@@ -18,3 +18,19 @@ __pycache__
node_modules
evidence
.DS_Store
# в образ идут только requirements.txt, src/ и migrations/
tests
student-tests
contracts
examples
scripts
infra
*.md
Makefile
Dockerfile*
compose*.yaml
lab.json
requirements-dev.txt
.gitignore
.idea
.vscode
+14 -1
View File
@@ -7,5 +7,18 @@ 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
SESSION_STORE=redis
CACHE_URL_FILE=/run/secrets/cache_url
# info / debug / warning
LOG_LEVEL=info
# Сколько секунд после SIGTERM ждать незавершённые запросы (не больше 10).
SHUTDOWN_TIMEOUT=8
# Пул соединений с PostgreSQL и таймауты в секундах.
DB_POOL_MIN_SIZE=2
DB_POOL_MAX_SIZE=10
DB_POOL_TIMEOUT=3
DB_CONNECT_TIMEOUT=3
DB_STATEMENT_TIMEOUT=5
# Пул соединений с Redis и таймаут операций в секундах.
CACHE_POOL_MAX_SIZE=20
CACHE_TIMEOUT=2
+34
View File
@@ -0,0 +1,34 @@
FROM python:3.13.16-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /app
# сначала зависимости: слой переиспользуется, пока не меняется requirements.txt
COPY requirements.txt .
RUN pip install -r requirements.txt
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app
COPY src/ .
COPY migrations/ migrations/
USER 10001:10001
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_ENV=lab
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=5s --start-period=10s --retries=3 \
CMD ["python", "healthcheck.py"]
STOPSIGNAL SIGTERM
# exec-форма: python запускается как PID 1 и сам получает SIGTERM
CMD ["python", "main.py"]
+26 -1
View File
@@ -2,9 +2,10 @@ PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
COMPOSE = docker compose --env-file .env
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence env up down clean student-test test-failures explain
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +25,27 @@ load:
test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
env:
./scripts/init-env.sh
up: env
$(COMPOSE) up -d --build
BASE_URL="$(BASE_URL)" ./scripts/wait-ready.sh
down:
$(COMPOSE) --profile test down
# удаляет контейнеры вместе с данными PostgreSQL и Redis
clean:
$(COMPOSE) --profile test down -v
student-test:
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -v
# останавливает и запускает redis/postgres, поднимает второй API на порту 8081
test-failures:
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests/failures -v
explain:
./scripts/explain_history.sh
+217 -15
View File
@@ -1,37 +1,239 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Мусаев Абдул-Хамид Рамзанович, БВТ-2303
- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не заявлен
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/27
- Использованные источники, библиотеки и помощь ИИ:
- библиотеки: FastAPI 0.143.0, Uvicorn 0.54.0, psycopg 3.3.6 и psycopg-pool 3.3.3, redis-py 8.1.0, argon2-cffi 25.1.0 (полный список с версиями в `requirements.txt`);
- источники: документация PostgreSQL (транзакции, EXPLAIN), Redis persistence, psycopg, Docker Compose, RFC 7617, `contracts/README.md`;
- помощь ИИ: ИИ-ассистент использовался во вспомогательных целях.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker с Compose v2 (проверено на Docker 29.3.0, Compose 5.1.0), `make`, `openssl`, `curl` и Python 3.9+ на хосте для тестов. Сервер, PostgreSQL и Redis работают только в контейнерах.
```sh
make up # создаёт .env с паролями, собирает образ, поднимает стенд и ждёт /health/ready
make check # структура skeleton
make test # публичный smoke
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make student-test # собственные тесты API
make test-failures # истечение сессии, остановка Redis и PostgreSQL, откат транзакции
make explain # 60 000 синтетических сообщений и планы запросов
python3 scripts/sigterm_check.py
make down # остановить и удалить контейнеры, данные остаются в volumes
make clean # то же и удалить volumes: намеренное удаление учебных данных
```
То же без `make`:
```sh
./scripts/init-env.sh
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
./scripts/wait-ready.sh
```
`scripts/init-env.sh` копирует `.env.example` в `.env` и дописывает в него случайные пароли PostgreSQL и Redis (`openssl rand`). Файл `.env` исключён из Git. Повторный запуск скрипта пароли не меняет: пароль PostgreSQL задаётся один раз при создании volume, поэтому после `make clean` нужно либо оставить старый `.env`, либо удалить его и создать заново.
Миграции отдельной команды не требуют: при `up` одноразовый контейнер `migrate` применяет их до старта API. Повторить вручную можно командой `docker compose --env-file .env run --rm migrate`.
`make test-failures` сам останавливает и запускает `redis` и `postgres` и поднимает второй экземпляр API на порту 8081, поэтому запускать его нужно только на учебном стенде.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──HTTP──> api (uvicorn + FastAPI) ──┬──> postgres: пользователи, чаты, участники, сообщения
└──> redis: сессии с TTL
```
### Роли и сервисы
| Роль | Сервис compose | Образ | Готовность | Volume | Сеть и порт | Как получает секреты |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` | собирается из `Dockerfile` на `python:3.13.16-slim-bookworm` | HEALTHCHECK → `/health/ready` | нет, состояния не хранит | опубликован `127.0.0.1:8080` | файлы `/run/secrets/database_url`, `/run/secrets/cache_url` |
| миграции | `migrate` | тот же образ, команда `python migrate.py` | одноразовый, код выхода 0 | нет | только внутренняя сеть | файл `/run/secrets/database_url` |
| postgres | `postgres` | `postgres:17.11-alpine` | `pg_isready` | `pgdata` | только внутренняя сеть, 5432 | `POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password` |
| redis | `redis` | `redis:7.4.11-alpine` | `redis-cli ping` | `redisdata` | только внутренняя сеть, 6379 | `--requirepass` из `/run/secrets/redis_password` |
Секреты описаны в `compose.yaml` как `secrets` с источником из переменных `.env`. Compose кладёт их в контейнеры файлами, в окружении контейнеров паролей нет (проверка в `evidence/07-containers.txt`). Наружу опубликован только порт API.
### Файлы
| Файл | Что в нём |
| --- | --- |
| `migrations/0001_init.sql` | таблицы, ключи, ограничения, индексы |
| `src/migrate.py` | применяет миграции по порядку, ведёт таблицу `schema_migrations` |
| `src/store.py` | все SQL-запросы и пул соединений |
| `src/sessions.py` | сессии в Redis |
| `src/security.py` | hash пароля (Argon2id), разбор заголовков Basic и Bearer |
| `src/main.py` | endpoint, middleware, обработка ошибок |
| `src/schemas.py`, `src/errors.py`, `src/config.py` | валидация JSON, формат ошибки, настройки |
### Схема данных
- `users`: `id` (PK), `username` (UNIQUE и CHECK по шаблону), `display_name`, `password_hash`, `created_at`.
- `chats`: `id` (PK), `title`, `created_at`.
- `chat_members`: PK `(chat_id, user_id)`, внешние ключи на `chats` и `users`, `position` — порядок участника в запросе. Индекс `(user_id, chat_id)` для списка чатов пользователя.
- `messages`: `id` (PK), внешние ключи `chat_id` и `sender_id`, `text` (CHECK 1–4000 символов), `created_at`. Индекс `(chat_id, created_at, id)` для истории.
`id` и `created_at` назначает PostgreSQL (`gen_random_uuid()`, `now()`). Ограничения длины продублированы в CHECK, чтобы неверные данные не попали в БД даже в обход приложения.
### Транзакционные границы
Каждый метод `Store` берёт одно соединение из пула и выполняется в одной транзакции: `with pool.connection()` делает COMMIT при выходе и ROLLBACK при исключении.
- **Регистрация** — один `INSERT`. Уникальность username проверяет сама БД; нарушение ограничения превращается в 409. Поэтому два одновременных запроса не создадут двух пользователей.
- **Создание чата** — составная операция: `INSERT` в `chats`, затем `INSERT` всех участников в `chat_members`. Если участника нет, срабатывает внешний ключ, транзакция откатывается вместе с уже вставленным чатом, клиент получает 400.
- **Отправка сообщения** — проверка членства и `INSERT` в одной транзакции.
- Ответ 201 отправляется только после COMMIT. PostgreSQL работает с настройками по умолчанию (`fsync=on`, `synchronous_commit=on`), то есть подтверждённая запись уже на диске.
Все значения попадают в запросы только параметрами `%s`, строки SQL из пользовательских данных не собираются.
### Аутентификация
- Пароль хешируется Argon2id (`argon2-cffi`, 19 МиБ памяти, 2 прохода, 1 поток — минимальные параметры из рекомендаций OWASP). В БД хранится только hash.
- `POST /api/v1/auth/sessions` принимает только `Authorization: Basic`. Неизвестный username и неверный пароль дают одинаковый 401 с `WWW-Authenticate: Basic`. Если пользователя нет, пароль всё равно сверяется с заранее посчитанным hash, чтобы время ответа не выдавало существование username.
- Токен — `secrets.token_urlsafe(32)`, 256 бит случайности. Остальные endpoint принимают только `Authorization: Bearer`; `X-User-Id` не читается, Basic на бизнес-запросах даёт 401.
- Проверка токена выполняется до валидации параметров и тела и до обращения к чату: сначала аутентификация, потом доступ к конкретному ресурсу.
### Роль Redis
Redis — **единственное хранилище сессий**. PostgreSQL о сессиях ничего не знает; источник истины для пользователей, чатов и сообщений — PostgreSQL, для сессий — Redis.
- Ключ `session:<sha256 от токена>`, значение — id пользователя. Сам токен в Redis не хранится, поэтому по дампу нельзя получить рабочий токен.
- **Expiry**: ключ записывается командой `SET ... EX SESSION_TTL_SECONDS`, срок отсчитывается от входа и запросами не продлевается. Истёкший ключ Redis удаляет сам.
- **Инвалидация**: logout — это `DEL` ключа текущей сессии. Другие сессии того же пользователя остаются.
- **Persistence**: включён AOF с `appendfsync always`, данные лежат в volume `redisdata`. Сессия переживает перезапуск Redis, а оставшийся TTL при этом не увеличивается (`evidence/04-redis-sessions.txt`: 3591 с до перезапуска, 3583 с после).
- Политика вытеснения — `noeviction`: при нехватке памяти Redis откажет в записи новой сессии, но не удалит действующие.
- После `FLUSHALL` или удаления volume `redisdata` все сессии пропадают: каждый токен получит 401, пользователям нужно войти заново. Данные в PostgreSQL при этом не страдают.
### Пул соединений и таймауты
| Что | Значение | Где задаётся |
| --- | --- | --- |
| соединений с PostgreSQL | от 2 до 10 | `DB_POOL_MIN_SIZE`, `DB_POOL_MAX_SIZE` |
| ожидание свободного соединения | 3 с | `DB_POOL_TIMEOUT` |
| установка соединения с PostgreSQL | 3 с | `DB_CONNECT_TIMEOUT` |
| выполнение одного запроса | 5 с (`statement_timeout`) | `DB_STATEMENT_TIMEOUT` |
| соединений с Redis | до 20 | `CACHE_POOL_MAX_SIZE` |
| операция с Redis и ожидание соединения | 2 с | `CACHE_TIMEOUT` |
Перед выдачей из пула соединение с PostgreSQL проверяется, поэтому после перезапуска БД запросы не получают мёртвые соединения.
### Поведение при отказе зависимостей
- **Redis недоступен**: проверить токен нечем, поэтому любой запрос с токеном получает 503 `unavailable`. Запрос не выполняется ни от имени владельца токена, ни как анонимный. Запрос без токена по-прежнему получает 401.
- **PostgreSQL недоступен**: запросы, которым нужны данные, получают 503 не позже чем через 3 секунды (ожидание соединения из пула).
- `/health/ready` проверяет обе зависимости (`SELECT 1` и `PING`) и отвечает 503 в общем формате ошибки, если хотя бы одна недоступна. `/health/live` от них не зависит.
- API стартует, даже если БД ещё не поднялась, и отвечает 503 до её появления.
### Пагинация и порядок
Запрос истории:
```sql
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id LIMIT $4
```
Cursor — base64 от JSON `[область, created_at, id]` последней выданной записи; область привязывает его к конкретному чату или к списку чатов конкретного пользователя. Разбор строгий: посторонние символы в base64 не пропускаются, внутри должен быть список ровно из трёх строк, время — в формате сервера, id — UUID в каноническом виде; затем cursor кодируется заново и сравнивается с присланным. Любое отклонение даёт 400 `invalid_request`. Запрашивается `limit + 1` строк: лишняя строка показывает, есть ли следующая страница.
**Семантика при конкурентных вставках.** `created_at` — это `now()` PostgreSQL, то есть время начала транзакции. Две параллельные транзакции могут зафиксироваться не в порядке своих `created_at`. Поэтому сообщение с чуть более ранним временем может появиться в истории уже после того, как клиент прошёл это место по cursor, и при обходе вперёд он его не увидит (окно — миллисекунды, длительность транзакции вставки). Повторов при обходе нет. Чтение после записи выполняется: ответ 201 приходит после COMMIT, следующий `GET` это сообщение видит.
### Соответствие переменных окружения
| Переменная в `.env` | По умолчанию | Что делает |
| --- | --- | --- |
| `APP_HOST`, `APP_PORT` | `0.0.0.0`, `8080` | адрес сервера; в compose заданы жёстко, из `.env` не читаются |
| `APP_ENV` | `lab` | выводится в лог при старте |
| `SESSION_TTL_SECONDS` | `3600` | срок жизни сессии |
| `SESSION_STORE` | `redis` | поддерживается только `redis`, с другим значением сервер не стартует |
| `DATABASE_URL_FILE`, `CACHE_URL_FILE` | `/run/secrets/...` | пути к файлам со строками подключения; в compose заданы жёстко |
| `LOG_LEVEL`, `SHUTDOWN_TIMEOUT` | `info`, `8` | как в lab1 |
| `DB_POOL_*`, `DB_*_TIMEOUT`, `CACHE_*` | см. таблицу выше | пул и таймауты |
| `POSTGRES_PASSWORD`, `REDIS_PASSWORD`, `DATABASE_URL`, `CACHE_URL` | создаёт `init-env.sh` | источник compose-секретов; в контейнер `api` попадают только файлами |
### Что перенесено из lab1 и что изменено
Перенесены: структура `src/`, формат ошибок и `X-Request-Id`, валидация JSON, cursor-пагинация, логирование без содержимого, Dockerfile (непривилегированный пользователь, healthcheck, корректная остановка по SIGTERM), собственные тесты.
Исправлено по замечаниям:
- (к lab1) Некорректный cursor мог вернуть 200 (посторонние символы в base64, неканоничные время и UUID); теперь он всегда даёт 400, проверка — тест `test_cursor_format_is_checked`.
- (к lab2) `POST /api/v1/auth/sessions` с заголовком `Authorization: Basic é` возвращал 500: при не-ASCII символах `b64decode` бросает обычный `ValueError`, а перехватывались только `binascii.Error` и `UnicodeDecodeError`. Теперь в `parse_basic` (`src/security.py`) перехватывается `ValueError`, который покрывает все три случая, и ответ — 401 с `WWW-Authenticate: Basic`. Негативные тесты: `test_garbage_after_basic_is_401_not_500` (11 вариантов значения после `Basic`) и `test_garbage_token_is_401_not_500` (то же для Bearer).
Изменено: хранилище в памяти заменено на PostgreSQL; `X-User-Id` заменён на пароль, Basic и Bearer; добавлены миграции, Redis, compose, проверка зависимостей в `/health/ready` и ответ 503. Строки теперь проверяются ещё и на символ NUL, который PostgreSQL не хранит. Контракт и публичные тесты не менялись.
## Доказательства критериев
Стенд: Apple M3 Pro, 11 CPU, 18 ГБ RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0, без ограничений CPU/RAM для контейнеров. Все файлы получены из чистого clone на пустых volumes, commit `6473fd0`. Файл `evidence/02-student-tests.txt` получен заново после исправлений по замечаниям (проверка cursor, разбор заголовка Basic).
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/01-up-and-smoke.txt` |
| 3: данные и сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS`; у контейнеров `postgres`, `redis`, `api` новое время старта, volumes те же | `evidence/03-persistence.txt` |
| 3: таблицы, ключи, уникальность username, миграции с нуля | `make up` на пустом volume | `применена: 0001_init.sql`, smoke проходит | `evidence/01-up-and-smoke.txt`, `migrations/0001_init.sql` |
| 3: создание чата атомарно | `make test-failures` (`test_transactions.py`) | после неудачного создания в `chats` 0 строк, после удачного — чат и 2 участника | `evidence/05-failures.txt` |
| 3: Basic только на входе, Bearer на остальном, срок жизни, отзыв, `X-User-Id` не даёт доступ | `make student-test` (`test_auth.py`) | 17 тестов `ok` | `evidence/02-student-tests.txt` |
| 3: пароли хешируются KDF | `test_password_is_stored_as_argon2id_hash` | hash в БД начинается с `$argon2id$` | `evidence/05-failures.txt` |
| 3: миграции повторяются без дублирования | `docker compose run --rm migrate` | `уже применена: 0001_init.sql`, в `schema_migrations` одна строка, число строк в таблицах не изменилось | `evidence/03-persistence.txt`, `evidence/05-failures.txt` |
| 3: secrets и volumes не в Git | `git ls-files \| grep -E "^\.env$\|secrets"` | пусто | `evidence/07-containers.txt` |
| 4: Redis реально используется для сессий с TTL и persistence | `redis-cli CONFIG GET`, `TTL`, `docker compose restart redis` | `appendonly yes`, `appendfsync always`; ключ пережил перезапуск, TTL 3591 → 3583 | `evidence/04-redis-sessions.txt` |
| 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/sessions.py`; остановка зависимостей | 503 через 0,01 с без Redis и через 3,0 с без PostgreSQL | `evidence/05-failures.txt` |
| 4: гонка регистрации одного username | `test_username_race_creates_one_row`, `test_same_username_registered_once` | один ответ 201 и девять 409, в `users` одна строка | `evidence/05-failures.txt`, `evidence/02-student-tests.txt` |
| 4: rollback составной операции | `test_chat_with_unknown_member_is_rolled_back` | 400, в `chats` 0 строк с этим названием, участников без чата нет | `evidence/05-failures.txt` |
| 4: индекс истории обоснован EXPLAIN на ≥10 000 сообщений | `make explain` | Index Scan, 8 буферов на страницу в любом месте истории | `evidence/06-explain.txt` |
| 4: автоматическая проверка expiry при коротком TTL | `test_expiry.py`, API с `SESSION_TTL_SECONDS=2` | через 3 с токен получает 401, запросы срок не продлевают | `evidence/05-failures.txt` |
| 4: автоматическая проверка logout и неверного пароля | `test_auth.py` | после logout 401, вторая сессия работает; неверный пароль — 401 | `evidence/02-student-tests.txt` |
| 4: недоступность Redis и БД | `test_dependencies.py` | 503 `unavailable` за ограниченное время, аноним получает 401, после восстановления прежний токен и данные на месте | `evidence/05-failures.txt` |
| Возможности lab1: непривилегированный пользователь, закреплённые версии, SIGTERM | `docker compose exec api id`, `scripts/sigterm_check.py` | `uid=10001(app)`; начатый запрос получил 201, выход за 1,45 с с кодом 0 | `evidence/07-containers.txt`, `evidence/08-sigterm.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Нагрузочное исследование (трек 5) не проводилось.
### Индекс истории
Гипотеза: индекс `(chat_id, created_at, id)` позволяет читать любую страницу истории за число обращений к диску, не зависящее от длины истории и от положения страницы.
Методика: `scripts/seed_history.sql` создаёт 21 чат и 60 000 сообщений, из них 10 000 в исследуемом чате, остальные 50 000 поровну в 20 других; затем `ANALYZE`. `scripts/explain_history.sql` выполняет `EXPLAIN (ANALYZE, BUFFERS)` для четырёх запросов с `LIMIT 51` (страница 50 плюс одна строка). Данные небольшие и целиком в кэше, поэтому сравнивать нужно число буферов, а не миллисекунды.
| Запрос | План | Буферов | Время выполнения |
| --- | --- | --- | --- |
| первая страница | Index Scan по `messages_chat_history_idx` | 8 | 0,025 мс |
| страница после 5000-го сообщения, keyset | Index Scan, условие на `(created_at, id)` внутри Index Cond | 8 | 0,034 мс |
| та же страница через `OFFSET 5000` | Index Scan, прочитано 5051 строка | 491 | 0,469 мс |
| keyset без индекса | Seq Scan всей таблицы (отброшено 55 140 строк) и сортировка | 862 | 2,266 мс |
Вывод: с индексом и keyset страница из середины стоит столько же, сколько первая, сортировка не нужна. OFFSET читает все пропущенные строки, и стоимость растёт с номером страницы. Без индекса каждая страница читает всю таблицу, включая чужие чаты.
Ограничение измерения: одна таблица на 60 000 строк, один запуск, всё в памяти. Для вывода о реальной нагрузке этого мало. Четвёртый запрос выполняет `DROP INDEX` внутри транзакции с `ROLLBACK`: на это время таблица `messages` заблокирована, поэтому скрипт годится только для учебного стенда.
### Отказы
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose restart postgres redis api` | данные и сессия на месте | прежний токен читает прежние сообщения | готов через несколько секунд, потерь нет |
| `docker compose stop redis` | запросы с токеном не выполняются | 503 за 0,01 с; без токена 401; `/health/ready` 503, `/health/live` 200 | после `start redis` прежний токен работает, сообщение, отправленное во время отказа, не записано |
| `docker compose stop postgres` | запросы к данным не выполняются | 503 за 3,0 с; без токена 401 | после `start postgres` данные на месте, запись снова работает |
| сессия с TTL 2 с | через 2 с токен недействителен | через 3 с 401, logout с ним тоже 401, новый вход работает | — |
| чат с несуществующим участником | ничего не создаётся | 400, в `chats` и `chat_members` следов нет | — |
| 10 одновременных регистраций одного username | один пользователь | один 201, девять 409, одна строка | — |
| SIGTERM процессу API | начатый запрос завершится | 201, новые соединения не принимаются, выход за 1,45 с | — |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один экземпляр API, один PostgreSQL, один Redis на одном хосте. Отказ хоста, диска или любого из хранилищ не переживается, резервных копий нет.
- При недоступном Redis не работает ни один запрос с токеном: запасного пути проверки сессии нет. Это осознанный выбор в пользу простоты и того, что отозванная сессия не может «ожить» из другого хранилища.
- `appendfsync always` делает каждую запись сессии синхронной записью на диск. Для учебного стенда это незаметно, под нагрузкой вход станет узким местом.
- Нет ограничения числа попыток входа и числа сессий на пользователя, код 429 не используется.
- Порядок истории при параллельных вставках описан выше: возможен пропуск сообщения при обходе вперёд в окне длительности транзакции.
- Если JSON синтаксически сломан, FastAPI отвечает 400 раньше, чем проверяется токен. На доступ к данным это не влияет.
- При недоступной БД ответ 503 приходит через 3 секунды, а не сразу: столько запрос ждёт соединение из пула.
- Пароли в `.env` лежат открытым текстом на диске разработчика (права 600). Для локального стенда с синтетическими данными это допустимо.
- `make explain` оставляет в БД синтетические чаты и 60 000 сообщений; убрать их можно только `make clean`.
- Проверено на одном стенде (macOS, Docker Desktop). На Linux не запускалось.
+125
View File
@@ -0,0 +1,125 @@
name: mtusi-messenger-lab2
# Настройки и секреты берутся из .env (создаёт scripts/init-env.sh, в Git не попадает).
# Секреты доходят до контейнеров только файлами в /run/secrets, в переменных окружения контейнеров их нет.
x-app: &app
build: .
image: mtusi-messenger:lab2
x-app-env: &app-env
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
LOG_LEVEL: ${LOG_LEVEL:-info}
SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-8}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: ${SESSION_STORE:-redis}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
DB_POOL_MIN_SIZE: ${DB_POOL_MIN_SIZE:-2}
DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-10}
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-3}
DB_CONNECT_TIMEOUT: ${DB_CONNECT_TIMEOUT:-3}
DB_STATEMENT_TIMEOUT: ${DB_STATEMENT_TIMEOUT:-5}
CACHE_POOL_MAX_SIZE: ${CACHE_POOL_MAX_SIZE:-20}
CACHE_TIMEOUT: ${CACHE_TIMEOUT:-2}
services:
postgres:
image: postgres:17.11-alpine
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
redis:
image: redis:7.4.11-alpine
# сессии хранятся только здесь, поэтому включён AOF с fsync на каждую запись;
# запуск через docker-entrypoint.sh, чтобы процесс работал от пользователя redis, а не от root
command:
- sh
- -c
- exec docker-entrypoint.sh redis-server --appendonly yes --appendfsync always --requirepass "$$(cat /run/secrets/redis_password)"
secrets:
- redis_password
volumes:
- redisdata:/data
healthcheck:
test: ["CMD-SHELL", "redis-cli --no-auth-warning -a \"$$(cat /run/secrets/redis_password)\" ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
migrate:
<<: *app
command: ["python", "migrate.py"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
restart: "no"
api:
<<: *app
environment: *app-env
secrets:
- database_url
- cache_url
ports:
- "127.0.0.1:8080:8080"
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
restart: unless-stopped
# тот же сервер с TTL сессии 2 секунды, нужен только тесту истечения:
# docker compose --profile test up -d api-short-ttl
api-short-ttl:
<<: *app
profiles: ["test"]
environment:
<<: *app-env
SESSION_TTL_SECONDS: "2"
secrets:
- database_url
- cache_url
ports:
- "127.0.0.1:8081:8080"
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
volumes:
pgdata:
redisdata:
secrets:
postgres_password:
environment: POSTGRES_PASSWORD
redis_password:
environment: REDIS_PASSWORD
database_url:
environment: DATABASE_URL
cache_url:
environment: CACHE_URL
+72
View File
@@ -0,0 +1,72 @@
# Запуск из чистого clone на пустых volumes, публичный smoke
# дата: 2026-10-08T15:55Z, commit: 6473fd0
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ ./scripts/init-env.sh
пароли записаны в .env
$ docker compose --env-file .env config --quiet
$ docker compose --env-file .env up -d --build
Image mtusi-messenger:lab2 Built
Image mtusi-messenger:lab2 Built
Network mtusi-messenger-lab2_default Creating
Network mtusi-messenger-lab2_default Created
Volume mtusi-messenger-lab2_redisdata Creating
Volume mtusi-messenger-lab2_redisdata Created
Volume mtusi-messenger-lab2_pgdata Creating
Volume mtusi-messenger-lab2_pgdata Created
Container mtusi-messenger-lab2-postgres-1 Creating
Container mtusi-messenger-lab2-redis-1 Creating
Container mtusi-messenger-lab2-postgres-1 Created
Container mtusi-messenger-lab2-redis-1 Created
Container mtusi-messenger-lab2-migrate-1 Creating
Container mtusi-messenger-lab2-migrate-1 Created
Container mtusi-messenger-lab2-api-1 Creating
Container mtusi-messenger-lab2-api-1 Created
Container mtusi-messenger-lab2-postgres-1 Starting
Container mtusi-messenger-lab2-redis-1 Starting
Container mtusi-messenger-lab2-postgres-1 Started
Container mtusi-messenger-lab2-postgres-1 Waiting
Container mtusi-messenger-lab2-redis-1 Started
Container mtusi-messenger-lab2-postgres-1 Healthy
Container mtusi-messenger-lab2-migrate-1 Starting
Container mtusi-messenger-lab2-migrate-1 Started
Container mtusi-messenger-lab2-migrate-1 Waiting
Container mtusi-messenger-lab2-redis-1 Waiting
Container mtusi-messenger-lab2-migrate-1 Exited
Container mtusi-messenger-lab2-redis-1 Healthy
Container mtusi-messenger-lab2-api-1 Starting
Container mtusi-messenger-lab2-api-1 Started
$ ./scripts/wait-ready.sh
готов: http://localhost:8080
$ docker compose --env-file .env ps -a
SERVICE IMAGE STATE STATUS
api mtusi-messenger:lab2 running Up 1 second (health: starting)
migrate mtusi-messenger:lab2 exited Exited (0) 1 second ago
postgres postgres:17.11-alpine running Up 7 seconds (healthy)
redis redis:7.4.11-alpine running Up 7 seconds (healthy)
$ docker compose --env-file .env logs migrate
migrate-1 | применена: 0001_init.sql
$ curl -s -i http://localhost:8080/health/ready
HTTP/1.1 200 OK
date: Thu, 08 Oct 2026 15:55:10 GMT
server: uvicorn
content-length: 15
content-type: application/json
x-request-id: c5fc87a41bdc4cfaa665cddb6d79a6c0
{"status":"ok"}
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+76
View File
@@ -0,0 +1,76 @@
# Собственные тесты API
# дата: 2026-10-09T21:41Z, после исправлений по замечаниям (проверка cursor, разбор заголовка Basic)
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make student-test
BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests -v
test_blank_title (test_access.CreateChatTest.test_blank_title) ... ok
test_creator_must_be_member (test_access.CreateChatTest.test_creator_must_be_member) ... ok
test_duplicate_members (test_access.CreateChatTest.test_duplicate_members) ... ok
test_empty_members (test_access.CreateChatTest.test_empty_members) ... ok
test_failed_create_leaves_no_chat (test_access.CreateChatTest.test_failed_create_leaves_no_chat) ... ok
test_unknown_member (test_access.CreateChatTest.test_unknown_member) ... ok
test_bad_chat_id (test_access.ForeignChatTest.test_bad_chat_id) ... ok
test_chat_is_not_listed_for_outsider (test_access.ForeignChatTest.test_chat_is_not_listed_for_outsider) ... ok
test_foreign_chat_looks_like_missing_chat (test_access.ForeignChatTest.test_foreign_chat_looks_like_missing_chat) ... ok
test_members_can_read_and_write (test_access.ForeignChatTest.test_members_can_read_and_write) ... ok
test_outsider_gets_404_everywhere (test_access.ForeignChatTest.test_outsider_gets_404_everywhere) ... ok
test_outsider_message_is_not_saved (test_access.ForeignChatTest.test_outsider_message_is_not_saved) ... ok
test_basic_is_not_accepted_on_business_endpoints (test_auth.BearerTest.test_basic_is_not_accepted_on_business_endpoints) ... ok
test_garbage_token_is_401_not_500 (test_auth.BearerTest.test_garbage_token_is_401_not_500) ... ok
test_no_token (test_auth.BearerTest.test_no_token) ... ok
test_token_is_checked_before_anything_else (test_auth.BearerTest.test_token_is_checked_before_anything_else) ... ok
test_unknown_tokens (test_auth.BearerTest.test_unknown_tokens) ... ok
test_x_user_id_does_not_change_identity (test_auth.BearerTest.test_x_user_id_does_not_change_identity) ... ok
test_x_user_id_gives_no_access (test_auth.BearerTest.test_x_user_id_gives_no_access) ... ok
test_colon_and_unicode_in_password (test_auth.LoginTest.test_colon_and_unicode_in_password) ... ok
test_garbage_after_basic_is_401_not_500 (test_auth.LoginTest.test_garbage_after_basic_is_401_not_500) ... ok
test_login (test_auth.LoginTest.test_login) ... ok
test_malformed_credentials (test_auth.LoginTest.test_malformed_credentials) ... ok
test_token_is_opaque_and_unique (test_auth.LoginTest.test_token_is_opaque_and_unique) ... ok
test_username_that_cannot_exist (test_auth.LoginTest.test_username_that_cannot_exist) ... ok
test_wrong_password_and_unknown_user_look_the_same (test_auth.LoginTest.test_wrong_password_and_unknown_user_look_the_same) ... ok
test_login_again_after_logout (test_auth.LogoutTest.test_login_again_after_logout) ... ok
test_logout_requires_token (test_auth.LogoutTest.test_logout_requires_token) ... ok
test_logout_revokes_only_current_session (test_auth.LogoutTest.test_logout_revokes_only_current_session) ... ok
test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) ... ok
test_same_username_registered_once (test_concurrency.ConcurrencyTest.test_same_username_registered_once) ... ok
test_chat_cursor_belongs_to_user (test_pagination.ChatPaginationTest.test_chat_cursor_belongs_to_user) ... ok
test_walk_chat_list (test_pagination.ChatPaginationTest.test_walk_chat_list) ... ok
test_bad_cursor (test_pagination.MessagePaginationTest.test_bad_cursor) ... ok
test_bad_limit (test_pagination.MessagePaginationTest.test_bad_limit) ... ok
test_cursor_format_is_checked (test_pagination.MessagePaginationTest.test_cursor_format_is_checked) ... ok
test_cursor_from_another_chat (test_pagination.MessagePaginationTest.test_cursor_from_another_chat) ... ok
test_default_limit (test_pagination.MessagePaginationTest.test_default_limit) ... ok
test_exact_page_has_no_cursor (test_pagination.MessagePaginationTest.test_exact_page_has_no_cursor) ... ok
test_limit_can_change_between_pages (test_pagination.MessagePaginationTest.test_limit_can_change_between_pages) ... ok
test_new_message_appears_after_last_page (test_pagination.MessagePaginationTest.test_new_message_appears_after_last_page) ... ok
test_no_duplicates_and_order (test_pagination.MessagePaginationTest.test_no_duplicates_and_order) ... ok
test_walk_several_pages (test_pagination.MessagePaginationTest.test_walk_several_pages) ... ok
test_extra_field (test_validation.InvalidJsonTest.test_extra_field) ... ok
test_malformed_json (test_validation.InvalidJsonTest.test_malformed_json) ... ok
test_malformed_json_in_message (test_validation.InvalidJsonTest.test_malformed_json_in_message) ... ok
test_missing_field (test_validation.InvalidJsonTest.test_missing_field) ... ok
test_not_an_object (test_validation.InvalidJsonTest.test_not_an_object) ... ok
test_wrong_type (test_validation.InvalidJsonTest.test_wrong_type) ... ok
test_empty_message (test_validation.MessageValidationTest.test_empty_message) ... ok
test_nul_character (test_validation.MessageValidationTest.test_nul_character) ... ok
test_sender_id_is_not_accepted (test_validation.MessageValidationTest.test_sender_id_is_not_accepted) ... ok
test_text_limit (test_validation.MessageValidationTest.test_text_limit) ... ok
test_unicode_is_kept (test_validation.MessageValidationTest.test_unicode_is_kept) ... ok
test_whitespace_message (test_validation.MessageValidationTest.test_whitespace_message) ... ok
test_bad_display_names (test_validation.UserValidationTest.test_bad_display_names) ... ok
test_bad_passwords (test_validation.UserValidationTest.test_bad_passwords) ... ok
test_bad_usernames (test_validation.UserValidationTest.test_bad_usernames) ... ok
test_display_name_length_is_counted_in_code_points (test_validation.UserValidationTest.test_display_name_length_is_counted_in_code_points) ... ok
test_duplicate_username (test_validation.UserValidationTest.test_duplicate_username) ... ok
test_password_is_never_returned (test_validation.UserValidationTest.test_password_is_never_returned) ... ok
test_password_length_limits (test_validation.UserValidationTest.test_password_length_limits) ... ok
----------------------------------------------------------------------
Ran 62 tests in 1.797s
OK
отправлено 100, подтверждено 100, в истории 100, уникальных id 100
+46
View File
@@ -0,0 +1,46 @@
# Сохранность: перезапуск API, PostgreSQL и Redis с сохранением volumes
# дата: 2026-10-08T15:55Z, commit: 6473fd0
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
# до перезапуска
postgres StartedAt=2026-10-08T15:55:04.230004924Z
redis StartedAt=2026-10-08T15:55:04.230356549Z
api StartedAt=2026-10-08T15:55:10.436053969Z
$ cat scripts/restart.sh
#!/bin/sh
# Перезапускает API и оба хранилища. Volumes не трогает: данные и сессии должны остаться.
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres redis api
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
# после перезапуска: у всех трёх контейнеров новое время старта
postgres StartedAt=2026-10-08T15:55:15.070657346Z
redis StartedAt=2026-10-08T15:55:15.160837596Z
api StartedAt=2026-10-08T15:55:15.392988013Z
$ docker volume ls --filter name=mtusi-messenger-lab2
DRIVER VOLUME NAME
local mtusi-messenger-lab2_pgdata
local mtusi-messenger-lab2_redisdata
# повторный запуск миграций
$ docker compose --env-file .env run --rm migrate
Container mtusi-messenger-lab2-postgres-1 Running
Container mtusi-messenger-lab2-postgres-1 Waiting
Container mtusi-messenger-lab2-postgres-1 Healthy
Container mtusi-messenger-lab2-migrate-run-c47ffc8919e4 Creating
Container mtusi-messenger-lab2-migrate-run-c47ffc8919e4 Created
уже применена: 0001_init.sql
$ psql: SELECT * FROM schema_migrations
version | applied_at
---------------+-------------------------------
0001_init.sql | 2026-10-08 15:55:10.184216+00
(1 row)
+36
View File
@@ -0,0 +1,36 @@
# Сессии в Redis: настройки persistence, вид ключа, TTL не продлевается перезапуском
# дата: 2026-10-08T15:55Z, commit: 6473fd0
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ redis-cli CONFIG GET appendonly / appendfsync / maxmemory-policy
appendonly
yes
appendfsync
always
maxmemory-policy
noeviction
$ redis-cli --scan --pattern 'session:*' | wc -l
41
# один из ключей: sha256 от токена, значение — id пользователя
$ redis-cli GET session:e478544e3e6f92c4c36896617f812541bdb171df4654de1fafaad9074c962367
97dbb54c-2e55-441f-ae31-ef469b935758
$ redis-cli TTL session:e478544e3e6f92c4c36896617f812541bdb171df4654de1fafaad9074c962367
3591
$ docker compose --env-file .env restart redis
Container mtusi-messenger-lab2-redis-1 Restarting
Container mtusi-messenger-lab2-redis-1 Started
$ redis-cli TTL session:e478544e3e6f92c4c36896617f812541bdb171df4654de1fafaad9074c962367 # после перезапуска ключ на месте, TTL уменьшился
3583
$ docker compose --env-file .env exec -T redis ls -la /data/appendonlydir
total 24
drwx------ 2 redis redis 4096 Oct 8 15:55 .
drwxr-xr-x 3 redis redis 4096 Oct 8 15:55 ..
-rw------- 1 redis redis 89 Oct 8 15:55 appendonly.aof.1.base.rdb
-rw------- 1 redis redis 7582 Oct 8 15:55 appendonly.aof.1.incr.aof
-rw------- 1 redis redis 88 Oct 8 15:55 appendonly.aof.manifest
+36
View File
@@ -0,0 +1,36 @@
# Тесты отказов: истечение сессии, остановка Redis и PostgreSQL, откат транзакции, гонка регистрации
# дата: 2026-10-08T15:55Z, commit: 6473fd0
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make test-failures
BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests/failures -v
test_postgres_down (test_dependencies.DependencyDownTest.test_postgres_down) ... ok
test_redis_down (test_dependencies.DependencyDownTest.test_redis_down) ... ok
test_expires_at_matches_ttl (test_expiry.SessionExpiryTest.test_expires_at_matches_ttl) ... ok
test_login_after_expiry (test_expiry.SessionExpiryTest.test_login_after_expiry) ... ok
test_requests_do_not_extend_session (test_expiry.SessionExpiryTest.test_requests_do_not_extend_session) ... ok
test_session_expires (test_expiry.SessionExpiryTest.test_session_expires) ... ok
test_chat_with_unknown_member_is_rolled_back (test_transactions.TransactionTest.test_chat_with_unknown_member_is_rolled_back) ... ok
test_migrations_can_be_repeated (test_transactions.TransactionTest.test_migrations_can_be_repeated) ... ok
test_password_is_stored_as_argon2id_hash (test_transactions.TransactionTest.test_password_is_stored_as_argon2id_hash) ... ok
test_username_race_creates_one_row (test_transactions.TransactionTest.test_username_race_creates_one_row) ... ok
test_valid_chat_is_committed_whole (test_transactions.TransactionTest.test_valid_chat_is_committed_whole) ... ok
----------------------------------------------------------------------
Ran 11 tests in 47.384s
OK
# время ответа при отказе (после тестов сервисы снова остановлены вручную)
$ docker compose stop redis; curl /api/v1/users/me с Bearer-токеном
{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"ec599bbf80da42ba9410d2bb5fe44408"}}
HTTP 503 за 0.010007 с
$ docker compose stop postgres; curl /health/ready
{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"ff86a9409ca74d1a9207d7efe82e4313"}}
HTTP 503 за 3.015225 с
$ docker compose logs api | grep unavailable | tail -4
api-1 | 2026-10-08 15:55:59,645 WARNING messenger: redis unavailable: ConnectionError request_id=7303c9edcbe8408496ff607945e71893
api-1 | 2026-10-08 15:55:59,653 WARNING messenger: redis unavailable: ConnectionError request_id=0a217c1035f548f0b3a68b9bb0640d3f
api-1 | 2026-10-08 15:56:17,960 WARNING messenger: redis unavailable: ConnectionError request_id=ec599bbf80da42ba9410d2bb5fe44408
api-1 | 2026-10-08 15:56:21,270 WARNING messenger: postgres unavailable: PoolTimeout request_id=ff86a9409ca74d1a9207d7efe82e4313
+74
View File
@@ -0,0 +1,74 @@
# Индекс истории: EXPLAIN (ANALYZE, BUFFERS) на 60 000 сообщений, 10 000 в одном чате
# дата: 2026-10-08T15:56Z, commit: 6473fd0
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make explain
./scripts/explain_history.sh
== Объём данных
messages_total | messages_in_chat | table_size | index_size
----------------+------------------+------------+------------
60140 | 10000 | 6848 kB | 6160 kB
(1 row)
== 1. Первая страница (limit 50, запрос берёт 51 строку)
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..21.21 rows=51 width=80) (actual time=0.007..0.015 rows=51 loops=1)
Buffers: shared hit=8
-> Index Scan using messages_chat_history_idx on messages (cost=0.41..4114.85 rows=10089 width=80) (actual time=0.006..0.012 rows=51 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Buffers: shared hit=8
Planning:
Buffers: shared hit=33
Planning Time: 0.079 ms
Execution Time: 0.025 ms
(9 rows)
== 2. Страница из середины истории: keyset после 5000-го сообщения
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.41..38.79 rows=51 width=80) (actual time=0.006..0.015 rows=51 loops=1)
Buffers: shared hit=8
-> Index Scan using messages_chat_history_idx on messages (cost=0.41..3778.58 rows=5021 width=80) (actual time=0.006..0.012 rows=51 loops=1)
Index Cond: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-08 07:36:22.289031+00'::timestamp with time zone, '31ba47ee-c105-47bd-9bb1-79986700dbd4'::uuid)))
Buffers: shared hit=8
Planning Time: 0.031 ms
Execution Time: 0.034 ms
(7 rows)
== 3. Та же страница через OFFSET (так делать не стали)
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=2039.48..2060.28 rows=51 width=80) (actual time=0.459..0.464 rows=51 loops=1)
Buffers: shared hit=491
-> Index Scan using messages_chat_history_idx on messages (cost=0.41..4114.85 rows=10089 width=80) (actual time=0.005..0.359 rows=5051 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Buffers: shared hit=491
Planning Time: 0.016 ms
Execution Time: 0.469 ms
(7 rows)
== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=2075.96..2076.09 rows=51 width=80) (actual time=2.252..2.256 rows=51 loops=1)
Buffers: shared hit=862
-> Sort (cost=2075.96..2088.51 rows=5021 width=80) (actual time=2.252..2.254 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 31kB
Buffers: shared hit=862
-> Seq Scan on messages (cost=0.00..1908.45 rows=5021 width=80) (actual time=0.939..2.012 rows=5000 loops=1)
Filter: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-08 07:36:22.289031+00'::timestamp with time zone, '31ba47ee-c105-47bd-9bb1-79986700dbd4'::uuid)))
Rows Removed by Filter: 55140
Buffers: shared hit=856
Planning:
Buffers: shared hit=4
Planning Time: 0.032 ms
Execution Time: 2.266 ms
(14 rows)
+58
View File
@@ -0,0 +1,58 @@
# Контейнеры: пользователи, секреты, версии
# дата: 2026-10-08T15:56Z, commit: 6473fd0
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ docker compose --env-file .env exec -T api id
uid=10001(app) gid=10001(app) groups=10001(app)
$ docker compose exec api ls -l /run/secrets
total 8
-r--r--r-- 1 root root 70 Oct 8 15:55 cache_url
-r--r--r-- 1 root root 95 Oct 8 15:55 database_url
$ docker compose exec api env | grep -ci "password\|postgresql://\|redis://" # секретов в окружении нет
0
$ docker compose exec redis ps -o user,args
USER COMMAND
redis redis-server *:6379
root ps -o user,args
$ docker compose exec postgres ps -o user,args | head -3
USER COMMAND
postgres postgres
postgres postgres: checkpointer
$ docker compose --env-file .env images
CONTAINER REPOSITORY TAG PLATFORM IMAGE ID SIZE CREATED
mtusi-messenger-lab2-api-1 mtusi-messenger lab2 linux/arm64 46505be4fa02 203MB 47 minutes ago
mtusi-messenger-lab2-migrate-1 mtusi-messenger lab2 linux/arm64 46505be4fa02 203MB 47 minutes ago
mtusi-messenger-lab2-postgres-1 postgres 17.11-alpine linux/arm64/v8 25a89970a832 291MB 2 weeks ago
mtusi-messenger-lab2-redis-1 redis 7.4.11-alpine linux/arm64/v8 ec4f171e9ff0 39.5MB 2 weeks ago
$ docker compose --env-file .env exec -T api pip freeze --disable-pip-version-check
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi==25.1.0
argon2-cffi-bindings==26.1.0
cffi==2.1.1
click==8.5.0
fastapi==0.143.0
h11==0.16.0
idna==3.20
opentelemetry-api==1.45.1
psycopg==3.3.6
psycopg-binary==3.3.6
psycopg-pool==3.3.3
pycparser==3.1
pydantic==2.13.5
pydantic_core==2.46.5
redis==8.1.0
starlette==1.7.0
typing-inspection==0.4.4
typing_extensions==4.16.0
uvicorn==0.54.0
$ git ls-files | grep -E "^\.env$|secrets" # в Git секретов нет
(пусто)
+11
View File
@@ -0,0 +1,11 @@
# SIGTERM (возможность lab1 сохранена)
# дата: 2026-10-08T15:56Z, commit: 6473fd0
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ python3 scripts/sigterm_check.py
$ docker kill --signal=SIGTERM <контейнер api>
новый запрос после SIGTERM: не принят (RemoteDisconnected)
начатый до SIGTERM запрос: HTTP/1.1 201 Created
процесс завершился за 1.45 с, код выхода 0
PASS: остановка корректная и укладывается в 10 секунд
+39
View File
@@ -0,0 +1,39 @@
-- Пользователи, чаты, участники и сообщения.
CREATE TABLE users (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
-- порядок участника в исходном запросе, чтобы member_ids возвращались как были переданы
position integer NOT NULL,
PRIMARY KEY (chat_id, user_id)
);
-- список чатов пользователя: поиск по user_id, первичный ключ начинается с chat_id и для этого не подходит
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users (id),
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT now()
);
-- история чата читается запросом
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4
-- индекс в том же порядке даёт и фильтр, и сортировку без чтения всей истории
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
+24
View File
@@ -0,0 +1,24 @@
# Прямые зависимости
fastapi==0.143.0
uvicorn==0.54.0
psycopg[binary,pool]==3.3.6
redis==8.1.0
argon2-cffi==25.1.0
# Транзитивные, зафиксированы по pip freeze в python:3.13.16-slim-bookworm
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi-bindings==26.1.0
cffi==2.1.1
click==8.5.0
h11==0.16.0
idna==3.20
opentelemetry-api==1.45.1
psycopg-binary==3.3.6
psycopg-pool==3.3.3
pycparser==3.1
pydantic==2.13.5
pydantic_core==2.46.5
starlette==1.7.0
typing-inspection==0.4.4
typing_extensions==4.16.0
+11
View File
@@ -0,0 +1,11 @@
#!/bin/sh
# Наполняет БД синтетической историей и печатает планы запросов пагинации.
set -eu
cd "$(dirname "$0")/.."
run_sql() {
docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 -q
}
run_sql < scripts/seed_history.sql
run_sql < scripts/explain_history.sql
+44
View File
@@ -0,0 +1,44 @@
\set chat '00000000-0000-4000-8000-000000000100'
\pset pager off
\echo '== Объём данных'
SELECT count(*) AS messages_total,
count(*) FILTER (WHERE chat_id = :'chat') AS messages_in_chat,
pg_size_pretty(pg_relation_size('messages')) AS table_size,
pg_size_pretty(pg_relation_size('messages_chat_history_idx')) AS index_size
FROM messages;
\echo
\echo '== 1. Первая страница (limit 50, запрос берёт 51 строку)'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat'
ORDER BY created_at, id LIMIT 51;
-- cursor на 5000-е сообщение чата, как его получил бы клиент после 100 страниц
SELECT created_at AS after_time, id AS after_id FROM messages
WHERE chat_id = :'chat' ORDER BY created_at, id OFFSET 4999 LIMIT 1 \gset
\echo
\echo '== 2. Страница из середины истории: keyset после 5000-го сообщения'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
ORDER BY created_at, id LIMIT 51;
\echo
\echo '== 3. Та же страница через OFFSET (так делать не стали)'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat'
ORDER BY created_at, id OFFSET 5000 LIMIT 51;
\echo
\echo '== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)'
BEGIN;
DROP INDEX messages_chat_history_idx;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
ORDER BY created_at, id LIMIT 51;
ROLLBACK;
+25
View File
@@ -0,0 +1,25 @@
#!/bin/sh
# Создаёт .env из .env.example и дописывает в него случайные пароли. Файл .env исключён из Git.
set -eu
cd "$(dirname "$0")/.."
[ -f .env ] || cp .env.example .env
if grep -q '^POSTGRES_PASSWORD=' .env; then
# пароль PostgreSQL задаётся один раз при создании volume, новый пароль к старым данным не подойдёт
echo ".env уже содержит пароли, ничего не меняю"
exit 0
fi
postgres_password=$(openssl rand -hex 24)
redis_password=$(openssl rand -hex 24)
cat >> .env <<END
# Локальные секреты, созданы scripts/init-env.sh. Compose кладёт их в контейнеры файлами /run/secrets/*.
POSTGRES_PASSWORD=$postgres_password
REDIS_PASSWORD=$redis_password
DATABASE_URL=postgresql://messenger:$postgres_password@postgres:5432/messenger
CACHE_URL=redis://:$redis_password@redis:6379/0
END
chmod 600 .env
echo "пароли записаны в .env"
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
# Перезапускает API и оба хранилища. Volumes не трогает: данные и сессии должны остаться.
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres redis api
+26
View File
@@ -0,0 +1,26 @@
-- Синтетические данные для EXPLAIN: 21 чат и 60 000 сообщений, из них 10 000 в исследуемом чате.
-- Повторный запуск ничего не добавляет. Войти под этим пользователем нельзя: вместо hash стоит заглушка.
INSERT INTO users (id, username, display_name, password_hash)
VALUES ('00000000-0000-4000-8000-000000000001', 'explain_seed', 'Данные для EXPLAIN', '!')
ON CONFLICT DO NOTHING;
INSERT INTO chats (id, title)
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(n::text, 2, '0'))::uuid, 'EXPLAIN чат ' || n
FROM generate_series(0, 20) AS n
ON CONFLICT DO NOTHING;
INSERT INTO chat_members (chat_id, user_id, position)
SELECT id, '00000000-0000-4000-8000-000000000001', 0 FROM chats WHERE title LIKE 'EXPLAIN чат %'
ON CONFLICT DO NOTHING;
-- чат 00: 10 000 сообщений; чаты 01..20: по 2 500. Время идёт с шагом в секунду и перемешано между чатами.
INSERT INTO messages (chat_id, sender_id, text, created_at)
SELECT ('00000000-0000-4000-8000-0000000001' || lpad((CASE WHEN n % 6 = 0 THEN 0 ELSE 1 + n % 20 END)::text, 2, '0'))::uuid,
'00000000-0000-4000-8000-000000000001',
'сообщение ' || n,
now() - make_interval(secs => 60000 - n)
FROM generate_series(1, 60000) AS n
WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100');
ANALYZE messages;
+69
View File
@@ -0,0 +1,69 @@
#!/usr/bin/env python3
"""Проверка SIGTERM (перенесена из lab1): начатый запрос завершается, новые не принимаются, выход быстрее 10 секунд."""
import json
import socket
import subprocess
import sys
import time
import urllib.parse
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "student-tests"))
from api import BASE_URL, call, new_chat, new_user
LIMIT_SECONDS = 10
def main():
container = subprocess.run(
["docker", "compose", "--env-file", ".env", "ps", "-q", "api"],
cwd=ROOT, check=True, capture_output=True, text=True,
).stdout.strip()
address = urllib.parse.urlsplit(BASE_URL)
user = new_user("sigterm")
chat = new_chat(user)
# отправляем заголовки и только половину тела: запрос уже начат, но ещё не закончен
body = json.dumps({"text": "сообщение, отправленное во время остановки"}).encode()
head = (
"POST /api/v1/chats/%s/messages HTTP/1.1\r\n"
"Host: %s\r\nContent-Type: application/json\r\nContent-Length: %d\r\nAuthorization: Bearer %s\r\n\r\n"
% (chat["id"], address.netloc, len(body), user["token"])
).encode()
connection = socket.create_connection((address.hostname, address.port), timeout=LIMIT_SECONDS)
connection.sendall(head + body[:10])
time.sleep(0.3)
print("$ docker kill --signal=SIGTERM <контейнер api>")
started = time.monotonic()
subprocess.run(["docker", "kill", "--signal=SIGTERM", container], check=True, stdout=subprocess.DEVNULL)
time.sleep(1)
try:
status = call("GET", "/health/live")[0]
print("новый запрос после SIGTERM: принят, статус", status)
accepted = True
except OSError as error:
print("новый запрос после SIGTERM: не принят (%s)" % type(error).__name__)
accepted = False
connection.sendall(body[10:])
status_line = connection.recv(65536).split(b"\r\n")[0].decode()
connection.close()
print("начатый до SIGTERM запрос:", status_line)
exit_code = subprocess.run(["docker", "wait", container], check=True, capture_output=True, text=True).stdout.strip()
elapsed = time.monotonic() - started
print("процесс завершился за %.2f с, код выхода %s" % (elapsed, exit_code))
# контейнер, остановленный через docker kill, сам не перезапускается: поднимаем его обратно
subprocess.run(["docker", "start", container], check=True, stdout=subprocess.DEVNULL)
if accepted or " 201 " not in status_line or elapsed > LIMIT_SECONDS or exit_code != "0":
raise SystemExit("FAIL")
print("PASS: остановка корректная и укладывается в %d секунд" % LIMIT_SECONDS)
if __name__ == "__main__":
main()
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Ждёт, пока /health/ready ответит 200, не дольше 60 секунд.
BASE_URL=${BASE_URL:-http://localhost:8080}
for attempt in $(seq 1 60); do
if curl -fs -o /dev/null "$BASE_URL/health/ready"; then
echo "готов: $BASE_URL"
exit 0
fi
sleep 1
done
echo "стенд не стал готов за 60 секунд: $BASE_URL" >&2
exit 1
+41
View File
@@ -0,0 +1,41 @@
import os
from pathlib import Path
HOST = os.getenv("APP_HOST", "0.0.0.0")
PORT = int(os.getenv("APP_PORT", "8080"))
ENV = os.getenv("APP_ENV", "lab")
LOG_LEVEL = os.getenv("LOG_LEVEL", "info").lower()
# docker stop по умолчанию ждёт 10 секунд, поэтому укладываемся с запасом
SHUTDOWN_TIMEOUT = int(os.getenv("SHUTDOWN_TIMEOUT", "8"))
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
SESSION_STORE = os.getenv("SESSION_STORE", "redis")
# пул соединений с PostgreSQL и таймауты, всё в секундах
DB_POOL_MIN_SIZE = int(os.getenv("DB_POOL_MIN_SIZE", "2"))
DB_POOL_MAX_SIZE = int(os.getenv("DB_POOL_MAX_SIZE", "10"))
DB_POOL_TIMEOUT = float(os.getenv("DB_POOL_TIMEOUT", "3"))
DB_CONNECT_TIMEOUT = int(os.getenv("DB_CONNECT_TIMEOUT", "3"))
DB_STATEMENT_TIMEOUT = int(os.getenv("DB_STATEMENT_TIMEOUT", "5"))
CACHE_POOL_MAX_SIZE = int(os.getenv("CACHE_POOL_MAX_SIZE", "20"))
CACHE_TIMEOUT = float(os.getenv("CACHE_TIMEOUT", "2"))
def read_secret(name: str) -> str:
"""Значение берётся из файла, путь к которому лежит в NAME_FILE. Для отладки без Docker подойдёт и сама NAME."""
path = os.getenv(name + "_FILE")
if path and Path(path).is_file():
return Path(path).read_text().strip()
value = os.getenv(name)
if not value:
raise SystemExit(f"не задан {name}_FILE или {name}")
return value
def database_url() -> str:
return read_secret("DATABASE_URL")
def cache_url() -> str:
return read_secret("CACHE_URL")
+38
View File
@@ -0,0 +1,38 @@
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers=None):
self.status = status
self.code = code
self.message = message
self.headers = headers
def invalid(message: str) -> ApiError:
return ApiError(400, "invalid_request", message)
def bad_credentials() -> ApiError:
# один и тот же ответ для неизвестного username и неверного пароля
return ApiError(
401, "unauthorized", "Неверное имя пользователя или пароль",
{"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
)
def unauthorized() -> ApiError:
return ApiError(
401, "unauthorized", "Нужен действующий Bearer-токен",
{"WWW-Authenticate": 'Bearer realm="messenger"'},
)
def not_found() -> ApiError:
# одинаковый ответ для несуществующего и чужого объекта
return ApiError(404, "not_found", "Объект не найден")
def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse:
body = {"error": {"code": code, "message": message, "request_id": request_id}}
return JSONResponse(body, status_code=status, headers=headers)
+11
View File
@@ -0,0 +1,11 @@
"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200."""
import os
import sys
import urllib.request
port = os.getenv("APP_PORT", "8080")
try:
with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response:
sys.exit(0 if response.status == 200 else 1)
except Exception:
sys.exit(1)
+280
View File
@@ -0,0 +1,280 @@
import base64
import json
import logging
import re
import sys
import time
import uuid
from contextlib import asynccontextmanager
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from uuid import UUID
import psycopg
import redis
import uvicorn
from fastapi import Depends, FastAPI, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException
import config
import security
from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized
from schemas import CreateChat, CreateMessage, CreateUser
from sessions import Sessions
from store import TIME_FORMAT, Store, UnknownMember, UsernameTaken, timestamp
logging.basicConfig(
level=config.LOG_LEVEL.upper(),
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
stream=sys.stdout,
)
log = logging.getLogger("messenger")
if config.SESSION_STORE != "redis":
sys.exit("поддерживается только SESSION_STORE=redis")
USERNAME = re.compile(r"[a-z0-9_]{3,32}")
store = Store(config.database_url())
sessions = Sessions(config.cache_url())
@asynccontextmanager
async def lifespan(app: FastAPI):
store.open()
log.info(
"started env=%s listen=%s:%d session_ttl=%ds db_pool_max=%d",
config.ENV, config.HOST, config.PORT, config.SESSION_TTL_SECONDS, config.DB_POOL_MAX_SIZE,
)
yield
store.close()
sessions.close()
log.info("stopped")
app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
@app.middleware("http")
async def request_context(request: Request, call_next):
request_id = uuid.uuid4().hex
request.state.request_id = request_id
started = time.perf_counter()
try:
response = await call_next(request)
except Exception:
log.exception("unhandled error request_id=%s", request_id)
response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера")
response.headers["X-Request-Id"] = request_id
# в лог идут только метод, путь и код ответа: тела запросов, пароли и токены не пишем
log.info(
"%s %s status=%d duration_ms=%.1f request_id=%s",
request.method, request.url.path, response.status_code,
(time.perf_counter() - started) * 1000, request_id,
)
return response
@app.exception_handler(ApiError)
async def on_api_error(request: Request, exc: ApiError):
return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def on_validation_error(request: Request, exc: RequestValidationError):
first = exc.errors()[0]
where = ".".join(str(part) for part in first["loc"])
return error_response(request.state.request_id, 400, "invalid_request", f"{where}: {first['msg']}")
@app.exception_handler(HTTPException)
async def on_http_error(request: Request, exc: HTTPException):
# сюда попадают ошибки самого фреймворка: неизвестный путь, неподдерживаемый метод
if exc.status_code == 404:
code, message = "not_found", "Объект не найден"
else:
code, message = "invalid_request", "Запрос не поддерживается"
return error_response(request.state.request_id, exc.status_code, code, message, exc.headers)
# OperationalError — нет связи с PostgreSQL, не дождались соединения из пула или сработал statement_timeout
@app.exception_handler(psycopg.OperationalError)
async def on_database_down(request: Request, exc: Exception):
log.warning("postgres unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@app.exception_handler(redis.RedisError)
async def on_cache_down(request: Request, exc: Exception):
log.warning("redis unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@dataclass
class Session:
user_id: str
token: str
def current_session(request: Request) -> Session:
# X-User-Id из lab1 здесь не читается вообще, Basic на бизнес-запросах тоже не принимается
token = security.parse_bearer(request.headers.get("Authorization"))
if token is None:
raise unauthorized()
# если Redis недоступен, здесь будет исключение и ответ 503: без проверки сессии запрос дальше не идёт
user_id = sessions.user_id(token)
if user_id is None:
raise unauthorized()
return Session(user_id, token)
def encode_cursor(scope: str, created_at: str, item_id: str) -> str:
raw = json.dumps([scope, created_at, item_id])
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(scope: str, cursor):
"""Возвращает ключ (created_at, id) последней выданной записи или None для первой страницы."""
if cursor is None:
return None
try:
# validate=True: символ вне алфавита base64 — ошибка, а не пропускается молча
cursor_scope, created_at, item_id = json.loads(base64.b64decode(cursor, altchars=b"-_", validate=True))
# время и id принимаются только в том виде, в котором их выдаёт сам сервер
moment = datetime.strptime(created_at, TIME_FORMAT).replace(tzinfo=timezone.utc)
time_ok = moment.strftime(TIME_FORMAT) == created_at
id_ok = str(UUID(item_id)) == item_id
except (TypeError, ValueError, AttributeError):
raise invalid("Некорректный cursor")
# cursor действует только для того списка, в котором был выдан
if cursor_scope != scope or not time_ok or not id_ok:
raise invalid("Некорректный cursor")
# у одной позиции есть ровно одна запись cursor: другое оформление JSON или base64 не принимается
if encode_cursor(scope, created_at, item_id) != cursor:
raise invalid("Некорректный cursor")
return [moment, item_id]
def page(scope: str, items: list, has_more: bool) -> dict:
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more else None
return {"items": items, "next_cursor": next_cursor}
@app.get("/health/live")
def liveness():
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
# без PostgreSQL и Redis обязательные запросы не выполнить, поэтому обе зависимости критичны
store.ping()
sessions.ping()
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def register_user(body: CreateUser):
try:
return store.create_user(body.username, body.display_name, security.hash_password(body.password))
except UsernameTaken:
raise ApiError(409, "conflict", "Такой username уже занят")
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
credentials = security.parse_basic(request.headers.get("Authorization"))
if credentials is None:
raise bad_credentials()
username, password = credentials
user, password_hash = None, None
# username, который не мог быть зарегистрирован, в БД не ищем, но пароль всё равно сверяем с пустышкой
if USERNAME.fullmatch(username):
user, password_hash = store.get_credentials(username)
if not security.verify_password(password_hash, password):
raise bad_credentials()
token = sessions.create(user["id"])
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
return {"token": token, "token_type": "Bearer", "expires_at": timestamp(expires_at), "user": user}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(session: Session = Depends(current_session)):
sessions.revoke(session.token)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def get_me(session: Session = Depends(current_session)):
user = store.get_user(session.user_id)
if user is None:
raise unauthorized()
return user
@app.post("/api/v1/chats", status_code=201)
def create_chat(body: CreateChat, session: Session = Depends(current_session)):
member_ids = [str(member) for member in body.member_ids]
if len(set(member_ids)) != len(member_ids):
raise invalid("member_ids содержит повторы")
if session.user_id not in member_ids:
raise invalid("Создатель чата должен быть в member_ids")
try:
return store.create_chat(body.title, member_ids)
except UnknownMember:
raise invalid("В member_ids есть несуществующий пользователь")
@app.get("/api/v1/chats")
def list_chats(
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
scope = "chats:" + session.user_id
items, has_more = store.list_chats(session.user_id, decode_cursor(scope, cursor), limit)
return page(scope, items, has_more)
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: UUID, session: Session = Depends(current_session)):
chat = store.get_chat(str(chat_id), session.user_id)
if chat is None:
raise not_found()
return chat
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def send_message(chat_id: UUID, body: CreateMessage, session: Session = Depends(current_session)):
# отправитель берётся из сессии, в теле запроса его нет
message = store.add_message(str(chat_id), session.user_id, body.text)
if message is None:
raise not_found()
return message
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: UUID,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
scope = "messages:" + str(chat_id)
result = store.list_messages(str(chat_id), session.user_id, decode_cursor(scope, cursor), limit)
if result is None:
raise not_found()
items, has_more = result
return page(scope, items, has_more)
if __name__ == "__main__":
uvicorn.run(
app,
host=config.HOST,
port=config.PORT,
log_level=config.LOG_LEVEL,
access_log=False,
timeout_graceful_shutdown=config.SHUTDOWN_TIMEOUT,
)
+48
View File
@@ -0,0 +1,48 @@
"""Применяет SQL-миграции из каталога migrations по порядку имён. Повторный запуск ничего не меняет."""
import os
import sys
import time
from pathlib import Path
import psycopg
import config
MIGRATIONS_DIR = Path(os.getenv("MIGRATIONS_DIR", "migrations"))
LOCK_ID = 20260201 # любое постоянное число: два мигратора не должны работать одновременно
def connect(attempts=30):
for attempt in range(attempts):
try:
return psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT)
except psycopg.OperationalError:
if attempt == attempts - 1:
raise
time.sleep(1)
def main():
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
if not files:
sys.exit(f"в {MIGRATIONS_DIR} нет миграций")
with connect() as conn:
conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,))
conn.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
"version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())"
)
applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
for path in files:
if path.name in applied:
print("уже применена:", path.name)
continue
# миграция и отметка о ней в одной транзакции: либо всё, либо ничего
with conn.transaction():
conn.execute(path.read_text())
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
print("применена:", path.name)
if __name__ == "__main__":
main()
+38
View File
@@ -0,0 +1,38 @@
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
def not_blank(value: str) -> str:
if not value.strip():
raise ValueError("строка не может состоять только из пробелов")
# PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8
if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value):
raise ValueError("строка содержит недопустимые символы")
return value
class StrictModel(BaseModel):
# лишние поля в JSON считаются ошибкой
model_config = ConfigDict(extra="forbid")
class CreateUser(StrictModel):
username: str = Field(pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
_not_blank = field_validator("display_name", "password")(not_blank)
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[UUID] = Field(min_length=1, max_length=100)
_title = field_validator("title")(not_blank)
class CreateMessage(StrictModel):
text: str = Field(min_length=1, max_length=4000)
_text = field_validator("text")(not_blank)
+45
View File
@@ -0,0 +1,45 @@
import base64
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username
DUMMY_HASH = hasher.hash("no-such-user-password")
def hash_password(password: str) -> str:
return hasher.hash(password)
def verify_password(password_hash, password: str) -> bool:
try:
return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None
except (VerificationError, InvalidHashError):
return False
def parse_basic(header):
"""Разбирает Authorization: Basic base64(username:password). Возвращает пару или None."""
scheme, _, value = (header or "").partition(" ")
if scheme.lower() != "basic":
return None
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except ValueError:
# три случая сразу: не ASCII в заголовке (сам ValueError), неверный base64 и байты не в UTF-8
# (их исключения — подклассы ValueError)
return None
# двоеточие в пароле допустимо, поэтому делим только по первому
username, colon, password = decoded.partition(":")
if not colon:
return None
return username, password
def parse_bearer(header):
scheme, _, token = (header or "").partition(" ")
if scheme.lower() != "bearer" or not token.strip():
return None
return token.strip()
+47
View File
@@ -0,0 +1,47 @@
import hashlib
import secrets
import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
import config
class Sessions:
"""Сессии лежат только в Redis: ключ session:<sha256 токена>, значение id пользователя, TTL ставит сам Redis."""
def __init__(self, url: str):
pool = redis.BlockingConnectionPool.from_url(
url,
max_connections=config.CACHE_POOL_MAX_SIZE,
timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения
socket_timeout=config.CACHE_TIMEOUT,
socket_connect_timeout=config.CACHE_TIMEOUT,
decode_responses=True,
# одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается
retry=Retry(NoBackoff(), 1),
)
self.client = redis.Redis(connection_pool=pool)
@staticmethod
def key(token: str) -> str:
# сам токен в Redis не хранится: по дампу нельзя войти от чужого имени
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def create(self, user_id: str) -> str:
token = secrets.token_urlsafe(32) # 256 бит случайности
self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS)
return token
def user_id(self, token: str):
return self.client.get(self.key(token))
def revoke(self, token: str) -> None:
self.client.delete(self.key(token))
def ping(self) -> None:
self.client.ping()
def close(self) -> None:
self.client.close()
+189
View File
@@ -0,0 +1,189 @@
from datetime import timezone
from psycopg import errors
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
import config
class UsernameTaken(Exception):
pass
class UnknownMember(Exception):
pass
# ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz
TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
def timestamp(value) -> str:
return value.astimezone(timezone.utc).strftime(TIME_FORMAT)
def user_json(row) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": timestamp(row["created_at"]),
}
def chat_json(row) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(member) for member in row["member_ids"]],
"created_at": timestamp(row["created_at"]),
}
def message_json(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": timestamp(row["created_at"]),
}
CHAT_COLUMNS = """
c.id, c.title, c.created_at,
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids
"""
class Store:
"""Все данные мессенджера в PostgreSQL. Значения в запросы попадают только через параметры %s."""
def __init__(self, url: str):
self.pool = ConnectionPool(
url,
min_size=config.DB_POOL_MIN_SIZE,
max_size=config.DB_POOL_MAX_SIZE,
timeout=config.DB_POOL_TIMEOUT, # сколько запрос ждёт свободное соединение
kwargs={
"connect_timeout": config.DB_CONNECT_TIMEOUT,
"options": f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT * 1000}",
"row_factory": dict_row,
},
# перед выдачей соединение проверяется, поэтому после перезапуска БД мёртвые соединения не достаются запросам
check=ConnectionPool.check_connection,
open=False,
)
def open(self) -> None:
# не ждём БД: если она недоступна, сервер стартует и отвечает 503
self.pool.open(wait=False)
def close(self) -> None:
self.pool.close()
def ping(self) -> None:
with self.pool.connection() as conn:
conn.execute("SELECT 1")
def create_user(self, username: str, display_name: str, password_hash: str) -> dict:
with self.pool.connection() as conn:
try:
row = conn.execute(
"INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s) "
"RETURNING id, username, display_name, created_at",
(username, display_name, password_hash),
).fetchone()
except errors.UniqueViolation:
# уникальность проверяет сама БД, поэтому два одновременных запроса не создадут двух пользователей
raise UsernameTaken()
return user_json(row)
def get_user(self, user_id: str):
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,)
).fetchone()
return user_json(row) if row else None
def get_credentials(self, username: str):
"""Пользователь и hash его пароля или (None, None)."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,),
).fetchone()
if row is None:
return None, None
return user_json(row), row["password_hash"]
def create_chat(self, title: str, member_ids: list) -> dict:
# блок with — одна транзакция: commit при выходе, rollback при любом исключении
with self.pool.connection() as conn:
chat = conn.execute(
"INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at", (title,)
).fetchone()
try:
with conn.cursor() as cursor:
cursor.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat["id"], member, position) for position, member in enumerate(member_ids)],
)
except errors.ForeignKeyViolation:
# участника нет в users: транзакция откатывается вместе с уже вставленным чатом
raise UnknownMember()
return chat_json({**chat, "member_ids": member_ids})
def get_chat(self, chat_id: str, user_id: str):
with self.pool.connection() as conn:
row = conn.execute(
f"SELECT {CHAT_COLUMNS} FROM chats c "
"JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE c.id = %s",
(user_id, chat_id),
).fetchone()
return chat_json(row) if row else None
def list_chats(self, user_id: str, after, limit: int):
query = f"SELECT {CHAT_COLUMNS} FROM chats c JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s"
params = [user_id]
if after:
query += " AND (c.created_at, c.id) > (%s, %s)"
params += after
query += " ORDER BY c.created_at, c.id LIMIT %s"
with self.pool.connection() as conn:
rows = conn.execute(query, params + [limit + 1]).fetchall()
return [chat_json(row) for row in rows[:limit]], len(rows) > limit
def add_message(self, chat_id: str, sender_id: str, text: str):
with self.pool.connection() as conn:
if not self._is_member(conn, chat_id, sender_id):
return None
row = conn.execute(
"INSERT INTO messages (chat_id, sender_id, text) VALUES (%s, %s, %s) "
"RETURNING id, chat_id, sender_id, text, created_at",
(chat_id, sender_id, text),
).fetchone()
return message_json(row)
def list_messages(self, chat_id: str, user_id: str, after, limit: int):
query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s"
params = [chat_id]
if after:
# keyset: продолжаем с записи после cursor, а не пропускаем N строк
query += " AND (created_at, id) > (%s, %s)"
params += after
query += " ORDER BY created_at, id LIMIT %s"
with self.pool.connection() as conn:
if not self._is_member(conn, chat_id, user_id):
return None
# limit + 1: лишняя строка показывает, есть ли следующая страница
rows = conn.execute(query, params + [limit + 1]).fetchall()
return [message_json(row) for row in rows[:limit]], len(rows) > limit
@staticmethod
def _is_member(conn, chat_id: str, user_id: str) -> bool:
row = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)
).fetchone()
return row is not None
+82
View File
@@ -0,0 +1,82 @@
"""Маленький HTTP-клиент для собственных тестов. Только стандартная библиотека."""
import base64
import json
import os
import urllib.error
import urllib.parse
import urllib.request
import uuid
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
def call(method, path, body=None, user=None, raw=None, headers=None, base_url=None):
"""Возвращает (код ответа, разобранный JSON или None, заголовки)."""
request_headers = {"Accept": "application/json"}
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
if raw is not None:
request_headers["Content-Type"] = "application/json"
if user is not None:
request_headers["Authorization"] = "Bearer " + user["token"]
request_headers.update(headers or {})
request = urllib.request.Request((base_url or BASE_URL) + path, data=raw, headers=request_headers, method=method)
try:
response = urllib.request.urlopen(request, timeout=15)
except urllib.error.HTTPError as error:
response = error
with response:
data = response.read()
return response.status, json.loads(data) if data else None, response.headers
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()}
def login(username, password, base_url=None):
return call("POST", "/api/v1/auth/sessions", headers=basic(username, password), base_url=base_url)
def user_body(**fields):
"""Корректное тело регистрации со случайным username; поля можно переопределить."""
body = {"username": "u_" + uuid.uuid4().hex[:12], "display_name": "Тест", "password": "Pw-" + uuid.uuid4().hex}
body.update(fields)
return body
def new_user(prefix="t", base_url=None):
"""Регистрирует синтетического пользователя и сразу входит. В словаре id, username, password и token."""
body = user_body(username=prefix + "_" + uuid.uuid4().hex[:12], display_name="Тест " + prefix)
status, user, _ = call("POST", "/api/v1/users", body, base_url=base_url)
assert status == 201, status
status, session, _ = login(body["username"], body["password"], base_url=base_url)
assert status == 201, status
return {**user, "password": body["password"], "token": session["token"], "user": user}
def new_chat(owner, *others, title="Тестовый чат"):
member_ids = [owner["id"]] + [other["id"] for other in others]
status, chat, _ = call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=owner)
assert status == 201, status
return chat
def send(user, chat, text):
return call("POST", "/api/v1/chats/" + chat["id"] + "/messages", {"text": text}, user=user)
def history(user, chat, limit):
"""Обходит всю историю чата страницами по limit, возвращает сообщения и размеры страниц."""
items, sizes, cursor = [], [], None
while True:
path = "/api/v1/chats/%s/messages?limit=%d" % (chat["id"], limit)
if cursor:
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
status, page, _ = call("GET", path, user=user)
assert status == 200, status
items += page["items"]
sizes.append(len(page["items"]))
cursor = page["next_cursor"]
if cursor is None:
return items, sizes
+39
View File
@@ -0,0 +1,39 @@
"""Управление стендом для тестов отказов: останавливает и запускает сервисы через docker compose."""
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "student-tests"))
from api import BASE_URL, call # noqa: E402
def compose(*args):
command = ["docker", "compose", "--env-file", ".env", *args]
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
def sql(query):
"""Выполняет запрос через psql внутри контейнера postgres и возвращает вывод без оформления."""
return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-At", "-c", query).strip()
def wait_ready(base_url=BASE_URL, seconds=60):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if call("GET", "/health/ready", base_url=base_url)[0] == 200:
return
except OSError:
pass
time.sleep(0.3)
raise AssertionError("стенд не стал готов за %d секунд" % seconds)
def timed(*args, **kwargs):
"""Как call, но первым элементом возвращает время ответа в секундах."""
started = time.monotonic()
result = call(*args, **kwargs)
return (time.monotonic() - started, *result)
@@ -0,0 +1,76 @@
"""Недоступность Redis и PostgreSQL: ограниченная по времени ошибка 503, анониму доступ не открывается."""
import unittest
from stand import call, compose, timed, wait_ready
from api import basic, history, new_chat, new_user, send, user_body
# таймауты в .env.example: 2 с на Redis, 3 с на ожидание соединения с БД; берём запас
MAX_SECONDS = 6
class DependencyDownTest(unittest.TestCase):
def setUp(self):
wait_ready()
self.user = new_user("dep")
self.chat = new_chat(self.user)
send(self.user, self.chat, "сообщение до отказа")
self.messages = "/api/v1/chats/" + self.chat["id"] + "/messages"
def assert_unavailable(self, result):
elapsed, status, body, headers = result
self.assertEqual(status, 503)
self.assertEqual(body["error"]["code"], "unavailable")
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
self.assertLess(elapsed, MAX_SECONDS)
def test_redis_down(self):
compose("stop", "redis")
self.addCleanup(wait_ready)
self.addCleanup(compose, "start", "redis")
# сессию проверить нечем: запрос с настоящим токеном не выполняется, но и чужим не становится
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
self.assert_unavailable(timed("GET", self.messages, user=self.user))
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user))
# поддельный токен тоже не принимается за действующий
self.assert_unavailable(timed("GET", "/api/v1/users/me", user={"token": "x" * 43}))
# без токена ответ прежний, Redis для него не нужен
self.assertEqual(call("GET", "/api/v1/users/me")[0], 401)
self.assertEqual(call("GET", self.messages)[0], 401)
# новую сессию создать негде
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
headers=basic(self.user["username"], self.user["password"])))
self.assert_unavailable(timed("GET", "/health/ready"))
self.assertEqual(call("GET", "/health/live")[0], 200)
compose("start", "redis")
wait_ready()
# прежний токен снова работает: сессия пережила остановку Redis, а сообщение во время отказа не записалось
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
def test_postgres_down(self):
compose("stop", "postgres")
self.addCleanup(wait_ready)
self.addCleanup(compose, "start", "postgres")
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
self.assert_unavailable(timed("GET", self.messages, user=self.user))
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user))
self.assert_unavailable(timed("POST", "/api/v1/users", user_body()))
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
headers=basic(self.user["username"], self.user["password"])))
# проверка токена идёт в Redis, поэтому аноним по-прежнему получает 401
self.assertEqual(call("GET", "/api/v1/users/me")[0], 401)
self.assert_unavailable(timed("GET", "/health/ready"))
self.assertEqual(call("GET", "/health/live")[0], 200)
compose("start", "postgres")
wait_ready()
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
self.assertEqual(send(self.user, self.chat, "после восстановления")[0], 201)
if __name__ == "__main__":
unittest.main()
+54
View File
@@ -0,0 +1,54 @@
"""Истечение сессии. Проверяется на втором экземпляре API с SESSION_TTL_SECONDS=2 (порт 8081)."""
import datetime
import time
import unittest
from stand import call, compose, wait_ready
from api import login, new_user
SHORT_TTL_URL = "http://localhost:8081"
class SessionExpiryTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
compose("--profile", "test", "up", "-d", "api-short-ttl")
cls.addClassCleanup(compose, "--profile", "test", "rm", "-sf", "api-short-ttl")
wait_ready(SHORT_TTL_URL)
def test_session_expires(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 200)
time.sleep(3)
status, body, headers = call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
# logout с истёкшим токеном тоже 401
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user, base_url=SHORT_TTL_URL)[0], 401)
def test_expires_at_matches_ttl(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
_, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
self.assertTrue(0 < left <= 2.5, left)
def test_requests_do_not_extend_session(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
deadline = time.monotonic() + 3
while time.monotonic() < deadline:
call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
time.sleep(0.2)
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 401)
def test_login_after_expiry(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
time.sleep(3)
status, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
self.assertEqual(status, 201)
self.assertEqual(call("GET", "/api/v1/users/me", user=session, base_url=SHORT_TTL_URL)[0], 200)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,65 @@
"""Проверки на уровне БД: откат составной операции, гонка регистрации, повторный запуск миграций."""
import threading
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
from stand import call, compose, sql, wait_ready
from api import new_user, user_body
class TransactionTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
wait_ready()
cls.alice, cls.bob = new_user("alice"), new_user("bob")
def create_chat(self, title, member_ids):
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)
def test_chat_with_unknown_member_is_rolled_back(self):
title = "rollback-" + uuid.uuid4().hex
# Алиса и Боб существуют, третьего участника нет: вставка чата и двух участников уже выполнена,
# на третьем срабатывает внешний ключ, и транзакция должна откатить всё
status, body, _ = self.create_chat(title, [self.alice["id"], self.bob["id"], str(uuid.uuid4())])
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "0")
self.assertEqual(sql("SELECT count(*) FROM chat_members m LEFT JOIN chats c ON c.id = m.chat_id WHERE c.id IS NULL"), "0")
def test_valid_chat_is_committed_whole(self):
title = "commit-" + uuid.uuid4().hex
status, chat, _ = self.create_chat(title, [self.alice["id"], self.bob["id"]])
self.assertEqual(status, 201)
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "1")
self.assertEqual(sql("SELECT count(*) FROM chat_members WHERE chat_id = '%s'" % chat["id"]), "2")
def test_username_race_creates_one_row(self):
body = user_body(username="race_" + uuid.uuid4().hex[:8])
barrier = threading.Barrier(10)
def register(_):
barrier.wait()
return call("POST", "/api/v1/users", body)[0]
with ThreadPoolExecutor(max_workers=10) as pool:
statuses = sorted(pool.map(register, range(10)))
self.assertEqual(statuses, [201] + [409] * 9)
self.assertEqual(sql("SELECT count(*) FROM users WHERE username = '%s'" % body["username"]), "1")
def test_password_is_stored_as_argon2id_hash(self):
stored = sql("SELECT password_hash FROM users WHERE id = '%s'" % self.alice["id"])
self.assertTrue(stored.startswith("$argon2id$"), stored[:12])
self.assertNotIn(self.alice["password"], stored)
def test_migrations_can_be_repeated(self):
before = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
output = compose("run", "--rm", "migrate")
self.assertIn("уже применена: 0001_init.sql", output)
self.assertEqual(sql("SELECT count(*) FROM schema_migrations"), "1")
after = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
self.assertEqual(before, after)
if __name__ == "__main__":
unittest.main()
+77
View File
@@ -0,0 +1,77 @@
import unittest
import uuid
from api import call, new_chat, new_user, send
class ForeignChatTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve")
cls.chat = new_chat(cls.alice, cls.bob)
cls.path = "/api/v1/chats/" + cls.chat["id"]
send(cls.alice, cls.chat, "секрет")
def test_outsider_gets_404_everywhere(self):
self.assertEqual(call("GET", self.path, user=self.eve)[0], 404)
self.assertEqual(call("GET", self.path + "/messages", user=self.eve)[0], 404)
status, body, _ = send(self.eve, self.chat, "я тут")
self.assertEqual(status, 404)
self.assertEqual(body["error"]["code"], "not_found")
def test_foreign_chat_looks_like_missing_chat(self):
_, foreign, _ = call("GET", self.path, user=self.eve)
_, missing, _ = call("GET", "/api/v1/chats/" + str(uuid.uuid4()), user=self.eve)
self.assertEqual(foreign["error"]["message"], missing["error"]["message"])
def test_outsider_message_is_not_saved(self):
send(self.eve, self.chat, "не должно появиться")
_, page, _ = call("GET", self.path + "/messages", user=self.alice)
self.assertNotIn("не должно появиться", [item["text"] for item in page["items"]])
def test_chat_is_not_listed_for_outsider(self):
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.eve)
self.assertNotIn(self.chat["id"], [item["id"] for item in page["items"]])
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
self.assertIn(self.chat["id"], [item["id"] for item in page["items"]])
def test_members_can_read_and_write(self):
self.assertEqual(send(self.bob, self.chat, "ответ")[0], 201)
self.assertEqual(call("GET", self.path, user=self.bob)[0], 200)
def test_bad_chat_id(self):
self.assertEqual(call("GET", "/api/v1/chats/123", user=self.alice)[0], 400)
class CreateChatTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice, cls.bob = new_user("alice"), new_user("bob")
def create(self, member_ids, title="Чат"):
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)[0]
def test_creator_must_be_member(self):
self.assertEqual(self.create([self.bob["id"]]), 400)
def test_duplicate_members(self):
self.assertEqual(self.create([self.alice["id"], self.bob["id"], self.bob["id"]]), 400)
def test_unknown_member(self):
self.assertEqual(self.create([self.alice["id"], str(uuid.uuid4())]), 400)
def test_empty_members(self):
self.assertEqual(self.create([]), 400)
def test_blank_title(self):
self.assertEqual(self.create([self.alice["id"]], title=" "), 400)
def test_failed_create_leaves_no_chat(self):
_, before, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
self.create([self.alice["id"], self.bob["id"], str(uuid.uuid4())])
_, after, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
self.assertEqual(before, after)
if __name__ == "__main__":
unittest.main()
+144
View File
@@ -0,0 +1,144 @@
import datetime
import unittest
import uuid
from api import basic, call, login, new_user, user_body
class LoginTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.body = user_body()
_, cls.user, _ = call("POST", "/api/v1/users", cls.body)
def assert_basic_challenge(self, result):
status, body, headers = result
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertTrue(headers["WWW-Authenticate"].startswith("Basic "))
return body
def test_login(self):
status, session, _ = login(self.body["username"], self.body["password"])
self.assertEqual(status, 201)
self.assertEqual(set(session), {"token", "token_type", "expires_at", "user"})
self.assertEqual(session["token_type"], "Bearer")
self.assertEqual(session["user"], self.user)
self.assertGreaterEqual(len(session["token"]), 32)
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
self.assertTrue(300 <= left <= 3600 + 5, left)
def test_token_is_opaque_and_unique(self):
first = login(self.body["username"], self.body["password"])[1]["token"]
second = login(self.body["username"], self.body["password"])[1]["token"]
self.assertNotEqual(first, second)
for token in (first, second):
self.assertNotIn(self.user["id"], token)
self.assertNotIn(self.body["username"], token)
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": token})[0], 200)
def test_wrong_password_and_unknown_user_look_the_same(self):
wrong = self.assert_basic_challenge(login(self.body["username"], "wrong-password-123"))
unknown = self.assert_basic_challenge(login("nobody_" + uuid.uuid4().hex[:8], self.body["password"]))
self.assertEqual(wrong["error"]["message"], unknown["error"]["message"])
def test_malformed_credentials(self):
token = login(self.body["username"], self.body["password"])[1]["token"]
for header in (None, "Basic", "Basic !!!not-base64!!!", "Basic bm8tY29sb24=", "Bearer " + token, "Basic 0KU6"):
with self.subTest(header=header):
headers = {"Authorization": header} if header else {}
self.assert_basic_challenge(call("POST", "/api/v1/auth/sessions", headers=headers))
def test_garbage_after_basic_is_401_not_500(self):
# значение заголовка приходит на сервер как latin-1, поэтому после Basic может оказаться не ASCII
values = ("\u00e9", "\u00e9\u00e9\u00e9=", "\u00ff\u00fe", "//46cHc=", "=", "====", "a", " ", "A" * 5000, "Og==",
"dXNlcjpwYXNz dXNlcjpwYXNz")
for value in values:
with self.subTest(value=ascii(value[:16])):
result = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + value})
self.assert_basic_challenge(result)
def test_username_that_cannot_exist(self):
for username in ("", "Has Space", "ab\u0000cd", "имя_кириллицей"):
with self.subTest(username=username):
self.assert_basic_challenge(login(username, self.body["password"]))
def test_colon_and_unicode_in_password(self):
body = user_body(password="пароль:с:двоеточиями")
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
self.assertEqual(login(body["username"], body["password"])[0], 201)
self.assert_basic_challenge(login(body["username"], "пароль"))
class BearerTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice, cls.eve = new_user("alice"), new_user("eve")
def assert_bearer_challenge(self, result):
status, body, headers = result
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
def test_no_token(self):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me"))
def test_unknown_tokens(self):
for token in ("x" * 43, self.alice["id"], self.alice["username"], self.alice["token"][:-1]):
with self.subTest(token=token[:8]):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token}))
def test_garbage_token_is_401_not_500(self):
for token in ("\u00e9", "\u00ff\u00fe", "a b", "x" * 10000):
with self.subTest(token=ascii(token[:16])):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token}))
def test_basic_is_not_accepted_on_business_endpoints(self):
headers = basic(self.alice["username"], self.alice["password"])
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers=headers))
self.assert_bearer_challenge(call("GET", "/api/v1/chats", headers=headers))
def test_x_user_id_gives_no_access(self):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers={"X-User-Id": self.alice["id"]}))
def test_x_user_id_does_not_change_identity(self):
status, me, _ = call("GET", "/api/v1/users/me", user=self.alice, headers={"X-User-Id": self.eve["id"]})
self.assertEqual(status, 200)
self.assertEqual(me, self.alice["user"])
def test_token_is_checked_before_anything_else(self):
self.assert_bearer_challenge(call("GET", "/api/v1/chats/not-a-uuid"))
self.assert_bearer_challenge(call("GET", "/api/v1/chats?limit=0"))
self.assert_bearer_challenge(call("POST", "/api/v1/chats", {"title": 5}))
class LogoutTest(unittest.TestCase):
def test_logout_revokes_only_current_session(self):
user = new_user()
other_token = login(user["username"], user["password"])[1]["token"]
status, body, _ = call("DELETE", "/api/v1/auth/sessions/current", user=user)
self.assertEqual(status, 204)
self.assertIsNone(body)
self.assertEqual(call("GET", "/api/v1/users/me", user=user)[0], 401)
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user)[0], 401)
# вторая сессия того же пользователя продолжает работать
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": other_token})[0], 200)
def test_login_again_after_logout(self):
user = new_user()
call("DELETE", "/api/v1/auth/sessions/current", user=user)
status, session, _ = login(user["username"], user["password"])
self.assertEqual(status, 201)
self.assertNotEqual(session["token"], user["token"])
self.assertEqual(call("GET", "/api/v1/users/me", user=session)[0], 200)
def test_logout_requires_token(self):
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current")[0], 401)
if __name__ == "__main__":
unittest.main()
+63
View File
@@ -0,0 +1,63 @@
"""Проверка гонок: 10 клиентов параллельно отправляют 100 сообщений в один чат."""
import threading
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
from api import call, history, new_chat, new_user, send, user_body
CLIENTS = 10
MESSAGES_PER_CLIENT = 10
class ConcurrencyTest(unittest.TestCase):
def test_100_messages_from_10_clients(self):
users = [new_user("c%d" % number) for number in range(CLIENTS)]
chat = new_chat(users[0], *users[1:])
barrier = threading.Barrier(CLIENTS)
def client(number):
barrier.wait() # все потоки стартуют одновременно
results = []
for index in range(MESSAGES_PER_CLIENT):
results.append(send(users[number], chat, "клиент %d сообщение %d" % (number, index)))
return results
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
results = [result for chunk in pool.map(client, range(CLIENTS)) for result in chunk]
total = CLIENTS * MESSAGES_PER_CLIENT
self.assertEqual([status for status, _, _ in results], [201] * total)
confirmed = {message["id"]: message for _, message, _ in results}
self.assertEqual(len(confirmed), total)
items, _ = history(users[0], chat, limit=7)
self.assertEqual(len(items), total)
self.assertEqual(len({item["id"] for item in items}), total)
self.assertEqual(len({item["text"] for item in items}), total)
# каждое подтверждённое сообщение есть в истории без изменений
self.assertEqual({item["id"]: item for item in items}, confirmed)
keys = [(item["created_at"], item["id"]) for item in items]
self.assertEqual(keys, sorted(keys))
# сообщения одного клиента идут в том порядке, в котором он их отправлял
for number in range(CLIENTS):
own = [item["text"] for item in items if item["sender_id"] == users[number]["id"]]
self.assertEqual(own, ["клиент %d сообщение %d" % (number, index) for index in range(MESSAGES_PER_CLIENT)])
print("\nотправлено %d, подтверждено %d, в истории %d, уникальных id %d"
% (total, len(confirmed), len(items), len({item["id"] for item in items})))
def test_same_username_registered_once(self):
body = user_body(username="race_" + uuid.uuid4().hex[:8])
barrier = threading.Barrier(CLIENTS)
def register(_):
barrier.wait()
return call("POST", "/api/v1/users", body)[0]
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
statuses = sorted(pool.map(register, range(CLIENTS)))
self.assertEqual(statuses, [201] + [409] * (CLIENTS - 1))
if __name__ == "__main__":
unittest.main()
+145
View File
@@ -0,0 +1,145 @@
import base64
import json
import unittest
import urllib.parse
from api import call, history, new_chat, new_user, send
class MessagePaginationTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.user = new_user()
cls.chat = new_chat(cls.user)
cls.sent = [send(cls.user, cls.chat, "сообщение %d" % number)[1] for number in range(25)]
cls.path = "/api/v1/chats/" + cls.chat["id"] + "/messages"
def test_walk_several_pages(self):
items, sizes = history(self.user, self.chat, limit=10)
self.assertEqual(sizes, [10, 10, 5])
self.assertEqual(items, self.sent)
def test_no_duplicates_and_order(self):
items, _ = history(self.user, self.chat, limit=7)
ids = [item["id"] for item in items]
self.assertEqual(len(ids), len(set(ids)))
keys = [(item["created_at"], item["id"]) for item in items]
self.assertEqual(keys, sorted(keys))
def test_exact_page_has_no_cursor(self):
_, page, _ = call("GET", self.path + "?limit=25", user=self.user)
self.assertEqual(len(page["items"]), 25)
self.assertIsNone(page["next_cursor"])
def test_default_limit(self):
_, page, _ = call("GET", self.path, user=self.user)
self.assertEqual(len(page["items"]), 25)
def test_limit_can_change_between_pages(self):
_, first, _ = call("GET", self.path + "?limit=3", user=self.user)
cursor = urllib.parse.quote(first["next_cursor"], safe="")
_, second, _ = call("GET", self.path + "?limit=100&cursor=" + cursor, user=self.user)
self.assertEqual(first["items"] + second["items"], self.sent)
def test_bad_limit(self):
for limit in ("0", "101", "-1", "abc", "1.5", ""):
with self.subTest(limit=limit):
self.assertEqual(call("GET", self.path + "?limit=" + limit, user=self.user)[0], 400)
def test_bad_cursor(self):
for cursor in ("garbage", "", "e30=", "%D0%B9"):
with self.subTest(cursor=cursor):
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
def test_cursor_format_is_checked(self):
_, first, _ = call("GET", self.path + "?limit=3", user=self.user)
good = first["next_cursor"]
scope, created_at, item_id = json.loads(base64.urlsafe_b64decode(good))
def encode(value, **options):
return base64.urlsafe_b64encode(json.dumps(value, **options).encode()).decode()
# тест знает внутренний формат cursor: собранный заново правильный cursor совпадает с выданным
self.assertEqual(encode([scope, created_at, item_id]), good)
bad = {
"посторонний символ внутри base64": good[:5] + "!" + good[5:],
"пробел внутри base64": good[:5] + " " + good[5:],
"перевод строки в конце": good + "\n",
"лишний знак =": good + "=",
"обрезанный": good[:-4],
"время не в формате сервера": encode([scope, "вчера", item_id]),
"время без микросекунд": encode([scope, created_at[:19] + "Z", item_id]),
"время с неполными микросекундами": encode([scope, created_at[:21] + "Z", item_id]),
"время со смещением вместо Z": encode([scope, created_at[:-1] + "+00:00", item_id]),
"несуществующая дата": encode([scope, "2026-13-45T25:61:61.000000Z", item_id]),
"число вместо времени": encode([scope, 1234567890, item_id]),
"id не UUID": encode([scope, created_at, "abc"]),
"UUID в верхнем регистре": encode([scope, created_at, item_id.upper()]),
"UUID без дефисов": encode([scope, created_at, item_id.replace("-", "")]),
"null вместо id": encode([scope, created_at, None]),
"лишний элемент": encode([scope, created_at, item_id, "x"]),
"не хватает элемента": encode([scope, created_at]),
"объект вместо списка": encode({"scope": scope, "created_at": created_at, "id": item_id}),
"тот же JSON без пробелов": encode([scope, created_at, item_id], separators=(",", ":")),
"пустой список": encode([]),
}
for name, cursor in bad.items():
with self.subTest(name):
path = self.path + "?cursor=" + urllib.parse.quote(cursor, safe="")
status, body, _ = call("GET", path, user=self.user)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
# правильный cursor при этом продолжает работать
self.assertEqual(call("GET", self.path + "?cursor=" + urllib.parse.quote(good, safe=""), user=self.user)[0], 200)
def test_cursor_from_another_chat(self):
other = new_chat(self.user, title="Другой чат")
send(self.user, other, "раз")
send(self.user, other, "два")
_, page, _ = call("GET", "/api/v1/chats/" + other["id"] + "/messages?limit=1", user=self.user)
cursor = urllib.parse.quote(page["next_cursor"], safe="")
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
def test_new_message_appears_after_last_page(self):
user = new_user()
chat = new_chat(user)
send(user, chat, "раз")
send(user, chat, "два")
path = "/api/v1/chats/" + chat["id"] + "/messages"
_, first, _ = call("GET", path + "?limit=1", user=user)
_, created, _ = send(user, chat, "три")
cursor = urllib.parse.quote(first["next_cursor"], safe="")
_, rest, _ = call("GET", path + "?limit=100&cursor=" + cursor, user=user)
self.assertEqual([item["text"] for item in rest["items"]], ["два", "три"])
self.assertEqual(rest["items"][-1], created)
class ChatPaginationTest(unittest.TestCase):
def test_walk_chat_list(self):
user = new_user()
created = [new_chat(user, title="Чат %d" % number) for number in range(5)]
items, cursor = [], None
while True:
path = "/api/v1/chats?limit=2"
if cursor:
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
status, page, _ = call("GET", path, user=user)
self.assertEqual(status, 200)
self.assertLessEqual(len(page["items"]), 2)
items += page["items"]
cursor = page["next_cursor"]
if cursor is None:
break
self.assertEqual(items, created)
def test_chat_cursor_belongs_to_user(self):
alice, bob = new_user("alice"), new_user("bob")
for number in range(2):
new_chat(alice, bob, title="Общий %d" % number)
_, page, _ = call("GET", "/api/v1/chats?limit=1", user=alice)
cursor = urllib.parse.quote(page["next_cursor"], safe="")
self.assertEqual(call("GET", "/api/v1/chats?cursor=" + cursor, user=bob)[0], 400)
if __name__ == "__main__":
unittest.main()
+122
View File
@@ -0,0 +1,122 @@
import unittest
from api import call, login, new_chat, new_user, send, user_body
class ErrorFormatTest(unittest.TestCase):
def assert_error(self, result, status, code):
got_status, body, headers = result
self.assertEqual(got_status, status)
self.assertEqual(set(body), {"error"})
self.assertEqual(set(body["error"]), {"code", "message", "request_id"})
self.assertEqual(body["error"]["code"], code)
self.assertTrue(body["error"]["message"])
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
class InvalidJsonTest(ErrorFormatTest):
def test_malformed_json(self):
self.assert_error(call("POST", "/api/v1/users", raw=b'{"username": "abc", '), 400, "invalid_request")
def test_not_an_object(self):
self.assert_error(call("POST", "/api/v1/users", raw=b'["abc"]'), 400, "invalid_request")
def test_extra_field(self):
self.assert_error(call("POST", "/api/v1/users", user_body(is_admin=True)), 400, "invalid_request")
def test_wrong_type(self):
self.assert_error(call("POST", "/api/v1/users", user_body(username=12345)), 400, "invalid_request")
def test_missing_field(self):
body = user_body()
del body["password"]
self.assert_error(call("POST", "/api/v1/users", body), 400, "invalid_request")
def test_malformed_json_in_message(self):
user = new_user()
chat = new_chat(user)
path = "/api/v1/chats/" + chat["id"] + "/messages"
self.assert_error(call("POST", path, raw=b"{text: no quotes}", user=user), 400, "invalid_request")
class UserValidationTest(ErrorFormatTest):
def test_bad_usernames(self):
for username in ("ab", "a" * 33, "Alice", "with space", "имя", "abc\n", ""):
with self.subTest(username=username):
self.assert_error(call("POST", "/api/v1/users", user_body(username=username)), 400, "invalid_request")
def test_bad_display_names(self):
for display_name in ("", " ", "\t\n", "я" * 101, "имя\u0000"):
with self.subTest(display_name=display_name):
result = call("POST", "/api/v1/users", user_body(display_name=display_name))
self.assert_error(result, 400, "invalid_request")
def test_display_name_length_is_counted_in_code_points(self):
# 100 эмодзи это 400 байт в UTF-8, но ровно 100 code points
status, user, _ = call("POST", "/api/v1/users", user_body(display_name="🙂" * 100))
self.assertEqual(status, 201)
self.assertEqual(user["display_name"], "🙂" * 100)
def test_bad_passwords(self):
for password in ("short-11-ch", "x" * 129, " " * 12, "", 123456789012, None):
with self.subTest(password=password):
self.assert_error(call("POST", "/api/v1/users", user_body(password=password)), 400, "invalid_request")
def test_password_length_limits(self):
for password in ("exactly-12-c", "x" * 128, "пароль🙂пароль"):
with self.subTest(length=len(password)):
body = user_body(password=password)
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
self.assertEqual(login(body["username"], password)[0], 201)
def test_password_is_never_returned(self):
body = user_body()
status, user, _ = call("POST", "/api/v1/users", body)
self.assertEqual(status, 201)
self.assertEqual(set(user), {"id", "username", "display_name", "created_at"})
_, session, _ = login(body["username"], body["password"])
self.assertNotIn(body["password"], str(session))
def test_duplicate_username(self):
body = user_body(display_name="Первый")
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
body["display_name"] = "Второй"
self.assert_error(call("POST", "/api/v1/users", body), 409, "conflict")
class MessageValidationTest(ErrorFormatTest):
@classmethod
def setUpClass(cls):
cls.user = new_user()
cls.chat = new_chat(cls.user)
def test_empty_message(self):
self.assert_error(send(self.user, self.chat, ""), 400, "invalid_request")
def test_whitespace_message(self):
for text in (" ", " \n\t ", "  "):
with self.subTest(text=repr(text)):
self.assert_error(send(self.user, self.chat, text), 400, "invalid_request")
def test_nul_character(self):
self.assert_error(send(self.user, self.chat, "до\u0000после"), 400, "invalid_request")
def test_text_limit(self):
self.assertEqual(send(self.user, self.chat, "ы" * 4000)[0], 201)
self.assert_error(send(self.user, self.chat, "ы" * 4001), 400, "invalid_request")
def test_sender_id_is_not_accepted(self):
path = "/api/v1/chats/" + self.chat["id"] + "/messages"
body = {"text": "привет", "sender_id": self.user["id"]}
self.assert_error(call("POST", path, body, user=self.user), 400, "invalid_request")
def test_unicode_is_kept(self):
text = "Привет 👋 你好 مرحبا\nвторая строка"
status, message, _ = send(self.user, self.chat, text)
self.assertEqual(status, 201)
self.assertEqual(message["text"], text)
self.assertEqual(message["sender_id"], self.user["id"])
if __name__ == "__main__":
unittest.main()