Claude
0fbeadd0c1
Der Ablauf des Vorbilds (hochladen) ist jetzt eine exportierte, parametrisierte Funktion; datenschutz-hochladen.mjs ruft sie mit Karte datenschutz, PDF und HTML auf und bricht ab, wenn der Stand in der HTML nicht der Freigabe entspricht. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> (cherry picked from commit 06676c459d0ac4f534aed7d616e2c0d40ac97b97)
112 lines
8.3 KiB
JavaScript
112 lines
8.3 KiB
JavaScript
import { test } from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
|
|
// Hochladen der Datenschutzerklärung nach WOMS "Rechtliches" (scripts/datenschutz-hochladen.mjs): die Tests rufen main nur mit Nachbau-deps
|
|
// auf, nie mit dem echten Schlüssel oder dem Netz. Das globale fetch wirft und zählt, damit ein Weg am Nachbau vorbei auffällt.
|
|
let netzzugriffe = 0
|
|
globalThis.fetch = () => {
|
|
netzzugriffe += 1
|
|
throw new Error('Netzzugriff im Test')
|
|
}
|
|
const m = await import('../scripts/datenschutz-hochladen.mjs') // der Import liest weder Schlüssel noch Netz
|
|
|
|
const frueher = ['v1', 'v2', 'v3', 'v4', 'v5'].map((v, i) => ({ $id: `s${i}`, version: v, validFrom: `2026-09-0${i + 1}`, status: 'superseded', source: `x${i}` }))
|
|
const AKTUELL = { $id: 'alt', version: 'v6', validFrom: '2026-10-05', status: 'current', source: 'kundenbereich@aaaaaaa:public/datenschutz.html' }
|
|
// stand = das Datum, das im Nachbau der HTML-Datei hinter "Stand" steht (die PDF-Datei ist beliebiger Inhalt)
|
|
function backend({ versionen = [...frueher, AKTUELL], karten = [{ $id: 'datenschutz', key: 'datenschutz' }], gitStatus = '', stand = '20.10.2026', vorhanden = () => true } = {}) {
|
|
const aufrufe = [], log = []
|
|
const antwort = (obj) => ({ ok: true, status: 200, text: async () => JSON.stringify(obj) })
|
|
const fetch = async (url, opt = {}) => {
|
|
const methode = opt.method ?? 'GET', pfad = new URL(url).pathname.replace(/^\/v1/, '')
|
|
aufrufe.push({ methode, pfad, body: opt.body })
|
|
if (methode === 'GET' && pfad.endsWith('/collections/legalDocuments/documents')) return antwort({ total: karten.length, documents: karten })
|
|
if (methode === 'GET' && pfad.endsWith('/collections/legalVersions/documents')) return antwort({ total: versionen.length, documents: versionen })
|
|
if (methode === 'GET' && pfad.startsWith('/storage/buckets/legal-files/files')) return antwort({ total: 0, files: [] })
|
|
if (methode === 'POST' && pfad === '/storage/buckets/legal-files/files') return antwort({ $id: `f${aufrufe.length}` })
|
|
if (methode === 'POST' && pfad.endsWith('/collections/legalVersions/documents')) return antwort({ $id: 'v-neu' })
|
|
if (methode === 'PATCH' && pfad.includes('/collections/legalVersions/documents/')) return antwort({})
|
|
throw new Error(`unerwartet: ${methode} ${pfad}`)
|
|
}
|
|
const html = () => Buffer.from(stand === null ? '<p class="meta">ohne Datum</p>' : `<p class="meta">Stand ${stand}</p>`)
|
|
return { aufrufe, log, deps: { fetch, schluessel: () => 'test-schluessel', log: (z) => log.push(z), git: (args) => (args[0] === 'status' ? gitStatus : 'abc1234\n'), dateien: { existsSync: vorhanden, readFileSync: (rel) => (rel.endsWith('.html') ? html() : Buffer.from('x')) } } }
|
|
}
|
|
const schreibend = (b) => b.aufrufe.filter((a) => a.methode !== 'GET')
|
|
|
|
test('parseArgs: --probe allein oder --freigabe=Tag, sonst Aufruf-Fehler', () => {
|
|
assert.deepEqual(m.parseArgs(['--probe']), { modus: 'probe', freigabe: null })
|
|
assert.deepEqual(m.parseArgs(['--freigabe=2026-10-20']), { modus: 'hochladen', freigabe: '2026-10-20' })
|
|
for (const bad of [[], ['--freigabe=20.10.2026'], ['--freigabe=2026-13-40'], ['--probe', '--freigabe=2026-10-20'], ['datenschutz']]) assert.throws(() => m.parseArgs(bad), /Aufruf|Freigabe/)
|
|
for (const bad of [['--freigabe=2026-10-20', '--freigabe=2026-10-21'], ['--probe', '--probe'], ['--freigabe=2026-10-20', '--karten-anlegen'], ['datenschutz', '--freigabe=2026-10-20']]) assert.throws(() => m.parseArgs(bad), /Aufruf|Freigabe/, JSON.stringify(bad))
|
|
})
|
|
test('Hochladen: Dateien zuerst (PDF, dann HTML), dann Version v7, dann die bisherige ablösen', async () => {
|
|
const b = backend()
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], b.deps), 0)
|
|
assert.deepEqual(schreibend(b).map((a) => `${a.methode} ${a.pfad.split('/').slice(-1)[0]}`), ['POST files', 'POST files', 'POST documents', 'PATCH alt'])
|
|
const neu = JSON.parse(schreibend(b)[2].body).data
|
|
assert.deepEqual([neu.documentKey, neu.version, neu.validFrom, neu.status, neu.source, neu.fileIds.length], ['datenschutz', 'v7', '2026-10-20', 'current', 'kundenbereich@abc1234:public/datenschutz.html', 2])
|
|
assert.match(neu.changeNote, /^Fassung vom 20\.10\.2026: Abschnitt 11 Interessenten/)
|
|
assert.deepEqual(JSON.parse(schreibend(b)[3].body).data, { status: 'superseded', validTo: '2026-10-19' })
|
|
})
|
|
test('Hochladen: die beiden Dateien sind die PDF und die HTML der Datenschutzerklärung, mit Dateiname und Typ', async () => {
|
|
const b = backend()
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], b.deps), 0)
|
|
const dateien = schreibend(b).slice(0, 2).map((a) => a.body.get('file'))
|
|
assert.deepEqual(dateien.map((f) => [f.name, f.type]), [['WEBklar-Datenschutzerklaerung.pdf', 'application/pdf'], ['datenschutz.html', 'text/html']])
|
|
assert.equal(await dateien[1].text(), '<p class="meta">Stand 20.10.2026</p>')
|
|
})
|
|
test('Changenote nennt weder Workers noch Hustler (sie kann für Kunden sichtbar werden)', async () => {
|
|
const b = backend()
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], b.deps), 0)
|
|
assert.doesNotMatch(JSON.parse(schreibend(b)[2].body).data.changeNote, /workers|hustler/i)
|
|
})
|
|
test('schon hochgeladen, fehlende Karte, nicht eingecheckter Stand und --probe schreiben nichts', async () => {
|
|
const schon = backend({ versionen: [{ ...AKTUELL, source: 'kundenbereich@abc1234:public/datenschutz.html' }] })
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], schon.deps), 0)
|
|
const ohneKarte = backend({ karten: [] })
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], ohneKarte.deps), 1)
|
|
const schmutzig = backend({ gitStatus: ' M public/datenschutz.html\n' })
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], schmutzig.deps), 1)
|
|
const probe = backend()
|
|
assert.equal(await m.main(['--probe'], probe.deps), 0)
|
|
for (const b of [schon, ohneKarte, schmutzig, probe]) assert.equal(schreibend(b).length, 0)
|
|
})
|
|
test('Fehlende Karte und fehlende Datei brechen mit Meldung ab, bevor etwas geschrieben wird', async () => {
|
|
const ohneKarte = backend({ karten: [] })
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], ohneKarte.deps), 1)
|
|
assert.ok(ohneKarte.log.some((z) => z.includes('Karte fehlt: datenschutz')))
|
|
assert.ok(!ohneKarte.log.some((z) => z.includes('--karten-anlegen')), 'dieses Skript legt keine Karten an')
|
|
const ohnePdf = backend({ vorhanden: (rel) => !rel.endsWith('.pdf') })
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], ohnePdf.deps), 1)
|
|
assert.ok(ohnePdf.log.some((z) => z.includes('Datei fehlt: docs/WEBklar-Datenschutzerklaerung.pdf')))
|
|
assert.equal(schreibend(ohneKarte).length + schreibend(ohnePdf).length, 0)
|
|
})
|
|
test('Stand in der HTML muss der Freigabe entsprechen, sonst Abbruch vor jedem Schreiben', async () => {
|
|
const falsch = backend({ stand: '17.10.2026' })
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], falsch.deps), 1)
|
|
assert.ok(falsch.log.some((z) => z.includes('Stand 17.10.2026') && z.includes('20.10.2026')), falsch.log.join(' | '))
|
|
const ohneStand = backend({ stand: null })
|
|
assert.equal(await m.main(['--freigabe=2026-10-20'], ohneStand.deps), 1)
|
|
assert.ok(ohneStand.log.some((z) => z.includes('Stand')), ohneStand.log.join(' | '))
|
|
for (const b of [falsch, ohneStand]) assert.equal(schreibend(b).length, 0)
|
|
const richtig = backend({ stand: '21.10.2026' })
|
|
assert.equal(await m.main(['--freigabe=2026-10-21'], richtig.deps), 0, 'mit passender Freigabe geht derselbe Stand durch')
|
|
})
|
|
test('--probe liest nur: Bucket, Karte und Versionen, meldet eine fehlende Karte als Stopp', async () => {
|
|
const b = backend()
|
|
assert.equal(await m.main(['--probe'], b.deps), 0)
|
|
assert.ok(b.log.includes('datenschutz: v1:superseded v2:superseded v3:superseded v4:superseded v5:superseded v6:current'), b.log.join(' | '))
|
|
assert.deepEqual(b.aufrufe.map((a) => a.pfad.replace(/^\/databases\/woms-database/, '')), ['/storage/buckets/legal-files/files', '/collections/legalDocuments/documents', '/collections/legalVersions/documents'])
|
|
const ohneKarte = backend({ karten: [] })
|
|
assert.equal(await m.main(['--probe'], ohneKarte.deps), 1)
|
|
assert.ok(ohneKarte.log.includes('STOPP: Karte fehlt: datenschutz'))
|
|
})
|
|
test('ungültige Aufrufe enden mit Exit 1 und Hinweis, ohne ein einziges Netz-Zeichen', async () => {
|
|
const b = backend()
|
|
assert.equal(await m.main([], b.deps), 1)
|
|
assert.match(b.log[0], /Aufruf/)
|
|
assert.equal(b.aufrufe.length, 0)
|
|
})
|
|
test('kein Test hat das echte fetch erreicht', () => {
|
|
assert.equal(netzzugriffe, 0)
|
|
})
|