forked from mtusi2026/mtusi2026lab5
Перенесено дерево lab4 целиком: NestJS-приложение с вложениями и S3,
Dockerfile, compose.yaml, infra/{haproxy,minio}, стендовые скрипты,
scripts/lab4, evidence/lab4 и contracts/extensions.openapi.json.
Задание lab5 оставлено своим: README, REPORT, COURSE, lab.json,
contracts/{openapi,infrastructure,jobs.schema,attachment-states,examples},
tests, compose.example.yaml, .github/pull_request_template.md.
Адаптации при переносе:
- docker-проект mtusi-lab4 -> mtusi-lab5 и тег образа mtusi-messenger:lab5,
чтобы тома и контейнеры не пересекались с lab4 (scripts/stop-one.sh:
LAB_PROJECT вместо LAB4_PROJECT);
- Makefile: цели lab5 сохранены, добавлены стендовые (stand-up/down,
wait-ready, init-env, test-e2e, test-dependencies, s3-security,
consistency, bench);
- .env.example: реальные переменные приложения и стенда lab4 (без них
compose.yaml не поднимается) + блок lab5 (BROKER_URL_FILE, WORKER_*).
675 lines
22 KiB
TypeScript
675 lines
22 KiB
TypeScript
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
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.
|
|
const baseUrl = (process.env.API_BASE_URL ?? 'http://localhost:8080').replace(
|
|
/\/+$/u,
|
|
'',
|
|
);
|
|
const basicChallenge = 'Basic realm="messenger", charset="UTF-8"';
|
|
const bearerChallenge = 'Bearer realm="messenger"';
|
|
const password = 'integration:пароль🔐';
|
|
const runId = randomUUID().replaceAll('-', '').slice(0, 12);
|
|
const usernames: string[] = [];
|
|
const tokens: string[] = [];
|
|
let sequence = 0;
|
|
let database: Pool;
|
|
let redis: ReturnType<typeof createClient>;
|
|
|
|
type Actor = { user: User; password: string; token: string };
|
|
type HttpResult<T> = { body: T; response: Response };
|
|
|
|
async function http<T = unknown>(
|
|
path: string,
|
|
init: RequestInit = {},
|
|
): Promise<HttpResult<T>> {
|
|
const response = await fetch(`${baseUrl}${path}`, init);
|
|
const text = await response.text();
|
|
let body: unknown = undefined;
|
|
if (text) {
|
|
try {
|
|
body = JSON.parse(text);
|
|
} catch {
|
|
body = text;
|
|
}
|
|
}
|
|
return { body: body as T, response };
|
|
}
|
|
|
|
function json(
|
|
body: unknown,
|
|
headers: Record<string, string> = {},
|
|
): RequestInit {
|
|
return {
|
|
method: 'POST',
|
|
headers: { 'content-type': 'application/json', ...headers },
|
|
body: JSON.stringify(body),
|
|
};
|
|
}
|
|
|
|
function basic(username: string, secret: string): string {
|
|
return `Basic ${Buffer.from(`${username}:${secret}`, 'utf8').toString('base64')}`;
|
|
}
|
|
|
|
function bearer(token: string): Record<string, string> {
|
|
return { authorization: `Bearer ${token}` };
|
|
}
|
|
|
|
function idempotencyKey(): Record<string, string> {
|
|
return { 'idempotency-key': randomUUID().replaceAll('-', '') };
|
|
}
|
|
|
|
function messageHeaders(token: string): Record<string, string> {
|
|
return { ...bearer(token), ...idempotencyKey() };
|
|
}
|
|
|
|
async function register(
|
|
displayName = 'Интеграционный пользователь',
|
|
secret = password,
|
|
): Promise<User> {
|
|
const username = `e2e_${runId}_${sequence++}`.slice(0, 32);
|
|
usernames.push(username);
|
|
const result = await http<User>(
|
|
'/api/v1/users',
|
|
json({ username, display_name: displayName, password: secret }),
|
|
);
|
|
expect(result.response.status).toBe(201);
|
|
return result.body;
|
|
}
|
|
|
|
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) },
|
|
});
|
|
expect(result.response.status).toBe(201);
|
|
tokens.push(result.body.token);
|
|
return result.body;
|
|
}
|
|
|
|
async function actor(displayName?: string): Promise<Actor> {
|
|
const user = await register(displayName);
|
|
const session = await login(user);
|
|
return { user, password, token: session.token };
|
|
}
|
|
|
|
function expectError(
|
|
result: HttpResult<ApiErrorBody>,
|
|
status: number,
|
|
code: string,
|
|
): void {
|
|
expect(result.response.status).toBe(status);
|
|
expect(result.body.error.code).toBe(code);
|
|
expect(result.body.error.request_id).toBe(
|
|
result.response.headers.get('x-request-id'),
|
|
);
|
|
}
|
|
|
|
describe('HTTP integration contract', () => {
|
|
beforeAll(async () => {
|
|
database = new Pool({
|
|
connectionString: process.env.DATABASE_URL,
|
|
connectionTimeoutMillis: 5000,
|
|
});
|
|
redis = createClient({
|
|
url: process.env.REDIS_URL,
|
|
socket: { reconnectStrategy: false },
|
|
});
|
|
redis.on('error', () => {});
|
|
await redis.connect();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
if (usernames.length) {
|
|
await database.query('BEGIN');
|
|
try {
|
|
await database.query(
|
|
`DELETE FROM messages WHERE sender_id IN (SELECT id FROM users WHERE username = ANY($1::text[]))`,
|
|
[usernames],
|
|
);
|
|
await database.query(
|
|
`DELETE FROM chats WHERE id IN (SELECT chat_id FROM chat_members WHERE user_id IN (SELECT id FROM users WHERE username = ANY($1::text[])))`,
|
|
[usernames],
|
|
);
|
|
await database.query(
|
|
'DELETE FROM users WHERE username = ANY($1::text[])',
|
|
[usernames],
|
|
);
|
|
await database.query('COMMIT');
|
|
} catch (error) {
|
|
await database.query('ROLLBACK');
|
|
throw error;
|
|
}
|
|
}
|
|
if (redis.isOpen) redis.destroy();
|
|
await database.end();
|
|
});
|
|
|
|
it('serves liveness and requires real session authentication', async () => {
|
|
const live = await http<{ status: string }>('/health/live');
|
|
expect(live.response.status).toBe(200);
|
|
expect(live.body).toEqual({ status: 'ok' });
|
|
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) }, messageHeaders(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) }, messageHeaders(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);
|
|
expect(session.user.id).toBe(user.id);
|
|
expect(session.token_type).toBe('Bearer');
|
|
const me = await http<User>('/api/v1/users/me', {
|
|
headers: bearer(session.token),
|
|
});
|
|
expect(me.response.status).toBe(200);
|
|
expect(me.body.id).toBe(user.id);
|
|
for (const authorization of [
|
|
'Basic !!!',
|
|
'Basic YWJj',
|
|
'Bearer nope',
|
|
]) {
|
|
const result = await http<ApiErrorBody>('/api/v1/auth/sessions', {
|
|
method: 'POST',
|
|
headers: { authorization },
|
|
});
|
|
expectError(result, 401, 'unauthorized');
|
|
expect(result.response.headers.get('www-authenticate')).toBe(
|
|
basicChallenge,
|
|
);
|
|
}
|
|
const bodyResult = await http<ApiErrorBody>('/api/v1/auth/sessions', {
|
|
...json({ unexpected: true }),
|
|
headers: { authorization: basic(user.username, password) },
|
|
});
|
|
expectError(bodyResult, 400, 'invalid_request');
|
|
});
|
|
|
|
it('returns conflict for concurrent duplicate registration', async () => {
|
|
const username = `e2e_${runId}_race`.slice(0, 32);
|
|
usernames.push(username);
|
|
const results = await Promise.all([
|
|
http<User>(
|
|
'/api/v1/users',
|
|
json({ username, display_name: 'Race A', password }),
|
|
),
|
|
http<User>(
|
|
'/api/v1/users',
|
|
json({ username, display_name: 'Race B', password }),
|
|
),
|
|
]);
|
|
expect(
|
|
results.filter((item) => item.response.status === 201),
|
|
'duplicate registration must create exactly one user',
|
|
).toHaveLength(1);
|
|
expect(
|
|
results.filter((item) => item.response.status === 409),
|
|
'loser of the race must receive 409, not 500',
|
|
).toHaveLength(1);
|
|
// The database unique index is the race-proof guard, so verify its effect.
|
|
const persisted = await database.query<{ count: string }>(
|
|
'SELECT count(*)::text AS count FROM users WHERE username = $1',
|
|
[username],
|
|
);
|
|
expect(persisted.rows[0]?.count).toBe('1');
|
|
});
|
|
|
|
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<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<ApiErrorBody>('/api/v1/users/me', {
|
|
headers: { authorization: basic(alice.user.username, password) },
|
|
});
|
|
expectError(basicBusiness, 401, 'unauthorized');
|
|
expect(basicBusiness.response.headers.get('www-authenticate')).toBe(
|
|
bearerChallenge,
|
|
);
|
|
const logout = await http('/api/v1/auth/sessions/current', {
|
|
method: 'DELETE',
|
|
headers: bearer(alice.token),
|
|
});
|
|
expect(logout.response.status).toBe(204);
|
|
const replay = await http<ApiErrorBody>('/api/v1/users/me', {
|
|
headers: bearer(alice.token),
|
|
});
|
|
expectError(replay, 401, 'unauthorized');
|
|
});
|
|
|
|
it('rejects unknown and duplicate chat members and hides chats from outsiders', async () => {
|
|
const alice = await actor();
|
|
const bob = await actor();
|
|
const outsider = await actor();
|
|
const unknown = await http<ApiErrorBody>(
|
|
'/api/v1/chats',
|
|
json(
|
|
{ title: 'unknown', member_ids: [alice.user.id, randomUUID()] },
|
|
bearer(alice.token),
|
|
),
|
|
);
|
|
expectError(unknown, 400, 'invalid_request');
|
|
const leaked = await http<ApiErrorBody>(`/api/v1/chats?limit=100`, {
|
|
headers: bearer(alice.token),
|
|
});
|
|
expect(leaked.response.status).toBe(200);
|
|
expect(
|
|
(leaked.body as unknown as Page<Chat>).items.some(
|
|
(item) => item.title === 'unknown',
|
|
),
|
|
).toBe(false);
|
|
const duplicate = await http<ApiErrorBody>(
|
|
'/api/v1/chats',
|
|
json(
|
|
{
|
|
title: 'duplicate',
|
|
member_ids: [alice.user.id, alice.user.id],
|
|
},
|
|
bearer(alice.token),
|
|
),
|
|
);
|
|
expectError(duplicate, 400, 'invalid_request');
|
|
const created = await http<Chat>(
|
|
'/api/v1/chats',
|
|
json(
|
|
{
|
|
title: `chat-${runId}`,
|
|
member_ids: [alice.user.id, bob.user.id],
|
|
},
|
|
bearer(alice.token),
|
|
),
|
|
);
|
|
expect(created.response.status).toBe(201);
|
|
const hidden = await http<ApiErrorBody>(
|
|
`/api/v1/chats/${created.body.id}`,
|
|
{ headers: bearer(outsider.token) },
|
|
);
|
|
expectError(hidden, 404, 'not_found');
|
|
});
|
|
|
|
it('keeps sender server-owned and makes writes visible to a second session', async () => {
|
|
const alice = await actor();
|
|
const secondSession = (await login(alice.user)).token;
|
|
const chat = await http<Chat>(
|
|
'/api/v1/chats',
|
|
json(
|
|
{ title: `messages-${runId}`, member_ids: [alice.user.id] },
|
|
bearer(alice.token),
|
|
),
|
|
);
|
|
expect(chat.response.status).toBe(201);
|
|
const blank = await http<ApiErrorBody>(
|
|
`/api/v1/chats/${chat.body.id}/messages`,
|
|
json(
|
|
{ text: ' \n\t', sender_id: randomUUID() },
|
|
messageHeaders(alice.token),
|
|
),
|
|
);
|
|
expectError(blank, 400, 'invalid_request');
|
|
const spoof = await http<ApiErrorBody>(
|
|
`/api/v1/chats/${chat.body.id}/messages`,
|
|
json(
|
|
{ text: 'hello', sender_id: randomUUID() },
|
|
messageHeaders(alice.token),
|
|
),
|
|
);
|
|
expectError(spoof, 400, 'invalid_request');
|
|
await http(`/api/v1/chats/${chat.body.id}/messages?limit=50`, {
|
|
headers: bearer(secondSession),
|
|
});
|
|
const sent = await http<Message>(
|
|
`/api/v1/chats/${chat.body.id}/messages`,
|
|
json({ text: 'hello' }, messageHeaders(alice.token)),
|
|
);
|
|
expect(sent.response.status).toBe(201);
|
|
expect(sent.body.sender_id).toBe(alice.user.id);
|
|
const page = await http<Page<Message>>(
|
|
`/api/v1/chats/${chat.body.id}/messages?limit=50`,
|
|
{ headers: bearer(secondSession) },
|
|
);
|
|
expect(page.response.status).toBe(200);
|
|
expect(page.body.items.map((item) => item.id)).toContain(sent.body.id);
|
|
});
|
|
|
|
it('validates cursor, limits, malformed JSON, and paginates without repeats', async () => {
|
|
const alice = await actor();
|
|
const chat = await http<Chat>(
|
|
'/api/v1/chats',
|
|
json(
|
|
{ title: `pages-${runId}`, member_ids: [alice.user.id] },
|
|
bearer(alice.token),
|
|
),
|
|
);
|
|
for (const text of ['one', 'two', 'three']) {
|
|
const sent = await http(
|
|
`/api/v1/chats/${chat.body.id}/messages`,
|
|
json({ text }, messageHeaders(alice.token)),
|
|
);
|
|
expect(sent.response.status).toBe(201);
|
|
}
|
|
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<ApiErrorBody>(
|
|
`/api/v1/chats/${chat.body.id}/messages?cursor=not-a-cursor`,
|
|
{ headers: bearer(alice.token) },
|
|
);
|
|
expectError(invalidCursor, 400, 'invalid_request');
|
|
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: '{',
|
|
});
|
|
expectError(malformed, 400, 'invalid_request');
|
|
const first = await http<Page<Message>>(
|
|
`/api/v1/chats/${chat.body.id}/messages?limit=2`,
|
|
{ headers: bearer(alice.token) },
|
|
);
|
|
expect(first.body.items).toHaveLength(2);
|
|
const second = await http<Page<Message>>(
|
|
`/api/v1/chats/${chat.body.id}/messages?limit=2&cursor=${encodeURIComponent(first.body.next_cursor!)}`,
|
|
{ headers: bearer(alice.token) },
|
|
);
|
|
expect(second.body.items).toHaveLength(1);
|
|
expect(
|
|
new Set(
|
|
[...first.body.items, ...second.body.items].map(
|
|
(item) => item.id,
|
|
),
|
|
).size,
|
|
).toBe(3);
|
|
});
|
|
|
|
it.skipIf(process.env.SESSION_TTL_SECONDS !== '2')(
|
|
'expires sessions with TTL=2',
|
|
async () => {
|
|
const user = await register();
|
|
const session = await login(user);
|
|
await sleep(2300);
|
|
const expired = await http<ApiErrorBody>('/api/v1/users/me', {
|
|
headers: bearer(session.token),
|
|
});
|
|
expectError(expired, 401, 'unauthorized');
|
|
},
|
|
);
|
|
});
|
|
|
|
// lab3: the Idempotency-Key contract of POST /chats/{id}/messages. The suite is
|
|
// black-box, so these assertions hold for one replica and for a load-balanced
|
|
// fleet alike.
|
|
describe('message idempotency', () => {
|
|
async function chatFor(token: string, memberIds: string[]): Promise<string> {
|
|
const created = await http<Chat>(
|
|
'/api/v1/chats',
|
|
json({ title: `idempotency-${runId}`, member_ids: memberIds }, bearer(token)),
|
|
);
|
|
expect(created.response.status).toBe(201);
|
|
return created.body.id;
|
|
}
|
|
|
|
async function textsIn(chatId: string, token: string): Promise<string[]> {
|
|
const page = await http<Page<Message>>(
|
|
`/api/v1/chats/${chatId}/messages?limit=100`,
|
|
{ headers: bearer(token) },
|
|
);
|
|
expect(page.response.status).toBe(200);
|
|
return page.body.items.map((item) => item.text);
|
|
}
|
|
|
|
it('requires a well-formed Idempotency-Key', async () => {
|
|
const alice = await actor();
|
|
const chatId = await chatFor(alice.token, [alice.user.id]);
|
|
const path = `/api/v1/chats/${chatId}/messages`;
|
|
const missing = await http<ApiErrorBody>(
|
|
path,
|
|
json({ text: 'без ключа' }, bearer(alice.token)),
|
|
);
|
|
expectError(missing, 400, 'invalid_request');
|
|
for (const key of ['has space', 'comma,separated', 'x'.repeat(129)]) {
|
|
const malformed = await http<ApiErrorBody>(
|
|
path,
|
|
json({ text: 'плохой ключ' }, { ...bearer(alice.token), 'idempotency-key': key }),
|
|
);
|
|
expectError(malformed, 400, 'invalid_request');
|
|
}
|
|
});
|
|
|
|
it('replays the stored response and conflicts on a different body', async () => {
|
|
const alice = await actor();
|
|
const chatId = await chatFor(alice.token, [alice.user.id]);
|
|
const path = `/api/v1/chats/${chatId}/messages`;
|
|
const key = randomUUID().replaceAll('-', '');
|
|
const headers = { ...bearer(alice.token), 'idempotency-key': key };
|
|
const text = `повтор ${runId}`;
|
|
|
|
const first = await http<Message>(path, json({ text }, headers));
|
|
expect(first.response.status).toBe(201);
|
|
const replayed = await http<Message>(path, json({ text }, headers));
|
|
expect(replayed.response.status).toBe(201);
|
|
expect(replayed.body).toEqual(first.body);
|
|
|
|
const conflict = await http<ApiErrorBody>(
|
|
path,
|
|
json({ text: 'другой body' }, headers),
|
|
);
|
|
expectError(conflict, 409, 'conflict');
|
|
|
|
expect(await textsIn(chatId, alice.token)).toEqual([text]);
|
|
});
|
|
|
|
it('creates exactly one message for concurrent requests with one key', async () => {
|
|
const alice = await actor();
|
|
const chatId = await chatFor(alice.token, [alice.user.id]);
|
|
const path = `/api/v1/chats/${chatId}/messages`;
|
|
const headers = { ...bearer(alice.token), ...idempotencyKey() };
|
|
const text = `конкурентный повтор ${runId}`;
|
|
|
|
const results = await Promise.all(
|
|
Array.from({ length: 8 }, () => http<Message>(path, json({ text }, headers))),
|
|
);
|
|
for (const result of results) expect(result.response.status).toBe(201);
|
|
const ids = new Set(results.map((result) => result.body.id));
|
|
expect(
|
|
ids.size,
|
|
'one key must resolve to exactly one message across replicas',
|
|
).toBe(1);
|
|
expect(await textsIn(chatId, alice.token)).toEqual([text]);
|
|
});
|
|
|
|
it('replays a key created by another replica', async () => {
|
|
// lab3: повтор с тем же ключом может прийти на любую реплику, поэтому
|
|
// проверяем не только сам повтор, но и то, что его обслужила другая реплика
|
|
// (иначе тест не отличал бы общий журнал от локального состояния процесса).
|
|
const alice = await actor();
|
|
const chatId = await chatFor(alice.token, [alice.user.id]);
|
|
const path = `/api/v1/chats/${chatId}/messages`;
|
|
const key = randomUUID().replaceAll('-', '');
|
|
const headers = { ...bearer(alice.token), 'idempotency-key': key };
|
|
|
|
const first = await http<Message>(path, json({ text: 'переключение реплики' }, headers));
|
|
expect(first.response.status).toBe(201);
|
|
const firstInstance = first.response.headers.get('x-instance-id');
|
|
expect(firstInstance).toBeTruthy();
|
|
|
|
let replay = first;
|
|
let replayInstance = firstInstance;
|
|
for (let attempt = 0; attempt < 12 && replayInstance === firstInstance; attempt += 1) {
|
|
replay = await http<Message>(path, json({ text: 'переключение реплики' }, headers));
|
|
expect(replay.response.status).toBe(201);
|
|
replayInstance = replay.response.headers.get('x-instance-id');
|
|
}
|
|
expect(
|
|
replayInstance,
|
|
'повтор должен был прийти на другую реплику (round-robin за LB)',
|
|
).not.toBe(firstInstance);
|
|
expect(replay.body).toEqual(first.body);
|
|
expect(await textsIn(chatId, alice.token)).toEqual(['переключение реплики']);
|
|
});
|
|
|
|
it('scopes the key per user and per chat path', async () => {
|
|
const alice = await actor();
|
|
const bob = await actor();
|
|
const outsider = await actor();
|
|
const chatId = await chatFor(alice.token, [alice.user.id, bob.user.id]);
|
|
const path = `/api/v1/chats/${chatId}/messages`;
|
|
const key = randomUUID().replaceAll('-', '');
|
|
const foreignChatId = await chatFor(outsider.token, [outsider.user.id]);
|
|
|
|
const denied = await http<ApiErrorBody>(
|
|
`/api/v1/chats/${foreignChatId}/messages`,
|
|
json({ text: 'чужое' }, { ...bearer(alice.token), 'idempotency-key': key }),
|
|
);
|
|
expectError(denied, 404, 'not_found');
|
|
|
|
const mine = await http<Message>(
|
|
path,
|
|
json({ text: 'своё' }, { ...bearer(alice.token), 'idempotency-key': key }),
|
|
);
|
|
expect(mine.response.status).toBe(201);
|
|
const other = await http<Message>(
|
|
path,
|
|
json({ text: 'своё' }, { ...bearer(bob.token), 'idempotency-key': key }),
|
|
);
|
|
expect(other.response.status).toBe(201);
|
|
expect(other.body.id).not.toBe(mine.body.id);
|
|
});
|
|
});
|