Öffnungszeiten: Bezahlen gesperrt, wenn im Abo enthalten
Checkout: neue Stufe 7b pruefeInklusive (Funktionen mit aboInklusive): laeuft das Wartungs-Abo (auch nicht aktiv), 409 inklusive mit Hinweis aufs Einschalten; kein Abo, Hosting und gekuendigt zahlen weiter 30 Euro. Zahlung (markPaid): setup mit unlockedBy kauf, dann Neubau (stosseNeubauAn, einbau am Dokument), erst danach das Einbau-Ticket mit dem Ergebnis; die Webhook-Wiederholung baut nicht noch einmal. Spaete Zahlungen aendern ein vorhandenes unlockedBy abo/team nicht. News und Terminplaner unveraendert. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Opus 5.5 committed
1 parent
66793d06d5
commit
47ae572fff
4 files changed
+518
-4
No files matched your search
@@ -0,0 +1,454 @@
|
||||
import { test, after, beforeEach, afterEach, mock } 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 { schemaKeys } from './support/schema.js'
|
||||
import { useTestEnv } from './support/testEnv.js'
|
||||
import { ZEITEN_DATETIMES } from '../server/services/zeiten/schema.js'
|
||||
|
||||
// Bezahlweg von Oeffnungszeiten live (Aufgabe 17, Spec 3.3 und 4.6): Checkout-Sperre "inklusive" (pruefeInklusive in featureOrder.js),
|
||||
// Zahlung (markPaid in siteFeatures.js): setup, unlockedBy kauf, Neubau VOR dem Ticket, einbau am Dokument, Ticket-Text nennt das Ergebnis.
|
||||
// News und Terminplaner bleiben unveraendert (kein inklusive-Check, kein Neubau, kein unlockedBy).
|
||||
const aw = await startAppwriteMock({
|
||||
schema: {
|
||||
portalFeatures: schemaKeys('portalFeatures'),
|
||||
subscriptions: schemaKeys('subscriptions'),
|
||||
featureConsents: schemaKeys('featureConsents'),
|
||||
termineConfig: schemaKeys('termineConfig'),
|
||||
oeffnungszeiten: schemaKeys('oeffnungszeiten'),
|
||||
zeitenErinnerungen: schemaKeys('zeitenErinnerungen'),
|
||||
},
|
||||
// Datumsfelder wie in Appwrite: Unlesbares oder '' waere dort ein 400 (leeren geht nur mit null)
|
||||
datetimes: {
|
||||
...ZEITEN_DATETIMES,
|
||||
portalFeatures: ['orderedAt', 'activatedAt', 'disabledAt', 'consentAt', 'aboEndeMailAt', 'aboEndeAt', 'k24At'],
|
||||
featureConsents: ['acceptedAt'],
|
||||
},
|
||||
defaultLimit: 25,
|
||||
})
|
||||
const st = await startFakeStripe()
|
||||
useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
|
||||
const { config } = await import('../server/config.js')
|
||||
const { startTestApp, post, postWebhook } = await import('./support/testApp.js')
|
||||
const { customerCookie, hostingDoc, seedFixtures, subscriptionDoc, wartungDoc } = await import('./support/fixtures.js')
|
||||
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
||||
const { setMailTransportForTests } = await import('../server/services/mailer.js')
|
||||
const { default: funktionenRoutes } = await import('../server/routes/funktionen.js')
|
||||
const { default: aboRoutes } = await import('../server/routes/abo.js')
|
||||
const { orderDeps, pruefeInklusive } = await import('../server/services/featureOrder.js')
|
||||
const { aboMemo } = await import('../server/services/aboStatus.js')
|
||||
const sf = await import('../server/services/siteFeatures.js')
|
||||
const { zeitenDeps } = await import('../server/services/zeiten/neubau.js')
|
||||
const { resetZeitenCacheForTests } = await import('../server/services/zeiten/cache.js')
|
||||
|
||||
const app = await startTestApp({ '/api/funktionen': funktionenRoutes, '/api/abo': aboRoutes })
|
||||
after(() => Promise.all([app.close(), aw.close(), st.close()]))
|
||||
after(() => setMailTransportForTests(null))
|
||||
|
||||
const Z = config.features.zeiten
|
||||
const T = config.features.termine
|
||||
const MODUS = { zeiten: { mode: config.zeiten.mode, pilotEmails: [...config.zeiten.pilotEmails] }, termine: { mode: config.termine.mode, pilotEmails: [...config.termine.pilotEmails] } }
|
||||
const c1 = customerCookie('c1')
|
||||
const c3 = customerCookie('c3')
|
||||
const INKLUSIVE_TEXT = 'Im Wartungs-Abo bereits enthalten – einfach einschalten.'
|
||||
const SUBJECT = {
|
||||
K15: 'Deine Bestellung: Öffnungszeiten live',
|
||||
T16: 'Neue Funktion bestellt: Öffnungszeiten live',
|
||||
}
|
||||
const BEREITS_DA = /Bezahlt, aber schon vorhanden/
|
||||
|
||||
const wartung = (patch = {}) => aw.seed('subscriptions', subscriptionDoc('sub_h', { ...wartungDoc, ...patch }))
|
||||
const projekt = (id, over = {}) =>
|
||||
aw.seed('websiteProjects', { $id: id, customerId: 'c1', projectName: `Projekt ${id}`, subdomain: id, repoFullName: `JUSN/${id}`, previewMode: 'auto', previewDetected: 'static', ...over })
|
||||
|
||||
const bezahlteHaken = () => Z.consent.items.filter((item) => item.haken).map((item) => item.id)
|
||||
const koerper = (projectId = 'p1', extra = {}) => ({ projectId, zustimmung: { version: Z.consent.version, haken: bezahlteHaken() }, ...extra })
|
||||
const checkout = (body, cookie = c1, key = 'zeiten') => post(`/api/funktionen/${key}/checkout`, body, { cookie })
|
||||
|
||||
const sessionAufrufe = () => st.calls.filter((c) => c.method === 'POST' && c.path === '/v1/checkout/sessions')
|
||||
const preisDerSitzung = (aufruf) => st.prices.get(aufruf.body['line_items[0][price]'])
|
||||
const zeitenDoc = (projectId = 'p1') => aw.docs('portalFeatures').get(`f_${projectId}_zeiten`)
|
||||
const tickets = () => [...aw.docs('workorders').values()]
|
||||
const mailsMit = (subject) => sink.sent.filter((m) => m.subject === subject)
|
||||
const keineSpuren = () =>
|
||||
assert.deepEqual(
|
||||
{ features: aw.docs('portalFeatures').size, consents: aw.docs('featureConsents').size, tickets: aw.docs('workorders').size, sitzungen: sessionAufrufe().length, mails: sink.sent.length },
|
||||
{ features: 0, consents: 0, tickets: 0, sitzungen: 0, mails: 0 }
|
||||
)
|
||||
const event = (type, session) => ({ id: `evt_${Math.random()}`, object: 'event', type, data: { object: session } })
|
||||
const webhook = (type, session) => postWebhook(event(type, session))
|
||||
/** Bezahlte Sitzung im Ereignis; die Rechnung liegt im Stripe-Nachbau. */
|
||||
function bezahlt(sessionId, { projectId = 'p1', featureKey = 'zeiten', invoice = `in_${sessionId}` } = {}) {
|
||||
st.invoices.set(invoice, { id: invoice, object: 'invoice', hosted_invoice_url: `https://invoice.stripe.test/${invoice}` })
|
||||
return { id: sessionId, object: 'checkout.session', mode: 'payment', payment_status: 'paid', invoice, metadata: { customerId: 'c1', projectId, featureKey } }
|
||||
}
|
||||
|
||||
/** Echter Bestellweg: Checkout-Route legt die Stripe-Sitzung an und das Dokument auf 'ordered' (kein Wartungs-Abo). */
|
||||
async function bestelle(projectId = 'p1') {
|
||||
const res = await checkout(koerper(projectId))
|
||||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||||
const sessionId = [...st.checkoutSessions.values()].at(-1).id
|
||||
assert.equal(zeitenDoc(projectId).state, 'ordered')
|
||||
return sessionId
|
||||
}
|
||||
|
||||
let sink
|
||||
let rebuilds
|
||||
const originalRebuild = zeitenDeps.rebuild
|
||||
const originalAboMemo = orderDeps.aboMemo
|
||||
beforeEach(async () => {
|
||||
for (const col of ['subscriptions', 'portalFeatures', 'featureConsents', 'oeffnungszeiten', 'workorders', 'websiteProjects']) {
|
||||
for (const id of aw.docs(col).keys()) await deleteDocument(col, id)
|
||||
}
|
||||
resetZeitenCacheForTests()
|
||||
st.checkoutSessions.clear()
|
||||
st.invoices.clear()
|
||||
st.calls.length = 0
|
||||
seedFixtures(aw)
|
||||
projekt('p1')
|
||||
projekt('p2')
|
||||
projekt('p3', { customerId: 'c3' })
|
||||
aw.seed('customers', { $id: 'c1', appwriteUserId: 'u1', email: 'k@example.invalid', name: 'Kunde Eins', status: 'active', portalAccessEnabled: true })
|
||||
config.zeiten.mode = 'pilot'
|
||||
config.zeiten.pilotEmails = ['*']
|
||||
config.termine.mode = 'pilot'
|
||||
config.termine.pilotEmails = ['*']
|
||||
T.bestellpruefung = async () => []
|
||||
sink = mailSink()
|
||||
setMailTransportForTests(sink)
|
||||
rebuilds = []
|
||||
zeitenDeps.rebuild = async (p) => {
|
||||
rebuilds.push({ projektId: p.$id, tickets: aw.docs('workorders').size, state: zeitenDoc(p.$id)?.state, unlockedBy: zeitenDoc(p.$id)?.unlockedBy, einbau: zeitenDoc(p.$id)?.einbau })
|
||||
return { queued: true }
|
||||
}
|
||||
mock.method(console, 'error', () => {})
|
||||
mock.method(console, 'warn', () => {})
|
||||
mock.method(console, 'log', () => {})
|
||||
})
|
||||
afterEach(() => {
|
||||
mock.restoreAll()
|
||||
zeitenDeps.rebuild = originalRebuild
|
||||
orderDeps.aboMemo = originalAboMemo
|
||||
})
|
||||
after(() => {
|
||||
config.zeiten.mode = MODUS.zeiten.mode
|
||||
config.zeiten.pilotEmails = MODUS.zeiten.pilotEmails
|
||||
config.termine.mode = MODUS.termine.mode
|
||||
config.termine.pilotEmails = MODUS.termine.pilotEmails
|
||||
delete T.bestellpruefung
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------- Checkout-Sperre inklusive
|
||||
|
||||
test('Checkout zeiten mit laufendem Abo ⇒ 409 inklusive, keine Stripe-Sitzung, keine Spur', async () => {
|
||||
wartung()
|
||||
const res = await checkout(koerper())
|
||||
assert.equal(res.status, 409, JSON.stringify(res.body))
|
||||
assert.equal(res.body.error, INKLUSIVE_TEXT)
|
||||
assert.equal(res.body.code, 'inklusive')
|
||||
assert.equal(res.body.grund, null)
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
test('Checkout zeiten bei Abo nicht aktiv ⇒ 409 inklusive mit grund nicht_aktiv', async () => {
|
||||
for (const status of ['trialing', 'past_due']) {
|
||||
wartung({ status })
|
||||
const res = await checkout(koerper())
|
||||
assert.equal(res.status, 409, status)
|
||||
assert.equal(res.body.error, INKLUSIVE_TEXT, status)
|
||||
assert.equal(res.body.code, 'inklusive', status)
|
||||
assert.equal(res.body.grund, 'nicht_aktiv', status)
|
||||
keineSpuren()
|
||||
}
|
||||
})
|
||||
|
||||
test('Checkout zeiten ohne Abo, mit Hosting-Abo oder gekündigt ⇒ Stripe-Sitzung über 3000 Cent', async () => {
|
||||
const faelle = [
|
||||
['Hosting-Abo', () => aw.seed('subscriptions', hostingDoc), c1, 'p1'],
|
||||
['gekündigt', () => wartung({ cancelAtPeriodEnd: true }), c1, 'p2'],
|
||||
['gar kein Abo', () => {}, c3, 'p3'],
|
||||
]
|
||||
for (const [name, vorbereiten, cookie, projectId] of faelle) {
|
||||
for (const id of aw.docs('subscriptions').keys()) await deleteDocument('subscriptions', id)
|
||||
vorbereiten()
|
||||
const vorher = sessionAufrufe().length
|
||||
const res = await checkout(koerper(projectId), cookie)
|
||||
assert.equal(res.status, 200, `${name}: ${JSON.stringify(res.body)}`)
|
||||
assert.match(res.body.url, /^https:\/\/checkout\.stripe\.test\/c\/pay\/cs_test_/, name)
|
||||
assert.equal(sessionAufrufe().length, vorher + 1, name)
|
||||
assert.equal(preisDerSitzung(sessionAufrufe().at(-1)).unit_amount, 3000, name)
|
||||
assert.equal(sessionAufrufe().at(-1).body['metadata[featureKey]'], 'zeiten', name)
|
||||
assert.equal(zeitenDoc(projectId).state, 'ordered', name)
|
||||
}
|
||||
})
|
||||
|
||||
test('Checkout zeiten: Abo nicht lesbar ⇒ 500 ohne Rohtext, keine Stripe-Sitzung, keine Spur (fail-closed)', async () => {
|
||||
wartung()
|
||||
aw.failNext({ collection: 'subscriptions', status: 500, message: 'Interner Appwrite-Text mit Kunde c1' })
|
||||
const res = await checkout(koerper())
|
||||
assert.equal(res.status, 500)
|
||||
assert.equal(JSON.stringify(res.body).includes('Appwrite'), false)
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
test('Reihenfolge: die Sperre inklusive kommt nach Zustimmung, Projekt, Schalter und Unterlagen', async () => {
|
||||
wartung()
|
||||
const lesungen = []
|
||||
orderDeps.aboMemo = () => {
|
||||
const memo = aboMemo()
|
||||
return { ...memo, bestellbar: async (id) => (lesungen.push(id), memo.bestellbar(id)) }
|
||||
}
|
||||
// 3 Zustimmung
|
||||
const ohne = await checkout({ projectId: 'p1' })
|
||||
assert.equal(ohne.status, 400)
|
||||
assert.equal(ohne.body.code, 'zustimmung_fehlt')
|
||||
// 4 Projekt (fremd)
|
||||
assert.equal((await checkout(koerper('p3'))).status, 403)
|
||||
// 5 Schalter
|
||||
config.zeiten.mode = 'off'
|
||||
const aus = await checkout(koerper())
|
||||
assert.equal(aus.status, 409)
|
||||
assert.equal(aus.body.code, 'nicht_verfuegbar')
|
||||
config.zeiten.mode = 'pilot'
|
||||
// 5b Unterlagen
|
||||
Z.unterlagenBereit = async () => false
|
||||
const unterlagen = await checkout(koerper())
|
||||
assert.equal(unterlagen.status, 503)
|
||||
assert.equal(unterlagen.body.code, 'unterlagen_fehlen')
|
||||
delete Z.unterlagenBereit
|
||||
assert.deepEqual(lesungen, [], 'bis hierhin wurde das Abo nicht gelesen')
|
||||
// 7b Abo: jetzt kommt inklusive, mit genau einer Abo-Lesung
|
||||
const inklusive = await checkout(koerper())
|
||||
assert.equal(inklusive.status, 409)
|
||||
assert.equal(inklusive.body.code, 'inklusive')
|
||||
assert.deepEqual(lesungen, ['c1'])
|
||||
keineSpuren()
|
||||
})
|
||||
|
||||
test('News und Termine unverändert: kein inklusive-Check (Abo wird für News nicht, für Termine einmal gelesen)', async () => {
|
||||
wartung()
|
||||
const lesungen = []
|
||||
orderDeps.aboMemo = () => {
|
||||
const memo = aboMemo()
|
||||
return { ...memo, bestellbar: async (id) => (lesungen.push(id), memo.bestellbar(id)) }
|
||||
}
|
||||
const news = await checkout({ projectId: 'p1', consent: true }, c1, 'news')
|
||||
assert.equal(news.status, 200, JSON.stringify(news.body))
|
||||
assert.deepEqual(lesungen, [], 'News liest das Abo nicht')
|
||||
|
||||
const haken = T.consent.items.filter((item) => item.haken).map((item) => item.id)
|
||||
const termine = await checkout({ projectId: 'p2', zustimmung: { version: T.consent.version, haken } }, c1, 'termine')
|
||||
assert.equal(termine.status, 200, JSON.stringify(termine.body))
|
||||
assert.deepEqual(lesungen, ['c1'], 'Termine liest das Abo einmal (Wartungs-Abo-Pflicht), nicht ein zweites Mal für inklusive')
|
||||
assert.equal(aw.docs('portalFeatures').get('f_p1_news')?.state, 'ordered')
|
||||
assert.equal(aw.docs('portalFeatures').get('f_p2_termine')?.state, 'ordered')
|
||||
})
|
||||
|
||||
test('pruefeInklusive: nur bei aboInklusive; ok und nicht_aktiv sperren, kein_abo und gekuendigt nicht; Lesefehler ⇒ 500', async () => {
|
||||
wartung()
|
||||
await pruefeInklusive({ ...Z, aboInklusive: false }, 'c1') // Funktion ohne aboInklusive: nichts
|
||||
await pruefeInklusive(config.features.news, 'c1')
|
||||
await assert.rejects(pruefeInklusive(Z, 'c1'), (err) => err.status === 409 && err.code === 'inklusive' && err.message === INKLUSIVE_TEXT && err.body.grund === null)
|
||||
wartung({ status: 'past_due' })
|
||||
await assert.rejects(pruefeInklusive(Z, 'c1'), (err) => err.status === 409 && err.code === 'inklusive' && err.body.grund === 'nicht_aktiv')
|
||||
wartung({ cancelAtPeriodEnd: true })
|
||||
await pruefeInklusive(Z, 'c1')
|
||||
await pruefeInklusive(Z, 'c3')
|
||||
aw.failNext({ collection: 'subscriptions', status: 500, message: 'Geheim' })
|
||||
await assert.rejects(pruefeInklusive(Z, 'c1'), (err) => err.status === 500 && err.code === undefined) // wie pruefeAbo: die Route zeigt nur ihren allgemeinen Text
|
||||
})
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------- Zahlung
|
||||
|
||||
test('Zahlung ⇒ setup, unlockedBy kauf, Neubau vor dem Ticket, einbau am Dokument, Ticket nennt das Ergebnis, K15 und T16', async () => {
|
||||
const sessionId = await bestelle()
|
||||
const res = await webhook('checkout.session.completed', bezahlt(sessionId))
|
||||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||||
|
||||
const doc = zeitenDoc()
|
||||
assert.deepEqual(
|
||||
[doc.state, doc.enabled, doc.purchaseStatus, doc.unlockedBy, doc.unlockedByPurchase, doc.einbau, doc.zahlungMeldung],
|
||||
['setup', false, 'paid', 'kauf', true, 'angestossen', '']
|
||||
)
|
||||
assert.equal(sf.unlockedByVon(doc), 'kauf')
|
||||
assert.equal(doc.invoiceUrl, `https://invoice.stripe.test/in_${sessionId}`)
|
||||
|
||||
// Reihenfolge: der Neubau lief, als der Zustand schon setup/kauf war, aber noch ohne Ticket und ohne einbau
|
||||
assert.deepEqual(rebuilds, [{ projektId: 'p1', tickets: 0, state: 'setup', unlockedBy: 'kauf', einbau: '' }])
|
||||
|
||||
// Ticket: einmal, Text nennt das Ergebnis des Neubaus (automatisch eingesetzt) und den siteKey
|
||||
assert.equal(tickets().length, 1)
|
||||
const [ticket] = tickets()
|
||||
assert.equal(doc.ticketId, ticket.$id)
|
||||
assert.equal(ticket.topic, 'Öffnungszeiten live einbauen – Projekt p1')
|
||||
assert.match(ticket.details, /Einbau: automatisch eingesetzt \(nach dem nächsten Veröffentlichen prüfen\)/)
|
||||
assert.doesNotMatch(ticket.details, /bitte von Hand einsetzen/)
|
||||
assert.ok(ticket.details.includes(`data-site="${doc.siteKey}"`))
|
||||
|
||||
// K15 an den Kunden, T16 ans Team, je einmal; keine K24 (die gehört zum Gratisweg)
|
||||
assert.equal(mailsMit(SUBJECT.K15).length, 1)
|
||||
assert.deepEqual(mailsMit(SUBJECT.K15)[0].to.map((a) => a.address), ['k@example.invalid'])
|
||||
assert.equal(mailsMit(SUBJECT.T16).length, 1)
|
||||
assert.doesNotMatch(mailsMit(SUBJECT.T16)[0].text, BEREITS_DA)
|
||||
assert.equal(mailsMit('Öffnungszeiten live ist eingeschaltet').length, 0)
|
||||
assert.equal(doc.k24At ?? null, null)
|
||||
})
|
||||
|
||||
test('Zahlung, Neubau nicht möglich (kein Repo): einbau manuell, Ticket sagt „bitte von Hand einsetzen“', async () => {
|
||||
aw.seed('websiteProjects', { $id: 'p1', customerId: 'c1', projectName: 'Ohne Repo' })
|
||||
const sessionId = await bestelle()
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt(sessionId))).status, 200)
|
||||
assert.deepEqual(rebuilds, [])
|
||||
assert.equal(zeitenDoc().einbau, 'manuell')
|
||||
assert.equal(zeitenDoc().unlockedBy, 'kauf')
|
||||
assert.equal(tickets().length, 1)
|
||||
assert.match(tickets()[0].details, /Einbau: bitte von Hand einsetzen/)
|
||||
assert.doesNotMatch(tickets()[0].details, /automatisch eingesetzt/)
|
||||
})
|
||||
|
||||
test('Zahlung, Neubau wirft: einbau manuell, Zustand und Ticket bleiben (bezahlt ist bezahlt)', async () => {
|
||||
zeitenDeps.rebuild = async () => {
|
||||
throw new Error('Runner nicht erreichbar')
|
||||
}
|
||||
const sessionId = await bestelle()
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt(sessionId))).status, 200)
|
||||
assert.deepEqual([zeitenDoc().state, zeitenDoc().einbau, zeitenDoc().unlockedBy], ['setup', 'manuell', 'kauf'])
|
||||
assert.equal(tickets().length, 1)
|
||||
assert.match(tickets()[0].details, /Einbau: bitte von Hand einsetzen/)
|
||||
assert.equal(mailsMit(SUBJECT.K15).length, 1)
|
||||
})
|
||||
|
||||
test('Stripe wiederholt den Webhook: kein zweiter Neubau, kein zweites Ticket, keine zweite Mail', async () => {
|
||||
const sessionId = await bestelle()
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt(sessionId))).status, 200)
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt(sessionId))).status, 200)
|
||||
assert.equal((await webhook('checkout.session.async_payment_succeeded', bezahlt(sessionId))).status, 200)
|
||||
assert.equal(rebuilds.length, 1)
|
||||
assert.equal(tickets().length, 1)
|
||||
assert.equal(mailsMit(SUBJECT.K15).length, 1)
|
||||
assert.equal(mailsMit(SUBJECT.T16).length, 1)
|
||||
})
|
||||
|
||||
test('Ticket scheitert ⇒ Webhook 500, Zustand setup/kauf/einbau gespeichert; die Wiederholung legt das Ticket an, ohne zweiten Neubau', async () => {
|
||||
const sessionId = await bestelle()
|
||||
aw.failNext({ collection: 'workorders', method: 'POST', status: 500, message: 'Ticketsystem down' })
|
||||
const erster = await webhook('checkout.session.completed', bezahlt(sessionId))
|
||||
assert.equal(erster.status, 500)
|
||||
assert.deepEqual([zeitenDoc().state, zeitenDoc().unlockedBy, zeitenDoc().einbau], ['setup', 'kauf', 'angestossen'])
|
||||
assert.equal(zeitenDoc().ticketId ?? '', '')
|
||||
assert.equal(tickets().length, 0)
|
||||
assert.equal(mailsMit(SUBJECT.K15).length, 0, 'K15 erst nach dem Ticket')
|
||||
|
||||
const zweiter = await webhook('checkout.session.completed', bezahlt(sessionId))
|
||||
assert.equal(zweiter.status, 200)
|
||||
assert.equal(rebuilds.length, 1, 'einbau war schon gespeichert: kein zweiter Neubau')
|
||||
assert.equal(tickets().length, 1)
|
||||
assert.match(tickets()[0].details, /Einbau: automatisch eingesetzt/)
|
||||
assert.equal(zeitenDoc().ticketId, tickets()[0].$id)
|
||||
assert.equal(mailsMit(SUBJECT.K15).length, 1)
|
||||
assert.equal(mailsMit(SUBJECT.T16).length, 1)
|
||||
})
|
||||
|
||||
test('Neubau-Absturz vor dem Speichern von einbau: die Wiederholung baut neu und legt dann das Ticket an', async () => {
|
||||
const sessionId = await bestelle()
|
||||
// der Zustand ist gespeichert (setup, kauf, einbau leer), aber weder Neubau noch Ticket sind gelaufen
|
||||
aw.seed('portalFeatures', { ...zeitenDoc(), state: 'setup', enabled: false, purchaseStatus: 'paid', unlockedBy: 'kauf', unlockedByPurchase: true, einbau: '' })
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt(sessionId))).status, 200)
|
||||
assert.equal(rebuilds.length, 1)
|
||||
assert.equal(tickets().length, 1)
|
||||
assert.equal(zeitenDoc().einbau, 'angestossen')
|
||||
})
|
||||
|
||||
test('Neubauten sind serialisiert: zwei gleichzeitige Zahlungen starten nie zwei Neubauten zugleich', async () => {
|
||||
let gleichzeitig = 0
|
||||
let hoechstens = 0
|
||||
zeitenDeps.rebuild = async (p) => {
|
||||
gleichzeitig += 1
|
||||
hoechstens = Math.max(hoechstens, gleichzeitig)
|
||||
await new Promise((resolve) => setTimeout(resolve, 25))
|
||||
gleichzeitig -= 1
|
||||
rebuilds.push({ projektId: p.$id })
|
||||
return { queued: true }
|
||||
}
|
||||
const s1 = await bestelle('p1')
|
||||
const s2 = await bestelle('p2')
|
||||
const [a, b] = await Promise.all([webhook('checkout.session.completed', bezahlt(s1, { projectId: 'p1' })), webhook('checkout.session.completed', bezahlt(s2, { projectId: 'p2' }))])
|
||||
assert.deepEqual([a.status, b.status], [200, 200])
|
||||
assert.equal(rebuilds.length, 2)
|
||||
assert.equal(hoechstens, 1)
|
||||
assert.deepEqual([zeitenDoc('p1').einbau, zeitenDoc('p2').einbau], ['angestossen', 'angestossen'])
|
||||
})
|
||||
|
||||
// -------------------------------------------------------------------------------------- späte Zahlung, Altbestand
|
||||
|
||||
const seedeZeiten = (over) =>
|
||||
aw.seed('portalFeatures', {
|
||||
$id: 'f_p1_zeiten',
|
||||
customerId: 'c1',
|
||||
projectId: 'p1',
|
||||
featureKey: 'zeiten',
|
||||
state: 'active',
|
||||
enabled: true,
|
||||
unlockedByPurchase: false,
|
||||
purchaseStatus: '',
|
||||
siteKey: 'abcdefghijklmnop',
|
||||
stripeSessionId: 'cs_alt',
|
||||
...over,
|
||||
})
|
||||
|
||||
test('späte Zahlung auf ein per Abo eingeschaltetes Dokument: gebucht und gemeldet, unlockedBy bleibt abo, nichts eingerichtet', async () => {
|
||||
seedeZeiten({ state: 'active', unlockedBy: 'abo', ticketId: 't_alt' })
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt('cs_alt'))).status, 200)
|
||||
const doc = zeitenDoc()
|
||||
assert.deepEqual([doc.state, doc.purchaseStatus, doc.unlockedBy, doc.zahlungMeldung], ['active', 'paid', 'abo', 'gemeldet'])
|
||||
assert.equal(rebuilds.length, 0)
|
||||
assert.equal(tickets().length, 0)
|
||||
assert.equal(mailsMit(SUBJECT.K15).length, 0)
|
||||
assert.equal(mailsMit(SUBJECT.T16).length, 1)
|
||||
assert.match(mailsMit(SUBJECT.T16)[0].text, BEREITS_DA)
|
||||
})
|
||||
|
||||
test('Zahlung auf ein Abo-Dokument in setup ohne Ticket: kein zweites Ticket neben dem Nachholen (holeZeitenNach), unlockedBy bleibt abo', async () => {
|
||||
seedeZeiten({ state: 'setup', enabled: false, unlockedBy: 'abo' })
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt('cs_alt'))).status, 200)
|
||||
const doc = zeitenDoc()
|
||||
assert.deepEqual([doc.state, doc.unlockedBy, doc.purchaseStatus], ['setup', 'abo', 'paid'])
|
||||
assert.equal(doc.ticketId ?? '', '')
|
||||
assert.equal(tickets().length, 0)
|
||||
assert.equal(rebuilds.length, 0)
|
||||
assert.equal(mailsMit(SUBJECT.K15).length, 0)
|
||||
assert.match(mailsMit(SUBJECT.T16)[0].text, BEREITS_DA)
|
||||
})
|
||||
|
||||
test('späte Zahlung ohne unlockedBy am Dokument (Altbestand): unlockedBy wird kauf, passend zu unlockedByPurchase true', async () => {
|
||||
seedeZeiten({ state: 'active', ticketId: 't_alt' })
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt('cs_alt'))).status, 200)
|
||||
const doc = zeitenDoc()
|
||||
assert.deepEqual([doc.unlockedBy, doc.unlockedByPurchase, doc.purchaseStatus], ['kauf', true, 'paid'])
|
||||
assert.equal(rebuilds.length, 0)
|
||||
})
|
||||
|
||||
// ------------------------------------------------------------------------------------ News und Termine unverändert
|
||||
|
||||
test('News und Termine bezahlt: wie bisher, kein unlockedBy, kein einbau, kein Neubau', async () => {
|
||||
// News (alter Weg ohne Abo) und Terminplaner (mit Wartungs-Abo, TERMINE_ENABLED=pilot)
|
||||
wartung()
|
||||
const haken = T.consent.items.filter((item) => item.haken).map((item) => item.id)
|
||||
assert.equal((await checkout({ projectId: 'p1', consent: true }, c1, 'news')).status, 200)
|
||||
assert.equal((await checkout({ projectId: 'p2', zustimmung: { version: T.consent.version, haken } }, c1, 'termine')).status, 200)
|
||||
const sNews = aw.docs('portalFeatures').get('f_p1_news').stripeSessionId
|
||||
const sTermine = aw.docs('portalFeatures').get('f_p2_termine').stripeSessionId
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt(sNews, { projectId: 'p1', featureKey: 'news' }))).status, 200)
|
||||
assert.equal((await webhook('checkout.session.completed', bezahlt(sTermine, { projectId: 'p2', featureKey: 'termine' }))).status, 200)
|
||||
|
||||
for (const id of ['f_p1_news', 'f_p2_termine']) {
|
||||
const doc = aw.docs('portalFeatures').get(id)
|
||||
assert.deepEqual([doc.state, doc.purchaseStatus, doc.unlockedByPurchase], ['setup', 'paid', true], id)
|
||||
assert.ok(doc.ticketId, id)
|
||||
assert.equal(doc.unlockedBy ?? null, null, `${id}: unlockedBy nicht geschrieben`)
|
||||
assert.equal(doc.einbau ?? null, null, `${id}: einbau nicht geschrieben`)
|
||||
}
|
||||
assert.equal(rebuilds.length, 0)
|
||||
assert.equal(tickets().length, 2)
|
||||
})
|
||||
Reference in new issue
Block a user