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; type Actor = { user: User; password: string; token: string }; type HttpResult = { body: T; response: Response }; async function http( path: string, init: RequestInit = {}, ): Promise> { 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 = {}, ): 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 { return { authorization: `Bearer ${token}` }; } function idempotencyKey(): Record { return { 'idempotency-key': randomUUID().replaceAll('-', '') }; } function messageHeaders(token: string): Record { return { ...bearer(token), ...idempotencyKey() }; } async function register( displayName = 'Интеграционный пользователь', secret = password, ): Promise { const username = `e2e_${runId}_${sequence++}`.slice(0, 32); usernames.push(username); const result = await http( '/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 { const result = await http('/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 { const user = await register(displayName); const session = await login(user); return { user, password, token: session.token }; } function expectError( result: HttpResult, 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('/api/v1/users/me'); expectError(denied, 401, 'unauthorized'); expect(denied.response.headers.get('www-authenticate')).toBe( bearerChallenge, ); }); it('measures string lengths in Unicode code points', async () => { const emoji = '🔐'; const username = (suffix: string) => `e2e_${runId}_${suffix}`.slice(0, 32); const rejected = await http( '/api/v1/users', json({ username: username('cp_short'), display_name: 'Code points', password: emoji.repeat(11), }), ); expectError(rejected, 400, 'invalid_request'); const tooLongPassword = await http( '/api/v1/users', json({ username: username('cp_long'), display_name: 'Code points', password: emoji.repeat(129), }), ); expectError(tooLongPassword, 400, 'invalid_request'); const tooLongName = await http( '/api/v1/users', json({ username: username('cp_name'), display_name: emoji.repeat(101), password, }), ); expectError(tooLongName, 400, 'invalid_request'); const shortUsername = username('cp_ok'); usernames.push(shortUsername); const boundaryPassword = emoji.repeat(12); const created = await http( '/api/v1/users', json({ username: shortUsername, display_name: emoji.repeat(100), password: boundaryPassword, }), ); expect(created.response.status).toBe(201); expect([...created.body.display_name].length).toBe(100); // The stored password keeps all 12 code points: authentication works. const session = await http('/api/v1/auth/sessions', { method: 'POST', headers: { authorization: basic(shortUsername, boundaryPassword), }, }); expect(session.response.status).toBe(201); tokens.push(session.body.token); const longTitleRejected = await http( '/api/v1/chats', json( { title: emoji.repeat(101), member_ids: [created.body.id] }, bearer(session.body.token), ), ); expectError(longTitleRejected, 400, 'invalid_request'); const longTitle = await http( '/api/v1/chats', json( { title: emoji.repeat(100), member_ids: [created.body.id] }, bearer(session.body.token), ), ); expect(longTitle.response.status).toBe(201); const tooLongText = await http( `/api/v1/chats/${longTitle.body.id}/messages`, json({ text: emoji.repeat(4001) }, messageHeaders(session.body.token)), ); expectError(tooLongText, 400, 'invalid_request'); const boundaryText = await http( `/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( '/api/v1/users', json({ username, ...body }), ); expectError(result, 400, 'invalid_request'); } const accepted = await http( '/api/v1/users', json({ username, display_name: 'Пользователь', password }), ); expect(accepted.response.status).toBe(201); }); it('registers, logs in with Unicode/colon password, and challenges malformed Basic', async () => { const user = await register(); const session = await login(user); expect(session.user.id).toBe(user.id); expect(session.token_type).toBe('Bearer'); const me = await http('/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('/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('/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( '/api/v1/users', json({ username, display_name: 'Race A', password }), ), http( '/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('/api/v1/users/me', { headers: { ...bearer(alice.token), 'x-user-id': bob.user.id }, }); expect(spoof.response.status).toBe(200); expect((spoof.body as unknown as User).id).toBe(alice.user.id); const basicBusiness = await http('/api/v1/users/me', { 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('/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( '/api/v1/chats', json( { title: 'unknown', member_ids: [alice.user.id, randomUUID()] }, bearer(alice.token), ), ); expectError(unknown, 400, 'invalid_request'); const leaked = await http(`/api/v1/chats?limit=100`, { headers: bearer(alice.token), }); expect(leaked.response.status).toBe(200); expect( (leaked.body as unknown as Page).items.some( (item) => item.title === 'unknown', ), ).toBe(false); const duplicate = await http( '/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( '/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( `/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( '/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( `/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( `/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( `/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>( `/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( '/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( `/api/v1/chats/${chat.body.id}/messages?limit=101`, { headers: bearer(alice.token) }, ); expectError(invalidLimit, 400, 'invalid_request'); const invalidCursor = await http( `/api/v1/chats/${chat.body.id}/messages?cursor=not-a-cursor`, { headers: bearer(alice.token) }, ); expectError(invalidCursor, 400, 'invalid_request'); const rolledOver = http( `/api/v1/chats/${chat.body.id}/messages?cursor=${encodeURIComponent( Buffer.from( JSON.stringify({ scope: `messages:${chat.body.id}`, created_at: '2026-02-31T00:00:00.000Z', id: randomUUID(), }), 'utf8', ).toString('base64url'), )}`, { headers: bearer(alice.token) }, ); expectError(await rolledOver, 400, 'invalid_request'); const malformed = await http('/api/v1/users', { method: 'POST', headers: { 'content-type': 'application/json' }, body: '{', }); expectError(malformed, 400, 'invalid_request'); const first = await http>( `/api/v1/chats/${chat.body.id}/messages?limit=2`, { headers: bearer(alice.token) }, ); expect(first.body.items).toHaveLength(2); const second = await http>( `/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('/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 { const created = await http( '/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 { const page = await http>( `/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( 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( 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(path, json({ text }, headers)); expect(first.response.status).toBe(201); const replayed = await http(path, json({ text }, headers)); expect(replayed.response.status).toBe(201); expect(replayed.body).toEqual(first.body); const conflict = await http( 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(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(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(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( `/api/v1/chats/${foreignChatId}/messages`, json({ text: 'чужое' }, { ...bearer(alice.token), 'idempotency-key': key }), ); expectError(denied, 404, 'not_found'); const mine = await http( path, json({ text: 'своё' }, { ...bearer(alice.token), 'idempotency-key': key }), ); expect(mine.response.status).toBe(201); const other = await http( path, json({ text: 'своё' }, { ...bearer(bob.token), 'idempotency-key': key }), ); expect(other.response.status).toBe(201); expect(other.body.id).not.toBe(mine.body.id); }); });