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:
1 parent
51ff6f9d40
commit
278194b707
31 files changed
+5099
No files matched your search
@@ -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 & <Seite>'), '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);
|
||||
});
|
||||
Reference in new issue
Block a user