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

715 lines
31 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import assert from 'node:assert/strict';
import fs from 'node:fs/promises';
import path from 'node:path';
import { Readable } from 'node:stream';
import { test } from 'node:test';
import {
CODE,
createTransfer,
finish,
putChunk,
randomFile,
rawRequest,
sleep,
startApp,
uploadAll,
} from './helpers.js';
const JSON_HEADERS = { 'Content-Type': 'application/json' };
test('Seiten und statische Dateien', async (t) => {
const ctx = await startApp({ SITE_NAME: 'Test & <Seite>' });
t.after(() => ctx.stop());
const home = await fetch(`${ctx.base}/`);
assert.equal(home.status, 200);
assert.match(home.headers.get('content-type'), /^text\/html/);
const html = await home.text();
assert.ok(html.includes('Test &amp; &lt;Seite&gt;'), 'Seitenname wird maskiert eingesetzt');
assert.equal(html.includes('{{'), false, 'keine Platzhalter übrig');
// Schutz-Header auf jeder Antwort
assert.match(home.headers.get('content-security-policy'), /default-src 'none'/);
assert.equal(home.headers.get('x-content-type-options'), 'nosniff');
assert.equal(home.headers.get('x-frame-options'), 'DENY');
assert.equal(home.headers.get('referrer-policy'), 'no-referrer');
// Unveränderte Seite: 304 statt erneuter Übertragung
const again = await fetch(`${ctx.base}/`, { headers: { 'If-None-Match': home.headers.get('etag') } });
assert.equal(again.status, 304);
const css = await fetch(`${ctx.base}/css/style.css`);
assert.equal(css.status, 200);
assert.match(css.headers.get('content-type'), /^text\/css/);
const js = await fetch(`${ctx.base}/js/upload.js`);
assert.match(js.headers.get('content-type'), /^text\/javascript/);
assert.equal((await fetch(`${ctx.base}/favicon.svg`)).headers.get('content-type'), 'image/svg+xml');
assert.match(await (await fetch(`${ctx.base}/robots.txt`)).text(), /Disallow: \//);
const head = await fetch(`${ctx.base}/`, { method: 'HEAD' });
assert.equal(head.status, 200);
assert.equal(await head.text(), '');
const missing = await fetch(`${ctx.base}/gibt-es-nicht`);
assert.equal(missing.status, 404);
assert.match(await missing.text(), /Seite nicht gefunden/);
const apiMissing = await fetch(`${ctx.base}/api/gibt-es-nicht`);
assert.equal(apiMissing.status, 404);
assert.deepEqual(await apiMissing.json(), { error: 'not_found' });
const wrongMethod = await fetch(`${ctx.base}/`, { method: 'POST' });
assert.equal(wrongMethod.status, 405);
assert.equal(wrongMethod.headers.get('allow'), 'GET, HEAD');
assert.equal((await fetch(`${ctx.base}/healthz`)).status, 200);
});
test('Pfade außerhalb von public/ sind nicht erreichbar', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
for (const target of [
'/../server.js',
'/css/../../server.js',
'/css/%2e%2e/%2e%2e/server.js',
'/..%2f.env',
'/.env',
'/server.js',
'/src/app.js',
'/pages/index.html',
'/index.html',
'//etc/passwd',
]) {
const res = await rawRequest(ctx.port, { method: 'GET', path: target });
assert.equal(res.status, 404, target);
}
});
test('Einstellungen für die Oberfläche', async (t) => {
const ctx = await startApp({ MAX_TRANSFER_SIZE: '10MB', MAX_FILES: '5', EXPIRY_DAYS: '1,3' });
t.after(() => ctx.stop());
const res = await fetch(`${ctx.base}/api/config`);
assert.equal(res.headers.get('cache-control'), 'no-store');
assert.deepEqual(await res.json(), {
uploadsEnabled: true,
codeRequired: true,
maxTransferBytes: 10 * 1024 ** 2,
maxFiles: 5,
expiryDays: [1, 3],
defaultExpiryDays: 1,
});
});
test('Hochladen in Stücken, abrufen und herunterladen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const files = [
randomFile('Urlaub 2026 – Ägäis (1).jpg', 700_000), // drei Stücke
randomFile('leer.txt', 0),
randomFile('../../boese/pfad.bin', 1234),
];
const transfer = await uploadAll(ctx.base, files, { expiryDays: 1 });
assert.match(transfer.id, /^[2-9a-hjkmnp-z]{10}$/);
const expectedExpiry = Date.now() + 86_400_000;
assert.ok(Math.abs(transfer.expiresAt - expectedExpiry) < 10_000);
const info = await (await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).json();
assert.equal(info.id, transfer.id);
assert.equal(info.totalBytes, 701_234);
assert.deepEqual(info.files, [
{ name: 'Urlaub 2026 – Ägäis (1).jpg', size: 700_000 },
{ name: 'leer.txt', size: 0 },
{ name: 'pfad.bin', size: 1234 },
]);
assert.equal('deleteTokenHash' in info || 'uploadTokenHash' in info, false);
// Auf der Platte liegen nur Nummern, keine Namen der Nutzer
const stored = (await fs.readdir(path.join(ctx.dataDir, 'transfers', transfer.id))).sort();
assert.deepEqual(stored, ['0', '1', '2', 'meta.json']);
for (let index = 0; index < files.length; index++) {
const res = await fetch(`${ctx.base}/d/${transfer.id}/${index}`);
assert.equal(res.status, 200);
assert.equal(res.headers.get('content-type'), 'application/octet-stream');
assert.equal(res.headers.get('x-content-type-options'), 'nosniff');
assert.match(res.headers.get('content-security-policy'), /sandbox/);
assert.match(res.headers.get('content-disposition'), /^attachment; /);
assert.equal(res.headers.get('content-length'), String(files[index].data.length));
assert.deepEqual(Buffer.from(await res.arrayBuffer()), files[index].data);
}
const disposition = (await fetch(`${ctx.base}/d/${transfer.id}/0`, { method: 'HEAD' })).headers.get(
'content-disposition',
);
assert.ok(disposition.includes("filename*=UTF-8''Urlaub%202026%20%E2%80%93%20%C3%84g%C3%A4is%20%281%29.jpg"));
// Teilabrufe (zum Fortsetzen abgebrochener Downloads)
const data = files[0].data;
const part = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=100-199' } });
assert.equal(part.status, 206);
assert.equal(part.headers.get('content-range'), `bytes 100-199/${data.length}`);
assert.deepEqual(Buffer.from(await part.arrayBuffer()), data.subarray(100, 200));
const tail = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=-50' } });
assert.equal(tail.status, 206);
assert.deepEqual(Buffer.from(await tail.arrayBuffer()), data.subarray(data.length - 50));
const rest = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=699990-' } });
assert.equal(rest.status, 206);
assert.deepEqual(Buffer.from(await rest.arrayBuffer()), data.subarray(699_990));
const beyond = await fetch(`${ctx.base}/d/${transfer.id}/0`, { headers: { Range: 'bytes=700000-' } });
assert.equal(beyond.status, 416);
assert.equal(beyond.headers.get('content-range'), `bytes */${data.length}`);
const stale = await fetch(`${ctx.base}/d/${transfer.id}/0`, {
headers: { Range: 'bytes=0-9', 'If-Range': '"anderer-stand"' },
});
assert.equal(stale.status, 200, 'veralteter If-Range liefert die ganze Datei');
await stale.arrayBuffer();
// Datei-Nummern außerhalb der Liste
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/3`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/meta.json`)).status, 404);
// Download-Seite; die Kennung gilt auch in Großbuchstaben
const page = await fetch(`${ctx.base}/d/${transfer.id}`);
assert.equal(page.status, 200);
assert.match(await page.text(), /data-state="loading"/);
assert.equal(page.headers.get('x-robots-tag'), 'noindex, nofollow');
assert.equal((await fetch(`${ctx.base}/d/${transfer.id.toUpperCase()}`)).status, 200);
assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id.toUpperCase()}`)).status, 200);
assert.ok(ctx.logs.some((line) => line.includes(`Transfer ${transfer.id} angelegt`) && line.includes('"test"')));
assert.equal(ctx.logs.some((line) => line.includes(CODE)), false, 'der Code selbst steht nie im Protokoll');
});
test('Ohne gültigen Upload-Code wird nichts angelegt', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('a.txt', 10);
const none = await createTransfer(ctx.base, [file], { code: undefined });
assert.equal(none.res.status, 401);
assert.equal(none.body.error, 'code_required');
const wrong = await createTransfer(ctx.base, [file], { code: 'falsch' });
assert.equal(wrong.res.status, 401);
assert.equal(wrong.body.error, 'code_invalid');
const padded = await createTransfer(ctx.base, [file], { code: ` ${CODE}\n` });
assert.equal(padded.res.status, 201, 'Leerzeichen um den Code stören nicht');
assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 1);
});
test('Zu viele falsche Codes sperren die Adresse vorübergehend', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('a.txt', 10);
for (let i = 0; i < 10; i++) {
assert.equal((await createTransfer(ctx.base, [file], { code: `falsch-${i}` })).res.status, 401);
}
const blocked = await createTransfer(ctx.base, [file]);
assert.equal(blocked.res.status, 429);
assert.equal(blocked.body.error, 'rate_limited');
assert.ok(Number(blocked.res.headers.get('retry-after')) > 0);
assert.equal(blocked.body.retryAfter, Number(blocked.res.headers.get('retry-after')));
});
test('Hinter einem Proxy zählt die weitergereichte Adresse', async (t) => {
const direct = await startApp();
const proxied = await startApp({ TRUST_PROXY: '1' });
t.after(() => Promise.all([direct.stop(), proxied.stop()]));
const file = randomFile('a.txt', 10);
// Mit TRUST_PROXY wird je weitergereichter Adresse gezählt …
for (let i = 0; i < 10; i++) {
await createTransfer(proxied.base, [file], { code: 'falsch' }, { 'X-Forwarded-For': '198.51.100.1' });
}
const sameIp = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '198.51.100.1' });
assert.equal(sameIp.res.status, 429);
const otherIp = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '198.51.100.2' });
assert.equal(otherIp.res.status, 201);
// … und nur der letzte Eintrag gilt, den der eigene Proxy angehängt hat.
const spoofed = await createTransfer(proxied.base, [file], {}, { 'X-Forwarded-For': '203.0.113.9, 198.51.100.1' });
assert.equal(spoofed.res.status, 429);
// Ohne TRUST_PROXY lässt sich die Sperre nicht mit dem Header umgehen.
for (let i = 0; i < 10; i++) {
await createTransfer(direct.base, [file], { code: 'falsch' }, { 'X-Forwarded-For': `198.51.100.${i}` });
}
const stillBlocked = await createTransfer(direct.base, [file], {}, { 'X-Forwarded-For': '203.0.113.50' });
assert.equal(stillBlocked.res.status, 429);
});
test('Grenzen und fehlerhafte Anfragen', async (t) => {
const ctx = await startApp({ MAX_TRANSFER_SIZE: '1MB', MAX_FILES: '3' });
t.after(() => ctx.stop());
const post = (body, headers = JSON_HEADERS) =>
fetch(`${ctx.base}/api/transfers`, { method: 'POST', headers, body });
const error = async (res) => (await res.json()).error;
const tooLarge = await post(JSON.stringify({ code: CODE, files: [{ name: 'a', size: 1024 ** 2 + 1 }] }));
assert.equal(tooLarge.status, 413);
assert.deepEqual(await tooLarge.json(), { error: 'too_large', maxBytes: 1024 ** 2 });
const sumTooLarge = await post(
JSON.stringify({ code: CODE, files: [{ name: 'a', size: 600_000 }, { name: 'b', size: 600_000 }] }),
);
assert.equal(sumTooLarge.status, 413);
const tooMany = await post(
JSON.stringify({ code: CODE, files: Array.from({ length: 4 }, (_, i) => ({ name: `f${i}`, size: 1 })) }),
);
assert.equal(tooMany.status, 413);
assert.deepEqual(await tooMany.json(), { error: 'too_many_files', maxFiles: 3 });
for (const files of [
undefined,
[],
'text',
[{ name: 'a' }],
[{ name: 'a', size: -1 }],
[{ name: 'a', size: 1.5 }],
[{ name: 'a', size: '5' }],
[{ name: 5, size: 5 }],
[{ name: 'x'.repeat(2000), size: 5 }],
[null],
]) {
const res = await post(JSON.stringify({ code: CODE, files }));
assert.equal(res.status, 400, JSON.stringify(files)?.slice(0, 40));
}
const badExpiry = await post(JSON.stringify({ code: CODE, expiryDays: 365, files: [{ name: 'a', size: 1 }] }));
assert.equal(badExpiry.status, 400);
assert.equal(await error(await post('{kein json')), 'invalid_json');
assert.equal(await error(await post('[1,2]')), 'invalid_request');
const form = await post('code=x', { 'Content-Type': 'application/x-www-form-urlencoded' });
assert.equal(form.status, 415);
const huge = await rawRequest(ctx.port, {
method: 'POST',
path: '/api/transfers',
headers: JSON_HEADERS,
body: Buffer.from('{"code":"'),
declaredLength: 10_000_000,
});
assert.equal(huge.status, 413);
assert.equal(huge.json.error, 'body_too_large');
assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 0, 'nichts wurde angelegt');
});
test('Regeln beim stückweisen Hochladen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 400_000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
const chunk = transfer.chunkBytes;
assert.equal(chunk, 256 * 1024);
// Vor dem Abschluss ist nichts öffentlich sichtbar
assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 404);
// Falsches oder fehlendes Token
const foreign = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 10), transfer.deleteToken);
assert.equal(foreign.res.status, 403);
const noToken = await fetch(`${ctx.base}/api/transfers/${transfer.id}/files/0?offset=0`, {
method: 'PUT',
body: file.data.subarray(0, 10),
});
assert.equal(noToken.status, 403);
// Falsche Stelle: Der Server nennt den richtigen Stand
const ahead = await putChunk(ctx.base, transfer, 0, 5000, file.data.subarray(5000, 6000));
assert.equal(ahead.res.status, 409);
assert.deepEqual(ahead.body, { error: 'offset_mismatch', received: 0 });
// Zu großes Stück, unbekannte Datei, unsinnige Stelle
const oversized = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk + 1));
assert.equal(oversized.res.status, 413);
assert.equal((await putChunk(ctx.base, transfer, 1, 0, file.data.subarray(0, 10))).res.status, 404);
assert.equal((await putChunk(ctx.base, transfer, 0, 'abc', file.data.subarray(0, 10))).res.status, 400);
const first = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk));
assert.deepEqual(first.body, { received: chunk });
// Dasselbe Stück noch einmal: wird abgelehnt, nichts wird doppelt geschrieben
const repeat = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, chunk));
assert.equal(repeat.res.status, 409);
assert.equal(repeat.body.received, chunk);
// Mehr als zur Datei gehört
const overflow = await putChunk(ctx.base, transfer, 0, chunk, Buffer.alloc(400_000 - chunk + 1));
assert.equal(overflow.res.status, 413);
// Zu früh abschließen
const early = await finish(ctx.base, transfer);
assert.equal(early.res.status, 409);
assert.equal(early.body.error, 'incomplete');
const status = await fetch(`${ctx.base}/api/transfers/${transfer.id}/upload`, {
headers: { Authorization: `Bearer ${transfer.uploadToken}` },
});
assert.deepEqual(await status.json(), {
state: 'uploading',
expiresAt: null,
files: [{ size: 400_000, received: chunk }],
});
const last = await putChunk(ctx.base, transfer, 0, chunk, file.data.subarray(chunk));
assert.deepEqual(last.body, { received: 400_000 });
const done = await finish(ctx.base, transfer);
assert.equal(done.res.status, 200);
// Abschließen ist wiederholbar (falls die Antwort verloren ging)
const doneAgain = await finish(ctx.base, transfer);
assert.equal(doneAgain.res.status, 200);
assert.equal(doneAgain.body.expiresAt, done.body.expiresAt);
// Nach dem Abschluss lässt sich nichts mehr überschreiben
const late = await putChunk(ctx.base, transfer, 0, 400_000, Buffer.alloc(0));
assert.equal(late.res.status, 409);
assert.equal(late.body.error, 'not_uploading');
const download = await fetch(`${ctx.base}/d/${transfer.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data);
});
test('Fehlermeldung kommt an, auch wenn der Browser noch sendet', async (t) => {
// Große Stücke, damit der Körper nicht einfach in den Netzwerkpuffern verschwindet.
const ctx = await startApp({ CHUNK_SIZE: '8MB' });
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 9_000_000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
const headers = { Authorization: `Bearer ${transfer.uploadToken}`, 'Content-Type': 'application/octet-stream' };
// Stück an falscher Stelle: Die Antwort 409 muss trotz großem Körper lesbar sein.
const wrongPlace = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=1000`,
headers,
body: file.data.subarray(1000, 8_001_000),
declaredLength: 8_000_000,
});
assert.equal(wrongPlace.status, 409);
assert.deepEqual(wrongPlace.json, { error: 'offset_mismatch', received: 0 });
assert.notEqual(wrongPlace.headers.connection, 'close', 'die Verbindung bleibt nutzbar');
// Falsches Token: genauso
const forbidden = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=0`,
headers: { ...headers, Authorization: `Bearer ${'x'.repeat(43)}` },
body: file.data.subarray(0, 8_000_000),
declaredLength: 8_000_000,
});
assert.equal(forbidden.status, 403);
// Mehr angekündigt als erlaubt: Der Server wartet den Körper gar nicht erst ab.
const tooBig = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=0`,
headers,
body: file.data.subarray(0, 1000),
declaredLength: 500_000_000,
});
assert.equal(tooBig.status, 413);
assert.equal(tooBig.headers.connection, 'close');
// Danach funktioniert der Upload normal weiter.
const ok = await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 8 * 1024 ** 2));
assert.deepEqual(ok.body, { received: 8 * 1024 ** 2 });
});
test('Abgebrochenes Stück lässt sich wiederholen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 200_000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
// Verbindung reißt mitten im Stück ab
const aborted = await rawRequest(ctx.port, {
method: 'PUT',
path: `/api/transfers/${transfer.id}/files/0?offset=0`,
headers: { Authorization: `Bearer ${transfer.uploadToken}`, 'Content-Type': 'application/octet-stream' },
body: file.data.subarray(0, 50_000),
declaredLength: 200_000,
abort: true,
});
assert.equal(aborted.aborted, true);
// Der Server zählt das halbe Stück nicht und nimmt es danach vollständig an.
let retry;
for (let i = 0; i < 40; i++) {
retry = await putChunk(ctx.base, transfer, 0, 0, file.data);
if (retry.res.status !== 409 || retry.body.error !== 'busy') break;
await sleep(50);
}
assert.equal(retry.res.status, 200);
assert.deepEqual(retry.body, { received: 200_000 });
assert.equal((await finish(ctx.base, transfer)).res.status, 200);
const download = await fetch(`${ctx.base}/d/${transfer.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data);
});
test('Löschen nur mit dem Lösch-Token', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const transfer = await uploadAll(ctx.base, [randomFile('a.bin', 5000)]);
const dir = path.join(ctx.dataDir, 'transfers', transfer.id);
const del = (token) =>
fetch(`${ctx.base}/api/transfers/${transfer.id}`, {
method: 'DELETE',
headers: token ? { Authorization: `Bearer ${token}` } : {},
});
assert.equal((await del()).status, 403);
assert.equal((await del(transfer.uploadToken)).status, 403);
assert.equal((await del('x'.repeat(43))).status, 403);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 200);
assert.equal((await del(transfer.deleteToken)).status, 204);
assert.equal((await fetch(`${ctx.base}/api/transfers/${transfer.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 404);
await assert.rejects(fs.access(dir));
assert.equal((await del(transfer.deleteToken)).status, 404);
});
test('Ein angefangener Upload lässt sich verwerfen', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('a.bin', 5000);
const { body: transfer } = await createTransfer(ctx.base, [file]);
await putChunk(ctx.base, transfer, 0, 0, file.data.subarray(0, 1000));
const res = await fetch(`${ctx.base}/api/transfers/${transfer.id}`, {
method: 'DELETE',
headers: { Authorization: `Bearer ${transfer.deleteToken}` },
});
assert.equal(res.status, 204);
assert.equal((await putChunk(ctx.base, transfer, 0, 1000, file.data.subarray(1000))).res.status, 404);
assert.equal(ctx.app.store.size, 0);
});
test('Abgelaufene und liegen gebliebene Transfers werden entfernt', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const ready = await uploadAll(ctx.base, [randomFile('a.bin', 100)]);
const kept = await uploadAll(ctx.base, [randomFile('b.bin', 100)]);
const { body: unfinished } = await createTransfer(ctx.base, [randomFile('c.bin', 100)]);
const dirOf = (id) => path.join(ctx.dataDir, 'transfers', id);
// Frist abgelaufen: sofort nicht mehr abrufbar, auch vor dem Aufräumen
ctx.app.store.get(ready.id).expiresAt = Date.now() - 1;
assert.equal((await fetch(`${ctx.base}/api/transfers/${ready.id}`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${ready.id}/0`)).status, 404);
assert.equal((await fetch(`${ctx.base}/d/${ready.id}`)).status, 404);
// Upload, an dem lange nichts mehr passiert ist
ctx.app.store.get(unfinished.id).lastActivity = Date.now() - ctx.config.staleUploadMs - 1;
assert.equal(await ctx.app.store.sweep(), 2);
await assert.rejects(fs.access(dirOf(ready.id)));
await assert.rejects(fs.access(dirOf(unfinished.id)));
await fs.access(dirOf(kept.id));
assert.equal((await fetch(`${ctx.base}/d/${kept.id}/0`)).status, 200);
// Ordner von Hand gelöscht: Der Eintrag verschwindet beim nächsten Aufräumen
await fs.rm(dirOf(kept.id), { recursive: true });
assert.equal((await fetch(`${ctx.base}/d/${kept.id}/0`)).status, 404);
assert.equal(await ctx.app.store.sweep(), 1);
assert.equal(ctx.app.store.size, 0);
});
test('Nach einem Neustart ist alles wieder da', async (t) => {
const first = await startApp();
const files = [randomFile('fertig.bin', 300_000)];
const ready = await uploadAll(first.base, files);
const partial = randomFile('halb.bin', 600_000);
const { body: uploading } = await createTransfer(first.base, [partial]);
await putChunk(first.base, uploading, 0, 0, partial.data.subarray(0, 256 * 1024));
await first.stop({ keepData: true });
const second = await startApp({}, { dataDir: first.dataDir });
t.after(() => second.stop());
assert.equal(second.app.store.size, 2);
const download = await fetch(`${second.base}/d/${ready.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), files[0].data);
const info = await (await fetch(`${second.base}/api/transfers/${ready.id}`)).json();
assert.equal(info.expiresAt, ready.expiresAt);
// Der angefangene Upload geht an der alten Stelle weiter
const status = await fetch(`${second.base}/api/transfers/${uploading.id}/upload`, {
headers: { Authorization: `Bearer ${uploading.uploadToken}` },
});
assert.equal((await status.json()).files[0].received, 256 * 1024);
let offset = 256 * 1024;
while (offset < partial.data.length) {
const result = await putChunk(second.base, uploading, 0, offset, partial.data.subarray(offset, offset + 256 * 1024));
assert.equal(result.res.status, 200);
offset = result.body.received;
}
assert.equal((await finish(second.base, uploading)).res.status, 200);
const resumed = await fetch(`${second.base}/d/${uploading.id}/0`);
assert.deepEqual(Buffer.from(await resumed.arrayBuffer()), partial.data);
});
test('Beschädigte Ordner im Datenverzeichnis stören den Start nicht', async (t) => {
const first = await startApp();
const ready = await uploadAll(first.base, [randomFile('a.bin', 100)]);
await first.stop({ keepData: true });
const transfers = path.join(first.dataDir, 'transfers');
await fs.mkdir(path.join(transfers, 'abcdefgh23'));
await fs.writeFile(path.join(transfers, 'abcdefgh23', 'meta.json'), '{kaputt');
await fs.mkdir(path.join(transfers, 'bcdefgh234'));
await fs.writeFile(
path.join(transfers, 'bcdefgh234', 'meta.json'),
JSON.stringify({ v: 1, id: 'ein-anderer', state: 'ready', files: [] }),
);
await fs.mkdir(path.join(transfers, 'kein-transfer'));
await fs.writeFile(path.join(transfers, 'notiz.txt'), 'hallo');
const second = await startApp({}, { dataDir: first.dataDir });
t.after(() => second.stop());
assert.equal(second.app.store.size, 1);
assert.equal((await fetch(`${second.base}/d/${ready.id}/0`)).status, 200);
assert.equal(second.logs.filter((line) => line.includes('übersprungen')).length, 2);
assert.equal((await fetch(`${second.base}/d/abcdefgh23`)).status, 404);
});
test('Kennungen lassen sich nicht in großem Stil durchprobieren', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const transfer = await uploadAll(ctx.base, [randomFile('a.bin', 100)]);
for (let i = 0; i < 60; i++) {
const res = await fetch(`${ctx.base}/api/transfers/2222222222`);
assert.equal(res.status, 404);
}
const api = await fetch(`${ctx.base}/api/transfers/2222222222`);
assert.equal(api.status, 429);
assert.ok(Number(api.headers.get('retry-after')) > 0);
// Die Sperre gilt dann auch für Seiten und Dateien …
const page = await fetch(`${ctx.base}/d/${transfer.id}`);
assert.equal(page.status, 429);
await page.text();
assert.equal((await fetch(`${ctx.base}/d/${transfer.id}/0`)).status, 429);
// … aber nicht für die Startseite.
assert.equal((await fetch(`${ctx.base}/`)).status, 200);
});
test('Ohne Upload-Codes ist das Hochladen gesperrt', async (t) => {
const ctx = await startApp({ UPLOAD_CODES: '' });
t.after(() => ctx.stop());
const config = await (await fetch(`${ctx.base}/api/config`)).json();
assert.equal(config.uploadsEnabled, false);
const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)]);
assert.equal(res.res.status, 503);
assert.equal(res.body.error, 'uploads_disabled');
});
test('Mit OPEN_UPLOADS geht es ohne Code', async (t) => {
const ctx = await startApp({ UPLOAD_CODES: '', OPEN_UPLOADS: '1' });
t.after(() => ctx.stop());
const config = await (await fetch(`${ctx.base}/api/config`)).json();
assert.deepEqual([config.uploadsEnabled, config.codeRequired], [true, false]);
const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)], { code: undefined });
assert.equal(res.res.status, 201);
});
test('Mehrere Codes; jeder wird im Protokoll mit Namen geführt', async (t) => {
const ctx = await startApp({ UPLOAD_CODES: 'anna:annas-geheimnis,ben:bens-geheimnis' });
t.after(() => ctx.stop());
const file = randomFile('a.txt', 10);
assert.equal((await createTransfer(ctx.base, [file], { code: 'annas-geheimnis' })).res.status, 201);
assert.equal((await createTransfer(ctx.base, [file], { code: 'bens-geheimnis' })).res.status, 201);
assert.equal((await createTransfer(ctx.base, [file], { code: 'anna' })).res.status, 401);
assert.equal((await createTransfer(ctx.base, [file], { code: 'anna:annas-geheimnis' })).res.status, 401);
assert.ok(ctx.logs.some((line) => line.includes('Code "anna"')));
assert.ok(ctx.logs.some((line) => line.includes('Code "ben"')));
});
test('Das Speicherkontingent wird eingehalten', async (t) => {
const ctx = await startApp({ STORAGE_QUOTA: '1MB', MIN_FREE_SPACE: '0' });
t.after(() => ctx.stop());
const post = (size) =>
fetch(`${ctx.base}/api/transfers`, {
method: 'POST',
headers: JSON_HEADERS,
body: JSON.stringify({ code: CODE, files: [{ name: 'a.bin', size }] }),
});
const first = await post(700_000);
assert.equal(first.status, 201);
const second = await post(400_000);
assert.equal(second.status, 507);
assert.deepEqual(await second.json(), { error: 'storage_full' });
assert.equal((await post(300_000)).status, 201);
// Nach dem Löschen ist der Platz wieder frei
const transfer = await first.json();
await fetch(`${ctx.base}/api/transfers/${transfer.id}`, {
method: 'DELETE',
headers: { Authorization: `Bearer ${transfer.deleteToken}` },
});
assert.equal((await post(700_000)).status, 201);
});
test('Zu wenig freier Plattenplatz wird vorher bemerkt', async (t) => {
// Verlangt mehr freien Platz, als irgendeine Platte hat.
const ctx = await startApp({ MIN_FREE_SPACE: '900000TB' });
t.after(() => ctx.stop());
const res = await createTransfer(ctx.base, [randomFile('a.txt', 10)]);
assert.equal(res.res.status, 507);
assert.equal((await fs.readdir(path.join(ctx.dataDir, 'transfers'))).length, 0);
});
test('Gleichzeitige Uploads kommen sich nicht in die Quere', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const sets = Array.from({ length: 6 }, (_, i) => [randomFile(`a${i}.bin`, 300_000 + i), randomFile(`b${i}.bin`, 1000 + i)]);
const transfers = await Promise.all(sets.map((files) => uploadAll(ctx.base, files)));
assert.equal(new Set(transfers.map((tr) => tr.id)).size, 6);
await Promise.all(
transfers.map(async (transfer, i) => {
for (let index = 0; index < 2; index++) {
const res = await fetch(`${ctx.base}/d/${transfer.id}/${index}`);
assert.deepEqual(Buffer.from(await res.arrayBuffer()), sets[i][index].data);
}
}),
);
});
test('Eine abgerissene Verbindung blockiert die Datei nicht', async (t) => {
const ctx = await startApp();
t.after(() => ctx.stop());
const file = randomFile('daten.bin', 1000);
const { body: created } = await createTransfer(ctx.base, [file]);
const transfer = ctx.app.store.get(created.id);
// Verbindung ist schon weg, bevor das Schreiben beginnt
const gone = new Readable({ read() {} });
gone.destroy();
await assert.rejects(ctx.app.store.writeChunk(transfer, 0, 0, gone, 1000));
// Verbindung reißt mitten im Schreiben ab
const breaking = new Readable({ read() {} });
const pending = ctx.app.store.writeChunk(transfer, 0, 0, breaking, 1000);
breaking.push(file.data.subarray(0, 400));
await sleep(20);
breaking.destroy();
await assert.rejects(pending);
assert.equal(transfer.files[0].received, 0);
assert.equal(transfer.files[0].busy, false);
// Danach lässt sich die Datei ganz normal hochladen
const ok = await putChunk(ctx.base, created, 0, 0, file.data);
assert.deepEqual(ok.body, { received: 1000 });
assert.equal((await finish(ctx.base, created)).res.status, 200);
const download = await fetch(`${ctx.base}/d/${created.id}/0`);
assert.deepEqual(Buffer.from(await download.arrayBuffer()), file.data);
});