forked from mtusi2026/mtusi2026lab2
fix: правки
This commit is contained in:
@@ -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/` не изменялись).
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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:<password>@<pg-host>:5432/messenger \
|
||||
REDIS_URL=redis://<redis-host>:6379 npx vitest run --config ./vitest.config.e2e.ts)
|
||||
|
||||
+29
-2
@@ -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-метки,
|
||||
|
||||
Generated
+11
@@ -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",
|
||||
|
||||
+3
-1
@@ -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",
|
||||
|
||||
@@ -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';
|
||||
|
||||
@@ -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<Page<Chat>> {
|
||||
const scope = `chats:${currentUser.id}`;
|
||||
const cursor = cursorValue
|
||||
? decodeCursor(cursorValue, scope)
|
||||
|
||||
@@ -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',
|
||||
})
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
export type ApiErrorBody = {
|
||||
error: {
|
||||
code: string;
|
||||
message: string;
|
||||
request_id: string;
|
||||
};
|
||||
};
|
||||
@@ -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<string, true> = {
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
);
|
||||
});
|
||||
});
|
||||
@@ -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)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
export type Page<T> = {
|
||||
items: T[];
|
||||
next_cursor: string | null;
|
||||
};
|
||||
@@ -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<boolean> {
|
||||
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);
|
||||
});
|
||||
});
|
||||
@@ -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,
|
||||
});
|
||||
};
|
||||
}
|
||||
+2
-4
@@ -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<unknown>;
|
||||
|
||||
@Injectable()
|
||||
export class MessagesCacheService {
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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 = {
|
||||
|
||||
@@ -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<Page<Message>> {
|
||||
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<Message>;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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<User> {
|
||||
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,
|
||||
});
|
||||
|
||||
+146
-48
@@ -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<typeof createClient>;
|
||||
|
||||
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<T> = { 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<T> = { body: T; response: Response };
|
||||
|
||||
@@ -102,8 +79,8 @@ async function register(
|
||||
return result.body;
|
||||
}
|
||||
|
||||
async function login(user: User, secret = password): Promise<Session> {
|
||||
const result = await http<Session>('/api/v1/auth/sessions', {
|
||||
async function login(user: User, secret = password): Promise<SessionResponse> {
|
||||
const result = await http<SessionResponse>('/api/v1/auth/sessions', {
|
||||
method: 'POST',
|
||||
headers: { authorization: basic(user.username, secret) },
|
||||
});
|
||||
@@ -119,7 +96,7 @@ async function actor(displayName?: string): Promise<Actor> {
|
||||
}
|
||||
|
||||
function expectError(
|
||||
result: HttpResult<ApiError>,
|
||||
result: HttpResult<ApiErrorBody>,
|
||||
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<ApiError>('/api/v1/users/me');
|
||||
const denied = await http<ApiErrorBody>('/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<ApiErrorBody>(
|
||||
'/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<ApiErrorBody>(
|
||||
'/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<ApiErrorBody>(
|
||||
'/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<User>(
|
||||
'/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<SessionResponse>('/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<ApiErrorBody>(
|
||||
'/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<Chat>(
|
||||
'/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<ApiErrorBody>(
|
||||
`/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<Message>(
|
||||
`/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<ApiErrorBody>(
|
||||
'/api/v1/users',
|
||||
json({ username, ...body }),
|
||||
);
|
||||
expectError(result, 400, 'invalid_request');
|
||||
}
|
||||
const accepted = await http<User>(
|
||||
'/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<ApiError>('/api/v1/auth/sessions', {
|
||||
const result = await http<ApiErrorBody>('/api/v1/auth/sessions', {
|
||||
method: 'POST',
|
||||
headers: { authorization },
|
||||
});
|
||||
@@ -205,7 +289,7 @@ describe('HTTP integration contract', () => {
|
||||
basicChallenge,
|
||||
);
|
||||
}
|
||||
const bodyResult = await http<ApiError>('/api/v1/auth/sessions', {
|
||||
const bodyResult = await http<ApiErrorBody>('/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<ApiError>('/api/v1/users/me', {
|
||||
const spoof = await http<ApiErrorBody>('/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<ApiError>('/api/v1/users/me', {
|
||||
const basicBusiness = await http<ApiErrorBody>('/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<ApiError>('/api/v1/users/me', {
|
||||
const replay = await http<ApiErrorBody>('/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<ApiError>(
|
||||
const unknown = await http<ApiErrorBody>(
|
||||
'/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<ApiError>(`/api/v1/chats?limit=100`, {
|
||||
const leaked = await http<ApiErrorBody>(`/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<ApiError>(
|
||||
const duplicate = await http<ApiErrorBody>(
|
||||
'/api/v1/chats',
|
||||
json(
|
||||
{
|
||||
@@ -310,7 +394,7 @@ describe('HTTP integration contract', () => {
|
||||
),
|
||||
);
|
||||
expect(created.response.status).toBe(201);
|
||||
const hidden = await http<ApiError>(
|
||||
const hidden = await http<ApiErrorBody>(
|
||||
`/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<ApiError>(
|
||||
const blank = await http<ApiErrorBody>(
|
||||
`/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<ApiError>(
|
||||
const spoof = await http<ApiErrorBody>(
|
||||
`/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<ApiError>(
|
||||
const invalidLimit = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?limit=101`,
|
||||
{ headers: bearer(alice.token) },
|
||||
);
|
||||
expectError(invalidLimit, 400, 'invalid_request');
|
||||
const invalidCursor = await http<ApiError>(
|
||||
const invalidCursor = await http<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.body.id}/messages?cursor=not-a-cursor`,
|
||||
{ headers: bearer(alice.token) },
|
||||
);
|
||||
expectError(invalidCursor, 400, 'invalid_request');
|
||||
const malformed = await http<ApiError>('/api/v1/users', {
|
||||
const rolledOver = http<ApiErrorBody>(
|
||||
`/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<ApiErrorBody>('/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<ApiError>('/api/v1/users/me', {
|
||||
const expired = await http<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: bearer(session.token),
|
||||
});
|
||||
expectError(expired, 401, 'unauthorized');
|
||||
|
||||
@@ -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<T> = { body: T; text: string; response: Response };
|
||||
|
||||
async function compose(...args: string[]): Promise<void> {
|
||||
await execFileAsync(
|
||||
'docker',
|
||||
['compose', '--env-file', composeEnvFile, ...args],
|
||||
{ cwd: composeDir, timeout: 120_000 },
|
||||
);
|
||||
}
|
||||
|
||||
async function request<T = unknown>(
|
||||
path: string,
|
||||
init: RequestInit = {},
|
||||
): Promise<Result<T>> {
|
||||
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<string, string> = {},
|
||||
): RequestInit {
|
||||
return {
|
||||
method: 'POST',
|
||||
headers: { 'content-type': 'application/json', ...headers },
|
||||
body: JSON.stringify(body),
|
||||
};
|
||||
}
|
||||
|
||||
function bearer(token: string): Record<string, string> {
|
||||
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<void> {
|
||||
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<ApiErrorBody>): 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<Result<Page<Message>>> {
|
||||
return request<Page<Message>>(`/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<User>(
|
||||
'/api/v1/users',
|
||||
json({ username, display_name: 'Отказ зависимости', password }),
|
||||
);
|
||||
expect(registered.response.status).toBe(201);
|
||||
user = registered.body;
|
||||
const session = await request<SessionResponse>(
|
||||
'/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<Chat>(
|
||||
'/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<Message>(
|
||||
`/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<ApiErrorBody>('/health/ready'));
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: bearer(token),
|
||||
}),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/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<ApiErrorBody>('/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<User>('/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<ApiErrorBody>('/health/ready'));
|
||||
|
||||
// Redis still answers, so these requests reach the database layer.
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/api/v1/users/me', {
|
||||
headers: bearer(token),
|
||||
}),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>('/api/v1/chats', {
|
||||
headers: bearer(token),
|
||||
}),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>(
|
||||
`/api/v1/chats/${chat.id}/messages?limit=100`,
|
||||
{ headers: bearer(token) },
|
||||
),
|
||||
);
|
||||
|
||||
expectBoundedOutage(
|
||||
await request<ApiErrorBody>(
|
||||
'/api/v1/users',
|
||||
json({
|
||||
username: `outage_${runId}_late`,
|
||||
display_name: 'Отказ зависимости',
|
||||
password,
|
||||
}),
|
||||
),
|
||||
);
|
||||
|
||||
await compose('start', postgresService);
|
||||
await waitForReadiness(200);
|
||||
|
||||
const recovered = await request<User>('/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<Message>(
|
||||
`/api/v1/chats/${chat.id}/messages`,
|
||||
json({ text: 'Сообщение после отказа' }, bearer(token)),
|
||||
);
|
||||
expect(sent.response.status).toBe(201);
|
||||
},
|
||||
outagedRequestBudgetMs,
|
||||
);
|
||||
});
|
||||
@@ -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 },
|
||||
|
||||
+4
-3
@@ -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) и пробельный текст.
|
||||
|
||||
## Проверка истечения сессии
|
||||
|
||||
|
||||
+10
-10
@@ -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.
|
||||
}
|
||||
|
||||
@@ -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.
|
||||
}
|
||||
+1
-1
@@ -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. |
|
||||
|
||||
@@ -82,10 +82,12 @@ $ (cd app && API_BASE_URL=http://localhost:8080 \
|
||||
REDIS_URL=redis://<redis-container>: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=<METRICS_TOKEN>` дал 28 запросов и
|
||||
56 проверок без падений (регистрация трёх пользователей, три Basic-сессии, чат,
|
||||
`bru run -r --env-var metricsToken=<METRICS_TOKEN>` дал 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.
|
||||
|
||||
Reference in New Issue
Block a user