Author SHA1 Message Date
k00kza 6aa9bd6a06 Обновить REPORT.md 2026-10-23 14:40:35 +03:00
k00kza 469dd51e2a Обновить REPORT.md 2026-10-23 14:23:19 +03:00
k00kzaAntonovaIra 840907cf2b solution 2026-10-23 14:09:32 +03:00
79 changed files with 6658 additions and 21 deletions
+36
View File
@@ -0,0 +1,36 @@
FROM python:3.12.8-slim-bookworm AS base
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1 \
PIP_ROOT_USER_ACTION=ignore \
APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_ENV=lab
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app
WORKDIR /srv
COPY requirements.txt ./
RUN pip install -r requirements.txt
COPY app ./app
FROM base AS test
COPY requirements-test.txt ./
RUN pip install -r requirements-test.txt
COPY pytest.ini ./
COPY student-tests ./student-tests
USER app
CMD ["python", "-m", "pytest", "-v", "--no-header"]
FROM base AS runtime
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-m", "app.healthcheck"]
STOPSIGNAL SIGTERM
CMD ["python", "-m", "app"]
+44
View File
@@ -0,0 +1,44 @@
# EVIDENCE — как собраны доказательства
Все файлы `evidence/` пересобираются одной командой из корня проекта (нужны Docker и `python3` на хосте, venv не нужен):
```sh
docker compose --env-file .env up -d --build
scripts/collect_evidence.sh # все пункты
scripts/collect_evidence.sh 14 15 # отдельные пункты
```
Каждый файл, кроме 13 и 14, пишет `scripts/run_and_save.py`: дата, commit, команда, вывод, код возврата и время. Файлы 13 и 14 — листинги сценариев, которые сами выполняют команды и проверки. Их последняя строка — `ИТОГ: PASS` или `ИТОГ: FAIL`. Данные синтетические; тома не удаляются.
| № | Что доказывает | Команда (из `scripts/collect_evidence.sh`) | Файл |
| --- | --- | --- | --- |
| 01 | Структура контракта | `make check` | `01_check_contract.txt` |
| 02 | Публичный smoke | `make test` | `02_smoke.txt` |
| 03 | Контейнеры и том **до** рестарта | `docker compose ps`, `docker volume inspect mtusi-messenger_pgdata` | `03_ps_before.txt`, `03_volume_before.txt` |
| 04 | Данные и прежний токен после рестарта API, Redis и PostgreSQL | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `04_persistence.txt` |
| 05 | Контейнеры и том **после** (Up сброшен, том тот же) | как 03 | `05_ps_after.txt`, `05_volume_after.txt` |
| 06 | PK, FK, UNIQUE, CHECK, индексы | `psql -c '\d users' … '\d sessions'` в контейнере `db` | `06_schema.txt` |
| 07 | Миграции с нуля и повторно | `docker compose logs api` первого старта на пустом томе; `python -m app.migrate`; `SELECT * FROM schema_migrations` | `07_migrations_first.txt`, `07_migrations.txt`, `07_migrations_table.txt` |
| 08 | Пароль — scrypt, токен — только SHA-256 | `SELECT left(password_hash,7) …`, `SELECT length(token_hash) …` | `08_hashes.txt` |
| 09 | Basic/Bearer, expiry, logout, `X-User-Id` | pytest в контейнере `tests`: `test_auth.py test_session_expiry.py` | `09_auth_tests.txt` |
| 10 | Атомарность, rollback, пул, гонка username, отказ БД | pytest: `test_database.py test_db_failure.py test_transactions.py test_duplicate_username.py` | `10_database_tests.txt` |
| 11 | Все собственные тесты (`153 passed`) | `docker compose --profile test run --rm tests` (= `make test-student`) | `11_all_tests.txt` |
| 12 | Секреты не в Git | `git check-ignore -v .env`; `git ls-files --cached --others --exclude-standard`; `grep -n -i 'password\|secret' compose.yaml` | `12_git_secrets.txt`, `12_git_files.txt`, `12_compose_no_secrets.txt` |
| 13 | Данные переживают `down` → `up -d` | `python3 scripts/storage_demo.py` | `13_storage.txt` |
| 14 | Роль Redis, инвалидация, рестарт/остановка Redis, остановка PostgreSQL | `python3 scripts/dependency_demo.py` | `14_dependencies.txt` |
| 15 | EXPLAIN (ANALYZE, BUFFERS) истории на 60 000 сообщений; автотест плана на 10 000 | `docker compose exec -T api python -m app.explain`; pytest `test_explain.py` | `15_explain.txt`, `15_explain_tests.txt` |
| 16 | Expiry на живом стенде (TTL 3 с), logout, неверный пароль | `docker compose --profile expiry up -d api-ttl`; `python3 scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3` | `16_expiry_live.txt` |
Пункт 07 «с нуля» снимается только на пустом томе: `docker compose --env-file .env down -v` (**удаляет учебные данные**), затем `up -d --build` и `python3 scripts/run_and_save.py evidence/07_migrations_first.txt -- docker compose --env-file .env logs api`.
## Что смотреть в файлах
- **03/05**: у `api`, `db`, `redis` в 05 время `Up` — секунды; дата создания тома в 03 и 05 одна и та же.
- **14**: «Чтений индекса sessions_pkey в PostgreSQL за 50 запросов: 0» и `keyspace_hits=49`; значение ключа после logout — `revoked`; при остановленном Redis все операции 2xx, а аноним получает 401; при остановленной БД — 503 и `/health/live` 200; в логе API — `cache_unavailable` и `cache: FLUSHDB after a lost revocation`.
- **15**: у запроса приложения `Index Scan using messages_chat_created_idx`, `rows=51`, `shared hit=6` на первой и глубокой странице; у OFFSET и варианта без индекса — `Seq Scan` и `Sort`.
## Проверка перед сдачей
- В `evidence/` нет паролей и токенов: `grep -l "$(sed -n 's/^POSTGRES_PASSWORD=//p' .env)" evidence/*` ничего не находит. Ключи Redis в 14 маскируются как `session:<sha256 токена>`.
- `11_all_tests.txt` заканчивается строкой `153 passed`, а `13_storage.txt` и `14_dependencies.txt` — строкой `ИТОГ: PASS`.
- `evidence/` указан в `.dockerignore` и в образ не попадает.
+65
View File
@@ -0,0 +1,65 @@
# GUIDE — запуск и тесты
Нужно: Docker с Compose v2 и Git. Для публичных проверок (`tests/`, `scripts/*.py`) — `python3` 3.9+ на хосте: они используют только стандартную библиотеку. Виртуальное окружение не нужно: API и собственные pytest-тесты собираются и работают в контейнерах. Команды выполняются из корня проекта. Для Windows (cmd) замените `cp` на `copy`, а `scripts/restart.sh` на `scripts\restart.bat`.
## 1. Поднять стенд
```sh
cp env.lab2.template .env # затем смените POSTGRES_PASSWORD (латиница и цифры)
docker compose --env-file .env up -d --build
docker compose --env-file .env ps # db, redis, api — healthy
curl http://localhost:8080/health/ready # {"status":"ok"}
```
- Миграции применяются сами при старте API.
- API: `http://localhost:8080`. PostgreSQL для отладки: `127.0.0.1:5433`. Redis наружу не опубликован: `docker compose --env-file .env exec redis redis-cli`.
- Если `api` перезапускается, смотрите `docker compose --env-file .env logs api`.
Остановить с сохранением данных: `docker compose --env-file .env stop`. Удалить вместе с данными: `docker compose --env-file .env down -v`.
## 2. Проверки
| Команда | Что проверяет |
| --- | --- |
| `make check` | Структура репозитория и контракта (офлайн) |
| `make test` | Публичный сквозной smoke по живому API |
| `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Рестарт API, Redis и PostgreSQL: данные и **прежний токен** живы |
| `make test-student` | Все собственные тесты (153) в контейнере `tests` |
| `make explain` | EXPLAIN (ANALYZE, BUFFERS) истории на 60 000 синтетических сообщений |
| `python3 scripts/dependency_demo.py` | Роль Redis; остановка Redis и PostgreSQL (листинг в `evidence/14_dependencies.txt`) |
| `python3 scripts/storage_demo.py` | `down` → `up -d`, те же данные старыми токенами |
| `docker compose --env-file .env --profile expiry up -d api-ttl` и `python3 scripts/check_expiry.py` | Expiry на живом экземпляре с `SESSION_TTL_SECONDS=3` (порт 8081) |
| `scripts/collect_evidence.sh` | Всё сразу, с сохранением в `evidence/` (см. `EVIDENCE.md`) |
Собственные тесты работают с **отдельной** БД `messenger_test` на том же PostgreSQL и с Redis DB 15, поэтому рабочие данные `messenger` не затрагиваются. Один файл или один тест:
```sh
docker compose --env-file .env --profile test run --rm tests python -m pytest -v student-tests/test_cache.py
docker compose --env-file .env --profile test run --rm tests python -m pytest -v -k redis_down
```
После изменения тестов или кода пересоберите образ: `make test-student` делает `--build` сам.
### Что проверяет каждый файл `student-tests/`
| Файл | За что отвечает |
| --- | --- |
| `test_auth.py` | Регистрация с паролем; Basic только на входе; Bearer на остальном; одинаковый 401 + `WWW-Authenticate` для неверного пароля и несуществующего логина; logout и повтор = 401; `X-User-Id` не даёт доступ |
| `test_session_expiry.py` | TTL 1 с и TTL 2 с из `SESSION_TTL_SECONDS` → 401; очистка истёкших сессий при входе |
| `test_cache.py` | Redis: попадания и TTL ключа, в кэше нет токенов и паролей, logout → `revoked`, `SET NX` против гонки, FLUSHDB без потерь, кэш не продлевает сессию, граница устаревания, Redis недоступен → обход и 401 для анонимов, FLUSHDB «грязного» кэша после восстановления |
| `test_db_failure.py` | БД недоступна → 503, live 200, ready 503, аноним не пропускается (с кэшем и без) |
| `test_transactions.py` | Сбой посреди создания чата → ROLLBACK; пул ограничен настройками; занятый пул → быстрый 503 |
| `test_explain.py` | План запроса истории на 10 000 сообщениях: Index Scan, нет Seq Scan и Sort |
| `test_database.py` | Что реально лежит в БД: `scrypt$…`, хеш токена, PK/FK/UNIQUE/CHECK, повторные миграции, атомарность чата |
| `test_duplicate_username.py` | 409 и гонка 10 одновременных регистраций → ровно один 201 |
| `test_invalid_json.py`, `test_empty_message.py`, `test_foreign_chat.py`, `test_pagination.py`, `test_concurrency.py`, `test_contract_basics.py` | Валидация, ACL (404 для чужого), keyset-курсор, параллельная запись, общий формат ошибок, отсутствие секретов в логах |
## 3. Запуск без Docker (только для отладки)
Нужны свои PostgreSQL и Redis (необязательно) и установленные `requirements.txt`.
```sh
DATABASE_URL=postgresql+asyncpg://messenger:ПАРОЛЬ@127.0.0.1:5433/messenger CACHE_URL= python -m app
```
Адрес БД обязан начинаться с `postgresql+asyncpg://`. Пустой `CACHE_URL` выключает кэш.
+15 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
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 up test-student explain evidence
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -24,3 +24,17 @@ 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)
COMPOSE = docker compose --env-file .env
up:
$(COMPOSE) up -d --build
test-student:
$(COMPOSE) --profile test run --rm --build tests
explain:
$(COMPOSE) exec -T api python -m app.explain
evidence:
scripts/collect_evidence.sh
+83
View File
@@ -0,0 +1,83 @@
# OPERATIONS — эксплуатация кратко
Формат: **что — как — для чего**.
## Стенд
| Что | Как | Для чего |
| --- | --- | --- |
| Три сервиса: `db` (PostgreSQL 16.6), `redis` (Redis 7.4.1, кэш сессий), `api` | `docker compose --env-file .env up -d --build` | Один запуск воспроизводит весь стенд |
| Профили: `test` (контейнер с pytest), `expiry` (`api-ttl` с TTL 3 с на 8081) | `--profile test run --rm tests`, `--profile expiry up -d api-ttl` | Тесты и проверка expiry без venv на хосте |
| Версии закреплены (`python:3.12.8`, `postgres:16.6`, `redis:7.4.1`, пакеты с транзитивными) | `Dockerfile`, `compose.yaml`, `requirements*.txt` | Сборка через год даёт то же самое, а не «latest» |
| API стартует после healthy `db`; Redis не обязателен | `depends_on` + повторные попытки подключения к БД в коде | Холодный старт не падает; без Redis API работает |
| API работает не от root | `USER app` в `Dockerfile` | Взлом приложения не даёт прав root в контейнере |
## Запуск, остановка, рестарт
| Действие | Команда | Что происходит с данными |
| --- | --- | --- |
| Запуск | `docker compose --env-file .env up -d --build` | Том `pgdata` создаётся при первом запуске |
| Остановка | `docker compose --env-file .env stop` | Данные остаются; кэш Redis пропадает (это нормально) |
| Рестарт API, Redis и БД | `scripts/restart.sh` (Windows: `scripts\restart.bat`), stop+start | Данные и сессии остаются; хук для `make test-persistence` |
| Пересборка API | `docker compose --env-file .env up -d --build api` | Данные остаются |
| **Удаление данных** | `docker compose --env-file .env down -v` | Том `pgdata` удалён, всё пропадает |
## Миграции
- Файлы `app/migrations/NNNN_*.sql` применяются по порядку при старте API; применённые записываются в `schema_migrations`.
- Повторный запуск ничего не делает. `pg_advisory_lock` гарантирует, что миграции выполняет один экземпляр.
- Вручную: `docker compose --env-file .env exec api python -m app.migrate`.
- Изменение схемы — **новый** файл `0002_*.sql`, старые файлы не редактируются.
## Redis (кэш сессий)
| Что | Как | Для чего |
| --- | --- | --- |
| Ключ | `session:<SHA-256 токена>` → JSON пользователя | Проверка Bearer без запроса к PostgreSQL |
| TTL | `min(CACHE_TTL_SECONDS=60, остаток сессии по часам БД)` | Кэш не продлевает сессию |
| Logout | DELETE в PostgreSQL, затем `revoked` в Redis; заполнение — `SET NX` | Отозванный токен не возвращается из кэша |
| Persistence | выключена (`--save ""`, `--appendonly no`) | Источник истины — PostgreSQL, кэш одноразовый |
| Память | `maxmemory 64mb`, `noeviction` | Отметки отзыва не вытесняются |
| Посмотреть | `docker compose --env-file .env exec redis redis-cli --scan --pattern 'session:*'`, `INFO stats` | Диагностика попаданий и промахов |
| Сбросить | `docker compose --env-file .env exec redis redis-cli FLUSHDB` | Безопасно: следующий запрос заполнит кэш из БД |
## Секреты
| Что | Где | Для чего |
| --- | --- | --- |
| Пароль БД | локальный `.env` (в `.gitignore`), в образ не зашит | Секрет не попадает в Git и в образ |
| Шаблон | `env.lab2.template` (без реального пароля) | Оператор знает, какие значения задать |
| Пароли пользователей | в БД только scrypt с солью | Утечка БД не раскрывает пароли |
| Токены сессий | у клиента — токен; в БД и Redis — SHA-256 | Утечка БД или Redis не даёт войти |
| Логи | без тел запросов, паролей, токенов, текста сообщений | Логи можно показывать и хранить |
| Известные ограничения | пароль БД виден в `docker inspect api`; Redis без пароля (только внутренняя сеть) | Учебный стенд; код умеет `DATABASE_URL_FILE` и `CACHE_URL_FILE` |
## Здоровье
| Адрес | Значение | Для чего |
| --- | --- | --- |
| `/health/live` | Процесс жив, зависимости не проверяются | Оркестратор не убивает API из-за временного сбоя БД |
| `/health/ready` | Миграции применены и PostgreSQL отвечает на `SELECT 1`: 200 или 503. Redis не учитывается | Трафик не идёт туда, где обязательный путь не работает |
| `HEALTHCHECK` образа | вызывает `/health/ready` | `docker compose ps` показывает `healthy` |
| `pg_isready`, `redis-cli ping` | healthcheck `db` и `redis` | От `db` зависит старт API |
## Поведение при сбоях
| Сбой | Ответ | Для чего |
| --- | --- | --- |
| Redis недоступен | Проверка токена идёт в PostgreSQL; таймаут 300 мс, затем кэш пропускается 5 с; ready 200 | Кэш не превращается в точку отказа |
| Logout во время сбоя Redis | 204; кэш помечен «грязным» → FLUSHDB при восстановлении | Отозванный токен не оживает из старой записи |
| БД недоступна | `503 unavailable` без деталей; live 200, ready 503 | Клиент понимает «временно», SQL и адреса не утекают |
| Не удалось проверить токен | `503`, запрос не пропускается | Сбой не превращает запрос в анонимно-доверенный |
| Нет свободного соединения в пуле | `503` через `DB_POOL_TIMEOUT` | Запросы не копятся при перегрузке |
| Неожиданная ошибка | `500 internal_error`, детали только в логе | Клиенту ничего лишнего, оператору — `request_id` |
| Рестарт БД | Данные живы (том), пул пересоздаёт соединения (`pool_pre_ping`) | Восстановление без рестарта API |
| SIGTERM (`docker stop`) | Корректное завершение: закрываются пул БД и Redis | Транзакции не обрываются |
## Логи
`docker compose --env-file .env logs -f api`. Строка запроса: `request request_id=… method=… path=… status=… duration_ms=…`. Сбои кэша: `cache_unavailable type=…` и `cache: FLUSHDB after a lost revocation`. По `request_id` (он же в `X-Request-Id` и в теле ошибки) запрос клиента находится в логе. Уровень логов задаёт `LOG_LEVEL`.
## Конфигурация (`.env` → compose)
`POSTGRES_USER/PASSWORD/DB` — учётка БД; `SESSION_TTL_SECONDS` — срок сессии (для persistence-теста ≥ 300); `SESSION_STORE=postgres`; `DB_POOL_SIZE`, `DB_MAX_OVERFLOW`, `DB_POOL_TIMEOUT` — пул; `CACHE_URL` (пусто — кэш выключен), `CACHE_TTL_SECONDS`, `CACHE_TIMEOUT_MS`, `CACHE_RETRY_SECONDS` — кэш; `LOG_LEVEL`, `APP_ENV`. Всё задаётся окружением, поэтому один образ работает на любом стенде без пересборки.
+60 -20
View File
@@ -1,37 +1,77 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Антонова Ирина Андреевна БПИ2301
- Целевая оценка: 4
- Commit/PR: 840907cf2bdaafa91543a3fbf964b18e34d9c851
- Использованные источники, библиотеки и помощь ИИ: FastAPI, SQLAlchemy (async) + asyncpg, Pydantic, uvicorn, redis-py, pytest, httpx; при написании кода использовался ИИ-ассистент (Claude).
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker с Compose v2 и Python 3.9+ (только для публичных скриптов `tests/`). Образы: `python:3.12.8-slim-bookworm`, `postgres:16.6-bookworm`, `redis:7.4.1-bookworm`; зависимости закреплены в `requirements.txt`.
```sh
cp env.lab2.template .env # задать свой POSTGRES_PASSWORD
docker compose --env-file .env up -d --build # миграции применяются при старте API
curl http://localhost:8080/health/ready # ждать {"status":"ok"}
python tests/smoke.py --base-url "http://localhost:8080" # публичный smoke
$env:ACTION_SCRIPT="scripts/restart.sh"
python tests/resilience.py --mode persistence --action-script "$env:ACTION_SCRIPT" --base-url "http://localhost:8080"
docker compose --env-file .env --profile test run --rm --build tests # собственные тесты в контейнере
```
- Остановка с сохранением данных: `docker compose --env-file .env stop`.
- Удаление учебных данных: `docker compose --env-file .env down -v`.
- `.env` не попадает в Git; в `compose.yaml` пароли только подставляются из `.env`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
Клиент → API (FastAPI) → PostgreSQL (том pgdata) — источник истины
↘ Redis — кэш проверки сессий
```
| Что появилось | Как сделано |
| --- | --- |
| Хранение данных | Пользователи, чаты, участники, сообщения и сессии в PostgreSQL; версионируемые миграции `app/migrations/` |
| Регистрация с паролем | Пароль 12–128 символов, хранится хеш scrypt с солью |
| Вход | `POST /auth/sessions` только по Basic, выдаёт случайный токен (256 бит) |
| Доступ | Все остальные эндпоинты только по Bearer; `X-User-Id` игнорируется |
| Срок жизни и выход | `SESSION_TTL_SECONDS`, срок считает БД; `DELETE /auth/sessions/current` отзывает токен |
| Кэш сессий | Redis хранит проверенные сессии с TTL не больше остатка сессии; при logout ставится отметка отзыва |
| Отказ Redis | Запросы проверяются через PostgreSQL, API продолжает работать |
| Отказ БД | `503` без деталей, `/health/live` 200, `/health/ready` 503 |
| Атомарность | Чат и участники создаются в одной транзакции |
| Пагинация истории | Keyset-курсор по `(created_at, id)` и индекс `messages(chat_id, created_at, id)` |
| Пул и таймауты | Пул 5+5 соединений, ожидание 5 с; таймаут Redis 300 мс |
Транзакция — одна HTTP-операция; ответ 201 уходит после COMMIT. Уникальность username и целостность ссылок обеспечивают ограничения БД (UNIQUE, FK, CHECK).
Переменные `.env.example`: `SESSION_TTL_SECONDS` — срок сессии; `SESSION_STORE=postgres` — где хранятся сессии; `DATABASE_URL_FILE` / `CACHE_URL_FILE` (или `DATABASE_URL` / `CACHE_URL`) — адреса PostgreSQL и Redis; `APP_HOST`, `APP_PORT`, `APP_ENV` — параметры сервера.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` | `PASS` | `evidence/02_smoke.txt` |
| Данные и сессии переживают рестарт API, БД и Redis | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` + `docker compose ps` до/после | `PASS`; контейнеры перезапущены, том тот же | `evidence/03_*`, `04_persistence.txt`, `05_*` |
| Данные переживают пересоздание контейнеров | `python scripts/storage_demo.py` | `ИТОГ: PASS` | `evidence/13_storage.txt` |
| Таблицы, ключи, индексы | `psql \d` | PK, FK, UNIQUE(username), CHECK, индексы | `evidence/06_schema.txt` |
| Миграции с нуля и повторно | лог первого старта, `python -m app.migrate` | `0001_init.sql`, затем «ничего нового» | `evidence/07_*` |
| Пароль — KDF, токен — хеш | `SELECT` из `users` и `sessions` | `scrypt$…`, хеш токена 64 символа | `evidence/08_hashes.txt` |
| Basic/Bearer, срок сессии, logout, неверный пароль | pytest `test_auth.py`, `test_session_expiry.py` | `38 passed` | `evidence/09_auth_tests.txt` |
| Атомарность, rollback, гонка username, пул | pytest `test_database.py`, `test_transactions.py`, `test_duplicate_username.py`, `test_db_failure.py` | `19 passed` | `evidence/10_database_tests.txt` |
| Все собственные тесты | `make test-student` | `153 passed` | `evidence/11_all_tests.txt` |
| Секреты не в Git | `git check-ignore -v .env` | `.env` игнорируется | `evidence/12_*` |
| Redis используется для сессий | `python scripts/dependency_demo.py` | 50 запросов: 0 обращений к PostgreSQL за сессией, 49 попаданий в кэш | `evidence/14_dependencies.txt` |
| Отказ Redis и БД | там же | без Redis всё работает; без БД — 503, аноним — 401 | `evidence/14_dependencies.txt` |
| Индекс истории, EXPLAIN на ≥10 000 сообщений | `make explain` | Index Scan, 51 строка на любой странице; без индекса — Seq Scan | `evidence/15_explain.txt` |
| Expiry при коротком TTL | `api-ttl` с TTL 3 с + `scripts/check_expiry.py` | через TTL токен даёт 401 | `evidence/16_expiry_live.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Все файлы пересобираются командой `scripts/collect_evidence.sh`.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один экземпляр API, PostgreSQL и Redis без репликации и бэкапов.
- Redis без пароля, доступен только внутри сети compose; HTTP без TLS.
- Если logout пришёлся на сбой Redis, кэш очищается только в этом экземпляре API.
- scrypt вместо Argon2id.
+1
View File
@@ -0,0 +1 @@
"""Мессенджер: HTTP API на FastAPI с PostgreSQL и кэшем сессий в Redis."""
+46
View File
@@ -0,0 +1,46 @@
"""Точка входа: python -m app запускает HTTP-сервер."""
import signal
import sys
import uvicorn
from .config import Settings
from .logging_setup import get_logger
from .main import create_app
def _exit_quietly(signum, frame):
"""Завершить процесс с кодом 0 по SIGTERM."""
raise SystemExit(0)
def main() -> int:
"""Прочитать настройки и запустить uvicorn; вернуть код выхода."""
try:
settings = Settings.from_env()
except ValueError as error:
print("Ошибка настроек:", error, file=sys.stderr)
return 2
signal.signal(signal.SIGTERM, _exit_quietly)
app = create_app(settings)
get_logger().info("listen host=%s port=%d", settings.host, settings.port)
config = uvicorn.Config(
app,
host=settings.host,
port=settings.port,
log_level=settings.log_level.lower(),
access_log=False,
timeout_graceful_shutdown=5,
)
server = uvicorn.Server(config)
if sys.platform == "win32":
signal.signal(
signal.SIGBREAK, lambda signum, frame: setattr(server, "should_exit", True)
)
server.run()
return 0
if __name__ == "__main__":
sys.exit(main())
+102
View File
@@ -0,0 +1,102 @@
"""Аутентификация: разбор Authorization (Basic и Bearer) и определение пользователя."""
import base64
import binascii
import re
import uuid
from datetime import datetime
from typing import AsyncIterator, Tuple
from fastapi import Depends, Request
from sqlalchemy.ext.asyncio import AsyncSession
from . import crud
from .errors import ApiError
from .models import User
from .security import hash_token
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
TOKEN_RE = re.compile(r"[A-Za-z0-9_-]{20,200}")
def unauthorized(challenge: str) -> ApiError:
"""Ошибка 401 с заголовком WWW-Authenticate и одинаковым текстом."""
return ApiError(
401, "unauthorized", "Нет действительной аутентификации", {"WWW-Authenticate": challenge}
)
async def get_session(request: Request) -> AsyncIterator[AsyncSession]:
"""Зависимость FastAPI: сессия БД на время запроса."""
async with request.app.state.sessionmaker() as session:
yield session
def parse_basic(request: Request) -> Tuple[str, str]:
"""Вернуть (username, password) из Basic; при любой ошибке формата 401."""
header = request.headers.get("authorization", "")
scheme, _, encoded = header.partition(" ")
if scheme.lower() != "basic" or not encoded.strip():
raise unauthorized(BASIC_CHALLENGE)
try:
raw = base64.b64decode(encoded.strip(), validate=True)
username_bytes, separator, password_bytes = raw.partition(b":")
if not separator:
raise ValueError("нет двоеточия")
return username_bytes.decode("ascii"), password_bytes.decode("utf-8")
except (binascii.Error, ValueError):
raise unauthorized(BASIC_CHALLENGE)
def parse_bearer(request: Request) -> str:
"""Вернуть токен из Bearer; при неверной схеме или формате 401."""
header = request.headers.get("authorization", "")
scheme, _, token = header.partition(" ")
token = token.strip()
if scheme.lower() != "bearer" or not TOKEN_RE.fullmatch(token):
raise unauthorized(BEARER_CHALLENGE)
return token
def cached_user(data: dict) -> User:
"""Собрать User из данных кэша (без привязки к сессии БД)."""
return User(
id=uuid.UUID(data["id"]),
username=data["username"],
display_name=data["display_name"],
password_hash="",
created_at=datetime.fromisoformat(data["created_at"]),
)
async def current_user(
request: Request, session: AsyncSession = Depends(get_session)
) -> User:
"""Зависимость FastAPI: пользователь по Bearer-токену.
Сначала кэш, при промахе или недоступном Redis -- PostgreSQL.
Ошибка БД превращается в 503, неизвестный токен -- в 401.
"""
token_hash = hash_token(parse_bearer(request))
cache = request.app.state.cache
data = await cache.get(token_hash)
if data is not None:
if data.get("revoked"):
raise unauthorized(BEARER_CHALLENGE)
return cached_user(data)
found = await crud.get_user_by_token(session, token_hash)
if found is None:
raise unauthorized(BEARER_CHALLENGE)
user, remaining_seconds = found
await cache.put(
token_hash,
{
"id": str(user.id),
"username": user.username,
"display_name": user.display_name,
"created_at": user.created_at.isoformat(),
},
remaining_seconds,
)
return user
+146
View File
@@ -0,0 +1,146 @@
"""Read-through кэш сессий в Redis; источник истины -- таблица sessions.
Ключ session:<sha256 токена>, TTL не больше остатка сессии. Заполнение
через SET NX, logout записывает отметку отзыва. При недоступном Redis
запросы идут в PostgreSQL; потерянная отметка отзыва ведёт к FLUSHDB
перед следующим использованием кэша.
"""
import asyncio
import json
import time
from typing import Awaitable, Callable, Dict, Optional, TypeVar
from redis.asyncio import Redis
from redis.exceptions import RedisError
from .logging_setup import get_logger
KEY_PREFIX = "session:"
REVOKED = "revoked"
CACHE_ERRORS = (RedisError, OSError, asyncio.TimeoutError)
T = TypeVar("T")
class SessionCache:
"""Кэш сессий поверх Redis; ошибки Redis не выходят наружу."""
enabled = True
def __init__(self, url: str, ttl_cap: int, timeout_ms: int, retry_seconds: int):
"""Создать клиент Redis с таймаутами; соединение открывается лениво."""
timeout = timeout_ms / 1000
self.client = Redis.from_url(
url,
socket_timeout=timeout,
socket_connect_timeout=timeout,
retry_on_timeout=False,
decode_responses=True,
)
self.ttl_cap = ttl_cap
self.timeout = timeout
self.retry_seconds = retry_seconds
self.down_until = 0.0
self.dirty = False
self.stats: Dict[str, int] = {
"hits": 0, "misses": 0, "revoked_hits": 0, "errors": 0, "bypassed": 0
}
async def _call(self, operation: Callable[[], Awaitable[T]]) -> T:
"""Выполнить операцию с таймаутом, паузой после сбоя и очисткой грязного кэша."""
if time.monotonic() < self.down_until:
self.stats["bypassed"] += 1
raise ConnectionError("cache is paused after a failure")
try:
if self.dirty:
await asyncio.wait_for(self.client.flushdb(), self.timeout * 2)
self.dirty = False
get_logger().warning("cache: FLUSHDB after a lost revocation")
return await asyncio.wait_for(operation(), self.timeout * 2)
except CACHE_ERRORS as error:
self.stats["errors"] += 1
self.down_until = time.monotonic() + self.retry_seconds
get_logger().warning("cache_unavailable type=%s", type(error).__name__)
raise
async def get(self, token_hash: str) -> Optional[dict]:
"""Данные пользователя, {"revoked": True} или None при промахе и сбое."""
try:
raw = await self._call(lambda: self.client.get(KEY_PREFIX + token_hash))
except CACHE_ERRORS:
return None
if raw is None:
self.stats["misses"] += 1
return None
if raw == REVOKED:
self.stats["revoked_hits"] += 1
return {"revoked": True}
self.stats["hits"] += 1
return json.loads(raw)
async def put(self, token_hash: str, user: dict, remaining_seconds: float) -> None:
"""Сохранить сессию с TTL не больше её остатка, не затирая существующий ключ."""
ttl_ms = int(min(self.ttl_cap, remaining_seconds) * 1000)
if ttl_ms <= 0:
return
payload = json.dumps(user, separators=(",", ":"))
try:
await self._call(
lambda: self.client.set(KEY_PREFIX + token_hash, payload, px=ttl_ms, nx=True)
)
except CACHE_ERRORS:
pass
async def revoke(self, token_hash: str) -> None:
"""Записать отметку отзыва; при сбое пометить кэш для очистки."""
try:
await self._call(
lambda: self.client.set(
KEY_PREFIX + token_hash, REVOKED, px=self.ttl_cap * 1000
)
)
except CACHE_ERRORS:
self.dirty = True
async def close(self) -> None:
"""Закрыть соединения с Redis."""
try:
await self.client.aclose()
except CACHE_ERRORS:
pass
class NoCache:
"""Заглушка при выключенном кэше: всегда промах."""
enabled = False
stats: Dict[str, int] = {}
async def get(self, token_hash: str) -> Optional[dict]:
"""Всегда промах."""
return None
async def put(self, token_hash: str, user: dict, remaining_seconds: float) -> None:
"""Ничего не делает."""
return None
async def revoke(self, token_hash: str) -> None:
"""Ничего не делает."""
return None
async def close(self) -> None:
"""Ничего не делает."""
return None
def create_cache(settings) -> "SessionCache | NoCache":
"""SessionCache, если задан CACHE_URL, иначе NoCache."""
if not settings.cache_url:
return NoCache()
return SessionCache(
settings.cache_url,
settings.cache_ttl_seconds,
settings.cache_timeout_ms,
settings.cache_retry_seconds,
)
+107
View File
@@ -0,0 +1,107 @@
"""Настройки приложения из переменных окружения."""
import os
from dataclasses import dataclass
from typing import Mapping, Optional
LOG_LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR")
@dataclass(frozen=True)
class Settings:
"""Неизменяемый набор настроек."""
host: str
port: int
env: str
log_level: str
database_url: str
session_ttl_seconds: int
session_store: str
db_pool_size: int
db_max_overflow: int
db_pool_timeout: int
db_startup_wait_seconds: int
cache_url: str
cache_ttl_seconds: int
cache_timeout_ms: int
cache_retry_seconds: int
@classmethod
def from_env(cls, environ: Optional[Mapping[str, str]] = None) -> "Settings":
"""Собрать и проверить настройки; при ошибке ValueError с описанием."""
source = os.environ if environ is None else environ
def get(name: str, default: str) -> str:
value = source.get(name)
if value is None or value.strip() == "":
return default
return value.strip()
def get_int(name: str, default: int, low: int, high: int) -> int:
text = get(name, str(default))
if not text.isdigit() or not (low <= int(text) <= high):
raise ValueError(
"%s должен быть числом от %d до %d" % (name, low, high)
)
return int(text)
log_level = get("LOG_LEVEL", "INFO").upper()
if log_level not in LOG_LEVELS:
raise ValueError(
"LOG_LEVEL должен быть одним из %s" % ", ".join(LOG_LEVELS)
)
session_store = get("SESSION_STORE", "postgres")
if session_store != "postgres":
raise ValueError(
"SESSION_STORE: источник истины сессий -- только postgres "
"(Redis -- кэш, задаётся CACHE_URL)"
)
database_url = _read_database_url(source)
if not database_url.startswith("postgresql+asyncpg://"):
raise ValueError("DATABASE_URL должен начинаться с postgresql+asyncpg://")
return cls(
host=get("APP_HOST", "127.0.0.1"),
port=get_int("APP_PORT", 8080, 1, 65535),
env=get("APP_ENV", "lab"),
log_level=log_level,
database_url=database_url,
session_ttl_seconds=get_int("SESSION_TTL_SECONDS", 3600, 1, 30 * 24 * 3600),
session_store=session_store,
db_pool_size=get_int("DB_POOL_SIZE", 5, 1, 50),
db_max_overflow=get_int("DB_MAX_OVERFLOW", 5, 0, 50),
db_pool_timeout=get_int("DB_POOL_TIMEOUT", 5, 1, 60),
db_startup_wait_seconds=get_int("DB_STARTUP_WAIT_SECONDS", 30, 0, 300),
cache_url=_read_cache_url(source),
cache_ttl_seconds=get_int("CACHE_TTL_SECONDS", 60, 1, 3600),
cache_timeout_ms=get_int("CACHE_TIMEOUT_MS", 300, 10, 5000),
cache_retry_seconds=get_int("CACHE_RETRY_SECONDS", 5, 0, 300),
)
def _read_database_url(source: Mapping[str, str]) -> str:
"""Адрес БД из DATABASE_URL_FILE или DATABASE_URL."""
path = source.get("DATABASE_URL_FILE", "").strip()
if path:
with open(path, encoding="utf-8") as handle:
return handle.read().strip()
value = source.get("DATABASE_URL", "").strip()
if not value:
raise ValueError("Не задан DATABASE_URL (или DATABASE_URL_FILE)")
return value
def _read_cache_url(source: Mapping[str, str]) -> str:
"""Адрес Redis из CACHE_URL_FILE или CACHE_URL; пустая строка -- кэш выключен."""
path = source.get("CACHE_URL_FILE", "").strip()
if path:
with open(path, encoding="utf-8") as handle:
value = handle.read().strip()
else:
value = source.get("CACHE_URL", "").strip()
if value and not value.startswith(("redis://", "rediss://")):
raise ValueError("CACHE_URL должен начинаться с redis:// или rediss://")
return value
+208
View File
@@ -0,0 +1,208 @@
"""Запросы к PostgreSQL через SQLAlchemy с параметрами.
Изменяющие функции -- одна транзакция: commit в конце, rollback при ошибке.
"""
import uuid
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple
from sqlalchemy import Select, delete, func, insert, select, tuple_
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from .models import Chat, ChatMember, Message, SessionRow, User
UNIQUE_VIOLATION = "23505"
FOREIGN_KEY_VIOLATION = "23503"
Position = Tuple[datetime, uuid.UUID]
class UsernameTaken(Exception):
"""Username уже занят."""
class UnknownMember(Exception):
"""Среди участников чата есть несуществующий пользователь."""
def sqlstate(error: IntegrityError) -> Optional[str]:
"""Код SQLSTATE из исключения SQLAlchemy."""
original = error.orig
code = getattr(original, "sqlstate", None)
if code is None:
code = getattr(getattr(original, "__cause__", None), "sqlstate", None)
return code
async def create_user(
session: AsyncSession, username: str, display_name: str, password_hash: str
) -> User:
"""Создать пользователя; дубликат username -> UsernameTaken."""
statement = (
insert(User)
.values(
id=uuid.uuid4(),
username=username,
display_name=display_name,
password_hash=password_hash,
)
.returning(User)
)
try:
user = (await session.execute(statement)).scalar_one()
await session.commit()
except IntegrityError as error:
await session.rollback()
if sqlstate(error) == UNIQUE_VIOLATION:
raise UsernameTaken(username)
raise
return user
async def get_user_by_username(session: AsyncSession, username: str) -> Optional[User]:
"""Пользователь по username или None."""
return (
await session.execute(select(User).where(User.username == username))
).scalar_one_or_none()
async def create_session(
session: AsyncSession, user_id: uuid.UUID, token_hash: str, ttl_seconds: int
) -> datetime:
"""Удалить истёкшие сессии пользователя, создать новую, вернуть expires_at."""
await session.execute(
delete(SessionRow).where(
SessionRow.user_id == user_id, SessionRow.expires_at < func.now()
)
)
statement = (
insert(SessionRow)
.values(
token_hash=token_hash,
user_id=user_id,
expires_at=func.now() + timedelta(seconds=ttl_seconds),
)
.returning(SessionRow.expires_at)
)
expires_at = (await session.execute(statement)).scalar_one()
await session.commit()
return expires_at
async def get_user_by_token(
session: AsyncSession, token_hash: str
) -> Optional[Tuple[User, float]]:
"""(User, секунд до истечения) для действующей сессии или None."""
statement = (
select(User, func.extract("epoch", SessionRow.expires_at - func.now()))
.join(SessionRow, SessionRow.user_id == User.id)
.where(SessionRow.token_hash == token_hash, SessionRow.expires_at > func.now())
)
row = (await session.execute(statement)).one_or_none()
if row is None:
return None
return row[0], float(row[1])
async def delete_session(session: AsyncSession, token_hash: str) -> None:
"""Удалить сессию по хешу токена."""
await session.execute(delete(SessionRow).where(SessionRow.token_hash == token_hash))
await session.commit()
async def create_chat(
session: AsyncSession, title: str, member_ids: List[uuid.UUID]
) -> Tuple[Chat, List[uuid.UUID]]:
"""Атомарно создать чат и участников; неизвестный участник -> UnknownMember."""
chat_statement = insert(Chat).values(id=uuid.uuid4(), title=title).returning(Chat)
try:
chat = (await session.execute(chat_statement)).scalar_one()
await session.execute(
insert(ChatMember),
[{"chat_id": chat.id, "user_id": user_id} for user_id in member_ids],
)
await session.commit()
except IntegrityError as error:
await session.rollback()
if sqlstate(error) == FOREIGN_KEY_VIOLATION:
raise UnknownMember()
raise
return chat, member_ids
async def get_chat_for_member(
session: AsyncSession, chat_id: uuid.UUID, user_id: uuid.UUID
) -> Optional[Chat]:
"""Чат, если пользователь в нём состоит, иначе None."""
statement = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
return (await session.execute(statement)).scalar_one_or_none()
async def get_member_ids(
session: AsyncSession, chat_ids: List[uuid.UUID]
) -> Dict[uuid.UUID, List[uuid.UUID]]:
"""Участники нескольких чатов одним запросом: {chat_id: [user_id]}."""
result: Dict[uuid.UUID, List[uuid.UUID]] = {chat_id: [] for chat_id in chat_ids}
if chat_ids:
statement = (
select(ChatMember.chat_id, ChatMember.user_id)
.where(ChatMember.chat_id.in_(chat_ids))
.order_by(ChatMember.chat_id, ChatMember.user_id)
)
for chat_id, user_id in (await session.execute(statement)).all():
result[chat_id].append(user_id)
return result
async def list_chats(
session: AsyncSession, user_id: uuid.UUID, after: Optional[Position], limit: int
) -> Tuple[List[Chat], bool]:
"""Страница чатов пользователя по (created_at, id) и признак следующей страницы."""
statement = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
)
if after is not None:
statement = statement.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after))
statement = statement.order_by(Chat.created_at, Chat.id).limit(limit + 1)
rows = list((await session.execute(statement)).scalars())
return rows[:limit], len(rows) > limit
async def create_message(
session: AsyncSession, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str
) -> Message:
"""Сохранить сообщение; время назначает БД."""
statement = (
insert(Message)
.values(id=uuid.uuid4(), chat_id=chat_id, sender_id=sender_id, text=text)
.returning(Message)
)
message = (await session.execute(statement)).scalar_one()
await session.commit()
return message
def history_query(chat_id: uuid.UUID, after: Optional[Position], limit: int) -> Select:
"""SELECT страницы истории по курсору (created_at, id); идёт по индексу чата."""
statement = select(Message).where(Message.chat_id == chat_id)
if after is not None:
statement = statement.where(
tuple_(Message.created_at, Message.id) > tuple_(*after)
)
return statement.order_by(Message.created_at, Message.id).limit(limit + 1)
async def list_messages(
session: AsyncSession, chat_id: uuid.UUID, after: Optional[Position], limit: int
) -> Tuple[List[Message], bool]:
"""Страница истории чата и признак следующей страницы."""
rows = list((await session.execute(history_query(chat_id, after, limit))).scalars())
return rows[:limit], len(rows) > limit
+45
View File
@@ -0,0 +1,45 @@
"""Непрозрачный keyset-курсор пагинации.
Хранит позицию (микросекунды, id) и область действия, поэтому курсор
другого ресурса отвергается.
"""
import base64
import binascii
import json
import re
from typing import Tuple
Key = Tuple[int, str]
UUID_RE = re.compile(
r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
)
MAX_CURSOR_LENGTH = 512
def encode_cursor(scope: str, key: Key) -> str:
"""Закодировать позицию и область в URL-безопасную строку."""
payload = json.dumps({"s": scope, "t": key[0], "i": key[1]}, separators=(",", ":"))
return base64.urlsafe_b64encode(payload.encode("ascii")).decode("ascii").rstrip("=")
def decode_cursor(text: str, scope: str) -> Key:
"""Раскодировать курсор; ValueError, если он испорчен или чужой."""
if len(text) > MAX_CURSOR_LENGTH or not re.fullmatch(r"[A-Za-z0-9_-]+", text):
raise ValueError("bad cursor")
try:
padded = text + "=" * (-len(text) % 4)
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
except (binascii.Error, ValueError, UnicodeError):
raise ValueError("bad cursor")
if not isinstance(data, dict) or set(data) != {"s", "t", "i"}:
raise ValueError("bad cursor")
stamp, ident = data["t"], data["i"]
if data["s"] != scope:
raise ValueError("cursor belongs to another resource")
if not isinstance(stamp, int) or isinstance(stamp, bool) or stamp < 0:
raise ValueError("bad cursor")
if not isinstance(ident, str) or not UUID_RE.fullmatch(ident):
raise ValueError("bad cursor")
return stamp, ident
+27
View File
@@ -0,0 +1,27 @@
"""Подключение к PostgreSQL: движок с пулом и фабрика сессий."""
from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
from sqlalchemy.ext.asyncio import AsyncSession
from .config import Settings
def create_engine(settings: Settings) -> AsyncEngine:
"""Async-движок с ограниченным пулом и таймаутами."""
return create_async_engine(
settings.database_url,
pool_size=settings.db_pool_size,
max_overflow=settings.db_max_overflow,
pool_timeout=settings.db_pool_timeout,
pool_pre_ping=True,
connect_args={
"timeout": 5,
"command_timeout": 10,
"server_settings": {"application_name": "messenger-api"},
},
)
def create_sessionmaker(engine: AsyncEngine) -> "async_sessionmaker[AsyncSession]":
"""Фабрика сессий без истечения объектов после commit."""
return async_sessionmaker(engine, expire_on_commit=False)
+37
View File
@@ -0,0 +1,37 @@
"""Единый формат ошибок API."""
from typing import Dict, Optional
from fastapi.responses import JSONResponse
class ApiError(Exception):
"""Исключение, которое превращается в ответ с кодом и сообщением."""
def __init__(
self,
status: int,
code: str,
message: str,
headers: Optional[Dict[str, str]] = None,
):
super().__init__(message)
self.status = status
self.code = code
self.message = message
self.headers = headers
def error_response(
request_id: str,
status: int,
code: str,
message: str,
headers: Optional[Dict[str, str]] = None,
) -> JSONResponse:
"""JSON-ответ вида {"error": {code, message, request_id}}."""
return JSONResponse(
status_code=status,
content={"error": {"code": code, "message": message, "request_id": request_id}},
headers=headers,
)
+139
View File
@@ -0,0 +1,139 @@
"""Анализ плана запроса истории: EXPLAIN (ANALYZE, BUFFERS) на синтетических данных.
Запуск: python -m app.explain [--messages N]. Создаёт данные один раз,
затем сравнивает запрос приложения с OFFSET и с вариантом без индекса.
"""
import argparse
import asyncio
import sys
import uuid
from datetime import datetime
from typing import List, Optional, Tuple
from sqlalchemy.ext.asyncio import AsyncEngine
from .config import Settings
from .crud import history_query
from .db import create_engine
SEED_NAMESPACE = uuid.UUID("6f1c1a52-6a39-4c1e-9d0e-5ab0e0c0e2a1")
BIG_CHAT = uuid.uuid5(SEED_NAMESPACE, "chat-big")
OTHER_CHATS = [uuid.uuid5(SEED_NAMESPACE, "chat-%d" % n) for n in range(49)]
SENDERS = [uuid.uuid5(SEED_NAMESPACE, "user-a"), uuid.uuid5(SEED_NAMESPACE, "user-b")]
PAGE = 50
DEEP_OFFSET = 15000
async def seed(pg, total: int) -> None:
"""Создать синтетических пользователей, чаты и сообщения, если их ещё нет."""
if await pg.fetchval("SELECT 1 FROM chats WHERE id = $1", BIG_CHAT):
return
async with pg.transaction():
await pg.executemany(
"INSERT INTO users (id, username, display_name, password_hash)"
" VALUES ($1, $2, $3, 'disabled')",
[(SENDERS[0], "explain_seed_a", "Seed A"), (SENDERS[1], "explain_seed_b", "Seed B")],
)
chats = [BIG_CHAT] + OTHER_CHATS
await pg.executemany(
"INSERT INTO chats (id, title, created_at)"
" VALUES ($1, $2, now() - interval '30 days')",
[(chat, "explain seed %d" % n) for n, chat in enumerate(chats)],
)
await pg.executemany(
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
[(chat, sender) for chat in chats for sender in SENDERS],
)
await pg.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(),
CASE WHEN g % 3 = 0 THEN $1::uuid ELSE ($2::uuid[])[1 + g % 49] END,
($3::uuid[])[1 + g % 2],
'synthetic message #' || g,
now() - interval '30 days' + g * interval '10 milliseconds'
FROM generate_series(1, $4::int) AS g
""",
BIG_CHAT, OTHER_CHATS, SENDERS, total,
)
await pg.execute("ANALYZE messages")
await pg.execute("ANALYZE chats")
await pg.execute("ANALYZE chat_members")
def compiled(engine: AsyncEngine, after: Optional[Tuple[datetime, uuid.UUID]]) -> Tuple[str, List]:
"""Текст SQL запроса истории и значения его параметров."""
query = history_query(BIG_CHAT, after, PAGE).compile(dialect=engine.dialect)
return query.string, [query.params[name] for name in query.positiontup]
async def explain(pg, title: str, sql: str, params: List) -> None:
"""Напечатать запрос, параметры и план выполнения."""
print("\n" + "=" * 78)
print(title)
print("=" * 78)
print(sql)
print("-- параметры:", ", ".join(str(p) for p in params))
for row in await pg.fetch("EXPLAIN (ANALYZE, BUFFERS) " + sql, *params):
print(row[0])
async def main_async(total: int) -> int:
"""Заполнить данные и вывести планы запросов."""
engine = create_engine(Settings.from_env())
try:
async with engine.connect() as conn:
pg = (await conn.get_raw_connection()).driver_connection
await seed(pg, total)
print("PostgreSQL:", await pg.fetchval("SHOW server_version"))
print("Сообщений всего:", await pg.fetchval("SELECT count(*) FROM messages"))
print("Сообщений в большом чате:",
await pg.fetchval("SELECT count(*) FROM messages WHERE chat_id = $1", BIG_CHAT))
print("Размер таблицы messages:",
await pg.fetchval("SELECT pg_size_pretty(pg_relation_size('messages'))"))
print("Размер индекса messages_chat_created_idx:",
await pg.fetchval("SELECT pg_size_pretty(pg_relation_size('messages_chat_created_idx'))"))
cursor = await pg.fetchrow(
"SELECT created_at, id FROM messages WHERE chat_id = $1"
" ORDER BY created_at, id OFFSET $2 LIMIT 1",
BIG_CHAT, DEEP_OFFSET - 1,
)
after = (cursor["created_at"], cursor["id"])
sql, params = compiled(engine, None)
await explain(pg, "1. Первая страница (без cursor), запрос приложения", sql, params)
sql, params = compiled(engine, after)
await explain(pg, "2. Глубокая страница: cursor после %d-го сообщения (keyset)"
% DEEP_OFFSET, sql, params)
await explain(
pg, "3. Для сравнения: та же страница через OFFSET (так приложение НЕ делает)",
"SELECT * FROM messages WHERE chat_id = $1 ORDER BY created_at, id"
" OFFSET %d LIMIT %d" % (DEEP_OFFSET, PAGE + 1),
[BIG_CHAT],
)
tx = pg.transaction()
await tx.start()
try:
await pg.execute("DROP INDEX messages_chat_created_idx")
await explain(pg, "4. Для сравнения: запрос приложения БЕЗ индекса"
" (DROP INDEX в транзакции, затем ROLLBACK)", sql, params)
finally:
await tx.rollback()
print("\nИндекс messages_chat_created_idx на месте:",
bool(await pg.fetchval("SELECT to_regclass('messages_chat_created_idx')")))
finally:
await engine.dispose()
return 0
def main() -> int:
"""Разобрать аргументы командной строки и запустить анализ."""
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
parser.add_argument("--messages", type=int, default=60000,
help="сколько синтетических сообщений создать при первом запуске")
return asyncio.run(main_async(parser.parse_args().messages))
if __name__ == "__main__":
sys.exit(main())
+20
View File
@@ -0,0 +1,20 @@
"""Проверка готовности для HEALTHCHECK контейнера."""
import os
import sys
import urllib.request
def main() -> int:
"""0, если /health/ready отвечает 200, иначе 1."""
port = os.environ.get("APP_PORT", "8080").strip() or "8080"
try:
url = "http://127.0.0.1:%s/health/ready" % port
with urllib.request.urlopen(url, timeout=2) as reply:
return 0 if reply.status == 200 else 1
except Exception:
return 1
if __name__ == "__main__":
sys.exit(main())
+102
View File
@@ -0,0 +1,102 @@
"""Помощники HTTP: чтение JSON, проверка тела, разбор UUID, limit и cursor."""
import json
import re
from typing import Optional, Type, TypeVar
from fastapi import Request
from pydantic import BaseModel, ValidationError
from .cursor import Key, UUID_RE, decode_cursor
from .errors import ApiError
MAX_BODY_BYTES = 256 * 1024
DEFAULT_LIMIT = 50
MAX_LIMIT = 100
T = TypeVar("T", bound=BaseModel)
def bad_request(message: str) -> ApiError:
"""Ошибка 400 invalid_request."""
return ApiError(400, "invalid_request", message)
def _reject_constant(name: str):
"""Запретить NaN и Infinity в JSON."""
raise ValueError("недопустимое значение " + name)
async def read_json_object(request: Request) -> dict:
"""Прочитать тело запроса как JSON-объект."""
content_type = request.headers.get("content-type", "")
media_type, _, params = content_type.partition(";")
if media_type.strip().lower() != "application/json":
raise ApiError(
415, "unsupported_media_type", "Нужен Content-Type: application/json"
)
charset = re.search(r"charset\s*=\s*\"?([^\";\s]+)", params, re.IGNORECASE)
if charset and charset.group(1).lower() not in ("utf-8", "utf8"):
raise ApiError(
415, "unsupported_media_type", "Поддерживается только кодировка UTF-8"
)
declared = request.headers.get("content-length", "")
if declared.isdigit() and int(declared) > MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
chunks = []
size = 0
async for chunk in request.stream():
size += len(chunk)
if size > MAX_BODY_BYTES:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
chunks.append(chunk)
try:
data = json.loads(
b"".join(chunks).decode("utf-8"), parse_constant=_reject_constant
)
except (UnicodeDecodeError, ValueError, RecursionError):
raise bad_request("Тело запроса не является корректным JSON")
if not isinstance(data, dict):
raise bad_request("Тело запроса должно быть JSON-объектом")
return data
def validate_body(model: Type[T], data: dict) -> T:
"""Проверить словарь моделью Pydantic; ошибки -> 400."""
try:
return model.model_validate(data)
except ValidationError as exc:
problems = []
for err in exc.errors()[:3]:
field = ".".join(str(part) for part in err["loc"]) or "body"
problems.append("%s: %s" % (field, err["msg"].replace("Value error, ", "")))
raise bad_request("Неверные данные: " + "; ".join(problems))
def parse_uuid(value: str, what: str) -> str:
"""Проверить строку как UUID и вернуть её в нижнем регистре."""
if not UUID_RE.fullmatch(value):
raise bad_request("%s должен быть UUID" % what)
return value.lower()
def parse_limit(raw: Optional[str]) -> int:
"""Размер страницы: по умолчанию 50, допустимо 1-100."""
if raw is None:
return DEFAULT_LIMIT
if not re.fullmatch(r"[0-9]{1,6}", raw) or not 1 <= int(raw) <= MAX_LIMIT:
raise bad_request("limit должен быть целым числом от 1 до %d" % MAX_LIMIT)
return int(raw)
def parse_cursor(raw: Optional[str], scope: str) -> Optional[Key]:
"""Позиция из курсора или None; неверный курсор -> 400."""
if raw is None or raw == "":
return None
try:
return decode_cursor(raw, scope)
except ValueError:
raise bad_request("Некорректный cursor")
+25
View File
@@ -0,0 +1,25 @@
"""Настройка логирования в stdout."""
import logging
import sys
LOGGER_NAME = "messenger"
def get_logger() -> logging.Logger:
"""Логгер приложения."""
return logging.getLogger(LOGGER_NAME)
def setup_logging(level: str = "INFO") -> logging.Logger:
"""Задать уровень и формат: одна строка на событие."""
logger = get_logger()
logger.setLevel(level)
if not logger.handlers:
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(
logging.Formatter("%(asctime)s %(levelname)s %(message)s", "%Y-%m-%dT%H:%M:%S%z")
)
logger.addHandler(handler)
logger.propagate = False
return logger
+136
View File
@@ -0,0 +1,136 @@
"""Сборка приложения FastAPI: зависимости, миграции, обработчики ошибок."""
import asyncio
import time
from contextlib import asynccontextmanager
from typing import Optional
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from sqlalchemy.exc import InterfaceError, OperationalError
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
from starlette.exceptions import HTTPException as StarletteHTTPException
from .cache import create_cache
from .config import Settings
from .db import create_engine, create_sessionmaker
from .errors import ApiError, error_response
from .logging_setup import get_logger, setup_logging
from .middleware import RequestContextMiddleware
from .migrate import run_migrations
from .routes import api, router
DB_UNAVAILABLE = (
OperationalError,
InterfaceError,
PoolTimeoutError,
OSError,
asyncio.TimeoutError,
)
async def migrate_with_retry(engine, wait_seconds: int) -> None:
"""Применить миграции, повторяя попытки, пока БД не станет доступна."""
deadline = time.monotonic() + wait_seconds
while True:
try:
applied = await run_migrations(engine)
get_logger().info(
"migrations: %s", ", ".join(applied) if applied else "nothing to apply"
)
return
except Exception as exc:
if time.monotonic() >= deadline:
raise
get_logger().warning(
"migrations: БД ещё не готова (%s), повтор", type(exc).__name__
)
await asyncio.sleep(1)
def create_app(settings: Optional[Settings] = None) -> FastAPI:
"""Создать приложение FastAPI с заданными настройками."""
settings = settings or Settings.from_env()
setup_logging(settings.log_level)
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Старт: кэш, движок, миграции. Остановка: закрыть соединения."""
get_logger().info(
"config env=%s pool=%d+%d ttl=%ds store=%s cache=%s",
settings.env,
settings.db_pool_size,
settings.db_max_overflow,
settings.session_ttl_seconds,
settings.session_store,
"redis" if settings.cache_url else "off",
)
app.state.cache = create_cache(settings)
engine = create_engine(settings)
app.state.engine = engine
app.state.sessionmaker = create_sessionmaker(engine)
await migrate_with_retry(engine, settings.db_startup_wait_seconds)
app.state.ready = True
get_logger().info("startup: приложение готово")
yield
app.state.ready = False
await app.state.cache.close()
await engine.dispose()
get_logger().info("shutdown: получен сигнал остановки, соединения с БД закрыты")
app = FastAPI(title="Messenger API", version="1.2.0", lifespan=lifespan)
app.state.settings = settings
app.state.ready = False
app.router.redirect_slashes = False
app.add_middleware(RequestContextMiddleware)
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
"""ApiError -> ответ в общем формате."""
return error_response(
request.state.request_id, exc.status, exc.code, exc.message, exc.headers
)
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
"""404 и 405 -> ответ в общем формате."""
if exc.status_code == 404:
return error_response(
request.state.request_id, 404, "not_found", "Объект не найден"
)
headers = dict(exc.headers) if exc.headers else None
return error_response(
request.state.request_id,
exc.status_code,
"invalid_request",
"Запрос не поддерживается",
headers,
)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
"""Ошибки разбора параметров -> 400."""
return error_response(
request.state.request_id,
400,
"invalid_request",
"Неверные параметры запроса",
)
async def handle_db_unavailable(request: Request, exc: Exception):
"""Недоступная БД или пул -> 503 без деталей."""
get_logger().error(
"db_unavailable request_id=%s type=%s",
request.state.request_id,
type(exc).__name__,
)
return error_response(
request.state.request_id, 503, "unavailable", "Сервис временно недоступен"
)
for error_type in DB_UNAVAILABLE:
app.add_exception_handler(error_type, handle_db_unavailable)
app.include_router(router)
app.include_router(api)
return app
+68
View File
@@ -0,0 +1,68 @@
"""ASGI-middleware: X-Request-Id, ответ 500 при сбое и строка лога на запрос."""
import time
import traceback
import uuid
from starlette.datastructures import MutableHeaders
from starlette.types import ASGIApp, Message, Receive, Scope, Send
from .errors import error_response
from .logging_setup import get_logger
class RequestContextMiddleware:
"""Request id, обработка необработанных исключений, журнал запросов."""
def __init__(self, app: ASGIApp) -> None:
"""Сохранить следующее приложение в цепочке."""
self.app = app
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
"""Обработать один HTTP-запрос."""
if scope["type"] != "http":
await self.app(scope, receive, send)
return
request_id = uuid.uuid4().hex
scope.setdefault("state", {})["request_id"] = request_id
started = time.perf_counter()
state = {"status": 500, "response_started": False}
async def send_with_request_id(message: Message) -> None:
if message["type"] == "http.response.start":
state["status"] = message["status"]
state["response_started"] = True
MutableHeaders(scope=message)["X-Request-Id"] = request_id
await send(message)
try:
await self.app(scope, receive, send_with_request_id)
except Exception as exc:
frames = traceback.extract_tb(exc.__traceback__)
where = " <- ".join(
"%s:%s" % (f.filename.split("/")[-1], f.lineno)
for f in reversed(frames[-3:])
)
get_logger().error(
"unhandled_error request_id=%s type=%s where=%s",
request_id,
type(exc).__name__,
where,
)
if state["response_started"]:
raise
response = error_response(
request_id, 500, "internal_error", "Внутренняя ошибка сервера"
)
await response(scope, receive, send_with_request_id)
finally:
get_logger().info(
"request request_id=%s method=%s path=%s status=%s duration_ms=%.1f",
request_id,
scope.get("method"),
scope.get("path"),
state["status"],
(time.perf_counter() - started) * 1000,
)
+64
View File
@@ -0,0 +1,64 @@
"""Применение SQL-миграций из app/migrations/.
Применённые файлы хранятся в schema_migrations; каждый файл выполняется
в своей транзакции под advisory lock. Запуск: python -m app.migrate
"""
import asyncio
import sys
from pathlib import Path
from typing import List
from sqlalchemy.ext.asyncio import AsyncEngine
from .config import Settings
from .db import create_engine
MIGRATIONS_DIR = Path(__file__).parent / "migrations"
LOCK_ID = 727001
async def run_migrations(engine: AsyncEngine) -> List[str]:
"""Применить новые миграции и вернуть их имена."""
applied_now: List[str] = []
async with engine.connect() as conn:
raw = await conn.get_raw_connection()
pg = raw.driver_connection
await pg.execute("SELECT pg_advisory_lock(%d)" % LOCK_ID)
try:
await pg.execute(
"CREATE TABLE IF NOT EXISTS schema_migrations ("
" version text PRIMARY KEY,"
" applied_at timestamptz NOT NULL DEFAULT now())"
)
done = {
row["version"]
for row in await pg.fetch("SELECT version FROM schema_migrations")
}
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
if path.name in done:
continue
async with pg.transaction():
await pg.execute(path.read_text(encoding="utf-8"))
await pg.execute(
"INSERT INTO schema_migrations (version) VALUES ($1)", path.name
)
applied_now.append(path.name)
finally:
await pg.execute("SELECT pg_advisory_unlock(%d)" % LOCK_ID)
return applied_now
async def _main() -> int:
"""Применить миграции из командной строки и напечатать результат."""
engine = create_engine(Settings.from_env())
try:
applied = await run_migrations(engine)
finally:
await engine.dispose()
print("Применено: %s" % (", ".join(applied) if applied else "ничего нового"))
return 0
if __name__ == "__main__":
sys.exit(asyncio.run(_main()))
+41
View File
@@ -0,0 +1,41 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
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 clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX chats_created_idx ON chats (created_at, id);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
PRIMARY KEY (chat_id, user_id)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
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 clock_timestamp()
);
CREATE INDEX messages_chat_created_idx ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash text PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
+70
View File
@@ -0,0 +1,70 @@
"""ORM-модели таблиц; схема и ограничения задаются миграциями."""
import uuid
from datetime import datetime
from sqlalchemy import DateTime, func
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
NOW = func.clock_timestamp()
class Base(DeclarativeBase):
"""Базовый класс моделей."""
class User(Base):
"""Пользователь; пароль хранится только как хеш."""
__tablename__ = "users"
id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
username: Mapped[str]
display_name: Mapped[str]
password_hash: Mapped[str]
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=NOW
)
class Chat(Base):
"""Чат."""
__tablename__ = "chats"
id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
title: Mapped[str]
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=NOW
)
class ChatMember(Base):
"""Участие пользователя в чате."""
__tablename__ = "chat_members"
chat_id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
user_id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
class Message(Base):
"""Сообщение чата."""
__tablename__ = "messages"
id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
chat_id: Mapped[uuid.UUID]
sender_id: Mapped[uuid.UUID]
text: Mapped[str]
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=NOW
)
class SessionRow(Base):
"""Сессия входа; хранится SHA-256 токена."""
__tablename__ = "sessions"
token_hash: Mapped[str] = mapped_column(primary_key=True)
user_id: Mapped[uuid.UUID]
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=NOW
)
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+290
View File
@@ -0,0 +1,290 @@
"""HTTP-эндпоинты API.
Порядок проверок: аутентификация (401), доступ к чату (404), тело запроса (400).
"""
import asyncio
import uuid
from typing import List
from fastapi import APIRouter, Depends, Request, Response
from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncSession
from . import crud
from .auth import (
BASIC_CHALLENGE,
current_user,
get_session,
parse_basic,
parse_bearer,
unauthorized,
)
from .cursor import encode_cursor
from .errors import ApiError
from .http_utils import (
parse_cursor,
parse_limit,
parse_uuid,
read_json_object,
validate_body,
)
from .models import Chat, Message, User
from .schemas import (
ChatOut,
ChatPage,
CreateChatIn,
CreateMessageIn,
CreateUserIn,
MessageOut,
MessagePage,
SessionOut,
UserOut,
)
from .security import (
DUMMY_HASH,
hash_password_async,
hash_token,
new_token,
verify_password_async,
)
from .timeutil import format_ts, from_micros, to_micros
router = APIRouter()
api = APIRouter(prefix="/api/v1")
def body_doc(model: type) -> dict:
"""Описание тела запроса для OpenAPI-документации."""
return {
"requestBody": {
"required": True,
"content": {"application/json": {"schema": model.model_json_schema()}},
}
}
def user_out(user: User) -> dict:
"""User -> словарь ответа."""
return {
"id": str(user.id),
"username": user.username,
"display_name": user.display_name,
"created_at": format_ts(user.created_at),
}
def chat_out(chat: Chat, member_ids: List[uuid.UUID]) -> dict:
"""Chat и участники -> словарь ответа."""
return {
"id": str(chat.id),
"title": chat.title,
"member_ids": [str(member_id) for member_id in member_ids],
"created_at": format_ts(chat.created_at),
}
def message_out(message: Message) -> dict:
"""Message -> словарь ответа."""
return {
"id": str(message.id),
"chat_id": str(message.chat_id),
"sender_id": str(message.sender_id),
"text": message.text,
"created_at": format_ts(message.created_at),
}
def position(key):
"""Позицию из курсора перевести в (datetime, UUID)."""
if key is None:
return None
return from_micros(key[0]), uuid.UUID(key[1])
def cursor_for(scope: str, row) -> str:
"""Курсор, указывающий на строку row."""
return encode_cursor(scope, (to_micros(row.created_at), str(row.id)))
async def open_chat(session: AsyncSession, user: User, chat_id_text: str) -> Chat:
"""Чат, доступный пользователю; неверный id -> 400, чужой или несуществующий -> 404."""
chat_id = uuid.UUID(parse_uuid(chat_id_text, "chat_id"))
chat = await crud.get_chat_for_member(session, chat_id, user.id)
if chat is None:
raise ApiError(404, "not_found", "Объект не найден")
return chat
@router.get("/health/live")
async def live() -> dict:
"""Процесс жив."""
return {"status": "ok"}
@router.get("/health/ready")
async def ready(request: Request):
"""Готовность: миграции применены и БД отвечает."""
if not getattr(request.app.state, "ready", False):
raise ApiError(503, "unavailable", "Сервис не готов")
try:
async with request.app.state.sessionmaker() as session:
await asyncio.wait_for(session.execute(text("SELECT 1")), timeout=2)
except Exception:
raise ApiError(503, "unavailable", "База данных недоступна")
return {"status": "ok"}
@api.post(
"/users",
status_code=201,
response_model=UserOut,
openapi_extra=body_doc(CreateUserIn),
)
async def register_user(request: Request, session: AsyncSession = Depends(get_session)):
"""Регистрация пользователя."""
body = validate_body(CreateUserIn, await read_json_object(request))
password_hash = await hash_password_async(body.password)
try:
user = await crud.create_user(
session, body.username, body.display_name, password_hash
)
except crud.UsernameTaken:
raise ApiError(409, "conflict", "Такое имя пользователя уже занято")
return user_out(user)
@api.post("/auth/sessions", status_code=201, response_model=SessionOut)
async def login(request: Request, session: AsyncSession = Depends(get_session)):
"""Вход по Basic: создать сессию и вернуть Bearer-токен."""
username, password = parse_basic(request)
user = await crud.get_user_by_username(session, username)
password_ok = await verify_password_async(
password, user.password_hash if user else DUMMY_HASH
)
if user is None or not password_ok:
raise unauthorized(BASIC_CHALLENGE)
token = new_token()
expires_at = await crud.create_session(
session,
user.id,
hash_token(token),
request.app.state.settings.session_ttl_seconds,
)
return {
"token": token,
"token_type": "Bearer",
"expires_at": format_ts(expires_at),
"user": user_out(user),
}
@api.delete("/auth/sessions/current", status_code=204)
async def logout(
request: Request,
user: User = Depends(current_user),
session: AsyncSession = Depends(get_session),
):
"""Отозвать текущую сессию."""
token_hash = hash_token(parse_bearer(request))
await crud.delete_session(session, token_hash)
await request.app.state.cache.revoke(token_hash)
return Response(status_code=204)
@api.get("/users/me", response_model=UserOut)
async def read_me(user: User = Depends(current_user)):
"""Текущий пользователь."""
return user_out(user)
@api.post(
"/chats",
status_code=201,
response_model=ChatOut,
openapi_extra=body_doc(CreateChatIn),
)
async def create_chat(
request: Request,
user: User = Depends(current_user),
session: AsyncSession = Depends(get_session),
):
"""Создать чат с участниками."""
body = validate_body(CreateChatIn, await read_json_object(request))
member_ids = [uuid.UUID(item) for item in body.member_ids]
if user.id not in member_ids:
raise ApiError(400, "invalid_request", "member_ids должен включать вас самих")
try:
chat, members = await crud.create_chat(session, body.title, member_ids)
except crud.UnknownMember:
raise ApiError(
400, "invalid_request", "member_ids содержит несуществующего пользователя"
)
return chat_out(chat, sorted(members))
@api.get("/chats", response_model=ChatPage)
async def list_chats(
request: Request,
user: User = Depends(current_user),
session: AsyncSession = Depends(get_session),
):
"""Страница чатов текущего пользователя."""
limit = parse_limit(request.query_params.get("limit"))
scope = "chats:" + str(user.id)
after = position(parse_cursor(request.query_params.get("cursor"), scope))
chats, has_more = await crud.list_chats(session, user.id, after, limit)
members = await crud.get_member_ids(session, [chat.id for chat in chats])
next_cursor = cursor_for(scope, chats[-1]) if has_more and chats else None
return {
"items": [chat_out(c, members[c.id]) for c in chats],
"next_cursor": next_cursor,
}
@api.get("/chats/{chat_id}", response_model=ChatOut)
async def read_chat(
chat_id: str,
user: User = Depends(current_user),
session: AsyncSession = Depends(get_session),
):
"""Один чат по id."""
chat = await open_chat(session, user, chat_id)
members = await crud.get_member_ids(session, [chat.id])
return chat_out(chat, members[chat.id])
@api.post(
"/chats/{chat_id}/messages",
status_code=201,
response_model=MessageOut,
openapi_extra=body_doc(CreateMessageIn),
)
async def create_message(
chat_id: str,
request: Request,
user: User = Depends(current_user),
session: AsyncSession = Depends(get_session),
):
"""Отправить сообщение в чат."""
chat = await open_chat(session, user, chat_id)
body = validate_body(CreateMessageIn, await read_json_object(request))
message = await crud.create_message(session, chat.id, user.id, body.text)
return message_out(message)
@api.get("/chats/{chat_id}/messages", response_model=MessagePage)
async def list_messages(
chat_id: str,
request: Request,
user: User = Depends(current_user),
session: AsyncSession = Depends(get_session),
):
"""Страница истории чата."""
chat = await open_chat(session, user, chat_id)
limit = parse_limit(request.query_params.get("limit"))
scope = "messages:" + str(chat.id)
after = position(parse_cursor(request.query_params.get("cursor"), scope))
messages, has_more = await crud.list_messages(session, chat.id, after, limit)
next_cursor = cursor_for(scope, messages[-1]) if has_more and messages else None
return {"items": [message_out(m) for m in messages], "next_cursor": next_cursor}
+153
View File
@@ -0,0 +1,153 @@
"""Pydantic-модели тел запросов и ответов."""
import re
from typing import List, Optional
from pydantic import BaseModel, ConfigDict, field_validator
from .cursor import UUID_RE
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
def _check_text(value: str, name: str, max_len: int, allow_blank: bool = False) -> str:
"""Проверить строку: тип, длина в символах, не только пробелы, без NUL."""
try:
value.encode("utf-8")
except UnicodeEncodeError:
raise ValueError("%s содержит недопустимые символы" % name)
if "\x00" in value:
raise ValueError("%s не может содержать символ NUL" % name)
if not allow_blank and value.strip() == "":
raise ValueError("%s не может быть пустым или состоять из пробелов" % name)
if len(value) > max_len:
raise ValueError("%s длиннее %d символов" % (name, max_len))
return value
class _Strict(BaseModel):
"""База моделей запроса: лишние поля и приведение типов запрещены."""
model_config = ConfigDict(extra="forbid", strict=True)
class CreateUserIn(_Strict):
"""Тело регистрации."""
username: str
display_name: str
password: str
@field_validator("username")
@classmethod
def _username(cls, value: str) -> str:
"""username: [a-z0-9_]{3,32}."""
if not USERNAME_RE.fullmatch(value):
raise ValueError("username: только a-z, 0-9 и _, длина 3-32")
return value
@field_validator("display_name")
@classmethod
def _display_name(cls, value: str) -> str:
"""display_name: 1-100 символов."""
return _check_text(value, "display_name", 100)
@field_validator("password")
@classmethod
def _password(cls, value: str) -> str:
"""password: 12-128 символов, без обрезки пробелов."""
_check_text(value, "password", 128, allow_blank=True)
if len(value) < 12:
raise ValueError("password короче 12 символов")
return value
class CreateChatIn(_Strict):
"""Тело создания чата."""
title: str
member_ids: List[str]
@field_validator("title")
@classmethod
def _title(cls, value: str) -> str:
"""title: 1-100 символов."""
return _check_text(value, "title", 100)
@field_validator("member_ids")
@classmethod
def _members(cls, value: List[str]) -> List[str]:
"""member_ids: 1-100 уникальных UUID."""
if not 1 <= len(value) <= 100:
raise ValueError("member_ids: от 1 до 100 участников")
normalized = []
for item in value:
if not UUID_RE.fullmatch(item):
raise ValueError("member_ids: каждый элемент должен быть UUID")
normalized.append(item.lower())
if len(set(normalized)) != len(normalized):
raise ValueError("member_ids: дубликаты не допускаются")
return normalized
class CreateMessageIn(_Strict):
"""Тело сообщения; отправитель определяется по токену."""
text: str
@field_validator("text")
@classmethod
def _text(cls, value: str) -> str:
"""text: 1-4000 символов."""
return _check_text(value, "text", 4000)
class UserOut(BaseModel):
"""Пользователь в ответе."""
id: str
username: str
display_name: str
created_at: str
class SessionOut(BaseModel):
"""Ответ на вход."""
token: str
token_type: str
expires_at: str
user: UserOut
class ChatOut(BaseModel):
"""Чат в ответе."""
id: str
title: str
member_ids: List[str]
created_at: str
class MessageOut(BaseModel):
"""Сообщение в ответе."""
id: str
chat_id: str
sender_id: str
text: str
created_at: str
class ChatPage(BaseModel):
"""Страница списка чатов."""
items: List[ChatOut]
next_cursor: Optional[str]
class MessagePage(BaseModel):
"""Страница истории сообщений."""
items: List[MessageOut]
next_cursor: Optional[str]
+74
View File
@@ -0,0 +1,74 @@
"""Хеширование паролей (scrypt) и токены сессий."""
import asyncio
import base64
import hashlib
import hmac
import os
import secrets
SCRYPT_N = 2**14
SCRYPT_R = 8
SCRYPT_P = 1
SCRYPT_LEN = 32
def hash_password(password: str) -> str:
"""Хеш пароля scrypt со случайной солью в формате scrypt$N$r$p$соль$хеш."""
salt = os.urandom(16)
digest = hashlib.scrypt(
password.encode("utf-8"),
salt=salt,
n=SCRYPT_N,
r=SCRYPT_R,
p=SCRYPT_P,
dklen=SCRYPT_LEN,
)
return "scrypt$%d$%d$%d$%s$%s" % (
SCRYPT_N,
SCRYPT_R,
SCRYPT_P,
base64.b64encode(salt).decode(),
base64.b64encode(digest).decode(),
)
def verify_password(password: str, stored: str) -> bool:
"""Проверить пароль по сохранённому хешу за постоянное время."""
try:
_, n, r, p, salt_b64, hash_b64 = stored.split("$")
expected = base64.b64decode(hash_b64)
actual = hashlib.scrypt(
password.encode("utf-8"),
salt=base64.b64decode(salt_b64),
n=int(n),
r=int(r),
p=int(p),
dklen=len(expected),
)
except (ValueError, TypeError):
return False
return hmac.compare_digest(actual, expected)
DUMMY_HASH = hash_password("dummy-password-for-timing-only")
async def hash_password_async(password: str) -> str:
"""hash_password в отдельном потоке."""
return await asyncio.to_thread(hash_password, password)
async def verify_password_async(password: str, stored: str) -> bool:
"""verify_password в отдельном потоке."""
return await asyncio.to_thread(verify_password, password, stored)
def new_token() -> str:
"""Случайный токен сессии (256 бит)."""
return secrets.token_urlsafe(32)
def hash_token(token: str) -> str:
"""SHA-256 токена в hex."""
return hashlib.sha256(token.encode("utf-8")).hexdigest()
+20
View File
@@ -0,0 +1,20 @@
"""Преобразования времени: RFC 3339 UTC и микросекунды."""
from datetime import datetime, timedelta, timezone
EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
def format_ts(moment: datetime) -> str:
"""datetime -> строка RFC 3339 в UTC с суффиксом Z."""
return moment.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def to_micros(moment: datetime) -> int:
"""datetime -> микросекунды от эпохи."""
return (moment - EPOCH) // timedelta(microseconds=1)
def from_micros(micros: int) -> datetime:
"""Микросекунды от эпохи -> datetime в UTC."""
return EPOCH + timedelta(microseconds=micros)
+107
View File
@@ -0,0 +1,107 @@
name: mtusi-messenger
x-api-env: &api-env
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
LOG_LEVEL: ${LOG_LEVEL:-INFO}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: ${SESSION_STORE:-postgres}
DB_POOL_SIZE: ${DB_POOL_SIZE:-5}
DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:-5}
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-5}
DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}:${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}@db:5432/${POSTGRES_DB:?задайте POSTGRES_DB в файле .env}
CACHE_URL: ${CACHE_URL-redis://redis:6379/0}
CACHE_TTL_SECONDS: ${CACHE_TTL_SECONDS:-60}
CACHE_TIMEOUT_MS: ${CACHE_TIMEOUT_MS:-300}
CACHE_RETRY_SECONDS: ${CACHE_RETRY_SECONDS:-5}
services:
db:
image: postgres:16.6-bookworm
container_name: messenger-db
environment:
POSTGRES_USER: ${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
POSTGRES_DB: ${POSTGRES_DB:?задайте POSTGRES_DB в файле .env}
volumes:
- pgdata:/var/lib/postgresql/data
ports:
- "127.0.0.1:5433:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
redis:
image: redis:7.4.1-bookworm
container_name: messenger-redis
command:
- redis-server
- --save
- ""
- --appendonly
- "no"
- --maxmemory
- 64mb
- --maxmemory-policy
- noeviction
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
api:
build: .
image: mtusi-messenger:lab2
container_name: messenger-api
depends_on:
db:
condition: service_healthy
redis:
condition: service_started
required: false
environment: *api-env
ports:
- "127.0.0.1:8080:8080"
restart: unless-stopped
api-ttl:
profiles: ["expiry"]
build: .
image: mtusi-messenger:lab2
container_name: messenger-api-ttl
depends_on:
db:
condition: service_healthy
environment:
<<: *api-env
SESSION_TTL_SECONDS: "3"
ports:
- "127.0.0.1:8081:8080"
tests:
profiles: ["test"]
build:
context: .
target: test
image: mtusi-messenger:lab2-test
depends_on:
db:
condition: service_healthy
redis:
condition: service_healthy
environment:
TEST_DB_HOST: db
TEST_DB_PORT: "5432"
TEST_DB_USER: ${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}
TEST_DB_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
TEST_CACHE_URL: redis://redis:6379/15
command: ["python", "-m", "pytest", "-v", "--no-header", "-p", "no:cacheprovider"]
volumes:
pgdata:
+17
View File
@@ -0,0 +1,17 @@
POSTGRES_USER=messenger
POSTGRES_PASSWORD=ChangeMe123
POSTGRES_DB=messenger
APP_ENV=lab
LOG_LEVEL=INFO
SESSION_TTL_SECONDS=3600
SESSION_STORE=postgres
DB_POOL_SIZE=5
DB_MAX_OVERFLOW=5
DB_POOL_TIMEOUT=5
CACHE_URL=redis://redis:6379/0
CACHE_TTL_SECONDS=60
CACHE_TIMEOUT_MS=300
CACHE_RETRY_SECONDS=5
+8
View File
@@ -0,0 +1,8 @@
# Дата (UTC): 2026-10-23 10:17:04
# Commit: 65003b6
# Команда: python3 scripts/check_contract.py
# ---------------------------------------- вывод ----------------------------------------
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.06 с
+9
View File
@@ -0,0 +1,9 @@
# Дата (UTC): 2026-10-23 10:17:05
# Commit: 65003b6
# Команда: make test
# ---------------------------------------- вывод ----------------------------------------
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.58 с
+11
View File
@@ -0,0 +1,11 @@
# Дата (UTC): 2026-10-23 10:17:05
# Commit: 65003b6
# Команда: docker compose --env-file .env ps
# ---------------------------------------- вывод ----------------------------------------
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
messenger-api mtusi-messenger:lab2 "python -m app" api 24 seconds ago Up 18 seconds (healthy) 127.0.0.1:8080->8080/tcp
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 24 seconds ago Up 23 seconds (healthy) 127.0.0.1:5433->5432/tcp
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 24 seconds ago Up 23 seconds (healthy) 6379/tcp
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.07 с
+8
View File
@@ -0,0 +1,8 @@
# Дата (UTC): 2026-10-23 10:17:05
# Commit: 65003b6
# Команда: docker volume inspect mtusi-messenger_pgdata --format {{.Name}} created={{.CreatedAt}}
# ---------------------------------------- вывод ----------------------------------------
mtusi-messenger_pgdata created=2026-10-23T13:16:41+03:00
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.01 с
+10
View File
@@ -0,0 +1,10 @@
# Дата (UTC): 2026-10-23 10:17:14
# Commit: 65003b6
# Команда: 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.
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 9.13 с
+11
View File
@@ -0,0 +1,11 @@
# Дата (UTC): 2026-10-23 10:17:14
# Commit: 65003b6
# Команда: docker compose --env-file .env ps
# ---------------------------------------- вывод ----------------------------------------
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
messenger-api mtusi-messenger:lab2 "python -m app" api 33 seconds ago Up 1 second (health: starting) 127.0.0.1:8080->8080/tcp
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 33 seconds ago Up 7 seconds (healthy) 127.0.0.1:5433->5432/tcp
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 33 seconds ago Up 7 seconds (healthy) 6379/tcp
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.07 с
+8
View File
@@ -0,0 +1,8 @@
# Дата (UTC): 2026-10-23 10:17:14
# Commit: 65003b6
# Команда: docker volume inspect mtusi-messenger_pgdata --format {{.Name}} created={{.CreatedAt}}
# ---------------------------------------- вывод ----------------------------------------
mtusi-messenger_pgdata created=2026-10-23T13:16:41+03:00
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.01 с
+83
View File
@@ -0,0 +1,83 @@
# Дата (UTC): 2026-10-23 10:17:15
# Commit: 65003b6
# Команда: docker compose --env-file .env exec -T db psql -U messenger -d messenger -c \d users -c \d chats -c \d chat_members -c \d messages -c \d sessions
# ---------------------------------------- вывод ----------------------------------------
Table "public.users"
Column | Type | Collation | Nullable | Default
---------------+--------------------------+-----------+----------+-------------------
id | uuid | | not null |
username | text | | not null |
display_name | text | | not null |
password_hash | text | | not null |
created_at | timestamp with time zone | | not null | clock_timestamp()
Indexes:
"users_pkey" PRIMARY KEY, btree (id)
"users_username_key" UNIQUE CONSTRAINT, btree (username)
Check constraints:
"users_display_name_check" CHECK (char_length(display_name) >= 1 AND char_length(display_name) <= 100)
"users_username_check" CHECK (username ~ '^[a-z0-9_]{3,32}$'::text)
Referenced by:
TABLE "chat_members" CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
TABLE "messages" CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
TABLE "sessions" CONSTRAINT "sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
Table "public.chats"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+-------------------
id | uuid | | not null |
title | text | | not null |
created_at | timestamp with time zone | | not null | clock_timestamp()
Indexes:
"chats_pkey" PRIMARY KEY, btree (id)
"chats_created_idx" btree (created_at, id)
Check constraints:
"chats_title_check" CHECK (char_length(title) >= 1 AND char_length(title) <= 100)
Referenced by:
TABLE "chat_members" CONSTRAINT "chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
TABLE "messages" CONSTRAINT "messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
Table "public.chat_members"
Column | Type | Collation | Nullable | Default
---------+------+-----------+----------+---------
chat_id | uuid | | not null |
user_id | uuid | | not null |
Indexes:
"chat_members_pkey" PRIMARY KEY, btree (chat_id, user_id)
"chat_members_user_idx" btree (user_id, chat_id)
Foreign-key constraints:
"chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
Table "public.messages"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+-------------------
id | uuid | | not null |
chat_id | uuid | | not null |
sender_id | uuid | | not null |
text | text | | not null |
created_at | timestamp with time zone | | not null | clock_timestamp()
Indexes:
"messages_pkey" PRIMARY KEY, btree (id)
"messages_chat_created_idx" btree (chat_id, created_at, id)
Check constraints:
"messages_text_check" CHECK (char_length(text) >= 1 AND char_length(text) <= 4000)
Foreign-key constraints:
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
Table "public.sessions"
Column | Type | Collation | Nullable | Default
------------+--------------------------+-----------+----------+-------------------
token_hash | text | | not null |
user_id | uuid | | not null |
created_at | timestamp with time zone | | not null | clock_timestamp()
expires_at | timestamp with time zone | | not null |
Indexes:
"sessions_pkey" PRIMARY KEY, btree (token_hash)
"sessions_expires_idx" btree (expires_at)
"sessions_user_idx" btree (user_id)
Foreign-key constraints:
"sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.16 с
+8
View File
@@ -0,0 +1,8 @@
# Дата (UTC): 2026-10-23 10:17:16
# Commit: 65003b6
# Команда: docker compose --env-file .env exec -T api python -m app.migrate
# ---------------------------------------- вывод ----------------------------------------
Применено: ничего нового
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.98 с
+16
View File
@@ -0,0 +1,16 @@
# Дата (UTC): 2026-10-23 10:16:49
# Commit: 65003b6
# Команда: docker compose --env-file .env logs api
# ---------------------------------------- вывод ----------------------------------------
messenger-api | 2026-10-23T10:16:48+0000 INFO listen host=0.0.0.0 port=8080
messenger-api | INFO: Started server process [1]
messenger-api | INFO: Waiting for application startup.
messenger-api | 2026-10-23T10:16:48+0000 INFO config env=lab pool=5+5 ttl=3600s store=postgres cache=redis
messenger-api | 2026-10-23T10:16:48+0000 INFO migrations: 0001_init.sql
messenger-api | 2026-10-23T10:16:48+0000 INFO startup: приложение готово
messenger-api | INFO: Application startup complete.
messenger-api | INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)
messenger-api | 2026-10-23T10:16:49+0000 INFO request request_id=4933db77a1c84e3197e740dc2e11d0f1 method=GET path=/health/ready status=200 duration_ms=14.7
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.07 с
+11
View File
@@ -0,0 +1,11 @@
# Дата (UTC): 2026-10-23 10:17:16
# Commit: 65003b6
# Команда: docker compose --env-file .env exec -T db psql -U messenger -d messenger -c SELECT * FROM schema_migrations
# ---------------------------------------- вывод ----------------------------------------
version | applied_at
---------------+-------------------------------
0001_init.sql | 2026-10-23 10:16:48.774351+00
(1 row)
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.13 с
+20
View File
@@ -0,0 +1,20 @@
# Дата (UTC): 2026-10-23 10:17:16
# Commit: 65003b6
# Команда: docker compose --env-file .env exec -T db psql -U messenger -d messenger -c SELECT username, left(password_hash, 7) AS password_prefix, length(password_hash) AS len FROM users WHERE password_hash LIKE 'scrypt$%' LIMIT 3 -c SELECT length(token_hash) AS token_hash_len, expires_at FROM sessions LIMIT 3
# ---------------------------------------- вывод ----------------------------------------
username | password_prefix | len
----------------------+-----------------+-----
u_alice_cbe058671fcd | scrypt$ | 86
u_bob_b1685b095bab | scrypt$ | 86
u_eve_1f0c444128f3 | scrypt$ | 86
(3 rows)
token_hash_len | expires_at
----------------+-------------------------------
64 | 2026-10-23 11:17:05.128109+00
64 | 2026-10-23 11:17:05.223716+00
64 | 2026-10-23 11:17:05.789433+00
(3 rows)
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.13 с
+64
View File
@@ -0,0 +1,64 @@
# Дата (UTC): 2026-10-23 10:17:28
# Commit: 65003b6
# Команда: docker compose --env-file .env --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider student-tests/test_auth.py student-tests/test_session_expiry.py
# ---------------------------------------- вывод ----------------------------------------
============================= test session starts ==============================
collecting ... collected 38 items
student-tests/test_auth.py::test_register_returns_user_without_secrets PASSED [ 2%]
student-tests/test_auth.py::test_register_password_rules[None] PASSED [ 5%]
student-tests/test_auth.py::test_register_password_rules[] PASSED [ 7%]
student-tests/test_auth.py::test_register_password_rules[short] PASSED [ 10%]
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaa] PASSED [ 13%]
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] PASSED [ 15%]
student-tests/test_auth.py::test_register_password_rules[123456789012] PASSED [ 18%]
student-tests/test_auth.py::test_register_password_rules[\u043f\u0430\u0440\u043e\u043b\u044c] PASSED [ 21%]
student-tests/test_auth.py::test_register_password_border_lengths PASSED [ 23%]
student-tests/test_auth.py::test_login_success_shape PASSED [ 26%]
student-tests/test_auth.py::test_each_login_gives_new_token PASSED [ 28%]
student-tests/test_auth.py::test_wrong_password_and_unknown_user_look_the_same PASSED [ 31%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic] PASSED [ 34%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic !!!not-base64!!!] PASSED [ 36%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic bm9jb2xvbg==] PASSED [ 39%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic 0LjQvNGPOnBhc3N3b3JkLTEyMzQ1Ng==] PASSED [ 42%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic dXNlcjr//i1iYWQtdXRmOA==] PASSED [ 44%]
student-tests/test_auth.py::test_malformed_basic_is_401[Bearer abc] PASSED [ 47%]
student-tests/test_auth.py::test_malformed_basic_is_401[] PASSED [ 50%]
student-tests/test_auth.py::test_login_without_header_is_401 PASSED [ 52%]
student-tests/test_auth.py::test_password_with_colon_and_unicode_works PASSED [ 55%]
student-tests/test_auth.py::test_bearer_token_gives_access PASSED [ 57%]
student-tests/test_auth.py::test_business_endpoint_rejects_basic PASSED [ 60%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[] PASSED [ 63%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer] PASSED [ 65%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer short] PASSED [ 68%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] PASSED [ 71%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Token abc] PASSED [ 73%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[bearer] PASSED [ 76%]
student-tests/test_auth.py::test_x_user_id_alone_gives_no_access PASSED [ 78%]
student-tests/test_auth.py::test_x_user_id_does_not_change_owner_of_session PASSED [ 81%]
student-tests/test_auth.py::test_logout_revokes_token_and_repeat_is_401 PASSED [ 84%]
student-tests/test_auth.py::test_logout_without_token_is_401 PASSED [ 86%]
student-tests/test_auth.py::test_logout_revokes_only_current_session PASSED [ 89%]
student-tests/test_auth.py::test_session_lives_longer_than_300_seconds PASSED [ 92%]
student-tests/test_session_expiry.py::test_session_expires_after_ttl PASSED [ 94%]
student-tests/test_session_expiry.py::test_expired_sessions_are_cleaned_on_next_login PASSED [ 97%]
student-tests/test_session_expiry.py::test_short_ttl_from_environment_variable PASSED [100%]
=============================== warnings summary ===============================
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
from starlette.testclient import TestClient as TestClient # noqa
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
======================== 38 passed, 1 warning in 8.97s =========================
Container messenger-db Running
Container messenger-redis Running
Container messenger-db Waiting
Container messenger-redis Waiting
Container messenger-redis Healthy
Container messenger-db Healthy
Container mtusi-messenger-tests-run-5a33a2ea2bbb Creating
Container mtusi-messenger-tests-run-5a33a2ea2bbb Created
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 12.15 с
+45
View File
@@ -0,0 +1,45 @@
# Дата (UTC): 2026-10-23 10:17:35
# Commit: 65003b6
# Команда: docker compose --env-file .env --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider student-tests/test_database.py student-tests/test_db_failure.py student-tests/test_transactions.py student-tests/test_duplicate_username.py
# ---------------------------------------- вывод ----------------------------------------
============================= test session starts ==============================
collecting ... collected 19 items
student-tests/test_database.py::test_password_is_stored_as_scrypt_hash_not_plaintext PASSED [ 5%]
student-tests/test_database.py::test_same_password_gives_different_hashes PASSED [ 10%]
student-tests/test_database.py::test_session_table_keeps_token_hash_not_token PASSED [ 15%]
student-tests/test_database.py::test_message_is_really_in_the_database PASSED [ 21%]
student-tests/test_database.py::test_migrations_can_run_again_without_duplicating_anything PASSED [ 26%]
student-tests/test_database.py::test_expected_tables_and_indexes_exist PASSED [ 31%]
student-tests/test_database.py::test_primary_and_foreign_keys_are_declared PASSED [ 36%]
student-tests/test_database.py::test_database_itself_rejects_bad_rows PASSED [ 42%]
student-tests/test_database.py::test_chat_creation_is_atomic PASSED [ 47%]
student-tests/test_database.py::test_successful_chat_has_all_members_in_database PASSED [ 52%]
student-tests/test_db_failure.py::test_database_down_gives_503_and_never_trusts_anyone PASSED [ 57%]
student-tests/test_db_failure.py::test_database_down_with_cache_up_still_needs_database_for_data PASSED [ 63%]
student-tests/test_transactions.py::test_failure_after_chat_insert_rolls_back_whole_operation PASSED [ 68%]
student-tests/test_transactions.py::test_pool_is_bounded_by_settings PASSED [ 73%]
student-tests/test_transactions.py::test_exhausted_pool_gives_fast_503 PASSED [ 78%]
student-tests/test_duplicate_username.py::test_second_registration_with_same_username_is_409 PASSED [ 84%]
student-tests/test_duplicate_username.py::test_duplicate_does_not_replace_original_user PASSED [ 89%]
student-tests/test_duplicate_username.py::test_username_is_case_sensitive_lowercase_only PASSED [ 94%]
student-tests/test_duplicate_username.py::test_parallel_registration_of_same_username_creates_exactly_one PASSED [100%]
=============================== warnings summary ===============================
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
from starlette.testclient import TestClient as TestClient # noqa
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
======================== 19 passed, 1 warning in 3.91s =========================
Container messenger-redis Running
Container messenger-db Running
Container messenger-db Waiting
Container messenger-redis Waiting
Container messenger-db Healthy
Container messenger-redis Healthy
Container mtusi-messenger-tests-run-28da14e927b9 Creating
Container mtusi-messenger-tests-run-28da14e927b9 Created
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 7.04 с
+179
View File
@@ -0,0 +1,179 @@
# Дата (UTC): 2026-10-23 10:18:12
# Commit: 65003b6
# Команда: docker compose --env-file .env --profile test run --rm tests
# ---------------------------------------- вывод ----------------------------------------
============================= test session starts ==============================
collecting ... collected 153 items
student-tests/test_auth.py::test_register_returns_user_without_secrets PASSED [ 0%]
student-tests/test_auth.py::test_register_password_rules[None] PASSED [ 1%]
student-tests/test_auth.py::test_register_password_rules[] PASSED [ 1%]
student-tests/test_auth.py::test_register_password_rules[short] PASSED [ 2%]
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaa] PASSED [ 3%]
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] PASSED [ 3%]
student-tests/test_auth.py::test_register_password_rules[123456789012] PASSED [ 4%]
student-tests/test_auth.py::test_register_password_rules[\u043f\u0430\u0440\u043e\u043b\u044c] PASSED [ 5%]
student-tests/test_auth.py::test_register_password_border_lengths PASSED [ 5%]
student-tests/test_auth.py::test_login_success_shape PASSED [ 6%]
student-tests/test_auth.py::test_each_login_gives_new_token PASSED [ 7%]
student-tests/test_auth.py::test_wrong_password_and_unknown_user_look_the_same PASSED [ 7%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic] PASSED [ 8%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic !!!not-base64!!!] PASSED [ 9%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic bm9jb2xvbg==] PASSED [ 9%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic 0LjQvNGPOnBhc3N3b3JkLTEyMzQ1Ng==] PASSED [ 10%]
student-tests/test_auth.py::test_malformed_basic_is_401[Basic dXNlcjr//i1iYWQtdXRmOA==] PASSED [ 11%]
student-tests/test_auth.py::test_malformed_basic_is_401[Bearer abc] PASSED [ 11%]
student-tests/test_auth.py::test_malformed_basic_is_401[] PASSED [ 12%]
student-tests/test_auth.py::test_login_without_header_is_401 PASSED [ 13%]
student-tests/test_auth.py::test_password_with_colon_and_unicode_works PASSED [ 13%]
student-tests/test_auth.py::test_bearer_token_gives_access PASSED [ 14%]
student-tests/test_auth.py::test_business_endpoint_rejects_basic PASSED [ 15%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[] PASSED [ 15%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer] PASSED [ 16%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer short] PASSED [ 16%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] PASSED [ 17%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Token abc] PASSED [ 18%]
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[bearer] PASSED [ 18%]
student-tests/test_auth.py::test_x_user_id_alone_gives_no_access PASSED [ 19%]
student-tests/test_auth.py::test_x_user_id_does_not_change_owner_of_session PASSED [ 20%]
student-tests/test_auth.py::test_logout_revokes_token_and_repeat_is_401 PASSED [ 20%]
student-tests/test_auth.py::test_logout_without_token_is_401 PASSED [ 21%]
student-tests/test_auth.py::test_logout_revokes_only_current_session PASSED [ 22%]
student-tests/test_auth.py::test_session_lives_longer_than_300_seconds PASSED [ 22%]
student-tests/test_cache.py::test_token_check_is_served_from_cache_with_bounded_ttl PASSED [ 23%]
student-tests/test_cache.py::test_cache_never_stores_raw_tokens_or_passwords PASSED [ 24%]
student-tests/test_cache.py::test_logout_revokes_cached_session PASSED [ 24%]
student-tests/test_cache.py::test_late_cache_fill_cannot_resurrect_revoked_session PASSED [ 25%]
student-tests/test_cache.py::test_flushed_cache_loses_nothing PASSED [ 26%]
student-tests/test_cache.py::test_cache_does_not_extend_short_session PASSED [ 26%]
student-tests/test_cache.py::test_staleness_after_out_of_band_delete_is_bounded_by_cache_ttl PASSED [ 27%]
student-tests/test_cache.py::test_redis_down_requests_bypass_cache_and_stay_fast PASSED [ 28%]
student-tests/test_cache.py::test_redis_down_never_trusts_anonymous_or_unknown_tokens PASSED [ 28%]
student-tests/test_cache.py::test_revocation_lost_while_redis_down_is_flushed_on_recovery PASSED [ 29%]
student-tests/test_cache.py::test_without_cache_url_cache_is_off PASSED [ 30%]
student-tests/test_concurrency.py::test_100_messages_from_10_clients_in_parallel PASSED [ 30%]
student-tests/test_concurrency.py::test_parallel_chat_creation_and_reading PASSED [ 31%]
student-tests/test_contract_basics.py::test_health_endpoints PASSED [ 32%]
student-tests/test_contract_basics.py::test_every_response_has_unique_request_id PASSED [ 32%]
student-tests/test_contract_basics.py::test_unknown_path_is_404_in_common_format PASSED [ 33%]
student-tests/test_contract_basics.py::test_trailing_slash_is_not_redirected PASSED [ 33%]
student-tests/test_contract_basics.py::test_wrong_method_is_405_in_common_format PASSED [ 34%]
student-tests/test_contract_basics.py::test_two_users_one_chat_two_messages PASSED [ 35%]
student-tests/test_contract_basics.py::test_chat_response_shape PASSED [ 35%]
student-tests/test_contract_basics.py::test_unexpected_exception_gives_500_without_details PASSED [ 36%]
student-tests/test_contract_basics.py::test_logs_have_requests_but_no_secrets PASSED [ 37%]
student-tests/test_database.py::test_password_is_stored_as_scrypt_hash_not_plaintext PASSED [ 37%]
student-tests/test_database.py::test_same_password_gives_different_hashes PASSED [ 38%]
student-tests/test_database.py::test_session_table_keeps_token_hash_not_token PASSED [ 39%]
student-tests/test_database.py::test_message_is_really_in_the_database PASSED [ 39%]
student-tests/test_database.py::test_migrations_can_run_again_without_duplicating_anything PASSED [ 40%]
student-tests/test_database.py::test_expected_tables_and_indexes_exist PASSED [ 41%]
student-tests/test_database.py::test_primary_and_foreign_keys_are_declared PASSED [ 41%]
student-tests/test_database.py::test_database_itself_rejects_bad_rows PASSED [ 42%]
student-tests/test_database.py::test_chat_creation_is_atomic PASSED [ 43%]
student-tests/test_database.py::test_successful_chat_has_all_members_in_database PASSED [ 43%]
student-tests/test_db_failure.py::test_database_down_gives_503_and_never_trusts_anyone PASSED [ 44%]
student-tests/test_db_failure.py::test_database_down_with_cache_up_still_needs_database_for_data PASSED [ 45%]
student-tests/test_duplicate_username.py::test_second_registration_with_same_username_is_409 PASSED [ 45%]
student-tests/test_duplicate_username.py::test_duplicate_does_not_replace_original_user PASSED [ 46%]
student-tests/test_duplicate_username.py::test_username_is_case_sensitive_lowercase_only PASSED [ 47%]
student-tests/test_duplicate_username.py::test_parallel_registration_of_same_username_creates_exactly_one PASSED [ 47%]
student-tests/test_empty_message.py::test_blank_text_is_rejected[] PASSED [ 48%]
student-tests/test_empty_message.py::test_blank_text_is_rejected[ ] PASSED [ 49%]
student-tests/test_empty_message.py::test_blank_text_is_rejected[ ] PASSED [ 49%]
student-tests/test_empty_message.py::test_blank_text_is_rejected[\n] PASSED [ 50%]
student-tests/test_empty_message.py::test_blank_text_is_rejected[\t \n] PASSED [ 50%]
student-tests/test_empty_message.py::test_blank_text_is_rejected[\xa0] PASSED [ 51%]
student-tests/test_empty_message.py::test_blank_text_is_rejected[\u2003] PASSED [ 52%]
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body0] PASSED [ 52%]
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body1] PASSED [ 53%]
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body2] PASSED [ 54%]
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body3] PASSED [ 54%]
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body4] PASSED [ 55%]
student-tests/test_empty_message.py::test_text_length_is_counted_in_characters PASSED [ 56%]
student-tests/test_empty_message.py::test_nul_character_is_400_not_500 PASSED [ 56%]
student-tests/test_empty_message.py::test_unicode_survives_the_database PASSED [ 57%]
student-tests/test_empty_message.py::test_message_has_correct_fields PASSED [ 58%]
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[0] PASSED [ 58%]
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[9000] PASSED [ 59%]
student-tests/test_foreign_chat.py::test_outsider_cannot_read_chat PASSED [ 60%]
student-tests/test_foreign_chat.py::test_outsider_cannot_read_history PASSED [ 60%]
student-tests/test_foreign_chat.py::test_outsider_cannot_write PASSED [ 61%]
student-tests/test_foreign_chat.py::test_outsider_gets_404_even_with_bad_body PASSED [ 62%]
student-tests/test_foreign_chat.py::test_unknown_chat_looks_the_same_as_foreign PASSED [ 62%]
student-tests/test_foreign_chat.py::test_chat_list_shows_only_own_chats PASSED [ 63%]
student-tests/test_foreign_chat.py::test_bad_chat_id_is_400 PASSED [ 64%]
student-tests/test_foreign_chat.py::test_no_token_is_401_everywhere PASSED [ 64%]
student-tests/test_foreign_chat.py::test_401_comes_before_404 PASSED [ 65%]
student-tests/test_foreign_chat.py::test_member_can_read_and_write PASSED [ 66%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[{] PASSED [ 66%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[not json at all] PASSED [ 67%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[] PASSED [ 67%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[{"username": "abc",}] PASSED [ 68%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[\xff\xfe\x00] PASSED [ 69%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[{"username": NaN}] PASSED [ 69%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[["username"]] PASSED [ 70%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json["text"] PASSED [ 71%]
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[null] PASSED [ 71%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes0] PASSED [ 72%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes1] PASSED [ 73%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes2] PASSED [ 73%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes3] PASSED [ 74%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes4] PASSED [ 75%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes5] PASSED [ 75%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes6] PASSED [ 76%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes7] PASSED [ 77%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes8] PASSED [ 77%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes9] PASSED [ 78%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes10] PASSED [ 79%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes11] PASSED [ 79%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes12] PASSED [ 80%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes13] PASSED [ 81%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes14] PASSED [ 81%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes15] PASSED [ 82%]
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes16] PASSED [ 83%]
student-tests/test_invalid_json.py::test_border_values_are_accepted PASSED [ 83%]
student-tests/test_invalid_json.py::test_lone_surrogate_is_400_not_500 PASSED [ 84%]
student-tests/test_invalid_json.py::test_wrong_or_missing_content_type_is_415 PASSED [ 84%]
student-tests/test_invalid_json.py::test_huge_body_is_413 PASSED [ 85%]
student-tests/test_invalid_json.py::test_broken_json_in_message_and_chat PASSED [ 86%]
student-tests/test_invalid_json.py::test_sender_id_in_message_is_rejected PASSED [ 86%]
student-tests/test_invalid_json.py::test_chat_body_validation PASSED [ 87%]
student-tests/test_pagination.py::test_walk_25_messages_by_7 PASSED [ 88%]
student-tests/test_pagination.py::test_exact_multiple_has_no_empty_extra_page PASSED [ 88%]
student-tests/test_pagination.py::test_limit_one_walks_everything PASSED [ 89%]
student-tests/test_pagination.py::test_default_limit_is_50_and_max_is_100 PASSED [ 90%]
student-tests/test_pagination.py::test_empty_history PASSED [ 90%]
student-tests/test_pagination.py::test_limit_can_change_between_pages PASSED [ 91%]
student-tests/test_pagination.py::test_messages_sent_during_walk_appear_at_the_end PASSED [ 92%]
student-tests/test_pagination.py::test_created_at_is_increasing_and_utc PASSED [ 92%]
student-tests/test_pagination.py::test_bad_limit_values PASSED [ 93%]
student-tests/test_pagination.py::test_garbage_cursor_is_400 PASSED [ 94%]
student-tests/test_pagination.py::test_cursor_from_another_chat_is_400 PASSED [ 94%]
student-tests/test_pagination.py::test_chat_list_pagination PASSED [ 95%]
student-tests/test_pagination.py::test_chat_list_cursor_cannot_be_used_for_messages PASSED [ 96%]
student-tests/test_session_expiry.py::test_session_expires_after_ttl PASSED [ 96%]
student-tests/test_session_expiry.py::test_expired_sessions_are_cleaned_on_next_login PASSED [ 97%]
student-tests/test_session_expiry.py::test_short_ttl_from_environment_variable PASSED [ 98%]
student-tests/test_transactions.py::test_failure_after_chat_insert_rolls_back_whole_operation PASSED [ 98%]
student-tests/test_transactions.py::test_pool_is_bounded_by_settings PASSED [ 99%]
student-tests/test_transactions.py::test_exhausted_pool_gives_fast_503 PASSED [100%]
=============================== warnings summary ===============================
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
from starlette.testclient import TestClient as TestClient # noqa
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
======================= 153 passed, 1 warning in 33.55s ========================
Container messenger-db Running
Container messenger-redis Running
Container messenger-redis Waiting
Container messenger-db Waiting
Container messenger-redis Healthy
Container messenger-db Healthy
Container mtusi-messenger-tests-run-27b6c4db6282 Creating
Container mtusi-messenger-tests-run-27b6c4db6282 Created
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 36.72 с
+10
View File
@@ -0,0 +1,10 @@
# Дата (UTC): 2026-10-23 10:18:12
# Commit: 65003b6
# Команда: grep -n -i password\|secret compose.yaml
# ---------------------------------------- вывод ----------------------------------------
13: DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}:${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}@db:5432/${POSTGRES_DB:?задайте POSTGRES_DB в файле .env}
25: POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
102: TEST_DB_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.00 с
+113
View File
@@ -0,0 +1,113 @@
# Дата (UTC): 2026-10-23 10:18:12
# Commit: 65003b6
# Команда: git ls-files --cached --others --exclude-standard
# ---------------------------------------- вывод ----------------------------------------
Dockerfile
EVIDENCE.md
GUIDE.md
OPERATIONS.md
app/__init__.py
app/__main__.py
app/auth.py
app/cache.py
app/config.py
app/crud.py
app/cursor.py
app/db.py
app/errors.py
app/explain.py
app/healthcheck.py
app/http_utils.py
app/logging_setup.py
app/main.py
app/middleware.py
app/migrate.py
app/migrations/0001_init.sql
app/models.py
app/routes.py
app/schemas.py
app/security.py
app/timeutil.py
compose.yaml
env.lab2.template
evidence/01_check_contract.txt
evidence/02_smoke.txt
evidence/03_ps_before.txt
evidence/03_volume_before.txt
evidence/04_persistence.txt
evidence/05_ps_after.txt
evidence/05_volume_after.txt
evidence/06_schema.txt
evidence/07_migrations.txt
evidence/07_migrations_first.txt
evidence/07_migrations_table.txt
evidence/08_hashes.txt
evidence/09_auth_tests.txt
evidence/10_database_tests.txt
evidence/11_all_tests.txt
evidence/12_compose_no_secrets.txt
evidence/12_git_files.txt
evidence/12_git_secrets.txt
evidence/13_storage.txt
evidence/14_dependencies.txt
evidence/15_explain.txt
evidence/15_explain_tests.txt
evidence/16_expiry_live.txt
pytest.ini
requirements-test.txt
requirements.txt
scripts/check_expiry.py
scripts/collect_evidence.sh
scripts/dependency_demo.py
scripts/restart.bat
scripts/restart.sh
scripts/run_and_save.py
scripts/storage_demo.py
student-tests/conftest.py
student-tests/test_auth.py
student-tests/test_cache.py
student-tests/test_concurrency.py
student-tests/test_contract_basics.py
student-tests/test_database.py
student-tests/test_db_failure.py
student-tests/test_duplicate_username.py
student-tests/test_empty_message.py
student-tests/test_explain.py
student-tests/test_foreign_chat.py
student-tests/test_invalid_json.py
student-tests/test_pagination.py
student-tests/test_session_expiry.py
student-tests/test_transactions.py
.dockerignore
.env.example
.github/pull_request_template.md
.github/workflows/contracts.yml
.gitignore
CONTRIBUTING.md
COURSE.md
Dockerfile.example
MAINTAINERS.md
Makefile
README.md
REPORT.md
compose.example.yaml
contracts/README.md
contracts/examples.json
contracts/infrastructure.json
contracts/openapi.json
evidence/README.md
examples/requests.http
infra/README.md
lab.json
requirements-dev.txt
scripts/check_contract.py
scripts/restart.example.sh
scripts/validate_openapi.py
tests/README.md
tests/client.py
tests/load.py
tests/resilience.py
tests/smoke.py
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.00 с
+8
View File
@@ -0,0 +1,8 @@
# Дата (UTC): 2026-10-23 10:18:12
# Commit: 65003b6
# Команда: git check-ignore -v .env
# ---------------------------------------- вывод ----------------------------------------
.gitignore:2:.env .env
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 0.00 с
+194
View File
@@ -0,0 +1,194 @@
# Дата (UTC): 2026-10-23 10:18:23
# Commit: 65003b6
# Команда: python scripts/storage_demo.py --mode down
==============================================================================
1. Как устроено приложение
==============================================================================
Приложение -- мессенджер: HTTP API (FastAPI), PostgreSQL и Redis (кэш сессий).
* Сам API состояния не хранит: пользователи, чаты, участники, сообщения и сессии
лежат в PostgreSQL (таблицы users, chats, chat_members, messages, sessions).
* Файлы PostgreSQL лежат не в контейнере, а в именованном томе Docker (pgdata).
Контейнеры api и db временные, том постоянный.
* Пароль хранится как scrypt-хеш, у сессии в БД лежит только SHA-256 токена,
срок сессии считает сама БД -- перезапуск его не продлевает и не сбрасывает.
* Redis только кэширует проверку токена (без persistence): после перезапуска
кэш пуст, и сессии читаются из PostgreSQL.
Ожидание: пока том не удалён (команда down -v здесь НЕ используется), после
удаления и повторного создания контейнеров (docker compose down, затем up -d)
те же пользователи, чат, сообщение и тот же токен продолжают работать.
План: (1) создать данные через API, (2) показать их в БД, (3) выключить,
(4) включить, (5) проверить, что данные и токены прежние.
==============================================================================
2. Состояние до начала
==============================================================================
$ docker compose --env-file .env ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
messenger-api mtusi-messenger:lab2 "python -m app" api About a minute ago Up 59 seconds (healthy) 127.0.0.1:8080->8080/tcp
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db About a minute ago Up About a minute (healthy) 127.0.0.1:5433->5432/tcp
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis About a minute ago Up About a minute (healthy) 6379/tcp
$ docker volume ls --filter name=pgdata --format {{.Name}}
mtusi-messenger_pgdata
$ docker volume inspect mtusi-messenger_pgdata --format "{{.Name}} создан: {{.CreatedAt}}"
mtusi-messenger_pgdata создан: 2026-10-23T13:16:41+03:00
==============================================================================
3. Запись данных через API (создаём пользователей, чат, сообщение)
==============================================================================
$ POST /api/v1/users # регистрация Алисы
тело запроса: {"username": "demo_a_7681083c", "display_name": "Алиса", "password": "***"}
ответ: 201 {"id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "username": "demo_a_7681083c", "display_name": "Алиса", "created_at": "2026-10-23T10:18:12.849116Z"}
$ POST /api/v1/users # регистрация Боба
тело запроса: {"username": "demo_b_7681083c", "display_name": "Боб", "password": "***"}
ответ: 201 {"id": "2c34c828-f3c2-46ae-8055-bfaa49de3789", "username": "demo_b_7681083c", "display_name": "Боб", "created_at": "2026-10-23T10:18:12.903720Z"}
$ POST /api/v1/auth/sessions # вход Алисы (Basic)
ответ: 201 {"token": "<скрыт, 43 симв.>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:12.910850Z", "user": {"id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "username": "demo_a_7681083c", "display_name": "Алиса", "created_at": "2026-10-23T10:18:12.849116Z"}}
$ POST /api/v1/auth/sessions # вход Боба (Basic)
ответ: 201 {"token": "<скрыт, 43 симв.>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:12.961660Z", "user": {"id": "2c34c828-f3c2-46ae-8055-bfaa49de3789", "username": "demo_b_7681083c", "display_name": "Боб", "created_at": "2026-10-23T10:18:12.903720Z"}}
$ POST /api/v1/chats # чат Алисы и Боба (Bearer)
тело запроса: {"title": "Проверка сохранности 7681083c", "member_ids": ["a0fce947-1cb5-4780-ba66-daddb74fadea", "2c34c828-f3c2-46ae-8055-bfaa49de3789"]}
ответ: 201 {"id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "title": "Проверка сохранности 7681083c", "member_ids": ["2c34c828-f3c2-46ae-8055-bfaa49de3789", "a0fce947-1cb5-4780-ba66-daddb74fadea"], "created_at": "2026-10-23T10:18:13.013118Z"}
$ POST /api/v1/chats/051a293a-c75d-45f5-b4ab-7e24ef0833f4/messages # сообщение Алисы
тело запроса: {"text": "Это сообщение должно пережить перезапуск 7681083c"}
ответ: 201 {"id": "8d7c0e89-8043-413d-b3f0-d6bca0062b3e", "chat_id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "sender_id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "text": "Это сообщение должно пережить перезапуск 7681083c", "created_at": "2026-10-23T10:18:13.025076Z"}
==============================================================================
4. Что лежит в PostgreSQL ДО выключения (SELECT внутри контейнера db)
==============================================================================
-- пользователи (пароль -- только префикс хеша)
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at FROM users WHERE username IN ('demo_a_7681083c', 'demo_b_7681083c') ORDER BY username"
username | display_name | password_prefix | created_at
-----------------+--------------+-----------------+-------------------------------
demo_a_7681083c | Алиса | scrypt$ | 2026-10-23 10:18:12.849116+00
demo_b_7681083c | Боб | scrypt$ | 2026-10-23 10:18:12.90372+00
(2 rows)
-- чат и число участников
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT c.title, count(m.user_id) AS members FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4' GROUP BY c.title"
title | members
-------------------------------+---------
Проверка сохранности 7681083c | 2
(1 row)
-- сообщение
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4'"
id | sender_id | text | created_at
--------------------------------------+--------------------------------------+---------------------------------------------------+-------------------------------
8d7c0e89-8043-413d-b3f0-d6bca0062b3e | a0fce947-1cb5-4780-ba66-daddb74fadea | Это сообщение должно пережить перезапуск 7681083c | 2026-10-23 10:18:13.025076+00
(1 row)
-- действующие сессии (токены не показываем)
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id WHERE u.username IN ('demo_a_7681083c', 'demo_b_7681083c') AND s.expires_at > now()"
live_sessions
---------------
2
(1 row)
==============================================================================
5. Выключаем приложение (контейнеры УДАЛЯЮТСЯ, том остаётся)
==============================================================================
$ docker compose --env-file .env down
Container messenger-api Stopping
Container messenger-api Stopped
Container messenger-api Removing
Container messenger-api Removed
Container messenger-db Stopping
Container messenger-redis Stopping
Container messenger-redis Stopped
Container messenger-redis Removing
Container messenger-redis Removed
Container messenger-db Stopped
Container messenger-db Removing
Container messenger-db Removed
Network mtusi-messenger_default Removing
Network mtusi-messenger_default Removed
$ docker compose --env-file .env ps -a
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
API на http://localhost:8080 не отвечает -- приложение выключено (так и должно быть).
-- том с данными на месте:
$ docker volume ls --filter name=pgdata
DRIVER VOLUME NAME
local mtusi-messenger_pgdata
==============================================================================
6. Включаем снова
==============================================================================
$ docker compose --env-file .env up -d
Network mtusi-messenger_default Creating
Network mtusi-messenger_default Creating
Network mtusi-messenger_default Created
Network mtusi-messenger_default Created
Container messenger-db Creating
Container messenger-redis Creating
Container messenger-redis Created
Container messenger-db Created
Container messenger-api Creating
Container messenger-api Created
Container messenger-db Starting
Container messenger-redis Starting
Container messenger-db Started
Container messenger-redis Started
Container messenger-db Waiting
Container messenger-db Healthy
Container messenger-api Starting
Container messenger-api Started
API снова готов (/health/ready = 200) через 2 с.
$ docker compose --env-file .env ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
messenger-api mtusi-messenger:lab2 "python -m app" api 7 seconds ago Up 2 seconds (health: starting) 127.0.0.1:8080->8080/tcp
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 7 seconds ago Up 7 seconds (healthy) 127.0.0.1:5433->5432/tcp
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 7 seconds ago Up 7 seconds (healthy) 6379/tcp
==============================================================================
7. Проверка ПОСЛЕ перезапуска: те же данные и те же токены
==============================================================================
$ GET /api/v1/users/me # старый токен Алисы, повторный вход НЕ делали
ответ: 200 {"id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "username": "demo_a_7681083c", "display_name": "Алиса", "created_at": "2026-10-23T10:18:12.849116Z"}
OK: тот же пользователь (id, username, created_at совпали).
$ GET /api/v1/chats/051a293a-c75d-45f5-b4ab-7e24ef0833f4/messages # старый токен Боба читает историю чата
ответ: 200 {"items": [{"id": "8d7c0e89-8043-413d-b3f0-d6bca0062b3e", "chat_id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "sender_id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "text": "Это сообщение должно пережить перезапуск 7681083c", "created_at": "2026-10-23T10:18:13.025076Z"}], "next_cursor": null}
OK: то же сообщение (id, text, created_at совпали).
$ GET /api/v1/chats?limit=100 # список чатов Алисы
ответ: 200 {"items": [{"id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "title": "Проверка сохранности 7681083c", "member_ids": ["2c34c828-f3c2-46ae-8055-bfaa49de3789", "a0fce947-1cb5-4780-ba66-daddb74fadea"], "created_at": "2026-10-23T10:18:13.013118Z"}], "next_cursor": null}
OK: чат в списке.
Те же SELECT после перезапуска (сравниваем с выводом из пункта 4):
-- пользователи (пароль -- только префикс хеша)
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at FROM users WHERE username IN ('demo_a_7681083c', 'demo_b_7681083c') ORDER BY username"
username | display_name | password_prefix | created_at
-----------------+--------------+-----------------+-------------------------------
demo_a_7681083c | Алиса | scrypt$ | 2026-10-23 10:18:12.849116+00
demo_b_7681083c | Боб | scrypt$ | 2026-10-23 10:18:12.90372+00
(2 rows)
OK: вывод идентичен выводу до перезапуска.
-- чат и число участников
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT c.title, count(m.user_id) AS members FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4' GROUP BY c.title"
title | members
-------------------------------+---------
Проверка сохранности 7681083c | 2
(1 row)
OK: вывод идентичен выводу до перезапуска.
-- сообщение
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4'"
id | sender_id | text | created_at
--------------------------------------+--------------------------------------+---------------------------------------------------+-------------------------------
8d7c0e89-8043-413d-b3f0-d6bca0062b3e | a0fce947-1cb5-4780-ba66-daddb74fadea | Это сообщение должно пережить перезапуск 7681083c | 2026-10-23 10:18:13.025076+00
(1 row)
OK: вывод идентичен выводу до перезапуска.
-- действующие сессии (токены не показываем)
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id WHERE u.username IN ('demo_a_7681083c', 'demo_b_7681083c') AND s.expires_at > now()"
live_sessions
---------------
2
(1 row)
OK: вывод идентичен выводу до перезапуска.
-- том тот же (дата создания не изменилась):
$ docker volume inspect mtusi-messenger_pgdata --format "{{.Name}} создан: {{.CreatedAt}}"
mtusi-messenger_pgdata создан: 2026-10-23T13:16:41+03:00
OK: том не пересоздавался.
==============================================================================
ИТОГ
==============================================================================
ИТОГ: PASS -- пользователи, чат, сообщение и действующие сессии сохранились после удаления и повторного создания контейнеров (docker compose down, затем up -d).
+323
View File
@@ -0,0 +1,323 @@
# Дата (UTC): 2026-10-23 10:18:23
# Commit: 65003b6
# Команда: python3 scripts/dependency_demo.py
==============================================================================
0. Контейнеры
==============================================================================
$ docker compose --env-file .env ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
messenger-api mtusi-messenger:lab2 "python -m app" api 8 seconds ago Up 2 seconds (health: starting) 127.0.0.1:8080->8080/tcp
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 8 seconds ago Up 8 seconds (healthy) 127.0.0.1:5433->5432/tcp
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 8 seconds ago Up 8 seconds (healthy) 6379/tcp
==============================================================================
1. Redis: версия и настройки (кэш, persistence выключена намеренно)
==============================================================================
$ docker compose --env-file .env exec -T redis redis-server --version
Redis server v=7.4.1 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=9ce9f16f947e6690
$ docker compose --env-file .env exec -T redis redis-cli CONFIG GET save
save
$ docker compose --env-file .env exec -T redis redis-cli CONFIG GET appendonly
appendonly
no
$ docker compose --env-file .env exec -T redis redis-cli CONFIG GET maxmemory-policy
maxmemory-policy
noeviction
==============================================================================
2. Роль кэша: проверка Bearer-токена без запроса к PostgreSQL
==============================================================================
POST /api/v1/users -> 201 (57 мс) # регистрация
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
POST /api/v1/auth/sessions -> 201 (52 мс) # вход (Basic)
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:24.063082Z", "user": {"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}}
POST /api/v1/users -> 201 (47 мс) # регистрация
{"id": "5430982a-788d-47f8-a794-b135476578df", "username": "bob_e2ebd6fa", "display_name": "bob", "created_at": "2026-10-23T10:18:24.154704Z"}
POST /api/v1/auth/sessions -> 201 (48 мс) # вход (Basic)
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:24.161175Z", "user": {"id": "5430982a-788d-47f8-a794-b135476578df", "username": "bob_e2ebd6fa", "display_name": "bob", "created_at": "2026-10-23T10:18:24.154704Z"}}
$ docker compose --env-file .env exec -T redis redis-cli CONFIG RESETSTAT
OK
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -At -c "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelname = 'sessions_pkey'"
10
50 x GET /api/v1/users/me -> 200; первый 4.1 мс, медиана остальных 1.7 мс
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -At -c "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelname = 'sessions_pkey'"
10
Чтений индекса sessions_pkey в PostgreSQL за 50 запросов: 0
$ docker compose --env-file .env exec -T redis redis-cli INFO stats
# Stats
total_connections_received:2
total_commands_processed:53
instantaneous_ops_per_sec:32
total_net_input_bytes:4910
total_net_output_bytes:7470
total_net_repl_input_bytes:0
total_net_repl_output_bytes:0
instantaneous_input_kbps:2.96
instantaneous_output_kbps:4.53
instantaneous_input_repl_kbps:0.00
instantaneous_output_repl_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_subkeys:0
expired_keys:0
expired_stale_perc:0.00
expired_time_cap_reached_count:0
expire_cycle_cpu_milliseconds:0
evicted_keys:0
evicted_clients:0
evicted_scripts:0
total_eviction_exceeded_time:0
current_eviction_exceeded_time:0
keyspace_hits:49
keyspace_misses:1
pubsub_channels:0
pubsub_patterns:0
pubsubshard_channels:0
latest_fork_usec:0
total_forks:0
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0
total_active_defrag_time:0
current_active_defrag_time:0
tracking_total_keys:0
tracking_total_items:0
tracking_total_prefixes:0
unexpected_error_replies:0
total_error_replies:0
dump_payload_sanitizations:0
total_reads_processed:55
total_writes_processed:53
io_threaded_reads_processed:0
io_threaded_writes_processed:0
client_query_buffer_limit_disconnections:0
client_output_buffer_limit_disconnections:0
reply_buffer_shrinks:0
reply_buffer_expands:0
eventloop_cycles:81
eventloop_duration_sum:14650
eventloop_duration_cmd_sum:128
instantaneous_eventloop_cycles_per_sec:42
instantaneous_eventloop_duration_usec:452
acl_access_denied_auth:0
acl_access_denied_cmd:0
acl_access_denied_key:0
acl_access_denied_channel:0
Redis: keyspace_hits=49 keyspace_misses=1
$ docker compose --env-file .env exec -T redis redis-cli PTTL session:<sha256 токена>
58542
TTL ключа сессии: 58542 мс (<= CACHE_TTL_SECONDS=60 с и <= остатка сессии)
$ docker compose --env-file .env exec -T redis redis-cli GET session:<sha256 токена>
{"id":"2454e675-039f-49b3-92f0-e2e492e0cefc","username":"alice_a3a3d232","display_name":"alice","created_at":"2026-10-23T10:18:24.048024+00:00"}
==============================================================================
3. Logout: DELETE в PostgreSQL, затем отметка отзыва в Redis
==============================================================================
POST /api/v1/users -> 201 (54 мс) # регистрация
{"id": "b3b307ec-a474-451c-a347-51450f51fec8", "username": "carol_e6a6b17a", "display_name": "carol", "created_at": "2026-10-23T10:18:27.081509Z"}
POST /api/v1/auth/sessions -> 201 (49 мс) # вход (Basic)
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:27.095801Z", "user": {"id": "b3b307ec-a474-451c-a347-51450f51fec8", "username": "carol_e6a6b17a", "display_name": "carol", "created_at": "2026-10-23T10:18:27.081509Z"}}
GET /api/v1/users/me -> 200 (4 мс) # кладёт сессию в кэш
{"id": "b3b307ec-a474-451c-a347-51450f51fec8", "username": "carol_e6a6b17a", "display_name": "carol", "created_at": "2026-10-23T10:18:27.081509Z"}
DELETE /api/v1/auth/sessions/current -> 204 (7 мс)
(пусто)
$ docker compose --env-file .env exec -T redis redis-cli GET session:<sha256 токена>
revoked
GET /api/v1/users/me -> 401 (2 мс) # отозванный токен
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "5137ca7dc5464437bdaa45e85bb17e84"}}
==============================================================================
4. Рестарт Redis: кэш пуст, сессии живы (источник истины -- PostgreSQL)
==============================================================================
$ docker compose --env-file .env restart redis
Container messenger-redis Restarting
Container messenger-redis Started
redis healthy через 5.4 с
$ docker compose --env-file .env exec -T redis redis-cli DBSIZE
0
GET /api/v1/users/me -> 200 (5 мс) # тот же токен
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
$ docker compose --env-file .env exec -T redis redis-cli EXISTS session:<sha256 токена>
1
GET /api/v1/users/me -> 401 (4 мс) # отозванный токен после потери кэша всё равно 401 (решает PostgreSQL)
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "aed4a94de8cf4ebfb495e3b35ae51bc3"}}
==============================================================================
5. Redis ОСТАНОВЛЕН: API обходит кэш
==============================================================================
$ docker compose --env-file .env stop redis
Container messenger-redis Stopping
Container messenger-redis Stopped
GET /health/live -> 200 (1 мс)
{"status": "ok"}
GET /health/ready -> 200 (2 мс) # Redis не критичен для обязательного пути
{"status": "ok"}
GET /api/v1/users/me -> 200 (307 мс)
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
POST /api/v1/chats -> 201 (21 мс)
{"id": "515465df-f215-49f0-9548-55d81bf82331", "title": "без Redis", "member_ids": ["2454e675-039f-49b3-92f0-e2e492e0cefc", "5430982a-788d-47f8-a794-b135476578df"], "created_at": "2026-10-23T10:18:33.810751Z"}
POST /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 201 (10 мс)
{"id": "ebd92a19-9f52-41c2-a883-6ecf0fa880b1", "chat_id": "515465df-f215-49f0-9548-55d81bf82331", "sender_id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "text": "сообщение при остановленном Redis", "created_at": "2026-10-23T10:18:33.830951Z"}
GET /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 200 (5 мс)
{"items": [{"id": "ebd92a19-9f52-41c2-a883-6ecf0fa880b1", "chat_id": "515465df-f215-49f0-9548-55d81bf82331", "sender_id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "text": "сообщение при остановленном Redis", "created_at": "2026-10-23T10:18:33.830951Z"}], "next_cursor": null}
GET /api/v1/users/me -> 401 (2 мс) # без токена -- 401, не доверяем
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "9726e3049265430abcbbf1370d866d0e"}}
GET /api/v1/users/me -> 401 (4 мс) # чужой токен -- 401
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "f187d7d2bd65451ba37797de881c940f"}}
POST /api/v1/users -> 201 (51 мс) # регистрация
{"id": "ff7f3a4f-e69f-465b-a2ae-3a38b9571bc8", "username": "dave_3786d2ec", "display_name": "dave", "created_at": "2026-10-23T10:18:33.890145Z"}
POST /api/v1/auth/sessions -> 201 (49 мс) # вход (Basic)
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:33.898871Z", "user": {"id": "ff7f3a4f-e69f-465b-a2ae-3a38b9571bc8", "username": "dave_3786d2ec", "display_name": "dave", "created_at": "2026-10-23T10:18:33.890145Z"}}
GET /api/v1/users/me -> 200 (3 мс)
{"id": "ff7f3a4f-e69f-465b-a2ae-3a38b9571bc8", "username": "dave_3786d2ec", "display_name": "dave", "created_at": "2026-10-23T10:18:33.890145Z"}
DELETE /api/v1/auth/sessions/current -> 204 (7 мс) # logout при недоступном Redis
(пусто)
GET /api/v1/users/me -> 401 (3 мс)
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "afc3e9b8832241068e49c15a5f255647"}}
Максимальная задержка запросов без Redis: 307 мс
$ docker compose --env-file .env start redis
Container messenger-redis Starting
Container messenger-redis Started
redis healthy через 5.4 с
GET /api/v1/users/me -> 200 (21 мс) # кэш снова в работе
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
GET /api/v1/users/me -> 401 (14 мс)
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "9b50d84c22434a8ea61d0e642afb75d7"}}
$ docker compose --env-file .env logs --since 2m api
messenger-api | 2026-10-23T10:18:21+0000 INFO listen host=0.0.0.0 port=8080
messenger-api | INFO: Started server process [1]
messenger-api | INFO: Waiting for application startup.
messenger-api | 2026-10-23T10:18:21+0000 INFO config env=lab pool=5+5 ttl=3600s store=postgres cache=redis
messenger-api | 2026-10-23T10:18:21+0000 INFO migrations: nothing to apply
messenger-api | 2026-10-23T10:18:21+0000 INFO startup: приложение готово
messenger-api | INFO: Application startup complete.
messenger-api | INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=ab0d003663564a1b9dc29362448eba2a method=GET path=/health/ready status=200 duration_ms=7.1
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=5ef96f93ebaa48f492ed2cc18ae57cef method=GET path=/api/v1/users/me status=200 duration_ms=15.0
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=3c763fd0b51641a8b6e78e67b93713dc method=GET path=/api/v1/chats/051a293a-c75d-45f5-b4ab-7e24ef0833f4/messages status=200 duration_ms=8.5
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=028499cc5fea4ab6806c129125221538 method=GET path=/api/v1/chats status=200 duration_ms=5.5
messenger-api | 2026-10-23T10:18:23+0000 INFO request request_id=fcded80bfe3747828ad334eb67bf452a method=GET path=/health/ready status=200 duration_ms=2.1
messenger-api | 2026-10-23T10:18:23+0000 INFO request request_id=ce4a44fa17fa419385d393eab8eda558 method=GET path=/health/ready status=200 duration_ms=2.0
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=a327a13994254a5e8695f8065c0052c7 method=POST path=/api/v1/users status=201 duration_ms=55.9
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=1bac32dcbdc9426981c93b4b1fc2a6a7 method=POST path=/api/v1/auth/sessions status=201 duration_ms=50.6
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=2ad87a6b1d714522b6ce473c3d03a88e method=POST path=/api/v1/users status=201 duration_ms=46.3
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=b6f69c04a1894b06966dce197177dc74 method=POST path=/api/v1/auth/sessions status=201 duration_ms=47.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=0939be01468d46149145707bb6a13e4e method=GET path=/api/v1/users/me status=200 duration_ms=3.4
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=68668e6e03c143d8aba1bc765e46594f method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=061a41bf184b4a28ae09a236a100b954 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3ac82f390f1e4c9ebf62030403c6d5f3 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=b5d7ef2a5af14a17a409261526158e73 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=60d4a26bdac3438fa1169f6e45eed859 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=0a795eda6f1b43cb83c37b5ca3633d2b method=GET path=/api/v1/users/me status=200 duration_ms=0.7
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=d33c6949fe41473c91ded47999a57451 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3da894a019194c80b4eb470af8067f9b method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3d45d5bb28e7433c91bd92fdabcf6529 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=4e6752620fa24ec1803dd970647f372a method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=bad3a45c841e4f619fb6f0d05847f2cb method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=0afb12feb0b34ef8a29835d7a33655be method=GET path=/api/v1/users/me status=200 duration_ms=1.0
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=f10d8b39b9b844c884e91d230ab6ee93 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=1d69e3356cac44dbb424492f1b666d5f method=GET path=/api/v1/users/me status=200 duration_ms=1.0
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=b52dcff84fe7411eb185807f66a477db method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=1f87f056fcda4b2d87e277424a596a81 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=7b7c2bbf8a8d49d9be2e163d12c2783a method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=e767c61290b240f190b673bbe0cb8320 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5a9a796e47a343d699a6d42e604c1a32 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5b8ef3ca395e4efbbd54c1e7fdd91781 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=f786c6bd84f84722886bf6dfd35d1a32 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=dabde023b7784d77b66993f95c3b0666 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=49c5501d17fd46eb916ce33a0ed8b504 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=6b46168eb0a44611a7ddbbe6138cf5a2 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3dde34ec48e146d7b5f0110f1d2fbdc1 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=1f122734d4544a9b8b1dc6f12cad4f87 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=ba06f9dbf16e4b538f68fc5ee1268f0f method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=75b39d4d183e46878ad7ce0e0946d4fe method=GET path=/api/v1/users/me status=200 duration_ms=0.8
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=344a490d3a37460fa08ea554600cf13d method=GET path=/api/v1/users/me status=200 duration_ms=0.9
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=d86193959efb469fa70484723c0479f7 method=GET path=/api/v1/users/me status=200 duration_ms=1.0
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5c7d4a99cf0d42e290c00843c5c5c277 method=GET path=/api/v1/users/me status=200 duration_ms=1.3
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=01eeb99a98c2496eae093957542f779c method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=33cccf79cdcb4b86a66b8db765943207 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=ccfc557d55cf4205b7010790f41f61e1 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=beb012eb4b4344c6ba47b1c229888c24 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=30a106dab9ad4ad9bde5a9c67dfa0fa8 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=2ef1c83fa84141f7ba9125ee2bd32b94 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=eb54e1442e49409dbe3952b1dc472a9d method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=add208ea268245af868c186f2a464580 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=124ca2404be5494696aae09353d139c3 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5b3f9c939709426992d41d96c14d32ee method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=d1cbe63bd9a44638abe624657ba0c203 method=GET path=/api/v1/users/me status=200 duration_ms=1.5
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=945013d1534c4a94a924a12eec335baa method=GET path=/api/v1/users/me status=200 duration_ms=1.5
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=464c092f0f164f9db27d86e840466e2a method=GET path=/api/v1/users/me status=200 duration_ms=1.3
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=becf9277028c4408bbab35fbf3e6fad2 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=4481eecaef30407e85ecf86762337d39 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=e1d34ed15b144d3b9907b64025677d39 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3d43e46e55334ddf91274467d331b167 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=8817c423a2da48529a4519cbb19791e6 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=705142a4330249bd99beaa84bdbc6127 method=GET path=/health/ready status=200 duration_ms=2.0
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=f4934e6692bd473fad9c59a9927fa304 method=POST path=/api/v1/users status=201 duration_ms=53.4
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=335a26c51d784946882f57f5668946e5 method=POST path=/api/v1/auth/sessions status=201 duration_ms=47.8
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=ea1bddbde1d04083966b5b77278a1618 method=GET path=/api/v1/users/me status=200 duration_ms=3.1
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=a47b63e1b3214a67974a4c506590b905 method=DELETE path=/api/v1/auth/sessions/current status=204 duration_ms=6.2
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=5137ca7dc5464437bdaa45e85bb17e84 method=GET path=/api/v1/users/me status=401 duration_ms=0.9
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=05218a878a3044d598f8a5c8ccc17ab6 method=GET path=/api/v1/users/me status=200 duration_ms=3.8
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=aed4a94de8cf4ebfb495e3b35ae51bc3 method=GET path=/api/v1/users/me status=401 duration_ms=2.7
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=dc35c7f0f7da44daa96e7f9995fe8ec7 method=GET path=/health/live status=200 duration_ms=0.5
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=742e776579014925b3426c3e5f28ed1a method=GET path=/health/ready status=200 duration_ms=1.5
messenger-api | 2026-10-23T10:18:33+0000 WARNING cache_unavailable type=TimeoutError
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=34d82defd3454b18a6b5e3b17fc31fd8 method=GET path=/api/v1/users/me status=200 duration_ms=306.3
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=41c38a52d56042a8b5346d7fb623d2d3 method=POST path=/api/v1/chats status=201 duration_ms=19.7
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=44445527e20f47ae847911b139196fde method=POST path=/api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages status=201 duration_ms=8.9
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=97111a005b89485c8f2abac6c18275a1 method=GET path=/api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages status=200 duration_ms=4.4
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=9726e3049265430abcbbf1370d866d0e method=GET path=/api/v1/users/me status=401 duration_ms=0.6
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=f187d7d2bd65451ba37797de881c940f method=GET path=/api/v1/users/me status=401 duration_ms=2.6
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=bd141144a65a4644887fe5fb2b511a27 method=POST path=/api/v1/users status=201 duration_ms=50.0
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=e52d5593aa6b459ca4d49cfc2b185b01 method=POST path=/api/v1/auth/sessions status=201 duration_ms=47.7
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=d0dbee871d0a44e3a8a0eb106e955ce0 method=GET path=/api/v1/users/me status=200 duration_ms=2.7
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=f4ce6d2b27f74affbbc32a88b7712765 method=DELETE path=/api/v1/auth/sessions/current status=204 duration_ms=6.4
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=afc3e9b8832241068e49c15a5f255647 method=GET path=/api/v1/users/me status=401 duration_ms=2.3
messenger-api | 2026-10-23T10:18:36+0000 INFO request request_id=d549e191c0974a69bd6f4bf634ee50bb method=GET path=/health/ready status=200 duration_ms=2.0
messenger-api | 2026-10-23T10:18:45+0000 WARNING cache: FLUSHDB after a lost revocation
messenger-api | 2026-10-23T10:18:45+0000 INFO request request_id=2620a2039cbf4f4e8cf5879087f13ec4 method=GET path=/api/v1/users/me status=200 duration_ms=18.6
messenger-api | 2026-10-23T10:18:45+0000 INFO request request_id=9b50d84c22434a8ea61d0e642afb75d7 method=GET path=/api/v1/users/me status=401 duration_ms=9.8
==============================================================================
6. PostgreSQL ОСТАНОВЛЕН: ограниченная ошибка, никого не пускаем без проверки
==============================================================================
$ docker compose --env-file .env stop db
Container messenger-db Stopping
Container messenger-db Stopped
GET /health/live -> 200 (1 мс) # процесс жив
{"status": "ok"}
GET /health/ready -> 503 (912 мс) # обязательная зависимость недоступна
{"error": {"code": "unavailable", "message": "База данных недоступна", "request_id": "127dd693633743c2ae7c483fec38293f"}}
GET /api/v1/chats -> 503 (6 мс) # данные только в БД
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "606963e195294eb1ac31c8195b368194"}}
POST /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 503 (6 мс)
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "27b4b397069446bca210fda788cc5f6d"}}
POST /api/v1/users -> 503 (51 мс)
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "72a0730aad794645b2f27e12da18c230"}}
GET /api/v1/users/me -> 401 (1 мс) # аноним -- 401
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "2e09c4aa32f044aebadbb9a58101de2c"}}
GET /api/v1/users/me -> 503 (5 мс) # неизвестный токен: проверить нельзя -> 503, не 200
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "e8f919b332014c4398f452d6e7787f5e"}}
$ docker compose --env-file .env start db
Container messenger-db Starting
Container messenger-db Started
API снова готов через 0.5 с после start db
GET /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 200 (16 мс) # тот же токен, те же данные
{"items": [{"id": "ebd92a19-9f52-41c2-a883-6ecf0fa880b1", "chat_id": "515465df-f215-49f0-9548-55d81bf82331", "sender_id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "text": "сообщение при остановленном Redis", "created_at": "2026-10-23T10:18:33.830951Z"}], "next_cursor": null}
$ docker compose --env-file .env ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
messenger-api mtusi-messenger:lab2 "python -m app" api 32 seconds ago Up 26 seconds (healthy) 127.0.0.1:8080->8080/tcp
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 32 seconds ago Up Less than a second (health: starting) 127.0.0.1:5433->5432/tcp
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 32 seconds ago Up 13 seconds (healthy) 6379/tcp
==============================================================================
ИТОГ
==============================================================================
ИТОГ: PASS -- Redis кэширует проверку сессий; рестарт/остановка Redis не теряют сессий и не пропускают анонимов; остановка PostgreSQL даёт 503 без деталей и восстанавливается.
+89
View File
@@ -0,0 +1,89 @@
# Дата (UTC): 2026-10-23 10:18:50
# Commit: 65003b6
# Команда: docker compose --env-file .env exec -T api python -m app.explain
# ---------------------------------------- вывод ----------------------------------------
PostgreSQL: 16.6 (Debian 16.6-1.pgdg120+1)
Сообщений всего: 60005
Сообщений в большом чате: 20000
Размер таблицы messages: 6784 kB
Размер индекса messages_chat_created_idx: 5992 kB
==============================================================================
1. Первая страница (без cursor), запрос приложения
==============================================================================
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
FROM messages
WHERE messages.chat_id = $1::UUID ORDER BY messages.created_at, messages.id
LIMIT $2::INTEGER
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576, 51
Limit (cost=0.41..12.38 rows=51 width=80) (actual time=0.008..0.022 rows=51 loops=1)
Buffers: shared hit=6
-> Index Scan using messages_chat_created_idx on messages (cost=0.41..4718.99 rows=20106 width=80) (actual time=0.007..0.018 rows=51 loops=1)
Index Cond: (chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid)
Buffers: shared hit=6
Planning:
Buffers: shared hit=6
Planning Time: 0.073 ms
Execution Time: 0.032 ms
==============================================================================
2. Глубокая страница: cursor после 15000-го сообщения (keyset)
==============================================================================
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
FROM messages
WHERE messages.chat_id = $1::UUID AND (messages.created_at, messages.id) > ($2::TIMESTAMP WITH TIME ZONE, $3) ORDER BY messages.created_at, messages.id
LIMIT $4::INTEGER
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576, 2026-09-23 10:26:18.547526+00:00, c108c4dd-61dd-4321-8b6c-70b26623adf7, 51
Limit (cost=0.41..38.34 rows=51 width=80) (actual time=0.009..0.022 rows=51 loops=1)
Buffers: shared hit=6
-> Index Scan using messages_chat_created_idx on messages (cost=0.41..3712.96 rows=4992 width=80) (actual time=0.008..0.019 rows=51 loops=1)
Index Cond: ((chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid) AND (ROW(created_at, id) > ROW('2026-09-23 10:26:18.547526+00'::timestamp with time zone, 'c108c4dd-61dd-4321-8b6c-70b26623adf7'::uuid)))
Buffers: shared hit=6
Planning Time: 0.052 ms
Execution Time: 0.049 ms
==============================================================================
3. Для сравнения: та же страница через OFFSET (так приложение НЕ делает)
==============================================================================
SELECT * FROM messages WHERE chat_id = $1 ORDER BY created_at, id OFFSET 15000 LIMIT 51
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576
Limit (cost=3072.67..3072.80 rows=51 width=80) (actual time=7.919..7.925 rows=51 loops=1)
Buffers: shared hit=848
-> Sort (cost=3035.17..3085.44 rows=20106 width=80) (actual time=6.788..7.505 rows=15051 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 3271kB
Buffers: shared hit=848
-> Seq Scan on messages (cost=0.00..1598.06 rows=20106 width=80) (actual time=0.006..5.029 rows=20000 loops=1)
Filter: (chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid)
Rows Removed by Filter: 40005
Buffers: shared hit=848
Planning Time: 0.035 ms
Execution Time: 7.938 ms
==============================================================================
4. Для сравнения: запрос приложения БЕЗ индекса (DROP INDEX в транзакции, затем ROLLBACK)
==============================================================================
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
FROM messages
WHERE messages.chat_id = $1::UUID AND (messages.created_at, messages.id) > ($2::TIMESTAMP WITH TIME ZONE, $3) ORDER BY messages.created_at, messages.id
LIMIT $4::INTEGER
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576, 2026-09-23 10:26:18.547526+00:00, c108c4dd-61dd-4321-8b6c-70b26623adf7, 51
Limit (cost=2064.63..2064.76 rows=51 width=80) (actual time=5.644..5.649 rows=51 loops=1)
Buffers: shared hit=848
-> Sort (cost=2064.63..2077.11 rows=4992 width=80) (actual time=5.643..5.645 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 31kB
Buffers: shared hit=848
-> Seq Scan on messages (cost=0.00..1898.09 rows=4992 width=80) (actual time=3.769..5.197 rows=5000 loops=1)
Filter: ((chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid) AND (ROW(created_at, id) > ROW('2026-09-23 10:26:18.547526+00'::timestamp with time zone, 'c108c4dd-61dd-4321-8b6c-70b26623adf7'::uuid)))
Rows Removed by Filter: 55005
Buffers: shared hit=848
Planning:
Buffers: shared hit=4
Planning Time: 0.067 ms
Execution Time: 5.661 ms
Индекс messages_chat_created_idx на месте: True
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 2.44 с
+28
View File
@@ -0,0 +1,28 @@
# Дата (UTC): 2026-10-23 10:18:54
# Commit: 65003b6
# Команда: docker compose --env-file .env --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider student-tests/test_explain.py
# ---------------------------------------- вывод ----------------------------------------
============================= test session starts ==============================
collecting ... collected 2 items
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[0] PASSED [ 50%]
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[9000] PASSED [100%]
=============================== warnings summary ===============================
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
from starlette.testclient import TestClient as TestClient # noqa
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
========================= 2 passed, 1 warning in 0.15s =========================
Container messenger-redis Running
Container messenger-db Running
Container messenger-db Waiting
Container messenger-redis Waiting
Container messenger-redis Healthy
Container messenger-db Healthy
Container mtusi-messenger-tests-run-177db5fdb80c Creating
Container mtusi-messenger-tests-run-177db5fdb80c Created
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 4.73 с
+19
View File
@@ -0,0 +1,19 @@
# Дата (UTC): 2026-10-23 10:19:02
# Commit: 65003b6
# Команда: python3 scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
# ---------------------------------------- вывод ----------------------------------------
OK регистрация -> 201
OK вход -> 201, expires_at через 2.9 с (TTL=3)
OK GET /users/me #1 до истечения -> 200
OK GET /users/me #2 до истечения -> 200
OK GET /users/me #3 до истечения -> 200
OK GET /users/me после TTL+1 с -> 401, WWW-Authenticate: Bearer realm="messenger", code=unauthorized
OK новый вход -> 201
OK logout -> 204
OK GET /users/me после logout -> 401
OK повторный logout -> 401
OK вход с неверным паролем -> 401, WWW-Authenticate: Basic realm="messenger", charset="UTF-8"
PASS: expiry (TTL=3 с), logout и неверный пароль на запущенном API
# ---------------------------------------------------------------------------------------
# Код возврата: 0
# Время выполнения: 4.34 с
+4
View File
@@ -0,0 +1,4 @@
[pytest]
testpaths = student-tests
pythonpath = .
addopts = -ra
+10
View File
@@ -0,0 +1,10 @@
# Зависимости собственных тестов (student-tests/). Ставятся только в test-образ
# (Dockerfile, target test) поверх requirements.txt.
certifi==2026.10.19
httpcore==1.0.9
httpx==0.28.1
iniconfig==2.3.1
packaging==26.3
pluggy==1.7.0
Pygments==2.21.0
pytest==9.1.1
+20
View File
@@ -0,0 +1,20 @@
# Зависимости API (runtime). Точные версии, включая транзитивные: сборка повторяема.
# Получено `pip freeze` в python:3.12.8-slim-bookworm.
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
asyncpg==0.32.0
click==8.5.0
fastapi==0.159.1
greenlet==3.5.6
h11==0.16.0
idna==3.20
opentelemetry-api==1.45.1
pydantic==2.14.1
pydantic_core==2.50.1
redis==5.2.1
SQLAlchemy==2.1.6
starlette==1.9.0
typing-inspection==0.4.4
typing_extensions==4.16.0
uvicorn==0.54.0
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env python3
"""Проверка срока жизни сессии, выхода и неверного пароля на запущенном API.
python scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
API должен работать с SESSION_TTL_SECONDS, равным --ttl.
"""
import argparse
import base64
import json
import sys
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timezone
def http(base, method, path, body=None, headers=None):
"""HTTP-запрос: (статус, заголовки, тело)."""
data = json.dumps(body).encode() if body is not None else None
request = urllib.request.Request(base + path, data=data, method=method, headers=dict(headers or {}))
if data is not None:
request.add_header("Content-Type", "application/json")
try:
with urllib.request.urlopen(request, timeout=10) as reply:
return reply.status, reply.headers, reply.read()
except urllib.error.HTTPError as error:
return error.code, error.headers, error.read()
def step(text, ok):
"""Напечатать результат шага; при неудаче завершить с кодом 1."""
print(("OK " if ok else "FAIL ") + text, flush=True)
if not ok:
sys.exit(1)
def main():
"""Выполнить проверку."""
parser = argparse.ArgumentParser()
parser.add_argument("--base-url", default="http://localhost:8081")
parser.add_argument("--ttl", type=float, default=3)
args = parser.parse_args()
base = args.base_url.rstrip("/")
username, password = "ttl_" + uuid.uuid4().hex[:8], "Expiry-" + uuid.uuid4().hex
basic = {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
status, _, _ = http(base, "POST", "/api/v1/users",
{"username": username, "display_name": "TTL", "password": password})
step("регистрация -> %d" % status, status == 201)
status, _, raw = http(base, "POST", "/api/v1/auth/sessions", headers=basic)
session = json.loads(raw)
expires = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
left = (expires - datetime.now(timezone.utc)).total_seconds()
step("вход -> %d, expires_at через %.1f с (TTL=%g)" % (status, left, args.ttl),
status == 201 and 0 < left <= args.ttl + 1)
bearer = {"Authorization": "Bearer " + session["token"]}
for n in range(3):
status, _, _ = http(base, "GET", "/api/v1/users/me", headers=bearer)
step("GET /users/me #%d до истечения -> %d" % (n + 1, status), status == 200)
time.sleep(args.ttl + 1)
status, headers, raw = http(base, "GET", "/api/v1/users/me", headers=bearer)
step("GET /users/me после TTL+1 с -> %d, WWW-Authenticate: %s, code=%s"
% (status, headers.get("WWW-Authenticate"), json.loads(raw)["error"]["code"]),
status == 401 and headers.get("WWW-Authenticate") == 'Bearer realm="messenger"')
status, _, raw = http(base, "POST", "/api/v1/auth/sessions", headers=basic)
bearer = {"Authorization": "Bearer " + json.loads(raw)["token"]}
step("новый вход -> %d" % status, status == 201)
status, _, _ = http(base, "DELETE", "/api/v1/auth/sessions/current", headers=bearer)
step("logout -> %d" % status, status == 204)
status, _, _ = http(base, "GET", "/api/v1/users/me", headers=bearer)
step("GET /users/me после logout -> %d" % status, status == 401)
status, _, _ = http(base, "DELETE", "/api/v1/auth/sessions/current", headers=bearer)
step("повторный logout -> %d" % status, status == 401)
wrong = {"Authorization": "Basic " + base64.b64encode((username + ":wrong-password-123").encode()).decode()}
status, headers, _ = http(base, "POST", "/api/v1/auth/sessions", headers=wrong)
step("вход с неверным паролем -> %d, WWW-Authenticate: %s" % (status, headers.get("WWW-Authenticate")),
status == 401 and headers.get("WWW-Authenticate", "").startswith("Basic"))
print("PASS: expiry (TTL=%g с), logout и неверный пароль на запущенном API" % args.ttl)
return 0
if __name__ == "__main__":
sys.exit(main())
+63
View File
@@ -0,0 +1,63 @@
#!/bin/sh
set -u
cd "$(dirname "$0")/.."
R="python3 scripts/run_and_save.py"
DC="docker compose --env-file .env"
PGUSER=$(sed -n 's/^POSTGRES_USER=//p' .env)
PGDB=$(sed -n 's/^POSTGRES_DB=//p' .env)
PSQL="$DC exec -T db psql -U ${PGUSER:-messenger} -d ${PGDB:-messenger}"
VOLUME=mtusi-messenger_pgdata
VOLFMT='{{.Name}} created={{.CreatedAt}}'
STEPS=${*:-"01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16"}
wait_ready() {
for _ in $(seq 1 90); do
curl -sf http://localhost:8080/health/ready >/dev/null && return 0
sleep 1
done
echo "API не готов" >&2
return 1
}
for step in $STEPS; do
echo "=== $step"
case $step in
01) $R evidence/01_check_contract.txt -- python3 scripts/check_contract.py ;;
02) $R evidence/02_smoke.txt -- make test ;;
03) $R evidence/03_ps_before.txt -- $DC ps
$R evidence/03_volume_before.txt -- docker volume inspect $VOLUME --format "$VOLFMT" ;;
04) $R evidence/04_persistence.txt -- make test-persistence ACTION_SCRIPT=scripts/restart.sh ;;
05) $R evidence/05_ps_after.txt -- $DC ps
$R evidence/05_volume_after.txt -- docker volume inspect $VOLUME --format "$VOLFMT" ;;
06) $R evidence/06_schema.txt -- $PSQL -c '\d users' -c '\d chats' -c '\d chat_members' \
-c '\d messages' -c '\d sessions' ;;
07) $R evidence/07_migrations.txt -- $DC exec -T api python -m app.migrate
$R evidence/07_migrations_table.txt -- $PSQL -c 'SELECT * FROM schema_migrations' ;;
08) $R evidence/08_hashes.txt -- $PSQL \
-c "SELECT username, left(password_hash, 7) AS password_prefix, length(password_hash) AS len FROM users WHERE password_hash LIKE 'scrypt\$%' LIMIT 3" \
-c 'SELECT length(token_hash) AS token_hash_len, expires_at FROM sessions LIMIT 3' ;;
09) $R evidence/09_auth_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
student-tests/test_auth.py student-tests/test_session_expiry.py ;;
10) $R evidence/10_database_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
student-tests/test_database.py student-tests/test_db_failure.py student-tests/test_transactions.py \
student-tests/test_duplicate_username.py ;;
11) $R evidence/11_all_tests.txt -- $DC --profile test run --rm tests ;;
12) $R evidence/12_git_secrets.txt -- git check-ignore -v .env
$R evidence/12_git_files.txt -- git ls-files --cached --others --exclude-standard
$R evidence/12_compose_no_secrets.txt -- grep -n -i 'password\|secret' compose.yaml ;;
13) python3 scripts/storage_demo.py --output evidence/13_storage.txt
wait_ready ;;
14) python3 scripts/dependency_demo.py --output evidence/14_dependencies.txt
wait_ready ;;
15) $R evidence/15_explain.txt -- $DC exec -T api python -m app.explain
$R evidence/15_explain_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
student-tests/test_explain.py ;;
16) $DC --profile expiry up -d api-ttl
for _ in $(seq 1 60); do curl -sf http://localhost:8081/health/ready >/dev/null && break; sleep 1; done
$R evidence/16_expiry_live.txt -- python3 scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
$DC --profile expiry stop api-ttl
$DC --profile expiry rm -f api-ttl ;;
*) echo "неизвестный пункт $step" >&2 ;;
esac
done
+324
View File
@@ -0,0 +1,324 @@
#!/usr/bin/env python3
"""Сценарий проверки кэша сессий и отказов зависимостей.
python scripts/dependency_demo.py [--output файл]
Показывает настройки Redis и попадания в кэш, отзыв сессии, рестарт и
остановку Redis, остановку PostgreSQL и восстановление. Тома не удаляются,
ключи Redis маскируются. Код возврата 0 -- все проверки прошли.
"""
import argparse
import base64
import hashlib
import json
import re
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
COMPOSE = ["docker", "compose", "--env-file", ".env"]
class Fail(Exception):
"""Проверка не прошла."""
pass
class Log:
"""Вывод на экран с накоплением строк для файла."""
def __init__(self):
"""Пустой листинг."""
self.lines = []
def say(self, text=""):
"""Напечатать строку и добавить её в листинг."""
self.lines.append(text)
print(text, flush=True)
def title(self, text):
"""Напечатать заголовок раздела."""
self.say("")
self.say("=" * 78)
self.say(text)
self.say("=" * 78)
def check(condition, message):
"""Бросить Fail, если условие ложно."""
if not condition:
raise Fail(message)
def mask(text):
"""Скрыть SHA-256 токенов в ключах Redis."""
return re.sub(r"session:[0-9a-f]{64}", "session:<sha256 токена>", text)
def run(log, args, must_succeed=True):
"""Выполнить команду, записать её и вывод в листинг."""
log.say("$ " + mask(" ".join(a if a and " " not in a else '"%s"' % a for a in args)))
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
if output:
log.say(mask(output))
if must_succeed and done.returncode != 0:
raise Fail("команда завершилась с кодом %d" % done.returncode)
return output
def env_value(name, default):
"""Значение переменной из .env."""
path = ROOT / ".env"
if path.exists():
for line in path.read_text(encoding="utf-8").splitlines():
if line.strip().startswith(name + "="):
return line.split("=", 1)[1].strip()
return default
def psql(log, query):
"""Выполнить запрос в контейнере db."""
user = env_value("POSTGRES_USER", "messenger")
db = env_value("POSTGRES_DB", "messenger")
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", db, "-At", "-c", query])
def redis_cli(log, *args):
"""Выполнить команду redis-cli в контейнере redis."""
return run(log, COMPOSE + ["exec", "-T", "redis", "redis-cli"] + list(args))
def http(base, method, path, body=None, headers=None, timeout=10):
"""HTTP-запрос: (статус, JSON или None, время в мс)."""
data = json.dumps(body).encode() if body is not None else None
request = urllib.request.Request(base + path, data=data, method=method, headers=dict(headers or {}))
if data is not None:
request.add_header("Content-Type", "application/json")
started = time.monotonic()
try:
with urllib.request.urlopen(request, timeout=timeout) as reply:
status, raw = reply.status, reply.read()
except urllib.error.HTTPError as error:
status, raw = error.code, error.read()
elapsed = (time.monotonic() - started) * 1000
return status, (json.loads(raw) if raw else None), elapsed
def call(log, base, method, path, expected, body=None, headers=None, note=""):
"""HTTP-запрос с проверкой статуса и записью в листинг."""
status, payload, elapsed = http(base, method, path, body, headers)
shown = json.dumps(payload, ensure_ascii=False) if payload is not None else "(пусто)"
if isinstance(payload, dict) and "token" in payload:
shown = json.dumps(dict(payload, token="<скрыт>"), ensure_ascii=False)
log.say("%s %s -> %d (%.0f мс)%s" % (method, path, status, elapsed, (" # " + note) if note else ""))
log.say(" " + shown[:300])
check(status == expected, "%s %s: ожидали %d, получили %d" % (method, path, expected, status))
return payload, elapsed
def wait_ready(base, seconds=90):
"""Дождаться /health/ready = 200."""
started = time.monotonic()
while time.monotonic() - started < seconds:
try:
if http(base, "GET", "/health/ready", timeout=3)[0] == 200:
return time.monotonic() - started
except (urllib.error.URLError, OSError):
pass
time.sleep(0.5)
raise Fail("API не стал готов за %d с" % seconds)
def wait_service_healthy(log, service, seconds=60):
"""Дождаться статуса healthy у контейнера сервиса."""
started = time.monotonic()
while time.monotonic() - started < seconds:
done = subprocess.run(
["docker", "inspect", "-f", "{{.State.Health.Status}}", "messenger-" + service],
capture_output=True, text=True,
)
if done.stdout.strip() == "healthy":
log.say("%s healthy через %.1f с" % (service, time.monotonic() - started))
return
time.sleep(0.5)
raise Fail(service + " не стал healthy")
def basic(username, password):
"""Заголовок Basic."""
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
def bearer(token):
"""Заголовок Bearer."""
return {"Authorization": "Bearer " + token}
def new_user(log, base, name):
"""Зарегистрировать пользователя и войти."""
username = "%s_%s" % (name, uuid.uuid4().hex[:8])
password = "Demo-" + uuid.uuid4().hex
user, _ = call(log, base, "POST", "/api/v1/users", 201,
{"username": username, "display_name": name, "password": password},
note="регистрация")
session, _ = call(log, base, "POST", "/api/v1/auth/sessions", 201,
headers=basic(username, password), note="вход (Basic)")
return user, session["token"]
def key_of(token):
"""Ключ Redis для токена."""
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def sessions_pkey_scans(log):
"""Число чтений индекса sessions_pkey."""
out = psql(log, "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelname = 'sessions_pkey'")
return int(out.strip().splitlines()[-1])
def scenario(log, base):
"""Выполнить сценарий проверки."""
log.title("0. Контейнеры")
check(http(base, "GET", "/health/ready")[0] == 200,
"API не готов: docker compose --env-file .env up -d --build")
run(log, COMPOSE + ["ps"])
log.title("1. Redis: версия и настройки (кэш, persistence выключена намеренно)")
run(log, COMPOSE + ["exec", "-T", "redis", "redis-server", "--version"])
redis_cli(log, "CONFIG", "GET", "save")
redis_cli(log, "CONFIG", "GET", "appendonly")
redis_cli(log, "CONFIG", "GET", "maxmemory-policy")
log.title("2. Роль кэша: проверка Bearer-токена без запроса к PostgreSQL")
alice, alice_token = new_user(log, base, "alice")
bob, bob_token = new_user(log, base, "bob")
redis_cli(log, "CONFIG", "RESETSTAT")
time.sleep(1)
scans_before = sessions_pkey_scans(log)
timings = []
for _ in range(50):
status, _, elapsed = http(base, "GET", "/api/v1/users/me", headers=bearer(alice_token))
check(status == 200, "GET /users/me не 200")
timings.append(elapsed)
log.say("50 x GET /api/v1/users/me -> 200; первый %.1f мс, медиана остальных %.1f мс"
% (timings[0], sorted(timings[1:])[len(timings) // 2]))
time.sleep(1)
scans_after = sessions_pkey_scans(log)
log.say("Чтений индекса sessions_pkey в PostgreSQL за 50 запросов: %d" % (scans_after - scans_before))
check(scans_after - scans_before <= 2, "проверка токена ходит в PostgreSQL мимо кэша")
stats = redis_cli(log, "INFO", "stats")
hits = int(re.search(r"keyspace_hits:(\d+)", stats).group(1))
misses = int(re.search(r"keyspace_misses:(\d+)", stats).group(1))
log.say("Redis: keyspace_hits=%d keyspace_misses=%d" % (hits, misses))
check(hits >= 49 and misses >= 1, "ожидали 1 промах и 49 попаданий")
ttl = int(redis_cli(log, "PTTL", key_of(alice_token)).splitlines()[-1])
log.say("TTL ключа сессии: %d мс (<= CACHE_TTL_SECONDS=60 с и <= остатка сессии)" % ttl)
check(0 < ttl <= 60000, "TTL ключа вне ожидаемого диапазона")
redis_cli(log, "GET", key_of(alice_token))
log.title("3. Logout: DELETE в PostgreSQL, затем отметка отзыва в Redis")
_, carol_token = new_user(log, base, "carol")
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(carol_token), note="кладёт сессию в кэш")
call(log, base, "DELETE", "/api/v1/auth/sessions/current", 204, headers=bearer(carol_token))
check(redis_cli(log, "GET", key_of(carol_token)).splitlines()[-1] == "revoked", "нет отметки отзыва")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(carol_token), note="отозванный токен")
log.title("4. Рестарт Redis: кэш пуст, сессии живы (источник истины -- PostgreSQL)")
run(log, COMPOSE + ["restart", "redis"])
wait_service_healthy(log, "redis")
redis_cli(log, "DBSIZE")
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token), note="тот же токен")
check(redis_cli(log, "EXISTS", key_of(alice_token)).splitlines()[-1] == "1", "ключ не создан заново")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(carol_token),
note="отозванный токен после потери кэша всё равно 401 (решает PostgreSQL)")
log.title("5. Redis ОСТАНОВЛЕН: API обходит кэш")
run(log, COMPOSE + ["stop", "redis"])
call(log, base, "GET", "/health/live", 200)
call(log, base, "GET", "/health/ready", 200, note="Redis не критичен для обязательного пути")
_, t1 = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token))
chat, t2 = call(log, base, "POST", "/api/v1/chats", 201,
{"title": "без Redis", "member_ids": [alice["id"], bob["id"]]},
headers=bearer(alice_token))
path = "/api/v1/chats/%s/messages" % chat["id"]
message, t3 = call(log, base, "POST", path, 201, {"text": "сообщение при остановленном Redis"},
headers=bearer(alice_token))
page, t4 = call(log, base, "GET", path, 200, headers=bearer(bob_token))
check(page["items"] == [message], "история не совпала")
call(log, base, "GET", "/api/v1/users/me", 401, note="без токена -- 401, не доверяем")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer("Z" * 43), note="чужой токен -- 401")
_, dave_token = new_user(log, base, "dave")
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(dave_token))
call(log, base, "DELETE", "/api/v1/auth/sessions/current", 204, headers=bearer(dave_token),
note="logout при недоступном Redis")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(dave_token))
log.say("Максимальная задержка запросов без Redis: %.0f мс" % max(t1, t2, t3, t4))
check(max(t1, t2, t3, t4) < 2000, "обход кэша слишком медленный")
run(log, COMPOSE + ["start", "redis"])
wait_service_healthy(log, "redis")
time.sleep(5.5)
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token), note="кэш снова в работе")
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(dave_token))
run(log, COMPOSE + ["logs", "--since", "2m", "api"], must_succeed=False)
log.title("6. PostgreSQL ОСТАНОВЛЕН: ограниченная ошибка, никого не пускаем без проверки")
run(log, COMPOSE + ["stop", "db"])
call(log, base, "GET", "/health/live", 200, note="процесс жив")
call(log, base, "GET", "/health/ready", 503, note="обязательная зависимость недоступна")
call(log, base, "GET", "/api/v1/chats", 503, headers=bearer(alice_token), note="данные только в БД")
call(log, base, "POST", path, 503, {"text": "не будет записано"}, headers=bearer(alice_token))
call(log, base, "POST", "/api/v1/users", 503,
{"username": "nodb_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "long-enough-pass"})
call(log, base, "GET", "/api/v1/users/me", 401, note="аноним -- 401")
call(log, base, "GET", "/api/v1/users/me", 503, headers=bearer("Y" * 43),
note="неизвестный токен: проверить нельзя -> 503, не 200")
run(log, COMPOSE + ["start", "db"])
waited = wait_ready(base)
log.say("API снова готов через %.1f с после start db" % waited)
page, _ = call(log, base, "GET", path, 200, headers=bearer(bob_token), note="тот же токен, те же данные")
check(page["items"] == [message], "сообщение пропало")
run(log, COMPOSE + ["ps"])
log.title("ИТОГ")
log.say("ИТОГ: PASS -- Redis кэширует проверку сессий; рестарт/остановка Redis не теряют сессий "
"и не пропускают анонимов; остановка PostgreSQL даёт 503 без деталей и восстанавливается.")
def main():
"""Выполнить сценарий и сохранить листинг."""
parser = argparse.ArgumentParser(description="Роль Redis и отказы зависимостей")
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--output", default="evidence/14_dependencies.txt")
args = parser.parse_args()
log = Log()
commit = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
capture_output=True, text=True).stdout.strip() or "нет"
log.say("# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"))
log.say("# Commit: " + commit)
log.say("# Команда: python3 scripts/dependency_demo.py")
code = 0
try:
scenario(log, args.base_url.rstrip("/"))
except Fail as error:
log.say("")
log.say("ИТОГ: FAIL -- " + str(error))
code = 1
finally:
for service in ("db", "redis"):
subprocess.run(COMPOSE + ["start", service], cwd=str(ROOT), capture_output=True)
output = ROOT / args.output
output.parent.mkdir(parents=True, exist_ok=True)
output.write_text("\n".join(log.lines) + "\n", encoding="utf-8")
return code
if __name__ == "__main__":
sys.exit(main())
+5
View File
@@ -0,0 +1,5 @@
@echo off
cd /d "%~dp0.."
docker compose --env-file .env stop api redis db || exit /b 1
docker compose --env-file .env start db redis api || exit /b 1
exit /b 0
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env stop api redis db
docker compose --env-file .env start db redis api
+64
View File
@@ -0,0 +1,64 @@
#!/usr/bin/env python3
"""Выполнить команду и сохранить её вывод в файл вместе с датой, коммитом и кодом возврата.
python scripts/run_and_save.py evidence/01.txt -- python scripts/check_contract.py
"""
import os
import subprocess
import sys
import time
from datetime import datetime, timezone
from pathlib import Path
def git_commit(root: Path) -> str:
"""Короткий hash текущего коммита или пояснение, почему его нет."""
try:
out = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(root), capture_output=True,
text=True, timeout=5)
return out.stdout.strip() if out.returncode == 0 and out.stdout.strip() else "нет (git не используется)"
except Exception:
return "нет (git не найден)"
def main() -> int:
"""Выполнить команду после --, записать отчёт и вернуть её код возврата."""
argv = sys.argv[1:]
if len(argv) < 3 or argv[1] != "--":
print(__doc__)
return 2
target = Path(argv[0])
command = argv[2:]
root = Path(__file__).resolve().parents[1]
env = dict(os.environ, PYTHONIOENCODING="utf-8", PYTHONUTF8="1")
started = time.monotonic()
try:
done = subprocess.run(command, capture_output=True, env=env, cwd=str(root))
output = (done.stdout + done.stderr).decode("utf-8", errors="replace")
code = done.returncode
except FileNotFoundError:
output = "Команда не найдена: %s\n" % command[0]
code = 127
elapsed = time.monotonic() - started
text = "\n".join([
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
"# Commit: " + git_commit(root),
"# Команда: " + " ".join(command),
"# ---------------------------------------- вывод ----------------------------------------",
output.rstrip(),
"# ---------------------------------------------------------------------------------------",
"# Код возврата: %d" % code,
"# Время выполнения: %.2f с" % elapsed,
"",
])
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(text, encoding="utf-8")
sys.stdout.buffer.write(text.encode("utf-8", errors="replace"))
print("\n[сохранено в %s]" % target)
return code
if __name__ == "__main__":
sys.exit(main())
+379
View File
@@ -0,0 +1,379 @@
#!/usr/bin/env python3
"""Сценарий проверки сохранности данных при пересоздании контейнеров.
python scripts/storage_demo.py [--mode down|stop] [--output файл]
Создаёт данные через API, показывает их в PostgreSQL, выключает и снова
включает контейнеры (тома не удаляются) и проверяет те же данные прежними
токенами. Пароли и токены в листинг не попадают. Код возврата 0 -- успех.
"""
import argparse
import base64
import json
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
COMPOSE = ["docker", "compose", "--env-file", ".env"]
INTRO = """\
Приложение -- мессенджер: HTTP API (FastAPI), PostgreSQL и Redis (кэш сессий).
* Сам API состояния не хранит: пользователи, чаты, участники, сообщения и сессии
лежат в PostgreSQL (таблицы users, chats, chat_members, messages, sessions).
* Файлы PostgreSQL лежат не в контейнере, а в именованном томе Docker (pgdata).
Контейнеры api и db временные, том постоянный.
* Пароль хранится как scrypt-хеш, у сессии в БД лежит только SHA-256 токена,
срок сессии считает сама БД -- перезапуск его не продлевает и не сбрасывает.
* Redis только кэширует проверку токена (без persistence): после перезапуска
кэш пуст, и сессии читаются из PostgreSQL.
Ожидание: пока том не удалён (команда down -v здесь НЕ используется), после
%(what)s
те же пользователи, чат, сообщение и тот же токен продолжают работать.
План: (1) создать данные через API, (2) показать их в БД, (3) выключить,
(4) включить, (5) проверить, что данные и токены прежние.
"""
class Fail(Exception):
"""Проверка не прошла."""
class Log:
"""Вывод на экран с накоплением строк для файла."""
def __init__(self):
"""Пустой листинг."""
self.lines = []
def say(self, text=""):
"""Напечатать строку и добавить её в листинг."""
self.lines.append(text)
print(text, flush=True)
def title(self, text):
"""Напечатать заголовок раздела."""
self.say("")
self.say("=" * 78)
self.say(text)
self.say("=" * 78)
def show(args):
"""Команда одной строкой для листинга."""
parts = []
for arg in args:
if arg == "" or " " in arg:
quote = "'" if '"' in arg else '"'
parts.append(quote + arg + quote)
else:
parts.append(arg)
return " ".join(parts)
def run(log, args, must_succeed=True):
"""Выполнить команду, записать её и вывод в листинг."""
log.say("$ " + show(args))
try:
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
except FileNotFoundError:
raise Fail("команда не найдена: %s (установлен ли Docker Desktop?)" % args[0])
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
if output:
log.say(output)
if must_succeed and done.returncode != 0:
raise Fail("команда завершилась с кодом %d" % done.returncode)
return output
def read_env():
"""Прочитать .env в словарь."""
values = {}
path = ROOT / ".env"
if path.exists():
for line in path.read_text(encoding="utf-8").splitlines():
line = line.strip()
if line and not line.startswith("#") and "=" in line:
key, _, value = line.partition("=")
values[key.strip()] = value.strip()
return values
def sql(log, query):
"""Выполнить SELECT в контейнере db."""
env = read_env()
user = env.get("POSTGRES_USER", "messenger")
database = env.get("POSTGRES_DB", "messenger")
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", database, "-c", query])
def http(base, method, path, body=None, headers=None, timeout=10):
"""HTTP-запрос к API: (статус, JSON или None)."""
data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
request_headers = {"Accept": "application/json"}
if body is not None:
request_headers["Content-Type"] = "application/json"
request_headers.update(headers or {})
request = urllib.request.Request(base + path, data=data, method=method, headers=request_headers)
try:
response = urllib.request.urlopen(request, timeout=timeout)
status, payload = response.status, response.read()
except urllib.error.HTTPError as error:
status, payload = error.code, error.read()
return status, (json.loads(payload) if payload else None)
def masked(value):
"""Копия ответа со скрытым токеном."""
if isinstance(value, dict):
return {
key: ("<скрыт, %d симв.>" % len(item) if key == "token" and isinstance(item, str) else masked(item))
for key, item in value.items()
}
if isinstance(value, list):
return [masked(item) for item in value]
return value
def call(log, base, method, path, expected, body=None, headers=None, note=""):
"""HTTP-запрос с проверкой статуса и записью в листинг."""
status, payload = http(base, method, path, body, headers)
shown = dict(body) if isinstance(body, dict) else body
if isinstance(shown, dict) and "password" in shown:
shown["password"] = "***"
log.say("$ %s %s %s" % (method, path, (" # " + note) if note else ""))
if shown is not None:
log.say(" тело запроса: " + json.dumps(shown, ensure_ascii=False))
log.say(" ответ: %d %s" % (status, json.dumps(masked(payload), ensure_ascii=False)))
if status != expected:
raise Fail("%s %s: ожидали %d, получили %d" % (method, path, expected, status))
return payload
def wait_ready(base, seconds):
"""Дождаться /health/ready = 200 и вернуть время ожидания."""
started = time.monotonic()
while time.monotonic() - started < seconds:
try:
status, _ = http(base, "GET", "/health/ready", timeout=3)
if status == 200:
return time.monotonic() - started
except (urllib.error.URLError, OSError, ValueError):
pass
time.sleep(1)
raise Fail("API не стал готовым за %d с" % seconds)
def is_down(base):
"""True, если API не отвечает."""
try:
http(base, "GET", "/health/live", timeout=3)
return False
except (urllib.error.URLError, OSError, ValueError):
return True
def volume_name(log):
"""Имя тома pgdata."""
out = run(log, ["docker", "volume", "ls", "--filter", "name=pgdata", "--format", "{{.Name}}"])
names = [line.strip() for line in out.splitlines() if line.strip()]
if not names:
raise Fail("том pgdata не найден: приложение не запускали? (docker compose --env-file .env up -d --build)")
return names[0]
def volume_info(log, name):
"""Имя и дата создания тома."""
return run(log, ["docker", "volume", "inspect", name, "--format", "{{.Name}} создан: {{.CreatedAt}}"])
def basic(username, password):
"""Заголовок Basic."""
raw = (username + ":" + password).encode("utf-8")
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
def bearer(token):
"""Заголовок Bearer."""
return {"Authorization": "Bearer " + token}
def scenario(log, args):
"""Выполнить сценарий проверки."""
base = args.base_url.rstrip("/")
down_mode = args.mode == "down"
what = (
"удаления и повторного создания контейнеров (docker compose down, затем up -d)"
if down_mode
else "остановки и повторного запуска контейнеров (docker compose stop, затем start)"
)
log.title("1. Как устроено приложение")
log.say(INTRO % {"what": what})
log.title("2. Состояние до начала")
try:
status, _ = http(base, "GET", "/health/ready")
except (urllib.error.URLError, OSError, ValueError):
status = 0
if status != 200:
raise Fail("API не отвечает на %s. Запустите приложение: docker compose --env-file .env up -d --build" % base)
run(log, COMPOSE + ["ps"])
volume = volume_name(log)
volume_before = volume_info(log, volume)
log.title("3. Запись данных через API (создаём пользователей, чат, сообщение)")
suffix = uuid.uuid4().hex[:8]
alice_name, bob_name = "demo_a_" + suffix, "demo_b_" + suffix
alice_pass, bob_pass = "Storage-" + uuid.uuid4().hex, "Storage-" + uuid.uuid4().hex
alice = call(log, base, "POST", "/api/v1/users", 201,
{"username": alice_name, "display_name": "Алиса", "password": alice_pass},
note="регистрация Алисы")
bob = call(log, base, "POST", "/api/v1/users", 201,
{"username": bob_name, "display_name": "Боб", "password": bob_pass},
note="регистрация Боба")
alice_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
headers=basic(alice_name, alice_pass), note="вход Алисы (Basic)")["token"]
bob_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
headers=basic(bob_name, bob_pass), note="вход Боба (Basic)")["token"]
chat = call(log, base, "POST", "/api/v1/chats", 201,
{"title": "Проверка сохранности " + suffix, "member_ids": [alice["id"], bob["id"]]},
headers=bearer(alice_token), note="чат Алисы и Боба (Bearer)")
message = call(log, base, "POST", "/api/v1/chats/%s/messages" % chat["id"], 201,
{"text": "Это сообщение должно пережить перезапуск " + suffix},
headers=bearer(alice_token), note="сообщение Алисы")
log.title("4. Что лежит в PostgreSQL ДО выключения (SELECT внутри контейнера db)")
queries = {
"пользователи (пароль -- только префикс хеша)":
"SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at "
"FROM users WHERE username IN ('%s', '%s') ORDER BY username" % (alice_name, bob_name),
"чат и число участников":
"SELECT c.title, count(m.user_id) AS members FROM chats c "
"JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '%s' GROUP BY c.title" % chat["id"],
"сообщение":
"SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '%s'" % chat["id"],
"действующие сессии (токены не показываем)":
"SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id "
"WHERE u.username IN ('%s', '%s') AND s.expires_at > now()" % (alice_name, bob_name),
}
before = {}
for title, query in queries.items():
log.say("-- " + title)
before[title] = sql(log, query)
log.title("5. Выключаем приложение" + (" (контейнеры УДАЛЯЮТСЯ, том остаётся)" if down_mode else ""))
if down_mode:
run(log, COMPOSE + ["down"])
run(log, COMPOSE + ["ps", "-a"], must_succeed=False)
else:
run(log, COMPOSE + ["stop", "api", "redis", "db"])
run(log, COMPOSE + ["ps", "-a"])
if not is_down(base):
raise Fail("после выключения API всё ещё отвечает")
log.say("API на %s не отвечает -- приложение выключено (так и должно быть)." % base)
log.say("-- том с данными на месте:")
run(log, ["docker", "volume", "ls", "--filter", "name=pgdata"])
log.title("6. Включаем снова")
if down_mode:
run(log, COMPOSE + ["up", "-d"])
else:
run(log, COMPOSE + ["start", "db", "redis", "api"])
waited = wait_ready(base, args.wait)
log.say("API снова готов (/health/ready = 200) через %.0f с." % waited)
run(log, COMPOSE + ["ps"])
log.title("7. Проверка ПОСЛЕ перезапуска: те же данные и те же токены")
me = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token),
note="старый токен Алисы, повторный вход НЕ делали")
if me != alice:
raise Fail("пользователь после перезапуска отличается: %r != %r" % (me, alice))
log.say(" OK: тот же пользователь (id, username, created_at совпали).")
page = call(log, base, "GET", "/api/v1/chats/%s/messages" % chat["id"], 200,
headers=bearer(bob_token), note="старый токен Боба читает историю чата")
if page["items"] != [message]:
raise Fail("история чата отличается от записанной до перезапуска")
log.say(" OK: то же сообщение (id, text, created_at совпали).")
listed = call(log, base, "GET", "/api/v1/chats?limit=100", 200, headers=bearer(alice_token),
note="список чатов Алисы")
if not any(item["id"] == chat["id"] for item in listed["items"]):
raise Fail("чат пропал из списка")
log.say(" OK: чат в списке.")
log.say("")
log.say("Те же SELECT после перезапуска (сравниваем с выводом из пункта 4):")
for title, query in queries.items():
log.say("-- " + title)
after = sql(log, query)
if after != before[title]:
raise Fail("результат SELECT изменился: " + title)
log.say(" OK: вывод идентичен выводу до перезапуска.")
log.say("")
log.say("-- том тот же (дата создания не изменилась):")
volume_after = volume_info(log, volume)
if volume_after != volume_before:
raise Fail("том изменился: был «%s», стал «%s»" % (volume_before, volume_after))
log.say(" OK: том не пересоздавался.")
log.title("ИТОГ")
log.say("ИТОГ: PASS -- пользователи, чат, сообщение и действующие сессии сохранились после "
+ what + ".")
def commit_hash():
"""Короткий hash текущего коммита."""
try:
done = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
capture_output=True, text=True, timeout=5)
return done.stdout.strip() if done.returncode == 0 and done.stdout.strip() else "нет"
except Exception:
return "нет"
def main():
"""Разобрать аргументы, выполнить сценарий и сохранить листинг."""
parser = argparse.ArgumentParser(description="Доказательство сохранности данных после перезапуска")
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--output", default="evidence/13_storage.txt")
parser.add_argument("--mode", choices=["down", "stop"], default="down",
help="down: удалить и создать контейнеры (по умолчанию); stop: остановить и запустить")
parser.add_argument("--wait", type=int, default=90, help="сколько секунд ждать готовности API")
args = parser.parse_args()
if hasattr(sys.stdout, "reconfigure"):
sys.stdout.reconfigure(encoding="utf-8", errors="replace")
log = Log()
code = 0
try:
scenario(log, args)
except Fail as error:
log.say("")
log.say("ИТОГ: FAIL -- " + str(error))
code = 1
header = [
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
"# Commit: " + commit_hash(),
"# Команда: python scripts/storage_demo.py --mode " + args.mode,
"",
]
target = Path(args.output)
if not target.is_absolute():
target = ROOT / target
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text("\n".join(header + log.lines) + "\n", encoding="utf-8")
print("\n[сохранено в %s]" % target)
return code
if __name__ == "__main__":
sys.exit(main())
+381
View File
@@ -0,0 +1,381 @@
#!/usr/bin/env python3
"""Доказать, что данные переживают удаление/перезапуск контейнеров.
Запуск (из корня проекта, стенд уже поднят: docker compose --env-file .env up -d --build):
python scripts\\storage_demo.py
Что делает скрипт и записывает в evidence/storage.txt (листинг команд и их вывода):
1. коротко описывает приложение;
2. создаёт через API двух пользователей, входит, создаёт чат и отправляет сообщение;
3. показывает, что именно лежит в PostgreSQL (SELECT внутри контейнера db);
4. выключает приложение (по умолчанию `docker compose down` -- контейнеры удаляются,
том pgdata остаётся; режим --mode stop делает `stop`, как scripts\\restart.bat);
5. включает снова и ждёт готовности;
6. тем же токеном читает те же данные и сравнивает SELECT до и после.
Флаг -v (удаление тома) скрипт НЕ использует никогда. Пароли и токены в файл не попадают.
Код возврата: 0 -- данные сохранились, 1 -- нет (или стенд не запущен).
Только стандартная библиотека Python 3.9+.
"""
import argparse
import base64
import json
import platform
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
from datetime import datetime, timezone
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
COMPOSE = ["docker", "compose", "--env-file", ".env"]
INTRO = """\
Приложение -- учебный мессенджер: HTTP API (FastAPI) и база PostgreSQL.
* Сам API состояния не хранит: пользователи, чаты, участники, сообщения и сессии
лежат в PostgreSQL (таблицы users, chats, chat_members, messages, sessions).
* Файлы PostgreSQL лежат не в контейнере, а в именованном томе Docker (pgdata).
Контейнеры api и db временные, том постоянный.
* Пароль хранится как scrypt-хеш, у сессии в БД лежит только SHA-256 токена,
срок сессии считает сама БД -- перезапуск его не продлевает и не сбрасывает.
Ожидание: пока том не удалён (команда down -v здесь НЕ используется), после
%(what)s
те же пользователи, чат, сообщение и тот же токен продолжают работать.
План: (1) создать данные через API, (2) показать их в БД, (3) выключить,
(4) включить, (5) проверить, что данные и токены прежние.
"""
class Fail(Exception):
"""Проверка не прошла или стенд не запущен."""
class Log:
"""Печатает строки на экран и копит их для файла evidence/storage.txt."""
def __init__(self):
self.lines = []
def say(self, text=""):
self.lines.append(text)
print(text, flush=True)
def title(self, text):
self.say("")
self.say("=" * 78)
self.say(text)
self.say("=" * 78)
def show(args):
"""Команда в виде строки для листинга (аргументы с пробелами в кавычках)."""
parts = []
for arg in args:
if arg == "" or " " in arg:
quote = "'" if '"' in arg else '"'
parts.append(quote + arg + quote)
else:
parts.append(arg)
return " ".join(parts)
def run(log, args, must_succeed=True):
"""Выполнить команду, записать её и вывод в листинг, вернуть вывод текстом."""
log.say("$ " + show(args))
try:
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
except FileNotFoundError:
raise Fail("команда не найдена: %s (установлен ли Docker Desktop?)" % args[0])
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
if output:
log.say(output)
if must_succeed and done.returncode != 0:
raise Fail("команда завершилась с кодом %d" % done.returncode)
return output
def read_env():
"""Прочитать .env (KEY=VALUE) в словарь. Пароль скрипту не нужен: psql внутри db заходит по сокету."""
values = {}
path = ROOT / ".env"
if path.exists():
for line in path.read_text(encoding="utf-8").splitlines():
line = line.strip()
if line and not line.startswith("#") and "=" in line:
key, _, value = line.partition("=")
values[key.strip()] = value.strip()
return values
def sql(log, query):
"""SELECT внутри контейнера db. Команда в листинге копируется в консоль как есть."""
env = read_env()
user = env.get("POSTGRES_USER", "messenger")
database = env.get("POSTGRES_DB", "messenger")
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", database, "-c", query])
def http(base, method, path, body=None, headers=None, timeout=10):
"""HTTP-запрос к API. Возвращает (статус, JSON или None)."""
data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
request_headers = {"Accept": "application/json"}
if body is not None:
request_headers["Content-Type"] = "application/json"
request_headers.update(headers or {})
request = urllib.request.Request(base + path, data=data, method=method, headers=request_headers)
try:
response = urllib.request.urlopen(request, timeout=timeout)
status, payload = response.status, response.read()
except urllib.error.HTTPError as error:
status, payload = error.code, error.read()
return status, (json.loads(payload) if payload else None)
def masked(value):
"""Копия ответа без токена: токены в evidence не сохраняем."""
if isinstance(value, dict):
return {
key: ("<скрыт, %d симв.>" % len(item) if key == "token" and isinstance(item, str) else masked(item))
for key, item in value.items()
}
if isinstance(value, list):
return [masked(item) for item in value]
return value
def call(log, base, method, path, expected, body=None, headers=None, note=""):
"""HTTP-запрос с проверкой статуса и записью в листинг (без паролей и токенов)."""
status, payload = http(base, method, path, body, headers)
shown = dict(body) if isinstance(body, dict) else body
if isinstance(shown, dict) and "password" in shown:
shown["password"] = "***"
log.say("$ %s %s %s" % (method, path, (" # " + note) if note else ""))
if shown is not None:
log.say(" тело запроса: " + json.dumps(shown, ensure_ascii=False))
log.say(" ответ: %d %s" % (status, json.dumps(masked(payload), ensure_ascii=False)))
if status != expected:
raise Fail("%s %s: ожидали %d, получили %d" % (method, path, expected, status))
return payload
def wait_ready(base, seconds):
"""Ждать, пока /health/ready ответит 200. Возвращает, сколько секунд ждали."""
started = time.monotonic()
while time.monotonic() - started < seconds:
try:
status, _ = http(base, "GET", "/health/ready", timeout=3)
if status == 200:
return time.monotonic() - started
except (urllib.error.URLError, OSError, ValueError):
pass
time.sleep(1)
raise Fail("API не стал готовым за %d с" % seconds)
def is_down(base):
"""True, если API сейчас не отвечает (контейнеры выключены)."""
try:
http(base, "GET", "/health/live", timeout=3)
return False
except (urllib.error.URLError, OSError, ValueError):
return True
def volume_name(log):
"""Имя тома pgdata (оно зависит от имени проекта compose)."""
out = run(log, ["docker", "volume", "ls", "--filter", "name=pgdata", "--format", "{{.Name}}"])
names = [line.strip() for line in out.splitlines() if line.strip()]
if not names:
raise Fail("том pgdata не найден: стенд не запускали? (docker compose --env-file .env up -d --build)")
return names[0]
def volume_info(log, name):
return run(log, ["docker", "volume", "inspect", name, "--format", "{{.Name}} создан: {{.CreatedAt}}"])
def basic(username, password):
raw = (username + ":" + password).encode("utf-8")
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
def bearer(token):
return {"Authorization": "Bearer " + token}
def scenario(log, args):
base = args.base_url.rstrip("/")
down_mode = args.mode == "down"
what = (
"удаления и повторного создания контейнеров (docker compose down, затем up -d)"
if down_mode
else "остановки и повторного запуска контейнеров (docker compose stop, затем start)"
)
log.title("1. Как устроено приложение")
log.say(INTRO % {"what": what})
log.title("2. Состояние до начала")
try:
status, _ = http(base, "GET", "/health/ready")
except (urllib.error.URLError, OSError, ValueError):
status = 0
if status != 200:
raise Fail("API не отвечает на %s. Поднимите стенд: docker compose --env-file .env up -d --build" % base)
run(log, COMPOSE + ["ps"])
volume = volume_name(log)
volume_before = volume_info(log, volume)
log.title("3. Запись данных через API (создаём пользователей, чат, сообщение)")
suffix = uuid.uuid4().hex[:8]
alice_name, bob_name = "evidence_a_" + suffix, "evidence_b_" + suffix
alice_pass, bob_pass = "Storage-" + uuid.uuid4().hex, "Storage-" + uuid.uuid4().hex
alice = call(log, base, "POST", "/api/v1/users", 201,
{"username": alice_name, "display_name": "Алиса (evidence)", "password": alice_pass},
note="регистрация Алисы")
bob = call(log, base, "POST", "/api/v1/users", 201,
{"username": bob_name, "display_name": "Боб (evidence)", "password": bob_pass},
note="регистрация Боба")
alice_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
headers=basic(alice_name, alice_pass), note="вход Алисы (Basic)")["token"]
bob_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
headers=basic(bob_name, bob_pass), note="вход Боба (Basic)")["token"]
chat = call(log, base, "POST", "/api/v1/chats", 201,
{"title": "Проверка сохранности " + suffix, "member_ids": [alice["id"], bob["id"]]},
headers=bearer(alice_token), note="чат Алисы и Боба (Bearer)")
message = call(log, base, "POST", "/api/v1/chats/%s/messages" % chat["id"], 201,
{"text": "Это сообщение должно пережить перезапуск " + suffix},
headers=bearer(alice_token), note="сообщение Алисы")
log.title("4. Что лежит в PostgreSQL ДО выключения (SELECT внутри контейнера db)")
queries = {
"пользователи (пароль -- только префикс хеша)":
"SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at "
"FROM users WHERE username IN ('%s', '%s') ORDER BY username" % (alice_name, bob_name),
"чат и число участников":
"SELECT c.title, count(m.user_id) AS members FROM chats c "
"JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '%s' GROUP BY c.title" % chat["id"],
"сообщение":
"SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '%s'" % chat["id"],
"действующие сессии (токены не показываем)":
"SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id "
"WHERE u.username IN ('%s', '%s') AND s.expires_at > now()" % (alice_name, bob_name),
}
before = {}
for title, query in queries.items():
log.say("-- " + title)
before[title] = sql(log, query)
log.title("5. Выключаем приложение" + (" (контейнеры УДАЛЯЮТСЯ, том остаётся)" if down_mode else ""))
if down_mode:
run(log, COMPOSE + ["down"])
run(log, COMPOSE + ["ps", "-a"], must_succeed=False)
else:
run(log, COMPOSE + ["stop", "api", "db"])
run(log, COMPOSE + ["ps", "-a"])
if not is_down(base):
raise Fail("после выключения API всё ещё отвечает")
log.say("API на %s не отвечает -- приложение выключено (так и должно быть)." % base)
log.say("-- том с данными на месте:")
run(log, ["docker", "volume", "ls", "--filter", "name=pgdata"])
log.title("6. Включаем снова")
if down_mode:
run(log, COMPOSE + ["up", "-d"])
else:
run(log, COMPOSE + ["start", "db", "api"])
waited = wait_ready(base, args.wait)
log.say("API снова готов (/health/ready = 200) через %.0f с." % waited)
run(log, COMPOSE + ["ps"])
log.title("7. Проверка ПОСЛЕ перезапуска: те же данные и те же токены")
me = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token),
note="старый токен Алисы, повторный вход НЕ делали")
if me != alice:
raise Fail("пользователь после перезапуска отличается: %r != %r" % (me, alice))
log.say(" OK: тот же пользователь (id, username, created_at совпали).")
page = call(log, base, "GET", "/api/v1/chats/%s/messages" % chat["id"], 200,
headers=bearer(bob_token), note="старый токен Боба читает историю чата")
if page["items"] != [message]:
raise Fail("история чата отличается от записанной до перезапуска")
log.say(" OK: то же сообщение (id, text, created_at совпали).")
listed = call(log, base, "GET", "/api/v1/chats?limit=100", 200, headers=bearer(alice_token),
note="список чатов Алисы")
if not any(item["id"] == chat["id"] for item in listed["items"]):
raise Fail("чат пропал из списка")
log.say(" OK: чат в списке.")
log.say("")
log.say("Те же SELECT после перезапуска (сравниваем с выводом из пункта 4):")
for title, query in queries.items():
log.say("-- " + title)
after = sql(log, query)
if after != before[title]:
raise Fail("результат SELECT изменился: " + title)
log.say(" OK: вывод идентичен выводу до перезапуска.")
log.say("")
log.say("-- том тот же (дата создания не изменилась):")
volume_after = volume_info(log, volume)
if volume_after != volume_before:
raise Fail("том изменился: был «%s», стал «%s»" % (volume_before, volume_after))
log.say(" OK: том не пересоздавался.")
log.title("ИТОГ")
log.say("ИТОГ: PASS -- пользователи, чат, сообщение и действующие сессии сохранились после "
+ what + ".")
def commit_hash():
try:
done = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
capture_output=True, text=True, timeout=5)
return done.stdout.strip() if done.returncode == 0 and done.stdout.strip() else "нет"
except Exception:
return "нет"
def main():
parser = argparse.ArgumentParser(description="Доказательство сохранности данных после перезапуска")
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--output", default="evidence/storage.txt")
parser.add_argument("--mode", choices=["down", "stop"], default="down",
help="down: удалить и создать контейнеры (по умолчанию); stop: остановить и запустить")
parser.add_argument("--wait", type=int, default=90, help="сколько секунд ждать готовности API")
args = parser.parse_args()
if hasattr(sys.stdout, "reconfigure"):
sys.stdout.reconfigure(encoding="utf-8", errors="replace")
log = Log()
code = 0
try:
scenario(log, args)
except Fail as error:
log.say("")
log.say("ИТОГ: FAIL -- " + str(error))
code = 1
header = [
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
"# Система: %s, Python %s" % (platform.platform(), platform.python_version()),
"# Commit: " + commit_hash(),
"# Команда: python scripts/storage_demo.py --mode " + args.mode,
"",
]
target = Path(args.output)
if not target.is_absolute():
target = ROOT / target
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text("\n".join(header + log.lines) + "\n", encoding="utf-8")
print("\n[сохранено в %s]" % target)
return code
if __name__ == "__main__":
sys.exit(main())
+257
View File
@@ -0,0 +1,257 @@
"""Общие фикстуры тестов.
Тесты работают с настоящим PostgreSQL (отдельная БД messenger_test) и,
если задан TEST_CACHE_URL, с Redis.
"""
import asyncio
import base64
import os
import uuid
from pathlib import Path
from typing import Optional
import asyncpg
import pytest
from fastapi.testclient import TestClient
from app.config import Settings
from app.main import create_app
ROOT = Path(__file__).resolve().parents[1]
TEST_DB_NAME = "messenger_test"
def read_dotenv() -> dict:
"""Прочитать .env из корня проекта в словарь."""
values = {}
path = ROOT / ".env"
if path.exists():
for line in path.read_text(encoding="utf-8").splitlines():
line = line.strip()
if line and not line.startswith("#") and "=" in line:
key, _, value = line.partition("=")
values[key.strip()] = value.strip()
return values
def database_parts() -> dict:
"""Параметры подключения к тестовой БД из TEST_DB_* или .env."""
env = read_dotenv()
return {
"user": os.environ.get("TEST_DB_USER", env.get("POSTGRES_USER", "messenger")),
"password": os.environ.get(
"TEST_DB_PASSWORD", env.get("POSTGRES_PASSWORD", "")
),
"host": os.environ.get("TEST_DB_HOST", "127.0.0.1"),
"port": int(os.environ.get("TEST_DB_PORT", "5433")),
}
def sqlalchemy_url(database: str = TEST_DB_NAME) -> str:
"""URL тестовой БД для SQLAlchemy."""
p = database_parts()
return "postgresql+asyncpg://%s:%s@%s:%d/%s" % (
p["user"],
p["password"],
p["host"],
p["port"],
database,
)
@pytest.fixture(scope="session", autouse=True)
def test_database():
"""Проверить доступность PostgreSQL и создать тестовую БД."""
p = database_parts()
async def prepare():
conn = await asyncpg.connect(
user=p["user"],
password=p["password"],
host=p["host"],
port=p["port"],
database="postgres",
timeout=5,
)
try:
exists = await conn.fetchval(
"SELECT 1 FROM pg_database WHERE datname = $1", TEST_DB_NAME
)
if not exists:
await conn.execute(
"CREATE DATABASE \"%s\" TEMPLATE template0 ENCODING 'UTF8'"
% TEST_DB_NAME
)
finally:
await conn.close()
try:
asyncio.run(prepare())
except Exception as error:
pytest.exit(
"PostgreSQL недоступен на %s:%s (%s). Запустите БД: "
"docker compose --env-file .env up -d db"
% (p["host"], p["port"], type(error).__name__),
returncode=2,
)
CACHE_URL = os.environ.get("TEST_CACHE_URL", "")
def make_settings(**overrides) -> Settings:
"""Настройки приложения для тестов с переопределением полей."""
base = Settings.from_env(
{
"DATABASE_URL": sqlalchemy_url(),
"DB_STARTUP_WAIT_SECONDS": "5",
"LOG_LEVEL": "INFO",
"CACHE_URL": CACHE_URL,
}
)
return Settings(**{**base.__dict__, **overrides})
def run_sql(query: str, *args):
"""Выполнить SQL в тестовой БД напрямую и вернуть строки."""
p = database_parts()
async def go():
conn = await asyncpg.connect(
user=p["user"],
password=p["password"],
host=p["host"],
port=p["port"],
database=TEST_DB_NAME,
timeout=5,
)
try:
return await conn.fetch(query, *args)
finally:
await conn.close()
return asyncio.run(go())
@pytest.fixture(scope="session")
def client(test_database):
"""Клиент приложения, общий для всего прогона."""
with TestClient(
create_app(make_settings()), raise_server_exceptions=False
) as test_client:
yield test_client
class Person:
"""Зарегистрированный пользователь с токеном и заголовками."""
def __init__(self, data: dict, password: str, token: str):
self.data = data
self.id = data["id"]
self.username = data["username"]
self.password = password
self.token = token
self.headers = {"Authorization": "Bearer " + token}
def basic_header(username: str, password: str) -> dict:
"""Заголовок Authorization: Basic."""
raw = (username + ":" + password).encode("utf-8")
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
def register_and_login(client: TestClient, name: str = "") -> Person:
"""Зарегистрировать уникального пользователя и войти."""
username = ("u_" + name + "_" + uuid.uuid4().hex[:10]).lower()
password = "T3st-pass-" + uuid.uuid4().hex
created = client.post(
"/api/v1/users",
json={
"username": username,
"display_name": "Тест " + name,
"password": password,
},
)
assert created.status_code == 201, created.text
session = client.post(
"/api/v1/auth/sessions", headers=basic_header(username, password)
)
assert session.status_code == 201, session.text
return Person(created.json(), password, session.json()["token"])
@pytest.fixture
def make_user(client):
"""Фабрика пользователей."""
return lambda name="": register_and_login(client, name)
@pytest.fixture
def make_chat(client):
"""Фабрика чатов."""
def factory(owner: Person, *others: Person, title: str = "Чат") -> dict:
members = [owner.id] + [p.id for p in others]
reply = client.post(
"/api/v1/chats",
json={"title": title, "member_ids": members},
headers=owner.headers,
)
assert reply.status_code == 201, reply.text
return reply.json()
return factory
@pytest.fixture
def alice(make_user):
"""Пользователь alice."""
return make_user("alice")
@pytest.fixture
def bob(make_user):
"""Пользователь bob."""
return make_user("bob")
@pytest.fixture
def eve(make_user):
"""Пользователь eve, не состоящий в чате."""
return make_user("eve")
@pytest.fixture
def chat(make_chat, alice, bob):
"""Чат alice и bob."""
return make_chat(alice, bob)
@pytest.fixture
def log_lines():
"""Собрать сообщения лога приложения."""
import logging
lines = []
class Collector(logging.Handler):
def emit(self, record):
lines.append(record.getMessage())
handler = Collector()
logger = logging.getLogger("messenger")
logger.addHandler(handler)
yield lines
logger.removeHandler(handler)
def assert_error(reply, status: int, code: str):
"""Проверить статус, код и формат тела ошибки."""
assert reply.status_code == status, reply.text
body = reply.json()
assert set(body) == {"error"}
assert set(body["error"]) == {"code", "message", "request_id"}
assert body["error"]["code"] == code
assert body["error"]["message"]
assert body["error"]["request_id"] == reply.headers["X-Request-Id"]
+193
View File
@@ -0,0 +1,193 @@
"""Регистрация, вход по Basic, доступ по Bearer и выход."""
import base64
import uuid
import pytest
from conftest import assert_error, basic_header, register_and_login
BAD_BASIC = [
"Basic",
"Basic !!!not-base64!!!",
"Basic " + base64.b64encode(b"nocolon").decode(),
"Basic " + base64.b64encode("имя:password-123456".encode()).decode(),
"Basic " + base64.b64encode(b"user:\xff\xfe-bad-utf8").decode(),
"Bearer abc",
"",
]
def test_register_returns_user_without_secrets(client):
reply = client.post(
"/api/v1/users",
json={
"username": "reg_" + uuid.uuid4().hex[:8],
"display_name": "Имя",
"password": "long-enough-pass",
},
)
assert reply.status_code == 201
assert set(reply.json()) == {"id", "username", "display_name", "created_at"}
assert "password" not in reply.text and "hash" not in reply.text
@pytest.mark.parametrize(
"password", [None, "", "short", "a" * 11, "a" * 129, 123456789012, "пароль"]
)
def test_register_password_rules(client, password):
body = {"username": "pw_" + uuid.uuid4().hex[:8], "display_name": "x"}
if password is not None:
body["password"] = password
assert_error(client.post("/api/v1/users", json=body), 400, "invalid_request")
def test_register_password_border_lengths(client):
for password in ["a" * 12, "я" * 128, "p:a:s:s:w:o:r:d:1:2:3"]:
body = {
"username": "pb_" + uuid.uuid4().hex[:8],
"display_name": "x",
"password": password,
}
assert client.post("/api/v1/users", json=body).status_code == 201
def test_login_success_shape(client, alice):
reply = client.post(
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
)
assert reply.status_code == 201
data = reply.json()
assert set(data) == {"token", "token_type", "expires_at", "user"}
assert data["token_type"] == "Bearer" and len(data["token"]) >= 32
assert data["user"] == alice.data
assert data["expires_at"].endswith("Z")
def test_each_login_gives_new_token(client, alice):
second = client.post(
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
).json()["token"]
assert second != alice.token
def test_wrong_password_and_unknown_user_look_the_same(client, alice):
wrong = client.post(
"/api/v1/auth/sessions",
headers=basic_header(alice.username, "wrong-password-123"),
)
unknown = client.post(
"/api/v1/auth/sessions",
headers=basic_header("no_such_user_x", "wrong-password-123"),
)
assert_error(wrong, 401, "unauthorized")
assert_error(unknown, 401, "unauthorized")
assert wrong.headers["WWW-Authenticate"] == unknown.headers["WWW-Authenticate"]
assert wrong.headers["WWW-Authenticate"].startswith('Basic realm="messenger"')
assert wrong.json()["error"]["message"] == unknown.json()["error"]["message"]
@pytest.mark.parametrize("header", BAD_BASIC)
def test_malformed_basic_is_401(client, header):
reply = client.post("/api/v1/auth/sessions", headers={"Authorization": header})
assert_error(reply, 401, "unauthorized")
assert reply.headers["WWW-Authenticate"].startswith("Basic")
def test_login_without_header_is_401(client):
assert_error(client.post("/api/v1/auth/sessions"), 401, "unauthorized")
def test_password_with_colon_and_unicode_works(client):
for password in ["pass:with:colons:123", "пароль-с-юникодом-😀-123"]:
username = "uc_" + uuid.uuid4().hex[:8]
client.post(
"/api/v1/users",
json={"username": username, "display_name": "x", "password": password},
)
reply = client.post(
"/api/v1/auth/sessions", headers=basic_header(username, password)
)
assert reply.status_code == 201, password
def test_bearer_token_gives_access(client, alice):
reply = client.get("/api/v1/users/me", headers=alice.headers)
assert reply.status_code == 200 and reply.json() == alice.data
def test_business_endpoint_rejects_basic(client, alice):
reply = client.get(
"/api/v1/users/me", headers=basic_header(alice.username, alice.password)
)
assert_error(reply, 401, "unauthorized")
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
@pytest.mark.parametrize(
"header",
["", "Bearer", "Bearer short", "Bearer " + "x" * 43, "Token abc", "bearer"],
)
def test_bad_or_unknown_bearer_is_401(client, header):
headers = {"Authorization": header} if header else {}
reply = client.get("/api/v1/users/me", headers=headers)
assert_error(reply, 401, "unauthorized")
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
def test_x_user_id_alone_gives_no_access(client, alice):
assert_error(
client.get("/api/v1/users/me", headers={"X-User-Id": alice.id}),
401,
"unauthorized",
)
def test_x_user_id_does_not_change_owner_of_session(client, alice, bob):
reply = client.get(
"/api/v1/users/me", headers={**alice.headers, "X-User-Id": bob.id}
)
assert reply.json()["id"] == alice.id
def test_logout_revokes_token_and_repeat_is_401(client, alice):
first = client.delete("/api/v1/auth/sessions/current", headers=alice.headers)
assert first.status_code == 204 and first.content == b""
assert_error(
client.get("/api/v1/users/me", headers=alice.headers), 401, "unauthorized"
)
assert_error(
client.delete("/api/v1/auth/sessions/current", headers=alice.headers),
401,
"unauthorized",
)
def test_logout_without_token_is_401(client):
assert_error(client.delete("/api/v1/auth/sessions/current"), 401, "unauthorized")
def test_logout_revokes_only_current_session(client, alice):
second = client.post(
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
).json()["token"]
client.delete("/api/v1/auth/sessions/current", headers=alice.headers)
assert (
client.get(
"/api/v1/users/me", headers={"Authorization": "Bearer " + second}
).status_code
== 200
)
def test_session_lives_longer_than_300_seconds(client, alice):
"""Сессия по умолчанию живёт не меньше 300 секунд."""
from datetime import datetime, timezone
data = client.post(
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
).json()
left = datetime.fromisoformat(data["expires_at"][:-1] + "+00:00") - datetime.now(
timezone.utc
)
assert left.total_seconds() > 300
+190
View File
@@ -0,0 +1,190 @@
"""Кэш сессий в Redis: попадания, TTL, отзыв и недоступность Redis."""
import hashlib
import json
import time
from dataclasses import replace
import pytest
import redis
from fastapi.testclient import TestClient
from redis.asyncio import Redis as AsyncRedis
from app.main import create_app
from conftest import CACHE_URL, assert_error, make_settings, register_and_login, run_sql
pytestmark = pytest.mark.skipif(
not CACHE_URL, reason="TEST_CACHE_URL не задан (запускайте тесты в контейнере)"
)
DEAD_REDIS = "redis://127.0.0.1:1/0"
def key_for(person) -> str:
"""Ключ Redis для токена пользователя."""
return "session:" + hashlib.sha256(person.token.encode()).hexdigest()
@pytest.fixture
def store():
"""Синхронный клиент тестовой базы Redis."""
client = redis.Redis.from_url(CACHE_URL, decode_responses=True)
client.flushdb()
yield client
client.close()
@pytest.fixture
def cached(store):
"""Клиент приложения с включённым кэшем."""
with TestClient(create_app(make_settings()), raise_server_exceptions=False) as app_client:
yield app_client
def test_token_check_is_served_from_cache_with_bounded_ttl(cached, store):
person = register_and_login(cached, "cache")
stats = cached.app.state.cache.stats
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert stats["misses"] == 1 and stats["hits"] == 0
ttl_ms = store.pttl(key_for(person))
assert 0 < ttl_ms <= 60_000
value = json.loads(store.get(key_for(person)))
assert set(value) == {"id", "username", "display_name", "created_at"}
assert (value["id"], value["username"]) == (person.id, person.username)
for _ in range(5):
reply = cached.get("/api/v1/users/me", headers=person.headers)
assert reply.status_code == 200 and reply.json() == person.data
assert stats["hits"] == 5
def test_cache_never_stores_raw_tokens_or_passwords(cached, store):
person = register_and_login(cached, "secret")
cached.get("/api/v1/users/me", headers=person.headers)
dump = " ".join(k + "=" + (store.get(k) or "") for k in store.scan_iter())
assert person.token not in dump
assert person.password not in dump
assert "scrypt" not in dump
def test_logout_revokes_cached_session(cached, store):
person = register_and_login(cached, "logout")
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert store.get(key_for(person)) is not None
assert cached.delete("/api/v1/auth/sessions/current", headers=person.headers).status_code == 204
assert store.get(key_for(person)) == "revoked"
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
assert_error(
cached.delete("/api/v1/auth/sessions/current", headers=person.headers), 401, "unauthorized"
)
def test_late_cache_fill_cannot_resurrect_revoked_session(cached, store):
"""Запоздалая запись в кэш не отменяет отзыв сессии."""
person = register_and_login(cached, "race")
cached.delete("/api/v1/auth/sessions/current", headers=person.headers)
token_hash = hashlib.sha256(person.token.encode()).hexdigest()
stale = {k: person.data[k] for k in ("id", "username", "display_name", "created_at")}
cached.portal.call(cached.app.state.cache.put, token_hash, stale, 3600.0)
assert store.get(key_for(person)) == "revoked"
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
def test_flushed_cache_loses_nothing(cached, store):
"""После очистки Redis сессия читается из PostgreSQL."""
person = register_and_login(cached, "flush")
cached.get("/api/v1/users/me", headers=person.headers)
store.flushdb()
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert store.exists(key_for(person))
def test_cache_does_not_extend_short_session():
"""TTL записи в кэше не больше остатка сессии."""
settings = make_settings(session_ttl_seconds=1)
with TestClient(create_app(settings), raise_server_exceptions=False) as short:
person = register_and_login(short, "short")
assert short.get("/api/v1/users/me", headers=person.headers).status_code == 200
time.sleep(2.2)
reply = short.get("/api/v1/users/me", headers=person.headers)
assert_error(reply, 401, "unauthorized")
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
def test_staleness_after_out_of_band_delete_is_bounded_by_cache_ttl(store):
"""Удаление сессии мимо API видно не позже CACHE_TTL_SECONDS."""
settings = make_settings(cache_ttl_seconds=1)
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
person = register_and_login(app_client, "bounded")
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
run_sql("DELETE FROM sessions WHERE token_hash = $1",
hashlib.sha256(person.token.encode()).hexdigest())
time.sleep(1.3)
assert_error(app_client.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
def test_redis_down_requests_bypass_cache_and_stay_fast():
settings = make_settings(cache_url=DEAD_REDIS)
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
assert app_client.get("/health/ready").status_code == 200
alice = register_and_login(app_client, "nocache_a")
bob = register_and_login(app_client, "nocache_b")
started = time.monotonic()
assert app_client.get("/api/v1/users/me", headers=alice.headers).json() == alice.data
chat = app_client.post(
"/api/v1/chats", json={"title": "без кэша", "member_ids": [alice.id, bob.id]},
headers=alice.headers,
)
assert chat.status_code == 201
path = "/api/v1/chats/%s/messages" % chat.json()["id"]
assert app_client.post(path, json={"text": "привет"}, headers=alice.headers).status_code == 201
assert len(app_client.get(path, headers=bob.headers).json()["items"]) == 1
assert time.monotonic() - started < 3
assert app_client.app.state.cache.stats["errors"] >= 1
assert app_client.delete("/api/v1/auth/sessions/current", headers=alice.headers).status_code == 204
assert_error(app_client.get("/api/v1/users/me", headers=alice.headers), 401, "unauthorized")
def test_redis_down_never_trusts_anonymous_or_unknown_tokens():
settings = make_settings(cache_url=DEAD_REDIS)
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
person = register_and_login(app_client, "anon")
for headers in (
{},
{"X-User-Id": person.id},
{"Authorization": "Bearer " + "B" * 43},
{"Authorization": "Basic " + "eDp5"},
):
reply = app_client.get("/api/v1/users/me", headers=headers)
assert_error(reply, 401, "unauthorized")
def test_revocation_lost_while_redis_down_is_flushed_on_recovery(cached, store):
"""Отзыв, потерянный при сбое Redis, приводит к очистке кэша."""
cache = cached.app.state.cache
person = register_and_login(cached, "lost")
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
assert store.exists(key_for(person))
working = cache.client
cache.client = AsyncRedis.from_url(DEAD_REDIS, socket_connect_timeout=0.2, socket_timeout=0.2)
cache.retry_seconds = 0
assert cached.delete("/api/v1/auth/sessions/current", headers=person.headers).status_code == 204
assert cache.dirty is True
assert store.exists(key_for(person)), "старая запись осталась в Redis -- ровно опасный случай"
cache.client = working
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
assert cache.dirty is False
assert not store.exists(key_for(person))
def test_without_cache_url_cache_is_off():
settings = replace(make_settings(), cache_url="")
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
assert app_client.app.state.cache.enabled is False
person = register_and_login(app_client, "off")
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
+61
View File
@@ -0,0 +1,61 @@
"""Параллельная запись: сообщения не теряются и не дублируются."""
import threading
from concurrent.futures import ThreadPoolExecutor
CLIENTS = 10
PER_CLIENT = 10
def test_100_messages_from_10_clients_in_parallel(client, make_user, make_chat):
people = [make_user("c%d" % n) for n in range(CLIENTS)]
chat = make_chat(people[0], *people[1:])
url = "/api/v1/chats/" + chat["id"] + "/messages"
start_together = threading.Barrier(CLIENTS)
def worker(index):
start_together.wait()
return [
client.post(
url,
json={"text": "c%d-m%d" % (index, n)},
headers=people[index].headers,
).status_code
for n in range(PER_CLIENT)
]
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
results = list(pool.map(worker, range(CLIENTS)))
assert all(code == 201 for codes in results for code in codes)
page = client.get(url + "?limit=100", headers=people[0].headers).json()
items = page["items"]
assert len(items) == 100 and page["next_cursor"] is None
assert len({m["id"] for m in items}) == 100
assert {m["text"] for m in items} == {
"c%d-m%d" % (c, n) for c in range(CLIENTS) for n in range(PER_CLIENT)
}
stamps = [m["created_at"] for m in items]
assert stamps == sorted(stamps)
for index in range(CLIENTS):
own = [m["text"] for m in items if m["sender_id"] == people[index].id]
assert own == ["c%d-m%d" % (index, n) for n in range(PER_CLIENT)]
def test_parallel_chat_creation_and_reading(client, make_user):
owner, friend = make_user("owner"), make_user("friend")
def create(number):
made = client.post(
"/api/v1/chats",
json={"title": "n%d" % number, "member_ids": [owner.id, friend.id]},
headers=owner.headers,
)
listing = client.get("/api/v1/chats?limit=100", headers=friend.headers)
return made.status_code, listing.status_code
with ThreadPoolExecutor(max_workers=10) as pool:
results = list(pool.map(create, range(30)))
assert all(r == (201, 200) for r in results)
final = client.get("/api/v1/chats?limit=100", headers=friend.headers).json()
assert len(final["items"]) == 30 and len({c["id"] for c in final["items"]}) == 30
+95
View File
@@ -0,0 +1,95 @@
"""Общие свойства API: заголовки, формат ошибок, health и логи."""
import re
from conftest import assert_error
def test_health_endpoints(client):
assert client.get("/health/live").json() == {"status": "ok"}
assert client.get("/health/ready").json() == {"status": "ok"}
def test_every_response_has_unique_request_id(client, alice):
seen = set()
for reply in [
client.get("/health/live"),
client.get("/health/ready"),
client.get("/api/v1/users/me", headers=alice.headers),
client.get("/api/v1/users/me"),
client.get("/no/such/page"),
client.delete("/api/v1/chats"),
]:
assert reply.headers.get("X-Request-Id")
seen.add(reply.headers["X-Request-Id"])
assert len(seen) == 6
def test_unknown_path_is_404_in_common_format(client):
assert_error(client.get("/api/v1/nothing"), 404, "not_found")
def test_trailing_slash_is_not_redirected(client, alice):
assert_error(
client.get("/api/v1/chats/", headers=alice.headers, follow_redirects=False),
404,
"not_found",
)
def test_wrong_method_is_405_in_common_format(client):
assert_error(client.delete("/api/v1/users"), 405, "invalid_request")
def test_two_users_one_chat_two_messages(client, alice, bob, eve, chat):
"""Двое переписываются, посторонний получает 404."""
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert (
client.post(
url, json={"text": "Привет, Боб!"}, headers=alice.headers
).status_code
== 201
)
assert (
client.post(
url, json={"text": "Привет, Алиса!"}, headers=bob.headers
).status_code
== 201
)
history = client.get(url, headers=alice.headers).json()["items"]
assert [m["text"] for m in history] == ["Привет, Боб!", "Привет, Алиса!"]
assert [m["sender_id"] for m in history] == [alice.id, bob.id]
assert client.get(url, headers=eve.headers).status_code == 404
def test_chat_response_shape(client, alice, bob, chat):
assert set(chat) == {"id", "title", "member_ids", "created_at"}
assert set(chat["member_ids"]) == {alice.id, bob.id}
assert re.fullmatch(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{6}Z", chat["created_at"])
assert client.get("/api/v1/chats/" + chat["id"], headers=bob.headers).json() == chat
def test_unexpected_exception_gives_500_without_details(client, log_lines):
async def boom():
raise RuntimeError("ТАЙНЫЙ-ТЕКСТ-ИЗ-ОШИБКИ")
client.app.add_api_route("/boom", boom)
reply = client.get("/boom")
assert_error(reply, 500, "internal_error")
assert "ТАЙНЫЙ" not in reply.text
assert not any("ТАЙНЫЙ" in line for line in log_lines)
assert any("unhandled_error" in line for line in log_lines)
def test_logs_have_requests_but_no_secrets(client, alice, chat, log_lines):
"""В логе есть запросы, но нет текста сообщений, паролей и токенов."""
secret = "ОЧЕНЬ-СЕКРЕТНОЕ-СООБЩЕНИЕ-12345"
url = "/api/v1/chats/" + chat["id"] + "/messages"
client.post(url, json={"text": secret}, headers=alice.headers)
client.get(url, headers=alice.headers)
joined = "\n".join(log_lines)
assert (
"method=POST" in joined and "status=201" in joined and "request_id=" in joined
)
for hidden in (secret, alice.token, alice.password):
assert hidden not in joined
+172
View File
@@ -0,0 +1,172 @@
"""Содержимое PostgreSQL: хеши, ограничения, миграции и атомарность."""
import asyncio
import uuid
import asyncpg
import pytest
from app.db import create_engine
from app.migrate import run_migrations
from conftest import make_settings, run_sql
def test_password_is_stored_as_scrypt_hash_not_plaintext(client, make_user):
one, two = make_user("hash1"), make_user("hash2")
rows = run_sql(
"SELECT username, password_hash FROM users WHERE username = ANY($1)",
[one.username, two.username],
)
hashes = {row["username"]: row["password_hash"] for row in rows}
assert hashes[one.username].startswith("scrypt$")
assert one.password not in hashes[one.username]
assert hashes[one.username] != hashes[two.username]
def test_same_password_gives_different_hashes(client):
password = "same-password-for-both"
for _ in range(2):
client.post(
"/api/v1/users",
json={
"username": "sp_" + uuid.uuid4().hex[:10],
"display_name": "x",
"password": password,
},
)
rows = run_sql("SELECT password_hash FROM users ORDER BY created_at DESC LIMIT 2")
assert rows[0]["password_hash"] != rows[1]["password_hash"]
def test_session_table_keeps_token_hash_not_token(client, alice):
rows = run_sql(
"SELECT token_hash FROM sessions WHERE user_id = $1", uuid.UUID(alice.id)
)
assert len(rows) == 1
assert len(rows[0]["token_hash"]) == 64 and rows[0]["token_hash"] != alice.token
assert alice.token not in rows[0]["token_hash"]
def test_message_is_really_in_the_database(client, alice, chat):
client.post(
"/api/v1/chats/" + chat["id"] + "/messages",
json={"text": "в базе"},
headers=alice.headers,
)
rows = run_sql(
"SELECT text, sender_id FROM messages WHERE chat_id = $1", uuid.UUID(chat["id"])
)
assert [(r["text"], str(r["sender_id"])) for r in rows] == [("в базе", alice.id)]
def test_migrations_can_run_again_without_duplicating_anything(client, alice):
users_before = run_sql("SELECT count(*) AS n FROM users")[0]["n"]
versions_before = [
r["version"]
for r in run_sql("SELECT version FROM schema_migrations ORDER BY version")
]
async def twice():
engine = create_engine(make_settings())
try:
return [await run_migrations(engine), await run_migrations(engine)]
finally:
await engine.dispose()
first, second = asyncio.run(twice())
assert first == [] and second == []
assert run_sql("SELECT count(*) AS n FROM users")[0]["n"] == users_before
assert [
r["version"]
for r in run_sql("SELECT version FROM schema_migrations ORDER BY version")
] == versions_before
assert versions_before == ["0001_init.sql"]
def test_expected_tables_and_indexes_exist(client):
tables = {
r["tablename"]
for r in run_sql("SELECT tablename FROM pg_tables WHERE schemaname = 'public'")
}
assert {
"users",
"chats",
"chat_members",
"messages",
"sessions",
"schema_migrations",
} <= tables
indexes = {
r["indexname"]
for r in run_sql("SELECT indexname FROM pg_indexes WHERE schemaname = 'public'")
}
assert "messages_chat_created_idx" in indexes
def count_constraints(table: str, kind: str) -> int:
"""Число ограничений заданного типа у таблицы."""
rows = run_sql(
"SELECT count(*) AS n FROM pg_constraint WHERE conrelid = $1::regclass AND contype::text = $2",
table,
kind,
)
return rows[0]["n"]
def test_primary_and_foreign_keys_are_declared(client):
for table in ("users", "chats", "chat_members", "messages", "sessions"):
assert count_constraints(table, "p") == 1, table
assert count_constraints("users", "u") == 1
assert count_constraints("chat_members", "f") == 2
assert count_constraints("messages", "f") == 2
assert count_constraints("sessions", "f") == 1
def test_database_itself_rejects_bad_rows(client, alice, chat):
chat_id, user_id = uuid.UUID(chat["id"]), uuid.UUID(alice.id)
with pytest.raises(asyncpg.ForeignKeyViolationError):
run_sql(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, 'x')",
uuid.uuid4(),
uuid.uuid4(),
user_id,
)
with pytest.raises(asyncpg.CheckViolationError):
run_sql(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, '')",
uuid.uuid4(),
chat_id,
user_id,
)
with pytest.raises(asyncpg.UniqueViolationError):
run_sql(
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
chat_id,
user_id,
)
with pytest.raises(asyncpg.CheckViolationError):
run_sql(
"INSERT INTO users (id, username, display_name, password_hash) VALUES ($1, 'BadName', 'x', 'h')",
uuid.uuid4(),
)
def test_chat_creation_is_atomic(client, alice):
"""Неизвестный участник: ни чата, ни участников в БД."""
title = "atomic-" + uuid.uuid4().hex
reply = client.post(
"/api/v1/chats",
json={"title": title, "member_ids": [alice.id, str(uuid.uuid4())]},
headers=alice.headers,
)
assert reply.status_code == 400
assert (
run_sql("SELECT count(*) AS n FROM chats WHERE title = $1", title)[0]["n"] == 0
)
def test_successful_chat_has_all_members_in_database(client, alice, bob, chat):
rows = run_sql(
"SELECT user_id FROM chat_members WHERE chat_id = $1", uuid.UUID(chat["id"])
)
assert {str(r["user_id"]) for r in rows} == {alice.id, bob.id}
+77
View File
@@ -0,0 +1,77 @@
"""Недоступная БД: ответ 503 и отказ анонимным запросам."""
from dataclasses import replace
import pytest
from fastapi.testclient import TestClient
from app.db import create_engine, create_sessionmaker
from app.main import create_app
from conftest import CACHE_URL, assert_error, make_settings, register_and_login
def test_database_down_gives_503_and_never_trusts_anyone():
settings = make_settings(cache_url="")
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
person = register_and_login(app_client, "down")
assert (
app_client.get("/api/v1/users/me", headers=person.headers).status_code
== 200
)
dead = replace(
settings,
database_url="postgresql+asyncpg://x:y@127.0.0.1:1/none",
db_pool_timeout=1,
)
app_client.app.state.sessionmaker = create_sessionmaker(create_engine(dead))
assert app_client.get("/health/live").status_code == 200
assert_error(app_client.get("/health/ready"), 503, "unavailable")
assert_error(
app_client.get("/api/v1/users/me", headers=person.headers),
503,
"unavailable",
)
assert_error(
app_client.post(
"/api/v1/users",
json={
"username": "abcdef",
"display_name": "x",
"password": "long-enough-password",
},
),
503,
"unavailable",
)
reply = app_client.get("/api/v1/chats")
assert reply.status_code in (401, 503) and reply.status_code != 200
def test_database_down_with_cache_up_still_needs_database_for_data():
"""При живом Redis операции с данными без БД всё равно дают 503."""
if not CACHE_URL:
pytest.skip("TEST_CACHE_URL не задан (тест для контейнера с Redis)")
settings = make_settings()
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
person = register_and_login(app_client, "down_cache")
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
dead = replace(
settings,
database_url="postgresql+asyncpg://x:y@127.0.0.1:1/none",
db_pool_timeout=1,
)
app_client.app.state.sessionmaker = create_sessionmaker(create_engine(dead))
assert_error(app_client.get("/health/ready"), 503, "unavailable")
assert_error(app_client.get("/api/v1/chats", headers=person.headers), 503, "unavailable")
assert_error(
app_client.post("/api/v1/chats", json={"title": "x", "member_ids": [person.id]},
headers=person.headers),
503, "unavailable",
)
assert_error(app_client.get("/api/v1/chats"), 401, "unauthorized")
unknown = {"Authorization": "Bearer " + "A" * 43}
assert app_client.get("/api/v1/users/me", headers=unknown).status_code == 503
+45
View File
@@ -0,0 +1,45 @@
"""Повторный username: 409, в том числе при одновременной регистрации."""
import uuid
from concurrent.futures import ThreadPoolExecutor
from conftest import assert_error, run_sql
def body(username: str, display_name: str = "Имя") -> dict:
"""Тело регистрации."""
return {"username": username, "display_name": display_name, "password": "long-enough-password"}
def test_second_registration_with_same_username_is_409(client):
name = "dup_" + uuid.uuid4().hex[:10]
assert client.post("/api/v1/users", json=body(name)).status_code == 201
assert_error(client.post("/api/v1/users", json=body(name, "Другое имя")), 409, "conflict")
def test_duplicate_does_not_replace_original_user(client):
name = "dup_" + uuid.uuid4().hex[:10]
first = client.post("/api/v1/users", json=body(name, "Первый")).json()
client.post("/api/v1/users", json=body(name, "Второй"))
rows = run_sql("SELECT display_name FROM users WHERE username = $1", name)
assert [row["display_name"] for row in rows] == ["Первый"]
assert first["display_name"] == "Первый"
def test_username_is_case_sensitive_lowercase_only(client):
name = "dup_" + uuid.uuid4().hex[:10]
assert client.post("/api/v1/users", json=body(name)).status_code == 201
assert_error(client.post("/api/v1/users", json=body(name.upper())), 400, "invalid_request")
def test_parallel_registration_of_same_username_creates_exactly_one(client):
name = "race_" + uuid.uuid4().hex[:10]
def register(_):
return client.post("/api/v1/users", json=body(name)).status_code
with ThreadPoolExecutor(max_workers=10) as pool:
codes = list(pool.map(register, range(10)))
assert codes.count(201) == 1
assert codes.count(409) == 9
assert len(run_sql("SELECT 1 FROM users WHERE username = $1", name)) == 1
+73
View File
@@ -0,0 +1,73 @@
"""Текст сообщения: пустые строки, длина и Unicode."""
import pytest
from conftest import assert_error
@pytest.mark.parametrize("text", ["", " ", " ", "\n", "\t \n", " ", " "])
def test_blank_text_is_rejected(client, alice, chat, text):
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert_error(
client.post(url, json={"text": text}, headers=alice.headers),
400,
"invalid_request",
)
assert client.get(url, headers=alice.headers).json()["items"] == []
@pytest.mark.parametrize(
"body", [{}, {"text": None}, {"text": 123}, {"text": ["a"]}, {"message": "hi"}]
)
def test_missing_or_wrong_type_text_is_rejected(client, alice, chat, body):
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert_error(
client.post(url, json=body, headers=alice.headers), 400, "invalid_request"
)
def test_text_length_is_counted_in_characters(client, alice, chat):
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert (
client.post(url, json={"text": "я" * 4000}, headers=alice.headers).status_code
== 201
)
assert (
client.post(url, json={"text": "😀" * 4000}, headers=alice.headers).status_code
== 201
)
assert_error(
client.post(url, json={"text": "я" * 4001}, headers=alice.headers),
400,
"invalid_request",
)
def test_nul_character_is_400_not_500(client, alice, chat):
"""Символ NUL отклоняется с 400."""
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert_error(
client.post(url, json={"text": "a\x00b"}, headers=alice.headers),
400,
"invalid_request",
)
def test_unicode_survives_the_database(client, alice, bob, chat):
url = "/api/v1/chats/" + chat["id"] + "/messages"
text = " Привет, мир 👋 你好 ✓ é "
sent = client.post(url, json={"text": text}, headers=alice.headers)
assert sent.status_code == 201 and sent.json()["text"] == text
assert client.get(url, headers=bob.headers).json()["items"][0]["text"] == text
assert sent.headers["content-type"].split(";")[0] == "application/json"
def test_message_has_correct_fields(client, alice, chat):
data = client.post(
"/api/v1/chats/" + chat["id"] + "/messages",
json={"text": "hi"},
headers=alice.headers,
).json()
assert set(data) == {"id", "chat_id", "sender_id", "text", "created_at"}
assert data["chat_id"] == chat["id"] and data["sender_id"] == alice.id
assert data["created_at"].endswith("Z")
+52
View File
@@ -0,0 +1,52 @@
"""План запроса истории на 10 000 сообщениях: индекс без полного сканирования."""
import asyncio
import asyncpg
import pytest
from app import explain
from app.crud import history_query
from conftest import database_parts, make_settings, TEST_DB_NAME
from app.db import create_engine
def plan_for(cursor_offset):
"""Заполнить данные и вернуть число сообщений и план запроса страницы."""
p = database_parts()
async def go():
conn = await asyncpg.connect(database=TEST_DB_NAME, timeout=5, **p)
try:
await explain.seed(conn, 30000)
count = await conn.fetchval(
"SELECT count(*) FROM messages WHERE chat_id = $1", explain.BIG_CHAT
)
after = None
if cursor_offset:
row = await conn.fetchrow(
"SELECT created_at, id FROM messages WHERE chat_id = $1"
" ORDER BY created_at, id OFFSET $2 LIMIT 1",
explain.BIG_CHAT, cursor_offset,
)
after = (row["created_at"], row["id"])
engine = create_engine(make_settings())
query = history_query(explain.BIG_CHAT, after, 50).compile(dialect=engine.dialect)
await engine.dispose()
params = [query.params[name] for name in query.positiontup]
rows = await conn.fetch("EXPLAIN (ANALYZE, BUFFERS) " + query.string, *params)
return count, "\n".join(r[0] for r in rows)
finally:
await conn.close()
return asyncio.run(go())
@pytest.mark.parametrize("cursor_offset", [0, 9000])
def test_history_page_uses_index_without_full_scan(cursor_offset):
count, plan = plan_for(cursor_offset)
assert count >= 10000
assert "Index Scan using messages_chat_created_idx" in plan, plan
assert "Seq Scan" not in plan, plan
assert "Sort" not in plan, plan
assert "rows=51 loops=1" in plan, plan
+65
View File
@@ -0,0 +1,65 @@
"""Доступ к чужому чату: 404 для посторонних, 401 без токена."""
import uuid
from conftest import assert_error
def test_outsider_cannot_read_chat(client, eve, chat):
assert_error(client.get("/api/v1/chats/" + chat["id"], headers=eve.headers), 404, "not_found")
def test_outsider_cannot_read_history(client, alice, eve, chat):
client.post("/api/v1/chats/" + chat["id"] + "/messages", json={"text": "секрет"}, headers=alice.headers)
reply = client.get("/api/v1/chats/" + chat["id"] + "/messages", headers=eve.headers)
assert_error(reply, 404, "not_found")
assert "секрет" not in reply.text
def test_outsider_cannot_write(client, alice, eve, chat):
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert_error(client.post(url, json={"text": "чужое"}, headers=eve.headers), 404, "not_found")
assert client.get(url, headers=alice.headers).json()["items"] == []
def test_outsider_gets_404_even_with_bad_body(client, eve, chat):
"""Проверка доступа выполняется раньше проверки тела."""
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert_error(client.post(url, json={"text": ""}, headers=eve.headers), 404, "not_found")
def test_unknown_chat_looks_the_same_as_foreign(client, eve, chat):
foreign = client.get("/api/v1/chats/" + chat["id"], headers=eve.headers)
missing = client.get("/api/v1/chats/" + str(uuid.uuid4()), headers=eve.headers)
assert foreign.status_code == missing.status_code == 404
assert foreign.json()["error"]["message"] == missing.json()["error"]["message"]
def test_chat_list_shows_only_own_chats(client, bob, eve, chat):
mine = client.get("/api/v1/chats", headers=bob.headers).json()["items"]
others = client.get("/api/v1/chats", headers=eve.headers).json()["items"]
assert [c["id"] for c in mine] == [chat["id"]]
assert others == []
def test_bad_chat_id_is_400(client, alice):
assert_error(client.get("/api/v1/chats/not-a-uuid", headers=alice.headers), 400, "invalid_request")
def test_no_token_is_401_everywhere(client, chat):
chat_url = "/api/v1/chats/" + chat["id"]
for url in ["/api/v1/users/me", "/api/v1/chats", chat_url, chat_url + "/messages"]:
assert_error(client.get(url), 401, "unauthorized")
assert_error(client.post("/api/v1/chats", json={"title": "x", "member_ids": []}), 401, "unauthorized")
assert_error(client.post(chat_url + "/messages", json={"text": "x"}), 401, "unauthorized")
def test_401_comes_before_404(client, chat):
"""Без токена существование чата не раскрывается."""
assert_error(client.get("/api/v1/chats/" + chat["id"] + "/messages"), 401, "unauthorized")
def test_member_can_read_and_write(client, alice, bob, chat):
url = "/api/v1/chats/" + chat["id"] + "/messages"
assert client.post(url, json={"text": "от Боба"}, headers=bob.headers).status_code == 201
assert client.get(url, headers=alice.headers).json()["items"][0]["text"] == "от Боба"
+115
View File
@@ -0,0 +1,115 @@
"""Некорректный JSON и поля: 400, 413 и 415."""
import uuid
import pytest
from conftest import assert_error
JSON = {"Content-Type": "application/json"}
PASSWORD = "long-enough-password"
def valid(**changes) -> dict:
"""Корректное тело регистрации с изменёнными полями."""
body = {"username": "j_" + uuid.uuid4().hex[:10], "display_name": "Имя", "password": PASSWORD}
body.update(changes)
return {key: value for key, value in body.items() if value is not None}
@pytest.mark.parametrize(
"raw",
[
b"{",
b"not json at all",
b"",
b'{"username": "abc",}',
b"\xff\xfe\x00",
b'{"username": NaN}',
b'["username"]',
b'"text"',
b"null",
],
)
def test_registration_rejects_broken_json(client, raw):
assert_error(client.post("/api/v1/users", content=raw, headers=JSON), 400, "invalid_request")
@pytest.mark.parametrize(
"changes",
[
{"username": None},
{"display_name": None},
{"password": None},
{"username": 123},
{"display_name": 5},
{"display_name": None, "extra_field": 1},
{"role": "admin"},
{"username": "ab"},
{"username": "a" * 33},
{"username": "Alice"},
{"username": "al ice"},
{"username": "алиса"},
{"username": "alice\n"},
{"display_name": ""},
{"display_name": " "},
{"display_name": "я" * 101},
{"display_name": "a\x00b"},
],
)
def test_registration_rejects_bad_fields(client, changes):
assert_error(client.post("/api/v1/users", json=valid(**changes)), 400, "invalid_request")
def test_border_values_are_accepted(client):
assert client.post("/api/v1/users", json=valid(display_name="я" * 100)).status_code == 201
assert client.post("/api/v1/users", json=valid(username=uuid.uuid4().hex, display_name="😀")).status_code == 201
def test_lone_surrogate_is_400_not_500(client):
raw = b'{"username": "abcdef", "display_name": "\\ud800", "password": "long-enough-password"}'
assert_error(client.post("/api/v1/users", content=raw, headers=JSON), 400, "invalid_request")
def test_wrong_or_missing_content_type_is_415(client):
body = b'{"username":"abc","display_name":"x","password":"long-enough-password"}'
assert_error(client.post("/api/v1/users", content=body, headers={"Content-Type": "text/plain"}), 415, "unsupported_media_type")
assert_error(client.post("/api/v1/users", content=body), 415, "unsupported_media_type")
def test_huge_body_is_413(client):
big = b'{"username": "abc", "display_name": "' + b"x" * (300 * 1024) + b'"}'
assert_error(client.post("/api/v1/users", content=big, headers=JSON), 413, "payload_too_large")
def test_broken_json_in_message_and_chat(client, alice, chat):
headers = {**JSON, **alice.headers}
assert_error(client.post("/api/v1/chats/" + chat["id"] + "/messages", content=b"{oops", headers=headers), 400, "invalid_request")
assert_error(client.post("/api/v1/chats", content=b"[", headers=headers), 400, "invalid_request")
def test_sender_id_in_message_is_rejected(client, alice, bob, chat):
"""Поле sender_id в теле сообщения запрещено."""
reply = client.post(
"/api/v1/chats/" + chat["id"] + "/messages", json={"text": "привет", "sender_id": bob.id}, headers=alice.headers
)
assert_error(reply, 400, "invalid_request")
def test_chat_body_validation(client, alice, bob):
unknown = str(uuid.uuid4())
cases = [
{"title": "x", "member_ids": []},
{"title": "", "member_ids": [alice.id]},
{"title": " ", "member_ids": [alice.id]},
{"title": "x" * 101, "member_ids": [alice.id]},
{"title": "x", "member_ids": [alice.id, alice.id]},
{"title": "x", "member_ids": [alice.id, unknown]},
{"title": "x", "member_ids": [bob.id]},
{"title": "x", "member_ids": ["не-uuid"]},
{"title": "x", "member_ids": alice.id},
{"title": "x"},
{"title": "x", "member_ids": [alice.id], "extra": 1},
]
for body in cases:
assert_error(client.post("/api/v1/chats", json=body, headers=alice.headers), 400, "invalid_request")
+170
View File
@@ -0,0 +1,170 @@
"""Пагинация истории и списка чатов по keyset-курсору."""
from urllib.parse import quote
from conftest import assert_error
def send_many(client, person, chat, count, prefix="msg"):
"""Отправить несколько сообщений в чат."""
url = "/api/v1/chats/" + chat["id"] + "/messages"
for number in range(count):
reply = client.post(
url, json={"text": "%s-%02d" % (prefix, number)}, headers=person.headers
)
assert reply.status_code == 201
def walk(client, person, chat, limit):
"""Пройти историю страницами; вернуть элементы и число страниц."""
url = "/api/v1/chats/" + chat["id"] + "/messages"
items, pages, cursor = [], 0, None
while True:
query = "?limit=%d" % limit + (
"&cursor=" + quote(cursor, safe="") if cursor else ""
)
data = client.get(url + query, headers=person.headers).json()
assert set(data) == {"items", "next_cursor"} and len(data["items"]) <= limit
items += data["items"]
pages += 1
cursor = data["next_cursor"]
if cursor is None:
return items, pages
assert pages < 1000, "бесконечный обход"
def test_walk_25_messages_by_7(client, alice, bob, chat):
send_many(client, alice, chat, 25)
items, pages = walk(client, bob, chat, 7)
assert pages == 4
assert [m["text"] for m in items] == ["msg-%02d" % n for n in range(25)]
assert len({m["id"] for m in items}) == 25
def test_exact_multiple_has_no_empty_extra_page(client, alice, chat):
send_many(client, alice, chat, 10)
items, pages = walk(client, alice, chat, 5)
assert len(items) == 10 and pages == 2
def test_limit_one_walks_everything(client, alice, chat):
send_many(client, alice, chat, 6)
items, pages = walk(client, alice, chat, 1)
assert len(items) == 6 and pages == 6
def test_default_limit_is_50_and_max_is_100(client, alice, chat):
send_many(client, alice, chat, 120)
url = "/api/v1/chats/" + chat["id"] + "/messages"
default = client.get(url, headers=alice.headers).json()
assert len(default["items"]) == 50 and default["next_cursor"]
biggest = client.get(url + "?limit=100", headers=alice.headers).json()
assert len(biggest["items"]) == 100 and biggest["next_cursor"]
def test_empty_history(client, alice, chat):
data = client.get(
"/api/v1/chats/" + chat["id"] + "/messages", headers=alice.headers
).json()
assert data == {"items": [], "next_cursor": None}
def test_limit_can_change_between_pages(client, alice, chat):
send_many(client, alice, chat, 9)
url = "/api/v1/chats/" + chat["id"] + "/messages"
first = client.get(url + "?limit=2", headers=alice.headers).json()
second = client.get(
url + "?limit=100&cursor=" + quote(first["next_cursor"], safe=""),
headers=alice.headers,
).json()
assert [m["text"] for m in first["items"] + second["items"]] == [
"msg-%02d" % n for n in range(9)
]
assert second["next_cursor"] is None
def test_messages_sent_during_walk_appear_at_the_end(client, alice, chat):
send_many(client, alice, chat, 4)
url = "/api/v1/chats/" + chat["id"] + "/messages"
first = client.get(url + "?limit=2", headers=alice.headers).json()
send_many(client, alice, chat, 1, prefix="late")
rest = client.get(
url + "?limit=10&cursor=" + quote(first["next_cursor"], safe=""),
headers=alice.headers,
).json()
texts = [m["text"] for m in first["items"] + rest["items"]]
assert texts == ["msg-00", "msg-01", "msg-02", "msg-03", "late-00"]
def test_created_at_is_increasing_and_utc(client, alice, chat):
send_many(client, alice, chat, 30)
items, _ = walk(client, alice, chat, 100)
stamps = [m["created_at"] for m in items]
assert stamps == sorted(stamps) and len(set(stamps)) == 30
assert all(s.endswith("Z") and "T" in s for s in stamps)
def test_bad_limit_values(client, alice, chat):
url = "/api/v1/chats/" + chat["id"] + "/messages"
for bad in ["0", "101", "-1", "abc", "1.5", "", "+5", " 5", "٣"]:
assert_error(
client.get(url + "?limit=" + quote(bad), headers=alice.headers),
400,
"invalid_request",
)
assert client.get(url + "?limit=1", headers=alice.headers).status_code == 200
assert client.get(url + "?limit=100", headers=alice.headers).status_code == 200
def test_garbage_cursor_is_400(client, alice, chat):
url = "/api/v1/chats/" + chat["id"] + "/messages"
for bad in ["garbage", "!!!", "e30", "a" * 600, "eyJzIjoibWVzc2FnZXM6eCJ9"]:
assert_error(
client.get(url + "?cursor=" + quote(bad), headers=alice.headers),
400,
"invalid_request",
)
def test_cursor_from_another_chat_is_400(client, alice, bob, make_chat, chat):
other = make_chat(alice, bob, title="Второй чат")
send_many(client, alice, chat, 5)
send_many(client, alice, other, 5)
first = client.get(
"/api/v1/chats/" + chat["id"] + "/messages?limit=2", headers=alice.headers
).json()
reply = client.get(
"/api/v1/chats/"
+ other["id"]
+ "/messages?cursor="
+ quote(first["next_cursor"], safe=""),
headers=alice.headers,
)
assert_error(reply, 400, "invalid_request")
def test_chat_list_pagination(client, alice, bob, make_chat):
created = [make_chat(alice, bob, title="Чат %02d" % n)["id"] for n in range(5)]
seen, cursor = [], None
while True:
query = "?limit=2" + ("&cursor=" + quote(cursor, safe="") if cursor else "")
data = client.get("/api/v1/chats" + query, headers=bob.headers).json()
seen += [c["id"] for c in data["items"]]
cursor = data["next_cursor"]
if cursor is None:
break
assert seen == created
def test_chat_list_cursor_cannot_be_used_for_messages(
client, alice, bob, make_chat, chat
):
make_chat(alice, bob, title="ещё")
cursor = client.get("/api/v1/chats?limit=1", headers=alice.headers).json()[
"next_cursor"
]
reply = client.get(
"/api/v1/chats/" + chat["id"] + "/messages?cursor=" + quote(cursor, safe=""),
headers=alice.headers,
)
assert_error(reply, 400, "invalid_request")
+56
View File
@@ -0,0 +1,56 @@
"""Истечение сессий."""
import time
from fastapi.testclient import TestClient
from app.main import create_app
from conftest import assert_error, make_settings, register_and_login
def test_session_expires_after_ttl():
with TestClient(
create_app(make_settings(session_ttl_seconds=1)), raise_server_exceptions=False
) as short:
person = register_and_login(short, "ttl")
assert short.get("/api/v1/users/me", headers=person.headers).status_code == 200
time.sleep(2.2)
reply = short.get("/api/v1/users/me", headers=person.headers)
assert_error(reply, 401, "unauthorized")
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
def test_expired_sessions_are_cleaned_on_next_login():
"""Истёкшие сессии удаляются при следующем входе."""
from conftest import basic_header, run_sql
import uuid
with TestClient(
create_app(make_settings(session_ttl_seconds=1)), raise_server_exceptions=False
) as short:
person = register_and_login(short, "clean")
time.sleep(1.5)
short.post(
"/api/v1/auth/sessions",
headers=basic_header(person.username, person.password),
)
rows = run_sql(
"SELECT token_hash FROM sessions WHERE user_id = $1", uuid.UUID(person.id)
)
assert len(rows) == 1
def test_short_ttl_from_environment_variable():
"""Короткий SESSION_TTL_SECONDS из окружения."""
from conftest import CACHE_URL, sqlalchemy_url
from app.config import Settings
settings = Settings.from_env(
{"DATABASE_URL": sqlalchemy_url(), "SESSION_TTL_SECONDS": "2", "CACHE_URL": CACHE_URL}
)
assert settings.session_ttl_seconds == 2
with TestClient(create_app(settings), raise_server_exceptions=False) as short:
person = register_and_login(short, "envttl")
assert short.get("/api/v1/users/me", headers=person.headers).status_code == 200
time.sleep(2.5)
assert_error(short.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
+69
View File
@@ -0,0 +1,69 @@
"""Транзакции, пул соединений и таймауты."""
import time
import uuid
import httpx
from fastapi.testclient import TestClient
from sqlalchemy.exc import OperationalError
from sqlalchemy.ext.asyncio import AsyncSession
from app.main import create_app
from app.models import ChatMember
from conftest import assert_error, make_settings, register_and_login, run_sql
def test_failure_after_chat_insert_rolls_back_whole_operation(client, alice, bob, monkeypatch):
"""Сбой после вставки чата откатывает всю операцию."""
real_execute = AsyncSession.execute
async def failing_execute(self, statement, *args, **kwargs):
if getattr(getattr(statement, "table", None), "name", None) == ChatMember.__tablename__:
raise OperationalError("INSERT INTO chat_members", {}, Exception("injected"))
return await real_execute(self, statement, *args, **kwargs)
monkeypatch.setattr(AsyncSession, "execute", failing_execute)
title = "rollback-" + uuid.uuid4().hex
reply = client.post(
"/api/v1/chats", json={"title": title, "member_ids": [alice.id, bob.id]},
headers=alice.headers,
)
monkeypatch.undo()
assert_error(reply, 503, "unavailable")
assert "injected" not in reply.text and "chat_members" not in reply.text
assert run_sql("SELECT count(*) AS n FROM chats WHERE title = $1", title)[0]["n"] == 0
assert run_sql(
"SELECT count(*) AS n FROM chat_members m JOIN chats c ON c.id = m.chat_id"
" WHERE c.title = $1", title,
)[0]["n"] == 0
def test_pool_is_bounded_by_settings():
settings = make_settings(db_pool_size=3, db_max_overflow=2, db_pool_timeout=4)
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
pool = app_client.app.state.engine.pool
assert pool.size() == 3
assert pool._max_overflow == 2
assert pool._timeout == 4
def test_exhausted_pool_gives_fast_503():
"""Занятый пул даёт 503 за время DB_POOL_TIMEOUT."""
settings = make_settings(db_pool_size=1, db_max_overflow=0, db_pool_timeout=1, cache_url="")
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
person = register_and_login(app_client, "pool")
app = app_client.app
async def scenario():
async with app.state.engine.connect():
transport = httpx.ASGITransport(app=app)
async with httpx.AsyncClient(transport=transport, base_url="http://t") as http:
started = time.monotonic()
reply = await http.get("/api/v1/users/me", headers=person.headers)
return reply, time.monotonic() - started
reply, elapsed = app_client.portal.call(scenario)
assert_error(reply, 503, "unavailable")
assert elapsed < 3
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200