Buchungskalender: Preise je Personenzahl (Server)
Jede Staffel darf personenCent tragen (Preis pro Nacht für 1 bis k Personen, k = 2 bis 10), ohne Schemaänderung im JSON-Feld staffeln. pruefePreise prüft Länge, Werte und Gleichheit über alle Staffeln und setzt preisProNachtCent = personenCent[0]. berechnePreis wählt die Spalte der Gästezahl (Posten mit Personenzahl), bei mehr Gästen als Spalten gilt die letzte plus Zusatzperson-Aufpreis. preiseVollstaendig prüft die Konsistenz. Ohne personenCent rechnet alles wie bisher. Tests mit Mimis Preismatrix, Doku in unterkunft-api.md. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
knsoandClaude Opus 5.5 committed
1 parent
b264d7f734
commit
a4ade5f649
5 files changed
+379
-12
No files matched your search
@@ -176,3 +176,147 @@ test('berechnePreis: 20 Personen ueber 548 Naechte besteht pruefePosten', () =>
|
||||
assert.equal(r.posten[1].menge, 18 * 548)
|
||||
assert.ok(pruefePosten(r.posten, 'regel').posten)
|
||||
})
|
||||
|
||||
// ---- Preise je Personenzahl (staffeln[].personenCent): Mimis Monteurwohnung, Preis pro Nacht fuer die ganze Wohnung
|
||||
|
||||
const MIMI = {
|
||||
staffeln: [
|
||||
{ abNaechten: 1, preisProNachtCent: 5500, personenCent: [5500, 7000, 8200] },
|
||||
{ abNaechten: 7, preisProNachtCent: 5000, personenCent: [5000, 6500, 7700] },
|
||||
{ abNaechten: 14, preisProNachtCent: 4500, personenCent: [4500, 6000, 7200] },
|
||||
{ abNaechten: 28, preisProNachtCent: 4000, personenCent: [4000, 5500, 6700] },
|
||||
],
|
||||
reinigungCent: 4000,
|
||||
personenInklusive: 2,
|
||||
aufpreisPersonNachtCent: 1500,
|
||||
direktrabattProzent: 0,
|
||||
steuerart: 'kleinunternehmer',
|
||||
ustUebernachtung: 0,
|
||||
ustReinigung: 0,
|
||||
}
|
||||
const mimi = (n, personen, extra = {}) => berechnePreis({ preise: { ...MIMI, ...extra }, von: '2026-11-01', bis: plusTage('2026-11-01', n), personen })
|
||||
|
||||
test('Personenpreise: Mimis Matrix (Naechte x Personen) mit Endreinigung 40 EUR', () => {
|
||||
const erwartet = [
|
||||
// [Naechte, Personen, Preis pro Nacht in Cent]
|
||||
[3, 1, 5500], [3, 2, 7000], [3, 3, 8200],
|
||||
[6, 3, 8200], [7, 1, 5000], [7, 2, 6500], [7, 3, 7700],
|
||||
[13, 3, 7700], [14, 1, 4500], [14, 2, 6000], [14, 3, 7200],
|
||||
[27, 3, 7200], [28, 1, 4000], [28, 2, 5500], [28, 3, 6700], [30, 3, 6700],
|
||||
]
|
||||
for (const [n, p, nacht] of erwartet) {
|
||||
const r = mimi(n, p)
|
||||
assert.equal(r.posten[0].einzelCent, nacht, `${n} Naechte, ${p} Personen`)
|
||||
assert.equal(r.posten[0].menge, n)
|
||||
assert.equal(r.summen.bruttoCent, n * nacht + 4000, `${n} Naechte, ${p} Personen`)
|
||||
}
|
||||
assert.equal(mimi(7, 3).summen.bruttoCent, 57900)
|
||||
assert.equal(mimi(3, 2).summen.bruttoCent, 25000)
|
||||
assert.equal(mimi(28, 1).summen.bruttoCent, 116000)
|
||||
assert.equal(mimi(30, 3).summen.bruttoCent, 205000)
|
||||
})
|
||||
|
||||
test('Personenpreise: Postentexte mit Personenzahl, kein Zusatzperson-Posten', () => {
|
||||
const r = mimi(7, 3)
|
||||
assert.deepEqual(r.posten, [
|
||||
{ text: 'Übernachtung, 7 Nächte, 3 Personen', menge: 7, einzelCent: 7700, ustProzent: 0 },
|
||||
{ text: 'Endreinigung', menge: 1, einzelCent: 4000, ustProzent: 0 },
|
||||
])
|
||||
assert.equal(mimi(7, 1).posten[0].text, 'Übernachtung, 7 Nächte, 1 Person')
|
||||
assert.equal(mimi(7, 2).posten[0].text, 'Übernachtung, 7 Nächte, 2 Personen')
|
||||
assert.equal(mimi(1, 2).posten[0].text, 'Übernachtung, 1 Nächte, 2 Personen', 'Stil des bisherigen Textes: immer "Nächte"')
|
||||
assert.ok(pruefePosten(mimi(30, 3).posten, 'kleinunternehmer').posten)
|
||||
})
|
||||
|
||||
test('Personenpreise: personenInklusive wird ignoriert', () => {
|
||||
const a = mimi(7, 3, { personenInklusive: 1 })
|
||||
const b = mimi(7, 3, { personenInklusive: 3 })
|
||||
assert.deepEqual(a, b)
|
||||
assert.equal(a.posten.length, 2)
|
||||
})
|
||||
|
||||
test('Personenpreise: mehr Gaeste als Preisspalten = letzte Spalte + Zusatzperson-Posten', () => {
|
||||
const r = mimi(7, 5)
|
||||
assert.deepEqual(r.posten, [
|
||||
{ text: 'Übernachtung, 7 Nächte, 3 Personen', menge: 7, einzelCent: 7700, ustProzent: 0 },
|
||||
{ text: 'Zusatzpersonen (2), 7 Nächte', menge: 14, einzelCent: 1500, ustProzent: 0 },
|
||||
{ text: 'Endreinigung', menge: 1, einzelCent: 4000, ustProzent: 0 },
|
||||
])
|
||||
assert.equal(r.summen.bruttoCent, 7 * 7700 + 14 * 1500 + 4000)
|
||||
assert.equal(mimi(7, 4).posten[1].text, 'Zusatzperson (1), 7 Nächte')
|
||||
// ohne Aufpreis kein Zusatzperson-Posten
|
||||
const ohne = mimi(7, 5, { aufpreisPersonNachtCent: 0 })
|
||||
assert.equal(ohne.posten.length, 2)
|
||||
assert.equal(ohne.posten[0].text, 'Übernachtung, 7 Nächte, 3 Personen')
|
||||
})
|
||||
|
||||
test('Personenpreise: Direktrabatt auf Uebernachtung und Zusatzpersonen, nicht auf die Reinigung', () => {
|
||||
const r = mimi(7, 5, { direktrabattProzent: 10 })
|
||||
// Basis 7*7700 + 14*1500 = 74900; 10 % = 7490
|
||||
assert.equal(r.posten.at(-1).text, 'Direktbuchungsrabatt 10 %')
|
||||
assert.equal(r.posten.at(-1).einzelCent, -7490)
|
||||
assert.equal(r.summen.bruttoCent, 74900 + 4000 - 7490)
|
||||
const einfach = mimi(7, 2, { direktrabattProzent: 10 })
|
||||
assert.equal(einfach.posten.at(-1).einzelCent, -Math.round((7 * 6500 * 10) / 100))
|
||||
assert.equal(einfach.summen.bruttoCent, 45500 + 4000 - 4550)
|
||||
})
|
||||
|
||||
test('Personenpreise: Regelbesteuerung 7 % Uebernachtung, 19 % Reinigung', () => {
|
||||
const r = mimi(7, 3, { steuerart: 'regel', ustUebernachtung: 7, ustReinigung: 19 })
|
||||
assert.deepEqual(r.posten.map((p) => p.ustProzent), [7, 19])
|
||||
assert.equal(r.summen.bruttoCent, 57900)
|
||||
assert.deepEqual(r.summen.ust, [
|
||||
{ satz: 7, nettoCent: Math.round((53900 * 100) / 107), steuerCent: 53900 - Math.round((53900 * 100) / 107) },
|
||||
{ satz: 19, nettoCent: Math.round((4000 * 100) / 119), steuerCent: 4000 - Math.round((4000 * 100) / 119) },
|
||||
])
|
||||
assert.equal(r.summen.ust.reduce((a, u) => a + u.nettoCent + u.steuerCent, 0), 57900)
|
||||
})
|
||||
|
||||
test('Personenpreise: Staffelwahl wie bisher (hoechste abNaechten <= Naechte), ungeordnete Eingabe', () => {
|
||||
const gemischt = { ...MIMI, staffeln: [...MIMI.staffeln].reverse() }
|
||||
assert.equal(berechnePreis({ preise: gemischt, von: '2026-11-01', bis: plusTage('2026-11-01', 20), personen: 2 }).posten[0].einzelCent, 6000)
|
||||
})
|
||||
|
||||
test('Personenpreise: Personenzahl kleiner 1 oder keine Zahl rechnet wie 1 Person', () => {
|
||||
assert.equal(mimi(7, 0).posten[0].einzelCent, 5000)
|
||||
assert.equal(mimi(7, NaN).posten[0].einzelCent, 5000)
|
||||
})
|
||||
|
||||
test('Alter Modus ohne personenCent rechnet unveraendert (Text ohne Personenangabe)', () => {
|
||||
const r = berechnePreis({ preise: PREISE, von: '2026-11-02', bis: '2026-11-09', personen: 3 })
|
||||
assert.deepEqual(r.posten.slice(0, 2), [
|
||||
{ text: 'Übernachtung, 7 Nächte', menge: 7, einzelCent: 5500, ustProzent: 7 },
|
||||
{ text: 'Zusatzperson (1), 7 Nächte', menge: 7, einzelCent: 1000, ustProzent: 7 },
|
||||
])
|
||||
// personenCent: null zaehlt als nicht vorhanden
|
||||
const mitNull = { ...PREISE, staffeln: PREISE.staffeln.map((s) => ({ ...s, personenCent: null })) }
|
||||
assert.deepEqual(berechnePreis({ preise: mitNull, von: '2026-11-02', bis: '2026-11-09', personen: 3 }), r)
|
||||
})
|
||||
|
||||
test('preiseVollstaendig mit personenCent: konsistent ja, sonst nein', () => {
|
||||
const f = (staffeln) => preiseVollstaendig({ ...MIMI, staffeln })
|
||||
const st = (o = {}) => MIMI.staffeln.map((s, i) => ({ ...s, ...(typeof o === 'function' ? o(s, i) : o) }))
|
||||
assert.equal(preiseVollstaendig(MIMI), true)
|
||||
assert.equal(f(st()), true)
|
||||
// nur eine Staffel hat personenCent
|
||||
assert.equal(f(st((s, i) => (i === 2 ? { personenCent: undefined } : {}))), false)
|
||||
// ungleiche Laengen
|
||||
assert.equal(f(st((s, i) => (i === 1 ? { personenCent: s.personenCent.slice(0, 2) } : {}))), false)
|
||||
// Laenge 1 und 11
|
||||
assert.equal(f(st((s) => ({ personenCent: [s.preisProNachtCent] }))), false)
|
||||
assert.equal(f(st((s) => ({ personenCent: Array(11).fill(s.preisProNachtCent) }))), false)
|
||||
assert.equal(f(st((s) => ({ personenCent: Array(10).fill(s.preisProNachtCent) }))), true)
|
||||
assert.equal(f(st((s) => ({ personenCent: [s.preisProNachtCent, s.preisProNachtCent] }))), true)
|
||||
// ungueltige Werte
|
||||
assert.equal(f(st((s, i) => (i === 0 ? { personenCent: [5500, 99, 8200] } : {}))), false)
|
||||
assert.equal(f(st((s, i) => (i === 0 ? { personenCent: [5500, 100001, 8200] } : {}))), false)
|
||||
assert.equal(f(st((s, i) => (i === 0 ? { personenCent: [5500, 7000.5, 8200] } : {}))), false)
|
||||
assert.equal(f(st((s, i) => (i === 0 ? { personenCent: [5500, '7000', 8200] } : {}))), false)
|
||||
assert.equal(f(st((s, i) => (i === 0 ? { personenCent: 'x' } : {}))), false)
|
||||
// preisProNachtCent muss personenCent[0] sein
|
||||
assert.equal(f(st((s, i) => (i === 3 ? { preisProNachtCent: 4100 } : {}))), false)
|
||||
// null zaehlt als nicht vorhanden
|
||||
assert.equal(preiseVollstaendig({ ...PREISE, staffeln: PREISE.staffeln.map((s) => ({ ...s, personenCent: null })) }), true)
|
||||
// alter Modus mit personenCent in nur einer Staffel
|
||||
assert.equal(preiseVollstaendig({ ...PREISE, staffeln: [{ ...PREISE.staffeln[0], personenCent: [6500, 7500] }, PREISE.staffeln[1], PREISE.staffeln[2]] }), false)
|
||||
})
|
||||
@@ -24,7 +24,7 @@ const zahlung = await import('../server/services/unterkunft/zahlung.js')
|
||||
const { UkFehler } = await import('../server/services/unterkunft/fehler.js')
|
||||
const { default: ukRoutes, resetUnterkunftRoutesForTests } = await import('../server/routes/unterkunft.js')
|
||||
const { kundenansichtGuard } = await import('../server/middleware/kundenansichtGuard.js')
|
||||
const { pruefeIcalUrl, pruefePreise, pruefeEinstellungen } = await import('../server/services/unterkunft/verwaltung.js')
|
||||
const { pruefeIcalUrl, pruefePreise, pruefeEinstellungen, STAFFELN_MAX_ZEICHEN } = await import('../server/services/unterkunft/verwaltung.js')
|
||||
const app = await startTestApp({ '/': kundenansichtGuard, '/api/unterkunft': ukRoutes })
|
||||
after(() => Promise.all([app.close(), aw.close(), st.close()]))
|
||||
|
||||
@@ -257,6 +257,128 @@ test('Preise: erste Staffel abNaechten:2, absteigend, mehr als 6, Preisgrenzen,
|
||||
assert.ok(pruefePreise(PREISE).werte)
|
||||
})
|
||||
|
||||
// Preise je Personenzahl (staffeln[].personenCent)
|
||||
const MIMI_PREISE = {
|
||||
...PREISE,
|
||||
staffeln: [
|
||||
{ abNaechten: 1, preisProNachtCent: 5500, personenCent: [5500, 7000, 8200] },
|
||||
{ abNaechten: 7, preisProNachtCent: 5000, personenCent: [5000, 6500, 7700] },
|
||||
{ abNaechten: 14, preisProNachtCent: 4500, personenCent: [4500, 6000, 7200] },
|
||||
{ abNaechten: 28, preisProNachtCent: 4000, personenCent: [4000, 5500, 6700] },
|
||||
],
|
||||
reinigungCent: 4000, personenInklusive: 2, aufpreisPersonNachtCent: 0, direktrabattProzent: 0, steuerart: 'kleinunternehmer',
|
||||
}
|
||||
const mitStaffeln = (staffeln) => pruefePreise({ ...MIMI_PREISE, staffeln })
|
||||
const einzelne = (personenCent, extra = {}) => mitStaffeln([{ abNaechten: 1, preisProNachtCent: personenCent?.[0] ?? 5500, personenCent, ...extra }])
|
||||
|
||||
test('pruefePreise: Preise je Personenzahl gueltig, personenCent wird sauber uebernommen', () => {
|
||||
const r = pruefePreise(MIMI_PREISE)
|
||||
assert.deepEqual(r.fehler, undefined)
|
||||
assert.deepEqual(r.werte.staffeln, MIMI_PREISE.staffeln)
|
||||
assert.equal(r.werte.staffeln[0].personenCent !== MIMI_PREISE.staffeln[0].personenCent, true, 'Kopie, nicht dasselbe Array')
|
||||
// Grenzen: 2 und 10 Werte, 100 und 100000 Cent
|
||||
assert.ok(einzelne([100, 100000]).werte)
|
||||
assert.ok(einzelne(Array(10).fill(100000)).werte)
|
||||
// unbekannte Felder in der Staffel fallen weg
|
||||
const mitMuell = mitStaffeln([{ abNaechten: 1, preisProNachtCent: 5500, personenCent: [5500, 7000], x: 1 }])
|
||||
assert.deepEqual(mitMuell.werte.staffeln, [{ abNaechten: 1, preisProNachtCent: 5500, personenCent: [5500, 7000] }])
|
||||
// alter Modus bleibt: kein personenCent im Ergebnis, auch bei null
|
||||
const alt = pruefePreise(PREISE)
|
||||
assert.deepEqual(alt.werte.staffeln, PREISE.staffeln)
|
||||
assert.ok(alt.werte.staffeln.every((s) => !('personenCent' in s)))
|
||||
const mitNull = mitStaffeln([{ abNaechten: 1, preisProNachtCent: 5500, personenCent: null }])
|
||||
assert.deepEqual(mitNull.werte.staffeln, [{ abNaechten: 1, preisProNachtCent: 5500 }])
|
||||
})
|
||||
|
||||
test('pruefePreise: preisProNachtCent wird im Personen-Modus mit personenCent[0] ueberschrieben', () => {
|
||||
const r = einzelne([5500, 7000, 8200], { preisProNachtCent: 9999 })
|
||||
assert.equal(r.werte.staffeln[0].preisProNachtCent, 5500)
|
||||
const ohne = mitStaffeln([{ abNaechten: 1, personenCent: [5500, 7000] }])
|
||||
assert.equal(ohne.werte.staffeln[0].preisProNachtCent, 5500)
|
||||
})
|
||||
|
||||
test('pruefePreise: personenCent ungueltig -> klare Meldung unter staffeln', () => {
|
||||
const faelle = {
|
||||
'Laenge 1': [5500],
|
||||
'Laenge 11': Array(11).fill(5500),
|
||||
'leer': [],
|
||||
'Wert 99': [5500, 99],
|
||||
'Wert 100001': [5500, 100001],
|
||||
'Kommazahl': [5500, 7000.5],
|
||||
'Text': [5500, '7000'],
|
||||
'null': [5500, null],
|
||||
'NaN': [5500, NaN],
|
||||
'kein Array': 'viele',
|
||||
'Objekt': { 0: 5500, 1: 7000 },
|
||||
'Zahl': 5500,
|
||||
}
|
||||
for (const [name, wert] of Object.entries(faelle)) {
|
||||
const r = einzelne(wert)
|
||||
assert.ok(r.fehler?.staffeln, name)
|
||||
assert.ok(/\S{3,}/.test(r.fehler.staffeln), name)
|
||||
assert.equal(Object.keys(r.fehler).length, 1, `${name}: nur das Feld staffeln`)
|
||||
}
|
||||
assert.match(einzelne([5500]).fehler.staffeln, /2 bis 10/)
|
||||
assert.match(einzelne([5500, 99]).fehler.staffeln, /1 € und 1\.000 €/)
|
||||
})
|
||||
|
||||
test('pruefePreise: Staffeln mit unterschiedlich vielen oder teils fehlenden personenCent -> Fehler', () => {
|
||||
const s = (ab, pc) => ({ abNaechten: ab, preisProNachtCent: 5000, ...(pc ? { personenCent: pc } : {}) })
|
||||
assert.match(mitStaffeln([s(1, [5000, 6000, 7000]), s(7, [5000, 6000])]).fehler.staffeln, /gleich viele/)
|
||||
assert.match(mitStaffeln([s(1, [5000, 6000, 7000]), s(7)]).fehler.staffeln, /alle Preisstufen/i)
|
||||
assert.match(mitStaffeln([s(1), s(7, [5000, 6000, 7000])]).fehler.staffeln, /alle Preisstufen/i)
|
||||
assert.ok(mitStaffeln([s(1, [5000, 6000]), s(7, [4500, 5500])]).werte)
|
||||
})
|
||||
|
||||
test('pruefePreise: bestehende Staffel-Regeln gelten auch im Personen-Modus', () => {
|
||||
const s = (ab, pc = [5500, 7000]) => ({ abNaechten: ab, preisProNachtCent: pc[0], personenCent: pc })
|
||||
assert.match(mitStaffeln([s(2)]).fehler.staffeln, /ab 1 Nacht/)
|
||||
assert.match(mitStaffeln([s(1), s(7), s(3)]).fehler.staffeln, /aufsteigend/)
|
||||
assert.match(mitStaffeln([s(1), s(1)]).fehler.staffeln, /aufsteigend/)
|
||||
assert.match(mitStaffeln([1, 2, 3, 4, 5, 6, 7].map((n) => s(n))).fehler.staffeln, /Höchstens 6/)
|
||||
assert.ok(mitStaffeln([1, 2, 3, 4, 5, 6].map((n) => s(n))).werte)
|
||||
assert.match(mitStaffeln([{ abNaechten: 1.5, personenCent: [5500, 7000] }]).fehler.staffeln, /Ungültige Preisstufe/)
|
||||
})
|
||||
|
||||
test('pruefePreise: schlimmster Fall (6 Staffeln x 10 Werte x 100000, ab 365) passt in das Textfeld staffeln (2000 Zeichen)', async () => {
|
||||
const { UNTERKUNFT_COLLECTIONS } = await import('../server/services/unterkunft/schema.js')
|
||||
const groesse = UNTERKUNFT_COLLECTIONS.ukPreise.attributes.find((a) => a.key === 'staffeln').size
|
||||
assert.equal(STAFFELN_MAX_ZEICHEN, groesse, 'Konstante und Schema stimmen ueberein')
|
||||
const staffeln = [360, 361, 362, 363, 364, 365].map((ab, i) => ({ abNaechten: i === 0 ? 1 : ab, preisProNachtCent: 100000, personenCent: Array(10).fill(100000) }))
|
||||
const r = mitStaffeln(staffeln)
|
||||
assert.ok(r.werte, JSON.stringify(r.fehler))
|
||||
assert.ok(JSON.stringify(r.werte.staffeln).length <= groesse, `${JSON.stringify(r.werte.staffeln).length} > ${groesse}`)
|
||||
assert.ok(JSON.stringify(r.werte.staffeln).length < 1200, 'deutlich unter der Grenze')
|
||||
})
|
||||
|
||||
test('Preise (HTTP): Personen-Modus speichern, lesen, Vorschau; preisProNachtCent wird ueberschrieben', async () => {
|
||||
const r = await put('/unterkuenfte/u1/preise', { ...MIMI_PREISE, staffeln: MIMI_PREISE.staffeln.map((s) => ({ ...s, preisProNachtCent: 1234 })) })
|
||||
assert.equal(r.status, 200, JSON.stringify(r.body))
|
||||
assert.deepEqual(r.body.preise.staffeln, MIMI_PREISE.staffeln)
|
||||
assert.deepEqual((await get('/unterkuenfte/u1/preise')).body.preise.staffeln, MIMI_PREISE.staffeln)
|
||||
assert.deepEqual(JSON.parse(aw.docs('ukPreise').get('pr1').staffeln), MIMI_PREISE.staffeln)
|
||||
const v = await post('/preisvorschau', { unterkunftId: 'u1', von: '2026-12-01', bis: '2026-12-08', personen: 3 })
|
||||
assert.equal(v.status, 200)
|
||||
assert.equal(v.body.summen.bruttoCent, 7 * 7700 + 4000)
|
||||
assert.equal(v.body.posten[0].text, 'Übernachtung, 7 Nächte, 3 Personen')
|
||||
// zurueck in den alten Modus: ohne personenCent gespeichert
|
||||
const alt = await put('/unterkuenfte/u1/preise', PREISE)
|
||||
assert.equal(alt.status, 200)
|
||||
assert.deepEqual(JSON.parse(aw.docs('ukPreise').get('pr1').staffeln), PREISE.staffeln)
|
||||
})
|
||||
|
||||
test('Preise (HTTP): ungueltige personenCent -> 400 felder.staffeln, gespeicherte Preise bleiben', async () => {
|
||||
const vorherText = aw.docs('ukPreise').get('pr1').staffeln
|
||||
for (const pc of [[5500], Array(11).fill(5500), [5500, 99], [5500, 100001], [5500, 'x']]) {
|
||||
const r = await put('/unterkuenfte/u1/preise', { ...MIMI_PREISE, staffeln: [{ abNaechten: 1, preisProNachtCent: 5500, personenCent: pc }] })
|
||||
assert.equal(r.status, 400, JSON.stringify(pc))
|
||||
assert.ok(r.body.felder.staffeln, JSON.stringify(pc))
|
||||
}
|
||||
const ungleich = await put('/unterkuenfte/u1/preise', { ...MIMI_PREISE, staffeln: [MIMI_PREISE.staffeln[0], { ...MIMI_PREISE.staffeln[1], personenCent: [5000, 6500] }] })
|
||||
assert.equal(ungleich.status, 400)
|
||||
assert.equal(aw.docs('ukPreise').get('pr1').staffeln, vorherText)
|
||||
})
|
||||
|
||||
test('Preisvorschau: berechnePreis mit gespeicherten Preisen; ohne Preise 409; ungueltige Eingaben 400', async () => {
|
||||
const r = await post('/preisvorschau', { unterkunftId: 'u1', von: '2026-12-01', bis: '2026-12-03', personen: 3 })
|
||||
assert.equal(r.status, 200)
|
||||
@@ -384,6 +506,20 @@ test('Anfragen: Liste mit Filter und ohne Geheimnisse; Detail mit Vorschlag', as
|
||||
assert.equal((await get('/anfragen/nix')).status, 404)
|
||||
})
|
||||
|
||||
test('Anfragen im Personen-Modus: Vorschlag und Freigabe ohne Posten rechnen mit der Spalte der Gaestezahl', async () => {
|
||||
aw.seed('ukPreise', { $id: 'pr1', unterkunftId: 'u1', featureId: FEATURE, ...MIMI_PREISE, staffeln: JSON.stringify(MIMI_PREISE.staffeln) })
|
||||
anfrage('a1', { status: 'neu', von: '2026-11-01', bis: '2026-11-08', personen: 3 })
|
||||
const d = await get('/anfragen/a1')
|
||||
assert.equal(d.status, 200)
|
||||
assert.deepEqual(d.body.vorschlag.posten.map((p) => [p.text, p.menge, p.einzelCent]), [['Übernachtung, 7 Nächte, 3 Personen', 7, 7700], ['Endreinigung', 1, 4000]])
|
||||
assert.equal(d.body.vorschlag.summen.bruttoCent, 57900)
|
||||
// Freigabe ohne eigene Posten uebernimmt die berechneten
|
||||
const f = await post('/anfragen/a1/freigeben', {})
|
||||
assert.equal(f.status, 200, JSON.stringify(f.body))
|
||||
assert.equal(f.body.anfrage.summen.bruttoCent, 57900)
|
||||
assert.equal(f.body.anfrage.posten[0].text, 'Übernachtung, 7 Nächte, 3 Personen')
|
||||
})
|
||||
|
||||
test('Freigeben: Posten + Frist, Antwort mit buchungsLink (Token passt zum Hash), nie tokenHash; Anfrage freigegeben', async () => {
|
||||
anfrage('a1')
|
||||
const r = await post('/anfragen/a1/freigeben', { posten: POSTEN, fristTage: 5, nachricht: 'Bis bald' })
|
||||
|
||||
Reference in new issue
Block a user