282 lines
17 KiB
JavaScript
282 lines
17 KiB
JavaScript
import test from 'node:test'
|
||
import assert from 'node:assert/strict'
|
||
import { loadModule } from './load.mjs'
|
||
|
||
const {
|
||
LEISTUNGSZEITRAUM_MAX, BEZEICHNUNG_MAX,
|
||
vorschauAnfrage, rechnungAnfrage, vorschauSchluessel, vorschauStatus, darfSpeichern,
|
||
zeileTeilen, zeileBearbeitbar, maxVorn, createSubmitter,
|
||
} = await loadModule('src/lib/rechnungAnfrage.js')
|
||
const { ADDRESS_INCOMPLETE_TEXT } = await loadModule('src/lib/financeView.js')
|
||
|
||
const kunde = { $id: 'c1', name: 'Anelia Wolf', email: 'anelia@example.de', street: 'Hauptstr. 1', postalCode: '67655', city: 'Kaiserslautern', customerStatus: 'customer' }
|
||
const zeile = (uid, description, quantity, price) => ({ uid, description, quantity, price })
|
||
const bl = (id, minuten) => ({ id, ticketId: 't1', woid: '100131', datum: '2026-10-06', minuten, text: 'Startseite', aboZeit: false, kommentar: false })
|
||
const B = [bl('b1', 60), bl('b2', 90), bl('b3', 45)]
|
||
const basis = (over = {}) => ({
|
||
kunde, art: 'festbetrag', projektId: 'p1', auftragId: '',
|
||
items: [zeile(1, 'Erstellung der Website, Pauschalpreis laut Absprache', '1', '500,00')], zusatz: [],
|
||
blaetter: [], abgewaehlt: [], anzahlung: { modus: 'prozent', wert: '50', bezeichnung: 'Anzahlung' },
|
||
zeilentexte: {}, zeitraum: '', zeitraumGeaendert: false, days: '14', memo: '', ...over,
|
||
})
|
||
|
||
test('rechnungAnfrage: Festbetrag ohne AB (500 € laut Absprache)', () => {
|
||
const r = rechnungAnfrage(basis())
|
||
assert.equal(r.ok, true)
|
||
assert.deepEqual(r.body, {
|
||
customerId: 'c1', art: 'festbetrag', projektId: 'p1', daysUntilDue: 14,
|
||
items: [{ description: 'Erstellung der Website, Pauschalpreis laut Absprache', quantity: 1, unitAmountCents: 50000 }],
|
||
})
|
||
assert.equal(r.totalCents, 50000)
|
||
})
|
||
|
||
test('rechnungAnfrage: ohne Projekt ist die Art frei und der Körper trägt kein projektId', () => {
|
||
const r = rechnungAnfrage(basis({ art: 'frei', projektId: '' }))
|
||
assert.equal(r.ok, true)
|
||
assert.equal(r.body.art, 'frei')
|
||
assert.equal('projektId' in r.body, false)
|
||
})
|
||
|
||
test('rechnungAnfrage: Notiz und selbst geänderter Leistungszeitraum gehen mit, ein Vorschlag nicht', () => {
|
||
assert.equal(LEISTUNGSZEITRAUM_MAX, 140)
|
||
const r = rechnungAnfrage(basis({ memo: ' Danke ', zeitraum: ' Oktober 2026 ', zeitraumGeaendert: true }))
|
||
assert.equal(r.body.memo, 'Danke')
|
||
assert.equal(r.body.leistungszeitraum, 'Oktober 2026')
|
||
assert.equal('leistungszeitraum' in rechnungAnfrage(basis({ zeitraum: '01.10.–20.10.2026', zeitraumGeaendert: false })).body, false)
|
||
assert.equal('leistungszeitraum' in rechnungAnfrage(basis({ zeitraum: ' ', zeitraumGeaendert: true })).body, false)
|
||
})
|
||
|
||
test('rechnungAnfrage: Festbetrag prüft Kunde, Projekt, Positionen, Zahlungsziel und Zeitraum', () => {
|
||
assert.deepEqual(rechnungAnfrage(basis({ projektId: '' })), { ok: false, error: 'Bitte ein Projekt wählen.' })
|
||
assert.equal(rechnungAnfrage(basis({ kunde: null })).error, 'Bitte einen Kunden wählen.')
|
||
assert.equal(rechnungAnfrage(basis({ items: [zeile(1, '', '1', '10,00')] })).error, 'Position 1: Bitte eine Beschreibung eingeben.')
|
||
assert.equal(rechnungAnfrage(basis({ days: 'abc' })).error, 'Das Zahlungsziel muss eine ganze Zahl von 0 bis 60 Tagen sein.')
|
||
assert.equal(
|
||
rechnungAnfrage(basis({ zeitraum: 'x'.repeat(141), zeitraumGeaendert: true })).error,
|
||
'Der Leistungszeitraum darf höchstens 140 Zeichen lang sein.'
|
||
)
|
||
})
|
||
|
||
test('rechnungAnfrage: Aufwand sendet nur die gewählten Arbeitsblätter, Zusatzpositionen und Zeilentexte', () => {
|
||
const r = rechnungAnfrage(basis({
|
||
art: 'aufwand', blaetter: B, abgewaehlt: ['b2'],
|
||
zeilentexte: { '2026-10-06': '06.10.2026: Startseite', leer: ' ' },
|
||
zusatz: [zeile(2, 'Domain-Registrierung', '1', '12,00'), zeile(3, '', '1', '')],
|
||
}))
|
||
assert.equal(r.ok, true)
|
||
assert.deepEqual(r.body, {
|
||
customerId: 'c1', art: 'aufwand', projektId: 'p1', daysUntilDue: 14,
|
||
arbeitsblattIds: ['b1', 'b3'],
|
||
items: [{ description: 'Domain-Registrierung', quantity: 1, unitAmountCents: 1200 }],
|
||
zeilentexte: { '2026-10-06': '06.10.2026: Startseite' },
|
||
})
|
||
assert.equal(r.totalCents, null)
|
||
})
|
||
|
||
test('rechnungAnfrage: Aufwand ohne Arbeitsblatt und unvollständige Zusatzpositionen', () => {
|
||
assert.deepEqual(
|
||
rechnungAnfrage(basis({ art: 'aufwand', blaetter: B, abgewaehlt: ['b1', 'b2', 'b3'] })),
|
||
{ ok: false, error: 'Bitte mindestens ein Arbeitsblatt auswählen.' }
|
||
)
|
||
assert.equal(
|
||
rechnungAnfrage(basis({ art: 'aufwand', blaetter: B, zusatz: [zeile(2, 'Domain', '1', '')] })).error,
|
||
'Zusatzposition 1: Der Einzelpreis muss ein Betrag zwischen 0,01 € und 100.000,00 € sein (z. B. 120,00).'
|
||
)
|
||
assert.equal(
|
||
rechnungAnfrage(basis({ art: 'aufwand', blaetter: B, zusatz: [zeile(2, '', '1', '5,00')] })).error,
|
||
'Zusatzposition 1: Bitte eine Beschreibung eingeben.'
|
||
)
|
||
// eine ganz leere Zeile zählt nicht
|
||
const r = rechnungAnfrage(basis({ art: 'aufwand', blaetter: B, zusatz: [zeile(2, '', '1', '')] }))
|
||
assert.equal(r.ok, true)
|
||
assert.equal('items' in r.body, false)
|
||
})
|
||
|
||
test('rechnungAnfrage: Anzahlung in Prozent oder in Euro mit Bezeichnung', () => {
|
||
const prozent = rechnungAnfrage(basis({ art: 'anzahlung', auftragId: 'a1', anzahlung: { modus: 'prozent', wert: '33,5', bezeichnung: ' Teilrechnung ' } }))
|
||
assert.deepEqual(prozent.body, {
|
||
customerId: 'c1', art: 'anzahlung', projektId: 'p1', auftragId: 'a1', daysUntilDue: 14,
|
||
anzahlung: { prozent: 33.5, bezeichnung: 'Teilrechnung' },
|
||
})
|
||
const betrag = rechnungAnfrage(basis({ art: 'anzahlung', auftragId: 'a1', anzahlung: { modus: 'betrag', wert: '400,00', bezeichnung: 'Anzahlung' } }))
|
||
assert.deepEqual(betrag.body.anzahlung, { betragCents: 40000, bezeichnung: 'Anzahlung' })
|
||
assert.equal(BEZEICHNUNG_MAX, 60)
|
||
})
|
||
|
||
test('rechnungAnfrage: Anzahlung prüft AB, Prozent, Betrag und Bezeichnung', () => {
|
||
const an = (anzahlung, auftragId = 'a1') => rechnungAnfrage(basis({ art: 'anzahlung', auftragId, anzahlung }))
|
||
assert.equal(an({ modus: 'prozent', wert: '50', bezeichnung: 'Anzahlung' }, '').error, 'Bitte eine Auftragsbestätigung wählen.')
|
||
for (const wert of ['0', '0,00', '101', 'abc', '']) {
|
||
assert.equal(an({ modus: 'prozent', wert, bezeichnung: 'Anzahlung' }).error, 'Der Prozentsatz muss größer als 0 und höchstens 100 sein.', wert)
|
||
}
|
||
for (const wert of ['0,5', '100']) assert.equal(an({ modus: 'prozent', wert, bezeichnung: 'Anzahlung' }).ok, true, wert)
|
||
assert.equal(an({ modus: 'betrag', wert: 'abc', bezeichnung: 'Anzahlung' }).error, 'Der Betrag muss zwischen 0,01 € und 100.000,00 € liegen.')
|
||
assert.equal(an({ modus: 'prozent', wert: '50', bezeichnung: ' ' }).error, 'Bitte eine Bezeichnung eingeben (höchstens 60 Zeichen).')
|
||
assert.equal(an({ modus: 'prozent', wert: '50', bezeichnung: 'x'.repeat(61) }).error, 'Bitte eine Bezeichnung eingeben (höchstens 60 Zeichen).')
|
||
})
|
||
|
||
test('rechnungAnfrage: Schlussrechnung mit Nachträgen; die Vorschau trägt weder Zahlungsziel noch Notiz', () => {
|
||
const e = basis({ art: 'schluss', auftragId: 'a1', zusatz: [zeile(2, 'Nachtrag Logo', '1', '150,00')], memo: 'Danke' })
|
||
const items = [{ description: 'Nachtrag Logo', quantity: 1, unitAmountCents: 15000 }]
|
||
assert.deepEqual(rechnungAnfrage(e).body, {
|
||
customerId: 'c1', art: 'schluss', projektId: 'p1', auftragId: 'a1', items, daysUntilDue: 14, memo: 'Danke',
|
||
})
|
||
assert.deepEqual(vorschauAnfrage(e), { ok: true, body: { customerId: 'c1', art: 'schluss', projektId: 'p1', auftragId: 'a1', items } })
|
||
assert.deepEqual(rechnungAnfrage(basis({ art: 'schluss', auftragId: '' })), { ok: false, error: 'Bitte eine Auftragsbestätigung wählen.' })
|
||
})
|
||
|
||
test('vorschauAnfrage: Festbetrag hat keine Vorschau; Zahlungsziel und Notiz blockieren sie nie', () => {
|
||
assert.deepEqual(vorschauAnfrage(basis()), { ok: false, error: '' })
|
||
assert.deepEqual(vorschauAnfrage(basis({ art: 'frei', projektId: '' })), { ok: false, error: '' })
|
||
const e = basis({ art: 'schluss', auftragId: 'a1', days: 'abc', memo: 'x'.repeat(1001) })
|
||
assert.equal(vorschauAnfrage(e).ok, true)
|
||
assert.equal(rechnungAnfrage(e).error, 'Das Zahlungsziel muss eine ganze Zahl von 0 bis 60 Tagen sein.')
|
||
assert.deepEqual(vorschauAnfrage(basis({ art: 'aufwand', kunde: null })), { ok: false, error: 'Bitte einen Kunden wählen.' })
|
||
})
|
||
|
||
test('vorschauSchluessel: gleiche Auswahl in anderer Reihenfolge ist derselbe Schlüssel, Texte zählen nicht', () => {
|
||
const key = (over) => vorschauSchluessel(vorschauAnfrage(basis({ art: 'aufwand', blaetter: B, ...over })).body)
|
||
const k1 = key({})
|
||
assert.equal(key({ blaetter: [B[2], B[0], B[1]] }), k1)
|
||
assert.notEqual(key({ abgewaehlt: ['b2'] }), k1)
|
||
assert.equal(key({ zeilentexte: { '2026-10-06': 'x' }, zeitraum: 'Oktober', zeitraumGeaendert: true }), k1)
|
||
assert.notEqual(key({ zusatz: [zeile(2, 'Domain', '1', '12,00')] }), k1)
|
||
})
|
||
|
||
test('vorschauStatus: nicht nötig, ungültig, lädt, veraltet, Fehler, bereit', () => {
|
||
const ok = { ok: true, body: {} }
|
||
const fertig = { key: 'k1', status: 'ok', daten: { summeCents: 30000, positionen: [] } }
|
||
const status = (args) => vorschauStatus({ art: 'aufwand', anfrage: ok, vorschau: fertig, schluessel: 'k1', ...args })
|
||
assert.deepEqual(
|
||
vorschauStatus({ art: 'festbetrag', anfrage: { ok: false, error: '' }, vorschau: null, schluessel: '' }),
|
||
{ state: 'nicht-noetig', message: '' }
|
||
)
|
||
assert.deepEqual(
|
||
status({ anfrage: { ok: false, error: 'Bitte mindestens ein Arbeitsblatt auswählen.' }, schluessel: '' }),
|
||
{ state: 'ungueltig', message: 'Bitte mindestens ein Arbeitsblatt auswählen.' }
|
||
)
|
||
assert.deepEqual(status({ vorschau: null }), { state: 'laedt', message: '' })
|
||
assert.equal(status({ vorschau: { key: 'k1', status: 'laedt' } }).state, 'laedt')
|
||
assert.equal(status({ schluessel: 'k2' }).state, 'laedt') // veraltet: die Eingabe hat sich geändert
|
||
assert.deepEqual(
|
||
status({ vorschau: { key: 'k1', status: 'fehler', message: 'Arbeitsblatt bereits abgerechnet' } }),
|
||
{ state: 'fehler', message: 'Arbeitsblatt bereits abgerechnet' }
|
||
)
|
||
assert.deepEqual(
|
||
status({ vorschau: { key: 'k1', status: 'ok', daten: { summeCents: 0, positionen: [] } } }),
|
||
{ state: 'fehler', message: 'Nichts mehr offen.' }
|
||
)
|
||
assert.deepEqual(status({}), { state: 'bereit', message: '' })
|
||
assert.equal(darfSpeichern({ state: 'bereit' }), true)
|
||
assert.equal(darfSpeichern({ state: 'nicht-noetig' }), true)
|
||
for (const state of ['laedt', 'ungueltig', 'fehler']) assert.equal(darfSpeichern({ state }), false, state)
|
||
})
|
||
|
||
test('Abwahl eines Arbeitsblatts macht die Vorschau veraltet und sperrt Entwurf und Senden', () => {
|
||
const e1 = basis({ art: 'aufwand', blaetter: B })
|
||
const a1 = vorschauAnfrage(e1)
|
||
const k1 = vorschauSchluessel(a1.body)
|
||
const vorschau = { key: k1, status: 'ok', daten: { summeCents: 32500, positionen: [] } }
|
||
assert.equal(darfSpeichern(vorschauStatus({ art: 'aufwand', anfrage: a1, vorschau, schluessel: k1 })), true)
|
||
const a2 = vorschauAnfrage({ ...e1, abgewaehlt: ['b2'] })
|
||
const k2 = vorschauSchluessel(a2.body)
|
||
assert.deepEqual(a2.body.arbeitsblattIds, ['b1', 'b3'])
|
||
assert.notEqual(k2, k1)
|
||
assert.equal(darfSpeichern(vorschauStatus({ art: 'aufwand', anfrage: a2, vorschau, schluessel: k2 })), false)
|
||
})
|
||
|
||
test('zeileTeilen, zeileBearbeitbar und maxVorn: nur Aufwandszeilen sind bearbeitbar, geteilt wird am letzten Gedankenstrich', () => {
|
||
const tag = '06.10.2026: Startseite, Kontaktformular – 2,25 Std. à 100,00 €'
|
||
assert.deepEqual(zeileTeilen(tag), { vorn: '06.10.2026: Startseite, Kontaktformular', hinten: ' – 2,25 Std. à 100,00 €' })
|
||
assert.deepEqual(zeileTeilen('KW 41/2026: A – B – 6,5 Std. à 100,00 €'), { vorn: 'KW 41/2026: A – B', hinten: ' – 6,5 Std. à 100,00 €' })
|
||
assert.deepEqual(zeileTeilen('Domain-Registrierung'), { vorn: 'Domain-Registrierung', hinten: '' })
|
||
const pos = (schluessel, beschreibung = tag) => ({ schluessel, beschreibung })
|
||
assert.equal(zeileBearbeitbar(pos('2026-10-06')), true)
|
||
assert.equal(zeileBearbeitbar(pos('KW-2026-41')), true)
|
||
for (const schluessel of ['ab-1', 'zusatz-1', 'abzug-in_123', 'anzahlung']) assert.equal(zeileBearbeitbar(pos(schluessel)), false, schluessel)
|
||
assert.equal(zeileBearbeitbar(pos('2026-10-06', 'ohne Strich')), false)
|
||
const hinten = ' – 2,25 Std. à 100,00 €'
|
||
assert.equal(maxVorn(hinten), 200 - hinten.length)
|
||
assert.equal(maxVorn('x'.repeat(250)), 1)
|
||
})
|
||
|
||
const okAntwort = { rechnung: { id: 'in_1', number: 'WEBKLAR-0009', status: 'offen', customerEmail: 'anelia@example.de' } }
|
||
const anfrage = rechnungAnfrage(basis())
|
||
|
||
test('createSubmitter: Entwurf fragt nicht nach und sendet senden=false', async () => {
|
||
const gesendet = []
|
||
const submit = createSubmitter({
|
||
create: async (body) => (gesendet.push(body), okAntwort),
|
||
confirm: () => assert.fail('beim Entwurf gibt es keine Rückfrage'),
|
||
})
|
||
const r = await submit({ anfrage, senden: false, kunde, totalCents: 50000 })
|
||
assert.deepEqual(r, { status: 'ok', rechnung: okAntwort.rechnung, senden: false })
|
||
assert.equal(gesendet[0].senden, false)
|
||
assert.equal(gesendet[0].art, 'festbetrag')
|
||
})
|
||
|
||
test('createSubmitter: Senden fragt vorher nach, bei „Abbrechen“ geht nichts raus', async () => {
|
||
let frage = ''
|
||
let create = 0
|
||
const submit = createSubmitter({ create: async () => { create += 1; return okAntwort }, confirm: (text) => { frage = text; return false } })
|
||
assert.deepEqual(await submit({ anfrage, senden: true, kunde, totalCents: 50000 }), { status: 'abgebrochen' })
|
||
assert.equal(create, 0)
|
||
assert.equal(frage, 'Rechnung für Anelia Wolf über 500,00 € jetzt festschreiben und an anelia@example.de senden? Danach lässt sie sich nur noch stornieren.')
|
||
})
|
||
|
||
test('createSubmitter: Adress-Sperre über 250 € ohne Anschrift gilt auch hier', async () => {
|
||
let create = 0
|
||
const submit = createSubmitter({ create: async () => { create += 1; return okAntwort }, confirm: () => true })
|
||
const ohneAdresse = { ...kunde, street: '' }
|
||
assert.deepEqual(await submit({ anfrage, senden: true, kunde: ohneAdresse, totalCents: 25001 }), { status: 'fehler', message: ADDRESS_INCOMPLETE_TEXT })
|
||
assert.equal(create, 0)
|
||
assert.equal((await submit({ anfrage, senden: true, kunde: ohneAdresse, totalCents: 25000 })).status, 'ok') // Kleinbetrag
|
||
assert.equal((await submit({ anfrage, senden: false, kunde: ohneAdresse, totalCents: 25001 })).status, 'ok') // Entwurf bleibt möglich
|
||
})
|
||
|
||
test('createSubmitter: Doppelklick auf Senden legt nur eine Rechnung an', async () => {
|
||
let create = 0
|
||
let fertig
|
||
const submit = createSubmitter({
|
||
create: () => { create += 1; return new Promise((resolve) => { fertig = () => resolve(okAntwort) }) },
|
||
confirm: () => true,
|
||
})
|
||
const erster = submit({ anfrage, senden: true, kunde, totalCents: 50000 })
|
||
const zweiter = await submit({ anfrage, senden: true, kunde, totalCents: 50000 })
|
||
assert.deepEqual(zweiter, { status: 'laeuft' })
|
||
fertig()
|
||
assert.equal((await erster).status, 'ok')
|
||
assert.equal(create, 1)
|
||
// danach geht wieder ein Aufruf (nach einem Fehler muss der Nutzer es erneut versuchen können)
|
||
const dritter = submit({ anfrage, senden: false, kunde, totalCents: 50000 })
|
||
fertig()
|
||
assert.equal((await dritter).status, 'ok')
|
||
assert.equal(create, 2)
|
||
})
|
||
|
||
test('createSubmitter: Fehler des Servers kommen als Meldung zurück, auch 409 und „festgeschrieben“', async () => {
|
||
const wirft = (err) => createSubmitter({ create: async () => { throw err }, confirm: () => true })
|
||
const konflikt = Object.assign(new Error('Arbeitsblatt bereits abgerechnet (Rechnung WEBKLAR-0009).'), { status: 409 })
|
||
assert.deepEqual(await wirft(konflikt)({ anfrage, senden: false, kunde, totalCents: 1 }), {
|
||
status: 'fehler', message: 'Arbeitsblatt bereits abgerechnet (Rechnung WEBKLAR-0009).', httpStatus: 409,
|
||
})
|
||
const ohneStatus = new Error('Irgendwas ist schiefgegangen.')
|
||
assert.deepEqual(await wirft(ohneStatus)({ anfrage, senden: false, kunde, totalCents: 1 }), { status: 'fehler', message: 'Irgendwas ist schiefgegangen.' })
|
||
const festgeschrieben = Object.assign(new Error('Rechnung WEBKLAR-0009 wurde festgeschrieben, aber nicht versendet. Bitte erneut senden.'), {
|
||
status: 502, invoiceId: 'in_9', invoiceNumber: 'WEBKLAR-0009',
|
||
})
|
||
assert.deepEqual(await wirft(festgeschrieben)({ anfrage, senden: true, kunde, totalCents: 50000 }), {
|
||
status: 'festgeschrieben',
|
||
notice: 'Rechnung WEBKLAR-0009 wurde festgeschrieben, aber nicht versendet. Bitte in der Liste erneut senden.',
|
||
finalizedFilter: 'offen',
|
||
})
|
||
})
|
||
|
||
test('createSubmitter: eine ungültige Anfrage geht nie an den Server', async () => {
|
||
let create = 0
|
||
const submit = createSubmitter({ create: async () => { create += 1 }, confirm: () => true })
|
||
const r = await submit({ anfrage: { ok: false, error: 'Bitte einen Kunden wählen.' }, senden: false, kunde, totalCents: 0 })
|
||
assert.deepEqual(r, { status: 'fehler', message: 'Bitte einen Kunden wählen.' })
|
||
assert.equal(create, 0)
|
||
})
|