Files
DerSchandfleckandClaude Fable 5.2 278194b707 Dateitransfer: Server, Seiten, Tests und Docker-Dateien
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>
2026-11-16 00:59:41 +01:00

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));