forked from mtusi2026/mtusi2026lab6
242 lines
11 KiB
TypeScript
242 lines
11 KiB
TypeScript
import { INestApplication } from '@nestjs/common';
|
|
import Ajv2020 from 'ajv/dist/2020';
|
|
import { randomUUID } from 'crypto';
|
|
import request from 'supertest';
|
|
import { PrismaService } from '../src/db/prisma.service';
|
|
import { loadDocument } from '../src/docs/swagger';
|
|
import {
|
|
basic,
|
|
bearer,
|
|
createTestApp,
|
|
PASSWORD,
|
|
processAttachment,
|
|
registerUser,
|
|
TestUser,
|
|
} from './helpers';
|
|
import { jpeg, SAMPLE_PNG } from './images';
|
|
|
|
const CONTRACT_ID = 'https://contract.local/openapi.json';
|
|
|
|
describe('Все ответы соответствуют контракту: коды, схемы, заголовки (e2e)', () => {
|
|
let app: INestApplication;
|
|
let server: any;
|
|
let alice: TestUser;
|
|
let bob: TestUser;
|
|
let eve: TestUser;
|
|
const document: any = loadDocument();
|
|
const ajv = new Ajv2020({ strict: false, validateFormats: false });
|
|
ajv.addSchema(document, CONTRACT_ID);
|
|
const covered = new Set<string>();
|
|
|
|
const call = async (
|
|
method: 'get' | 'post' | 'delete',
|
|
template: string,
|
|
values: Record<string, string>,
|
|
expected: number,
|
|
{
|
|
user,
|
|
auth,
|
|
query = '',
|
|
body,
|
|
raw,
|
|
type,
|
|
headers = {},
|
|
}: {
|
|
user?: TestUser | null;
|
|
auth?: string;
|
|
query?: string;
|
|
body?: unknown;
|
|
raw?: Buffer | string;
|
|
type?: string;
|
|
headers?: Record<string, string>;
|
|
} = {},
|
|
) => {
|
|
const path = template.replace(/\{(\w+)\}/g, (_, name) => values[name]);
|
|
let req = request(server)[method](path + query).buffer(true).parse(binaryParser);
|
|
if (user) {
|
|
req = req.set('Authorization', bearer(user));
|
|
}
|
|
if (auth) {
|
|
req = req.set('Authorization', auth);
|
|
}
|
|
for (const [name, value] of Object.entries(headers)) {
|
|
req = req.set(name, value);
|
|
}
|
|
if (type) {
|
|
req = req.set('Content-Type', type);
|
|
}
|
|
const res = raw !== undefined ? await req.send(raw) : body !== undefined ? await req.send(body as object) : await req;
|
|
const operation = document.paths[template][method];
|
|
const label = `${method.toUpperCase()} ${template} -> ${res.status}`;
|
|
expect({ label, status: res.status }).toEqual({ label, status: expected });
|
|
expect({ label, declared: String(res.status) in operation.responses }).toEqual({ label, declared: true });
|
|
expect({ label, requestId: Boolean(res.headers['x-request-id']) }).toEqual({ label, requestId: true });
|
|
expect({ label, instanceId: Boolean(res.headers['x-instance-id']) }).toEqual({ label, instanceId: true });
|
|
const declared = operation.responses[String(res.status)];
|
|
const content = declared.content ?? {};
|
|
const type_ = (res.headers['content-type'] ?? '').split(';')[0];
|
|
if (res.status === 204) {
|
|
expect({ label, length: res.body.length }).toEqual({ label, length: 0 });
|
|
} else if (content['application/json']) {
|
|
expect({ label, type: type_ }).toEqual({ label, type: 'application/json' });
|
|
const json = JSON.parse(res.body.toString('utf8'));
|
|
const schema = content['application/json'].schema;
|
|
const validate = ajv.compile(schema.$ref ? { $ref: CONTRACT_ID + schema.$ref } : schema);
|
|
const valid = validate(json);
|
|
expect({ label, valid, errors: validate.errors }).toEqual({ label, valid: true, errors: null });
|
|
if (json && typeof json === 'object' && 'error' in json) {
|
|
expect({ label, same: json.error.request_id === res.headers['x-request-id'] }).toEqual({ label, same: true });
|
|
}
|
|
} else {
|
|
expect({ label, type: Object.keys(content).includes(type_) }).toEqual({ label, type: true });
|
|
}
|
|
covered.add(label);
|
|
return res.status === 204 || !content['application/json'] ? res.body : JSON.parse(res.body.toString('utf8'));
|
|
};
|
|
|
|
beforeAll(async () => {
|
|
({ app, server } = await createTestApp());
|
|
alice = await registerUser(server, 'ct_alice');
|
|
bob = await registerUser(server, 'ct_bob');
|
|
eve = await registerUser(server, 'ct_eve');
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await app.close();
|
|
});
|
|
|
|
it('health, пользователи и сессии', async () => {
|
|
await call('get', '/health/live', {}, 200);
|
|
await call('get', '/health/ready', {}, 200);
|
|
const username = `ct_${randomUUID().slice(0, 8)}`;
|
|
await call('post', '/api/v1/users', {}, 201, { body: { username, display_name: 'C', password: PASSWORD } });
|
|
await call('post', '/api/v1/users', {}, 409, { body: { username, display_name: 'C', password: PASSWORD } });
|
|
await call('post', '/api/v1/users', {}, 400, { body: { username: 'BAD NAME', display_name: 'C', password: PASSWORD } });
|
|
await call('post', '/api/v1/users', {}, 400, { raw: '{bad', type: 'application/json' });
|
|
await call('post', '/api/v1/auth/sessions', {}, 201, { auth: basic(username, PASSWORD) });
|
|
await call('post', '/api/v1/auth/sessions', {}, 401, { auth: basic(username, 'wrong-password-123') });
|
|
await call('post', '/api/v1/auth/sessions', {}, 400, {
|
|
auth: basic(username, PASSWORD),
|
|
body: { username },
|
|
});
|
|
await call('get', '/api/v1/users/me', {}, 200, { user: alice });
|
|
await call('get', '/api/v1/users/me', {}, 401);
|
|
await call('get', '/api/v1/users/me', {}, 401, { auth: basic(username, PASSWORD) });
|
|
const temp = await registerUser(server, 'ct_tmp');
|
|
await call('delete', '/api/v1/auth/sessions/current', {}, 204, { user: temp });
|
|
await call('delete', '/api/v1/auth/sessions/current', {}, 401, { user: temp });
|
|
});
|
|
|
|
it('чаты и сообщения', async () => {
|
|
const chat = await call('post', '/api/v1/chats', {}, 201, {
|
|
user: alice,
|
|
body: { title: 'Contract', member_ids: [alice.id, bob.id] },
|
|
});
|
|
await call('post', '/api/v1/chats', {}, 400, { user: alice, body: { title: 'x', member_ids: [bob.id] } });
|
|
await call('post', '/api/v1/chats', {}, 401, { body: { title: 'x', member_ids: [] } });
|
|
await call('get', '/api/v1/chats', {}, 200, { user: bob, query: '?limit=1' });
|
|
await call('get', '/api/v1/chats', {}, 400, { user: bob, query: '?limit=0' });
|
|
await call('get', '/api/v1/chats', {}, 400, { user: bob, query: '?cursor=garbage' });
|
|
const ids = { chat_id: chat.id };
|
|
await call('get', '/api/v1/chats/{chat_id}', ids, 200, { user: bob });
|
|
await call('get', '/api/v1/chats/{chat_id}', ids, 404, { user: eve });
|
|
await call('get', '/api/v1/chats/{chat_id}', { chat_id: 'nope' }, 400, { user: bob });
|
|
const key = randomUUID();
|
|
const send = (status: number, body: unknown, user: TestUser = alice, idem: string | null = randomUUID()) =>
|
|
call('post', '/api/v1/chats/{chat_id}/messages', ids, status, {
|
|
user,
|
|
body,
|
|
headers: idem ? { 'Idempotency-Key': idem } : {},
|
|
});
|
|
await send(201, { text: 'привет' }, alice, key);
|
|
await send(201, { text: 'привет' }, alice, key);
|
|
await send(201, { text: 'второе' }, bob);
|
|
await send(409, { text: 'другое' }, alice, key);
|
|
await send(400, { text: 'без ключа' }, alice, null);
|
|
await send(400, { text: '' });
|
|
await send(400, { text: 'x', sender_id: alice.id });
|
|
await send(404, { text: 'x' }, eve);
|
|
await send(404, { text: 'x', attachment_ids: [randomUUID()] });
|
|
const page = await call('get', '/api/v1/chats/{chat_id}/messages', ids, 200, { user: bob, query: '?limit=1' });
|
|
await call('get', '/api/v1/chats/{chat_id}/messages', ids, 200, {
|
|
user: bob,
|
|
query: `?limit=1&cursor=${encodeURIComponent(page.next_cursor)}`,
|
|
});
|
|
await call('get', '/api/v1/chats/{chat_id}/messages', ids, 400, { user: bob, query: '?limit=101' });
|
|
await call('get', '/api/v1/chats/{chat_id}/messages', ids, 404, { user: eve });
|
|
});
|
|
|
|
it('вложения во всех состояниях', async () => {
|
|
const chat = await call('post', '/api/v1/chats', {}, 201, {
|
|
user: alice,
|
|
body: { title: 'Files', member_ids: [alice.id, bob.id] },
|
|
});
|
|
const ids = { chat_id: chat.id };
|
|
const upload = (status: number, body: Buffer, type = 'image/png', query = '?filename=a.png', user: TestUser | null = alice) =>
|
|
call('post', '/api/v1/chats/{chat_id}/attachments', ids, status, { user, raw: body, type, query });
|
|
const queued = await upload(202, SAMPLE_PNG);
|
|
expect(queued.status).toBe('queued');
|
|
await upload(202, await jpeg(), 'image/jpeg');
|
|
await upload(400, SAMPLE_PNG, 'image/png', '?filename=../a.png');
|
|
await upload(415, SAMPLE_PNG, 'image/jpeg');
|
|
await upload(415, Buffer.from('text'), 'text/plain');
|
|
await upload(413, Buffer.alloc(10 * 1024 * 1024 + 1), 'image/png');
|
|
await upload(404, SAMPLE_PNG, 'image/png', '?filename=a.png', eve);
|
|
await upload(401, SAMPLE_PNG, 'image/png', '?filename=a.png', null);
|
|
|
|
const one = { attachment_id: queued.id };
|
|
const meta = '/api/v1/attachments/{attachment_id}';
|
|
const content = '/api/v1/attachments/{attachment_id}/content';
|
|
expect((await call('get', meta, one, 200, { user: bob })).status).toBe('queued');
|
|
await call('get', content, one, 409, { user: bob });
|
|
await call('get', content, one, 409, { user: bob, query: '?variant=thumbnail' });
|
|
await call('post', '/api/v1/chats/{chat_id}/messages', ids, 201, {
|
|
user: alice,
|
|
body: { text: '', attachment_ids: [queued.id] },
|
|
headers: { 'Idempotency-Key': randomUUID() },
|
|
});
|
|
|
|
expect(await processAttachment(app, queued.id)).toBe('ready');
|
|
const ready = await call('get', meta, one, 200, { user: bob });
|
|
expect(ready.variants.map((v: any) => v.name)).toEqual(['thumbnail', 'crop', 'optimized']);
|
|
for (const variant of ['', '?variant=original', '?variant=thumbnail', '?variant=crop', '?variant=optimized']) {
|
|
await call('get', content, one, 200, { user: bob, query: variant });
|
|
}
|
|
await call('get', content, one, 400, { user: bob, query: '?variant=huge' });
|
|
await call('get', content, one, 404, { user: eve });
|
|
await call('get', meta, one, 404, { user: eve });
|
|
await call('get', meta, { attachment_id: 'nope' }, 400, { user: bob });
|
|
await call('get', meta, one, 401);
|
|
|
|
const broken = await upload(202, SAMPLE_PNG);
|
|
const prisma = app.get(PrismaService);
|
|
await prisma.attachmentJob.updateMany({ where: { attachmentId: broken.id }, data: { maxAttempts: 1 } });
|
|
await prisma.attachment.update({ where: { id: broken.id }, data: { sha256: 'f'.repeat(64) } });
|
|
expect(await processAttachment(app, broken.id)).toBe('failed');
|
|
const failed = await call('get', meta, { attachment_id: broken.id }, 200, { user: bob });
|
|
expect(failed).toMatchObject({ status: 'failed', error_code: 'checksum_mismatch', variants: [] });
|
|
await call('get', content, { attachment_id: broken.id }, 409, { user: bob });
|
|
await call('post', '/api/v1/chats/{chat_id}/messages', ids, 409, {
|
|
user: alice,
|
|
body: { text: '', attachment_ids: [broken.id] },
|
|
headers: { 'Idempotency-Key': randomUUID() },
|
|
});
|
|
});
|
|
|
|
it('каждая операция контракта вызвана хотя бы раз', () => {
|
|
const operations = Object.entries(document.paths).flatMap(([path, ops]: [string, any]) =>
|
|
Object.keys(ops)
|
|
.filter((method) => ['get', 'post', 'delete'].includes(method))
|
|
.map((method) => `${method.toUpperCase()} ${path}`),
|
|
);
|
|
const called = new Set([...covered].map((label) => label.split(' -> ')[0]));
|
|
expect(operations.filter((operation) => !called.has(operation))).toEqual([]);
|
|
});
|
|
});
|
|
|
|
function binaryParser(res: any, done: (error: Error | null, body: Buffer) => void): void {
|
|
const chunks: Buffer[] = [];
|
|
res.on('data', (chunk: Buffer) => chunks.push(chunk));
|
|
res.on('end', () => done(null, Buffer.concat(chunks)));
|
|
}
|