Finanzen: Formatierung, Betragsparser und Portal-API-Client

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-01 15:12:18 +00:00
1 parent 8ecf07fecd
commit c910bedcec
@@ -0,0 +1,247 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { loadModule } from './load.mjs'
+
+const {
+  euro,
+  euroWhole,
+  signedEuro,
+  dateDe,
+  sinceLabel,
+  parseEuro,
+  INVOICE_STATUS,
+  CATEGORY_LABEL,
+  URGENCY,
+  AGE_GROUP_LABEL,
+  pageOf,
+  canInvoice,
+} = await loadModule('src/lib/financeFormat.js')
+
+const MINUS = '−'
+
+test('euro: de-DE mit Tausenderpunkt und Komma, Leerzeichen vor dem Euro-Zeichen', () => {
+  assert.equal(euro(123456), '1.234,56 €')
+  assert.equal(euro(10893), '108,93 €')
+  assert.equal(euro(0), '0,00 €')
+  assert.equal(euro(5), '0,05 €')
+  assert.equal(euro(100), '1,00 €')
+  assert.equal(euro(100000000), '1.000.000,00 €')
+})
+
+test('euro: Platzhalter für fehlende Werte', () => {
+  assert.equal(euro(null), '–')
+  assert.equal(euro(undefined), '–')
+  assert.equal(euro(NaN), '–')
+  assert.equal(euro('abc'), '–')
+})
+
+test('euro: negative Beträge mit Minuszeichen U+2212', () => {
+  assert.equal(euro(-449), `${MINUS}4,49 €`)
+  assert.equal(euro(-123456), `${MINUS}1.234,56 €`)
+  assert.equal(euro(-5), `${MINUS}0,05 €`)
+  assert.equal(euro(-0), '0,00 €')
+})
+
+test('euroWhole: auf ganze Euro gerundet', () => {
+  assert.equal(euroWhole(10893), '109 €')
+  assert.equal(euroWhole(10849), '108 €')
+  assert.equal(euroWhole(10850), '109 €')
+  assert.equal(euroWhole(0), '0 €')
+  assert.equal(euroWhole(123456), '1.235 €')
+  assert.equal(euroWhole(null), '–')
+  assert.equal(euroWhole(undefined), '–')
+})
+
+test('euroWhole: negative Werte, keine „−0 €“', () => {
+  assert.equal(euroWhole(-10893), `${MINUS}109 €`)
+  assert.equal(euroWhole(-49), '0 €')
+  assert.equal(euroWhole(-50), `${MINUS}1 €`)
+})
+
+test('signedEuro: immer mit Vorzeichen, Minus ist U+2212', () => {
+  assert.equal(signedEuro(16879), '+168,79 €')
+  assert.equal(signedEuro(-449), `${MINUS}4,49 €`)
+  assert.equal(signedEuro(-449).charAt(0), '−')
+  assert.equal(signedEuro(123456), '+1.234,56 €')
+  assert.equal(signedEuro(-123456), `${MINUS}1.234,56 €`)
+  assert.equal(signedEuro(0), '0,00 €')
+  assert.equal(signedEuro(null), '–')
+  assert.equal(signedEuro(undefined), '–')
+})
+
+test('dateDe: ISO-Datum zu TT.MM.JJJJ', () => {
+  assert.equal(dateDe('2027-03-29'), '29.03.2027')
+  assert.equal(dateDe('2026-01-05'), '05.01.2026')
+})
+
+test('dateDe: ISO-Zeitpunkt in Berliner Zeit, Platzhalter für Ungültiges', () => {
+  assert.equal(dateDe('2099-03-29T00:00:00.000Z'), '29.03.2099')
+  // 23:30 UTC im Sommer = 01:30 am Folgetag in Berlin
+  assert.equal(dateDe('2026-07-01T23:30:00.000Z'), '02.07.2026')
+  assert.equal(dateDe(''), '–')
+  assert.equal(dateDe(null), '–')
+  assert.equal(dateDe(undefined), '–')
+  assert.equal(dateDe('kein Datum'), '–')
+})
+
+test('sinceLabel: gerade eben / Minuten / Stunden / Tage', () => {
+  const now = Date.parse('2026-10-01T12:00:00.000Z')
+  const ago = (ms) => new Date(now - ms).toISOString()
+  assert.equal(sinceLabel(ago(0), now), 'gerade eben')
+  assert.equal(sinceLabel(ago(59 * 1000), now), 'gerade eben')
+  assert.equal(sinceLabel(ago(60 * 1000), now), 'vor 1 Min.')
+  assert.equal(sinceLabel(ago(12 * 60000), now), 'vor 12 Min.')
+  assert.equal(sinceLabel(ago(59 * 60000), now), 'vor 59 Min.')
+  assert.equal(sinceLabel(ago(60 * 60000), now), 'vor 1 Std.')
+  assert.equal(sinceLabel(ago(3 * 3600000), now), 'vor 3 Std.')
+  assert.equal(sinceLabel(ago(23 * 3600000), now), 'vor 23 Std.')
+  assert.equal(sinceLabel(ago(24 * 3600000), now), 'vor 1 Tag')
+  assert.equal(sinceLabel(ago(2 * 86400000), now), 'vor 2 Tagen')
+  assert.equal(sinceLabel(ago(40 * 86400000), now), 'vor 40 Tagen')
+})
+
+test('sinceLabel: Zukunft, Date als now, fehlende Werte', () => {
+  const now = Date.parse('2026-10-01T12:00:00.000Z')
+  assert.equal(sinceLabel(new Date(now + 5 * 60000).toISOString(), now), 'gerade eben')
+  assert.equal(sinceLabel('2026-10-01T11:48:00.000Z', new Date(now)), 'vor 12 Min.')
+  assert.equal(sinceLabel(null, now), '–')
+  assert.equal(sinceLabel('Quatsch', now), '–')
+})
+
+test('parseEuro: Tausenderpunkte und Dezimalkomma', () => {
+  assert.equal(parseEuro('1.234,56'), 123456)
+  assert.equal(parseEuro('12,50'), 1250)
+  assert.equal(parseEuro('12,5'), 1250)
+  assert.equal(parseEuro('1234'), 123400)
+  assert.equal(parseEuro('1234,5'), 123450)
+  assert.equal(parseEuro('0,05'), 5)
+  assert.equal(parseEuro('0'), 0)
+  assert.equal(parseEuro('0,00'), 0)
+  assert.equal(parseEuro('1.234'), 123400)
+  assert.equal(parseEuro('1.234.567,89'), 123456789)
+  assert.equal(parseEuro('19,99'), 1999)
+})
+
+test('parseEuro: Leerraum und Euro-Zeichen werden toleriert', () => {
+  assert.equal(parseEuro('  12,50  '), 1250)
+  assert.equal(parseEuro('12,50 €'), 1250)
+  assert.equal(parseEuro('12,50€'), 1250)
+  assert.equal(parseEuro('€ 12,50'), 1250)
+})
+
+test('parseEuro: ergibt exakte Cent (keine Gleitkomma-Fehler)', () => {
+  assert.equal(parseEuro('19,99'), 1999)
+  assert.equal(parseEuro('0,29'), 29)
+  assert.equal(parseEuro('1,15'), 115)
+  assert.equal(parseEuro('4,35'), 435)
+  assert.ok(Number.isInteger(parseEuro('1.234,56')))
+})
+
+test('parseEuro: ungültige Eingaben werfen „Ungültiger Betrag“', () => {
+  const bad = [
+    '', '   ', 'abc', '12abc', '1,2,3', '12,345', '1,234', '12.50', '1.23', '1.2345',
+    '1..234', '1.234,5,6', ',5', '.5', '12,', '1.', '-5', '-0', '+5', '−5', '1e3',
+    '12 34', '1 234,56', '0.500', '€', '12,50 € 3', '١٢', '１２',
+  ]
+  for (const text of bad) {
+    assert.throws(() => parseEuro(text), { message: 'Ungültiger Betrag' }, `sollte werfen: ${JSON.stringify(text)}`)
+  }
+})
+
+test('parseEuro: Nicht-Strings und zu große Werte werfen', () => {
+  for (const v of [null, undefined, 12.5, {}, [], true]) {
+    assert.throws(() => parseEuro(v), { message: 'Ungültiger Betrag' })
+  }
+  assert.throws(() => parseEuro('99999999999999999999'), { message: 'Ungültiger Betrag' })
+})
+
+test('Status- und Beschriftungstabellen (verbatim)', () => {
+  assert.deepEqual(INVOICE_STATUS, {
+    entwurf: { label: 'Entwurf', tone: 'muted' },
+    offen: { label: 'Offen', tone: 'info' },
+    ueberfaellig: { label: 'Überfällig', tone: 'warn' },
+    bezahlt: { label: 'Bezahlt', tone: 'ok' },
+    storniert: { label: 'Storniert', tone: 'muted' },
+    uneinbringlich: { label: 'Uneinbringlich', tone: 'danger' },
+  })
+  assert.deepEqual(CATEGORY_LABEL, {
+    rechnung: 'Rechnung',
+    'rechnung-extern': 'Einnahme ohne Stripe-Rechnung',
+    'stripe-auszahlung': 'Stripe-Auszahlung',
+    fixkosten: 'Fixkosten',
+    privat: 'Privat/Umbuchung',
+    sonstiges: 'Sonstiges',
+    '': 'Offen',
+  })
+  assert.deepEqual(URGENCY, {
+    hoch: { label: 'Dringend', tone: 'danger' },
+    mittel: { label: 'Bald', tone: 'warn' },
+    info: { label: 'Hinweis', tone: 'muted' },
+  })
+  assert.deepEqual(AGE_GROUP_LABEL, {
+    'nicht-faellig': 'Nicht fällig',
+    '1-30': '1–30 Tage',
+    '31-60': '31–60 Tage',
+    'ueber-60': 'Über 60 Tage',
+  })
+})
+
+test('pageOf: 1-basiert, 50 pro Seite, Standardgröße', () => {
+  const list = Array.from({ length: 120 }, (_, i) => i + 1)
+  const p1 = pageOf(list, 1)
+  assert.equal(p1.items.length, 50)
+  assert.equal(p1.items[0], 1)
+  assert.equal(p1.page, 1)
+  assert.equal(p1.pages, 3)
+  const p3 = pageOf(list, 3)
+  assert.deepEqual(p3.items, list.slice(100))
+  assert.equal(p3.items.length, 20)
+  assert.equal(p3.page, 3)
+  assert.equal(p3.pages, 3)
+})
+
+test('pageOf: Seitenzahl wird begrenzt, eigene Größe, leere Liste', () => {
+  const list = [1, 2, 3, 4, 5]
+  assert.deepEqual(pageOf(list, 99, 2), { items: [5], page: 3, pages: 3 })
+  assert.deepEqual(pageOf(list, 0, 2), { items: [1, 2], page: 1, pages: 3 })
+  assert.deepEqual(pageOf(list, -4, 2), { items: [1, 2], page: 1, pages: 3 })
+  assert.deepEqual(pageOf(list, 'x', 2), { items: [1, 2], page: 1, pages: 3 })
+  assert.deepEqual(pageOf(list, 2.7, 2), { items: [3, 4], page: 2, pages: 3 })
+  assert.deepEqual(pageOf([], 1), { items: [], page: 1, pages: 1 })
+  assert.deepEqual(pageOf(null, 3), { items: [], page: 1, pages: 1 })
+  assert.deepEqual(pageOf(undefined), { items: [], page: 1, pages: 1 })
+  assert.equal(pageOf(Array.from({ length: 50 }, (_, i) => i), 1).pages, 1)
+  assert.equal(pageOf(Array.from({ length: 51 }, (_, i) => i), 1).pages, 2)
+})
+
+test('canInvoice: fester Kunde mit E-Mail ist ok', () => {
+  assert.deepEqual(canInvoice({ customerStatus: 'customer', email: 'k@example.invalid' }), { ok: true })
+  // Bestandsdaten ohne Status gelten als fester Kunde (wie customerStage)
+  assert.deepEqual(canInvoice({ email: 'k@example.invalid' }), { ok: true })
+  assert.deepEqual(canInvoice({ customerStatus: '', email: 'k@example.invalid' }), { ok: true })
+})
+
+test('canInvoice: Lead und Abgesagt sind noch keine festen Kunden', () => {
+  const reason = 'Noch kein fester Kunde'
+  assert.deepEqual(canInvoice({ customerStatus: 'lead', email: 'k@example.invalid' }), { ok: false, reason })
+  assert.deepEqual(canInvoice({ customerStatus: 'lost', email: 'k@example.invalid' }), { ok: false, reason })
+  assert.deepEqual(canInvoice({ customerStatus: 'Lead', email: 'k@example.invalid' }), { ok: false, reason })
+  assert.deepEqual(canInvoice({ customerStatus: ' LOST ', email: 'k@example.invalid' }), { ok: false, reason })
+  // Status hat Vorrang vor fehlender E-Mail
+  assert.deepEqual(canInvoice({ customerStatus: 'lead', email: '' }), { ok: false, reason })
+})
+
+test('canInvoice: ohne E-Mail nicht möglich', () => {
+  const reason = 'E-Mail fehlt'
+  assert.deepEqual(canInvoice({ customerStatus: 'customer' }), { ok: false, reason })
+  assert.deepEqual(canInvoice({ customerStatus: 'customer', email: '' }), { ok: false, reason })
+  assert.deepEqual(canInvoice({ customerStatus: 'customer', email: '   ' }), { ok: false, reason })
+  assert.deepEqual(canInvoice({ customerStatus: 'customer', email: null }), { ok: false, reason })
+  assert.deepEqual(canInvoice({}), { ok: false, reason })
+})
+
+test('canInvoice: kein Kunde', () => {
+  assert.equal(canInvoice(null).ok, false)
+  assert.equal(canInvoice(undefined).ok, false)
+  assert.equal(typeof canInvoice(null).reason, 'string')
+})