Files
mtusi2026lab4/app/test/direct-upload.e2e-spec.ts

345 lines
9.4 KiB
TypeScript

import { createHash } from 'node:crypto';
import { readFileSync } from 'node:fs';
import { setTimeout as sleep } from 'node:timers/promises';
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import type { Pool } from 'pg';
import type { Attachment } from '../src/attachments/attachment.js';
import type { DirectUpload } from '../src/attachments/direct-uploads.service.js';
import type { ApiErrorBody } from '../src/common/errors/api-error.js';
import {
Actor,
actor,
bearer,
createChat,
database,
download,
expectError,
http,
json,
postMessage,
} from './support/e2e.js';
import { noisePng, pixelBombPng } from './support/png.js';
const png = readFileSync(
new URL('../../tests/fixtures/sample.png', import.meta.url),
);
const jpeg = readFileSync(new URL('./fixtures/sample.jpg', import.meta.url));
const MAX = 10_485_760;
const shortTtl = process.env.E2E_DIRECT_TTL_SHORT === '1';
let db: Pool;
let alice: Actor;
let bob: Actor;
let eve: Actor;
let chatId: string;
const sha256 = (data: Uint8Array) =>
createHash('sha256').update(data).digest('hex');
function init(token: string, chat: string, body: Record<string, unknown>) {
return http<DirectUpload & ApiErrorBody>(
`/api/v1/chats/${chat}/attachments/direct-uploads`,
json(body, bearer(token)),
);
}
function declaration(data: Buffer, contentType = 'image/png') {
return {
filename: 'direct.png',
content_type: contentType,
size_bytes: data.length,
sha256: sha256(data),
};
}
async function initOk(data: Buffer, contentType = 'image/png') {
const result = await init(
alice.token,
chatId,
declaration(data, contentType),
);
expect(result.response.status).toBe(201);
return result.body;
}
// The PUT goes straight to the public S3 endpoint, not through the API.
async function put(ticket: DirectUpload, data: Buffer): Promise<Response> {
return fetch(ticket.url, {
method: ticket.method,
headers: ticket.headers,
body: data as unknown as BodyInit,
});
}
function complete(token: string, id: string) {
return http<Attachment & ApiErrorBody>(
`/api/v1/attachments/${id}/complete`,
{
method: 'POST',
headers: bearer(token),
},
);
}
describe('direct upload (presigned PUT)', () => {
beforeAll(async () => {
db = database();
alice = await actor();
bob = await actor();
eve = await actor();
chatId = (await createChat(alice, [bob])).id;
});
afterAll(async () => {
await db.end();
});
it('uploads around the API and exposes the attachment after complete', async () => {
const ticket = await initOk(png);
expect(ticket.method).toBe('PUT');
expect(ticket.headers['x-amz-checksum-sha256']).toBe(
Buffer.from(sha256(png), 'hex').toString('base64'),
);
expect(Date.parse(ticket.expires_at)).toBeGreaterThan(Date.now());
expect(new URL(ticket.url).pathname).toBe(
`/messenger-attachments/attachments/${ticket.attachment_id}/original`,
);
const hidden = await http<ApiErrorBody>(
`/api/v1/attachments/${ticket.attachment_id}`,
{ headers: bearer(bob.token) },
);
expectError(hidden, 404, 'not_found');
expectError(
await postMessage(alice.token, chatId, {
text: '',
attachment_ids: [ticket.attachment_id],
}),
404,
'not_found',
);
expectError(
await complete(alice.token, ticket.attachment_id),
409,
'conflict',
);
expect((await put(ticket, png)).status).toBe(200);
expectError(
await complete(bob.token, ticket.attachment_id),
404,
'not_found',
);
expectError(
await complete(eve.token, ticket.attachment_id),
404,
'not_found',
);
const done = await complete(alice.token, ticket.attachment_id);
expect(done.response.status).toBe(200);
expect(done.body).toMatchObject({
id: ticket.attachment_id,
owner_id: alice.user.id,
content_type: 'image/png',
size_bytes: png.length,
sha256: sha256(png),
status: 'ready',
});
const again = await complete(alice.token, ticket.attachment_id);
expect(again.response.status).toBe(200);
expect(again.body).toEqual(done.body);
const content = await download(bob.token, ticket.attachment_id);
expect(content.response.status).toBe(200);
expect(content.bytes.equals(png)).toBe(true);
const sent = await postMessage(alice.token, chatId, {
text: '',
attachment_ids: [ticket.attachment_id],
});
expect(sent.response.status).toBe(201);
expect(sent.body.attachment_ids).toEqual([ticket.attachment_id]);
});
it('answers 200 to every parallel complete of one upload', async () => {
const ticket = await initOk(png);
expect((await put(ticket, png)).status).toBe(200);
const results = await Promise.all(
Array.from({ length: 4 }, () =>
complete(alice.token, ticket.attachment_id),
),
);
expect(results.map((result) => result.response.status)).toEqual([
200, 200, 200, 200,
]);
for (const result of results)
expect(result.body.id).toBe(ticket.attachment_id);
});
it('rejects invalid declarations', async () => {
const base = declaration(png);
expectError(await init(eve.token, chatId, base), 404, 'not_found');
expectError(
await init(alice.token, chatId, { ...base, size_bytes: MAX + 1 }),
413,
'payload_too_large',
);
expectError(
await init(alice.token, chatId, {
...base,
content_type: 'image/gif',
}),
415,
'unsupported_media_type',
);
for (const bad of [
{ ...base, extra: true },
{ ...base, sha256: 'ABC' },
{ ...base, size_bytes: 0 },
{ ...base, filename: 'a/b.png' },
])
expectError(
await init(alice.token, chatId, bad),
400,
'invalid_request',
);
});
it('lets the storage refuse bytes that differ from the declaration', async () => {
const ticket = await initOk(png);
const tampered = Buffer.from(png);
tampered[1000] ^= 1;
const refused = await put(ticket, tampered);
expect(refused.status).toBe(400);
expect(await refused.text()).toContain('XAmzContentChecksumMismatch');
// No object was created, so the upload can still be finished.
expectError(
await complete(alice.token, ticket.attachment_id),
409,
'conflict',
);
expect((await put(ticket, png)).status).toBe(200);
expect(
(await complete(alice.token, ticket.attachment_id)).response.status,
).toBe(200);
const longer = await initOk(png);
const wrongLength = await put(
longer,
Buffer.concat([png, Buffer.from('x')]),
);
expect(wrongLength.status).toBe(403);
});
it('rejects a declared PNG that is really a JPEG, then forgets the claim', async () => {
const ticket = await initOk(jpeg, 'image/png');
expect((await put(ticket, jpeg)).status).toBe(200);
expectError(
await complete(alice.token, ticket.attachment_id),
415,
'unsupported_media_type',
);
expectError(
await complete(alice.token, ticket.attachment_id),
404,
'not_found',
);
// The URL is still valid: a re-PUT must stay tracked so the sweeper
// removes the new object too.
expect((await put(ticket, jpeg)).status).toBe(200);
const row = await db.query<{ status: string }>(
'SELECT status FROM attachments WHERE id = $1',
[ticket.attachment_id],
);
expect(row.rows[0]?.status).toBe('rejected');
expectError(
await complete(alice.token, ticket.attachment_id),
404,
'not_found',
);
});
it.each([
['truncated PNG', () => png.subarray(0, png.length - 100)],
[
'PNG damaged after the first 64 KiB',
() => {
const data = noisePng(1_048_576);
data[700_000] ^= 0xff;
return data;
},
],
])('rejects a %s even with a matching checksum', async (_name, make) => {
// The declaration and the signed checksum match the bytes exactly:
// only a check of the whole image can tell they are not an image.
const data = make();
const ticket = await initOk(data);
expect((await put(ticket, data)).status).toBe(200);
expectError(
await complete(alice.token, ticket.attachment_id),
415,
'unsupported_media_type',
);
expectError(
await complete(alice.token, ticket.attachment_id),
404,
'not_found',
);
});
it('rejects a pixel bomb on complete', async () => {
const bomb = pixelBombPng();
const ticket = await initOk(bomb);
expect((await put(ticket, bomb)).status).toBe(200);
expectError(
await complete(alice.token, ticket.attachment_id),
413,
'payload_too_large',
);
expectError(
await complete(alice.token, ticket.attachment_id),
404,
'not_found',
);
});
it('limits unfinished direct uploads per user', async () => {
const spammer = await actor();
const chat = (await createChat(spammer, [])).id;
for (let index = 0; index < 10; index += 1) {
const ok = await init(spammer.token, chat, declaration(png));
expect(ok.response.status).toBe(201);
}
const limited = await init(spammer.token, chat, declaration(png));
expectError(limited, 429, 'rate_limited');
expect(
Number(limited.response.headers.get('retry-after')),
).toBeGreaterThan(0);
});
it.runIf(shortTtl)(
'refuses an expired URL and removes the claim',
async () => {
const ticket = await initOk(png);
const expiresAt = Date.parse(ticket.expires_at);
await sleep(Math.max(0, expiresAt - Date.now()) + 2000);
expect((await put(ticket, png)).status).toBe(403);
const deadline = Date.now() + 15_000;
for (;;) {
const rows = await db.query(
'SELECT 1 FROM attachments WHERE id = $1',
[ticket.attachment_id],
);
if (rows.rowCount === 0) break;
expect(Date.now()).toBeLessThan(deadline);
await sleep(250);
}
expectError(
await complete(alice.token, ticket.attachment_id),
404,
'not_found',
);
},
60_000,
);
});