diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 3fe887f6..ab66d7f5 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -44,12 +44,13 @@ make check PASS make validate PASS make test BASE_URL=http://localhost:8080 PASS: lab2 public API scenario make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS: preserved confirmed data and existing session +make test-dependencies PASS: 2 passed (отказы Redis и PostgreSQL) (cd app && npm run build) PASS -(cd app && npm test) 5 files, 13 tests passed +(cd app && npm test) 7 files, 20 tests passed (cd app && npx tsc --noEmit) PASS -integration suite (реальные PostgreSQL/Redis) 7 passed | 1 skipped -то же с SESSION_TTL_SECONDS=2 8 passed (expiry → 401) -коллекция Bruno (bru run -r --env local) 28 запросов, 56 проверок — все зелёные +integration suite (реальные PostgreSQL/Redis) 9 passed | 1 skipped +то же с SESSION_TTL_SECONDS=2 10 passed (expiry → 401) +коллекция Bruno (bru run -r --env local) 29 запросов, 58 проверок — все зелёные ``` Трек 1 (32 конкурентных GET × 5 повторностей, `CACHE_MISS_DELAY_MS=75`): @@ -59,7 +60,7 @@ integration suite (реальные PostgreSQL/Redis) 7 passed | 1 | naive | 160 | 0 | 0 | ≈ 89 | | protected | 5 | 155 | 0 | ≈ 20 | -Отдельно проверены: гонка одинакового username (201 + 409, в таблице ровно 1 строка, unique-индекс), rollback при неизвестном участнике чата (`400`, строк не осталось), отказы Redis и PostgreSQL (`/health/ready` 503, анонимный доступ не выдаётся, процесс API жив, после старта — 200 с тем же токеном), `EXPLAIN (ANALYZE, BUFFERS)` на 10 002 сообщениях (Index Scan по `messages_chat_created_id_idx`, keyset-предикат в `Index Cond`). +Отдельно проверены границы длин в code points (11 эмодзи-пароль → 400, 12 → 201 и вход работает, 101 эмодзи в `display_name` → 400, 4001 эмодзи в тексте → 400, 4000 → 201). Также проверены: гонка одинакового username (201 + 409, в таблице ровно 1 строка, unique-индекс), rollback при неизвестном участнике чата (`400`, строк не осталось), отказы Redis и PostgreSQL автоматическим набором (`make test-dependencies`: `/health/live` 200, `/health/ready` и бизнес-запросы — ограниченная `503` без деталей драйвера, анонимный запрос 401, процесс API жив, после старта — 200 с тем же токеном и подтверждённым сообщением), `EXPLAIN (ANALYZE, BUFFERS)` на 10 002 сообщениях (Index Scan по `messages_chat_created_id_idx`, keyset-предикат в `Index Cond`). - [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. - [x] Контракт и публичные тесты не ослаблены (`contracts/` и `tests/` не изменялись). diff --git a/Makefile b/Makefile index 9ecb223e..9bea7436 100644 --- a/Makefile +++ b/Makefile @@ -3,11 +3,12 @@ BASE_URL ?= http://localhost:8080 CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) +COMPOSE_ENV_FILE ?= .env -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence test-dependencies help: - @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes; test-persistence: restart hook; test-dependencies: stops/restarts Redis and PostgreSQL" check: $(PYTHON) scripts/check_contract.py @@ -24,3 +25,6 @@ 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) + +test-dependencies: + cd app && E2E_COMPOSE_DIR="$(CURDIR)" E2E_COMPOSE_ENV_FILE="$(COMPOSE_ENV_FILE)" npm run test:dependencies diff --git a/REPORT.md b/REPORT.md index 6abffde6..c715ca6a 100644 --- a/REPORT.md +++ b/REPORT.md @@ -43,6 +43,7 @@ Client - Удаление Redis cache не теряет подтверждённые данные: они восстанавливаются из PostgreSQL. - Отказ Redis не даёт анонимного доступа: сессионный путь возвращает ограниченную 503. - Отказ PostgreSQL не убивает процесс API и даёт ограниченную 503. +- Оба отказа проверяются автоматически (`make test-dependencies`): остановка и старт контейнеров, ограниченные ошибки без деталей драйвера, восстановление сессии и подтверждённых данных. ### Схема данных и миграции @@ -73,6 +74,13 @@ Migration runner сам находит `NNN_*.sql`, сортирует по им - `DELETE /api/v1/auth/sessions/current` → 204 без тела; повтор с тем же токеном → 401. - Ответы 401 содержат корректный challenge: Basic для создания сессии, Bearer для остальных. +## Валидация входа + +- Обязательные строки не состоят только из пробельных символов (`contracts/README.md`): у `display_name` и `password` есть проверка `\S`, поэтому пароль из 12 пробелов — `400`, а не созданная учётная запись. +- Курсор истории — непрозрачная строка, но сервер проверяет формат (`YYYY-MM-DDTHH:MM:SS(.f)Z`, диапазоны часов/минут/секунд) и календарь через `date-fns` `parseISO` + `isValid`. Несуществующие даты (`2026-02-31`, `2025-02-29`) и `24:00:00` отклоняются как `400 invalid_request`, потому что `Date.parse` молча переносит их на другой день и такое значение падало бы уже в PostgreSQL (`500`). Разобранный инстант нормализуется к каноническим миллисекундам. +- Длины строк считаются в Unicode code points, как в JSON Schema и контракте: собственный декоратор `@CodePointLength` (`app/src/common/validation/`) заменяет `@Length`, который мерил UTF-16-единицы. Поэтому `display_name` и `title` — 1–100, пароль — 12–128, текст сообщения — 1–4000 code points независимо от наличия эмодзи вне BMP; подсчёт идёт по code points, а не по графемным кластерам (комбинирующие символы считаются отдельно, как в JSON Schema). +- Неизвестные поля и неверные типы — `400`; лимит истории — целое 1–100. + ## Политика кэша и трек 1 Ключ страницы: `messages:{chat_id}:v{message_version}:c{cursor|start}:l{limit}`. @@ -167,19 +175,19 @@ Read-after-write (protected, вторая действующая сессия): ## Уровень 3/4: наблюдаемые проверки -| Проверка | Команда/сценарий | Наблюдаемый результат | -| ---------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | -| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | -| Сохранность через полный рестарт | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | -| Интеграционный набор (реальные PG/Redis) | `npx vitest run --config vitest.config.e2e.ts` | 7 passed, 1 gated | -| То же с `SESSION_TTL_SECONDS=2` | тот же набор с TTL=2 | 8 passed (включая expiry → 401) | -| Гонка одинакового username | набор: два одновременных POST + `select count(*)` | 201 и 409; в `users` ровно 1 строка (гарантия — unique index `users_username_key`, ошибка `23505` → 409) | -| Rollback чата с неизвестным участником | HTTP 400 + `select count(*)` | 400; строк в `chats` — 0 | -| Индекс истории | `EXPLAIN (ANALYZE, BUFFERS)` на 10 002 строках | `Index Scan using messages_chat_created_id_idx` для первой страницы (0.040 мс) и для keyset-продолжения (0.048 мс) | -| Отказ Redis | stop redis | `/health/ready` 503, `/users/me` 503 (анонимного доступа нет), после старта — 200 | -| Отказ PostgreSQL | stop postgres | `/health/ready` 503, `/users/me` 503; процесс API жив; после старта — 200 с тем же токеном | -| Логин/логаут/подмена | набор + `X-User-Id` | Basic на бизнес-endpoint 401, `X-User-Id` не меняет владельца, replay после logout 401 | -| Ручной клиент (Bruno) | `bru run -r --env local ...` из `bruno/` | 28 запросов, 56 проверок — все зелёные (включая негативные и метрики) | +| Проверка | Команда/сценарий | Наблюдаемый результат | +| ---------------------------------------- | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | +| Сохранность через полный рестарт | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | +| Интеграционный набор (реальные PG/Redis) | `npx vitest run --config vitest.config.e2e.ts` | 9 passed, 1 gated | +| То же с `SESSION_TTL_SECONDS=2` | тот же набор с TTL=2 | 10 passed (включая expiry → 401) | +| Гонка одинакового username | набор: два одновременных POST + `select count(*)` | 201 и 409; в `users` ровно 1 строка (гарантия — unique index `users_username_key`, ошибка `23505` → 409) | +| Rollback чата с неизвестным участником | HTTP 400 + `select count(*)` | 400; строк в `chats` — 0 | +| Индекс истории | `EXPLAIN (ANALYZE, BUFFERS)` на 10 002 строках | `Index Scan using messages_chat_created_id_idx` для первой страницы (0.040 мс) и для keyset-продолжения (0.048 мс) | +| Отказ Redis (автоматически) | `make test-dependencies` | `/health/live` 200; `/health/ready` и бизнес-запросы — ограниченная 503; анонимный запрос 401; после старта сессия и данные живы | +| Отказ PostgreSQL (автоматически) | `make test-dependencies` | `/health/live` 200; все бизнес-запросы и регистрация — 503 без утечки деталей; процесс жив; после старта запись работает | +| Логин/логаут/подмена | набор + `X-User-Id` | Basic на бизнес-endpoint 401, `X-User-Id` не меняет владельца, replay после logout 401 | +| Ручной клиент (Bruno) | `bru run -r --env local ...` из `bruno/` | 29 запросов, 58 проверок — все зелёные (включая негативные и метрики) | Отдельно исправлен реальный дефект: при падении PostgreSQL процесс API завершался из-за необработанного события `error` у idle-клиента пула. Добавлен обработчик `pool.on('error')`, а ошибки доступности БД в фильтре отображаются в ограниченную 503 вместо 500. @@ -195,6 +203,7 @@ make validate (cd app && npm run build && npm test && npx tsc --noEmit) make test BASE_URL=http://localhost:8080 make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-dependencies (cd app && API_BASE_URL=http://localhost:8080 \ DATABASE_URL=postgresql://messenger:@:5432/messenger \ REDIS_URL=redis://:6379 npx vitest run --config ./vitest.config.e2e.ts) diff --git a/app/README.md b/app/README.md index d73b4dfc..f8651900 100644 --- a/app/README.md +++ b/app/README.md @@ -30,7 +30,11 @@ src/ cache/ версионированный кэш истории + lock на страницу metrics/ /internal/metrics и /internal/metrics/reset health/ liveness/readiness с проверкой зависимостей - common/ guard, exception filter, request-id, cursor, errors + common/ + http/ cursor (формат+календарь), page (конверт {items,next_cursor}), request-id + errors/ exception filter и тип тела ошибки ApiErrorBody + validation/ декоратор CodePointLength (длины в Unicode code points) + auth/ guard и декоратор текущего пользователя test/ app.e2e-spec.ts black-box набор против запущенного API (PG + Redis) scripts/ @@ -40,7 +44,9 @@ scripts/ Принципы: raw `pg.Pool` без ORM, параметризованные запросы, никаких in-memory хранилищ в боевых путях; кэш — производное состояние и всегда допускает восстановление из PostgreSQL; отказ зависимости даёт ограниченную ошибку -(`503`), а не аварийное завершение процесса. +(`503`), а не аварийное завершение процесса; длины строк проверяются в Unicode +code points (свой декоратор `@CodePointLength`), как в JSON Schema, а не в +UTF-16-единицах. ## Быстрый старт @@ -132,6 +138,7 @@ npm run start:dev # или npm run start:prod после | `npm run start:prod` | запуск собранного приложения (`node dist/main`) | | `npm test` / `npm run test:unit` | unit-тесты (vitest) | | `npm run test:e2e` | black-box набор против запущенного API (см. ниже) | +| `npm run test:dependencies` | автоматическая проверка отказов Redis/PostgreSQL: останавливает и поднимает контейнеры Compose-стенда | | `npm run lint` | oxlint по `src/` и `test/` | | `npm run format` | prettier | | `npm run graph` | граф модулей и провайдеров через nestjs-spelunker (пишет `../docs/architecture/`) | @@ -158,6 +165,26 @@ npm run test:e2e устанавливает `process.env.BASE_URL` в значение Vite base. Кейс истечения сессии включается переменной `SESSION_TTL_SECONDS=2` и у запущенного API, и у набора. +## Отказы зависимостей + +Отдельный набор останавливает и поднимает контейнеры Compose-стенда и проверяет +ограниченные ошибки вместо 500: + +```sh +cd .. # из корня репозитория, стенд поднят через docker compose +make test-dependencies +``` + +Он включён по флагу `E2E_DEPENDENCY_FAULTS=1` (им же управляет цель Makefile), +потому что требует прав на управление Docker Compose-проектом; остальные +переменные — `E2E_COMPOSE_DIR`, `E2E_COMPOSE_ENV_FILE`, `E2E_REDIS_SERVICE`, +`E2E_POSTGRES_SERVICE`. Проверяется для Redis и PostgreSQL: `/health/live` +остаётся `200`, `/health/ready` и бизнес-запросы возвращают `503 unavailable` +с `request_id` из `X-Request-Id` и без деталей драйвера, запрос без сессии — +по-прежнему `401`, а после старта зависимости живы прежняя сессия, +подтверждённое сообщение и новая запись. Каждый запрос к остановленной БД ждёт +`DATABASE_CONNECTION_TIMEOUT_MS`, поэтому набор идёт около 40 секунд. + ## Метрики `GET /internal/metrics` возвращает `{counters, latency_ms}`: именованные SQL-метки, diff --git a/app/package-lock.json b/app/package-lock.json index 0ef2c3ab..b98212b8 100644 --- a/app/package-lock.json +++ b/app/package-lock.json @@ -17,6 +17,7 @@ "argon2": "^0.45.1", "class-transformer": "^0.5.1", "class-validator": "^0.15.1", + "date-fns": "^4.4.0", "fastify": "^5.12.5", "pg": "^8.23.1", "redis": "^6.3.0", @@ -3526,6 +3527,16 @@ "node": ">= 8" } }, + "node_modules/date-fns": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-4.4.0.tgz", + "integrity": "sha512-+1UMbeh68lH1SegH83CGWwpb6OHHbpSgr3+s5Eww5M4CAgswBpoWS0AjTOfEJ33HiYKz1hdj/KTFprzXHmq/6w==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/kossnocorp" + } + }, "node_modules/debug": { "version": "4.4.3", "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", diff --git a/app/package.json b/app/package.json index 00de6a9f..0bf3832b 100644 --- a/app/package.json +++ b/app/package.json @@ -21,7 +21,8 @@ "test:cov": "vitest run --coverage", "test:debug": "vitest --inspect-brk --no-file-parallelism", "graph": "npm run build && DATABASE_URL=postgresql://graph-only.invalid/messenger REDIS_URL=redis://graph-only.invalid:6379 tsx scripts/graph-modules.ts", - "test:e2e": "vitest run --config ./vitest.config.e2e.ts" + "test:e2e": "vitest run --config ./vitest.config.e2e.ts", + "test:dependencies": "E2E_DEPENDENCY_FAULTS=1 vitest run --config ./vitest.config.e2e.ts dependency-failures" }, "dependencies": { "@nestjs/common": "^12.0.1", @@ -32,6 +33,7 @@ "argon2": "^0.45.1", "class-transformer": "^0.5.1", "class-validator": "^0.15.1", + "date-fns": "^4.4.0", "fastify": "^5.12.5", "pg": "^8.23.1", "redis": "^6.3.0", diff --git a/app/src/chats/chats.repository.ts b/app/src/chats/chats.repository.ts index 7090e15a..7f724bcb 100644 --- a/app/src/chats/chats.repository.ts +++ b/app/src/chats/chats.repository.ts @@ -1,8 +1,4 @@ -import { - BadRequestException, - Injectable, - NotFoundException, -} from '@nestjs/common'; +import { BadRequestException, Injectable } from '@nestjs/common'; import { randomUUID } from 'node:crypto'; import { DatabaseClient } from '../database/database.client.js'; import type { Cursor } from '../common/http/cursor.js'; diff --git a/app/src/chats/chats.service.ts b/app/src/chats/chats.service.ts index 354c8973..2a78c65e 100644 --- a/app/src/chats/chats.service.ts +++ b/app/src/chats/chats.service.ts @@ -4,6 +4,7 @@ import { NotFoundException, } from '@nestjs/common'; import { encodeCursor, decodeCursor } from '../common/http/cursor.js'; +import type { Page } from '../common/http/page.js'; import type { User } from '../users/user.js'; import type { CreateChatDto } from './dto/create-chat.dto.js'; import type { Chat } from './chat.js'; @@ -34,7 +35,7 @@ export class ChatsService { currentUser: User, limit: number, cursorValue?: string, - ): Promise<{ items: Chat[]; next_cursor: string | null }> { + ): Promise> { const scope = `chats:${currentUser.id}`; const cursor = cursorValue ? decodeCursor(cursorValue, scope) diff --git a/app/src/chats/dto/create-chat.dto.ts b/app/src/chats/dto/create-chat.dto.ts index baeb07cc..37ff853d 100644 --- a/app/src/chats/dto/create-chat.dto.ts +++ b/app/src/chats/dto/create-chat.dto.ts @@ -5,13 +5,13 @@ import { IsArray, IsString, IsUUID, - Length, Matches, } from 'class-validator'; +import { CodePointLength } from '../../common/validation/code-point-length.js'; export class CreateChatDto { @IsString() - @Length(1, 100) + @CodePointLength(1, 100) @Matches(/\S/, { message: 'title must contain a non-whitespace character', }) diff --git a/app/src/common/errors/api-error.ts b/app/src/common/errors/api-error.ts new file mode 100644 index 00000000..b26ece9b --- /dev/null +++ b/app/src/common/errors/api-error.ts @@ -0,0 +1,7 @@ +export type ApiErrorBody = { + error: { + code: string; + message: string; + request_id: string; + }; +}; diff --git a/app/src/common/errors/api-exception.filter.ts b/app/src/common/errors/api-exception.filter.ts index ce3298b9..dd7e5871 100644 --- a/app/src/common/errors/api-exception.filter.ts +++ b/app/src/common/errors/api-exception.filter.ts @@ -4,35 +4,56 @@ import { ExceptionFilter, HttpException, HttpStatus, + Logger, } from '@nestjs/common'; import { HttpAdapterHost } from '@nestjs/core'; import { randomUUID } from 'node:crypto'; +import type { ApiErrorBody } from './api-error.js'; type RequestWithId = { requestId?: string; method?: string; url?: string }; type ExceptionBody = { message?: unknown; challenge?: unknown }; // Connection/session loss codes reported by node-postgres and the network layer. -const UNAVAILABLE_ERROR_CODES = new Set([ - 'ECONNREFUSED', - 'ECONNRESET', - 'ENOTFOUND', - 'ETIMEDOUT', - 'EPIPE', - '08000', - '08001', - '08003', - '08004', - '08006', - '57P01', - '57P02', - '57P03', - '53300', -]); +const UNAVAILABLE_ERROR_CODES: Record = { + ECONNREFUSED: true, + ECONNRESET: true, + ENOTFOUND: true, + ETIMEDOUT: true, + EPIPE: true, + '08000': true, + '08001': true, + '08003': true, + '08004': true, + '08006': true, + '57P01': true, + '57P02': true, + '57P03': true, + '53300': true, +}; + +// Some driver failures carry no `code` at all: node-postgres raises plain errors +// when a connection dies or its pool attempt times out, and node-redis reports a +// closed socket the same way. Without these patterns a stopped database would +// surface as an internal fault instead of a bounded outage. +const UNAVAILABLE_ERROR_MESSAGES = [ + 'Connection terminated unexpectedly', + 'Connection terminated due to connection timeout', + 'timeout exceeded when trying to connect', + 'Client has encountered a connection error and is not queryable', + 'Socket closed unexpectedly', + 'Connection is closed', +]; function isDependencyOutage(exception: unknown): boolean { if (typeof exception !== 'object' || exception === null) return false; const code = (exception as { code?: unknown }).code; - return typeof code === 'string' && UNAVAILABLE_ERROR_CODES.has(code); + if (typeof code === 'string' && UNAVAILABLE_ERROR_CODES[code] === true) + return true; + const message = (exception as { message?: unknown }).message; + return ( + typeof message === 'string' && + UNAVAILABLE_ERROR_MESSAGES.some((pattern) => message.includes(pattern)) + ); } function errorCodeForStatus(status: number): string { @@ -51,6 +72,8 @@ function errorCodeForStatus(status: number): string { @Catch() export class ApiExceptionFilter implements ExceptionFilter { + private readonly logger = new Logger(ApiExceptionFilter.name); + constructor(private readonly adapterHost: HttpAdapterHost) {} catch(exception: unknown, host: ArgumentsHost): void { @@ -92,6 +115,16 @@ export class ApiExceptionFilter implements ExceptionFilter { // A dropped dependency is a bounded outage, not an internal fault. status = HttpStatus.SERVICE_UNAVAILABLE; message = 'Service unavailable'; + this.logger.warn( + `Dependency outage on ${request.method ?? ''} ${request.url ?? ''}: ${exception instanceof Error ? exception.message : 'unknown error'}`, + ); + } else { + this.logger.error( + `Unhandled exception on ${request.method ?? ''} ${request.url ?? ''}`, + exception instanceof Error + ? exception.stack + : String(exception), + ); } if (status === HttpStatus.UNAUTHORIZED) { const authChallenge = @@ -103,16 +136,13 @@ export class ApiExceptionFilter implements ExceptionFilter { adapter.setHeader(response, 'WWW-Authenticate', authChallenge); } adapter.setHeader(response, 'X-Request-Id', requestId); - adapter.reply( - response, - { - error: { - code: errorCodeForStatus(status), - message, - request_id: requestId, - }, + const payload: ApiErrorBody = { + error: { + code: errorCodeForStatus(status), + message, + request_id: requestId, }, - status, - ); + }; + adapter.reply(response, payload, status); } } diff --git a/app/src/common/http/cursor.spec.ts b/app/src/common/http/cursor.spec.ts new file mode 100644 index 00000000..f4e7823b --- /dev/null +++ b/app/src/common/http/cursor.spec.ts @@ -0,0 +1,85 @@ +import { BadRequestException } from '@nestjs/common'; +import { randomUUID } from 'node:crypto'; +import { describe, expect, it } from 'vitest'; +import { decodeCursor, encodeCursor } from './cursor.js'; + +const scope = 'messages:6f1c2a3e-1111-4222-8333-444455556666'; + +function encode(createdAt: string, cursorScope = scope): string { + return encodeCursor({ + scope: cursorScope, + created_at: createdAt, + id: randomUUID(), + }); +} + +describe('decodeCursor', () => { + it('accepts valid instants and normalizes them to canonical milliseconds', () => { + const accepted: Array<[string, string]> = [ + ['2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'], + ['2026-01-01T00:00:00Z', '2026-01-01T00:00:00.000Z'], + ['2026-01-01T00:00:00.999999Z', '2026-01-01T00:00:00.999Z'], + ['2024-02-29T23:59:59.000Z', '2024-02-29T23:59:59.000Z'], + ['2026-12-31T23:59:59.999Z', '2026-12-31T23:59:59.999Z'], + ]; + for (const [createdAt, expected] of accepted) { + const decoded = decodeCursor(encode(createdAt), scope); + expect(decoded.created_at).toBe(expected); + expect(decoded.scope).toBe(scope); + } + }); + + it('rejects calendar dates that the platform parser rolls over', () => { + // 2026-02-31 would silently become 2026-03-03 and then fail inside SQL. + for (const createdAt of [ + '2026-02-31T00:00:00.000Z', + '2025-02-29T00:00:00.000Z', + '2026-04-31T00:00:00.000Z', + '2026-06-31T12:00:00.000Z', + ]) { + expect(() => decodeCursor(encode(createdAt), scope)).toThrow( + BadRequestException, + ); + } + }); + + it('rejects out-of-range and malformed timestamps', () => { + for (const createdAt of [ + '2026-01-01T24:00:00.000Z', + '2026-01-01T00:00:60.000Z', + '2026-13-01T00:00:00.000Z', + '2026-00-01T00:00:00.000Z', + '2026-01-01T00:00:00', + '2026-01-01T00:00:00+02:00', + '2026-1-1T00:00:00.000Z', + '2026-01-01', + 'not-a-timestamp', + ]) { + expect(() => decodeCursor(encode(createdAt), scope)).toThrow( + BadRequestException, + ); + } + }); + + it('rejects a cursor from another scope, a malformed id, and non-cursor input', () => { + expect(() => + decodeCursor( + encode('2026-01-01T00:00:00.000Z', 'messages:other'), + scope, + ), + ).toThrow(BadRequestException); + expect(() => + decodeCursor( + encodeCursor({ + scope, + created_at: '2026-01-01T00:00:00.000Z', + id: 'not-a-uuid', + }), + scope, + ), + ).toThrow(BadRequestException); + expect(() => decodeCursor('not-a-cursor', scope)).toThrow( + BadRequestException, + ); + }); +}); diff --git a/app/src/common/http/cursor.ts b/app/src/common/http/cursor.ts index bdc53a1e..037d4a4d 100644 --- a/app/src/common/http/cursor.ts +++ b/app/src/common/http/cursor.ts @@ -1,4 +1,5 @@ import { BadRequestException } from '@nestjs/common'; +import { isValid, parseISO } from 'date-fns'; export type Cursor = { scope: string; @@ -6,6 +7,14 @@ export type Cursor = { id: string; }; +// Format check for the canonical API shape: `Date.prototype.toISOString()` with +// optional fractional seconds. Explicit ranges reject values such as 24:00:00. +// Calendar validity (2026-02-31, 2025-02-29, 2026-04-31) is checked by +// date-fns `parseISO`, which refuses impossible dates that the platform parser +// would silently roll over into another day. +const CURSOR_TIMESTAMP = + /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?Z$/u; + export function encodeCursor(cursor: Cursor): string { return Buffer.from(JSON.stringify(cursor), 'utf8').toString('base64url'); } @@ -28,30 +37,18 @@ export function decodeCursor(value: string, expectedScope: string): Cursor { !/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu.test( parsed.id, ) || - !/^(?:\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/u.test( - parsed.created_at, - ) + !CURSOR_TIMESTAMP.test(parsed.created_at) ) throw new Error('invalid cursor'); - const timestamp = Date.parse(parsed.created_at); - if (!Number.isFinite(timestamp)) throw new Error('invalid cursor'); + const instant = parseISO(parsed.created_at); + if (!isValid(instant)) throw new Error('invalid cursor'); + return { scope: parsed.scope, - created_at: parsed.created_at, + created_at: instant.toISOString(), id: parsed.id, }; } catch { throw new BadRequestException('Invalid cursor'); } } - -export function isAfter( - createdAt: string, - id: string, - cursor: Cursor, -): boolean { - return ( - createdAt > cursor.created_at || - (createdAt === cursor.created_at && id > cursor.id) - ); -} diff --git a/app/src/common/http/page.ts b/app/src/common/http/page.ts new file mode 100644 index 00000000..55c9ff8a --- /dev/null +++ b/app/src/common/http/page.ts @@ -0,0 +1,4 @@ +export type Page = { + items: T[]; + next_cursor: string | null; +}; diff --git a/app/src/common/validation/code-point-length.spec.ts b/app/src/common/validation/code-point-length.spec.ts new file mode 100644 index 00000000..2daa8306 --- /dev/null +++ b/app/src/common/validation/code-point-length.spec.ts @@ -0,0 +1,43 @@ +import { validate } from 'class-validator'; +import { describe, expect, it } from 'vitest'; +import { CodePointLength } from './code-point-length.js'; + +class Sample { + @CodePointLength(3, 5) + value!: string; +} + +async function fails(value: unknown): Promise { + const sample = new Sample(); + (sample as { value: unknown }).value = value; + const errors = await validate(sample); + return errors.length > 0; +} + +describe('CodePointLength', () => { + it('counts Unicode code points instead of UTF-16 units', async () => { + // '🔐' is one code point but two UTF-16 units. + expect(await fails('🔐🔐')).toBe(true); + expect(await fails('🔐🔐🔐')).toBe(false); + expect(await fails('🔐🔐🔐🔐🔐')).toBe(false); + expect(await fails('🔐🔐🔐🔐🔐🔐')).toBe(true); + // Combining marks are separate code points, not grapheme clusters: + // three 'é' sequences are six code points and exceed the maximum. + expect(await fails('e\u0301e\u0301')).toBe(false); + expect(await fails('e\u0301e\u0301e\u0301')).toBe(true); + }); + + it('applies to BMP text boundaries', async () => { + expect(await fails('ab')).toBe(true); + expect(await fails('abc')).toBe(false); + expect(await fails('abcde')).toBe(false); + expect(await fails('abcdef')).toBe(true); + }); + + it('rejects empty and non-string values', async () => { + expect(await fails('')).toBe(true); + expect(await fails(undefined)).toBe(true); + expect(await fails(12345)).toBe(true); + expect(await fails(['a', 'b', 'c'])).toBe(true); + }); +}); diff --git a/app/src/common/validation/code-point-length.ts b/app/src/common/validation/code-point-length.ts new file mode 100644 index 00000000..5b3fa3ae --- /dev/null +++ b/app/src/common/validation/code-point-length.ts @@ -0,0 +1,38 @@ +import { + registerDecorator, + ValidatorConstraint, + type ValidationArguments, + type ValidatorConstraintInterface, +} from 'class-validator'; + +// JSON Schema (and the course contract) measure string lengths in Unicode code +// points, while String.prototype.length counts UTF-16 units: one emoji outside +// the BMP is two units. `@Length` therefore accepted an 11-emoji password +// (22 units) and rejected 4000 emoji (8000 units), so these fields use an +// explicit code-point validator instead. +@ValidatorConstraint({ name: 'codePointLength', async: false }) +class CodePointLengthConstraint implements ValidatorConstraintInterface { + validate(value: unknown, args: ValidationArguments): boolean { + const [min, max] = args.constraints as [number, number]; + if (typeof value !== 'string') return false; + const length = [...value].length; + return length >= min && length <= max; + } + + defaultMessage(args: ValidationArguments): string { + const [min, max] = args.constraints as [number, number]; + return `${args.property} must be between ${min} and ${max} code points`; + } +} + +export function CodePointLength(min: number, max: number): PropertyDecorator { + return (target, propertyKey) => { + registerDecorator({ + name: 'codePointLength', + target: target.constructor, + propertyName: String(propertyKey), + constraints: [min, max], + validator: CodePointLengthConstraint, + }); + }; +} diff --git a/app/src/messages/cache/messages-cache.service.ts b/app/src/messages/cache/messages-cache.service.ts index c41f5e49..565c17c4 100644 --- a/app/src/messages/cache/messages-cache.service.ts +++ b/app/src/messages/cache/messages-cache.service.ts @@ -3,15 +3,13 @@ import { ConfigService } from '@nestjs/config'; import { setTimeout as delay } from 'node:timers/promises'; import type { AppConfig } from '../../config/app-config.schema.js'; import { RedisClient } from '../../redis/redis.client.js'; +import type { Page } from '../../common/http/page.js'; import { MetricsService } from '../../metrics/metrics.service.js'; const LOCK_RETRY_COUNT = 4; const LOCK_RETRY_DELAY_MS = 25; -export type CachePage = { - items: unknown[]; - next_cursor: string | null; -}; +export type CachePage = Page; @Injectable() export class MessagesCacheService { diff --git a/app/src/messages/dto/create-message.dto.ts b/app/src/messages/dto/create-message.dto.ts index 875a3c22..57e5be26 100644 --- a/app/src/messages/dto/create-message.dto.ts +++ b/app/src/messages/dto/create-message.dto.ts @@ -1,7 +1,8 @@ -import { IsString, Length } from 'class-validator'; +import { IsString } from 'class-validator'; +import { CodePointLength } from '../../common/validation/code-point-length.js'; export class CreateMessageDto { @IsString() - @Length(1, 4000) + @CodePointLength(1, 4000) text!: string; } diff --git a/app/src/messages/messages.repository.ts b/app/src/messages/messages.repository.ts index 7427b28f..6f0e8a1d 100644 --- a/app/src/messages/messages.repository.ts +++ b/app/src/messages/messages.repository.ts @@ -1,12 +1,10 @@ import { - BadRequestException, Injectable, NotFoundException, } from '@nestjs/common'; import { randomUUID } from 'node:crypto'; import { DatabaseClient } from '../database/database.client.js'; import type { Cursor } from '../common/http/cursor.js'; -import type { User } from '../users/user.js'; import type { Message } from './message.js'; type MessageRow = { diff --git a/app/src/messages/messages.service.ts b/app/src/messages/messages.service.ts index 3db1128b..e95644a5 100644 --- a/app/src/messages/messages.service.ts +++ b/app/src/messages/messages.service.ts @@ -1,5 +1,6 @@ import { BadRequestException, Injectable } from '@nestjs/common'; import { decodeCursor, encodeCursor } from '../common/http/cursor.js'; +import type { Page } from '../common/http/page.js'; import type { User } from '../users/user.js'; import { ChatsService } from '../chats/chats.service.js'; import type { CreateMessageDto } from './dto/create-message.dto.js'; @@ -35,7 +36,7 @@ export class MessagesService { currentUser: User, limit: number, cursorValue?: string, - ): Promise<{ items: Message[]; next_cursor: string | null }> { + ): Promise> { await this.chatsService.getForUser(chatId, currentUser); const scope = `messages:${chatId}`; const cursor = cursorValue @@ -70,6 +71,6 @@ export class MessagesService { }; }, ); - return page as { items: Message[]; next_cursor: string | null }; + return page as Page; } } diff --git a/app/src/users/dto/create-user.dto.ts b/app/src/users/dto/create-user.dto.ts index fbbe6da3..8e82f58e 100644 --- a/app/src/users/dto/create-user.dto.ts +++ b/app/src/users/dto/create-user.dto.ts @@ -1,4 +1,5 @@ -import { IsString, Length, Matches } from 'class-validator'; +import { IsString, Matches } from 'class-validator'; +import { CodePointLength } from '../../common/validation/code-point-length.js'; export class CreateUserDTO { @IsString() @@ -6,13 +7,16 @@ export class CreateUserDTO { username!: string; @IsString() - @Length(1, 100) + @CodePointLength(1, 100) @Matches(/\S/u, { message: 'display_name must contain a non-whitespace character', }) display_name!: string; @IsString() - @Length(12, 128) + @CodePointLength(12, 128) + @Matches(/\S/u, { + message: 'password must contain a non-whitespace character', + }) password!: string; } diff --git a/app/src/users/users.service.ts b/app/src/users/users.service.ts index 341cebe0..e4ac35df 100644 --- a/app/src/users/users.service.ts +++ b/app/src/users/users.service.ts @@ -1,4 +1,4 @@ -import { BadRequestException, Injectable } from '@nestjs/common'; +import { Injectable } from '@nestjs/common'; import argon2 from 'argon2'; import { randomUUID } from 'node:crypto'; import { CreateUserDTO } from './dto/create-user.dto.js'; @@ -10,13 +10,6 @@ export class UsersService { constructor(private readonly usersRepository: UsersRepository) {} async create(input: CreateUserDTO): Promise { - if ( - [...input.display_name].length < 1 || - [...input.display_name].length > 100 || - input.display_name.trim().length === 0 - ) { - throw new BadRequestException('Invalid display name'); - } const passwordHash = await argon2.hash(input.password, { type: argon2.argon2id, }); diff --git a/app/test/app.e2e-spec.ts b/app/test/app.e2e-spec.ts index 00270906..ff45dc3e 100644 --- a/app/test/app.e2e-spec.ts +++ b/app/test/app.e2e-spec.ts @@ -3,6 +3,12 @@ import { randomUUID } from 'node:crypto'; import { setTimeout as sleep } from 'node:timers/promises'; import { Pool } from 'pg'; import { createClient } from 'redis'; +import type { SessionResponse } from '../src/auth/auth.service.js'; +import type { Chat } from '../src/chats/chat.js'; +import type { ApiErrorBody } from '../src/common/errors/api-error.js'; +import type { Page } from '../src/common/http/page.js'; +import type { Message } from '../src/messages/message.js'; +import type { User } from '../src/users/user.js'; // The suite is black-box: run it against the compiled application process. // Vitest sets process.env.BASE_URL itself (Vite base), so the API URL uses its own name. @@ -20,35 +26,6 @@ let sequence = 0; let database: Pool; let redis: ReturnType; -type User = { - id: string; - username: string; - display_name: string; - created_at: string; -}; -type Session = { - token: string; - token_type: string; - expires_at: string; - user: User; -}; -type Chat = { - id: string; - title: string; - member_ids: string[]; - created_at: string; -}; -type Message = { - id: string; - chat_id: string; - sender_id: string; - text: string; - created_at: string; -}; -type Page = { items: T[]; next_cursor: string | null }; -type ApiError = { - error: { code: string; message: string; request_id: string }; -}; type Actor = { user: User; password: string; token: string }; type HttpResult = { body: T; response: Response }; @@ -102,8 +79,8 @@ async function register( return result.body; } -async function login(user: User, secret = password): Promise { - const result = await http('/api/v1/auth/sessions', { +async function login(user: User, secret = password): Promise { + const result = await http('/api/v1/auth/sessions', { method: 'POST', headers: { authorization: basic(user.username, secret) }, }); @@ -119,7 +96,7 @@ async function actor(displayName?: string): Promise { } function expectError( - result: HttpResult, + result: HttpResult, status: number, code: string, ): void { @@ -174,13 +151,120 @@ describe('HTTP integration contract', () => { const live = await http<{ status: string }>('/health/live'); expect(live.response.status).toBe(200); expect(live.body).toEqual({ status: 'ok' }); - const denied = await http('/api/v1/users/me'); + const denied = await http('/api/v1/users/me'); expectError(denied, 401, 'unauthorized'); expect(denied.response.headers.get('www-authenticate')).toBe( bearerChallenge, ); }); + it('measures string lengths in Unicode code points', async () => { + const emoji = '🔐'; + const username = (suffix: string) => + `e2e_${runId}_${suffix}`.slice(0, 32); + const rejected = await http( + '/api/v1/users', + json({ + username: username('cp_short'), + display_name: 'Code points', + password: emoji.repeat(11), + }), + ); + expectError(rejected, 400, 'invalid_request'); + const tooLongPassword = await http( + '/api/v1/users', + json({ + username: username('cp_long'), + display_name: 'Code points', + password: emoji.repeat(129), + }), + ); + expectError(tooLongPassword, 400, 'invalid_request'); + const tooLongName = await http( + '/api/v1/users', + json({ + username: username('cp_name'), + display_name: emoji.repeat(101), + password, + }), + ); + expectError(tooLongName, 400, 'invalid_request'); + + const shortUsername = username('cp_ok'); + usernames.push(shortUsername); + const boundaryPassword = emoji.repeat(12); + const created = await http( + '/api/v1/users', + json({ + username: shortUsername, + display_name: emoji.repeat(100), + password: boundaryPassword, + }), + ); + expect(created.response.status).toBe(201); + expect([...created.body.display_name].length).toBe(100); + // The stored password keeps all 12 code points: authentication works. + const session = await http('/api/v1/auth/sessions', { + method: 'POST', + headers: { + authorization: basic(shortUsername, boundaryPassword), + }, + }); + expect(session.response.status).toBe(201); + tokens.push(session.body.token); + + const longTitleRejected = await http( + '/api/v1/chats', + json( + { title: emoji.repeat(101), member_ids: [created.body.id] }, + bearer(session.body.token), + ), + ); + expectError(longTitleRejected, 400, 'invalid_request'); + const longTitle = await http( + '/api/v1/chats', + json( + { title: emoji.repeat(100), member_ids: [created.body.id] }, + bearer(session.body.token), + ), + ); + expect(longTitle.response.status).toBe(201); + const tooLongText = await http( + `/api/v1/chats/${longTitle.body.id}/messages`, + json({ text: emoji.repeat(4001) }, bearer(session.body.token)), + ); + expectError(tooLongText, 400, 'invalid_request'); + const boundaryText = await http( + `/api/v1/chats/${longTitle.body.id}/messages`, + json({ text: emoji.repeat(4000) }, bearer(session.body.token)), + ); + expect(boundaryText.response.status).toBe(201); + expect([...boundaryText.body.text].length).toBe(4000); + }); + + it('rejects whitespace-only and too-short credentials', async () => { + const username = `e2e_${runId}_${sequence++}`.slice(0, 32); + usernames.push(username); + const cases = [ + { password: ' '.repeat(12), display_name: 'Пользователь' }, + { password: '\t'.repeat(16), display_name: 'Пользователь' }, + { password: 'short-pass', display_name: 'Пользователь' }, + { password, display_name: ' ' }, + ]; + for (const body of cases) { + const result = await http( + '/api/v1/users', + json({ username, ...body }), + ); + expectError(result, 400, 'invalid_request'); + } + const accepted = await http( + '/api/v1/users', + json({ username, display_name: 'Пользователь', password }), + ); + expect(accepted.response.status).toBe(201); + }); + it('registers, logs in with Unicode/colon password, and challenges malformed Basic', async () => { const user = await register(); const session = await login(user); @@ -196,7 +280,7 @@ describe('HTTP integration contract', () => { 'Basic YWJj', 'Bearer nope', ]) { - const result = await http('/api/v1/auth/sessions', { + const result = await http('/api/v1/auth/sessions', { method: 'POST', headers: { authorization }, }); @@ -205,7 +289,7 @@ describe('HTTP integration contract', () => { basicChallenge, ); } - const bodyResult = await http('/api/v1/auth/sessions', { + const bodyResult = await http('/api/v1/auth/sessions', { ...json({ unexpected: true }), headers: { authorization: basic(user.username, password) }, }); @@ -244,12 +328,12 @@ describe('HTTP integration contract', () => { it('uses Bearer only, ignores X-User-Id spoofing, and prevents logout replay', async () => { const alice = await actor('Алиса'); const bob = await actor('Боб'); - const spoof = await http('/api/v1/users/me', { + const spoof = await http('/api/v1/users/me', { headers: { ...bearer(alice.token), 'x-user-id': bob.user.id }, }); expect(spoof.response.status).toBe(200); expect((spoof.body as unknown as User).id).toBe(alice.user.id); - const basicBusiness = await http('/api/v1/users/me', { + const basicBusiness = await http('/api/v1/users/me', { headers: { authorization: basic(alice.user.username, password) }, }); expectError(basicBusiness, 401, 'unauthorized'); @@ -261,7 +345,7 @@ describe('HTTP integration contract', () => { headers: bearer(alice.token), }); expect(logout.response.status).toBe(204); - const replay = await http('/api/v1/users/me', { + const replay = await http('/api/v1/users/me', { headers: bearer(alice.token), }); expectError(replay, 401, 'unauthorized'); @@ -271,7 +355,7 @@ describe('HTTP integration contract', () => { const alice = await actor(); const bob = await actor(); const outsider = await actor(); - const unknown = await http( + const unknown = await http( '/api/v1/chats', json( { title: 'unknown', member_ids: [alice.user.id, randomUUID()] }, @@ -279,7 +363,7 @@ describe('HTTP integration contract', () => { ), ); expectError(unknown, 400, 'invalid_request'); - const leaked = await http(`/api/v1/chats?limit=100`, { + const leaked = await http(`/api/v1/chats?limit=100`, { headers: bearer(alice.token), }); expect(leaked.response.status).toBe(200); @@ -288,7 +372,7 @@ describe('HTTP integration contract', () => { (item) => item.title === 'unknown', ), ).toBe(false); - const duplicate = await http( + const duplicate = await http( '/api/v1/chats', json( { @@ -310,7 +394,7 @@ describe('HTTP integration contract', () => { ), ); expect(created.response.status).toBe(201); - const hidden = await http( + const hidden = await http( `/api/v1/chats/${created.body.id}`, { headers: bearer(outsider.token) }, ); @@ -328,7 +412,7 @@ describe('HTTP integration contract', () => { ), ); expect(chat.response.status).toBe(201); - const blank = await http( + const blank = await http( `/api/v1/chats/${chat.body.id}/messages`, json( { text: ' \n\t', sender_id: randomUUID() }, @@ -336,7 +420,7 @@ describe('HTTP integration contract', () => { ), ); expectError(blank, 400, 'invalid_request'); - const spoof = await http( + const spoof = await http( `/api/v1/chats/${chat.body.id}/messages`, json( { text: 'hello', sender_id: randomUUID() }, @@ -377,17 +461,31 @@ describe('HTTP integration contract', () => { ); expect(sent.response.status).toBe(201); } - const invalidLimit = await http( + const invalidLimit = await http( `/api/v1/chats/${chat.body.id}/messages?limit=101`, { headers: bearer(alice.token) }, ); expectError(invalidLimit, 400, 'invalid_request'); - const invalidCursor = await http( + const invalidCursor = await http( `/api/v1/chats/${chat.body.id}/messages?cursor=not-a-cursor`, { headers: bearer(alice.token) }, ); expectError(invalidCursor, 400, 'invalid_request'); - const malformed = await http('/api/v1/users', { + const rolledOver = http( + `/api/v1/chats/${chat.body.id}/messages?cursor=${encodeURIComponent( + Buffer.from( + JSON.stringify({ + scope: `messages:${chat.body.id}`, + created_at: '2026-02-31T00:00:00.000Z', + id: randomUUID(), + }), + 'utf8', + ).toString('base64url'), + )}`, + { headers: bearer(alice.token) }, + ); + expectError(await rolledOver, 400, 'invalid_request'); + const malformed = await http('/api/v1/users', { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{', @@ -418,7 +516,7 @@ describe('HTTP integration contract', () => { const user = await register(); const session = await login(user); await sleep(2300); - const expired = await http('/api/v1/users/me', { + const expired = await http('/api/v1/users/me', { headers: bearer(session.token), }); expectError(expired, 401, 'unauthorized'); diff --git a/app/test/dependency-failures.e2e-spec.ts b/app/test/dependency-failures.e2e-spec.ts new file mode 100644 index 00000000..ecd0cdbd --- /dev/null +++ b/app/test/dependency-failures.e2e-spec.ts @@ -0,0 +1,290 @@ +import { execFile } from 'node:child_process'; +import { randomUUID } from 'node:crypto'; +import { setTimeout as sleep } from 'node:timers/promises'; +import { fileURLToPath } from 'node:url'; +import { promisify } from 'node:util'; +import { afterAll, beforeAll, describe, expect, it } from 'vitest'; +import type { SessionResponse } from '../src/auth/auth.service.js'; +import type { Chat } from '../src/chats/chat.js'; +import type { ApiErrorBody } from '../src/common/errors/api-error.js'; +import type { Page } from '../src/common/http/page.js'; +import type { Message } from '../src/messages/message.js'; +import type { User } from '../src/users/user.js'; + +// Automated counterpart of the manual Redis/PostgreSQL outage checks: the suite +// stops a dependency of the Compose stand, asserts a bounded 503 (never a 500, +// never a trusted anonymous request, never a leaked driver error) and then +// restarts it to prove recovery without data loss. +// +// It is opt-in because it needs control over the Docker Compose project: +// make test-dependencies +// cd app && E2E_DEPENDENCY_FAULTS=1 npm run test:dependencies +const enabled = process.env.E2E_DEPENDENCY_FAULTS === '1'; +const baseUrl = (process.env.API_BASE_URL ?? 'http://localhost:8080').replace( + /\/+$/u, + '', +); +const composeDir = + process.env.E2E_COMPOSE_DIR ?? + fileURLToPath(new URL('../..', import.meta.url)); +const composeEnvFile = process.env.E2E_COMPOSE_ENV_FILE ?? '.env'; +const redisService = process.env.E2E_REDIS_SERVICE ?? 'redis'; +const postgresService = process.env.E2E_POSTGRES_SERVICE ?? 'postgres'; +const password = 'outage-check:пароль🔐'; +const runId = randomUUID().replaceAll('-', '').slice(0, 12); +// A request that reaches a stopped database waits for the pool connection +// timeout, so every outage step costs up to DATABASE_CONNECTION_TIMEOUT_MS. +const outagedRequestBudgetMs = 180_000; + +const execFileAsync = promisify(execFile); + +type Result = { body: T; text: string; response: Response }; + +async function compose(...args: string[]): Promise { + await execFileAsync( + 'docker', + ['compose', '--env-file', composeEnvFile, ...args], + { cwd: composeDir, timeout: 120_000 }, + ); +} + +async function request( + path: string, + init: RequestInit = {}, +): Promise> { + const response = await fetch(`${baseUrl}${path}`, init); + const text = await response.text(); + return { body: (text ? JSON.parse(text) : undefined) as T, text, response }; +} + +function json( + body: unknown, + headers: Record = {}, +): RequestInit { + return { + method: 'POST', + headers: { 'content-type': 'application/json', ...headers }, + body: JSON.stringify(body), + }; +} + +function bearer(token: string): Record { + return { authorization: `Bearer ${token}` }; +} + +function basic(username: string, secret: string): string { + return `Basic ${Buffer.from(`${username}:${secret}`, 'utf8').toString('base64')}`; +} + +// The dependencies recover asynchronously, so readiness is polled instead of +// asserted right after docker compose returns. +async function waitForReadiness( + expected: number, + timeoutMs = 90_000, +): Promise { + const deadline = Date.now() + timeoutMs; + let last: number | string = 'no response'; + for (;;) { + try { + const probe = await request('/health/ready'); + last = probe.response.status; + if (probe.response.status === expected) return; + } catch (error) { + last = error instanceof Error ? error.message : 'request failed'; + } + if (Date.now() > deadline) + throw new Error( + `readiness never became ${expected} within ${timeoutMs}ms (last: ${String(last)})`, + ); + await sleep(250); + } +} + +function expectBoundedOutage(result: Result): void { + expect(result.response.status).toBe(503); + expect(result.body.error.code).toBe('unavailable'); + expect(result.body.error.message).toBe('Service unavailable'); + expect(result.body.error.request_id).toBe( + result.response.headers.get('x-request-id'), + ); + // A bounded error must not leak driver details, SQL text or a stack trace. + expect(result.text).not.toMatch( + /ECONNREFUSED|ECONNRESET|Connection terminated|pg\.|node_modules|at .*\(.+:\d+:\d+\)/u, + ); +} + +async function historyOf( + chatId: string, + token: string, +): Promise>> { + return request>(`/api/v1/chats/${chatId}/messages?limit=100`, { + headers: bearer(token), + }); +} + +describe.skipIf(!enabled)('dependency outages', () => { + let user: User; + let token: string; + let chat: Chat; + let message: Message; + + beforeAll(async () => { + await compose('up', '-d'); + await waitForReadiness(200); + const username = `outage_${runId}`; + const registered = await request( + '/api/v1/users', + json({ username, display_name: 'Отказ зависимости', password }), + ); + expect(registered.response.status).toBe(201); + user = registered.body; + const session = await request( + '/api/v1/auth/sessions', + { + method: 'POST', + headers: { authorization: basic(username, password) }, + }, + ); + expect(session.response.status).toBe(201); + token = session.body.token; + const created = await request( + '/api/v1/chats', + json( + { title: `outage-${runId}`, member_ids: [user.id] }, + bearer(token), + ), + ); + expect(created.response.status).toBe(201); + chat = created.body; + const sent = await request( + `/api/v1/chats/${chat.id}/messages`, + json({ text: 'Сообщение до отказа' }, bearer(token)), + ); + expect(sent.response.status).toBe(201); + message = sent.body; + }, outagedRequestBudgetMs); + + afterAll(async () => { + // Always restore the stand, even when an assertion failed mid-outage. + await compose('start', redisService); + await compose('start', postgresService); + await waitForReadiness(200); + }, outagedRequestBudgetMs); + + it( + 'serves bounded 503 for the Redis outage and recovers the session', + async () => { + await compose('stop', redisService); + + const live = await request('/health/live'); + expect(live.response.status).toBe(200); + await waitForReadiness(503); + + expectBoundedOutage(await request('/health/ready')); + + expectBoundedOutage( + await request('/api/v1/users/me', { + headers: bearer(token), + }), + ); + + expectBoundedOutage( + await request('/api/v1/auth/sessions', { + method: 'POST', + headers: { authorization: basic(user.username, password) }, + }), + ); + + // A request without a session must stay unauthorized during an outage: + // the outage may not turn an anonymous caller into a trusted one. + const anonymous = await request('/api/v1/chats', { + headers: { 'x-user-id': user.id }, + }); + expect(anonymous.response.status).toBe(401); + expect(anonymous.body.error.code).toBe('unauthorized'); + + await compose('start', redisService); + await waitForReadiness(200); + + // Sessions live in Redis with persistence, so the old token still works. + const recovered = await request('/api/v1/users/me', { + headers: bearer(token), + }); + expect(recovered.response.status).toBe(200); + expect(recovered.body.id).toBe(user.id); + + const history = await historyOf(chat.id, token); + expect(history.response.status).toBe(200); + expect(history.body.items.map((item) => item.id)).toContain( + message.id, + ); + }, + outagedRequestBudgetMs, + ); + + it( + 'serves bounded 503 for the PostgreSQL outage and keeps confirmed data', + async () => { + await compose('stop', postgresService); + + const live = await request('/health/live'); + expect(live.response.status).toBe(200); + await waitForReadiness(503); + + expectBoundedOutage(await request('/health/ready')); + + // Redis still answers, so these requests reach the database layer. + expectBoundedOutage( + await request('/api/v1/users/me', { + headers: bearer(token), + }), + ); + + expectBoundedOutage( + await request('/api/v1/chats', { + headers: bearer(token), + }), + ); + + expectBoundedOutage( + await request( + `/api/v1/chats/${chat.id}/messages?limit=100`, + { headers: bearer(token) }, + ), + ); + + expectBoundedOutage( + await request( + '/api/v1/users', + json({ + username: `outage_${runId}_late`, + display_name: 'Отказ зависимости', + password, + }), + ), + ); + + await compose('start', postgresService); + await waitForReadiness(200); + + const recovered = await request('/api/v1/users/me', { + headers: bearer(token), + }); + expect(recovered.response.status).toBe(200); + expect(recovered.body.id).toBe(user.id); + + const history = await historyOf(chat.id, token); + expect(history.response.status).toBe(200); + expect(history.body.items.map((item) => item.id)).toContain( + message.id, + ); + + const sent = await request( + `/api/v1/chats/${chat.id}/messages`, + json({ text: 'Сообщение после отказа' }, bearer(token)), + ); + expect(sent.response.status).toBe(201); + }, + outagedRequestBudgetMs, + ); +}); diff --git a/app/vitest.config.e2e.ts b/app/vitest.config.e2e.ts index e7a3addd..a7d63173 100644 --- a/app/vitest.config.e2e.ts +++ b/app/vitest.config.e2e.ts @@ -6,7 +6,7 @@ export default defineConfig({ test: { globals: true, root: './', - include: ['test/app.e2e-spec.ts'], + include: ['test/*.e2e-spec.ts'], testTimeout: 30_000, hookTimeout: 30_000, sequence: { concurrent: false }, diff --git a/bruno/README.md b/bruno/README.md index 69a9d467..347c3873 100644 --- a/bruno/README.md +++ b/bruno/README.md @@ -21,7 +21,7 @@ cd bruno bru run -r --env-var metricsToken=$(grep '^METRICS_TOKEN=' ../.env | cut -d= -f2) ``` -Проверено на `bru` 4.2.1 против локального стенда: 28 запросов, 56 проверок, +Проверено на `bru` 4.2.1 против локального стенда: 29 запросов, 58 проверок, все зелёные (см. `../evidence/level3-4-verification.md` §12). Стенд должен быть поднят: `docker compose --env-file .env up -d --build`, @@ -60,7 +60,8 @@ chats/ создание чата (два участника), список health/ /health/live и /health/ready internal/ /internal/metrics и /internal/metrics/reset messages/ два сообщения, первая страница истории, страница по курсору -negative/ неверный пароль, Basic на бизнес-endpoint, X-User-Id, 404 чужого чата, 400 на limit/cursor и пробельный текст, 409 дубликата +negative/ неверный пароль, Basic на бизнес-endpoint, X-User-Id, 404 чужого чата, 400 на limit/cursor, + несуществующую календарную дату курсора и пробельный текст, 409 дубликата zz-cleanup/ logout и проверка, что отозванный токен даёт 401 (выполняется последним) ``` @@ -79,7 +80,7 @@ zz-cleanup/ logout и проверка, что отозванный токен - `messages/send-message*.bru` — `sender_id` выведен из сессии, `chat_id` верный; - `messages/history-*.bru` — `limit` соблюдён, курсор ведёт на следующую страницу и не повторяет элемент; - `internal/metrics.bru` — счётчики и агрегаты латентности без секретов; -- `negative/*` — коды и challenge-заголовки, отсутствие подмены владельца через `X-User-Id`, 404 вместо 403 для чужого чата, 409 при дубликате username, 400 на невалидные limit/cursor и пробельный текст. +- `negative/*` — коды и challenge-заголовки, отсутствие подмены владельца через `X-User-Id`, 404 вместо 403 для чужого чата, 409 при дубликате username, 400 на невалидные limit/cursor (включая несуществующую дату `2026-02-31`, которая раньше доходила до SQL и давала 500) и пробельный текст. ## Проверка истечения сессии diff --git a/bruno/chats/create-chat.bru b/bruno/chats/create-chat.bru index 2a27de61..8f4b3c99 100644 --- a/bruno/chats/create-chat.bru +++ b/bruno/chats/create-chat.bru @@ -14,13 +14,6 @@ headers { Authorization: Bearer {{token}} } -docs { - Составная операция в одной транзакции: проверка участников, вставка чата - и всех chat_members. Текущий пользователь обязан входить в member_ids, - неизвестные и дублирующиеся ID дают 400 без частичных данных. - Сохраняет chatId. -} - body:json { { "title": "Демо-чат {{suffix}}", @@ -28,11 +21,15 @@ body:json { } } +script:post-response { + bru.setVar("chatId", res.body.id); +} + tests { test("201 created", function() { expect(res.status).to.equal(201); }); - + test("оба участника в чате", function() { expect(res.body.member_ids).to.have.members([ bru.getVar("userId"), @@ -41,6 +38,9 @@ tests { }); } -script:post-response { - bru.setVar("chatId", res.body.id); +docs { + Составная операция в одной транзакции: проверка участников, вставка чата + и всех chat_members. Текущий пользователь обязан входить в member_ids, + неизвестные и дублирующиеся ID дают 400 без частичных данных. + Сохраняет chatId. } diff --git a/bruno/negative/invalid-calendar-cursor.bru b/bruno/negative/invalid-calendar-cursor.bru new file mode 100644 index 00000000..1f95ba1a --- /dev/null +++ b/bruno/negative/invalid-calendar-cursor.bru @@ -0,0 +1,46 @@ +meta { + name: Invalid calendar cursor + type: http + seq: 7 +} + +get { + url: {{baseUrl}}/api/v1/chats/{{chatId}}/messages?cursor={{calendarCursor}} + body: none + auth: none +} + +headers { + Authorization: Bearer {{token}} +} + +script:pre-request { + // Курсор собирается с реальным scope текущего чата, но с датой 31 февраля: + // платформенный Date.parse молча переносит её на 3 марта, поэтому проверка + // календаря (date-fns parseISO) должна отклонить запрос до SQL. + // В песочнице Bruno доступен btoa, но не Buffer. + const json = JSON.stringify({ + scope: `messages:${bru.getVar("chatId")}`, + created_at: "2026-02-31T00:00:00.000Z", + id: "00000000-0000-4000-8000-000000000000" + }); + const cursor = btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""); + bru.setVar("calendarCursor", cursor); +} + +tests { + test("400 invalid_request", function() { + expect(res.status).to.equal(400); + }); + + test("формат ошибки по контракту", function() { + expect(res.body.error.code).to.equal("invalid_request"); + expect(res.body.error.request_id).to.equal(res.headers["x-request-id"]); + }); +} + +docs { + Несуществующая календарная дата (31 февраля, 29 февраля невисокосного года) + — 400 invalid_request, а не 500 из PostgreSQL. Регрессия: 2026-02-31 проходила + проверку формы и доходила до SQL. +} diff --git a/evidence/README.md b/evidence/README.md index c375bb5a..6d4c240d 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -7,7 +7,7 @@ | [`track1-cache-consistency.md`](track1-cache-consistency.md) | Трек 1: окружение, методика, счётчики и латентность по каждой повторности для naive и protected, сравнение, read-after-write, восстановление после рестарта Redis, план запроса, хеши артефактов, ограничения. | | [`level3-4-verification.md`](level3-4-verification.md) | Проверки уровня 3/4 с наблюдаемым выводом команд: контракт, сборка и тесты, миграции, публичный smoke, persistence-перезапуск, чёрно-белый интеграционный набор, истечение TTL, гонка username, rollback, отказы зависимостей, `EXPLAIN`, endpoint метрик, а также дефекты, найденные этим аудитом. | | [`track1-explain.md`](track1-explain.md) | Тексты анализируемых SQL-запросов, подготовка 10 000 синтетических строк и сырой `EXPLAIN (ANALYZE, BUFFERS)`: `Index Scan using messages_chat_created_id_idx` для первой страницы и для продолжения по keyset-cursor. | -| [`../bruno/README.md`](../bruno/README.md) | Коллекция ручных запросов Bruno ко всем эндпоинтам (28 запросов / 56 проверок, все зелёные) — удобно для разбора API вручную. | +| [`../bruno/README.md`](../bruno/README.md) | Коллекция ручных запросов Bruno ко всем эндпоинтам (29 запросов / 58 проверок, все зелёные) — удобно для разбора API вручную. | | `track1-raw/naive.json` (в Git не попадает) | Сырой вывод бенчмарка для `CACHE_MODE=naive`. | | `track1-raw/protected.json` (в Git не попадает) | Сырой вывод бенчмарка для `CACHE_MODE=protected`. | | `track1-raw/redis-restart.json` (в Git не попадает) | Сырой вывод проверки рестарта Redis. | diff --git a/evidence/level3-4-verification.md b/evidence/level3-4-verification.md index 1656b8d1..712170b8 100644 --- a/evidence/level3-4-verification.md +++ b/evidence/level3-4-verification.md @@ -82,10 +82,12 @@ $ (cd app && API_BASE_URL=http://localhost:8080 \ REDIS_URL=redis://:6379 \ npx vitest run --config ./vitest.config.e2e.ts) Test Files 1 passed (1) -Tests 7 passed | 1 skipped (8) +Tests 9 passed | 1 skipped (10) ``` -Покрыто: challenge для Basic/Bearer с точными значениями `WWW-Authenticate`, некорректный Basic, запрет тела при создании сессии, пароль с Unicode и двоеточием, гонка дублирующейся регистрации, подмена `X-User-Id`, повторное использование токена после logout, чужой чат скрыт (404), неизвестные и дублирующиеся участники, пробельный текст и подмена отправителя, read-after-write через вторую сессию, сломанный JSON, некорректные cursor/limit, keyset-пагинация без повторов. +Покрыто: challenge для Basic/Bearer с точными значениями `WWW-Authenticate`, некорректный Basic, запрет тела при создании сессии, пароль с Unicode и двоеточием, гонка дублирующейся регистрации, подмена `X-User-Id`, повторное использование токена после logout, чужой чат скрыт (404), неизвестные и дублирующиеся участники, пробельный текст и подмена отправителя, read-after-write через вторую сессию, сломанный JSON, некорректные cursor/limit (включая несуществующую календарную дату), +границы длин в Unicode code points для пароля, `display_name`, `title` и текста сообщения, +keyset-пагинация без повторов. Набор читает `API_BASE_URL`, потому что Vitest сам устанавливает `process.env.BASE_URL` в значение Vite base (`/`). Порты PostgreSQL и Redis наружу не публикуются, поэтому оператор передаёт адреса контейнеров. @@ -96,7 +98,7 @@ $ sed -i 's/^SESSION_TTL_SECONDS=.*/SESSION_TTL_SECONDS=2/' .env $ docker compose up -d api $ (cd app && API_BASE_URL=http://localhost:8080 ... SESSION_TTL_SECONDS=2 npx vitest run --config ./vitest.config.e2e.ts) Test Files 1 passed (1) -Tests 8 passed (8) +Tests 10 passed (10) ``` Кейс истечения: регистрация, вход, ожидание 2,3 с, ожидание `401 unauthorized` с Bearer-challenge. Работают и TTL Redis, и сериализованный `expires_at`. После проверки TTL возвращён в 3600. @@ -141,6 +143,29 @@ GET /users/me (валидный токен) -> 503 Здесь найден и исправлен реальный дефект: idle-клиент пула эмитил `error` на пул, Node считал это необработанным исключением, и процесс API завершался. Теперь `DatabaseClient` регистрирует `pool.on('error')` (счётчик `database.pool_error` + `warn` в лог), а ошибки доступности БД маппятся в ограниченную `503` в `ApiExceptionFilter` вместо `500`. +Тот же сценарий автоматизирован: `make test-dependencies` (или +`E2E_DEPENDENCY_FAULTS=1 npm run test:dependencies` из `app/`) сам останавливает +и поднимает контейнеры Compose-стенда и проверяет для обоих хранилищ, что +`/health/live` остаётся `200`, `/health/ready` и бизнес-запросы дают ограниченную +`503 unavailable` с `request_id`, равным `X-Request-Id`, в теле ошибки нет утечки +деталей драйвера/SQL/стека, запрос без сессии остаётся `401` (отказ не делает +анонимного вызывающего доверенным), а после старта зависимости работают прежняя +сессия, подтверждённое сообщение и новая запись. + +```text +$ make test-dependencies + Test Files 1 passed (1) + Tests 2 passed (2) + Duration 40.09s +``` + +Первая версия этого теста сразу нашла дефект: `POST /api/v1/users` при +остановленном PostgreSQL отвечал `500`, потому что часть ошибок node-postgres +не несёт поля `code` («Connection terminated unexpectedly», «timeout exceeded +when trying to connect»). Фильтр теперь распознаёт и такие сообщения, а +неожиданные исключения логируются на сервере (в ответе остаётся только +`internal_error`). + Путь деградации кэша (Redis недоступен → ответ из PostgreSQL, счётчик `cache_fallback`) подтверждён unit-тестами, а не этим экспериментом: при остановленном Redis бизнес-запрос останавливается раньше, на session guard, и по дизайну получает `503`, поэтому до слоя кэша не доходит. ## 11. План запроса истории @@ -174,8 +199,8 @@ latency: {count: 25, sample_count: 25, p50: 2.82, p95: 50.71, p99: 52.74, max: 5 Без корректного `METRICS_TOKEN` endpoint отдаёт `401`; в ответе нет токенов, кредов, тел запросов и SQL-текста. Тот же путь проверен ручным клиентом Bruno (`bruno/README.md`): из корня коллекции -`bru run -r --env-var metricsToken=` дал 28 запросов и -56 проверок без падений (регистрация трёх пользователей, три Basic-сессии, чат, +`bru run -r --env-var metricsToken=` дал 29 запросов и +58 проверок без падений (регистрация трёх пользователей, три Basic-сессии, чат, сообщения с пагинацией, метрики и негативные сценарии). `baseUrl` и пароль подставляются на уровне коллекции (`bruno/collection.bru`), поэтому вводить адрес в каждой ручке не требуется; без реального токена метрик два запроса к @@ -185,27 +210,36 @@ latency: {count: 25, sample_count: 25, p50: 2.82, p95: 50.71, p99: 52.74, max: 5 ## 13. Дефекты, найденные этим аудитом и исправленные -| Дефект | Симптом | Исправление | -|---|---|---| -| Отсутствовали DI-импорты зависимостей `CurrentUserGuard` | контейнер API `Exited (1)` с `UnknownDependenciesException` | `ChatsModule`/`MessagesModule` импортируют `RedisModule`, `MetricsModule`; `UsersModule` их реэкспортирует | -| Микросекунды PostgreSQL против миллисекунд JavaScript | вторая страница истории повторяла последнее сообщение (`make test` падал) | миграция `002_timestamp_precision.sql` → `timestamptz(3)` | -| Regex курсора требовал строго version 4 | валидные курсоры отклонялись как `400 invalid_request` | regex принимает любую корректную форму UUID плюс строгий RFC 3339 UTC timestamp | -| Необработанное событие `error` пула | процесс API умирал при недоступности PostgreSQL | обработчик `pool.on('error')` (счётчик `database.pool_error` + `warn`), отказ маппится в `503` | -| «Тихие» блоки `catch` | деградация кэша и зависимостей была невидима | счётчики (`cache_fallback`, `cache_write_error`, `cache_unlock_error`, `cache_lock_timeout`, `cache_corrupt_entry`, `database.pool_error`, `database.rollback_error`, `redis.error`) + `warn`-логи | -| Мёртвое состояние `lastError`, `getLastError()`, `isReady()` | заполнялось и нигде не читалось | удалено; листенеры пишут лог и счётчик | -| `POST /internal/metrics/reset` отвечал `201` | действие возвращало статус создания ресурса (нашлось прогоном коллекции Bruno) | добавлен `@HttpCode(HttpStatus.OK)`, теперь `200` | -| `nest build` не копировал `.sql`-миграции в `dist/` | локальный запуск `node dist/database/migration.runner.js` упал бы: каталога миграций в `dist/` нет, работал только Docker за счёт отдельного `COPY` | в `nest-cli.json` добавлен `assets: database/migrations/*.sql → dist`, лишний `COPY` из `Dockerfile` убран; проверено `docker run --rm --entrypoint ls mtusi-messenger:lab2 dist/database/migrations` и повторным запуском runner (exit 0) | +| Дефект | Симптом | Исправление | +| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Отсутствовали DI-импорты зависимостей `CurrentUserGuard` | контейнер API `Exited (1)` с `UnknownDependenciesException` | `ChatsModule`/`MessagesModule` импортируют `RedisModule`, `MetricsModule`; `UsersModule` их реэкспортирует | +| Микросекунды PostgreSQL против миллисекунд JavaScript | вторая страница истории повторяла последнее сообщение (`make test` падал) | миграция `002_timestamp_precision.sql` → `timestamptz(3)` | +| Regex курсора требовал строго version 4 | валидные курсоры отклонялись как `400 invalid_request` | regex принимает любую корректную форму UUID плюс строгий RFC 3339 UTC timestamp | +| Необработанное событие `error` пула | процесс API умирал при недоступности PostgreSQL | обработчик `pool.on('error')` (счётчик `database.pool_error` + `warn`), отказ маппится в `503` | +| «Тихие» блоки `catch` | деградация кэша и зависимостей была невидима | счётчики (`cache_fallback`, `cache_write_error`, `cache_unlock_error`, `cache_lock_timeout`, `cache_corrupt_entry`, `database.pool_error`, `database.rollback_error`, `redis.error`) + `warn`-логи | +| Мёртвое состояние `lastError`, `getLastError()`, `isReady()` | заполнялось и нигде не читалось | удалено; листенеры пишут лог и счётчик | +| `POST /internal/metrics/reset` отвечал `201` | действие возвращало статус создания ресурса (нашлось прогоном коллекции Bruno) | добавлен `@HttpCode(HttpStatus.OK)`, теперь `200` | +| Курсор с несуществующей датой (`2026-02-31`) отвечал `500` | `Date.parse` молча переносил дату на 3 марта, значение доходило до SQL и Postgres отклонял его | формат проверяется регулярным выражением, календарь — `date-fns` `parseISO` + `isValid`; невозможные даты и `24:00:00` дают `400 invalid_request` (unit-тесты `cursor.spec.ts`, e2e-кейс, `bruno/negative/invalid-calendar-cursor.bru`) | +| Длины строк мерились в UTF-16-единицах | `@Length` считает UTF-16: пароль из 11 эмодзи (22 единицы) проходил проверку «12+», а текст из 4000 эмодзи (8000 единиц) отклонялся как слишком длинный | собственный декоратор `@CodePointLength` (`app/src/common/validation/code-point-length.ts`) считает code points; применён к `display_name`, `password`, `title`, тексту сообщения; дублирующая проверка в `UsersService` удалена; unit-тесты границ + HTTP-кейс в `app/test/app.e2e-spec.ts` | +| Пароль из 12 пробелов принимался (`201`) | проверялась только длина, хотя контракт требует непустые по непробельным символам обязательные строки | в `CreateUserDTO` добавлен `@Matches(/\S/u)`; e2e-кейс отклоняет пробельный пароль, короткий пароль и пробельное `display_name`, при этом Unicode-пароль с двоеточием по-прежнему принимается | +| `POST /api/v1/users` при отказе PostgreSQL отвечал `500` | часть ошибок node-postgres приходит без `code`, поэтому фильтр не относил их к отказу зависимости (нашёл автоматический тест `make test-dependencies`) | фильтр распознаёт тексты «Connection terminated unexpectedly»/«timeout exceeded when trying to connect» и логирует неожиданные исключения серверно | +| `nest build` не копировал `.sql`-миграции в `dist/` | локальный запуск `node dist/database/migration.runner.js` упал бы: каталога миграций в `dist/` нет, работал только Docker за счёт отдельного `COPY` | в `nest-cli.json` добавлен `assets: database/migrations/*.sql → dist`, лишний `COPY` из `Dockerfile` убран; проверено `docker run --rm --entrypoint ls mtusi-messenger:lab2 dist/database/migrations` и повторным запуском runner (exit 0) | ## 14. Инвентарь артефактов -| Артефакт | Назначение | -| ---------------------------------------- | --------------------------------------------------------- | -| `evidence/track1-cache-consistency.md` | подробный отчёт по треку 1 с таблицами по повторностям | -| `evidence/track1-raw/naive.json` | сырой прогон naive (в Git не попадает) | -| `evidence/track1-raw/protected.json` | сырой прогон protected (в Git не попадает) | -| `evidence/track1-raw/redis-restart.json` | сырая проверка рестарта Redis (в Git не попадает) | -| `evidence/track1-explain.md` | запросы и `EXPLAIN (ANALYZE, BUFFERS)` | -| `bruno/README.md` | коллекция ручных запросов (Bruno) ко всем эндпоинтам | -| `REPORT.md` | основной отчёт: архитектура, решения, команды, результаты | +| Артефакт | Назначение | +| ----------------------------------------------------- | --------------------------------------------------------------------------- | +| `evidence/track1-cache-consistency.md` | подробный отчёт по треку 1 с таблицами по повторностям | +| `evidence/track1-raw/naive.json` | сырой прогон naive (в Git не попадает) | +| `evidence/track1-raw/protected.json` | сырой прогон protected (в Git не попадает) | +| `evidence/track1-raw/redis-restart.json` | сырая проверка рестарта Redis (в Git не попадает) | +| `evidence/track1-explain.md` | запросы и `EXPLAIN (ANALYZE, BUFFERS)` | +| `bruno/README.md` | коллекция ручных запросов (Bruno) ко всем эндпоинтам | +| `app/test/app.e2e-spec.ts` | black-box набор против запущенного API (реальные PG/Redis) | +| `app/test/dependency-failures.e2e-spec.ts` | автоматическая проверка отказов Redis/PostgreSQL (`make test-dependencies`) | +| `app/src/common/http/cursor.spec.ts` | unit-тесты разбора курсора (формат, календарь, scope) | +| `app/src/common/validation/code-point-length.ts` | декоратор проверки длины в Unicode code points | +| `app/src/common/validation/code-point-length.spec.ts` | unit-тесты границ декоратора по code points | +| `REPORT.md` | основной отчёт: архитектура, решения, команды, результаты | Хеши сырых артефактов перечислены в `evidence/track1-cache-consistency.md` §8.