Upload via GUI (85 Dateien)

__tests__/gitignoreTemplates.test.js

@@ -2,9 +2,17 @@ const test = require('node:test');
 const assert = require('node:assert');
 const { listTemplates, buildGitignore } = require('../src/features/gitignoreTemplates.js');
 
-test('listTemplates nennt Node, .NET und Electron', () => {
-  const keys = listTemplates().map(t => t.key);
-  assert.deepStrictEqual(keys, ['node', 'dotnet', 'electron']);
+test('listTemplates nennt alle Vorlagen mit Beschriftung', () => {
+  const list = listTemplates();
+  assert.deepStrictEqual(list.map(t => t.key), ['node', 'dotnet', 'electron', 'python', 'java', 'php', 'unity']);
+  assert.ok(list.every(t => t.label));
+});
+
+test('buildGitignore: Vorlagen für Python, Java, PHP und Unity enthalten ihre Kerneinträge', () => {
+  assert.match(buildGitignore(['python']), /__pycache__\//);
+  assert.match(buildGitignore(['java']), /target\//);
+  assert.match(buildGitignore(['php']), /vendor\//);
+  assert.match(buildGitignore(['unity']), /\[Ll\]ibrary\//);
 });
 
 test('buildGitignore enthält immer den allgemeinen Teil', () => {

__tests__/pauseGate.test.js

@@ -0,0 +1,77 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { createPauseGate } = require('../src/features/pauseGate.js');
+
+const tick = () => new Promise((r) => setTimeout(r, 20));
+
+test('Ohne Pause läuft wait() sofort durch', async () => {
+  const gate = createPauseGate();
+  await gate.wait();
+  await gate.wait(new AbortController().signal);
+  assert.strictEqual(gate.isPaused(), false);
+});
+
+test('Während der Pause bleibt wait() stehen und läuft nach resume() weiter', async () => {
+  const gate = createPauseGate();
+  gate.pause();
+  let done = false;
+  const p = gate.wait().then(() => { done = true; });
+  await tick();
+  assert.strictEqual(done, false);
+  assert.strictEqual(gate.waitingCount(), 1);
+  gate.resume();
+  await p;
+  assert.strictEqual(done, true);
+  assert.strictEqual(gate.waitingCount(), 0);
+});
+
+test('resume() gibt alle Wartenden frei', async () => {
+  const gate = createPauseGate();
+  gate.pause();
+  const all = Promise.all([gate.wait(), gate.wait(), gate.wait()]);
+  await tick();
+  assert.strictEqual(gate.waitingCount(), 3);
+  gate.resume();
+  await all;
+});
+
+test('Abbruch während der Pause löst wait() mit dem Abbruchfehler aus', async () => {
+  const gate = createPauseGate();
+  gate.pause();
+  const c = new AbortController();
+  const p = gate.wait(c.signal);
+  await tick();
+  c.abort();
+  await assert.rejects(p, (e) => e.code === 'UPLOAD_CANCELLED');
+  assert.strictEqual(gate.waitingCount(), 0);
+});
+
+test('Bereits abgebrochenes Signal wirft sofort, auch ohne Pause', async () => {
+  const gate = createPauseGate();
+  const c = new AbortController();
+  c.abort();
+  await assert.rejects(gate.wait(c.signal), (e) => e.code === 'UPLOAD_CANCELLED');
+});
+
+test('onChange meldet nur echte Wechsel', () => {
+  const states = [];
+  const gate = createPauseGate({ onChange: (p) => states.push(p) });
+  assert.strictEqual(gate.pause(), true);
+  assert.strictEqual(gate.pause(), false);
+  assert.strictEqual(gate.resume(), true);
+  assert.strictEqual(gate.resume(), false);
+  assert.deepStrictEqual(states, [true, false]);
+});
+
+test('Ein abgebrochener Wartender blockiert die übrigen nicht', async () => {
+  const gate = createPauseGate();
+  gate.pause();
+  const c = new AbortController();
+  const a = gate.wait(c.signal).catch((e) => e.code);
+  const b = gate.wait();
+  await tick();
+  c.abort();
+  assert.strictEqual(await a, 'UPLOAD_CANCELLED');
+  gate.resume();
+  await b;
+});

__tests__/releaseAssist.test.js

@@ -0,0 +1,64 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const {
+  parseVersionFromFileName, compareVersions, parseSidecar, checkNewTag, buildReleaseBody
+} = require('../src/features/releaseAssist.js');
+
+const HASH = '5ca7f0c680b6d73a92eadb5e90f8164f7f3fa52071ffaac54803b0e5ec95f35d';
+
+test('Version aus dem Dateinamen', () => {
+  assert.strictEqual(parseVersionFromFileName('Git-Manager-GUI-Setup-2.2.1.exe'), '2.2.1');
+  assert.strictEqual(parseVersionFromFileName('Git Manager GUI Setup 2.1.10.exe'), '2.1.10');
+  assert.strictEqual(parseVersionFromFileName('setup.exe'), null);
+  assert.strictEqual(parseVersionFromFileName(null), null);
+});
+
+test('Versionen werden numerisch verglichen, nicht als Text', () => {
+  assert.strictEqual(compareVersions('2.2.1', '2.2.0'), 1);
+  assert.strictEqual(compareVersions('v2.10.0', 'v2.9.9'), 1);
+  assert.strictEqual(compareVersions('2.2.1', 'v2.2.1'), 0);
+  assert.strictEqual(compareVersions('2.1.9', '2.2.0'), -1);
+  assert.deepStrictEqual(['v2.10.0', 'v2.9.0', 'v2.2.1'].sort(compareVersions), ['v2.2.1', 'v2.9.0', 'v2.10.0']);
+});
+
+test('Sidecar-Datei: Hash wird gefunden, auch mit Großbuchstaben', () => {
+  assert.strictEqual(parseSidecar(`${HASH}  Git-Manager-GUI-Setup-2.2.1.exe\n`), HASH);
+  assert.strictEqual(parseSidecar(HASH.toUpperCase()), HASH);
+  assert.strictEqual(parseSidecar('kein Hash'), null);
+  assert.strictEqual(parseSidecar('abc123'), null);
+});
+
+test('Neuer Tag: Format, Duplikat und Reihenfolge werden geprüft', () => {
+  const releases = [{ tag_name: 'v2.2.0' }, { tag_name: 'v2.1.9' }];
+  assert.strictEqual(checkNewTag('v2.2.1', releases).ok, true);
+  assert.strictEqual(checkNewTag('2.2.1', releases).ok, true);
+  assert.strictEqual(checkNewTag('v2.10.0', releases).ok, true);
+
+  assert.match(checkNewTag('release-2', releases).reason, /Version wie v2\.2\.1/);
+  assert.match(checkNewTag('v2.2.0', releases).reason, /gibt es schon/);
+  assert.match(checkNewTag('V2.2.0', releases).reason, /gibt es schon/);
+  assert.match(checkNewTag('v2.1.5', releases).reason, /nicht neuer/);
+});
+
+test('Neuer Tag: ohne vorhandene Releases ist jede Version erlaubt', () => {
+  assert.strictEqual(checkNewTag('v1.0.0', []).ok, true);
+  assert.strictEqual(checkNewTag('v1.0.0', null).ok, true);
+  assert.strictEqual(checkNewTag('v1.0.0', [{ tag_name: 'nightly' }]).ok, true);
+});
+
+test('Release-Text: Prüfsummen im Format, das der Updater liest', () => {
+  const body = buildReleaseBody('## Neu\n\n- Abbrechen\n', [{ name: 'Git-Manager-GUI-Setup-2.2.1.exe', sha256: HASH.toUpperCase() }]);
+  assert.match(body, /^## Neu/);
+  assert.ok(body.includes(`- Git-Manager-GUI-Setup-2.2.1.exe: ${HASH}`));
+
+  // genau so liest updater.js die Zeile
+  const line = body.split('\n').find((l) => l.toLowerCase().includes('git-manager-gui-setup-2.2.1.exe') && /\b[a-f0-9]{64}\b/i.test(l));
+  assert.ok(line);
+  assert.strictEqual(line.match(/\b([a-fA-F0-9]{64})\b/)[1], HASH);
+});
+
+test('Release-Text: ungültige Prüfsummen und leere Notizen', () => {
+  assert.strictEqual(buildReleaseBody('Nur Text', [{ name: 'a.exe', sha256: 'zu kurz' }]), 'Nur Text');
+  assert.strictEqual(buildReleaseBody('', []), '');
+  assert.ok(buildReleaseBody('', [{ name: 'a.exe', sha256: HASH }]).startsWith('### Prüfsummen'));
+});

__tests__/splash.test.js

@@ -0,0 +1,36 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { remainingMs, centeredBounds, MIN_SPIN_MS } = require('../src/features/splash.js');
+
+test('Startanimation: wurde das Logo nie gezeigt, gibt es keine Wartezeit', () => {
+  assert.strictEqual(remainingMs(0, 5000, 1600), 0);
+});
+
+test('Startanimation: das Logo dreht sich mindestens minMs', () => {
+  assert.strictEqual(remainingMs(1000, 1300, 1600), 1300);
+  assert.strictEqual(remainingMs(1000, 1000, 1600), 1600);
+});
+
+test('Startanimation: nach Ablauf von minMs wird nicht mehr gewartet', () => {
+  assert.strictEqual(remainingMs(1000, 2600, 1600), 0);
+  assert.strictEqual(remainingMs(1000, 9000, 1600), 0);
+});
+
+test('Startanimation: Mindestdauer ist wie bei AeroMC 1,6 s', () => {
+  assert.strictEqual(MIN_SPIN_MS, 1600);
+});
+
+test('Startanimation: Fenster wird im Arbeitsbereich zentriert', () => {
+  const b = centeredBounds({ x: 0, y: 0, width: 1920, height: 1040 }, 1200, 820);
+  assert.deepStrictEqual(b, { x: 360, y: 110, width: 1200, height: 820 });
+});
+
+test('Startanimation: Arbeitsbereich mit Versatz und mehrere Monitore', () => {
+  const b = centeredBounds({ x: -1920, y: 40, width: 1920, height: 1000 }, 1200, 820);
+  assert.deepStrictEqual(b, { x: -1560, y: 130, width: 1200, height: 820 });
+});
+
+test('Startanimation: auf kleinen Bildschirmen wird das Fenster begrenzt', () => {
+  const b = centeredBounds({ x: 0, y: 0, width: 1024, height: 700 }, 1200, 820);
+  assert.deepStrictEqual(b, { x: 0, y: 0, width: 1024, height: 700 });
+});

__tests__/transferNotice.test.js

@@ -0,0 +1,28 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { describeTransfer } = require('../src/features/transferNotice.js');
+
+test('Erfolg nennt Repo und Dateizahl', () => {
+  assert.deepStrictEqual(describeTransfer({ status: 'ok', repo: 'a/b', files: 3 }), { title: 'Upload fertig', body: 'a/b: 3 Dateien hochgeladen.' });
+  assert.match(describeTransfer({ status: 'ok', repo: 'a/b', files: 1 }).body, /1 Datei hochgeladen/);
+});
+
+test('Erfolg ohne bekannte Dateizahl bleibt lesbar', () => {
+  assert.strictEqual(describeTransfer({ status: 'ok', repo: 'a/b', files: null }).body, 'a/b: Upload hochgeladen.');
+});
+
+test('Abgebrochene Uploads melden nichts', () => {
+  assert.strictEqual(describeTransfer({ status: 'abgebrochen', repo: 'a/b' }), null);
+  assert.strictEqual(describeTransfer(null), null);
+});
+
+test('Fehler zeigt fehlgeschlagene Dateien oder den Fehlertext', () => {
+  assert.strictEqual(describeTransfer({ status: 'fehler', repo: 'a/b', failed: 2 }).title, 'Upload fehlgeschlagen');
+  assert.match(describeTransfer({ status: 'fehler', repo: 'a/b', failed: 2 }).body, /2 Dateien fehlgeschlagen/);
+  assert.match(describeTransfer({ status: 'fehler', repo: 'a/b', error: 'Server nicht erreichbar' }).body, /Server nicht erreichbar/);
+  assert.match(describeTransfer({ status: 'fehler', repo: '' }).body, /Unbekannter Fehler/);
+});
+
+test('Langer Fehlertext wird gekürzt', () => {
+  assert.ok(describeTransfer({ status: 'fehler', repo: 'a/b', error: 'x'.repeat(500) }).body.length < 200);
+});

__tests__/trayMenu.test.js

@@ -0,0 +1,133 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { buildTrayTemplate, trayTooltip } = require('../src/features/trayMenu.js');
+
+const noop = () => {};
+const base = { version: '2.2.1', onOpen: noop, onHistory: noop, onCancel: noop, onAutostart: noop, onQuit: noop };
+const labels = (tpl) => tpl.filter(i => i.label).map(i => i.label);
+const find = (tpl, label) => tpl.find(i => i.label === label);
+
+test('Tooltip nennt Version und zeigt eine laufende Übertragung', () => {
+  assert.strictEqual(trayTooltip('2.2.1', 0), 'Git Manager Explorer Pro v2.2.1');
+  assert.match(trayTooltip('2.2.1', 2), /Übertragung läuft/);
+  assert.match(trayTooltip('2.2.1', 1, true), /Übertragung pausiert/);
+  assert.strictEqual(trayTooltip('2.2.1', 0, true), 'Git Manager Explorer Pro v2.2.1');
+});
+
+test('Menü im Ruhezustand: Kopfzeile, Status, Aktionen; Abbrechen gesperrt', () => {
+  const tpl = buildTrayTemplate(base);
+  assert.deepStrictEqual(labels(tpl), [
+    'Git Manager Explorer Pro  v2.2.1',
+    'Keine laufende Übertragung',
+    'Fenster öffnen',
+    'Upload-Verlauf',
+    'Übertragung pausieren',
+    'Laufende Übertragung abbrechen',
+    'Mit Windows starten',
+    'Beenden'
+  ]);
+  assert.strictEqual(find(tpl, 'Laufende Übertragung abbrechen').enabled, false);
+  assert.strictEqual(tpl[0].enabled, false);
+});
+
+test('Menü bei laufender Übertragung: Zähler, Abbrechen freigeschaltet', () => {
+  const one = buildTrayTemplate({ ...base, active: 1 });
+  assert.ok(labels(one).includes('1 Übertragung läuft'));
+  assert.strictEqual(find(one, 'Laufende Übertragung abbrechen').enabled, true);
+  assert.ok(labels(buildTrayTemplate({ ...base, active: 3 })).includes('3 Übertragungen laufen'));
+});
+
+test('Retry-Queue erscheint nur, wenn etwas wartet', () => {
+  assert.ok(!labels(buildTrayTemplate(base)).some(l => l.startsWith('Retry-Queue')));
+  assert.ok(labels(buildTrayTemplate({ ...base, queued: 4 })).includes('Retry-Queue: 4 wartend'));
+});
+
+test('Autostart ist ein Häkchen und spiegelt den Zustand', () => {
+  assert.strictEqual(find(buildTrayTemplate({ ...base, autostart: true }), 'Mit Windows starten').checked, true);
+  const off = find(buildTrayTemplate(base), 'Mit Windows starten');
+  assert.strictEqual(off.type, 'checkbox');
+  assert.strictEqual(off.checked, false);
+});
+
+test('Einträge rufen die übergebenen Aktionen auf', () => {
+  const calls = [];
+  const tpl = buildTrayTemplate({
+    ...base,
+    active: 1,
+    onOpen: () => calls.push('open'),
+    onHistory: () => calls.push('history'),
+    onCancel: () => calls.push('cancel'),
+    onQuit: () => calls.push('quit')
+  });
+  for (const l of ['Fenster öffnen', 'Upload-Verlauf', 'Laufende Übertragung abbrechen', 'Beenden']) find(tpl, l).click();
+  assert.deepStrictEqual(calls, ['open', 'history', 'cancel', 'quit']);
+});
+
+const { serializeTemplate, runAction } = require('../src/features/trayMenu.js');
+const { computePosition } = require('../src/features/trayPopup.js');
+
+test('serializeTemplate: nur Daten, keine Funktionen, Trenner bleiben erhalten', () => {
+  const plain = serializeTemplate(buildTrayTemplate({ ...base, active: 1, autostart: true }));
+  assert.ok(plain.every(i => Object.values(i).every(v => typeof v !== 'function')));
+  assert.strictEqual(plain.filter(i => i.type === 'separator').length, 3);
+  const cancel = plain.find(i => i.id === 'cancel');
+  assert.deepStrictEqual(cancel, { id: 'cancel', label: 'Laufende Übertragung abbrechen', type: 'normal', enabled: true, checked: false });
+  assert.strictEqual(plain.find(i => i.id === 'autostart').checked, true);
+  assert.doesNotThrow(() => JSON.stringify(plain));
+});
+
+test('runAction: führt Aktionen per id aus, Häkchen wird umgeschaltet', () => {
+  const calls = [];
+  const tpl = buildTrayTemplate({
+    ...base,
+    active: 1,
+    autostart: false,
+    onOpen: () => calls.push('open'),
+    onAutostart: (item) => calls.push(`autostart:${item.checked}`)
+  });
+  assert.strictEqual(runAction(tpl, 'open'), true);
+  assert.strictEqual(runAction(tpl, 'autostart'), true);
+  assert.deepStrictEqual(calls, ['open', 'autostart:true']);
+});
+
+test('runAction: gesperrte oder unbekannte Einträge tun nichts', () => {
+  let cancelled = false;
+  const tpl = buildTrayTemplate({ ...base, active: 0, onCancel: () => { cancelled = true; } });
+  assert.strictEqual(runAction(tpl, 'cancel'), false);
+  assert.strictEqual(runAction(tpl, 'gibt-es-nicht'), false);
+  assert.strictEqual(runAction(tpl, 'header'), false);
+  assert.strictEqual(cancelled, false);
+});
+
+test('computePosition: Menü bleibt im sichtbaren Bereich', () => {
+  const wa = { x: 0, y: 0, width: 1920, height: 1040 };
+  // Zeiger in der Taskleiste unten rechts: Menü sitzt direkt über der Taskleiste, nicht außerhalb rechts
+  const bottomRight = computePosition({ x: 1900, y: 1060 }, wa, 286, 300);
+  assert.strictEqual(bottomRight.y, 1040 - 300 - 8);
+  assert.ok(bottomRight.x + 286 <= 1920 - 8);
+  // Zeiger weit links: nicht links aus dem Bildschirm
+  assert.ok(computePosition({ x: 2, y: 1060 }, wa, 286, 300).x >= 8);
+  // Taskleiste oben
+  assert.strictEqual(computePosition({ x: 500, y: 10 }, { ...wa, y: 40, height: 1000 }, 286, 300).y, 48);
+});
+
+test('Pause: Eintrag wechselt zwischen pausieren und fortsetzen, nur bei laufender Übertragung wählbar', () => {
+  const idle = buildTrayTemplate(base);
+  assert.strictEqual(find(idle, 'Übertragung pausieren').enabled, false);
+
+  const running = buildTrayTemplate({ ...base, active: 1 });
+  assert.strictEqual(find(running, 'Übertragung pausieren').enabled, true);
+
+  const paused = buildTrayTemplate({ ...base, active: 2, paused: true });
+  assert.ok(labels(paused).includes('Übertragung fortsetzen'));
+  assert.ok(labels(paused).includes('2 Übertragungen pausiert'));
+  assert.ok(!labels(paused).includes('Übertragung pausieren'));
+  assert.ok(labels(buildTrayTemplate({ ...base, active: 1, paused: true })).includes('1 Übertragung pausiert'));
+});
+
+test('Pause-Eintrag ruft onPause auf', () => {
+  const calls = [];
+  const tpl = buildTrayTemplate({ ...base, active: 1, onPause: () => calls.push('pause') });
+  assert.strictEqual(runAction(tpl, 'pause'), true);
+  assert.deepStrictEqual(calls, ['pause']);
+});

__tests__/uploadBlocklist.test.js

@@ -0,0 +1,35 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { blockedReason, partitionBlocked } = require('../src/features/uploadBlocklist.js');
+
+test('Sperre: Dateien mit Zugangsdaten werden erkannt', () => {
+  for (const name of ['credentials.json', 'data/credentials.json', 'C:\\proj\\.env', '.env.production', 'id_rsa', 'release.keystore', 'server.pem', 'secrets.json', '.npmrc']) {
+    assert.ok(blockedReason(name, {}), `${name} sollte gesperrt sein`);
+  }
+});
+
+test('Sperre: normale Dateien und Vorlagen bleiben erlaubt', () => {
+  for (const name of ['main.js', 'package.json', 'README.md', '.env.example', 'config.sample.json', 'id_rsa.pub', 'credentials.md', 'src/credentials/index.js']) {
+    assert.strictEqual(blockedReason(name, {}), null, `${name} darf hochgeladen werden`);
+  }
+});
+
+test('Sperre: Einstellung kann sie abschalten, Standard ist an', () => {
+  assert.ok(blockedReason('credentials.json', undefined));
+  assert.ok(blockedReason('credentials.json', { uploadBlockSecrets: true }));
+  assert.strictEqual(blockedReason('credentials.json', { uploadBlockSecrets: false }), null);
+});
+
+test('partitionBlocked: trennt Einträge und behält die Reihenfolge', () => {
+  const items = [
+    { localFile: 'a/main.js', targetPath: 'a/main.js' },
+    { localFile: 'a/data/credentials.json', targetPath: 'a/data/credentials.json' },
+    { localFile: 'a/.env', targetPath: 'a/.env' },
+    { localFile: 'a/README.md', targetPath: 'a/README.md' }
+  ];
+  const { allowed, blocked } = partitionBlocked(items, {});
+  assert.deepStrictEqual(allowed.map(i => i.localFile), ['a/main.js', 'a/README.md']);
+  assert.deepStrictEqual(blocked.map(b => b.path), ['a/data/credentials.json', 'a/.env']);
+  assert.ok(blocked.every(b => b.reason));
+  assert.strictEqual(partitionBlocked(items, { uploadBlockSecrets: false }).blocked.length, 0);
+});

__tests__/uploadCancel.test.js

@@ -0,0 +1,146 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const http = require('node:http');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  uploadItemsViaGiteaApi,
+  createUploadCancelledError,
+  isUploadCancelledError,
+  throwIfUploadCancelled
+} = require('../src/git/apiHandler.js');
+
+test('Abbruchfehler: Erkennung und throwIfUploadCancelled', () => {
+  assert.strictEqual(isUploadCancelledError(createUploadCancelledError()), true);
+  assert.strictEqual(isUploadCancelledError(new Error('anderer Fehler')), false);
+  assert.strictEqual(isUploadCancelledError(null), false);
+
+  assert.doesNotThrow(() => throwIfUploadCancelled(undefined));
+  assert.doesNotThrow(() => throwIfUploadCancelled(new AbortController().signal));
+  const c = new AbortController();
+  c.abort();
+  assert.throws(() => throwIfUploadCancelled(c.signal), (e) => isUploadCancelledError(e));
+});
+
+function makeTempFile() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gm-cancel-'));
+  const file = path.join(dir, 'a.txt');
+  fs.writeFileSync(file, 'hallo');
+  return { dir, file };
+}
+
+test('API-Upload: bereits abgebrochenes Signal sendet nichts', async () => {
+  const { dir, file } = makeTempFile();
+  try {
+    const c = new AbortController();
+    c.abort();
+    await assert.rejects(
+      uploadItemsViaGiteaApi({
+        token: 't', url: 'http://127.0.0.1:1', owner: 'o', repo: 'r', branch: 'main',
+        items: [{ localFile: file, targetPath: 'a.txt' }], message: 'm', signal: c.signal
+      }),
+      (e) => isUploadCancelledError(e)
+    );
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('API-Upload: Abbruch während der Übertragung wirft Abbruchfehler und landet nicht in "failed"', async () => {
+  const { dir, file } = makeTempFile();
+  let postSeen = false;
+  const server = http.createServer((req, res) => {
+    if (req.method === 'POST') {
+      postSeen = true;
+      setTimeout(() => { res.writeHead(201, { 'content-type': 'application/json' }); res.end('{}'); }, 3000);
+      return;
+    }
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ default_branch: 'main', tree: [], entries: [] }));
+  });
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  const { port } = server.address();
+  try {
+    const c = new AbortController();
+    const started = Date.now();
+    setTimeout(() => c.abort(), 400);
+    await assert.rejects(
+      uploadItemsViaGiteaApi({
+        token: 't', url: `http://127.0.0.1:${port}`, owner: 'o', repo: 'r', branch: 'main',
+        items: [{ localFile: file, targetPath: 'a.txt' }], message: 'm', signal: c.signal
+      }),
+      (e) => isUploadCancelledError(e)
+    );
+    assert.ok(postSeen, 'Der POST muss gestartet sein, sonst prüft der Test nichts');
+    assert.ok(Date.now() - started < 2500, 'Abbruch muss sofort greifen, nicht erst nach der Serverantwort');
+  } finally {
+    server.closeAllConnections?.();
+    await new Promise(r => server.close(r));
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+const { createPauseGate } = require('../src/features/pauseGate.js');
+
+function gitea(onPost) {
+  return http.createServer((req, res) => {
+    if (req.method === 'POST') {
+      onPost();
+      res.writeHead(201, { 'content-type': 'application/json' });
+      res.end('{}');
+      return;
+    }
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ default_branch: 'main', tree: [], entries: [] }));
+  });
+}
+
+test('API-Upload: während der Pause wird nichts gesendet, nach resume() schon', async () => {
+  const { dir, file } = makeTempFile();
+  let posts = 0;
+  const server = gitea(() => { posts++; });
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  const { port } = server.address();
+  const gate = createPauseGate();
+  try {
+    gate.pause();
+    const upload = uploadItemsViaGiteaApi({
+      token: 't', url: `http://127.0.0.1:${port}`, owner: 'o', repo: 'r', branch: 'main',
+      items: [{ localFile: file, targetPath: 'a.txt' }], message: 'm',
+      waitIfPaused: (s) => gate.wait(s)
+    });
+    await new Promise(r => setTimeout(r, 700));
+    assert.strictEqual(posts, 0, 'Während der Pause darf kein Paket gesendet werden');
+    gate.resume();
+    const result = await upload;
+    assert.strictEqual(posts, 1);
+    assert.deepStrictEqual(result.uploaded, ['a.txt']);
+  } finally {
+    await new Promise(r => server.close(r));
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('API-Upload: Abbruch während der Pause beendet den Upload sofort', async () => {
+  const { dir, file } = makeTempFile();
+  let posts = 0;
+  const server = gitea(() => { posts++; });
+  await new Promise(r => server.listen(0, '127.0.0.1', r));
+  const { port } = server.address();
+  const gate = createPauseGate();
+  try {
+    gate.pause();
+    const c = new AbortController();
+    const upload = uploadItemsViaGiteaApi({
+      token: 't', url: `http://127.0.0.1:${port}`, owner: 'o', repo: 'r', branch: 'main',
+      items: [{ localFile: file, targetPath: 'a.txt' }], message: 'm',
+      signal: c.signal, waitIfPaused: (s) => gate.wait(s)
+    });
+    setTimeout(() => c.abort(), 400);
+    await assert.rejects(upload, (e) => isUploadCancelledError(e));
+    assert.strictEqual(posts, 0);
+    assert.strictEqual(gate.waitingCount(), 0);
+  } finally {
+    await new Promise(r => server.close(r));
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

__tests__/uploadHistory.test.js

@@ -0,0 +1,113 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const { buildEntry, filterEntries, createUploadHistory } = require('../src/features/uploadHistory.js');
+
+function memoryFs(initial) {
+  const files = new Map(initial ? [['h.json', initial]] : []);
+  return {
+    files,
+    readFileSync: (f) => { if (!files.has(f)) throw new Error('ENOENT'); return files.get(f); },
+    writeFileSync: (f, c) => { files.set(f, c); }
+  };
+}
+
+test('buildEntry: erfolgreicher Upload', () => {
+  const e = buildEntry('Drag & Drop', { owner: 'a', repo: 'b' }, { ok: true, results: [{}, {}, {}] }, 1000, null, 4000);
+  assert.strictEqual(e.status, 'ok');
+  assert.strictEqual(e.repo, 'a/b');
+  assert.strictEqual(e.files, 3);
+  assert.strictEqual(e.durationMs, 3000);
+  assert.strictEqual(e.error, '');
+});
+
+test('buildEntry: abgebrochen ist kein Fehler und trägt keinen Fehlertext', () => {
+  const e = buildEntry('Ordner', { owner: 'a', repo: 'b' }, { ok: false, cancelled: true, error: 'Upload abgebrochen' }, 0, null, 10);
+  assert.strictEqual(e.status, 'abgebrochen');
+  assert.strictEqual(e.error, '');
+});
+
+test('buildEntry: Fehler und geworfene Ausnahmen', () => {
+  const failed = buildEntry('Dateien', { owner: 'a', repo: 'b' }, { ok: false, error: 'kaputt', failedCount: 2 }, 0, null, 10);
+  assert.strictEqual(failed.status, 'fehler');
+  assert.strictEqual(failed.error, 'kaputt');
+  assert.strictEqual(failed.failed, 2);
+
+  const thrown = buildEntry('Dateien', {}, null, 0, new Error('boom'), 10);
+  assert.strictEqual(thrown.status, 'fehler');
+  assert.strictEqual(thrown.error, 'boom');
+  assert.strictEqual(thrown.repo, '');
+});
+
+test('buildEntry: Einzeldatei zählt als eine Datei, lange Fehler werden gekürzt', () => {
+  assert.strictEqual(buildEntry('x', {}, { ok: true, singleFile: true }, 0, null, 1).files, 1);
+  assert.strictEqual(buildEntry('x', {}, { ok: false, error: 'e'.repeat(1000) }, 0, null, 1).error.length, 300);
+});
+
+test('filterEntries: nach Status und Repo-Suche', () => {
+  const list = [
+    { repo: 'a/alpha', status: 'ok' },
+    { repo: 'a/beta', status: 'fehler' },
+    { repo: 'b/Alpha-2', status: 'abgebrochen' }
+  ];
+  assert.strictEqual(filterEntries(list).length, 3);
+  assert.deepStrictEqual(filterEntries(list, { status: 'fehler' }).map(e => e.repo), ['a/beta']);
+  assert.deepStrictEqual(filterEntries(list, { query: 'ALPHA' }).map(e => e.repo), ['a/alpha', 'b/Alpha-2']);
+  assert.strictEqual(filterEntries(list, { status: 'ok', query: 'beta' }).length, 0);
+});
+
+test('Verlauf: neueste zuerst, auf max Einträge begrenzt', () => {
+  const history = createUploadHistory({ file: 'h.json', max: 3, fs: memoryFs() });
+  for (let i = 1; i <= 5; i++) history.record({ n: i });
+  assert.deepStrictEqual(history.read().map(e => e.n), [5, 4, 3]);
+});
+
+test('Verlauf: kaputte oder fehlende Datei ergibt eine leere Liste', () => {
+  assert.deepStrictEqual(createUploadHistory({ file: 'h.json', fs: memoryFs() }).read(), []);
+  assert.deepStrictEqual(createUploadHistory({ file: 'h.json', fs: memoryFs('{kaputt') }).read(), []);
+  assert.deepStrictEqual(createUploadHistory({ file: 'h.json', fs: memoryFs('{"a":1}') }).read(), []);
+});
+
+test('Verlauf: leeren', () => {
+  const history = createUploadHistory({ file: 'h.json', fs: memoryFs() });
+  history.record({ n: 1 });
+  history.clear();
+  assert.deepStrictEqual(history.read(), []);
+});
+
+test('Verlauf: Schreibfehler werfen nicht', () => {
+  const broken = { readFileSync: () => '[]', writeFileSync: () => { throw new Error('Platte voll'); } };
+  assert.strictEqual(createUploadHistory({ file: 'h.json', fs: broken }).record({ n: 1 }), false);
+});
+
+const { toCsv, formatDate } = require('../src/features/uploadHistory.js');
+
+test('formatDate: TT.MM.JJJJ HH:MM:SS, ungültige Eingabe ergibt leeren Text', () => {
+  assert.match(formatDate('2026-10-22T07:11:53.080Z'), /^\d{2}\.\d{2}\.2026 \d{2}:\d{2}:\d{2}$/);
+  assert.strictEqual(formatDate('kein Datum'), '');
+});
+
+test('toCsv: BOM, Semikolon, Windows-Zeilenenden, Kopfzeile', () => {
+  const csv = toCsv([{ at: '2026-10-22T07:11:53.080Z', repo: 'a/b', kind: 'Drag & Drop', files: 3, failed: 0, status: 'ok', durationMs: 2500, error: '' }]);
+  assert.strictEqual(csv.charCodeAt(0), 0xFEFF);
+  const lines = csv.slice(1).split('\r\n');
+  assert.strictEqual(lines[0], 'Datum;Repo;Art;Dateien;Fehlgeschlagen;Ergebnis;Dauer (s);Fehler');
+  assert.match(lines[1], /;a\/b;Drag & Drop;3;0;Erfolgreich;2\.5;$/);
+  assert.strictEqual(lines[2], '');
+});
+
+test('toCsv: Anführungszeichen, Semikolon und Zeilenumbrüche werden maskiert', () => {
+  const csv = toCsv([{ at: '2026-10-22T07:11:53Z', repo: 'a/b', kind: 'x', files: null, failed: 1, status: 'fehler', durationMs: 100, error: 'sagt "nein"; und\nmehr' }]);
+  assert.ok(csv.includes('"sagt ""nein""; und\nmehr"'));
+  assert.match(csv, /;Fehler;0\.1;/);
+});
+
+test('toCsv: Excel-Formeln werden entschärft', () => {
+  const csv = toCsv([{ at: '2026-10-22T07:11:53Z', repo: '=cmd|calc', kind: '+x', files: 1, failed: 0, status: 'ok', durationMs: 0, error: '@SUMME(A1)' }]);
+  assert.ok(csv.includes(";'=cmd|calc;"));
+  assert.ok(csv.includes(";'+x;"));
+  assert.ok(csv.includes(";'@SUMME(A1)"));
+});
+
+test('toCsv: leere Liste liefert nur die Kopfzeile', () => {
+  assert.strictEqual(toCsv([]).slice(1).split('\r\n').filter(Boolean).length, 1);
+});