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 & ' }); 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); });