// Gemeinsames für die Tests: eine frische Instanz mit eigenem Datenordner. import { randomBytes } from 'node:crypto'; import fs from 'node:fs/promises'; import http from 'node:http'; import os from 'node:os'; import path from 'node:path'; import { createApp } from '../src/app.js'; import { loadConfig } from '../src/config.js'; export const rootDir = path.resolve(import.meta.dirname, '..'); export const CODE = 'test-code-123'; export async function startApp(env = {}, { dataDir } = {}) { const dir = dataDir ?? (await fs.mkdtemp(path.join(os.tmpdir(), 'filetransfer-test-'))); const config = loadConfig( { DATA_DIR: dir, HOST: '127.0.0.1', PORT: '0', UPLOAD_CODES: `test:${CODE}`, CHUNK_SIZE: '256KB', ...env }, { rootDir }, ); const logs = []; const app = await createApp(config, { log: (message) => logs.push(message) }); const address = await app.listen(); return { app, config, logs, dataDir: dir, base: `http://127.0.0.1:${address.port}`, port: address.port, /** Beendet den Server; der Datenordner bleibt nur mit keepData erhalten. */ async stop({ keepData = false } = {}) { await app.close({ graceMs: 200 }); if (!keepData) await fs.rm(dir, { recursive: true, force: true }); }, }; } export function randomFile(name, size) { return { name, data: randomBytes(size) }; } export async function createTransfer(base, files, extra = {}, headers = {}) { const res = await fetch(`${base}/api/transfers`, { method: 'POST', headers: { 'Content-Type': 'application/json', ...headers }, body: JSON.stringify({ code: CODE, files: files.map((file) => ({ name: file.name, size: file.data.length })), ...extra, }), }); return { res, body: await res.json() }; } export async function putChunk(base, transfer, index, offset, data, token = transfer.uploadToken) { const res = await fetch(`${base}/api/transfers/${transfer.id}/files/${index}?offset=${offset}`, { method: 'PUT', headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/octet-stream' }, body: data, }); return { res, body: await res.json().catch(() => null) }; } export async function finish(base, transfer, token = transfer.uploadToken) { const res = await fetch(`${base}/api/transfers/${transfer.id}/finish`, { method: 'POST', headers: { Authorization: `Bearer ${token}` }, }); return { res, body: await res.json().catch(() => null) }; } /** Legt einen Transfer an, lädt alles stückweise hoch und schließt ihn ab. */ export async function uploadAll(base, files, extra = {}) { const { res, body: transfer } = await createTransfer(base, files, extra); if (res.status !== 201) throw new Error(`Anlegen fehlgeschlagen: ${res.status} ${JSON.stringify(transfer)}`); for (let index = 0; index < files.length; index++) { const { data } = files[index]; for (let offset = 0; offset < data.length; ) { const piece = data.subarray(offset, offset + transfer.chunkBytes); const result = await putChunk(base, transfer, index, offset, piece); if (result.res.status !== 200) throw new Error(`Stück fehlgeschlagen: ${result.res.status}`); offset = result.body.received; } } const done = await finish(base, transfer); if (done.res.status !== 200) throw new Error(`Abschließen fehlgeschlagen: ${done.res.status}`); return { ...transfer, expiresAt: done.body.expiresAt }; } /** * Anfrage auf unterster Ebene, um Sonderfälle nachzustellen: `declaredLength` * kündigt mehr an, als `body` liefert; mit `abort` wird danach getrennt. */ export function rawRequest(port, { method, path: target, headers = {}, body, declaredLength, abort = false }) { return new Promise((resolve, reject) => { const req = http.request({ host: '127.0.0.1', port, method, path: target, headers: { ...headers, ...(declaredLength !== undefined ? { 'Content-Length': declaredLength } : {}) }, }); req.on('response', (res) => { const chunks = []; res.on('data', (chunk) => chunks.push(chunk)); res.on('end', () => { const text = Buffer.concat(chunks).toString('utf8'); let json = null; try { json = JSON.parse(text); } catch { json = null; } resolve({ status: res.statusCode, headers: res.headers, text, json }); }); }); req.on('error', (err) => (abort ? resolve({ aborted: true }) : reject(err))); if (body) req.write(body); if (abort) { setTimeout(() => { req.destroy(); resolve({ aborted: true }); }, 100); } else if (declaredLength === undefined || (body?.length ?? 0) >= declaredLength) { req.end(); } }); } export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));