Checkout je Funktion: Vorpruefungen in der Reihenfolge der Spezifikation
POST /api/funktionen/:key/checkout ersetzt /news/checkout (der News-Pfad bleibt als key = news erhalten). Stufen ohne Seiteneffekt: 1 Kundenansicht (403), 2 Schluessel gegen das Register (404), 3 Zustimmung (400 zustimmung_fehlt, 409 fassung_veraltet mit der Serverfassung; News weiter mit consent: true), 4 Projekt (400/403; bei fortsetzen muss das Dokument ordered sein), 5 Schalter (409 nicht_verfuegbar), 5b Unterlagen (503 unterlagen_fehlen), 6 Bestellpruefung (409 bestellung_offen mit offen), 7 Wartungs-Abo (409 kein_abo | gekuendigt | nicht_aktiv, Lesefehler 500). fail() gibt err.body weiter. featureOrder.js: pruefeZustimmung, istFortsetzen, aboMeldung (einzige Quelle der Abo-Hinweistexte), ladeEntwurf, pruefeAbo, orderDeps. featureRegistry.js: featureSperre und die Standard-Haken verfuegbar, bestellpruefung (mitAbo: false, ohne abo) und unterlagenBereit des Terminplaners. Der Rest der Route (Sperre, Zustand, Sitzung, Nachweis) bleibt bis Task B7 nur fuer News; andere Funktionen enden mit 503. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Sonnet 5.5 committed
1 parent
d568a3798d
commit
ded6bb2a77
5 files changed
+960
-11
No files matched your search
@@ -0,0 +1,705 @@
|
||||
import { test, after, beforeEach, mock } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { startAppwriteMock } from './support/appwriteMock.js'
|
||||
import { startFakeStripe } from './support/fakeStripe.js'
|
||||
import { useTestEnv } from './support/testEnv.js'
|
||||
import { schemaKeys } from './support/schema.js'
|
||||
|
||||
// Checkout je Funktion, Teil 1 (Task B6): POST /api/funktionen/:key/checkout mit den Vorpruefungen in der
|
||||
// Reihenfolge der Spezifikation (1 Kundenansicht, 2 Schluessel, 3 Zustimmung, 4 Projekt, 5 Schalter, 5b Unterlagen,
|
||||
// 6 Bestellpruefung, 7 Wartungs-Abo). Jede Ablehnung laesst keine Spur zurueck: keine Stripe-Sitzung, kein
|
||||
// featureConsents- und kein portalFeatures-Dokument. Sperre, Zustandspruefung und Nachweis folgen in Task B7.
|
||||
const aw = await startAppwriteMock({
|
||||
schema: {
|
||||
portalFeatures: schemaKeys('portalFeatures'),
|
||||
subscriptions: schemaKeys('subscriptions'),
|
||||
featureConsents: schemaKeys('featureConsents'),
|
||||
termineConfig: schemaKeys('termineConfig'),
|
||||
},
|
||||
})
|
||||
const st = await startFakeStripe()
|
||||
useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
|
||||
const { config } = await import('../server/config.js')
|
||||
const { startTestApp, post } = await import('./support/testApp.js')
|
||||
const { customerCookie, kundenansichtCookie, seedFixtures, subscriptionDoc, wartungDoc } = await import('./support/fixtures.js')
|
||||
const { default: funktionenRoutes } = await import('../server/routes/funktionen.js')
|
||||
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
||||
const reg = await import('../server/services/featureRegistry.js')
|
||||
const order = await import('../server/services/featureOrder.js')
|
||||
|
||||
const app = await startTestApp({ '/api/funktionen': funktionenRoutes })
|
||||
after(() => Promise.all([app.close(), aw.close(), st.close()]))
|
||||
|
||||
const T = config.features.termine
|
||||
const STANDARD_TERMINE_MODUS = { mode: config.termine.mode, pilotEmails: config.termine.pilotEmails }
|
||||
const DAY_MS = 86400000
|
||||
|
||||
// seedFixtures gibt c1 nur ein Hosting-Abo (sub_h): Termine-Faelle ueberschreiben es mit einem Wartungs-Abo
|
||||
const wartung = (patch = {}) => aw.seed('subscriptions', subscriptionDoc('sub_h', { ...wartungDoc, ...patch }))
|
||||
|
||||
// Jeder Test beginnt sauber: Standard-Abos (c1 Wartung), Pilot fuer alle, keine Haken-Ueberschreibungen, keine Dokumente
|
||||
beforeEach(async () => {
|
||||
for (const col of ['subscriptions', 'portalFeatures', 'featureConsents', 'termineConfig']) {
|
||||
for (const id of aw.docs(col).keys()) await deleteDocument(col, id)
|
||||
}
|
||||
seedFixtures(aw)
|
||||
aw.seed('websiteProjects', { $id: 'p1', customerId: 'c1', projectName: 'Salon' })
|
||||
aw.seed('websiteProjects', { $id: 'p3', customerId: 'c3', projectName: 'Kiosk' })
|
||||
aw.seed('websiteProjects', { $id: 'p5', customerId: 'c2', projectName: 'Fremd' })
|
||||
wartung()
|
||||
st.checkoutSessions.clear()
|
||||
config.termine.mode = 'pilot'
|
||||
config.termine.pilotEmails = ['*']
|
||||
for (const name of ['verfuegbar', 'bestellpruefung', 'unterlagenBereit']) delete T[name]
|
||||
})
|
||||
after(() => {
|
||||
config.termine.mode = STANDARD_TERMINE_MODUS.mode
|
||||
config.termine.pilotEmails = STANDARD_TERMINE_MODUS.pilotEmails
|
||||
})
|
||||
|
||||
const c1 = customerCookie('c1')
|
||||
const checkout = (key, body, cookie = c1) => post(`/api/funktionen/${key}/checkout`, body, { cookie })
|
||||
const pflichtHaken = (feature = T) => feature.consent.items.filter((item) => item.haken).map((item) => item.id)
|
||||
const zustimmung = (patch = {}) => ({ version: T.consent.version, haken: pflichtHaken(), ...patch })
|
||||
const bodyT = (extra = {}) => ({ projectId: 'p1', zustimmung: zustimmung(), ...extra })
|
||||
const spuren = () => ({ sessions: st.checkoutSessions.size, consents: aw.docs('featureConsents').size, features: aw.docs('portalFeatures').size })
|
||||
const keineSpuren = () => assert.deepEqual(spuren(), { sessions: 0, consents: 0, features: 0 }, 'Ablehnung ohne Spur')
|
||||
const stumm = () => mock.method(console, 'error', () => {})
|
||||
|
||||
/** Zeichnet die Reihenfolge der Stufen auf: Haken unterlagenBereit/bestellpruefung und orderDeps.aboMemo (Zaehler). */
|
||||
function ablaufAufzeichnen({ unterlagen = true, offen = [] } = {}) {
|
||||
const ablauf = []
|
||||
const args = []
|
||||
T.unterlagenBereit = async () => {
|
||||
ablauf.push('unterlagen')
|
||||
return unterlagen
|
||||
}
|
||||
T.bestellpruefung = async (arg) => {
|
||||
ablauf.push('pruefung')
|
||||
args.push(arg)
|
||||
return offen
|
||||
}
|
||||
const echt = order.orderDeps.aboMemo
|
||||
order.orderDeps.aboMemo = () => {
|
||||
ablauf.push('abo')
|
||||
return echt()
|
||||
}
|
||||
return { ablauf, args, ende: () => (order.orderDeps.aboMemo = echt) }
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 1 Kundenansicht ---
|
||||
test('Kundenansicht: 403, auch mit gueltigem Body (Testanwendung ohne Waechter)', async () => {
|
||||
const res = await checkout('termine', bodyT(), kundenansichtCookie())
|
||||
assert.equal(res.status, 403)
|
||||
assert.equal(res.body.error, 'In der Kundenansicht kann nicht bestellt werden.')
|
||||
keineSpuren()
|
||||
// News ebenso, und die Sperre kommt vor dem Schluessel: ein unbekannter Schluessel ist in der Kundenansicht 403, nicht 404
|
||||
assert.equal((await checkout('news', { projectId: 'p1', consent: true }, kundenansichtCookie())).status, 403)
|
||||
assert.equal((await checkout('nope', {}, kundenansichtCookie())).status, 403)
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 2 Schluessel ---
|
||||
test('unbekannter Schluessel: 404 (analyse, __proto__, nope, Gross-/Kleinschreibung)', async () => {
|
||||
for (const key of ['analyse', '__proto__', 'nope', 'News', 'constructor']) {
|
||||
const res = await checkout(key, bodyT())
|
||||
assert.equal(res.status, 404, key)
|
||||
assert.equal(res.body.error, 'Unbekannte Funktion', key)
|
||||
}
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 3 Zustimmung ---
|
||||
test('Zustimmung fehlt oder ist leer: 400 zustimmung_fehlt', async () => {
|
||||
const faelle = [
|
||||
{ projectId: 'p1' },
|
||||
{ projectId: 'p1', zustimmung: null },
|
||||
{ projectId: 'p1', zustimmung: {} },
|
||||
{ projectId: 'p1', zustimmung: zustimmung({ haken: [] }) },
|
||||
{ projectId: 'p1', zustimmung: zustimmung({ haken: undefined }) },
|
||||
{ projectId: 'p1', zustimmung: zustimmung({ version: undefined }) },
|
||||
{ projectId: 'p1', zustimmung: 'alles' },
|
||||
{ projectId: 'p1', zustimmung: [] },
|
||||
{ projectId: 'p1', zustimmung: zustimmung({ haken: 'unterlagen' }) },
|
||||
{ projectId: 'p1', zustimmung: zustimmung({ haken: [...pflichtHaken(), 42] }) },
|
||||
{ projectId: 'p1', zustimmung: zustimmung({ haken: [...pflichtHaken(), null] }) },
|
||||
]
|
||||
for (const body of faelle) {
|
||||
const res = await checkout('termine', body)
|
||||
assert.equal(res.status, 400, JSON.stringify(body))
|
||||
assert.equal(res.body.code, 'zustimmung_fehlt', JSON.stringify(body))
|
||||
assert.match(res.body.error, /zu/)
|
||||
}
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
test('Zustimmung: ein Pflicht-Haken fehlt oder eine Haken-ID ist unbekannt: 400', async () => {
|
||||
const ids = pflichtHaken()
|
||||
assert.equal(ids.length, 4, 'Terminplaner hat vier Haken')
|
||||
for (const fehlt of ids) {
|
||||
const res = await checkout('termine', bodyT({ zustimmung: zustimmung({ haken: ids.filter((id) => id !== fehlt) }) }))
|
||||
assert.equal(res.status, 400, `ohne ${fehlt}`)
|
||||
assert.equal(res.body.code, 'zustimmung_fehlt', `ohne ${fehlt}`)
|
||||
}
|
||||
// unbekannte ID, auch neben vollstaendigen Haken; ebenso die ID eines Items ohne Haken
|
||||
for (const fremd of ['gibt-es-nicht', '__proto__', '']) {
|
||||
const res = await checkout('termine', bodyT({ zustimmung: zustimmung({ haken: [...ids, fremd] }) }))
|
||||
assert.equal(res.status, 400, `unbekannt ${fremd}`)
|
||||
assert.equal(res.body.code, 'zustimmung_fehlt', `unbekannt ${fremd}`)
|
||||
}
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
test('Zustimmung: falsche Fassung ist 409 fassung_veraltet mit der Serverfassung und allen Item-Texten', async () => {
|
||||
const res = await checkout('termine', bodyT({ zustimmung: zustimmung({ version: '1999-01-01' }) }))
|
||||
assert.equal(res.status, 409)
|
||||
assert.equal(res.body.code, 'fassung_veraltet')
|
||||
assert.equal(res.body.consent.version, T.consent.version)
|
||||
assert.deepEqual(res.body.consent, reg.oeffentlicheAnsicht('termine').consent)
|
||||
assert.deepEqual(
|
||||
res.body.consent.items.map((item) => item.text),
|
||||
T.consent.items.map((item) => item.text),
|
||||
'alle Item-Texte'
|
||||
)
|
||||
assert.equal(typeof res.body.error, 'string')
|
||||
// die Fassung entscheidet auch dann, wenn die Haken nicht passen (der Browser zeigt erst die neue Fassung)
|
||||
const alt = await checkout('termine', bodyT({ zustimmung: zustimmung({ version: 'alt', haken: ['frueher-anderes-item'] }) }))
|
||||
assert.equal(alt.status, 409)
|
||||
assert.equal(alt.body.code, 'fassung_veraltet')
|
||||
keineSpuren()
|
||||
// zur Laufzeit geaenderte Serverfassung gilt sofort (config bei jedem Aufruf gelesen)
|
||||
const vorher = T.consent.version
|
||||
const alterBody = bodyT()
|
||||
try {
|
||||
T.consent.version = 'neuere-fassung'
|
||||
const veraltet = await checkout('termine', alterBody)
|
||||
assert.equal(veraltet.status, 409)
|
||||
assert.equal(veraltet.body.consent.version, 'neuere-fassung')
|
||||
} finally {
|
||||
T.consent.version = vorher
|
||||
}
|
||||
})
|
||||
|
||||
test('consent: true gilt nur fuer Funktionen mit genau einem Haken: Termine 400, News weiter', async () => {
|
||||
const termine = await checkout('termine', { projectId: 'p1', consent: true })
|
||||
assert.equal(termine.status, 400)
|
||||
assert.equal(termine.body.code, 'zustimmung_fehlt')
|
||||
keineSpuren()
|
||||
// News: consent true kommt durch die Zustimmung (fremdes Projekt => erst danach 403), false/fehlend nicht
|
||||
assert.equal((await checkout('news', { projectId: 'p5', consent: true })).status, 403)
|
||||
for (const body of [{ projectId: 'p1', consent: false }, { projectId: 'p1' }, { projectId: 'p1', consent: 'true' }, { projectId: 'p1', consent: 1 }]) {
|
||||
const res = await checkout('news', body)
|
||||
assert.equal(res.status, 400, JSON.stringify(body))
|
||||
assert.equal(res.body.code, 'zustimmung_fehlt', JSON.stringify(body))
|
||||
}
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
test('News mit zustimmung-Objekt: richtige Fassung kommt durch, alte ist 409 mit der News-Fassung', async () => {
|
||||
const news = config.features.news
|
||||
const ok = { version: news.consent.version, haken: ['beginn'] }
|
||||
assert.equal((await checkout('news', { projectId: 'p5', zustimmung: ok })).status, 403, 'Zustimmung ok, fremdes Projekt')
|
||||
const alt = await checkout('news', { projectId: 'p1', zustimmung: { ...ok, version: 'alt' } })
|
||||
assert.equal(alt.status, 409)
|
||||
assert.deepEqual(alt.body.consent, reg.oeffentlicheAnsicht('news').consent)
|
||||
// die Haken des Terminplaners gelten nicht fuer News und umgekehrt
|
||||
assert.equal((await checkout('news', { projectId: 'p1', zustimmung: { ...ok, haken: ['unterlagen'] } })).status, 400)
|
||||
assert.equal((await checkout('termine', { projectId: 'p1', zustimmung: zustimmung({ haken: ['beginn'] }) })).status, 400)
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 4 Projekt ---
|
||||
test('Projekt: ohne projectId 400, fremdes Projekt 403', async () => {
|
||||
for (const projectId of [undefined, '', 12, null, {}]) {
|
||||
const res = await checkout('termine', { projectId, zustimmung: zustimmung() })
|
||||
assert.equal(res.status, 400, String(projectId))
|
||||
assert.equal(res.body.error, 'Bitte wähle ein Projekt.')
|
||||
}
|
||||
const fremd = await checkout('termine', bodyT({ projectId: 'p5' }))
|
||||
assert.equal(fremd.status, 403)
|
||||
assert.equal((await checkout('termine', bodyT({ projectId: 'gibt-es-nicht' }))).status, 403)
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 5 Schalter ---
|
||||
test('Schalter: mode off und Pilot mit fremder Adresse sind 409 nicht_verfuegbar, News unabhaengig vom Modus', async () => {
|
||||
config.termine.mode = 'off'
|
||||
const aus = await checkout('termine', bodyT())
|
||||
assert.equal(aus.status, 409)
|
||||
assert.equal(aus.body.error, 'Der Terminplaner ist noch nicht verfügbar.')
|
||||
assert.equal(aus.body.code, 'nicht_verfuegbar')
|
||||
keineSpuren()
|
||||
|
||||
config.termine.mode = 'pilot'
|
||||
config.termine.pilotEmails = ['jemand-anderes@example.invalid']
|
||||
const fremd = await checkout('termine', bodyT())
|
||||
assert.equal(fremd.status, 409)
|
||||
assert.equal(fremd.body.code, 'nicht_verfuegbar')
|
||||
keineSpuren()
|
||||
|
||||
// eigene Adresse in der Pilotliste und Modus on lassen durch (die Stufen danach lehnen hier nichts ab)
|
||||
for (const [mode, pilotEmails] of [['pilot', ['k@example.invalid']], ['on', []]]) {
|
||||
config.termine.mode = mode
|
||||
config.termine.pilotEmails = pilotEmails
|
||||
const res = await checkout('termine', bodyT())
|
||||
assert.notEqual(res.body?.code, 'nicht_verfuegbar', `${mode} ${pilotEmails}`)
|
||||
}
|
||||
|
||||
// News kennt den Schalter nicht
|
||||
config.termine.mode = 'off'
|
||||
const news = await checkout('news', { projectId: 'p1', consent: true })
|
||||
assert.equal(news.status, 200)
|
||||
assert.match(news.body.url, /^https?:\/\//)
|
||||
})
|
||||
|
||||
test('featureSperre: Text bei nicht verfuegbar, sonst null; Haken und Meldung ueberschreibbar', () => {
|
||||
config.termine.mode = 'off'
|
||||
assert.equal(reg.featureSperre('termine', 'k@example.invalid'), 'Der Terminplaner ist noch nicht verfügbar.')
|
||||
assert.equal(reg.featureSperre('news', 'k@example.invalid'), null, 'News ohne Haken verfuegbar')
|
||||
config.termine.mode = 'pilot'
|
||||
config.termine.pilotEmails = ['k@example.invalid']
|
||||
assert.equal(reg.featureSperre('termine', 'k@example.invalid'), null)
|
||||
assert.equal(reg.featureSperre('termine', 'x@example.invalid'), 'Der Terminplaner ist noch nicht verfügbar.')
|
||||
assert.equal(reg.featureSperre('termine', undefined), 'Der Terminplaner ist noch nicht verfügbar.')
|
||||
config.termine.mode = 'on'
|
||||
assert.equal(reg.featureSperre('termine', 'x@example.invalid'), null)
|
||||
// ueberschriebener Haken und Meldung des Registers
|
||||
const meldung = T.unavailableMessage
|
||||
try {
|
||||
T.verfuegbar = (email) => email === 'ok@example.invalid'
|
||||
T.unavailableMessage = 'Gerade nicht.'
|
||||
assert.equal(reg.featureSperre('termine', 'ok@example.invalid'), null)
|
||||
assert.equal(reg.featureSperre('termine', 'k@example.invalid'), 'Gerade nicht.')
|
||||
delete T.unavailableMessage
|
||||
assert.equal(reg.featureSperre('termine', 'k@example.invalid'), 'Diese Funktion ist noch nicht verfügbar.', 'ohne Meldung im Register')
|
||||
} finally {
|
||||
T.unavailableMessage = meldung
|
||||
delete T.verfuegbar
|
||||
}
|
||||
// unbekannter Schluessel: nicht verfuegbar (fail-closed)
|
||||
assert.equal(typeof reg.featureSperre('analyse', 'k@example.invalid'), 'string')
|
||||
})
|
||||
|
||||
test('Standard-Haken des Terminplaners: verfuegbar, bestellpruefung und unterlagenBereit sind gefuellt, News hat keine', async () => {
|
||||
const haken = reg.featureHaken('termine')
|
||||
for (const name of ['verfuegbar', 'bestellpruefung', 'unterlagenBereit']) assert.equal(typeof haken[name], 'function', name)
|
||||
assert.equal(await haken.unterlagenBereit(), true, 'Standard: immer bereit')
|
||||
assert.deepEqual(reg.featureHaken('news'), {})
|
||||
// dieselben Funktionen bei jedem Aufruf (der Haken-Test in featureRegistry.test.js vergleicht per ===)
|
||||
assert.equal(reg.featureHaken('termine').bestellpruefung, haken.bestellpruefung)
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 5b Unterlagen ---
|
||||
test('Unterlagen nicht abrufbar: 503 unterlagen_fehlen, ohne Spur', async () => {
|
||||
const lauf = ablaufAufzeichnen({ unterlagen: false })
|
||||
try {
|
||||
const res = await checkout('termine', bodyT())
|
||||
assert.equal(res.status, 503)
|
||||
assert.equal(res.body.code, 'unterlagen_fehlen')
|
||||
assert.equal(res.body.error, 'Die Vertragsunterlagen sind gerade nicht abrufbar. Bitte versuch es später noch einmal oder schreib uns im Chat.')
|
||||
assert.deepEqual(lauf.ablauf, ['unterlagen'], 'weder Bestellpruefung noch Abo gelesen')
|
||||
keineSpuren()
|
||||
} finally {
|
||||
lauf.ende()
|
||||
}
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 6 Bestellpruefung ---
|
||||
test('Bestellpruefung nicht leer: 409 bestellung_offen mit den offenen Punkten, Haken ohne abo', async () => {
|
||||
const offen = [{ schritt: 'zeiten', text: 'Zeiten bestätigen' }, { schritt: 'website', text: 'Impressum eintragen' }]
|
||||
const lauf = ablaufAufzeichnen({ offen })
|
||||
try {
|
||||
const res = await checkout('termine', bodyT())
|
||||
assert.equal(res.status, 409)
|
||||
assert.equal(res.body.code, 'bestellung_offen')
|
||||
assert.deepEqual(res.body.offen, offen)
|
||||
assert.equal(typeof res.body.error, 'string')
|
||||
assert.equal(lauf.args.length, 1)
|
||||
const [arg] = lauf.args
|
||||
assert.equal('abo' in arg, false, 'der Checkout uebergibt kein abo')
|
||||
assert.equal(arg.customerId, 'c1')
|
||||
assert.equal(arg.projectId, 'p1')
|
||||
assert.equal(arg.feature, T, 'der Register-Eintrag')
|
||||
assert.deepEqual(lauf.ablauf, ['unterlagen', 'pruefung'], 'die Abo-Stufe wird nicht gelesen')
|
||||
keineSpuren()
|
||||
} finally {
|
||||
lauf.ende()
|
||||
}
|
||||
})
|
||||
|
||||
test('Bestellpruefung: kaputter Haken (keine Liste) lehnt ab, 500 ohne Rohtext (fail-closed)', async () => {
|
||||
T.bestellpruefung = async () => 'sieht gut aus'
|
||||
const log = stumm()
|
||||
try {
|
||||
const res = await checkout('termine', bodyT())
|
||||
assert.equal(res.status, 500)
|
||||
assert.doesNotMatch(JSON.stringify(res.body), /sieht gut aus|Liste/)
|
||||
keineSpuren()
|
||||
} finally {
|
||||
log.mock.restore()
|
||||
}
|
||||
})
|
||||
|
||||
test('Standard-Haken liest den Entwurf nur, wenn es ein Dokument gibt, und ruft die Bestellpruefung ohne Abo', async () => {
|
||||
const haken = reg.featureHaken('termine')
|
||||
const arg = { customerId: 'c1', projectId: 'p1', feature: T }
|
||||
// ohne Dokument: keine Abfrage von termineConfig, der Platzhalter meldet nichts offen
|
||||
aw.failNext({ collection: 'termineConfig', status: 500 })
|
||||
assert.deepEqual(await haken.bestellpruefung(arg), [])
|
||||
// mit Dokument: der Entwurf wird geladen (der eingeplante Lesefehler trifft)
|
||||
aw.seed('portalFeatures', { $id: 'f_p1_termine', customerId: 'c1', projectId: 'p1', featureKey: 'termine', state: 'off', enabled: false, siteKey: 'abcdefghijklmnop' })
|
||||
const log = stumm()
|
||||
try {
|
||||
await assert.rejects(haken.bestellpruefung(arg), (err) => err.status === 500)
|
||||
} finally {
|
||||
log.mock.restore()
|
||||
}
|
||||
assert.deepEqual(await haken.bestellpruefung(arg), [], 'danach wieder normal')
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ 7 Abo ---
|
||||
const ABO_TEXT = {
|
||||
kein_abo: 'Für den Terminplaner brauchst du ein laufendes Wartungs-Abo.',
|
||||
gekuendigt: 'Dein Wartungs-Abo ist gekündigt. Für den Terminplaner brauchst du ein laufendes Abo.',
|
||||
nicht_aktiv:
|
||||
'Dein Wartungs-Abo ist gerade nicht aktiv (zum Beispiel wegen einer offenen Zahlung). Sobald es wieder aktiv ist, kannst du den Terminplaner bestellen.',
|
||||
}
|
||||
|
||||
function aboAbgelehnt(res, grund) {
|
||||
assert.equal(res.status, 409, grund)
|
||||
assert.equal(res.body.code, grund)
|
||||
assert.equal(res.body.grund, grund, 'Grund ohne Praefix')
|
||||
assert.equal(res.body.error, ABO_TEXT[grund])
|
||||
keineSpuren()
|
||||
}
|
||||
|
||||
test('Abo-Gruende: kein Abo (c3, c2 mit Hosting), Kuendigung, offene Zahlung', async () => {
|
||||
T.bestellpruefung = async () => []
|
||||
// c3 hat gar kein Abo, c2 nur Hosting
|
||||
aboAbgelehnt(await checkout('termine', { projectId: 'p3', zustimmung: zustimmung() }, customerCookie('c3')), 'kein_abo')
|
||||
aboAbgelehnt(await checkout('termine', { projectId: 'p5', zustimmung: zustimmung() }, customerCookie('c2')), 'kein_abo')
|
||||
// c1 mit Wartungs-Abo, aber Hosting-Abo allein ist auch kein Wartungs-Abo
|
||||
aw.seed('subscriptions', subscriptionDoc('sub_h', { ...wartungDoc, productKey: 'hosting' }))
|
||||
aboAbgelehnt(await checkout('termine', bodyT()), 'kein_abo')
|
||||
|
||||
wartung({ cancelAtPeriodEnd: true })
|
||||
aboAbgelehnt(await checkout('termine', bodyT()), 'gekuendigt')
|
||||
wartung({ cancelAt: new Date(Date.now() + 30 * DAY_MS).toISOString() })
|
||||
aboAbgelehnt(await checkout('termine', bodyT()), 'gekuendigt')
|
||||
|
||||
wartung({ status: 'past_due' })
|
||||
aboAbgelehnt(await checkout('termine', bodyT()), 'nicht_aktiv')
|
||||
wartung({ status: 'past_due', cancelAtPeriodEnd: true })
|
||||
aboAbgelehnt(await checkout('termine', bodyT()), 'gekuendigt')
|
||||
|
||||
// laufendes, ungekuendigtes Abo: die Abo-Stufe lehnt nicht ab
|
||||
wartung({ status: 'active' })
|
||||
const ok = await checkout('termine', bodyT())
|
||||
assert.notEqual(ok.body?.code, 'kein_abo')
|
||||
assert.notEqual(ok.body?.grund, 'nicht_aktiv')
|
||||
})
|
||||
|
||||
test('Abo-Lesefehler: 500 ohne Rohtext, fail-closed ohne Spur', async () => {
|
||||
T.bestellpruefung = async () => []
|
||||
aw.failNext({ collection: 'subscriptions', status: 500, message: 'GEHEIMER-ROHTEXT interner Fehler' })
|
||||
const log = stumm()
|
||||
try {
|
||||
const res = await checkout('termine', bodyT())
|
||||
assert.equal(res.status, 500)
|
||||
assert.doesNotMatch(JSON.stringify(res.body), /GEHEIMER-ROHTEXT/)
|
||||
assert.equal(typeof res.body.error, 'string')
|
||||
keineSpuren()
|
||||
} finally {
|
||||
log.mock.restore()
|
||||
}
|
||||
})
|
||||
|
||||
test('Abo-Stufe mit leerer Pruefung (Stub und Standard-Gate): ohne Abo 409 kein_abo, nie bestellung_offen', async () => {
|
||||
const c3 = customerCookie('c3')
|
||||
// Standard-Haken (Platzhalter von Block B meldet nichts offen)
|
||||
aboAbgelehnt(await checkout('termine', { projectId: 'p3', zustimmung: zustimmung() }, c3), 'kein_abo')
|
||||
// ueberschriebener Haken mit leerer Liste
|
||||
T.bestellpruefung = async () => []
|
||||
aboAbgelehnt(await checkout('termine', { projectId: 'p3', zustimmung: zustimmung() }, c3), 'kein_abo')
|
||||
})
|
||||
|
||||
test('aboMeldung: Wortlaute aus dem Register, Akkusativ aus mails.formen.akk, unbekannter Grund wie unbekannt', () => {
|
||||
for (const grund of ['kein_abo', 'gekuendigt', 'nicht_aktiv']) assert.equal(order.aboMeldung(T, grund), ABO_TEXT[grund], grund)
|
||||
assert.equal(order.aboMeldung(T, 'unbekannt'), 'Das Abo konnte gerade nicht geprüft werden.')
|
||||
assert.equal(order.aboMeldung(T, 'irgendwas'), 'Das Abo konnte gerade nicht geprüft werden.')
|
||||
assert.equal(order.aboMeldung(T, undefined), 'Das Abo konnte gerade nicht geprüft werden.')
|
||||
// die Funktion steht im Satz: Akkusativ der jeweiligen Funktion
|
||||
assert.equal(order.aboMeldung(config.features.news, 'kein_abo'), 'Für die News-Pinnwand brauchst du ein laufendes Wartungs-Abo.')
|
||||
assert.match(order.aboMeldung(config.features.news, 'nicht_aktiv'), /kannst du die News-Pinnwand bestellen\.$/)
|
||||
assert.match(order.aboMeldung(T, 'nicht_aktiv'), /bestellen\.$/)
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ Reihenfolge ---
|
||||
test('Reihenfolge der Stufen: jede Stufe steht vor der naechsten und laesst nichts zurueck', async () => {
|
||||
const lauf = ablaufAufzeichnen({ offen: [{ schritt: 'zeiten', text: 'Zeiten bestätigen' }] })
|
||||
try {
|
||||
const nichtsGelesen = () => {
|
||||
assert.deepEqual(lauf.ablauf, [], 'kein Haken, kein Abo gelesen')
|
||||
keineSpuren()
|
||||
}
|
||||
config.termine.mode = 'off'
|
||||
// 1 vor 2: Kundenansicht schlaegt unbekannten Schluessel und alles andere
|
||||
assert.equal((await checkout('nope', {}, kundenansichtCookie())).status, 403)
|
||||
// 2 vor 3: unbekannter Schluessel schlaegt fehlende Zustimmung
|
||||
assert.equal((await checkout('nope', { projectId: 'p5' })).status, 404)
|
||||
// 3 vor 4: fehlende Zustimmung schlaegt fremdes Projekt und fehlendes Projekt
|
||||
assert.equal((await checkout('termine', { projectId: 'p5' })).status, 400)
|
||||
assert.equal((await checkout('termine', {})).status, 400)
|
||||
// 4 vor 5: Projekt schlaegt den Schalter (mode off)
|
||||
assert.equal((await checkout('termine', { zustimmung: zustimmung() })).status, 400)
|
||||
assert.equal((await checkout('termine', bodyT({ projectId: 'p5' }))).status, 403)
|
||||
nichtsGelesen()
|
||||
// 5: Schalter vor den Unterlagen, der Bestellpruefung und dem Abo
|
||||
const aus = await checkout('termine', bodyT())
|
||||
assert.equal(aus.body.code, 'nicht_verfuegbar')
|
||||
nichtsGelesen()
|
||||
|
||||
config.termine.mode = 'pilot'
|
||||
// 5b vor 6 und 7
|
||||
lauf.ablauf.length = 0
|
||||
const alt = T.unterlagenBereit
|
||||
T.unterlagenBereit = async () => {
|
||||
lauf.ablauf.push('unterlagen')
|
||||
return false
|
||||
}
|
||||
const unterlagen = await checkout('termine', bodyT())
|
||||
assert.equal(unterlagen.body.code, 'unterlagen_fehlen')
|
||||
assert.deepEqual(lauf.ablauf, ['unterlagen'])
|
||||
T.unterlagenBereit = alt
|
||||
|
||||
// 6 vor 7: offene Punkte, die Abo-Stufe (Zaehler) wird nicht angefasst - auch ohne Abo (c3)
|
||||
lauf.ablauf.length = 0
|
||||
const offen = await checkout('termine', { projectId: 'p3', zustimmung: zustimmung() }, customerCookie('c3'))
|
||||
assert.equal(offen.status, 409)
|
||||
assert.equal(offen.body.code, 'bestellung_offen')
|
||||
assert.equal(offen.body.offen[0].schritt, 'zeiten')
|
||||
assert.deepEqual(lauf.ablauf, ['unterlagen', 'pruefung'])
|
||||
assert.equal(lauf.ablauf.filter((x) => x === 'abo').length, 0, 'Zaehler 0')
|
||||
keineSpuren()
|
||||
|
||||
// danach leere Pruefung: die Abo-Stufe wird genau einmal gelesen
|
||||
lauf.ablauf.length = 0
|
||||
T.bestellpruefung = async (arg) => {
|
||||
lauf.ablauf.push('pruefung')
|
||||
assert.equal('abo' in arg, false)
|
||||
return []
|
||||
}
|
||||
const weiter = await checkout('termine', bodyT())
|
||||
assert.deepEqual(lauf.ablauf, ['unterlagen', 'pruefung', 'abo'], 'Zaehler 1')
|
||||
assert.notEqual(weiter.body?.code, 'bestellung_offen')
|
||||
assert.notEqual(weiter.body?.code, 'kein_abo')
|
||||
} finally {
|
||||
lauf.ende()
|
||||
}
|
||||
})
|
||||
|
||||
test('Abo-Memo: je Anfrage ein aboMemo(), News fragt das Abo nie', async () => {
|
||||
const lauf = ablaufAufzeichnen()
|
||||
try {
|
||||
T.bestellpruefung = async () => []
|
||||
await checkout('termine', bodyT())
|
||||
assert.equal(lauf.ablauf.filter((x) => x === 'abo').length, 1)
|
||||
lauf.ablauf.length = 0
|
||||
// News (requiresWartungsAbo false) liest weder Abo noch Haken, c3 bestellt weiter
|
||||
const news = await checkout('news', { projectId: 'p3', consent: true }, customerCookie('c3'))
|
||||
assert.equal(news.status, 200)
|
||||
assert.deepEqual(lauf.ablauf, [])
|
||||
} finally {
|
||||
lauf.ende()
|
||||
}
|
||||
})
|
||||
|
||||
// Zwischenstand bis Task B7: der Rest der Route (Sperre, Zustand, Stripe-Sitzung, Nachweis, markOrdered) gilt noch nur fuer News.
|
||||
// Eine Termine-Bestellung, die alle Vorpruefungen besteht, darf bis dahin weder Sitzung noch Dokument noch Nachweis anlegen;
|
||||
// B7 ersetzt diesen Test durch den Erfolgsfall.
|
||||
test('Termine-Bestellung nach bestandenen Vorpruefungen legt bis Task B7 noch nichts an (503)', async () => {
|
||||
T.bestellpruefung = async () => []
|
||||
const res = await checkout('termine', bodyT())
|
||||
assert.equal(res.status, 503)
|
||||
assert.equal(res.body.code, 'bestellung_nicht_freigeschaltet')
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ fortsetzen ---
|
||||
const featureDoc = (state, extra = {}) =>
|
||||
aw.seed('portalFeatures', { $id: 'f_p1_termine', customerId: 'c1', projectId: 'p1', featureKey: 'termine', state, enabled: state === 'active', siteKey: 'abcdefghijklmnop', ...extra })
|
||||
|
||||
test('fortsetzen: ohne Dokument oder ausser ordered ist 400 zustimmung_fehlt, es entsteht nichts', async () => {
|
||||
const fall = { projectId: 'p1', fortsetzen: true }
|
||||
const res = await checkout('termine', fall)
|
||||
assert.equal(res.status, 400)
|
||||
assert.equal(res.body.code, 'zustimmung_fehlt')
|
||||
keineSpuren()
|
||||
for (const state of ['off', 'setup', 'active', 'disabled']) {
|
||||
featureDoc(state) // seed ersetzt das Dokument gleicher ID
|
||||
const vorher = spuren()
|
||||
const antwort = await checkout('termine', fall)
|
||||
assert.equal(antwort.status, 400, state)
|
||||
assert.equal(antwort.body.code, 'zustimmung_fehlt', state)
|
||||
assert.deepEqual(spuren(), vorher, `${state}: nichts angelegt`)
|
||||
assert.equal(vorher.features, 1)
|
||||
assert.equal(aw.docs('portalFeatures').get('f_p1_termine').state, state, `${state}: Dokument unveraendert`)
|
||||
}
|
||||
// ein Dokument eines anderen Kunden zaehlt nicht als eigenes ordered
|
||||
await deleteDocument('portalFeatures', 'f_p1_termine')
|
||||
featureDoc('ordered', { customerId: 'c2' })
|
||||
assert.equal((await checkout('termine', fall)).status, 400)
|
||||
})
|
||||
|
||||
test('fortsetzen: fremdes Projekt ist 403, die Projektpruefung kommt vor dem Dokument', async () => {
|
||||
featureDoc('ordered')
|
||||
const res = await checkout('termine', { projectId: 'p5', fortsetzen: true })
|
||||
assert.equal(res.status, 403)
|
||||
assert.equal(aw.docs('featureConsents').size, 0)
|
||||
assert.equal(st.checkoutSessions.size, 0)
|
||||
// ohne projectId bleibt es bei 400 Projekt
|
||||
const ohne = await checkout('termine', { fortsetzen: true })
|
||||
assert.equal(ohne.status, 400)
|
||||
assert.equal(ohne.body.error, 'Bitte wähle ein Projekt.')
|
||||
})
|
||||
|
||||
test('fortsetzen bei ordered ueberspringt nur die Zustimmung: Schalter, Unterlagen, Pruefung und Abo gelten weiter', async () => {
|
||||
featureDoc('ordered')
|
||||
const fall = { projectId: 'p1', fortsetzen: true }
|
||||
// Schalter
|
||||
config.termine.mode = 'off'
|
||||
assert.equal((await checkout('termine', fall)).body.code, 'nicht_verfuegbar')
|
||||
config.termine.mode = 'pilot'
|
||||
// Unterlagen, Bestellpruefung
|
||||
const lauf = ablaufAufzeichnen({ unterlagen: false })
|
||||
try {
|
||||
assert.equal((await checkout('termine', fall)).body.code, 'unterlagen_fehlen')
|
||||
T.unterlagenBereit = async () => true
|
||||
T.bestellpruefung = async () => [{ schritt: 'branche', text: 'Branche wählen' }]
|
||||
assert.equal((await checkout('termine', fall)).body.code, 'bestellung_offen')
|
||||
T.bestellpruefung = async () => []
|
||||
// Abo
|
||||
wartung({ cancelAtPeriodEnd: true })
|
||||
assert.equal((await checkout('termine', fall)).body.code, 'gekuendigt')
|
||||
} finally {
|
||||
lauf.ende()
|
||||
}
|
||||
assert.equal(st.checkoutSessions.size, 0)
|
||||
assert.equal(aw.docs('featureConsents').size, 0)
|
||||
})
|
||||
|
||||
test('fortsetzen und zustimmung zusammen: die Zustimmung gilt und wird geprueft', async () => {
|
||||
featureDoc('ordered')
|
||||
// unvollstaendige Zustimmung neben fortsetzen: 400 trotz ordered
|
||||
const unvollstaendig = await checkout('termine', { projectId: 'p1', fortsetzen: true, zustimmung: zustimmung({ haken: [] }) })
|
||||
assert.equal(unvollstaendig.status, 400)
|
||||
assert.equal(unvollstaendig.body.code, 'zustimmung_fehlt')
|
||||
// alte Fassung neben fortsetzen: 409
|
||||
const alt = await checkout('termine', { projectId: 'p1', fortsetzen: true, zustimmung: zustimmung({ version: 'alt' }) })
|
||||
assert.equal(alt.status, 409)
|
||||
assert.equal(alt.body.code, 'fassung_veraltet')
|
||||
// gueltige Zustimmung neben fortsetzen und ohne Dokument im Zustand ordered: die Zustimmung genuegt, der Zustand zaehlt nicht
|
||||
await deleteDocument('portalFeatures', 'f_p1_termine')
|
||||
config.termine.mode = 'off'
|
||||
const gueltig = await checkout('termine', { projectId: 'p1', fortsetzen: true, zustimmung: zustimmung() })
|
||||
assert.equal(gueltig.body.code, 'nicht_verfuegbar', 'Zustimmung geprueft und bestanden, weiter bis zum Schalter')
|
||||
// News-Altform: consent: true neben fortsetzen gilt als Zustimmung (fremdes Projekt => erst danach 403), consent: false nicht
|
||||
assert.equal((await checkout('news', { projectId: 'p5', fortsetzen: true, consent: true })).status, 403)
|
||||
const news = await checkout('news', { projectId: 'p1', fortsetzen: true, consent: false })
|
||||
assert.equal(news.status, 400, 'fortsetzen ohne ordered')
|
||||
assert.equal(news.body.code, 'zustimmung_fehlt')
|
||||
assert.equal(aw.docs('portalFeatures').size, 0)
|
||||
assert.equal(st.checkoutSessions.size, 0)
|
||||
})
|
||||
|
||||
test('fortsetzen ist nur true wirksam: andere Werte zaehlen nicht', async () => {
|
||||
featureDoc('ordered')
|
||||
for (const fortsetzen of ['true', 1, 'ja', {}, [], false, null]) {
|
||||
const res = await checkout('termine', { projectId: 'p1', fortsetzen })
|
||||
assert.equal(res.status, 400, JSON.stringify(fortsetzen))
|
||||
assert.equal(res.body.code, 'zustimmung_fehlt', JSON.stringify(fortsetzen))
|
||||
}
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ News ---
|
||||
test('News braucht kein Abo und keinen Termine-Schalter: c3 bestellt weiter', async () => {
|
||||
config.termine.mode = 'off'
|
||||
const res = await checkout('news', { projectId: 'p3', consent: true }, customerCookie('c3'))
|
||||
assert.equal(res.status, 200)
|
||||
assert.match(res.body.url, /^https?:\/\//)
|
||||
assert.equal(st.checkoutSessions.size, 1)
|
||||
assert.equal([...aw.docs('portalFeatures').values()].filter((d) => d.featureKey === 'news' && d.state === 'ordered').length, 1)
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------------ Bausteine ---
|
||||
test('pruefeZustimmung: gibt die Haken-IDs in Reihenfolge des Registers zurueck, wirft 400/409 mit body', () => {
|
||||
const ids = pflichtHaken()
|
||||
assert.deepEqual(order.pruefeZustimmung(T, { zustimmung: zustimmung() }), { akzeptiert: ids })
|
||||
assert.deepEqual(order.pruefeZustimmung(T, { zustimmung: zustimmung({ haken: [...ids].reverse() }) }), { akzeptiert: ids }, 'Registerreihenfolge')
|
||||
assert.deepEqual(order.pruefeZustimmung(T, { zustimmung: zustimmung({ haken: [...ids, ids[0]] }) }), { akzeptiert: ids }, 'Doppelte zaehlen einmal')
|
||||
assert.deepEqual(order.pruefeZustimmung(config.features.news, { consent: true }), { akzeptiert: ['beginn'] })
|
||||
|
||||
assert.throws(
|
||||
() => order.pruefeZustimmung(T, { consent: true }),
|
||||
(err) => err.status === 400 && err.code === 'zustimmung_fehlt' && err.body.code === 'zustimmung_fehlt'
|
||||
)
|
||||
assert.throws(
|
||||
() => order.pruefeZustimmung(T, undefined),
|
||||
(err) => err.status === 400
|
||||
)
|
||||
assert.throws(
|
||||
() => order.pruefeZustimmung(T, { zustimmung: zustimmung({ version: 'alt' }) }),
|
||||
(err) => err.status === 409 && err.code === 'fassung_veraltet' && err.body.code === 'fassung_veraltet' && err.body.consent.version === T.consent.version
|
||||
)
|
||||
// die Ansicht im Fehler ist eine Kopie: Aenderungen daran aendern das Register nicht
|
||||
try {
|
||||
order.pruefeZustimmung(T, { zustimmung: zustimmung({ version: 'alt' }) })
|
||||
} catch (err) {
|
||||
err.body.consent.items[0].text = 'manipuliert'
|
||||
assert.notEqual(T.consent.items[0].text, 'manipuliert')
|
||||
}
|
||||
})
|
||||
|
||||
test('istFortsetzen: nur fortsetzen === true ohne Zustimmung und ohne consent: true', () => {
|
||||
assert.equal(order.istFortsetzen({ fortsetzen: true }), true)
|
||||
assert.equal(order.istFortsetzen({ fortsetzen: true, zustimmung: null }), true)
|
||||
assert.equal(order.istFortsetzen({ fortsetzen: true, zustimmung: undefined, consent: false }), true)
|
||||
assert.equal(order.istFortsetzen({ fortsetzen: true, zustimmung: {} }), false)
|
||||
assert.equal(order.istFortsetzen({ fortsetzen: true, consent: true }), false)
|
||||
assert.equal(order.istFortsetzen({ fortsetzen: 'true' }), false)
|
||||
assert.equal(order.istFortsetzen({}), false)
|
||||
assert.equal(order.istFortsetzen(undefined), false)
|
||||
assert.equal(order.istFortsetzen(null), false)
|
||||
})
|
||||
|
||||
test('ladeEntwurf: Einstellung und Fragebogen aus termineConfig, fehlend oder kaputt ist null', async () => {
|
||||
const einstellung = { betrieb: { name: 'Salon' } }
|
||||
const fragebogen = { schritt: 'branche', branche: 'friseur' }
|
||||
const doc = (extra) => aw.seed('termineConfig', { $id: 'f_p1_termine', customerId: 'c1', projectId: 'p1', einstellung: JSON.stringify(einstellung), version: 3, updatedAt: new Date().toISOString(), updatedBy: 'x', ...extra })
|
||||
|
||||
assert.deepEqual(await order.ladeEntwurf('f_p1_termine'), { einstellung: null, fragebogen: null }, 'kein Dokument')
|
||||
doc({ fragebogen: JSON.stringify(fragebogen) })
|
||||
assert.deepEqual(await order.ladeEntwurf('f_p1_termine'), { einstellung, fragebogen })
|
||||
doc({})
|
||||
assert.deepEqual(await order.ladeEntwurf('f_p1_termine'), { einstellung, fragebogen: null }, 'Attribut fehlt')
|
||||
for (const kaputt of ['{kaputt', '', '[1,2]', '42', '"text"', 'null']) {
|
||||
doc({ fragebogen: kaputt })
|
||||
assert.deepEqual(await order.ladeEntwurf('f_p1_termine'), { einstellung, fragebogen: null }, `fragebogen ${JSON.stringify(kaputt)}`)
|
||||
}
|
||||
// Einstellung unlesbar: null (der Fehler wird im Kontext-Modul geloggt), der Fragebogen bleibt
|
||||
const log = stumm()
|
||||
try {
|
||||
doc({ einstellung: '{kaputt', fragebogen: JSON.stringify(fragebogen) })
|
||||
assert.deepEqual(await order.ladeEntwurf('f_p1_termine'), { einstellung: null, fragebogen })
|
||||
} finally {
|
||||
log.mock.restore()
|
||||
}
|
||||
// Lesefehler werden nicht verschluckt
|
||||
doc({ fragebogen: JSON.stringify(fragebogen) })
|
||||
aw.failNext({ collection: 'termineConfig', status: 500 })
|
||||
await assert.rejects(order.ladeEntwurf('f_p1_termine'))
|
||||
aw.failNext({ collection: 'termineConfig', method: 'GET', status: 500, after: 1 })
|
||||
await assert.rejects(order.ladeEntwurf('f_p1_termine'))
|
||||
await assert.doesNotReject(order.ladeEntwurf('f_p1_termine'))
|
||||
await assert.rejects(order.ladeEntwurf(''), TypeError)
|
||||
})
|
||||
@@ -104,6 +104,20 @@ test('jede Schreib-Route ausserhalb der Erlaubnisliste -> 403 view_blocked', asy
|
||||
assert.ok(checked >= 18, `nur ${checked} gesperrte Routen geprueft`)
|
||||
})
|
||||
|
||||
// Checkout je Funktion (POST /api/funktionen/:key/checkout): die Schleife oben findet die Route ueber :key => x und sperrt sie,
|
||||
// ohne dass sie auf der Erlaubnisliste steht (die Route prueft zusaetzlich selbst req.session.viewAs)
|
||||
test('Checkout je Funktion ist in der Kundenansicht gesperrt (Schleife trifft /api/funktionen/x/checkout, Alias news auch)', async () => {
|
||||
const routes = writeRoutes(MOUNTS)
|
||||
assert.ok(routes.some(({ method, path: p }) => method === 'POST' && p === '/api/funktionen/x/checkout'), 'Route :key/checkout gefunden')
|
||||
for (const key of ['x', 'news', 'termine']) {
|
||||
const p = `/api/funktionen/${key}/checkout`
|
||||
assert.ok(!allowed('POST', p), p)
|
||||
const res = await call('POST', p, { ...kv(), body: { projectId: 'p1', fortsetzen: true } })
|
||||
assert.equal(res.status, 403, p)
|
||||
assert.equal(res.body.code, 'view_blocked', p)
|
||||
}
|
||||
})
|
||||
|
||||
test('Erlaubnisliste: genau News, Terminplaner, Analyse-Link, Ende, Logout und Login', () => {
|
||||
const ok = [
|
||||
['POST', '/api/news'], ['POST', '/api/news/image'], ['PATCH', '/api/news/abc'], ['DELETE', '/api/news/abc'],
|
||||
|
||||
Reference in new issue
Block a user