From 840907cf2bdaafa91543a3fbf964b18e34d9c851 Mon Sep 17 00:00:00 2001 From: k00kzaAntonovaIra <148076030+k00kzaAntonovaIra@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:09:32 +0300 Subject: [PATCH 1/3] solution --- Dockerfile | 36 +++ EVIDENCE.md | 44 +++ GUIDE.md | 65 ++++ Makefile | 16 +- OPERATIONS.md | 83 +++++ REPORT.md | 77 +++-- app/__init__.py | 1 + app/__main__.py | 46 +++ app/auth.py | 102 ++++++ app/cache.py | 146 +++++++++ app/config.py | 107 +++++++ app/crud.py | 208 +++++++++++++ app/cursor.py | 45 +++ app/db.py | 27 ++ app/errors.py | 37 +++ app/explain.py | 139 +++++++++ app/healthcheck.py | 20 ++ app/http_utils.py | 102 ++++++ app/logging_setup.py | 25 ++ app/main.py | 136 ++++++++ app/middleware.py | 68 ++++ app/migrate.py | 64 ++++ app/migrations/0001_init.sql | 41 +++ app/models.py | 70 +++++ app/routes.py | 290 +++++++++++++++++ app/schemas.py | 153 +++++++++ app/security.py | 74 +++++ app/timeutil.py | 20 ++ compose.yaml | 107 +++++++ env.lab2.template | 17 + evidence/01_check_contract.txt | 8 + evidence/02_smoke.txt | 9 + evidence/03_ps_before.txt | 11 + evidence/03_volume_before.txt | 8 + evidence/04_persistence.txt | 10 + evidence/05_ps_after.txt | 11 + evidence/05_volume_after.txt | 8 + evidence/06_schema.txt | 83 +++++ evidence/07_migrations.txt | 8 + evidence/07_migrations_first.txt | 16 + evidence/07_migrations_table.txt | 11 + evidence/08_hashes.txt | 20 ++ evidence/09_auth_tests.txt | 64 ++++ evidence/10_database_tests.txt | 45 +++ evidence/11_all_tests.txt | 179 +++++++++++ evidence/12_compose_no_secrets.txt | 10 + evidence/12_git_files.txt | 113 +++++++ evidence/12_git_secrets.txt | 8 + evidence/13_storage.txt | 194 ++++++++++++ evidence/14_dependencies.txt | 323 +++++++++++++++++++ evidence/15_explain.txt | 89 ++++++ evidence/15_explain_tests.txt | 28 ++ evidence/16_expiry_live.txt | 19 ++ pytest.ini | 4 + requirements-test.txt | 10 + requirements.txt | 20 ++ scripts/check_expiry.py | 90 ++++++ scripts/collect_evidence.sh | 63 ++++ scripts/dependency_demo.py | 324 +++++++++++++++++++ scripts/restart.bat | 5 + scripts/restart.sh | 5 + scripts/run_and_save.py | 64 ++++ scripts/storage_demo.py | 379 ++++++++++++++++++++++ storage_demo.py | 381 +++++++++++++++++++++++ student-tests/conftest.py | 257 +++++++++++++++ student-tests/test_auth.py | 193 ++++++++++++ student-tests/test_cache.py | 190 +++++++++++ student-tests/test_concurrency.py | 61 ++++ student-tests/test_contract_basics.py | 95 ++++++ student-tests/test_database.py | 172 ++++++++++ student-tests/test_db_failure.py | 77 +++++ student-tests/test_duplicate_username.py | 45 +++ student-tests/test_empty_message.py | 73 +++++ student-tests/test_explain.py | 52 ++++ student-tests/test_foreign_chat.py | 65 ++++ student-tests/test_invalid_json.py | 115 +++++++ student-tests/test_pagination.py | 170 ++++++++++ student-tests/test_session_expiry.py | 56 ++++ student-tests/test_transactions.py | 69 ++++ 79 files changed, 6656 insertions(+), 20 deletions(-) create mode 100644 Dockerfile create mode 100644 EVIDENCE.md create mode 100644 GUIDE.md create mode 100644 OPERATIONS.md create mode 100644 app/__init__.py create mode 100644 app/__main__.py create mode 100644 app/auth.py create mode 100644 app/cache.py create mode 100644 app/config.py create mode 100644 app/crud.py create mode 100644 app/cursor.py create mode 100644 app/db.py create mode 100644 app/errors.py create mode 100644 app/explain.py create mode 100644 app/healthcheck.py create mode 100644 app/http_utils.py create mode 100644 app/logging_setup.py create mode 100644 app/main.py create mode 100644 app/middleware.py create mode 100644 app/migrate.py create mode 100644 app/migrations/0001_init.sql create mode 100644 app/models.py create mode 100644 app/routes.py create mode 100644 app/schemas.py create mode 100644 app/security.py create mode 100644 app/timeutil.py create mode 100644 compose.yaml create mode 100644 env.lab2.template create mode 100644 evidence/01_check_contract.txt create mode 100644 evidence/02_smoke.txt create mode 100644 evidence/03_ps_before.txt create mode 100644 evidence/03_volume_before.txt create mode 100644 evidence/04_persistence.txt create mode 100644 evidence/05_ps_after.txt create mode 100644 evidence/05_volume_after.txt create mode 100644 evidence/06_schema.txt create mode 100644 evidence/07_migrations.txt create mode 100644 evidence/07_migrations_first.txt create mode 100644 evidence/07_migrations_table.txt create mode 100644 evidence/08_hashes.txt create mode 100644 evidence/09_auth_tests.txt create mode 100644 evidence/10_database_tests.txt create mode 100644 evidence/11_all_tests.txt create mode 100644 evidence/12_compose_no_secrets.txt create mode 100644 evidence/12_git_files.txt create mode 100644 evidence/12_git_secrets.txt create mode 100644 evidence/13_storage.txt create mode 100644 evidence/14_dependencies.txt create mode 100644 evidence/15_explain.txt create mode 100644 evidence/15_explain_tests.txt create mode 100644 evidence/16_expiry_live.txt create mode 100644 pytest.ini create mode 100644 requirements-test.txt create mode 100644 requirements.txt create mode 100644 scripts/check_expiry.py create mode 100644 scripts/collect_evidence.sh create mode 100644 scripts/dependency_demo.py create mode 100644 scripts/restart.bat create mode 100644 scripts/restart.sh create mode 100644 scripts/run_and_save.py create mode 100644 scripts/storage_demo.py create mode 100644 storage_demo.py create mode 100644 student-tests/conftest.py create mode 100644 student-tests/test_auth.py create mode 100644 student-tests/test_cache.py create mode 100644 student-tests/test_concurrency.py create mode 100644 student-tests/test_contract_basics.py create mode 100644 student-tests/test_database.py create mode 100644 student-tests/test_db_failure.py create mode 100644 student-tests/test_duplicate_username.py create mode 100644 student-tests/test_empty_message.py create mode 100644 student-tests/test_explain.py create mode 100644 student-tests/test_foreign_chat.py create mode 100644 student-tests/test_invalid_json.py create mode 100644 student-tests/test_pagination.py create mode 100644 student-tests/test_session_expiry.py create mode 100644 student-tests/test_transactions.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..47cf4996 --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/EVIDENCE.md b/EVIDENCE.md new file mode 100644 index 00000000..88441d2f --- /dev/null +++ b/EVIDENCE.md @@ -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:`. +- `11_all_tests.txt` заканчивается строкой `153 passed`, а `13_storage.txt` и `14_dependencies.txt` — строкой `ИТОГ: PASS`. +- `evidence/` указан в `.dockerignore` и в образ не попадает. diff --git a/GUIDE.md b/GUIDE.md new file mode 100644 index 00000000..570e9516 --- /dev/null +++ b/GUIDE.md @@ -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` выключает кэш. diff --git a/Makefile b/Makefile index 9ecb223e..e8cf2d81 100644 --- a/Makefile +++ b/Makefile @@ -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 diff --git a/OPERATIONS.md b/OPERATIONS.md new file mode 100644 index 00000000..23daa26c --- /dev/null +++ b/OPERATIONS.md @@ -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:` → 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`. Всё задаётся окружением, поэтому один образ работает на любом стенде без пересборки. diff --git a/REPORT.md b/REPORT.md index e42f2b05..d20bfab0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,76 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Антонова Ирина Андреевна БПИ2301 +- Целевая оценка: 4 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: 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"} +make test # публичный smoke +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-student # собственные тесты в контейнере +``` + +- Остановка с сохранением данных: `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. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..9e0da457 --- /dev/null +++ b/app/__init__.py @@ -0,0 +1 @@ +"""Мессенджер: HTTP API на FastAPI с PostgreSQL и кэшем сессий в Redis.""" diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 00000000..bee22d1d --- /dev/null +++ b/app/__main__.py @@ -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()) diff --git a/app/auth.py b/app/auth.py new file mode 100644 index 00000000..5567922c --- /dev/null +++ b/app/auth.py @@ -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 diff --git a/app/cache.py b/app/cache.py new file mode 100644 index 00000000..35df1385 --- /dev/null +++ b/app/cache.py @@ -0,0 +1,146 @@ +"""Read-through кэш сессий в Redis; источник истины -- таблица sessions. + +Ключ session:, 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, + ) diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..aeb6291a --- /dev/null +++ b/app/config.py @@ -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 diff --git a/app/crud.py b/app/crud.py new file mode 100644 index 00000000..c3695c7c --- /dev/null +++ b/app/crud.py @@ -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 diff --git a/app/cursor.py b/app/cursor.py new file mode 100644 index 00000000..f73bcc04 --- /dev/null +++ b/app/cursor.py @@ -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 diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..da547a07 --- /dev/null +++ b/app/db.py @@ -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) diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..ab112932 --- /dev/null +++ b/app/errors.py @@ -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, + ) diff --git a/app/explain.py b/app/explain.py new file mode 100644 index 00000000..a7046d93 --- /dev/null +++ b/app/explain.py @@ -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()) diff --git a/app/healthcheck.py b/app/healthcheck.py new file mode 100644 index 00000000..321bd002 --- /dev/null +++ b/app/healthcheck.py @@ -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()) diff --git a/app/http_utils.py b/app/http_utils.py new file mode 100644 index 00000000..9e243b90 --- /dev/null +++ b/app/http_utils.py @@ -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") diff --git a/app/logging_setup.py b/app/logging_setup.py new file mode 100644 index 00000000..9e104879 --- /dev/null +++ b/app/logging_setup.py @@ -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 diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..5b161611 --- /dev/null +++ b/app/main.py @@ -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 diff --git a/app/middleware.py b/app/middleware.py new file mode 100644 index 00000000..852eed8a --- /dev/null +++ b/app/middleware.py @@ -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, + ) diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..c1c2d054 --- /dev/null +++ b/app/migrate.py @@ -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())) diff --git a/app/migrations/0001_init.sql b/app/migrations/0001_init.sql new file mode 100644 index 00000000..6a487a45 --- /dev/null +++ b/app/migrations/0001_init.sql @@ -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); diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..051cde24 --- /dev/null +++ b/app/models.py @@ -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)) diff --git a/app/routes.py b/app/routes.py new file mode 100644 index 00000000..f625cd3c --- /dev/null +++ b/app/routes.py @@ -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} diff --git a/app/schemas.py b/app/schemas.py new file mode 100644 index 00000000..dfb37131 --- /dev/null +++ b/app/schemas.py @@ -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] diff --git a/app/security.py b/app/security.py new file mode 100644 index 00000000..70a3e63d --- /dev/null +++ b/app/security.py @@ -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() diff --git a/app/timeutil.py b/app/timeutil.py new file mode 100644 index 00000000..92efa98d --- /dev/null +++ b/app/timeutil.py @@ -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) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..9edae339 --- /dev/null +++ b/compose.yaml @@ -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: diff --git a/env.lab2.template b/env.lab2.template new file mode 100644 index 00000000..82f9eacb --- /dev/null +++ b/env.lab2.template @@ -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 diff --git a/evidence/01_check_contract.txt b/evidence/01_check_contract.txt new file mode 100644 index 00000000..9cd80901 --- /dev/null +++ b/evidence/01_check_contract.txt @@ -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 с diff --git a/evidence/02_smoke.txt b/evidence/02_smoke.txt new file mode 100644 index 00000000..ac067707 --- /dev/null +++ b/evidence/02_smoke.txt @@ -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 с diff --git a/evidence/03_ps_before.txt b/evidence/03_ps_before.txt new file mode 100644 index 00000000..5ab247ee --- /dev/null +++ b/evidence/03_ps_before.txt @@ -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 с diff --git a/evidence/03_volume_before.txt b/evidence/03_volume_before.txt new file mode 100644 index 00000000..2a043dcf --- /dev/null +++ b/evidence/03_volume_before.txt @@ -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 с diff --git a/evidence/04_persistence.txt b/evidence/04_persistence.txt new file mode 100644 index 00000000..eb7a745e --- /dev/null +++ b/evidence/04_persistence.txt @@ -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 с diff --git a/evidence/05_ps_after.txt b/evidence/05_ps_after.txt new file mode 100644 index 00000000..f812e4a2 --- /dev/null +++ b/evidence/05_ps_after.txt @@ -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 с diff --git a/evidence/05_volume_after.txt b/evidence/05_volume_after.txt new file mode 100644 index 00000000..4077c2fd --- /dev/null +++ b/evidence/05_volume_after.txt @@ -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 с diff --git a/evidence/06_schema.txt b/evidence/06_schema.txt new file mode 100644 index 00000000..c383852b --- /dev/null +++ b/evidence/06_schema.txt @@ -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 с diff --git a/evidence/07_migrations.txt b/evidence/07_migrations.txt new file mode 100644 index 00000000..98fe6ad4 --- /dev/null +++ b/evidence/07_migrations.txt @@ -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 с diff --git a/evidence/07_migrations_first.txt b/evidence/07_migrations_first.txt new file mode 100644 index 00000000..9b7ff6ee --- /dev/null +++ b/evidence/07_migrations_first.txt @@ -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 с diff --git a/evidence/07_migrations_table.txt b/evidence/07_migrations_table.txt new file mode 100644 index 00000000..6c3e6a57 --- /dev/null +++ b/evidence/07_migrations_table.txt @@ -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 с diff --git a/evidence/08_hashes.txt b/evidence/08_hashes.txt new file mode 100644 index 00000000..c29f933d --- /dev/null +++ b/evidence/08_hashes.txt @@ -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 с diff --git a/evidence/09_auth_tests.txt b/evidence/09_auth_tests.txt new file mode 100644 index 00000000..53e77f15 --- /dev/null +++ b/evidence/09_auth_tests.txt @@ -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 с diff --git a/evidence/10_database_tests.txt b/evidence/10_database_tests.txt new file mode 100644 index 00000000..49be0ee1 --- /dev/null +++ b/evidence/10_database_tests.txt @@ -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 с diff --git a/evidence/11_all_tests.txt b/evidence/11_all_tests.txt new file mode 100644 index 00000000..7f42c0ef --- /dev/null +++ b/evidence/11_all_tests.txt @@ -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 с diff --git a/evidence/12_compose_no_secrets.txt b/evidence/12_compose_no_secrets.txt new file mode 100644 index 00000000..b3c25f2c --- /dev/null +++ b/evidence/12_compose_no_secrets.txt @@ -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 с diff --git a/evidence/12_git_files.txt b/evidence/12_git_files.txt new file mode 100644 index 00000000..d027d2f7 --- /dev/null +++ b/evidence/12_git_files.txt @@ -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 с diff --git a/evidence/12_git_secrets.txt b/evidence/12_git_secrets.txt new file mode 100644 index 00000000..273f7eb1 --- /dev/null +++ b/evidence/12_git_secrets.txt @@ -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 с diff --git a/evidence/13_storage.txt b/evidence/13_storage.txt new file mode 100644 index 00000000..95934f9c --- /dev/null +++ b/evidence/13_storage.txt @@ -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). diff --git a/evidence/14_dependencies.txt b/evidence/14_dependencies.txt new file mode 100644 index 00000000..552c01bc --- /dev/null +++ b/evidence/14_dependencies.txt @@ -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: +58542 +TTL ключа сессии: 58542 мс (<= CACHE_TTL_SECONDS=60 с и <= остатка сессии) +$ docker compose --env-file .env exec -T redis redis-cli GET session: +{"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: +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: +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 без деталей и восстанавливается. diff --git a/evidence/15_explain.txt b/evidence/15_explain.txt new file mode 100644 index 00000000..9c9b47c3 --- /dev/null +++ b/evidence/15_explain.txt @@ -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 с diff --git a/evidence/15_explain_tests.txt b/evidence/15_explain_tests.txt new file mode 100644 index 00000000..e6ca2cff --- /dev/null +++ b/evidence/15_explain_tests.txt @@ -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 с diff --git a/evidence/16_expiry_live.txt b/evidence/16_expiry_live.txt new file mode 100644 index 00000000..4129e818 --- /dev/null +++ b/evidence/16_expiry_live.txt @@ -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 с diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..74c626a0 --- /dev/null +++ b/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +testpaths = student-tests +pythonpath = . +addopts = -ra diff --git a/requirements-test.txt b/requirements-test.txt new file mode 100644 index 00000000..72a5be34 --- /dev/null +++ b/requirements-test.txt @@ -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 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..c4395cbe --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/check_expiry.py b/scripts/check_expiry.py new file mode 100644 index 00000000..d4185df8 --- /dev/null +++ b/scripts/check_expiry.py @@ -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()) diff --git a/scripts/collect_evidence.sh b/scripts/collect_evidence.sh new file mode 100644 index 00000000..e2a74094 --- /dev/null +++ b/scripts/collect_evidence.sh @@ -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 diff --git a/scripts/dependency_demo.py b/scripts/dependency_demo.py new file mode 100644 index 00000000..65219d11 --- /dev/null +++ b/scripts/dependency_demo.py @@ -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:", 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()) diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..bcbd70ea --- /dev/null +++ b/scripts/restart.bat @@ -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 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..38dae4b2 --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/scripts/run_and_save.py b/scripts/run_and_save.py new file mode 100644 index 00000000..0acf0ea5 --- /dev/null +++ b/scripts/run_and_save.py @@ -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()) diff --git a/scripts/storage_demo.py b/scripts/storage_demo.py new file mode 100644 index 00000000..b74bbc14 --- /dev/null +++ b/scripts/storage_demo.py @@ -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()) diff --git a/storage_demo.py b/storage_demo.py new file mode 100644 index 00000000..cf4b08e7 --- /dev/null +++ b/storage_demo.py @@ -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()) diff --git a/student-tests/conftest.py b/student-tests/conftest.py new file mode 100644 index 00000000..b6e9949e --- /dev/null +++ b/student-tests/conftest.py @@ -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"] diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 00000000..de3d0211 --- /dev/null +++ b/student-tests/test_auth.py @@ -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 diff --git a/student-tests/test_cache.py b/student-tests/test_cache.py new file mode 100644 index 00000000..4092d801 --- /dev/null +++ b/student-tests/test_cache.py @@ -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 diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..bc7e5647 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -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 diff --git a/student-tests/test_contract_basics.py b/student-tests/test_contract_basics.py new file mode 100644 index 00000000..d1a7b344 --- /dev/null +++ b/student-tests/test_contract_basics.py @@ -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 diff --git a/student-tests/test_database.py b/student-tests/test_database.py new file mode 100644 index 00000000..7251123d --- /dev/null +++ b/student-tests/test_database.py @@ -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} diff --git a/student-tests/test_db_failure.py b/student-tests/test_db_failure.py new file mode 100644 index 00000000..bf7d5514 --- /dev/null +++ b/student-tests/test_db_failure.py @@ -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 diff --git a/student-tests/test_duplicate_username.py b/student-tests/test_duplicate_username.py new file mode 100644 index 00000000..0863caa7 --- /dev/null +++ b/student-tests/test_duplicate_username.py @@ -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 diff --git a/student-tests/test_empty_message.py b/student-tests/test_empty_message.py new file mode 100644 index 00000000..b92148ef --- /dev/null +++ b/student-tests/test_empty_message.py @@ -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") diff --git a/student-tests/test_explain.py b/student-tests/test_explain.py new file mode 100644 index 00000000..42ac3dec --- /dev/null +++ b/student-tests/test_explain.py @@ -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 diff --git a/student-tests/test_foreign_chat.py b/student-tests/test_foreign_chat.py new file mode 100644 index 00000000..465c9c23 --- /dev/null +++ b/student-tests/test_foreign_chat.py @@ -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"] == "от Боба" diff --git a/student-tests/test_invalid_json.py b/student-tests/test_invalid_json.py new file mode 100644 index 00000000..9d76d14b --- /dev/null +++ b/student-tests/test_invalid_json.py @@ -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") diff --git a/student-tests/test_pagination.py b/student-tests/test_pagination.py new file mode 100644 index 00000000..c2844d0f --- /dev/null +++ b/student-tests/test_pagination.py @@ -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") diff --git a/student-tests/test_session_expiry.py b/student-tests/test_session_expiry.py new file mode 100644 index 00000000..373e067f --- /dev/null +++ b/student-tests/test_session_expiry.py @@ -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") diff --git a/student-tests/test_transactions.py b/student-tests/test_transactions.py new file mode 100644 index 00000000..8fe59a8f --- /dev/null +++ b/student-tests/test_transactions.py @@ -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 -- 2.54.0 From 469dd51e2a8ba5703ce0f923ae648b6beeb12abd Mon Sep 17 00:00:00 2001 From: k00kza <102+k00kza@noreply.gitea.privcloud.tech> Date: Fri, 23 Oct 2026 14:23:19 +0300 Subject: [PATCH 2/3] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20REPORT.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index d20bfab0..98a33e7e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,7 @@ - Автор, группа: Антонова Ирина Андреевна БПИ2301 - Целевая оценка: 4 -- Commit/PR: TODO после публикации +- Commit/PR: 840907cf2bdaafa91543a3fbf964b18e34d9c851 - Использованные источники, библиотеки и помощь ИИ: FastAPI, SQLAlchemy (async) + asyncpg, Pydantic, uvicorn, redis-py, pytest, httpx; при написании кода использовался ИИ-ассистент (Claude). ## Запуск из чистого clone -- 2.54.0 From 6aa9bd6a066207be9a39a0665d3028950828cf92 Mon Sep 17 00:00:00 2001 From: k00kza <102+k00kza@noreply.gitea.privcloud.tech> Date: Fri, 23 Oct 2026 14:40:35 +0300 Subject: [PATCH 3/3] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20REPORT.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/REPORT.md b/REPORT.md index 98a33e7e..796dea3d 100644 --- a/REPORT.md +++ b/REPORT.md @@ -13,9 +13,10 @@ cp env.lab2.template .env # задать свой POSTGRES_PASSWORD docker compose --env-file .env up -d --build # миграции применяются при старте API curl http://localhost:8080/health/ready # ждать {"status":"ok"} -make test # публичный smoke -make test-persistence ACTION_SCRIPT=scripts/restart.sh -make test-student # собственные тесты в контейнере +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`. -- 2.54.0