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>
This commit is contained in:
DerSchandfleckandClaude Fable 5.2 committed 2026-11-16 00:59:41 +01:00
1 parent 51ff6f9d40
commit 278194b707
31 files changed
+5099

No files matched your search

+714
View File
@@ -0,0 +1,714 @@
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);
});