225 lines
12 KiB
JavaScript
225 lines
12 KiB
JavaScript
import { test, after } from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { startAppwriteMock } from './support/appwriteMock.js'
|
|
import { startFakeStripe } from './support/fakeStripe.js'
|
|
import { mailSink } from './support/mailSink.js'
|
|
import { useTestEnv } from './support/testEnv.js'
|
|
import { schemaKeys } from './support/schema.js'
|
|
|
|
// Bestellung (POST /api/abo/checkout) in Fassung 6: Kundenart und Beginn kommen vom Server, der Wortlaut wird vor der Stripe-Sitzung gespeichert
|
|
const aw = await startAppwriteMock({
|
|
schema: {
|
|
subscriptions: schemaKeys('subscriptions'),
|
|
contractEvents: schemaKeys('contractEvents'),
|
|
aboOffers: schemaKeys('aboOffers'),
|
|
hourCredits: schemaKeys('hourCredits'),
|
|
featureConsents: schemaKeys('featureConsents'),
|
|
},
|
|
})
|
|
const st = await startFakeStripe()
|
|
useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
|
|
Object.assign(process.env, { KUNDENANSICHT_NEU: 'pilot', KUNDENANSICHT_NEU_PILOT_EMAILS: 'K@example.invalid, k3@example.invalid' })
|
|
const { config } = await import('../server/config.js')
|
|
const { startTestApp, get, post, postWebhook } = await import('./support/testApp.js')
|
|
const { customerCookie, customers, kundenansichtCookie, seedFixtures, stripeSubscription } = await import('./support/fixtures.js')
|
|
const { default: aboRoutes } = await import('../server/routes/abo.js')
|
|
const { listContractEvents } = await import('../server/services/contractEvents.js')
|
|
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
|
const { setMailTransportForTests } = await import('../server/services/mailer.js')
|
|
const { offerText } = await import('../server/services/offers.js')
|
|
|
|
const app = await startTestApp({ '/api/abo': aboRoutes })
|
|
setMailTransportForTests(mailSink())
|
|
after(() => {
|
|
setMailTransportForTests(null)
|
|
return Promise.all([app.close(), aw.close(), st.close()])
|
|
})
|
|
seedFixtures(aw)
|
|
|
|
const unix = (iso) => Math.floor(new Date(iso).getTime() / 1000)
|
|
const setzeKundenart = (id, wert) => aw.seed('customers', { ...customers[id], ...(wert === undefined ? {} : { kundenart: wert }) })
|
|
|
|
/** Bestellung abschicken; dazu der Checkout-Aufruf beim Stripe-Nachbau (nur Aufrufe ab jetzt, sonst null). */
|
|
async function checkout(body, { cookie = customerCookie('c3') } = {}) {
|
|
const before = st.calls.length
|
|
const res = await post('/api/abo/checkout', body, { cookie })
|
|
const call = st.calls.slice(before).find((c) => c.method === 'POST' && c.path === '/v1/checkout/sessions') || null
|
|
return { res, call }
|
|
}
|
|
|
|
const NEU = () => config.abo.termsVersionNeu
|
|
const body = (productKey, extra = {}) => ({ productKey, acceptTerms: true, termsVersion: NEU(), offerId: '', ...extra })
|
|
const meta = (call, key) => call.body[`subscription_data[metadata][${key}]`]
|
|
const zeilen = () => [...aw.docs('featureConsents').values()].filter((d) => d.featureKey === 'abo')
|
|
const ids = (z) => JSON.parse(z.texte).map((t) => t.id)
|
|
|
|
test('Betrieb: sofort ohne Häkchen, Fassung 6 in den Metadaten, Nachweis ohne Beginn-Häkchen', async () => {
|
|
setzeKundenart('c3', 'unternehmen')
|
|
const n0 = zeilen().length
|
|
const { res, call } = await checkout(body('wartung'))
|
|
assert.equal(res.status, 200, JSON.stringify(res.body))
|
|
assert.equal(meta(call, 'startChoice'), 'sofort')
|
|
assert.ok(!meta(call, 'earlyStartConsentAt'))
|
|
assert.deepEqual([meta(call, 'termsVersion'), meta(call, 'consentTextVersion')], [NEU(), NEU()])
|
|
assert.equal(call.body['subscription_data[trial_end]'], undefined)
|
|
const [z] = zeilen().slice(n0)
|
|
assert.deepEqual([z.customerId, z.projectId, z.kundenart, z.stripeSessionId], ['c3', '', 'unternehmen', ''])
|
|
assert.deepEqual(ids(z), ['bestellung', 'linkzeile', 'knopf', 'kundenart'])
|
|
assert.deepEqual(JSON.parse(z.fassungen), { zustimmung: NEU(), bezug: 'wartung', wortlaut: 'entwurf' })
|
|
assert.match(JSON.parse(z.texte)[0].text, /^Wartungs-Abo: 50,00 € pro Monat .*Beginn sofort/)
|
|
})
|
|
|
|
test('Privat und leer: ohne earlyStart nach der Frist, mit earlyStart sofort mit Zeitstempel und Häkchen im Nachweis', async () => {
|
|
for (const art of ['privat', undefined]) {
|
|
setzeKundenart('c3', art)
|
|
const n0 = zeilen().length
|
|
const { lateStartAt } = await get('/api/abo', { cookie: customerCookie('c3') })
|
|
const frist = await checkout(body('hosting', { lateStartAt }))
|
|
assert.equal(frist.res.status, 200, JSON.stringify(frist.res.body))
|
|
assert.equal(meta(frist.call, 'startChoice'), 'nach_frist')
|
|
assert.equal(frist.call.body['subscription_data[trial_end]'], String(unix(lateStartAt)))
|
|
const sofort = await checkout(body('hosting', { earlyStart: true }))
|
|
assert.equal(meta(sofort.call, 'startChoice'), 'sofort')
|
|
assert.match(meta(sofort.call, 'earlyStartConsentAt'), /^\d{4}-\d\d-\d\dT/)
|
|
const neu = zeilen().slice(n0)
|
|
assert.deepEqual(neu.map(ids), [['bestellung', 'linkzeile', 'knopf', 'kundenart'], ['bestellung', 'linkzeile', 'beginn', 'knopf', 'kundenart']])
|
|
assert.deepEqual(neu.map((z) => z.kundenart), ['privat', 'privat'])
|
|
assert.match(JSON.parse(neu[0].texte)[0].text, /Beginn nach Ablauf der Widerrufsfrist am \d\d\.\d\d\.\d{4}/)
|
|
}
|
|
})
|
|
|
|
test('earlyStart zählt nur als Boolean true; veralteter Leistungsbeginn ist 409 ohne Nachweis und Stripe-Aufruf', async () => {
|
|
setzeKundenart('c3', 'privat')
|
|
const n0 = zeilen().length
|
|
const { lateStartAt } = await get('/api/abo', { cookie: customerCookie('c3') })
|
|
for (const wert of ['ja', 1, 'true', null]) assert.equal(meta((await checkout(body('hosting', { earlyStart: wert, lateStartAt }))).call, 'startChoice'), 'nach_frist', String(wert))
|
|
const alt = await checkout(body('hosting', { lateStartAt: '2026-01-02T05:00:00.000Z' }))
|
|
assert.equal(alt.res.status, 409)
|
|
assert.equal(alt.call, null)
|
|
assert.equal(zeilen().length, n0 + 4)
|
|
const ohne = await checkout(body('hosting'))
|
|
assert.equal(ohne.res.status, 409, 'ohne gezeigten Leistungsbeginn')
|
|
assert.equal(zeilen().length, n0 + 4)
|
|
})
|
|
|
|
test('Kundenart und Beginn kommen nie vom Client (Review Focus 1)', async () => {
|
|
const { lateStartAt } = await get('/api/abo', { cookie: customerCookie('c3') })
|
|
setzeKundenart('c3', 'unternehmen')
|
|
const b = await checkout(body('wartung', { kundenart: 'privat', unternehmer: false, startChoice: 'nach_frist', earlyStart: true, lateStartAt }))
|
|
assert.equal(meta(b.call, 'startChoice'), 'sofort')
|
|
assert.ok(!meta(b.call, 'earlyStartConsentAt'))
|
|
assert.equal(zeilen().at(-1).kundenart, 'unternehmen')
|
|
assert.ok(!ids(zeilen().at(-1)).includes('beginn'))
|
|
for (const wert of ['privat', '', 'firma', 'Unternehmen']) {
|
|
setzeKundenart('c3', wert === '' ? undefined : wert)
|
|
const p = await checkout(body('wartung', { kundenart: 'unternehmen', startChoice: 'sofort', lateStartAt }))
|
|
assert.equal(meta(p.call, 'startChoice'), 'nach_frist', wert)
|
|
assert.equal(zeilen().at(-1).kundenart, 'privat', wert)
|
|
}
|
|
})
|
|
|
|
test('Fassungsweiche: Fassung 6 ohne Pilot 409, Fassung 5 aus dem Pilot wie früher, fehlende Version nie neu', async () => {
|
|
setzeKundenart('c3', 'unternehmen')
|
|
const n0 = zeilen().length
|
|
const fremd = await checkout(body('wartung'), { cookie: customerCookie('c2') })
|
|
assert.equal(fremd.res.status, 409)
|
|
assert.match(fremd.res.body.error, /Bedingungen/)
|
|
assert.equal(fremd.call, null)
|
|
const v3 = await checkout(body('wartung', { termsVersion: '2026-09-25-v3' }))
|
|
assert.equal(v3.res.status, 409)
|
|
assert.equal(v3.res.body.error, 'Die Bedingungen wurden aktualisiert. Bitte lade die Seite neu.')
|
|
const alt = await checkout({ productKey: 'wartung', acceptTerms: true, startChoice: 'sofort', termsVersion: config.abo.termsVersion, offerId: '' })
|
|
assert.equal(alt.res.status, 200)
|
|
assert.equal(meta(alt.call, 'termsVersion'), config.abo.termsVersion)
|
|
assert.equal((await checkout({ productKey: 'wartung', acceptTerms: true, termsVersion: config.abo.termsVersion, offerId: '' })).res.status, 400) // alter Weg verlangt startChoice
|
|
const { termsVersion: _t, ...ohne } = body('wartung')
|
|
const gemerkt = config.abo.termsVersionNeu
|
|
for (const neuWert of [gemerkt, undefined]) {
|
|
config.abo.termsVersionNeu = neuWert
|
|
assert.equal((await checkout(ohne)).res.status, 409)
|
|
}
|
|
config.abo.termsVersionNeu = gemerkt
|
|
assert.equal(zeilen().length, n0) // weder Fassung 5 noch Fehlerfälle schreiben einen Nachweis
|
|
})
|
|
|
|
test('Fehlende Zustimmung in Fassung 6 ist 400 ohne Nachweis und ohne Stripe-Aufruf', async () => {
|
|
setzeKundenart('c3', 'unternehmen')
|
|
const n0 = zeilen().length
|
|
for (const acceptTerms of [false, undefined, 'true', 1]) {
|
|
const r = await checkout(body('wartung', { acceptTerms }))
|
|
assert.deepEqual([r.res.status, r.res.body.error, r.call], [400, 'Die Bestellung ist unvollständig. Bitte lade die Seite neu.', null], String(acceptTerms))
|
|
}
|
|
assert.equal((await checkout(body('gibtEsNicht'))).res.status, 400)
|
|
assert.equal(zeilen().length, n0)
|
|
})
|
|
|
|
test('Nachweis nicht speicherbar: 500, keine Stripe-Sitzung; Ansichtsmodus 403 ohne Schreiben', async () => {
|
|
setzeKundenart('c3', 'unternehmen')
|
|
const n0 = zeilen().length
|
|
aw.failNext({ collection: config.collections.featureConsents, method: 'POST' })
|
|
const f = await checkout(body('wartung'))
|
|
assert.deepEqual([f.res.status, f.res.body.error, f.call], [500, 'Das hat gerade nicht geklappt. Bitte versuche es gleich noch einmal.', null])
|
|
const v = await checkout(body('wartung'), { cookie: kundenansichtCookie({ customerId: 'c3' }) })
|
|
assert.deepEqual([v.res.status, v.call, zeilen().length], [403, null, n0])
|
|
})
|
|
|
|
test('Kunde nicht lesbar: 500 statt Rückfall auf privat oder Betrieb', async () => {
|
|
setzeKundenart('c3', 'unternehmen')
|
|
const n0 = zeilen().length
|
|
aw.failNext({ collection: config.collections.customers, method: 'GET', status: 500 })
|
|
const r = await checkout(body('wartung'))
|
|
assert.equal(r.res.status, 500)
|
|
assert.equal(r.call, null)
|
|
assert.equal(zeilen().length, n0)
|
|
})
|
|
|
|
test('Angebot: Die Zeile im Nachweis nennt das Angebot, das der Server kennt', async () => {
|
|
setzeKundenart('c3', 'unternehmen')
|
|
const offer = { $id: 'o1', customerId: 'c3', status: 'offen', scope: 'neu', months: 2, monthlyPriceCents: 2500, regularPriceCents: 5000, validUntil: '2099-01-01T00:00:00.000Z', stripeCouponId: 'WEBKLAR-ANGEBOT-O1', note: '' }
|
|
aw.seed('aboOffers', offer)
|
|
try {
|
|
const { res, call } = await checkout(body('wartung', { offerId: 'o1' }))
|
|
assert.equal(res.status, 200, JSON.stringify(res.body))
|
|
assert.equal(meta(call, 'offerId'), 'o1')
|
|
assert.ok(JSON.parse(zeilen().at(-1).texte)[0].text.includes(`individuelles Angebot: ${offerText(offer)}, Beginn sofort`))
|
|
} finally {
|
|
await deleteDocument(config.collections.aboOffers, 'o1').catch(() => {})
|
|
}
|
|
})
|
|
|
|
// Webhook: Abo-IDs sind 28 Zeichen wie bei Stripe (sub_ + 24), 'abschluss-' + ID wären sonst länger als 36
|
|
const SUB_NEW = 'sub_1SD6vPRxAbCdEfGhIjKlMnOp'
|
|
const checkoutCompleted = (subscriptionId, metadata = {}) => ({
|
|
id: `evt_${subscriptionId}`,
|
|
object: 'event',
|
|
type: 'checkout.session.completed',
|
|
created: Math.floor(Date.now() / 1000),
|
|
data: {
|
|
object: {
|
|
id: `cs_${subscriptionId}`, object: 'checkout.session', mode: 'subscription', subscription: subscriptionId, customer: 'cus_c3',
|
|
customer_details: { email: 'k3@example.invalid', name: 'Kunde Drei' },
|
|
metadata: { webklarCustomerId: 'c3', productKey: 'hosting', ...metadata },
|
|
},
|
|
},
|
|
})
|
|
async function cleanupWebhook(subscriptionId) {
|
|
for (const e of await listContractEvents('c3')) await deleteDocument(config.collections.contractEvents, e.$id)
|
|
await deleteDocument(config.collections.subscriptions, subscriptionId).catch(() => {})
|
|
}
|
|
|
|
test('Webhook: Ereignis abschluss nennt den Grund kundenart nur bei Fassung 6 ohne Zeitstempel', async () => {
|
|
const lauf = async (metadata) => {
|
|
st.subscriptions.set(SUB_NEW, stripeSubscription({ id: SUB_NEW, customerId: 'c3', productKey: 'wartung', metadata }))
|
|
try {
|
|
assert.equal((await postWebhook(checkoutCompleted(SUB_NEW, { productKey: 'wartung' }))).status, 200)
|
|
return (await listContractEvents('c3'))[0].details
|
|
} finally {
|
|
await cleanupWebhook(SUB_NEW)
|
|
}
|
|
}
|
|
assert.equal((await lauf({ termsVersion: NEU(), consentTextVersion: NEU(), startChoice: 'sofort', earlyStartConsentAt: '' })).kundenart, 'unternehmen')
|
|
assert.equal('kundenart' in (await lauf({ termsVersion: NEU(), startChoice: 'sofort', earlyStartConsentAt: new Date().toISOString() })), false)
|
|
assert.equal('kundenart' in (await lauf({ termsVersion: NEU(), startChoice: 'nach_frist', earlyStartConsentAt: '' })), false)
|
|
assert.equal('kundenart' in (await lauf({ termsVersion: config.abo.termsVersion, startChoice: 'sofort', earlyStartConsentAt: '' })), false)
|
|
})
|