test(api): cover persistence, cache consistency and dependency failures

This commit is contained in:
2026-10-14 06:29:28 +03:00
parent 1dc5f08813
commit 6cccda14d2
11 changed files with 1764 additions and 0 deletions
+74
View File
@@ -0,0 +1,74 @@
# Проверки приложения
Текущий вариант использует 16 счётчиков эпохи истории, единый SQL проверки сессии и членства и профиль из JOIN. Сравнение трёх оптимизаций: [результаты](../evidence/epoch-variants-summary.md). Итоговый контроль против того же кода без кэша и обслуживания эпох: [методика и результаты](../evidence/cache-strategy-buckets-summary.md), включая точные команды повторения длинной нагрузки. Для актуальной схемы примените миграции и используйте проверки ниже. `epoch-variants-experiment.cjs` предназначен для исторической матрицы до миграции счётчиков; точные исходники вариантов сохранены в `evidence/epoch-variants-sources.json`.
Нужны Node.js 24.20.0 (как в Dockerfile), установленные зависимости и PostgreSQL с применёнными миграциями. Переменные читаются из локального `.env`; Redis нужен проверкам кэша и отказов.
```powershell
pnpm.cmd build
node --test test/passwords.mjs test/persistence.mjs test/resilience.mjs
node --test test/cache.mjs test/cache-epochs.mjs test/message-pagination.mjs
pnpm.cmd lint
```
`passwords.mjs` проверяет Argon2id в PHC-формате, независимое вычисление ключа, случайные соли, Unicode/NUL, неверные и повреждённые хеши. Поддерживается только Argon2id; прежние scrypt-хеши не принимаются. Пароли, хеши и токены не печатаются.
Публичные проверки работают по HTTP с уже запущенным Compose:
```powershell
python -X utf8 tests/smoke.py --base-url http://127.0.0.1:8080
python -X utf8 scripts/test-persistence.py --scenario public --base-url http://127.0.0.1:8080 --output evidence/persistence-public.json
```
Последняя команда использует неизменённую публичную проверку с HTTP-дедлайном 2 секунды. Она создаёт синтетические данные, перезапускает API/PostgreSQL/Redis через `scripts/restart.cmd` (Windows) или `scripts/restart.sh` (Linux), сохраняет volumes и проверяет данные прежним токеном. Windows требует Git Bash. Для Linux сохраните executable bit скрипта (`chmod +x scripts/restart.sh`).
На Windows можно запустить этот же нормативный сценарий через make:
```powershell
make test-persistence ACTION_SCRIPT=scripts/restart.cmd PYTHON="python -X utf8"
```
Собственный сценарий с HTTP-дедлайном 30 секунд:
```powershell
python -X utf8 scripts/test-persistence.py --scenario full-restart --base-url http://127.0.0.1:8080 --output evidence/argon2-full-restart.json
```
Измерения кэша описаны в `evidence/cache-epochs-summary.md`. Их основное сравнение выполнено до замены KDF, на синтетических сессиях без измерения регистрации/входа. Хеширование паролей не входит в эти RPS.
Результаты оптимизации записи эпохи одним CTE: [сводка](../evidence/cache-epochs-optimization-summary.md). Повторение замера после сборки и запуска backend:
```powershell
docker compose -f compose.yaml -f test/compose.benchmark.yaml run --rm --no-deps --pull never benchmark node test/cache-benchmark.mjs after /results/cache-epochs-optimized.json
node test/cache-epochs-optimization-summary.mjs
```
Один сравнительный прогон с Redis и со всеми кэшами приложения, отключёнными через отсутствие CACHE_URL. Эпохи в PostgreSQL остаются включены в обоих режимах:
```powershell
docker compose -f compose.yaml -f test/compose.benchmark.yaml run --rm --no-deps --pull never benchmark node test/cache-benchmark.mjs after /results/redis-comparison.json --compare-redis
node test/redis-comparison-summary.mjs
```
[Средние результаты и ограничения](../evidence/redis-comparison-summary.md). Сборка не нужна, если текущий образ уже содержит проверяемую реализацию приложения.
Сравнение полной стратегии с вариантом без Redis и поддержания эпох:
```powershell
docker compose -f compose.yaml -f test/compose.benchmark.yaml run --rm --no-deps --pull never benchmark node test/cache-benchmark.mjs after /results/cache-strategy-full.json
node test/no-epochs-experiment.cjs
node test/cache-strategy-summary.mjs
```
Второй шаг создаёт временные копии шести модулей, убирает обслуживание эпох, компилирует их TypeScript и подключает в отдельный benchmark-контейнер. Рабочие исходники и backend не меняются; служебные колонки БД сохраняются. По завершении временные файлы удаляются. [Результаты](../evidence/cache-strategy-summary.md).
Увеличенная нагрузка: 100 000 сообщений, конкурентность 32, чтение по 60 секунд, прогрев 10 секунд, по 4096 записей, три повтора. Дополнительный контроль с частично отключённым кэшем пропущен:
```powershell
docker compose -f compose.yaml -f test/compose.benchmark.yaml run --rm --no-deps --pull never benchmark node test/cache-benchmark.mjs after /results/cache-strategy-long-full.json --concurrency 32 --duration-seconds 60 --warmup-seconds 10 --repetitions 3 --seed-messages 100000 --cold-burst 64 --writes-per-repeat 4096 --skip-history-control
$env:EXPERIMENT_PREFIX='cache-strategy-long'
node test/no-epochs-experiment.cjs --concurrency 32 --duration-seconds 60 --warmup-seconds 10 --repetitions 3 --seed-messages 100000 --cold-burst 64 --writes-per-repeat 4096 --skip-history-control
node test/cache-strategy-summary.mjs cache-strategy-long
```
[Результаты увеличенного прогона](../evidence/cache-strategy-long-summary.md). Старые короткие замеры сохраняются отдельно.
+195
View File
@@ -0,0 +1,195 @@
import 'dotenv/config';
import assert from 'node:assert/strict';
import { createHash, randomBytes, randomUUID } from 'node:crypto';
import { createRequire } from 'node:module';
import test from 'node:test';
import { faultProxy } from './helpers/fault-proxy.mjs';
import { messageEpoch } from './helpers/message-epoch.mjs';
const require = createRequire(import.meta.url);
const Redis = require('ioredis').default;
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require('../dist/app.module');
const { PrismaService } = require('../dist/prisma/prisma.service');
const { CacheService } = require('../dist/cache/cache.service');
const { ChatService } = require('../dist/Chat/chat.service');
const {
createFastifyAdapter,
exposeRequestIdHeader,
} = require('../dist/common/http/fastify-adapter');
const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
test(
'DB cache epochs: two replicas, retained Redis keys, concurrent writes and atomic rollback',
{ timeout: 90000 },
async (t) => {
assert.ok(process.env.CACHE_URL && process.env.DATABASE_URL);
const oldUrl = process.env.CACHE_URL;
const oldPrefix = process.env.CACHE_PREFIX;
const prefix = `test:epochs:${randomUUID()}`;
const proxy = await faultProxy(oldUrl, 6379);
const observer = new Redis(oldUrl);
process.env.CACHE_URL = proxy.url;
process.env.CACHE_PREFIX = prefix;
const apps = [];
let prisma, userId;
const chatIds = [];
t.after(async () => {
proxy.setMode('online');
try {
if (prisma) {
await prisma.chat.deleteMany({ where: { id: { in: chatIds } } });
if (userId) await prisma.user.delete({ where: { id: userId } });
}
let cursor = '0';
do {
const [next, keys] = await observer.scan(
cursor,
'MATCH',
`${prefix}:*`,
'COUNT',
100,
);
cursor = next;
if (keys.length) await observer.del(...keys);
} while (cursor !== '0');
} finally {
for (const app of apps) await app.close();
observer.disconnect();
await proxy.close();
process.env.CACHE_URL = oldUrl;
if (oldPrefix === undefined) delete process.env.CACHE_PREFIX;
else process.env.CACHE_PREFIX = oldPrefix;
}
});
for (let i = 0; i < 2; i++) {
const app = await NestFactory.create(AppModule, createFastifyAdapter(), {
logger: false,
abortOnError: false,
});
apps.push(app);
exposeRequestIdHeader(app);
await app.init();
await app.getHttpAdapter().getInstance().ready();
require('nestjs-pino').PinoLogger.root.level = 'silent';
}
prisma = apps[0].get(PrismaService);
const user = await prisma.user.create({
data: {
username: `epoch_${randomUUID().replaceAll('-', '').slice(0, 20)}`,
displayName: 'Synthetic epochs',
},
});
userId = user.id;
const token = randomBytes(32).toString('base64url');
await prisma.session.create({
data: {
userId,
tokenHash: createHash('sha256').update(token).digest('hex'),
expiresAt: new Date(Date.now() + 600000),
},
});
const call = async (replica, method, url, payload) => {
const response = await apps[replica]
.getHttpAdapter()
.getInstance()
.inject({
method,
url,
headers: { authorization: `Bearer ${token}` },
...(payload ? { payload } : {}),
});
return { status: response.statusCode, body: response.json() };
};
const createChat = async () => {
const response = await call(0, 'POST', '/api/v1/chats', {
title: 'Epoch test',
member_ids: [userId],
});
assert.equal(response.status, 201);
chatIds.push(response.body.id);
return response.body.id;
};
assert.equal((await call(1, 'GET', '/api/v1/chats')).body.items.length, 0);
proxy.setMode('cut');
await pause(100);
const chatId = await createChat();
proxy.setMode('online');
const reconnect = async () => {
for (let i = 0; i < 60; i++) {
if (apps.every((app) => app.get(CacheService).redis.status === 'ready'))
return;
await pause(100);
}
assert.fail('Redis did not reconnect');
};
await reconnect();
assert.deepEqual(
(await call(1, 'GET', '/api/v1/chats')).body.items.map((x) => x.id),
[chatId],
);
assert.equal(
(await prisma.user.findUniqueOrThrow({ where: { id: userId } }))
.chatsEpoch,
1n,
);
const path = `/api/v1/chats/${chatId}/messages`;
assert.equal((await call(1, 'GET', path)).body.items.length, 0);
const oldKeys = await observer.keys(`${prefix}:messages:${chatId}:*`);
assert.ok(oldKeys.length);
proxy.setMode('cut');
await pause(100);
const posted = await call(0, 'POST', path, {
text: 'Write during Redis outage',
});
assert.equal(posted.status, 201);
proxy.setMode('online');
await reconnect();
assert.equal(
await observer.exists(...oldKeys),
oldKeys.length,
'old cache keys must still exist',
);
assert.deepEqual(
(await call(1, 'GET', path)).body.items.map((x) => x.id),
[posted.body.id],
);
const service = apps[0].get(ChatService);
const original = service.prisma;
service.prisma = original.$extends({
query: {
$queryRaw({ args, query }) {
const index = args.values.indexOf('Must roll back');
if (index !== -1) args.values[index] = 'x'.repeat(4001);
return query(args);
},
},
});
try {
assert.equal(
(await call(0, 'POST', path, { text: 'Must roll back' })).status,
500,
);
} finally {
service.prisma = original;
}
assert.equal(await prisma.message.count({ where: { chatId } }), 1);
assert.equal(await messageEpoch(prisma, chatId), 1n);
const writes = await Promise.all(
Array.from({ length: 20 }, (_, i) =>
call(i % 2, 'POST', path, { text: `Concurrent ${i}` }),
),
);
assert.ok(writes.every((x) => x.status === 201));
assert.equal(await prisma.message.count({ where: { chatId } }), 21);
assert.equal(await messageEpoch(prisma, chatId), 21n);
const history = (await call(1, 'GET', path)).body.items;
assert.equal(new Set(history.map((x) => x.id)).size, 21);
assert.ok(
writes.every((x) => history.some((message) => message.id === x.body.id)),
);
},
);
+287
View File
@@ -0,0 +1,287 @@
import 'dotenv/config';
import assert from 'node:assert/strict';
import { createHash, randomBytes, randomUUID } from 'node:crypto';
import { createRequire } from 'node:module';
import test from 'node:test';
const require = createRequire(import.meta.url);
const Redis = require('ioredis').default;
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require('../dist/app.module');
const { PrismaService } = require('../dist/prisma/prisma.service');
const { CacheService } = require('../dist/cache/cache.service');
const {
createFastifyAdapter,
exposeRequestIdHeader,
} = require('../dist/common/http/fastify-adapter');
async function isolatedCache(t) {
assert.ok(process.env.CACHE_URL, 'Set CACHE_URL to a running Redis instance');
const previous = process.env.CACHE_PREFIX;
const prefix = `test:cache:${randomUUID()}`;
process.env.CACHE_PREFIX = prefix;
const observer = new Redis(process.env.CACHE_URL, {
maxRetriesPerRequest: 0,
connectTimeout: 1000,
commandTimeout: 1000,
});
observer.on('error', () => {});
await observer.ping();
t.after(async () => {
try {
let cursor = '0';
do {
const [next, keys] = await observer.scan(
cursor,
'MATCH',
`${prefix}:*`,
'COUNT',
100,
);
cursor = next;
if (keys.length) await observer.del(...keys);
} while (cursor !== '0');
} finally {
observer.disconnect();
if (previous === undefined) delete process.env.CACHE_PREFIX;
else process.env.CACHE_PREFIX = previous;
}
});
return { prefix, observer };
}
test('Redis cache: hits, expiry, invalidation race and unavailable-server fallback', async (t) => {
await isolatedCache(t);
const cache = new CacheService();
t.after(() => cache.onModuleDestroy());
await cache.onModuleInit();
let reads = 0;
const load = async () => ({ value: ++reads });
assert.deepEqual(await cache.remember('hits', 'page', 30, load), {
value: 1,
});
assert.deepEqual(await cache.remember('hits', 'page', 30, load), {
value: 1,
});
assert.equal(reads, 1);
assert.deepEqual(await cache.remember('expiry', 'page', 1, load), {
value: 2,
});
await new Promise((resolve) => setTimeout(resolve, 1100));
assert.deepEqual(await cache.remember('expiry', 'page', 1, load), {
value: 3,
});
await cache.invalidate('expiry');
assert.deepEqual(await cache.remember('expiry', 'page', 1, load), {
value: 4,
});
let resolveOld;
let began;
const started = new Promise((resolve) => {
began = resolve;
});
const pending = cache.remember('race', 'page', 30, () => {
began();
return new Promise((resolve) => {
resolveOld = resolve;
});
});
await started;
await cache.invalidate('race');
resolveOld({ value: 'old' });
await pending;
assert.deepEqual(
await cache.remember('race', 'page', 30, async () => ({ value: 'new' })),
{ value: 'new' },
);
assert.deepEqual(
await cache.remember('race', 'page', 30, async () => {
throw new Error('cache miss');
}),
{ value: 'new' },
);
await assert.rejects(
cache.remember('db-error', 'page', 30, async () => {
throw new Error('database failure');
}),
/database failure/,
);
const previous = process.env.CACHE_URL;
process.env.CACHE_URL = 'redis://127.0.0.1:1/0';
const offline = new CacheService();
process.env.CACHE_URL = previous;
t.after(() => offline.onModuleDestroy());
await offline.onModuleInit();
assert.deepEqual(
await offline.remember('offline', 'page', 30, async () => ({
value: 'database',
})),
{ value: 'database' },
);
await offline.invalidate('offline');
});
test('API cache: fewer SQL reads, write invalidation, permissions, logout and Redis fallback', async (t) => {
assert.ok(process.env.DATABASE_URL);
const { prefix, observer } = await isolatedCache(t);
const app = await NestFactory.create(AppModule, createFastifyAdapter(), {
logger: false,
abortOnError: false,
});
exposeRequestIdHeader(app);
await app.init();
const server = app.getHttpAdapter().getInstance();
await server.ready();
const prisma = app.get(PrismaService);
const userIds = [];
const chatIds = [];
t.after(async () => {
try {
await prisma.chat.deleteMany({ where: { id: { in: chatIds } } });
await prisma.user.deleteMany({ where: { id: { in: userIds } } });
} finally {
await app.close();
}
});
const actors = [];
for (let i = 0; i < 2; i++) {
const user = await prisma.user.create({
data: {
username: `cache_${randomUUID().replaceAll('-', '').slice(0, 20)}`,
displayName: 'Cache test',
},
});
userIds.push(user.id);
const token = randomBytes(32).toString('base64url');
const session = await prisma.session.create({
data: {
userId: user.id,
tokenHash: createHash('sha256').update(token).digest('hex'),
expiresAt: new Date(Date.now() + 600000),
},
});
actors.push({ id: user.id, token, sessionId: session.id });
}
const [alice, outsider] = actors;
const request = (method, url, payload, actor = alice) =>
server.inject({
method,
url,
headers: { authorization: `Bearer ${actor.token}` },
...(payload === undefined ? {} : { payload }),
});
const counts = new Map();
const tracked = prisma.$extends({
query: {
$allModels: {
$allOperations({ model, operation, args, query }) {
const key = `${model}:${operation}`;
counts.set(key, (counts.get(key) ?? 0) + 1);
return query(args);
},
},
},
});
for (const name of [
'User/user.service',
'Chat/chat.service',
'Auth/auth.service',
]) {
const exported = require(`../dist/${name}`);
const Service = Object.values(exported)[0];
app.get(Service).prisma = tracked;
}
const spy = (model, operation) => ({
mock: { callCount: () => counts.get(`${model}:${operation}`) ?? 0 },
});
const profileReads = spy('User', 'findUnique');
assert.equal((await request('GET', '/api/v1/users/me')).statusCode, 200);
assert.equal((await request('GET', '/api/v1/users/me')).statusCode, 200);
assert.equal(profileReads.mock.callCount(), 0);
const chatListReads = spy('Chat', 'findMany');
assert.equal((await request('GET', '/api/v1/chats')).json().items.length, 0);
assert.equal((await request('GET', '/api/v1/chats')).json().items.length, 0);
assert.equal(chatListReads.mock.callCount(), 1);
const created = await request('POST', '/api/v1/chats', {
title: 'Cached chat',
member_ids: [alice.id],
});
assert.equal(created.statusCode, 201);
const chatId = created.json().id;
chatIds.push(chatId);
assert.deepEqual(
(await request('GET', '/api/v1/chats')).json().items.map((x) => x.id),
[chatId],
);
assert.equal(chatListReads.mock.callCount(), 2);
const metadataReads = spy('Chat', 'findUnique');
const messageReads = spy('Message', 'findMany');
const path = `/api/v1/chats/${chatId}/messages`;
assert.equal((await request('GET', path)).json().items.length, 0);
assert.equal((await request('GET', path)).json().items.length, 0);
assert.equal(metadataReads.mock.callCount(), 0);
assert.equal(messageReads.mock.callCount(), 1);
const message = await request('POST', path, {
text: 'Invalidate cached empty history',
});
assert.equal(message.statusCode, 201);
assert.deepEqual(
(await request('GET', path)).json().items.map((x) => x.id),
[message.json().id],
);
assert.equal(messageReads.mock.callCount(), 2);
assert.equal(
(await request('GET', path, undefined, outsider)).statusCode,
404,
);
await prisma.chatMember.delete({
where: { chatId_userId: { chatId, userId: alice.id } },
});
assert.equal((await request('GET', path)).statusCode, 404);
await prisma.chatMember.create({
data: { chatId, userId: alice.id, position: 0 },
});
await prisma.session.update({
where: { id: outsider.sessionId },
data: { revokedAt: new Date() },
});
assert.equal(
(await request('GET', '/api/v1/users/me', undefined, outsider)).statusCode,
401,
);
const keys = [];
let cursor = '0';
do {
const [next, batch] = await observer.scan(
cursor,
'MATCH',
`${prefix}:*`,
'COUNT',
100,
);
cursor = next;
keys.push(...batch);
} while (cursor !== '0');
assert.ok(keys.length >= 4, 'Redis must contain the cached responses');
for (const key of keys) {
const value = await observer.get(key);
assert.ok(
!value.includes('password_hash') && !value.includes('passwordHash'),
);
for (const actor of actors) assert.ok(!value.includes(actor.token));
}
app.get(CacheService).onModuleDestroy();
assert.equal((await request('GET', path)).statusCode, 200);
assert.equal(messageReads.mock.callCount(), 3);
assert.equal(
(await request('POST', path, { text: 'Write while Redis is unavailable' }))
.statusCode,
201,
);
assert.equal((await request('GET', path)).json().items.length, 2);
});
+57
View File
@@ -0,0 +1,57 @@
#!/usr/bin/env python3
import argparse
from pathlib import Path
import subprocess
import sys
import time
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, check, run
from resilience import history
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--base-url', default='http://127.0.0.1:8080')
parser.add_argument('--ca-file')
parser.add_argument('--action-script', required=True)
args = parser.parse_args()
client = Client(args.base_url, args.ca_file, timeout=30)
alice, bob, eve, chat = client.bootstrap()
original = client.message(alice, chat, 'Сохранность после полного перезапуска')['json']
check(history(client, bob, chat) == [original], 'pre-restart history mismatch')
hook = Path(args.action_script).resolve()
check(hook.is_file(), 'restart hook not found')
print('Restarting backend, PostgreSQL and Redis; hook output suppressed.', flush=True)
try:
proc = subprocess.run([str(hook)], cwd=ROOT, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL, timeout=90)
except subprocess.TimeoutExpired:
raise Failure('restart hook exceeded 90 seconds') from None
check(proc.returncode == 0, 'restart hook failed')
deadline = time.monotonic() + 90
while True:
try:
client.call('GET', '/health/ready', schema='Health')
break
except Failure:
check(time.monotonic() < deadline, 'API did not recover within 90 seconds')
time.sleep(0.5)
for actor in (alice, bob, eve):
check(client.call('GET', '/api/v1/users/me', actor=actor, schema='User')['json']
== actor['user'], 'user or existing session changed after restart')
check(client.call('GET', '/api/v1/chats/' + chat['id'], actor=bob, schema='Chat')['json']
== chat, 'chat or membership changed after restart')
check(history(client, bob, chat) == [original], 'confirmed message lost, changed or duplicated')
client.call('GET', '/api/v1/chats/' + chat['id'], 404, actor=eve, schema='Error')
followup = client.message(bob, chat, 'Запись после восстановления')['json']
check(history(client, alice, chat) == [original, followup], 'post-restart write/read mismatch')
client.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice)
client.call('GET', '/api/v1/users/me', 401, actor=alice, schema='Error')
print('PASS: users, chat, membership, confirmed message and all existing sessions survived; '
'access control, new writes and logout work after restart.')
if __name__ == '__main__':
run(main)
+56
View File
@@ -0,0 +1,56 @@
import assert from 'node:assert/strict';
import net from 'node:net';
export async function faultProxy(connectionUrl, defaultPort) {
const upstreamUrl = new URL(connectionUrl);
const host = upstreamUrl.hostname.replace(/^\[|\]$/g, '');
const port = Number(upstreamUrl.port || defaultPort);
let mode = 'online';
const sockets = new Set();
const track = (socket) => {
sockets.add(socket);
socket.on('error', () => {});
socket.on('close', () => sockets.delete(socket));
return socket;
};
const server = net.createServer((client) => {
track(client);
if (mode === 'cut') {
client.destroy();
return;
}
const upstream = track(net.connect({ host, port }));
client.on('data', (chunk) => {
if (mode === 'online' && !upstream.destroyed) upstream.write(chunk);
});
upstream.on('data', (chunk) => {
if (mode === 'online' && !client.destroyed) client.write(chunk);
});
client.on('close', () => upstream.destroy());
upstream.on('close', () => client.destroy());
});
await new Promise((resolve, reject) => {
server.once('error', reject);
server.listen(0, '127.0.0.1', () => {
server.off('error', reject);
resolve();
});
});
const relayUrl = new URL(connectionUrl);
relayUrl.hostname = '127.0.0.1';
relayUrl.port = String(server.address().port);
return {
url: relayUrl.toString(),
setMode(nextMode) {
assert.ok(['online', 'cut', 'hang'].includes(nextMode));
mode = nextMode;
if (mode === 'cut') {
for (const socket of sockets) socket.destroy();
}
},
async close() {
for (const socket of sockets) socket.destroy();
await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
},
};
}
+7
View File
@@ -0,0 +1,7 @@
export async function messageEpoch(prisma, chatId) {
const [row] = await prisma.$queryRawUnsafe(
'SELECT COALESCE(SUM(epoch), 0)::bigint AS epoch FROM public.chat_message_epochs WHERE chat_id = $1::uuid',
chatId,
);
return row.epoch;
}
+137
View File
@@ -0,0 +1,137 @@
import 'dotenv/config';
import assert from 'node:assert/strict';
import { createHash, randomBytes, randomUUID } from 'node:crypto';
import { createRequire } from 'node:module';
import test from 'node:test';
const require = createRequire(import.meta.url);
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require('../dist/app.module');
const { PrismaService } = require('../dist/prisma/prisma.service');
const {
createFastifyAdapter,
exposeRequestIdHeader,
} = require('../dist/common/http/fastify-adapter');
test('message keyset pagination: timestamp ties, chat isolation and deleted cursor row', async (t) => {
assert.ok(process.env.DATABASE_URL);
const previousCacheUrl = process.env.CACHE_URL;
process.env.CACHE_URL = '';
const app = await NestFactory.create(AppModule, createFastifyAdapter(), {
logger: false,
abortOnError: false,
});
const prisma = app.get(PrismaService);
let userId;
const chatIds = [];
t.after(async () => {
try {
await prisma.chat.deleteMany({ where: { id: { in: chatIds } } });
if (userId) await prisma.user.delete({ where: { id: userId } });
} finally {
await app.close();
if (previousCacheUrl === undefined) delete process.env.CACHE_URL;
else process.env.CACHE_URL = previousCacheUrl;
}
});
exposeRequestIdHeader(app);
await app.init();
const server = app.getHttpAdapter().getInstance();
await server.ready();
const user = await prisma.user.create({
data: {
username: `page_${randomUUID().replaceAll('-', '').slice(0, 20)}`,
displayName: 'Synthetic pagination test',
},
});
userId = user.id;
const token = randomBytes(32).toString('base64url');
await prisma.session.create({
data: {
userId,
tokenHash: createHash('sha256').update(token).digest('hex'),
expiresAt: new Date(Date.now() + 600000),
},
});
for (let i = 0; i < 2; i++) {
const chat = await prisma.chat.create({
data: {
title: `Pagination ${i}`,
members: { create: { userId, position: 0 } },
},
});
chatIds.push(chat.id);
}
const [chatId, otherChatId] = chatIds;
const rows = Array.from({ length: 140 }, (_, i) => ({
id: randomUUID(),
chatId,
senderId: userId,
text: `Message ${i}`,
createdAt: new Date(Date.UTC(2026, 0, 1) + Math.floor(i / 10) * 1000),
}));
await prisma.message.createMany({
data: [
...rows,
...rows.map((row) => ({
...row,
id: randomUUID(),
chatId: otherChatId,
text: 'Other chat',
})),
],
});
const expected = [...rows]
.sort(
(a, b) =>
a.createdAt - b.createdAt || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
)
.map((row) => ({
id: row.id,
chat_id: chatId,
sender_id: userId,
text: row.text,
created_at: row.createdAt.toISOString(),
}));
const request = (cursor, selectedChat = chatId) =>
server.inject({
method: 'GET',
url: `/api/v1/chats/${selectedChat}/messages?limit=7${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ''}`,
headers: { authorization: `Bearer ${token}` },
});
const seen = [];
let cursor;
let firstCursor;
do {
const response = await request(cursor);
assert.equal(response.statusCode, 200);
const page = response.json();
assert.ok(page.items.length <= 7);
seen.push(...page.items);
if (!firstCursor) firstCursor = page.next_cursor;
cursor = page.next_cursor;
assert.ok(
seen.length <= rows.length,
'pagination must terminate without duplicates',
);
} while (cursor);
assert.deepEqual(seen, expected);
const anchor = JSON.parse(
Buffer.from(firstCursor, 'base64url').toString('utf8'),
);
await prisma.message.delete({ where: { id: anchor.id } });
const afterDeletion = await request(firstCursor);
assert.equal(afterDeletion.statusCode, 200);
assert.deepEqual(afterDeletion.json().items, expected.slice(7, 14));
assert.equal((await request(firstCursor, otherChatId)).statusCode, 400);
const pastEnd = Buffer.from(
JSON.stringify({
scope: `messages:${chatId}`,
id: randomUUID(),
created_at: '2027-01-01T00:00:00.000Z',
}),
).toString('base64url');
const empty = await request(pastEnd);
assert.equal(empty.statusCode, 200);
assert.deepEqual(empty.json(), { items: [], next_cursor: null });
});
+63
View File
@@ -0,0 +1,63 @@
import assert from 'node:assert/strict';
import { argon2 } from 'node:crypto';
import { createRequire } from 'node:module';
import test from 'node:test';
const require = createRequire(import.meta.url);
const { PasswordService } = require('../dist/Auth/password.service');
const password = '🔐'.repeat(40) + ':Синтетический пароль\0';
test('Argon2id only: PHC format, independent derivation, unique salts, Unicode and invalid hashes', async () => {
const service = new PasswordService();
const first = await service.hash(password);
const second = await service.hash(password);
assert.notEqual(
first,
second,
'same password must have independently salted hashes',
);
assert.match(
first,
/^\$argon2id\$v=19\$m=19456,t=2,p=1\$[A-Za-z0-9+/]{22}\$[A-Za-z0-9+/]{43}$/,
);
assert.ok(!first.includes(password));
const parts = first.split('$');
const independent = await new Promise((resolve, reject) =>
argon2(
'argon2id',
{
message: password,
nonce: Buffer.from(parts[4], 'base64'),
memory: 19456,
passes: 2,
parallelism: 1,
tagLength: 32,
},
(error, key) => (error ? reject(error) : resolve(key)),
),
);
assert.deepEqual(Buffer.from(parts[5], 'base64'), independent);
assert.equal(await service.verify(password, first), true);
assert.equal(
await service.verify(password.replace('🔐', '🔑'), first),
false,
);
assert.equal(
await service.verify(password.slice(0, -1), first),
false,
'NUL must not be silently truncated',
);
for (const invalid of [
null,
'',
'scrypt$131072$8$1$unsupported$unsupported',
'$argon2id$v=19$m=999999999,t=999999999,p=1$x$x',
first.replace('v=19', 'v=16'),
first.replace('argon2id', 'argon2i'),
first + '$extra',
first.replace(parts[5], 'a'),
first.replace(parts[4], parts[4] + '='),
]) {
assert.equal(await service.verify(password, invalid), false);
}
});
+346
View File
@@ -0,0 +1,346 @@
import 'dotenv/config';
import assert from 'node:assert/strict';
import { randomUUID } from 'node:crypto';
import { createRequire } from 'node:module';
import test from 'node:test';
const require = createRequire(import.meta.url);
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require('../dist/app.module');
const { PrismaService } = require('../dist/prisma/prisma.service');
const {
createFastifyAdapter,
exposeRequestIdHeader,
} = require('../dist/common/http/fastify-adapter');
async function start() {
const app = await NestFactory.create(AppModule, createFastifyAdapter(), {
logger: false,
abortOnError: false,
});
try {
exposeRequestIdHeader(app);
await app.init();
const server = app.getHttpAdapter().getInstance();
await server.ready();
return { app, server, prisma: app.get(PrismaService) };
} catch (error) {
await app.close();
throw error;
}
}
test('PostgreSQL storage: constraints, pagination, access and application restart', async (t) => {
assert.ok(
process.env.DATABASE_URL,
'Set DATABASE_URL and apply migrations before running this test',
);
let context = await start();
const userIds = [];
const chatIds = [];
t.after(async () => {
try {
await context.prisma.chat.deleteMany({ where: { id: { in: chatIds } } });
await context.prisma.user.deleteMany({ where: { id: { in: userIds } } });
} finally {
await context.app.close();
}
});
const suffix = randomUUID().replaceAll('-', '').slice(0, 16);
const password = '🔐'.repeat(40) + ':пароль с пробелами ';
const tokens = new Map();
const request = (method, url, payload, userId) =>
context.server.inject({
method,
url,
...(payload === undefined ? {} : { payload }),
...(userId
? { headers: { authorization: `Bearer ${tokens.get(userId)}` } }
: {}),
});
const registrations = await Promise.all(
Array.from({ length: 4 }, () =>
request('POST', '/api/v1/users', {
username: `race_${suffix}`,
display_name: 'Race',
password,
}),
),
);
for (const response of registrations) {
if (response.statusCode === 201) userIds.push(response.json().id);
}
assert.deepEqual(
registrations.map((response) => response.statusCode).sort(),
[201, 409, 409, 409],
);
const userId = userIds[0];
const outsider = await request('POST', '/api/v1/users', {
username: `other_${suffix}`,
display_name: 'Other',
password,
});
assert.equal(outsider.statusCode, 201);
userIds.push(outsider.json().id);
const login = (username, secret = password, payload) =>
context.server.inject({
method: 'POST',
url: '/api/v1/auth/sessions',
headers: {
authorization: `Basic ${Buffer.from(`${username}:${secret}`, 'utf8').toString('base64')}`,
},
...(payload === undefined ? {} : { payload }),
});
for (const user of [
registrations.find((r) => r.statusCode === 201).json(),
outsider.json(),
]) {
assert.deepEqual(Object.keys(user).sort(), [
'created_at',
'display_name',
'id',
'username',
]);
const response = await login(user.username);
assert.equal(response.statusCode, 201);
assert.equal(response.json().token_type, 'Bearer');
assert.match(response.json().token, /^[A-Za-z0-9_-]{43}$/);
assert.deepEqual(response.json().user, user);
tokens.set(user.id, response.json().token);
const stored = await context.prisma.user.findUniqueOrThrow({
where: { id: user.id },
});
assert.match(stored.passwordHash, /^\$argon2id\$v=19\$m=19456,t=2,p=1\$/);
assert.ok(!stored.passwordHash.includes(password));
}
const sessions = await context.prisma.session.findMany({ where: { userId } });
assert.equal(sessions.length, 1);
assert.match(sessions[0].tokenHash, /^[a-f0-9]{64}$/);
assert.notEqual(sessions[0].tokenHash, tokens.get(userId));
const wrong = await login(`race_${suffix}`, 'wrong-password');
const unknown = await login(`missing_${suffix}`, 'wrong-password');
assert.equal(wrong.statusCode, 401);
assert.equal(unknown.statusCode, 401);
assert.equal(wrong.json().error.message, unknown.json().error.message);
assert.equal(
wrong.headers['www-authenticate'],
'Basic realm="messenger", charset="UTF-8"',
);
assert.equal((await login(`race_${suffix}`, password, {})).statusCode, 400);
for (const invalid of [
undefined,
'short',
' '.repeat(12),
'🔐'.repeat(129),
]) {
assert.equal(
(
await request('POST', '/api/v1/users', {
username: `bad_${suffix}`,
display_name: 'Bad',
...(invalid === undefined ? {} : { password: invalid }),
})
).statusCode,
400,
);
}
for (const authorization of [
undefined,
'Bearer unknown',
`Basic ${Buffer.from(`race_${suffix}:${password}`).toString('base64')}`,
]) {
const response = await context.server.inject({
method: 'GET',
url: '/api/v1/users/me',
headers: {
'x-user-id': userId,
...(authorization ? { authorization } : {}),
},
});
assert.equal(response.statusCode, 401);
assert.equal(
response.headers['www-authenticate'],
'Bearer realm="messenger"',
);
}
const identity = await context.server.inject({
method: 'GET',
url: '/api/v1/users/me',
headers: {
authorization: `Bearer ${tokens.get(userId)}`,
'x-user-id': outsider.json().id,
},
});
assert.equal(identity.json().id, userId);
const ready = await request('GET', '/health/ready');
assert.equal(ready.statusCode, 200);
const invalidChat = await request(
'POST',
'/api/v1/chats',
{
title: `invalid_${suffix}`,
member_ids: [userId, randomUUID()],
},
userId,
);
assert.equal(invalidChat.statusCode, 400);
assert.equal(
await context.prisma.chat.count({ where: { title: `invalid_${suffix}` } }),
0,
);
const rolledBackId = randomUUID();
chatIds.push(rolledBackId);
await assert.rejects(
context.prisma.$transaction(async (tx) => {
await tx.chat.create({ data: { id: rolledBackId, title: 'Rollback' } });
await tx.chatMember.create({
data: { chatId: rolledBackId, userId: randomUUID(), position: 0 },
});
}),
{ code: 'P2003' },
);
assert.equal(
await context.prisma.chat.count({ where: { id: rolledBackId } }),
0,
);
const createdChat = await request(
'POST',
'/api/v1/chats',
{ title: 'Persisted chat', member_ids: [userId] },
userId,
);
assert.equal(createdChat.statusCode, 201);
const chatId = createdChat.json().id;
chatIds.push(chatId);
const forbidden = await request(
'GET',
`/api/v1/chats/${chatId}`,
undefined,
outsider.json().id,
);
assert.equal(forbidden.statusCode, 404);
const unauthorized = await request('GET', `/api/v1/chats/${chatId}`);
assert.equal(unauthorized.statusCode, 401);
const messageIds = [];
for (let i = 0; i < 5; i++) {
const message = await request(
'POST',
`/api/v1/chats/${chatId}/messages`,
{ text: `Message ${i}` },
userId,
);
assert.equal(message.statusCode, 201);
messageIds.push(message.json().id);
}
await context.prisma.message.updateMany({
where: { chatId },
data: { createdAt: new Date('2026-01-01T00:00:00.000Z') },
});
const first = await request(
'GET',
`/api/v1/chats/${chatId}/messages?limit=2`,
undefined,
userId,
);
assert.equal(first.statusCode, 200);
assert.equal(first.json().items.length, 2);
assert.ok(first.json().next_cursor);
await context.app.close();
context = await start();
const me = await request('GET', '/api/v1/users/me', undefined, userId);
assert.equal(me.statusCode, 200);
const chat = await request(
'GET',
`/api/v1/chats/${chatId}`,
undefined,
userId,
);
assert.equal(chat.statusCode, 200);
assert.deepEqual(chat.json().member_ids, [userId]);
const listed = await request(
'GET',
'/api/v1/chats?limit=1',
undefined,
userId,
);
assert.deepEqual(
listed.json().items.map((item) => item.id),
[chatId],
);
const seen = first.json().items.map((message) => message.id);
let cursor = first.json().next_cursor;
while (cursor) {
const page = await request(
'GET',
`/api/v1/chats/${chatId}/messages?limit=2&cursor=${cursor}`,
undefined,
userId,
);
assert.equal(page.statusCode, 200);
assert.ok(page.json().items.length <= 2);
seen.push(...page.json().items.map((message) => message.id));
cursor = page.json().next_cursor;
}
assert.deepEqual(seen, [...messageIds].sort());
assert.equal(new Set(seen).size, 5);
const logouts = await Promise.all(
Array.from({ length: 2 }, () =>
request('DELETE', '/api/v1/auth/sessions/current', undefined, userId),
),
);
assert.deepEqual(logouts.map((r) => r.statusCode).sort(), [204, 401]);
assert.equal(logouts.find((r) => r.statusCode === 204).body, '');
assert.equal(
(await request('GET', '/api/v1/users/me', undefined, userId)).statusCode,
401,
);
assert.equal(
(
await request(
'DELETE',
'/api/v1/auth/sessions/current',
undefined,
userId,
)
).statusCode,
401,
);
await context.app.close();
const originalTtl = process.env.SESSION_TTL_SECONDS;
process.env.SESSION_TTL_SECONDS = '2';
try {
context = await start();
} finally {
if (originalTtl === undefined) delete process.env.SESSION_TTL_SECONDS;
else process.env.SESSION_TTL_SECONDS = originalTtl;
}
const short = await login(`race_${suffix}`);
assert.equal(short.statusCode, 201);
tokens.set(userId, short.json().token);
assert.equal(
(await request('GET', '/api/v1/users/me', undefined, userId)).statusCode,
200,
);
await context.app.close();
context = await start();
await new Promise((resolve) =>
setTimeout(
resolve,
Math.max(0, Date.parse(short.json().expires_at) - Date.now()) + 100,
),
);
assert.equal(
(await request('GET', '/api/v1/users/me', undefined, userId)).statusCode,
401,
);
});
+441
View File
@@ -0,0 +1,441 @@
import 'dotenv/config';
import assert from 'node:assert/strict';
import { randomBytes, randomUUID } from 'node:crypto';
import { createRequire } from 'node:module';
import { performance } from 'node:perf_hooks';
import test from 'node:test';
import { faultProxy } from './helpers/fault-proxy.mjs';
const require = createRequire(import.meta.url);
const Redis = require('ioredis').default;
const { NestFactory } = require('@nestjs/core');
const { AppModule } = require('../dist/app.module');
const { PrismaService } = require('../dist/prisma/prisma.service');
const {
createFastifyAdapter,
exposeRequestIdHeader,
} = require('../dist/common/http/fastify-adapter');
const pause = (milliseconds) =>
new Promise((resolve) => setTimeout(resolve, milliseconds));
test(
'Auth and dependency failures remain bounded and fail closed',
{ timeout: 120000 },
async (t) => {
assert.ok(
process.env.DATABASE_URL,
'Set DATABASE_URL and apply migrations',
);
assert.ok(
process.env.CACHE_URL,
'Set CACHE_URL to a running Redis instance',
);
const original = {
DATABASE_URL: process.env.DATABASE_URL,
CACHE_URL: process.env.CACHE_URL,
CACHE_PREFIX: process.env.CACHE_PREFIX,
SESSION_TTL_SECONDS: process.env.SESSION_TTL_SECONDS,
};
const prefix = `test:resilience:${randomUUID()}`;
const db = await faultProxy(original.DATABASE_URL, 5432);
const redis = await faultProxy(original.CACHE_URL, 6379);
Object.assign(process.env, {
DATABASE_URL: db.url,
CACHE_URL: redis.url,
CACHE_PREFIX: prefix,
SESSION_TTL_SECONDS: '2',
});
const observer = new Redis(original.CACHE_URL, {
connectTimeout: 1000,
commandTimeout: 1000,
maxRetriesPerRequest: 0,
});
observer.on('error', () => {});
let app;
let prisma;
let userId;
let chatId;
t.after(async () => {
db.setMode('online');
redis.setMode('online');
try {
if (prisma) {
if (chatId) await prisma.chat.deleteMany({ where: { id: chatId } });
if (userId) await prisma.user.deleteMany({ where: { id: userId } });
}
let cursor = '0';
do {
const [next, keys] = await observer.scan(
cursor,
'MATCH',
`${prefix}:*`,
'COUNT',
100,
);
cursor = next;
if (keys.length) await observer.del(...keys);
} while (cursor !== '0');
} finally {
observer.disconnect();
if (app) await app.close();
await db.close();
await redis.close();
for (const [key, value] of Object.entries(original)) {
if (value === undefined) delete process.env[key];
else process.env[key] = value;
}
}
});
await observer.ping();
app = await NestFactory.create(AppModule, createFastifyAdapter(), {
logger: false,
abortOnError: false,
});
exposeRequestIdHeader(app);
await app.init();
const server = app.getHttpAdapter().getInstance();
await server.ready();
prisma = app.get(PrismaService);
let token;
const request = async (
method,
url,
{
payload,
authorization = token ? `Bearer ${token}` : undefined,
headers = {},
budget = 8000,
} = {},
) => {
const start = performance.now();
let timer;
try {
const response = await Promise.race([
server.inject({
method,
url,
headers: {
...headers,
...(authorization ? { authorization } : {}),
},
...(payload === undefined ? {} : { payload }),
}),
new Promise((_, reject) => {
timer = setTimeout(
() => reject(new Error(`${method} ${url} exceeded ${budget}ms`)),
budget,
);
}),
]);
assert.ok(
performance.now() - start < budget,
'request exceeded its deadline',
);
return response;
} finally {
clearTimeout(timer);
}
};
const errorResponse = (response, status, code, challenge) => {
assert.equal(
response.statusCode,
status,
`${response.statusCode}: ${response.body}`,
);
const body = response.json();
assert.deepEqual(Object.keys(body), ['error']);
assert.deepEqual(Object.keys(body.error).sort(), [
'code',
'message',
'request_id',
]);
assert.equal(body.error.code, code);
assert.equal(body.error.request_id, response.headers['x-request-id']);
assert.ok(body.error.request_id);
assert.ok(body.error.message.length <= 200);
for (const secret of [
original.DATABASE_URL,
original.CACHE_URL,
token,
].filter(Boolean))
assert.ok(!response.body.includes(secret));
assert.ok(
!/Prisma|SELECT |INSERT |stack|ECONN|postgresql:\/\//i.test(
response.body,
),
'error leaks implementation details',
);
if (challenge)
assert.equal(response.headers['www-authenticate'], challenge);
};
const username = `fault_${randomUUID().replaceAll('-', '').slice(0, 20)}`;
const password = 'Synthetic-test-password:🔐123';
const basic = (secret) =>
`Basic ${Buffer.from(`${username}:${secret}`, 'utf8').toString('base64')}`;
const login = (secret = password) =>
request('POST', '/api/v1/auth/sessions', {
authorization: basic(secret),
});
const registered = await request('POST', '/api/v1/users', {
payload: { username, display_name: 'Fault test', password },
budget: 15000,
});
assert.equal(registered.statusCode, 201);
userId = registered.json().id;
await t.test('incorrect password is 401 with Basic challenge', async () => {
const wrong = await login('wrong-password');
errorResponse(
wrong,
401,
'unauthorized',
'Basic realm="messenger", charset="UTF-8"',
);
assert.equal(await prisma.session.count({ where: { userId } }), 0);
});
await t.test(
'SESSION_TTL_SECONDS=2 expires without renewing on reads',
async () => {
const response = await login();
assert.equal(response.statusCode, 201);
token = response.json().token;
const stored = await prisma.session.findFirstOrThrow({
where: { userId },
});
assert.ok(
Math.abs(
stored.expiresAt.getTime() - stored.createdAt.getTime() - 2000,
) < 500,
);
assert.equal(
(await request('GET', '/api/v1/users/me')).statusCode,
200,
);
await pause(
Math.max(0, Date.parse(response.json().expires_at) - Date.now()) +
100,
);
errorResponse(
await request('GET', '/api/v1/users/me'),
401,
'unauthorized',
'Bearer realm="messenger"',
);
errorResponse(
await request('DELETE', '/api/v1/auth/sessions/current'),
401,
'unauthorized',
'Bearer realm="messenger"',
);
},
);
await t.test(
'logout revokes immediately, including with a cached profile',
async () => {
const response = await login();
assert.equal(response.statusCode, 201);
token = response.json().token;
assert.equal(
(await request('GET', '/api/v1/users/me')).statusCode,
200,
);
const logout = await request('DELETE', '/api/v1/auth/sessions/current');
assert.equal(logout.statusCode, 204);
assert.equal(logout.body, '');
errorResponse(
await request('GET', '/api/v1/users/me'),
401,
'unauthorized',
'Bearer realm="messenger"',
);
errorResponse(
await request('DELETE', '/api/v1/auth/sessions/current'),
401,
'unauthorized',
'Bearer realm="messenger"',
);
},
);
token = randomBytes(32).toString('base64url');
const { createHash } = await import('node:crypto');
await prisma.session.create({
data: {
userId,
tokenHash: createHash('sha256').update(token).digest('hex'),
expiresAt: new Date(Date.now() + 600000),
},
});
const chat = await request('POST', '/api/v1/chats', {
payload: { title: 'Fault isolation', member_ids: [userId] },
});
assert.equal(chat.statusCode, 201);
chatId = chat.json().id;
const history = `/api/v1/chats/${chatId}/messages`;
assert.equal(
(await request('POST', history, { payload: { text: 'Before fault' } }))
.statusCode,
201,
);
assert.equal((await request('GET', history)).json().items.length, 1);
const anonymousChecks = async () => {
for (const authorization of ['', 'Bearer invalid', basic(password)]) {
const headers = { 'x-user-id': userId };
errorResponse(
await request('GET', history, { authorization, headers }),
401,
'unauthorized',
'Bearer realm="messenger"',
);
errorResponse(
await request('POST', history, {
authorization,
headers,
payload: { text: 'Must not be stored' },
}),
401,
'unauthorized',
'Bearer realm="messenger"',
);
}
};
await t.test(
'Redis disconnect: SQL fallback and anonymous callers remain unauthorized',
async () => {
redis.setMode('cut');
await anonymousChecks();
assert.equal(
(await request('GET', history, { budget: 3000 })).statusCode,
200,
);
assert.equal(
(
await request('POST', history, {
payload: { text: 'Redis offline' },
budget: 3000,
})
).statusCode,
201,
);
assert.equal(
(await request('GET', history, { budget: 3000 })).json().items.length,
2,
);
redis.setMode('online');
await pause(1300);
},
);
await t.test('Redis hangs: command timeout bypasses cache', async () => {
redis.setMode('hang');
try {
assert.equal(
(await request('GET', `${history}?limit=10`, { budget: 3000 }))
.statusCode,
200,
);
assert.equal(
(
await request('POST', history, {
payload: { text: 'Redis blackhole' },
budget: 3000,
})
).statusCode,
201,
);
await anonymousChecks();
} finally {
redis.setMode('cut');
redis.setMode('online');
}
await pause(1300);
});
await t.test(
'PostgreSQL disconnect: bounded 503, no cached authorization bypass',
async () => {
db.setMode('cut');
try {
await anonymousChecks();
errorResponse(
await request('GET', '/api/v1/users/me'),
503,
'unavailable',
);
errorResponse(await request('GET', history), 503, 'unavailable');
errorResponse(
await request('POST', history, { payload: { text: 'DB offline' } }),
503,
'unavailable',
);
errorResponse(
await request('DELETE', '/api/v1/auth/sessions/current'),
503,
'unavailable',
);
errorResponse(await login(), 503, 'unavailable');
errorResponse(
await request('GET', '/health/ready'),
503,
'unavailable',
);
assert.equal((await request('GET', '/health/live')).statusCode, 200);
} finally {
db.setMode('online');
}
assert.equal(
(await request('GET', '/api/v1/users/me')).statusCode,
200,
);
},
);
await t.test(
'PostgreSQL hangs on an established connection: client query timeout',
async () => {
assert.equal(
(await request('GET', '/api/v1/users/me')).statusCode,
200,
);
db.setMode('hang');
try {
await anonymousChecks();
errorResponse(await request('GET', history), 503, 'unavailable');
} finally {
db.setMode('cut');
db.setMode('online');
}
assert.equal(
(await request('GET', '/api/v1/users/me')).statusCode,
200,
);
},
);
await t.test(
'both services unavailable: fail closed and recover confirmed data',
async () => {
db.setMode('cut');
redis.setMode('cut');
try {
await anonymousChecks();
errorResponse(await request('GET', history), 503, 'unavailable');
errorResponse(
await request('GET', history, {
authorization: `Bearer ${randomBytes(32).toString('base64url')}`,
}),
503,
'unavailable',
);
} finally {
db.setMode('online');
redis.setMode('online');
}
const recovered = await request('GET', `${history}?limit=100`);
assert.equal(recovered.statusCode, 200);
assert.deepEqual(
recovered.json().items.map((message) => message.text),
['Before fault', 'Redis offline', 'Redis blackhole'],
);
assert.equal(await prisma.message.count({ where: { chatId } }), 3);
assert.equal((await request('GET', '/health/ready')).statusCode, 200);
},
);
},
);