Files
FileTransfer/test/units.test.js
T
DerSchandfleckandClaude Fable 5.2 278194b707 Dateitransfer: Server, Seiten, Tests und Docker-Dateien
Hochladen mit Upload-Code, kurzer Link zum Herunterladen, automatische
Löschung nach Ablauf der Frist. Node.js ohne zusätzliche Pakete.

- src/: HTTP-Server, Ablage auf der Platte, Zugriffsbegrenzung
- pages/, public/: Oberfläche in Deutsch und Englisch
- tools/: Transfers auflisten und löschen
- test/: 34 automatische Tests
- Dockerfile, compose.yaml: Betrieb als Container auf 127.0.0.1:8083

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-16 00:59:41 +01:00

132 lines
6.3 KiB
JavaScript

import assert from 'node:assert/strict';
import { test } from 'node:test';
import { loadConfig, parseCodes, parseSize } from '../src/config.js';
import { RateLimiter } from '../src/limiter.js';
import { ID_PATTERN, contentDisposition, hashEquals, ipKey, randomId, sanitizeName, sha256 } from '../src/util.js';
test('parseSize versteht übliche Schreibweisen', () => {
assert.equal(parseSize('1024'), 1024);
assert.equal(parseSize('1KB'), 1024);
assert.equal(parseSize('8 MB'), 8 * 1024 ** 2);
assert.equal(parseSize('5GB'), 5 * 1024 ** 3);
assert.equal(parseSize('5GiB'), 5 * 1024 ** 3);
assert.equal(parseSize('1,5g'), 1.5 * 1024 ** 3);
assert.throws(() => parseSize('viel'));
assert.throws(() => parseSize('5 XB'));
assert.throws(() => parseSize('-5GB'));
});
test('parseCodes liest Namen und Codes, behält aber nur Hashes', () => {
const codes = parseCodes('freunde:apfel-kuchen-73, anna:kurz\nohne-namen-123');
assert.deepEqual(
codes.map((c) => c.label),
['freunde', 'anna', 'code3'],
);
assert.equal(codes[0].hash, sha256('apfel-kuchen-73'));
assert.equal(codes[0].short, false);
assert.equal(codes[1].short, true);
assert.equal(JSON.stringify(codes).includes('apfel'), false);
assert.deepEqual(parseCodes(''), []);
assert.throws(() => parseCodes('a:eins-zwei-drei,a:vier-fuenf-sechs'), /doppelt/);
assert.throws(() => parseCodes('name:'), /fehlt/);
});
test('loadConfig setzt Vorgaben und meldet Unsinn', () => {
const cfg = loadConfig({}, { rootDir: '/srv/app' });
assert.equal(cfg.port, 8083);
assert.equal(cfg.host, '127.0.0.1');
assert.equal(cfg.dataDir, '/srv/app/data');
assert.deepEqual(cfg.expiryDays, [1, 7, 30]);
assert.equal(cfg.defaultExpiryDays, 7);
assert.equal(cfg.openUploads, false);
assert.deepEqual(cfg.codes, []);
assert.equal(loadConfig({ DATA_DIR: '/var/x' }, { rootDir: '/srv/app' }).dataDir, '/var/x');
assert.deepEqual(loadConfig({ EXPIRY_DAYS: '30, 3,3' }, { rootDir: '/' }).expiryDays, [3, 30]);
assert.equal(loadConfig({ EXPIRY_DAYS: '3,30' }, { rootDir: '/' }).defaultExpiryDays, 3);
assert.throws(() => loadConfig({ PORT: 'abc' }, { rootDir: '/' }), /PORT/);
assert.throws(() => loadConfig({ EXPIRY_DAYS: '0' }, { rootDir: '/' }), /EXPIRY_DAYS/);
assert.throws(() => loadConfig({ DEFAULT_EXPIRY_DAYS: '5' }, { rootDir: '/' }), /DEFAULT_EXPIRY_DAYS/);
assert.throws(() => loadConfig({ MAX_TRANSFER_SIZE: 'riesig' }, { rootDir: '/' }), /MAX_TRANSFER_SIZE/);
assert.throws(() => loadConfig({ CHUNK_SIZE: '1GB' }, { rootDir: '/' }), /CHUNK_SIZE/);
});
test('randomId passt zum Muster', () => {
for (let i = 0; i < 200; i++) assert.match(randomId(), ID_PATTERN);
assert.equal(ID_PATTERN.test('abcdefghi1'), false); // enthält i und 1
assert.equal(ID_PATTERN.test('../../etc'), false);
});
test('hashEquals vergleicht nur gleich lange, gültige Hashes', () => {
assert.equal(hashEquals(sha256('a'), sha256('a')), true);
assert.equal(hashEquals(sha256('a'), sha256('b')), false);
assert.equal(hashEquals('', ''), false);
assert.equal(hashEquals(sha256('a'), 'abcd'), false);
});
test('ipKey fasst IPv6-Adressen zu /64-Netzen zusammen', () => {
assert.equal(ipKey('203.0.113.7'), '203.0.113.7');
assert.equal(ipKey('::ffff:203.0.113.7'), '203.0.113.7');
assert.equal(ipKey('2001:db8:1:2:aaaa:bbbb:cccc:dddd'), '2001:db8:1:2::/64');
assert.equal(ipKey('2001:db8:1:2::1'), '2001:db8:1:2::/64');
assert.equal(ipKey('2001:0db8:0001:0002::ffff'), '2001:db8:1:2::/64');
assert.equal(ipKey('2001:db8::1'), '2001:db8:0:0::/64');
assert.equal(ipKey('::1'), '0:0:0:0::/64');
assert.equal(ipKey('fe80::1%eth0'), 'fe80:0:0:0::/64');
assert.equal(ipKey('quatsch'), 'unbekannt');
assert.equal(ipKey(undefined), 'unbekannt');
});
test('sanitizeName entschärft Dateinamen', () => {
assert.equal(sanitizeName('urlaub.jpg'), 'urlaub.jpg');
assert.equal(sanitizeName('../../etc/passwd'), 'passwd');
assert.equal(sanitizeName('C:\\Users\\x\\bild.png'), 'bild.png');
assert.equal(sanitizeName(' a\tb\n.txt '), 'a b .txt');
assert.equal(sanitizeName('zeile\u0000null.txt'), 'zeilenull.txt');
assert.equal(sanitizeName('rechnung\u202Efdp.exe'), 'rechnungfdp.exe'); // versteckte Richtungsumkehr
assert.equal(sanitizeName(''), 'datei');
assert.equal(sanitizeName('..'), 'datei');
assert.equal(sanitizeName('ordner/'), 'datei');
assert.equal(sanitizeName('Ä-ö-ü ß.pdf'), 'Ä-ö-ü ß.pdf');
assert.equal(sanitizeName('a\u0308.txt'), 'ä.txt'); // zusammengesetzt -> ein Zeichen
assert.equal(sanitizeName('kaputt\ud800.txt'), 'kaputt\ufffd.txt');
const long = sanitizeName(`${'ä'.repeat(400)}.tar.gz`);
assert.ok(Buffer.byteLength(long) <= 200);
assert.ok(long.endsWith('.gz'));
assert.ok(Buffer.byteLength(sanitizeName('x'.repeat(1000))) <= 200);
});
test('contentDisposition kodiert Sonderzeichen sicher', () => {
assert.equal(contentDisposition('bild.png'), `attachment; filename="bild.png"; filename*=UTF-8''bild.png`);
assert.equal(
contentDisposition('Über "uns" (1).pdf'),
`attachment; filename="_ber _uns_ (1).pdf"; filename*=UTF-8''%C3%9Cber%20%22uns%22%20%281%29.pdf`,
);
// Kein Zeilenumbruch und kein Anführungszeichen darf den Header aufbrechen.
const header = contentDisposition('a"\r\nSet-Cookie: x=1');
assert.equal(/[\r\n]/.test(header), false);
assert.equal(header.split('"').length, 3);
});
test('RateLimiter sperrt nach dem Limit und gibt nach Ablauf wieder frei', () => {
const limiter = new RateLimiter({ limit: 3, windowMs: 1000 });
const t0 = 1_000_000;
assert.equal(limiter.take('a', t0), true);
assert.equal(limiter.take('a', t0 + 1), true);
assert.equal(limiter.take('a', t0 + 2), true);
assert.equal(limiter.take('a', t0 + 3), false);
assert.equal(limiter.blocked('a', t0 + 3), true);
assert.equal(limiter.blocked('b', t0 + 3), false);
assert.equal(limiter.retryAfter('a', t0 + 500), 1);
assert.equal(limiter.blocked('a', t0 + 1000), false);
assert.equal(limiter.take('a', t0 + 1000), true);
});
test('RateLimiter wächst nicht unbegrenzt', () => {
const limiter = new RateLimiter({ limit: 1, windowMs: 60_000, maxKeys: 100 });
for (let i = 0; i < 1000; i++) limiter.hit(`key${i}`, 1000);
// Der jüngste Schlüssel ist noch bekannt, die ältesten wurden verdrängt.
assert.equal(limiter.blocked('key999', 1000), true);
assert.equal(limiter.blocked('key0', 1000), false);
});