Hochladen mit Upload-Code, kurzer Link zum Herunterladen, automatische Löschung nach Ablauf der Frist. Node.js ohne zusätzliche Pakete. - src/: HTTP-Server, Ablage auf der Platte, Zugriffsbegrenzung - pages/, public/: Oberfläche in Deutsch und Englisch - tools/: Transfers auflisten und löschen - test/: 34 automatische Tests - Dockerfile, compose.yaml: Betrieb als Container auf 127.0.0.1:8083 Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
130 lines
4.7 KiB
JavaScript
130 lines
4.7 KiB
JavaScript
// 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));
|