1156 lines
65 KiB
JavaScript
1156 lines
65 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 { useTestEnv } from './support/testEnv.js'
|
||
import { schemaKeys } from './support/schema.js'
|
||
import { mailSink } from './support/mailSink.js'
|
||
|
||
// Nachbauten starten und die Umgebung setzen, BEVOR config.js (ueber testApp/fixtures/Routen) geladen wird
|
||
const aw = await startAppwriteMock({
|
||
schema: {
|
||
subscriptions: schemaKeys('subscriptions'),
|
||
contractEvents: schemaKeys('contractEvents'),
|
||
hourCredits: schemaKeys('hourCredits'),
|
||
},
|
||
})
|
||
const st = await startFakeStripe()
|
||
useTestEnv({ appwriteUrl: aw.url, stripeUrl: st.url })
|
||
// Testkonto (Testrabatte): Kunde c4 der Fixtures
|
||
process.env.ABO_TEST_EMAILS = 'test@example.invalid'
|
||
const { config } = await import('../server/config.js')
|
||
const { startTestApp, get, post, postWebhook } = await import('./support/testApp.js')
|
||
const { hostingDoc, hosting2Doc, consent, customerCookie, viewAsCookie, seedFixtures, stripeSubscription, subscriptionDoc } =
|
||
await import('./support/fixtures.js')
|
||
const { default: aboRoutes } = await import('../server/routes/abo.js')
|
||
const { previewSwitch, switchToWartung, markSwitchFailed, previewProblem, paymentMethodTypeOf, reconcilePendingSwitch, SWITCH_FAILED_REASONS } =
|
||
await import('../server/services/planSwitch.js')
|
||
const { listContractEvents, recordContractEvent, updateContractEvent } = await import('../server/services/contractEvents.js')
|
||
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
||
const { addMonths } = await import('../server/services/stripeBilling.js')
|
||
const { setMailTransportForTests } = await import('../server/services/mailer.js')
|
||
const { parseArgs, run: runFailedSwitchScript } = await import('../scripts/wechsel-gescheitert.mjs')
|
||
|
||
const app = await startTestApp({ '/api/abo': aboRoutes })
|
||
// F25: Mails landen in einer Senke (nodemailer jsonTransport) statt bei SMTP, damit K12, K14 und T12 pruefbar sind
|
||
const mails = mailSink()
|
||
setMailTransportForTests(mails)
|
||
after(() => {
|
||
setMailTransportForTests(null)
|
||
return Promise.all([app.close(), aw.close(), st.close()])
|
||
})
|
||
seedFixtures(aw)
|
||
|
||
// Preise im Stripe-Nachbau mit den lookup_keys des Katalogs (ensurePrice findet sie, die Fixture
|
||
// stripeSubscription() haengt dieselben IDs an die Abo-Posten)
|
||
const price = (id, lookup_key, unit_amount) => ({ id, object: 'price', active: true, lookup_key, unit_amount, recurring: { interval: 'month' } })
|
||
st.prices.set('price_hosting', price('price_hosting', config.products.hosting.lookupKey, config.products.hosting.amountCents))
|
||
st.prices.set('price_wartung', price('price_wartung', config.products.wartung.lookupKey, config.products.wartung.amountCents))
|
||
st.prices.set('price_mailStorage', price('price_mailStorage', config.mailStorage.lookupKey, config.mailStorage.amountCents))
|
||
|
||
const nowUnix = () => Math.floor(Date.now() / 1000)
|
||
const unix = (iso) => Math.floor(new Date(iso).getTime() / 1000)
|
||
|
||
// Standard-Zahlungsmethoden, wie subscriptions.retrieve sie mit expand liefert (F24)
|
||
const CARD = { id: 'pm_card_visa', object: 'payment_method', type: 'card' }
|
||
const SEPA = { id: 'pm_sepa_de', object: 'payment_method', type: 'sepa_debit' }
|
||
|
||
const K12_SUBJECT = 'Ihr Wechsel ins WEBklar Wartungs-Abo – Bestätigung'
|
||
const K14_SUBJECT = 'Ihr Wechsel ins WEBklar Wartungs-Abo ist nicht zustande gekommen'
|
||
const t12Subject = (email) => `[Abo] Wechsel ins Wartungs-Abo: ${email}`
|
||
// Wortlaut aus der Rechtsrunde (Task 9, Block zahlung_offen)
|
||
const ZAHLUNG_OFFEN =
|
||
'Der Wechsel wird wirksam, sobald die Zahlung bestätigt ist. Andernfalls läuft Ihr Hosting-Abo mit Preis und Mindestlaufzeit wie bisher weiter.'
|
||
const LASTSCHRIFT = 'Wird die Lastschrift nicht eingelöst, gilt der Wechsel als nicht erfolgt'
|
||
const WIRKSAM = 'Der Wechsel ist wirksam'
|
||
const HOSTING_LAEUFT_WEITER = 'Ihr Hosting-Abo läuft mit Preis und Mindestlaufzeit wie vor dem Wechsel weiter.'
|
||
|
||
async function clearEvents(customerId) {
|
||
for (const e of await listContractEvents(customerId)) await deleteDocument(config.collections.contractEvents, e.$id)
|
||
}
|
||
|
||
/**
|
||
* Hosting-Abo in Spiegel und Stripe-Nachbau auf den Ausgangsstand setzen (Standard: sub_h von c1, Karte),
|
||
* Ereignisse des Kunden und die Mail-Senke leeren. patch aendert den Spiegel, stripe das Stripe-Abo.
|
||
*/
|
||
async function resetHosting({ id = 'sub_h', customerId = 'c1', mirror = hostingDoc, patch = {}, stripe = {}, paymentMethod = CARD } = {}) {
|
||
await clearEvents(customerId)
|
||
aw.seed('subscriptions', { ...mirror, ...patch })
|
||
st.subscriptions.set(id, stripeSubscription({ id, customerId, productKey: 'hosting', default_payment_method: paymentMethod, ...stripe }))
|
||
st.nextSubscriptionUpdate = null
|
||
mails.sent.length = 0
|
||
}
|
||
|
||
// Rechnungszeilen in der Form der SDK-API-Version (2025-10-29.clover)
|
||
const line = (priceId, amount, { proration = false, subscription = 'sub_h', periodStart = null } = {}) => ({
|
||
amount,
|
||
quantity: 1,
|
||
period: { start: periodStart ?? unix(hostingDoc.startedAt), end: unix(hostingDoc.currentPeriodEnd) },
|
||
pricing: { type: 'price_details', price_details: { price: priceId } },
|
||
parent: { type: 'subscription_item_details', subscription_item_details: { proration, subscription } },
|
||
})
|
||
const previewInvoice = (...lines) => ({
|
||
object: 'invoice',
|
||
lines: { object: 'list', data: lines, has_more: false },
|
||
amount_due: lines.reduce((sum, l) => sum + l.amount, 0),
|
||
})
|
||
// Wechselrechnung, wie subscriptions.update sie mit expand: ['latest_invoice'] liefert
|
||
const switchInvoice = (overrides = {}) => ({
|
||
id: 'in_wechsel',
|
||
object: 'invoice',
|
||
status: 'paid',
|
||
amount_due: 4100,
|
||
billing_reason: 'subscription_update',
|
||
hosted_invoice_url: 'https://invoice.stripe.test/i/in_wechsel',
|
||
...overrides,
|
||
})
|
||
// Stripe haelt die Aenderung zurueck, bis die Rechnung bezahlt ist (Karte, z. B. 3-D Secure)
|
||
const pendingUpdate = () => ({ expires_at: nowUnix() + 23 * 3600, billing_cycle_anchor: nowUnix(), subscription_items: [], trial_end: null, trial_from_plan: null })
|
||
const paidInvoice = (id, subscription = 'sub_h') => ({
|
||
id,
|
||
object: 'invoice',
|
||
number: `WK-${id}`,
|
||
status: 'paid',
|
||
billing_reason: 'subscription_update',
|
||
amount_due: 4100,
|
||
created: nowUnix(),
|
||
status_transitions: { paid_at: nowUnix() },
|
||
parent: { type: 'subscription_details', subscription_details: { subscription } },
|
||
lines: { object: 'list', data: [line('price_hosting', -900, { proration: true, periodStart: nowUnix(), subscription }), line('price_wartung', 5000, { subscription })] },
|
||
})
|
||
const webhookEvent = (type, object) => ({
|
||
id: `evt_${Math.random().toString(36).slice(2, 10)}`,
|
||
object: 'event',
|
||
type,
|
||
created: nowUnix(),
|
||
data: { object },
|
||
})
|
||
|
||
const updateCalls = (id = 'sub_h', from = 0) => st.calls.slice(from).filter((c) => c.method === 'POST' && c.path === `/v1/subscriptions/${id}`)
|
||
const previewCalls = (from = 0) => st.calls.slice(from).filter((c) => c.method === 'POST' && c.path === '/v1/invoices/create_preview')
|
||
const mailsWithSubject = (subject) => mails.sent.filter((m) => m.subject === subject)
|
||
const recipients = (mail) => mail.to.map((t) => t.address)
|
||
|
||
async function withCapturedLogs(fn) {
|
||
const logs = { error: [], warn: [] }
|
||
const original = { error: console.error, warn: console.warn }
|
||
console.error = (...args) => logs.error.push(args.join(' '))
|
||
console.warn = (...args) => logs.warn.push(args.join(' '))
|
||
try {
|
||
await fn(logs)
|
||
} finally {
|
||
console.error = original.error
|
||
console.warn = original.warn
|
||
}
|
||
return logs
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Vorschau
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Vorschau: Gutschrift und heute fällig aus der Stripe-Vorschau', async () => {
|
||
await resetHosting()
|
||
// Stripe-Nachbau: POST /v1/invoices/create_preview liefert die Zeilen -900 (anteilig) und 5000
|
||
st.invoicePreview = previewInvoice(line('price_hosting', -900, { proration: true, periodStart: nowUnix() }), line('price_wartung', 5000))
|
||
const before = st.calls.length
|
||
const p = await previewSwitch('c1')
|
||
assert.equal(p.creditCents, 900); assert.equal(p.amountDueCents, 4100); assert.equal(p.monthlyCents, 5000)
|
||
assert.ok(Math.abs(p.prorationDate - nowUnix()) <= 5, 'Vorschau-Zeitpunkt jetzt')
|
||
// Neuer Abbuchungstag = Wechseltag, neue Mindestlaufzeit 12 Monate ab dem Wechseltag
|
||
assert.equal(p.nextChargeAt, addMonths(new Date(p.prorationDate * 1000), 1).toISOString())
|
||
assert.equal(p.minTermEnd, addMonths(new Date(p.prorationDate * 1000), 12).toISOString())
|
||
const [call] = previewCalls(before)
|
||
assert.equal(call.body['subscription'], 'sub_h')
|
||
assert.equal(call.body['subscription_details[items][0][id]'], 'si_sub_h_abo')
|
||
assert.equal(call.body['subscription_details[items][0][price]'], 'price_wartung')
|
||
assert.equal(call.body['subscription_details[billing_cycle_anchor]'], 'now')
|
||
assert.equal(call.body['subscription_details[proration_behavior]'], 'create_prorations')
|
||
assert.equal(call.body['subscription_details[proration_date]'], String(p.prorationDate))
|
||
assert.equal(call.body['discounts[0][coupon]'], undefined, 'kein Testkonto: Rabatte wie am Abo')
|
||
// Eine Vorschau aendert nichts bei Stripe
|
||
assert.deepEqual(updateCalls('sub_h', before), [])
|
||
})
|
||
|
||
test('Vorschau: Gutschrift nur aus den anteiligen Zeilen dieses Wechsels (auch Speicher), ältere zählen nicht', async () => {
|
||
await resetHosting({ stripe: { storageUnits: 2 } })
|
||
const now = nowUnix()
|
||
st.invoicePreview = previewInvoice(
|
||
// Speicher-Plus von vorhin (schon vorgemerkte Rechnungsposition): im Betrag, aber keine Gutschrift dieses Wechsels
|
||
line('price_mailStorage', -30, { proration: true, periodStart: now - 3 * 3600 }),
|
||
line('price_mailStorage', 90, { proration: true, periodStart: now - 3 * 3600 }),
|
||
line('price_hosting', -900, { proration: true, periodStart: now }),
|
||
line('price_mailStorage', -120, { proration: true, periodStart: now }),
|
||
line('price_wartung', 5000),
|
||
line('price_mailStorage', 200)
|
||
)
|
||
const p = await previewSwitch('c1')
|
||
assert.equal(p.creditCents, 1020)
|
||
assert.equal(p.amountDueCents, 5000 + 200 - 900 - 120 - 30 + 90)
|
||
})
|
||
|
||
test('Vorschau: Voraussetzungen wie beim Wechsel (409), kein Abo 404, ohne Stripe-Vorschau', async () => {
|
||
const before = st.calls.length
|
||
for (const patch of [{ cancelAtPeriodEnd: true }, { productKey: 'wartung' }, { status: 'trialing' }, { status: 'past_due' }]) {
|
||
await resetHosting({ patch })
|
||
await assert.rejects(previewSwitch('c1'), (e) => e.status === 409, JSON.stringify(patch))
|
||
}
|
||
await assert.rejects(previewSwitch('c3'), (e) => e.status === 404)
|
||
assert.deepEqual(previewCalls(before), [])
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Wechsel: Karte, Karte mit offener Zahlung, SEPA-Lastschrift (Rechtsrunde 28.09.2026, F23/F24)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Wechsel: Stripe-Aufruf mit Anker jetzt, Metadaten, Ereignis', async () => {
|
||
await resetHosting({ paymentMethod: CARD })
|
||
// Karte, Zahlung sofort erfolgreich: Stripe wendet die Aenderung an, die Wechselrechnung ist bezahlt
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice() }
|
||
const prorationDate = nowUnix()
|
||
const before = st.calls.length
|
||
let r
|
||
const logs = await withCapturedLogs(async () => {
|
||
r = await switchToWartung('c1', consent, prorationDate)
|
||
})
|
||
const call = st.calls.findLast((c) => c.path === '/v1/subscriptions/sub_h' && c.method === 'POST')
|
||
assert.equal(call.body['billing_cycle_anchor'], 'now')
|
||
assert.equal(call.body['metadata[productKey]'], 'wartung')
|
||
assert.equal(call.body['metadata[switchedFrom]'], 'hosting')
|
||
assert.equal((await listContractEvents('c1'))[0].type, 'wechsel')
|
||
assert.equal(r.paymentUrl, null)
|
||
|
||
// F23: Karte -> pending_if_incomplete; Preis der Abo-Position, Gutschrift ab dem Zeitpunkt der Vorschau
|
||
assert.equal(call.body['payment_behavior'], 'pending_if_incomplete')
|
||
assert.equal(call.body['proration_behavior'], 'create_prorations')
|
||
assert.equal(call.body['proration_date'], String(prorationDate))
|
||
assert.equal(call.body['items[0][id]'], 'si_sub_h_abo')
|
||
assert.equal(call.body['items[0][price]'], 'price_wartung')
|
||
assert.equal(call.body['expand[0]'], 'latest_invoice')
|
||
assert.equal(call.body['discounts[0][coupon]'], undefined)
|
||
assert.equal(call.body['discounts[0][discount]'], undefined)
|
||
// Metadaten: neue Mindestlaufzeit ab dem Wechseltag, Nachweis der Zustimmung
|
||
const switchedAt = call.body['metadata[switchedAt]']
|
||
assert.ok(Math.abs(new Date(switchedAt).getTime() - Date.now()) < 5000, 'Wechsel jetzt')
|
||
assert.equal(call.body['metadata[termStartAt]'], switchedAt)
|
||
assert.equal(call.body['metadata[termsVersion]'], consent.termsVersion)
|
||
assert.equal(call.body['metadata[termsAcceptedAt]'], consent.consentAt)
|
||
assert.equal(call.body['metadata[earlyStartConsentAt]'], consent.earlyStartConsentAt)
|
||
assert.equal(call.body['metadata[consentIp]'], '127.0.0.1')
|
||
assert.equal(call.body['metadata[consentUserAgent]'], 'test')
|
||
// F24: Zahlart aus der Standard-Zahlungsmethode (Abo, sonst Kunde)
|
||
const retrieve = st.calls.slice(before).find((c) => c.method === 'GET' && c.path === '/v1/subscriptions/sub_h')
|
||
const expand = Object.entries(retrieve.query).filter(([k]) => k.startsWith('expand')).map(([, v]) => v)
|
||
assert.ok(expand.includes('default_payment_method'))
|
||
assert.ok(expand.includes('customer.invoice_settings.default_payment_method'))
|
||
|
||
// Ereignis: bezahlt und wirksam -> erledigt; Nachweis und Angaben fuer ein spaeteres Zuruecksetzen (F27)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'erledigt')
|
||
assert.equal(ev.subscriptionId, 'sub_h')
|
||
assert.equal(ev.productKey, 'wartung')
|
||
assert.equal(ev.termsVersion, consent.termsVersion)
|
||
assert.equal(ev.consentAt, consent.consentAt)
|
||
assert.equal(ev.earlyStartConsentAt, consent.earlyStartConsentAt)
|
||
assert.equal(ev.consentIp, '127.0.0.1')
|
||
assert.equal(ev.consentUserAgent, 'test')
|
||
assert.equal(ev.$id.length, 36)
|
||
assert.equal(ev.details.from, 'hosting')
|
||
assert.equal(ev.details.amountDueCents, 4100)
|
||
assert.equal(ev.details.prorationDate, prorationDate)
|
||
assert.equal(ev.details.switchedAt, switchedAt)
|
||
assert.equal(ev.details.paymentMethod, 'card')
|
||
assert.equal(ev.details.invoiceId, 'in_wechsel')
|
||
assert.equal(ev.details.paymentUrl, null)
|
||
assert.equal(ev.details.effectiveAt, switchedAt)
|
||
// Mindestlaufzeit des Hosting-Abos vor dem Wechsel (ohne termStartAt: Abo-Start) und alte Metadaten
|
||
assert.equal(ev.details.previousTermStartAt, hostingDoc.startedAt)
|
||
// Fix 1 (7): auch die Zustimmungsdaten des Hosting-Abschlusses, damit eine gescheiterte Lastschrift sie wiederherstellt
|
||
assert.deepEqual(ev.details.previousMetadata, {
|
||
productKey: 'hosting', termStartAt: null, switchedAt: null, switchedFrom: null,
|
||
termsVersion: config.abo.termsVersion, termsAcceptedAt: consent.consentAt, earlyStartConsentAt: consent.consentAt,
|
||
consentIp: '127.0.0.1', consentUserAgent: 'test',
|
||
})
|
||
|
||
// Spiegel: Wartungs-Abo, Mindestlaufzeit ab dem Wechseltag
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.productKey, 'wartung')
|
||
assert.equal(doc.termStartAt, switchedAt)
|
||
assert.equal(r.subscription.productKey, 'wartung')
|
||
|
||
// K12 sofort (Vertragsbestaetigung mit PDF der Fassung 4), T12 sofort (Wechsel ist wirksam)
|
||
const [k12] = mailsWithSubject(K12_SUBJECT)
|
||
assert.ok(k12, 'K12 verschickt')
|
||
assert.deepEqual(recipients(k12), ['k@example.invalid'])
|
||
assert.deepEqual(k12.attachments.map((a) => [a.filename, a.contentType]), [['WEBklar-Abo-Vertragsunterlagen.pdf', 'application/pdf']])
|
||
assert.ok(k12.attachments[0].content.length > 1000, 'PDF-Inhalt angehaengt')
|
||
assert.ok(k12.text.includes('Guten Tag Kunde Eins,'))
|
||
assert.ok(k12.text.includes('41,00 €'), k12.text)
|
||
assert.ok(k12.text.includes('50,00 €'))
|
||
assert.ok(k12.text.includes(`Mindestlaufzeit 12 Monate bis ${addMonths(new Date(switchedAt), 12).toLocaleDateString('de-DE', { timeZone: 'Europe/Berlin', day: '2-digit', month: '2-digit', year: 'numeric' })}.`))
|
||
assert.ok(k12.text.includes(`(Version ${consent.termsVersion})`))
|
||
assert.ok(!k12.text.includes(ZAHLUNG_OFFEN), 'kein Block zahlung_offen')
|
||
assert.ok(!k12.text.includes(LASTSCHRIFT), 'kein Block lastschrift')
|
||
const [t12] = mailsWithSubject(t12Subject('k@example.invalid'))
|
||
assert.ok(t12, 'T12 verschickt')
|
||
assert.ok(t12.text.includes(WIRKSAM))
|
||
assert.ok(t12.text.includes('sub_h'))
|
||
assert.ok(t12.text.includes('Weitere Postfächer erst einrichten, wenn die Wechselrechnung bezahlt ist'), t12.text)
|
||
assert.equal(mails.sent.length, 2)
|
||
// Alle Platzhalter und Bloecke passen zu den Vorlagen
|
||
assert.deepEqual(logs.warn.filter((w) => /Vorlage (K12|T12)/.test(w)), [])
|
||
})
|
||
|
||
// Task 12 (Spec 3.5): {{monatspreis}} in K12 und T12 ist die Monatsgebühr des Wartungs-Abos mit gebuchtem
|
||
// Zusatzspeicher; K12 sagt es im Block zusatzspeicher. Auch nach einem gescheiterten Wechsel (T12 aus dem Ereignis)
|
||
test('K12/T12: Monatspreis mit gebuchtem Zusatzspeicher, auch im Hinweis zum gescheiterten Wechsel', async () => {
|
||
await resetHosting({ stripe: { storageUnits: 2 } })
|
||
st.nextSubscriptionUpdate = { pending_update: pendingUpdate(), latest_invoice: switchInvoice({ id: 'in_speicher', status: 'open', amount_due: 4300, hosted_invoice_url: 'https://pay.example/inv2' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
const [k12] = mailsWithSubject(K12_SUBJECT)
|
||
assert.ok(k12.text.includes('52,00 € / Monat'), k12.text)
|
||
assert.ok(k12.text.includes('einschließlich Ihres gebuchten E-Mail-Zusatzspeichers'), k12.text)
|
||
assert.ok(k12.text.includes('43,00 €'))
|
||
assert.deepEqual(mailsWithSubject(t12Subject('k@example.invalid')), [])
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.details.monthlyCents, 5200)
|
||
await markSwitchFailed(ev.$id, SWITCH_FAILED_REASONS.abgelaufen)
|
||
const [t12] = mailsWithSubject(t12Subject('k@example.invalid'))
|
||
assert.ok(t12.text.includes('52,00 €'), t12.text)
|
||
assert.ok(t12.text.includes('43,00 €'))
|
||
// Ohne Zusatzspeicher: 50,00 € und kein Block
|
||
await resetHosting()
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice() }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
const [plain] = mailsWithSubject(K12_SUBJECT)
|
||
assert.ok(plain.text.includes('50,00 € / Monat'), plain.text)
|
||
assert.ok(!plain.text.includes('einschließlich Ihres gebuchten'))
|
||
})
|
||
|
||
test('Offene Rechnung liefert paymentUrl', async () => {
|
||
await resetHosting({ id: 'sub_h2', customerId: 'c2', mirror: hosting2Doc })
|
||
// Karte, Zahlung nicht sofort erfolgreich (3-D Secure): Stripe haelt die Aenderung in pending_update zurueck
|
||
st.nextSubscriptionUpdate = { pending_update: pendingUpdate(), latest_invoice: switchInvoice({ id: 'in_offen', status: 'open', hosted_invoice_url: 'https://pay.example/inv' }) }
|
||
const r = await switchToWartung('c2', consent, Math.floor(Date.now() / 1000))
|
||
assert.equal(r.paymentUrl, 'https://pay.example/inv')
|
||
assert.equal((await listContractEvents('c2'))[0].type, 'wechsel')
|
||
|
||
const call = updateCalls('sub_h2').at(-1)
|
||
assert.equal(call.body['payment_behavior'], 'pending_if_incomplete')
|
||
const [ev] = await listContractEvents('c2')
|
||
assert.equal(ev.status, 'offen')
|
||
assert.equal(ev.details.paymentUrl, 'https://pay.example/inv')
|
||
assert.equal(ev.details.effectiveAt, null)
|
||
// Metadaten und Spiegel aendern sich noch nicht
|
||
assert.equal(aw.docs('subscriptions').get('sub_h2').productKey, 'hosting')
|
||
assert.equal(aw.docs('subscriptions').get('sub_h2').termStartAt, hosting2Doc.termStartAt)
|
||
assert.equal(st.subscriptions.get('sub_h2').metadata.productKey, 'hosting')
|
||
assert.equal(st.subscriptions.get('sub_h2').metadata.switchedAt, undefined)
|
||
// K12 sofort, mit Block zahlung_offen; T12 erst, wenn der Wechsel wirksam ist
|
||
const [k12] = mailsWithSubject(K12_SUBJECT)
|
||
assert.deepEqual(recipients(k12), ['k2@example.invalid'])
|
||
assert.ok(k12.text.includes(ZAHLUNG_OFFEN), k12.text)
|
||
assert.ok(!k12.text.includes(LASTSCHRIFT))
|
||
assert.deepEqual(mailsWithSubject(t12Subject('k2@example.invalid')), [])
|
||
// Portal: Wechsel wartet auf die Zahlung, Link zur Zahlungsseite (F12)
|
||
const view = await get('/api/abo', { cookie: customerCookie('c2') })
|
||
assert.deepEqual(view.subscription.switchPending, { since: consent.consentAt, paymentUrl: 'https://pay.example/inv' })
|
||
assert.equal(view.subscription.canSwitch, false)
|
||
assert.equal(view.subscription.productKey, 'hosting')
|
||
// Ein zweiter Wechsel, waehrend einer auf die Zahlung wartet
|
||
await assert.rejects(switchToWartung('c2', consent, nowUnix()), (e) => e.status === 409 && e.message === 'Ein Wechsel wartet noch auf die Zahlung.')
|
||
await clearEvents('c2')
|
||
})
|
||
|
||
test('SEPA-Lastschrift: allow_incomplete, sofort wirksam, offen bis zur Zahlung, K12 mit Block lastschrift, T12 sofort', async () => {
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
// SEPA: Stripe wendet die Aenderung sofort an, die Lastschrift ist noch nicht eingeloest
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ status: 'open' }) }
|
||
const r = await switchToWartung('c1', consent, nowUnix())
|
||
const call = updateCalls('sub_h').at(-1)
|
||
assert.equal(call.body['payment_behavior'], 'allow_incomplete')
|
||
assert.equal(r.paymentUrl, null, 'keine Weiterleitung bei SEPA')
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'offen')
|
||
assert.equal(ev.details.paymentMethod, 'sepa_debit')
|
||
assert.equal(ev.details.paymentUrl, null)
|
||
assert.equal(ev.details.effectiveAt, ev.details.switchedAt)
|
||
// Wechsel gilt sofort: Stripe und Spiegel sind Wartung
|
||
assert.equal(st.subscriptions.get('sub_h').metadata.productKey, 'wartung')
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').productKey, 'wartung')
|
||
const [k12] = mailsWithSubject(K12_SUBJECT)
|
||
assert.ok(k12.text.includes(LASTSCHRIFT), k12.text)
|
||
assert.ok(k12.text.includes('Ihr Abbuchungstag bleibt der Wechseltag'))
|
||
assert.ok(!k12.text.includes(ZAHLUNG_OFFEN))
|
||
const [t12] = mailsWithSubject(t12Subject('k@example.invalid'))
|
||
assert.ok(t12.text.includes(WIRKSAM))
|
||
assert.ok(t12.text.includes('SEPA-Lastschrift'))
|
||
// Portal: Zahlung offen (ohne Link), keine Speicheraenderung bis zur Zahlung
|
||
const view = await get('/api/abo', { cookie: customerCookie() })
|
||
assert.deepEqual(view.subscription.switchPending, { since: consent.consentAt, paymentUrl: null })
|
||
assert.equal(view.subscription.canChangeStorage, false)
|
||
assert.equal(view.subscription.productKey, 'wartung')
|
||
})
|
||
|
||
test('Zahlart: Standard-Zahlungsmethode des Abos, sonst des Kunden; unbekannt oder keine → Karte', async () => {
|
||
assert.equal(paymentMethodTypeOf({ default_payment_method: SEPA }), 'sepa_debit')
|
||
assert.equal(paymentMethodTypeOf({ default_payment_method: CARD, customer: { invoice_settings: { default_payment_method: SEPA } } }), 'card')
|
||
assert.equal(paymentMethodTypeOf({ default_payment_method: null, customer: { id: 'cus_1', invoice_settings: { default_payment_method: SEPA } } }), 'sepa_debit')
|
||
assert.equal(paymentMethodTypeOf({ default_payment_method: 'pm_nicht_erweitert', customer: 'cus_1' }), null)
|
||
assert.equal(paymentMethodTypeOf({}), null)
|
||
|
||
// Kunde mit SEPA als Standard, Abo ohne eigene Zahlungsmethode -> allow_incomplete
|
||
await resetHosting({
|
||
paymentMethod: null,
|
||
stripe: { customer: { id: 'cus_c1', object: 'customer', email: 'k@example.invalid', invoice_settings: { default_payment_method: SEPA } } },
|
||
})
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ status: 'open' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
assert.equal(updateCalls('sub_h').at(-1).body['payment_behavior'], 'allow_incomplete')
|
||
// Keine Zahlungsmethode bekannt -> Weg fuer Karten (Stripe haelt die Aenderung bis zur Zahlung zurueck)
|
||
await resetHosting({ paymentMethod: null })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice() }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
assert.equal(updateCalls('sub_h').at(-1).body['payment_behavior'], 'pending_if_incomplete')
|
||
assert.equal((await listContractEvents('c1'))[0].details.paymentMethod, null)
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Voraussetzungen und Frische der Vorschau
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Gekündigt, Wartung, trialing, past_due: 409', async () => {
|
||
await resetHosting()
|
||
const before = st.calls.length
|
||
for (const patch of [{ cancelAtPeriodEnd: true }, { productKey: 'wartung' }, { status: 'trialing' }, { status: 'past_due' }]) {
|
||
aw.seed('subscriptions', { ...hostingDoc, ...patch })
|
||
await assert.rejects(switchToWartung('c1', consent, Math.floor(Date.now() / 1000)), (e) => e.status === 409, JSON.stringify(patch))
|
||
}
|
||
// Kuendigung nur per cancelAt zaehlt ebenso
|
||
aw.seed('subscriptions', { ...hostingDoc, cancelAt: '2027-10-05T10:00:00.000Z' })
|
||
await assert.rejects(switchToWartung('c1', consent, nowUnix()), (e) => e.status === 409)
|
||
assert.deepEqual(updateCalls('sub_h', before), [], 'keine Aenderung bei Stripe')
|
||
aw.seed('subscriptions', hostingDoc)
|
||
})
|
||
|
||
test('Alte Vorschau (> 30 min): 409', async () => {
|
||
await resetHosting()
|
||
const before = st.calls.length
|
||
await assert.rejects(switchToWartung('c1', consent, Math.floor(Date.now() / 1000) - 31 * 60), (e) => e.status === 409 && /Bitte Seite neu laden/.test(e.message))
|
||
assert.equal(st.calls.length, before, 'kein Stripe-Aufruf')
|
||
})
|
||
|
||
test('Frische der Vorschau: 30 Minuten, derselbe Kalendertag in Deutschland, nicht aus der Zukunft', () => {
|
||
const at = (iso) => new Date(iso).getTime()
|
||
assert.equal(previewProblem(unix('2026-10-01T10:00:00Z'), at('2026-10-01T10:29:00Z')), null)
|
||
assert.equal(previewProblem(unix('2026-10-01T10:00:00Z'), at('2026-10-01T10:31:00Z'))?.status, 409)
|
||
// 23:55 und 00:05 Uhr in Deutschland (Sommerzeit): der angezeigte Wechseltag stimmt nicht mehr
|
||
const midnight = previewProblem(unix('2026-10-01T21:55:00Z'), at('2026-10-01T22:05:00Z'))
|
||
assert.equal(midnight?.status, 409)
|
||
assert.match(midnight.message, /Datumswechsel/)
|
||
// Aus der Zukunft (mehr als 5 Minuten) oder keine ganze Zahl: 400
|
||
assert.equal(previewProblem(unix('2026-10-01T10:10:00Z'), at('2026-10-01T10:00:00Z'))?.status, 400)
|
||
assert.equal(previewProblem(unix('2026-10-01T10:02:00Z'), at('2026-10-01T10:00:00Z')), null, 'kleine Uhrabweichung erlaubt')
|
||
for (const bad of ['1790000000', 1.5, null, undefined, 0, -5]) assert.equal(previewProblem(bad, at('2026-10-01T10:00:00Z'))?.status, 400, String(bad))
|
||
})
|
||
|
||
test('Abrechnungsmonat hat seit der Vorschau neu begonnen: 409', async () => {
|
||
await resetHosting()
|
||
st.subscriptions.get('sub_h').items.data[0].current_period_start = nowUnix()
|
||
const before = st.calls.length
|
||
await assert.rejects(switchToWartung('c1', consent, nowUnix() - 60), (e) => e.status === 409 && /Bitte Seite neu laden/.test(e.message))
|
||
assert.deepEqual(updateCalls('sub_h', before), [])
|
||
})
|
||
|
||
test('Ein zweiter Wechsel, während einer auf die Zahlung wartet: 409', async () => {
|
||
await resetHosting()
|
||
await recordContractEvent({
|
||
customerId: 'c1', subscriptionId: 'sub_h', type: 'wechsel', productKey: 'wartung',
|
||
details: { from: 'hosting', paymentUrl: 'https://pay.example/alt' }, consent, status: 'offen',
|
||
})
|
||
const before = st.calls.length
|
||
await assert.rejects(switchToWartung('c1', consent, nowUnix()), (e) => e.status === 409 && e.message === 'Ein Wechsel wartet noch auf die Zahlung.')
|
||
await assert.rejects(previewSwitch('c1'), (e) => e.status === 409)
|
||
assert.equal(st.calls.length, before)
|
||
await clearEvents('c1')
|
||
})
|
||
|
||
test('Stripe ist die Wahrheit: schon Wartung oder ausstehende Änderung bei Stripe → 409 ohne Änderung', async () => {
|
||
// Spiegel veraltet (Webhook noch nicht da), Stripe hat schon den Wartungs-Preis
|
||
await resetHosting()
|
||
st.subscriptions.set('sub_h', stripeSubscription({ id: 'sub_h', customerId: 'c1', productKey: 'wartung', default_payment_method: CARD }))
|
||
const before = st.calls.length
|
||
await assert.rejects(switchToWartung('c1', consent, nowUnix()), (e) => e.status === 409)
|
||
// Stripe haelt noch eine Aenderung zurueck (Ereignis fehlt im Portal)
|
||
await resetHosting({ stripe: { pending_update: pendingUpdate() } })
|
||
await assert.rejects(switchToWartung('c1', consent, nowUnix()), (e) => e.status === 409 && /wartet noch auf die Zahlung/.test(e.message))
|
||
await assert.rejects(previewSwitch('c1'), (e) => e.status === 409)
|
||
assert.deepEqual(updateCalls('sub_h', before), [])
|
||
})
|
||
|
||
test('Ohne Zustimmung zu Bedingungen oder Sofortbeginn kein Wechsel (400)', async () => {
|
||
await resetHosting()
|
||
const before = st.calls.length
|
||
const { earlyStartConsentAt: _drop, ...withoutEarlyStart } = consent
|
||
await assert.rejects(switchToWartung('c1', withoutEarlyStart, nowUnix()), (e) => e.status === 400)
|
||
await assert.rejects(switchToWartung('c1', { ...consent, termsVersion: '' }, nowUnix()), (e) => e.status === 400)
|
||
await assert.rejects(switchToWartung('c1', null, nowUnix()), (e) => e.status === 400)
|
||
assert.equal(st.calls.length, before)
|
||
})
|
||
|
||
test('Testkonto: Testrabatt Hosting fällt weg, Testrabatt Wartung kommt dazu, andere Rabatte bleiben', async () => {
|
||
const subId = 'sub_t'
|
||
await clearEvents('c4')
|
||
aw.seed('subscriptions', subscriptionDoc(subId, { ...hostingDoc, customerId: 'c4', email: 'test@example.invalid', stripeCustomerId: 'cus_c4' }))
|
||
st.subscriptions.set(
|
||
subId,
|
||
stripeSubscription({
|
||
id: subId,
|
||
customerId: 'c4',
|
||
productKey: 'hosting',
|
||
default_payment_method: CARD,
|
||
// expand: ['discounts'] -> Rabatt-Objekte (API 2025-10-29.clover: discount.source.coupon)
|
||
discounts: [
|
||
{ id: 'di_test_hosting', object: 'discount', source: { type: 'coupon', coupon: 'WEBKLAR-TEST-050-HOSTING' } },
|
||
{ id: 'di_angebot', object: 'discount', source: { type: 'coupon', coupon: { id: 'WEBKLAR-ANGEBOT-X', object: 'coupon' } } },
|
||
],
|
||
})
|
||
)
|
||
st.invoicePreview = previewInvoice(line('price_hosting', -30, { proration: true, periodStart: nowUnix(), subscription: subId }), line('price_wartung', 50, { subscription: subId }))
|
||
try {
|
||
const before = st.calls.length
|
||
const p = await previewSwitch('c4')
|
||
const [previewCall] = previewCalls(before)
|
||
assert.equal(previewCall.body['discounts[0][discount]'], 'di_angebot')
|
||
assert.equal(previewCall.body['discounts[1][coupon]'], 'WEBKLAR-TEST-050')
|
||
assert.equal(previewCall.body['discounts[2][coupon]'], undefined)
|
||
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ id: 'in_test', amount_due: 20 }) }
|
||
await switchToWartung('c4', consent, p.prorationDate)
|
||
const call = updateCalls(subId).at(-1)
|
||
assert.equal(call.body['discounts[0][discount]'], 'di_angebot')
|
||
assert.equal(call.body['discounts[1][coupon]'], 'WEBKLAR-TEST-050')
|
||
assert.equal(call.body['discounts[2][coupon]'], undefined)
|
||
assert.equal(call.body['discounts[2][discount]'], undefined)
|
||
assert.ok(!Object.values(call.body).includes('di_test_hosting'), 'Testrabatt Hosting faellt weg')
|
||
// Der Wartungs-Testrabatt existiert (angelegt, falls er fehlte)
|
||
assert.equal(st.coupons.get('WEBKLAR-TEST-050').amount_off, 4950)
|
||
} finally {
|
||
await clearEvents('c4')
|
||
await deleteDocument(config.collections.subscriptions, subId).catch(() => {})
|
||
}
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Fehler beim Nachweis und beim Mailversand
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Mailfehler brechen den Wechsel nicht ab (nur im Log)', async () => {
|
||
await resetHosting()
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice() }
|
||
setMailTransportForTests({ sendMail: async () => { throw new Error('SMTP gestört') } })
|
||
try {
|
||
let r
|
||
const logs = await withCapturedLogs(async () => {
|
||
r = await switchToWartung('c1', consent, nowUnix())
|
||
})
|
||
assert.equal(r.subscription.productKey, 'wartung')
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'erledigt')
|
||
assert.ok(logs.error.some((e) => e.includes('K12') && e.includes('SMTP gestört')), logs.error.join('\n'))
|
||
assert.ok(logs.error.some((e) => e.includes('Admin-Hinweis fehlgeschlagen')))
|
||
} finally {
|
||
setMailTransportForTests(mails)
|
||
}
|
||
})
|
||
|
||
test('Nachweis nicht speicherbar: Wechsel läuft, T12 meldet es sofort (auch bei offener Zahlung)', async () => {
|
||
await resetHosting()
|
||
st.nextSubscriptionUpdate = { pending_update: pendingUpdate(), latest_invoice: switchInvoice({ status: 'open', hosted_invoice_url: 'https://pay.example/x' }) }
|
||
aw.failNext({ collection: config.collections.contractEvents, method: 'POST', status: 500 })
|
||
let r
|
||
const logs = await withCapturedLogs(async () => {
|
||
r = await switchToWartung('c1', consent, nowUnix())
|
||
})
|
||
assert.equal(r.paymentUrl, 'https://pay.example/x')
|
||
assert.deepEqual(await listContractEvents('c1'), [])
|
||
assert.ok(logs.error.some((e) => e.includes('Ereignis') && e.includes('sub_h')), logs.error.join('\n'))
|
||
const [t12] = mailsWithSubject(t12Subject('k@example.invalid'))
|
||
assert.ok(t12, 'T12 geht sofort raus, damit das Team den Wechsel von Hand verfolgt')
|
||
assert.ok(t12.text.includes('Nachweis nicht gespeichert'))
|
||
assert.ok(!t12.text.includes(WIRKSAM), 'Zahlung noch offen: nicht wirksam')
|
||
assert.ok(mailsWithSubject(K12_SUBJECT)[0].text.includes(ZAHLUNG_OFFEN))
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Routen
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Route: ohne earlyStart 400', async () => {
|
||
const res = await post('/api/abo/switch', { acceptTerms: true, termsVersion: config.abo.termsVersion, prorationDate: 1 }, { cookie: customerCookie() })
|
||
assert.equal(res.status, 400)
|
||
})
|
||
|
||
test('Routen: fehlende Angaben 400, alte Fassung 409, ohne Session 401, „Als Kunde ansehen“ 403, ohne Stripe-Aufruf', async () => {
|
||
await resetHosting()
|
||
const cookie = customerCookie()
|
||
const body = { acceptTerms: true, earlyStart: true, termsVersion: config.abo.termsVersion, prorationDate: nowUnix(), amountDueCents: 4100 }
|
||
const before = st.calls.length
|
||
for (const missing of ['acceptTerms', 'earlyStart', 'termsVersion', 'prorationDate', 'amountDueCents']) {
|
||
const { [missing]: _drop, ...rest } = body
|
||
assert.equal((await post('/api/abo/switch', rest, { cookie })).status, 400, missing)
|
||
}
|
||
assert.equal((await post('/api/abo/switch', { ...body, earlyStart: 'ja' }, { cookie })).status, 400)
|
||
assert.equal((await post('/api/abo/switch', { ...body, prorationDate: String(body.prorationDate) }, { cookie })).status, 400)
|
||
assert.equal((await post('/api/abo/switch', { ...body, amountDueCents: '4100' }, { cookie })).status, 400)
|
||
const stale = await post('/api/abo/switch', { ...body, termsVersion: '2026-09-25-v3' }, { cookie })
|
||
assert.equal(stale.status, 409)
|
||
assert.match(stale.body.error, /Bedingungen/)
|
||
assert.equal((await post('/api/abo/switch', body)).status, 401)
|
||
assert.equal((await post('/api/abo/switch/preview', {})).status, 401)
|
||
assert.equal((await post('/api/abo/switch', body, { cookie: viewAsCookie() })).status, 403)
|
||
assert.equal((await post('/api/abo/switch/preview', {}, { cookie: viewAsCookie() })).status, 403)
|
||
assert.equal(st.calls.length, before)
|
||
})
|
||
|
||
test('Route Vorschau: Beträge; Wartungs-Abo 409', async () => {
|
||
await resetHosting()
|
||
st.invoicePreview = previewInvoice(line('price_hosting', -900, { proration: true, periodStart: nowUnix() }), line('price_wartung', 5000))
|
||
const res = await post('/api/abo/switch/preview', {}, { cookie: customerCookie() })
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
assert.equal(res.body.creditCents, 900)
|
||
assert.equal(res.body.amountDueCents, 4100)
|
||
assert.equal(res.body.monthlyCents, 5000)
|
||
assert.ok(Number.isInteger(res.body.prorationDate))
|
||
assert.ok(res.body.nextChargeAt && res.body.minTermEnd)
|
||
await resetHosting({ patch: { productKey: 'wartung' } })
|
||
const wartung = await post('/api/abo/switch/preview', {}, { cookie: customerCookie() })
|
||
assert.equal(wartung.status, 409)
|
||
assert.ok(wartung.body.error)
|
||
aw.seed('subscriptions', hostingDoc)
|
||
})
|
||
|
||
test('Route Wechsel: Antwort mit Abo-Ansicht und paymentUrl, Zustimmung aus der Anfrage', async () => {
|
||
await resetHosting()
|
||
// Fix 1 (8): der Server rechnet die Vorschau nach; hier dieselben 41,00 € wie in der Bestelluebersicht
|
||
st.invoicePreview = previewInvoice(line('price_hosting', -900, { proration: true, periodStart: nowUnix() }), line('price_wartung', 5000))
|
||
st.nextSubscriptionUpdate = { pending_update: pendingUpdate(), latest_invoice: switchInvoice({ status: 'open', hosted_invoice_url: 'https://pay.example/route' }) }
|
||
const res = await post(
|
||
'/api/abo/switch',
|
||
{ acceptTerms: true, earlyStart: true, termsVersion: config.abo.termsVersion, prorationDate: nowUnix(), amountDueCents: 4100 },
|
||
{ cookie: customerCookie(), headers: { 'user-agent': 'Testbrowser/1.0' } }
|
||
)
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
assert.equal(res.body.paymentUrl, 'https://pay.example/route')
|
||
assert.equal(res.body.subscription.productKey, 'hosting')
|
||
assert.equal(res.body.subscription.canSwitch, false)
|
||
assert.equal(res.body.subscription.switchPending.paymentUrl, 'https://pay.example/route')
|
||
// F16: Zustimmung zum Sofortbeginn aus earlyStart, Nachweis mit Fassung, Zeitpunkt, IP, Browser
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.termsVersion, config.abo.termsVersion)
|
||
assert.ok(ev.consentAt)
|
||
assert.equal(ev.earlyStartConsentAt, ev.consentAt)
|
||
assert.equal(ev.consentIp, '127.0.0.1')
|
||
assert.equal(ev.consentUserAgent, 'Testbrowser/1.0')
|
||
|
||
// Karte, sofort bezahlt: Antwort zeigt das Wartungs-Abo mit Widerrufsfrist fuer den Wechsel
|
||
await resetHosting()
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice() }
|
||
const done = await post('/api/abo/switch', { acceptTerms: true, earlyStart: true, termsVersion: config.abo.termsVersion, prorationDate: nowUnix(), amountDueCents: 4100 }, { cookie: customerCookie() })
|
||
assert.equal(done.status, 200, JSON.stringify(done.body))
|
||
assert.equal(done.body.paymentUrl, null)
|
||
assert.equal(done.body.subscription.productKey, 'wartung')
|
||
assert.equal(done.body.subscription.switchPending, null)
|
||
assert.deepEqual(done.body.subscription.withdrawals.map((w) => w.type), ['wechsel'])
|
||
// Wechsel geht nur einmal: jetzt Wartung -> 409
|
||
const again = await post('/api/abo/switch', { acceptTerms: true, earlyStart: true, termsVersion: config.abo.termsVersion, prorationDate: nowUnix(), amountDueCents: 4100 }, { cookie: customerCookie() })
|
||
assert.equal(again.status, 409)
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Webhooks (F23, F26, F27)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
async function pendingCardSwitch(invoiceId = 'in_karte') {
|
||
await resetHosting({ paymentMethod: CARD })
|
||
st.nextSubscriptionUpdate = { pending_update: pendingUpdate(), latest_invoice: switchInvoice({ id: invoiceId, status: 'open', hosted_invoice_url: 'https://pay.example/karte' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').productKey, 'hosting')
|
||
mails.sent.length = 0
|
||
}
|
||
|
||
test('Webhook pending_update_applied: Ereignis erledigt, Spiegel Wartung, T12; Wiederholung ohne zweite Mail', async () => {
|
||
await pendingCardSwitch()
|
||
// Zahlung auf der Stripe-Seite: Stripe uebernimmt Preis, Anker und Metadaten
|
||
st.applyPendingUpdate('sub_h')
|
||
const event = webhookEvent('customer.subscription.pending_update_applied', { id: 'sub_h', object: 'subscription' })
|
||
const res = await postWebhook(event)
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'erledigt')
|
||
assert.equal(ev.doneBy, 'stripe')
|
||
assert.ok(ev.details.effectiveAt)
|
||
assert.ok(ev.details.paidAt)
|
||
assert.equal(ev.details.paymentUrl, 'https://pay.example/karte', 'details bleiben erhalten')
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.productKey, 'wartung')
|
||
assert.equal(doc.termStartAt, ev.details.switchedAt)
|
||
assert.equal(mailsWithSubject(t12Subject('k@example.invalid')).length, 1)
|
||
assert.ok(mailsWithSubject(t12Subject('k@example.invalid'))[0].text.includes(WIRKSAM))
|
||
assert.deepEqual(mailsWithSubject(K12_SUBJECT), [], 'K12 ging schon beim Klick raus')
|
||
// Wiederholung durch Stripe: nichts mehr offen, keine zweite Mail
|
||
assert.equal((await postWebhook(event)).status, 200)
|
||
assert.equal(mails.sent.length, 1)
|
||
const view = await get('/api/abo', { cookie: customerCookie() })
|
||
assert.equal(view.subscription.switchPending, null)
|
||
assert.equal(view.subscription.productKey, 'wartung')
|
||
})
|
||
|
||
test('Webhook pending_update_expired: Ereignis gescheitert, K14 an den Kunden, T12 gescheitert; Hosting bleibt', async () => {
|
||
await pendingCardSwitch()
|
||
st.expirePendingUpdate('sub_h')
|
||
const event = webhookEvent('customer.subscription.pending_update_expired', { id: 'sub_h', object: 'subscription' })
|
||
const res = await postWebhook(event)
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'gescheitert')
|
||
assert.equal(ev.doneBy, 'stripe')
|
||
assert.equal(ev.details.grund, SWITCH_FAILED_REASONS.abgelaufen)
|
||
assert.ok(ev.details.failedAt)
|
||
const [k14] = mailsWithSubject(K14_SUBJECT)
|
||
assert.ok(k14, 'K14 verschickt')
|
||
assert.deepEqual(recipients(k14), ['k@example.invalid'])
|
||
assert.ok(k14.text.includes(HOSTING_LAEUFT_WEITER), k14.text)
|
||
assert.ok(k14.text.includes(SWITCH_FAILED_REASONS.abgelaufen))
|
||
assert.ok(!k14.text.includes('Abbuchungstag'), 'Karte: der alte Abbuchungstag bleibt, kein Hinweis darauf')
|
||
assert.ok(!/23 Stunden/.test(k14.text))
|
||
const [t12] = mailsWithSubject(t12Subject('k@example.invalid'))
|
||
assert.ok(t12.text.includes('nicht zustande gekommen'), t12.text)
|
||
assert.ok(!t12.text.includes(WIRKSAM))
|
||
// Hosting-Abo laeuft weiter, der Wechsel kann neu bestellt werden; keine Widerrufsfrist fuer den gescheiterten Wechsel
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').productKey, 'hosting')
|
||
const view = await get('/api/abo', { cookie: customerCookie() })
|
||
assert.equal(view.subscription.switchPending, null)
|
||
assert.equal(view.subscription.canSwitch, true)
|
||
assert.ok(!view.subscription.withdrawals.some((w) => w.type === 'wechsel'))
|
||
// Wiederholung: keine zweite K14
|
||
mails.sent.length = 0
|
||
assert.equal((await postWebhook(event)).status, 200)
|
||
assert.deepEqual(mails.sent, [])
|
||
})
|
||
|
||
test('Webhook invoice.paid (SEPA): Ereignis erledigt, Stunde gutgeschrieben, kein zweites T12', async () => {
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ id: 'in_sepa', status: 'open' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
st.invoices.set('in_sepa', paidInvoice('in_sepa'))
|
||
mails.sent.length = 0
|
||
try {
|
||
const event = webhookEvent('invoice.paid', { id: 'in_sepa', object: 'invoice', billing_reason: 'subscription_update', parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_h' } } })
|
||
const res = await postWebhook(event)
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'erledigt')
|
||
assert.equal(ev.doneBy, 'stripe')
|
||
assert.ok(ev.details.paidAt)
|
||
assert.equal(ev.details.effectiveAt, ev.details.switchedAt, 'wirksam seit dem Klick')
|
||
// Erste Stunde mit der bezahlten Wechselrechnung (Spec 3.5)
|
||
assert.equal(aw.docs('hourCredits').get('in_sepa').minutes, 60)
|
||
assert.deepEqual(mailsWithSubject(t12Subject('k@example.invalid')), [], 'T12 ging bei SEPA schon beim Klick raus')
|
||
// Idempotent
|
||
assert.equal((await postWebhook(event)).status, 200)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'erledigt')
|
||
const view = await get('/api/abo', { cookie: customerCookie() })
|
||
assert.equal(view.subscription.switchPending, null)
|
||
assert.equal(view.subscription.canChangeStorage, true)
|
||
} finally {
|
||
await deleteDocument(config.collections.hourCredits, 'in_sepa').catch(() => {})
|
||
}
|
||
})
|
||
|
||
test('Webhook invoice.paid vor pending_update_applied (Karte): erledigt und T12 genau einmal', async () => {
|
||
await pendingCardSwitch('in_karte_zuerst')
|
||
st.applyPendingUpdate('sub_h')
|
||
st.invoices.set('in_karte_zuerst', paidInvoice('in_karte_zuerst'))
|
||
try {
|
||
const paid = webhookEvent('invoice.paid', { id: 'in_karte_zuerst', object: 'invoice', billing_reason: 'subscription_update', parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_h' } } })
|
||
assert.equal((await postWebhook(paid)).status, 200)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'erledigt')
|
||
assert.ok(ev.details.effectiveAt)
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').productKey, 'wartung')
|
||
assert.equal(mailsWithSubject(t12Subject('k@example.invalid')).length, 1)
|
||
const applied = webhookEvent('customer.subscription.pending_update_applied', { id: 'sub_h', object: 'subscription' })
|
||
assert.equal((await postWebhook(applied)).status, 200)
|
||
assert.equal(mailsWithSubject(t12Subject('k@example.invalid')).length, 1, 'kein zweites T12')
|
||
} finally {
|
||
await deleteDocument(config.collections.hourCredits, 'in_karte_zuerst').catch(() => {})
|
||
}
|
||
})
|
||
|
||
test('Webhook invoice.paid, solange Stripe die Änderung noch zurückhält: Ereignis bleibt offen', async () => {
|
||
await pendingCardSwitch('in_noch_offen')
|
||
// Stripe hat die ausstehende Aenderung noch nicht uebernommen: der Nachbau zeigt pending_update am Abo (Fix 1, 6)
|
||
assert.ok(st.subscriptions.get('sub_h').pending_update)
|
||
st.invoices.set('in_noch_offen', paidInvoice('in_noch_offen'))
|
||
try {
|
||
const paid = webhookEvent('invoice.paid', { id: 'in_noch_offen', object: 'invoice', billing_reason: 'subscription_update', parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_h' } } })
|
||
assert.equal((await postWebhook(paid)).status, 200)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'offen')
|
||
assert.deepEqual(mailsWithSubject(t12Subject('k@example.invalid')), [])
|
||
} finally {
|
||
await deleteDocument(config.collections.hourCredits, 'in_noch_offen').catch(() => {})
|
||
}
|
||
})
|
||
|
||
test('Webhook invoice.payment_failed: SEPA-Wechselrechnung → T12 mit Handgriffen; Karte ohne T12', async () => {
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ id: 'in_sepa_f', status: 'open' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
mails.sent.length = 0
|
||
const failed = webhookEvent('invoice.payment_failed', {
|
||
id: 'in_sepa_f', object: 'invoice', number: 'WK-10', billing_reason: 'subscription_update', amount_due: 4100, customer_email: 'k@example.invalid',
|
||
parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_h' } },
|
||
})
|
||
const res = await postWebhook(failed)
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
const [t12] = mailsWithSubject(t12Subject('k@example.invalid'))
|
||
assert.ok(t12, 'T12 mit Handgriffen')
|
||
for (const text of ['SEPA-Lastschrift für die Wechselrechnung ist gescheitert', 'stornieren', 'ohne anteilige Verrechnung', 'Der Abbuchungstag bleibt der Wechseltag', 'termStartAt, switchedAt, switchedFrom und die Zustimmungsdaten', 'node scripts/wechsel-gescheitert.mjs sub_h --ausfuehren', '41,00 €']) {
|
||
assert.ok(t12.text.includes(text), `${text}\n---\n${t12.text}`)
|
||
}
|
||
assert.ok(!t12.text.includes(WIRKSAM))
|
||
assert.equal(mails.sent.length, 2, 'dazu T04 wie bei jeder fehlgeschlagenen Zahlung')
|
||
// Das Ereignis schliesst das Team (Skript), nicht der Webhook
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'offen')
|
||
|
||
// Karte mit offener Zahlung: Stripe hat nichts uebernommen, kein switchedAt -> nur T04
|
||
await pendingCardSwitch('in_karte_f')
|
||
const cardFailed = webhookEvent('invoice.payment_failed', {
|
||
id: 'in_karte_f', object: 'invoice', billing_reason: 'subscription_update', amount_due: 4100,
|
||
parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_h' } },
|
||
})
|
||
assert.equal((await postWebhook(cardFailed)).status, 200)
|
||
assert.deepEqual(mailsWithSubject(t12Subject('k@example.invalid')), [])
|
||
assert.equal(mails.sent.length, 1)
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// markSwitchFailed (F27) und das Skript fuers Team (SEPA)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('markSwitchFailed: gescheitert, K14 (SEPA: Abbuchungstag bleibt), T12; zweiter Aufruf ohne Mails; wirksamer Wechsel bleibt', async () => {
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ status: 'open' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
const [open] = await listContractEvents('c1')
|
||
mails.sent.length = 0
|
||
const result = await markSwitchFailed(open.$id, SWITCH_FAILED_REASONS.lastschrift, { doneBy: 'skript' })
|
||
assert.equal(result.event.status, 'gescheitert')
|
||
assert.equal(result.event.doneBy, 'skript')
|
||
assert.equal(result.event.details.grund, SWITCH_FAILED_REASONS.lastschrift)
|
||
assert.equal(result.event.details.paymentMethod, 'sepa_debit', 'details bleiben erhalten')
|
||
const [k14] = mailsWithSubject(K14_SUBJECT)
|
||
assert.ok(k14.text.includes(SWITCH_FAILED_REASONS.lastschrift))
|
||
assert.ok(k14.text.includes(HOSTING_LAEUFT_WEITER))
|
||
assert.ok(k14.text.includes('Ihr Abbuchungstag bleibt der Tag des Wechsels.'), k14.text)
|
||
assert.ok(mailsWithSubject(t12Subject('k@example.invalid'))[0].text.includes('nicht zustande gekommen'))
|
||
assert.equal(mails.sent.length, 2)
|
||
|
||
mails.sent.length = 0
|
||
const again = await markSwitchFailed(open.$id, 'egal')
|
||
assert.ok(again.skipped)
|
||
assert.deepEqual(mails.sent, [])
|
||
|
||
// Ein wirksamer, bezahlter Wechsel wird nicht zurueckgesetzt
|
||
await resetHosting()
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice() }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
const [done] = await listContractEvents('c1')
|
||
mails.sent.length = 0
|
||
assert.ok((await markSwitchFailed(done.$id, 'egal')).skipped)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'erledigt')
|
||
assert.deepEqual(mails.sent, [])
|
||
await assert.rejects(markSwitchFailed('gibt-es-nicht', 'x'), (e) => e.status === 404)
|
||
})
|
||
|
||
/** Handgriffe des Teams in Stripe nach einer gescheiterten Lastschrift (T12): Rechnung stornieren, Preis und Metadaten zurueck. */
|
||
function revertAtStripe(event, { voidInvoice = true, price = true, metadata = true } = {}) {
|
||
const sub = st.subscriptions.get(event.subscriptionId)
|
||
if (voidInvoice) st.invoices.set(event.details.invoiceId, { id: event.details.invoiceId, object: 'invoice', status: 'void', lines: { data: [] } })
|
||
if (price) sub.items.data = sub.items.data.map((item) => (item.price.id === 'price_wartung' ? { ...item, price: st.prices.get('price_hosting') } : item))
|
||
if (metadata) {
|
||
for (const [key, value] of Object.entries(event.details.previousMetadata)) {
|
||
if (value === null) delete sub.metadata[key]
|
||
else sub.metadata[key] = value
|
||
}
|
||
}
|
||
}
|
||
|
||
test('Skript wechsel-gescheitert: Aufruf, prüfen zeigt den Stripe-Stand, ausführen erst nach den Handgriffen', async () => {
|
||
assert.deepEqual(parseArgs(['node', 'wechsel-gescheitert.mjs', 'sub_h', '--pruefen']), { subscriptionId: 'sub_h', mode: 'pruefen' })
|
||
assert.deepEqual(parseArgs(['node', 'wechsel-gescheitert.mjs', 'sub_h', '--ausfuehren']), { subscriptionId: 'sub_h', mode: 'ausfuehren', grund: SWITCH_FAILED_REASONS.lastschrift })
|
||
assert.equal(parseArgs(['node', 'wechsel-gescheitert.mjs', 'sub_h', '--ausfuehren', 'Konto', 'erloschen']).grund, 'Konto erloschen')
|
||
// Fix 1 (5): kein Schalter im Grund (Tippfehler wie "--pruefen" landet sonst in K14), Grund hoechstens 300 Zeichen
|
||
assert.equal(parseArgs(['node', 'wechsel-gescheitert.mjs', 'sub_h', '--ausfuehren', '--pruefen']), null)
|
||
assert.equal(parseArgs(['node', 'wechsel-gescheitert.mjs', 'sub_h', '--ausfuehren', 'Grund', '--force']), null)
|
||
assert.equal(parseArgs(['node', 'wechsel-gescheitert.mjs', 'sub_h', '--ausfuehren', 'x'.repeat(400)]).grund.length, 300)
|
||
for (const args of [['sub_h'], ['--pruefen'], ['sub_h', '--anders'], ['cus_1', '--pruefen'], ['sub_h', '--pruefen', 'zu viel'], []]) {
|
||
assert.equal(parseArgs(['node', 'wechsel-gescheitert.mjs', ...args]), null, args.join(' '))
|
||
}
|
||
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ status: 'open' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
st.invoices.set('in_wechsel', { id: 'in_wechsel', object: 'invoice', status: 'open', lines: { data: [] } })
|
||
const [open] = await listContractEvents('c1')
|
||
mails.sent.length = 0
|
||
const out = []
|
||
const checked = await runFailedSwitchScript({ subscriptionId: 'sub_h', mode: 'pruefen' }, (line) => out.push(line))
|
||
assert.equal(checked.ok, true)
|
||
const printed = out.join('\n')
|
||
assert.ok(printed.includes(open.$id), printed)
|
||
assert.ok(printed.includes('productKey = hosting'))
|
||
assert.ok(printed.includes('termStartAt = (löschen)'))
|
||
assert.ok(printed.includes('consentUserAgent = test'))
|
||
// Stand bei Stripe: Rechnung offen, Preis Wartung, Metadaten des Wechsels
|
||
assert.match(printed, /Rechnung in_wechsel: open/)
|
||
assert.match(printed, /Abo-Position: wartung/)
|
||
assert.match(printed, /productKey: jetzt wartung/)
|
||
assert.ok(printed.includes('--ausfuehren'))
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'offen', 'nur geprueft')
|
||
assert.deepEqual(mails.sent, [])
|
||
|
||
// Ohne die Handgriffe in Stripe: kein K14, Liste der fehlenden Schritte
|
||
out.length = 0
|
||
const early = await runFailedSwitchScript({ subscriptionId: 'sub_h', mode: 'ausfuehren', grund: SWITCH_FAILED_REASONS.lastschrift }, (line) => out.push(line))
|
||
assert.equal(early.ok, false)
|
||
assert.deepEqual(early.missing.length, 3, out.join('\n'))
|
||
assert.match(out.join('\n'), /stornieren/)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'offen')
|
||
assert.deepEqual(mails.sent, [])
|
||
// Nur teilweise erledigt (Metadaten fehlen noch)
|
||
revertAtStripe(open, { metadata: false })
|
||
const partial = await runFailedSwitchScript({ subscriptionId: 'sub_h', mode: 'ausfuehren', grund: SWITCH_FAILED_REASONS.lastschrift }, () => {})
|
||
assert.equal(partial.ok, false)
|
||
assert.equal(partial.missing.length, 1)
|
||
assert.deepEqual(mails.sent, [])
|
||
|
||
revertAtStripe(open)
|
||
const done = await runFailedSwitchScript({ subscriptionId: 'sub_h', mode: 'ausfuehren', grund: SWITCH_FAILED_REASONS.lastschrift }, () => {})
|
||
assert.equal(done.ok, true)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'gescheitert')
|
||
assert.equal(ev.doneBy, 'skript')
|
||
assert.equal(mailsWithSubject(K14_SUBJECT).length, 1)
|
||
|
||
out.length = 0
|
||
const nothing = await runFailedSwitchScript({ subscriptionId: 'sub_h', mode: 'pruefen' }, (line) => out.push(line))
|
||
assert.equal(nothing.ok, false)
|
||
assert.match(out.join('\n'), /Kein offener Wechsel/)
|
||
assert.equal((await runFailedSwitchScript({ subscriptionId: 'sub_unbekannt', mode: 'pruefen' }, () => {})).ok, false)
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Fix round 1
|
||
// ---------------------------------------------------------------------------
|
||
|
||
const paymentFailed = (invoiceId, subscription = 'sub_h') =>
|
||
webhookEvent('invoice.payment_failed', {
|
||
id: invoiceId, object: 'invoice', billing_reason: 'subscription_update', amount_due: 4100, customer_email: 'k@example.invalid',
|
||
parent: { type: 'subscription_details', subscription_details: { subscription } },
|
||
})
|
||
const t12Count = () => mailsWithSubject(t12Subject('k@example.invalid')).length
|
||
|
||
// Fix 1 (1): T12 "Lastschrift gescheitert" nur fuer den echten Wechsel: offenes Ereignis, SEPA, wirksam, dieselbe Rechnung
|
||
test('Lastschrift gescheitert: nur für die Wechselrechnung eines offenen SEPA-Wechsels, einmal je Wechsel', async () => {
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ id: 'in_sepa_x', status: 'open' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
mails.sent.length = 0
|
||
// Andere Rechnung desselben Abos: kein T12
|
||
assert.equal((await postWebhook(paymentFailed('in_andere'))).status, 200)
|
||
assert.equal(t12Count(), 0)
|
||
// Die Wechselrechnung: T12, Ereignis merkt sich den Fehlschlag
|
||
assert.equal((await postWebhook(paymentFailed('in_sepa_x'))).status, 200)
|
||
assert.equal(t12Count(), 1)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'offen')
|
||
assert.ok(ev.details.lastschriftFailedAt)
|
||
// Wiederholung durch Stripe (oder erneuter Einzugsversuch): kein zweites T12
|
||
assert.equal((await postWebhook(paymentFailed('in_sepa_x'))).status, 200)
|
||
assert.equal(t12Count(), 1)
|
||
|
||
// Wechsel schon erledigt (bezahlt): kein T12, auch nicht ueber den Metadaten-Rueckfall
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ id: 'in_sepa_y', status: 'paid' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'erledigt')
|
||
mails.sent.length = 0
|
||
await postWebhook(paymentFailed('in_sepa_y'))
|
||
assert.equal(t12Count(), 0)
|
||
|
||
// Kartenkunde, Wechsel wirksam, Rechnung noch offen (kein pending_update): kein T12
|
||
await resetHosting({ paymentMethod: CARD })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ id: 'in_karte_x', status: 'open' }) }
|
||
await switchToWartung('c1', consent, nowUnix())
|
||
const [cardEvent] = await listContractEvents('c1')
|
||
assert.equal(cardEvent.status, 'offen')
|
||
assert.equal(cardEvent.details.paymentMethod, 'card')
|
||
mails.sent.length = 0
|
||
await postWebhook(paymentFailed('in_karte_x'))
|
||
assert.equal(t12Count(), 0)
|
||
})
|
||
|
||
test('Lastschrift gescheitert ohne gespeichertes Ereignis: Rückfall über die Metadaten, mit Hinweis auf den fehlenden Nachweis', async () => {
|
||
await resetHosting({ paymentMethod: SEPA })
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice({ id: 'in_ohne', status: 'open' }) }
|
||
aw.failNext({ collection: config.collections.contractEvents, method: 'POST', status: 500 })
|
||
await withCapturedLogs(() => switchToWartung('c1', consent, nowUnix()))
|
||
assert.deepEqual(await listContractEvents('c1'), [])
|
||
mails.sent.length = 0
|
||
await postWebhook(paymentFailed('in_ohne'))
|
||
const [t12] = mailsWithSubject(t12Subject('k@example.invalid'))
|
||
assert.ok(t12.text.includes('SEPA-Lastschrift für die Wechselrechnung ist gescheitert'))
|
||
assert.ok(t12.text.includes('Nachweis nicht gespeichert'))
|
||
})
|
||
|
||
// Fix 1 (2): kommt pending_update_expired (oder _applied) nie an, gleicht das Lesen des Abos den Wechsel ab
|
||
async function staleCardSwitch() {
|
||
await pendingCardSwitch()
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.ok(ev.details.pendingExpiresAt, 'Ablauf der ausstehenden Aenderung gespeichert')
|
||
await updateContractEvent(ev.$id, { details: { pendingExpiresAt: new Date(Date.now() - 60000).toISOString() } })
|
||
return ev
|
||
}
|
||
|
||
test('Abgleich ohne Webhook: abgelaufene Zahlung → gescheitert und K14 beim Lesen von GET /api/abo', async () => {
|
||
await staleCardSwitch()
|
||
st.expirePendingUpdate('sub_h')
|
||
const view = await get('/api/abo', { cookie: customerCookie() })
|
||
assert.equal(view.subscription.switchPending, null)
|
||
assert.equal(view.subscription.canSwitch, true)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.status, 'gescheitert')
|
||
assert.equal(ev.details.grund, SWITCH_FAILED_REASONS.abgelaufen)
|
||
assert.equal(mailsWithSubject(K14_SUBJECT).length, 1)
|
||
// Ein spaeter noch eintreffender Webhook aendert nichts mehr
|
||
await postWebhook(webhookEvent('customer.subscription.pending_update_expired', { id: 'sub_h', object: 'subscription' }))
|
||
assert.equal(mailsWithSubject(K14_SUBJECT).length, 1)
|
||
})
|
||
|
||
test('Abgleich ohne Webhook: bezahlt, Stripe hat übernommen → erledigt, T12, Spiegel Wartung', async () => {
|
||
const stale = await staleCardSwitch()
|
||
st.applyPendingUpdate('sub_h')
|
||
// Rueckfall ohne gespeicherten Ablauf: 23 Stunden nach dem Wechsel
|
||
await updateContractEvent(stale.$id, { details: { pendingExpiresAt: null, switchedAt: new Date(Date.now() - 24 * 3600000).toISOString() } })
|
||
const view = await get('/api/abo', { cookie: customerCookie() })
|
||
assert.equal(view.subscription.productKey, 'wartung')
|
||
assert.equal(view.subscription.switchPending, null)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'erledigt')
|
||
assert.equal(t12Count(), 1)
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').productKey, 'wartung')
|
||
})
|
||
|
||
test('Abgleich: vor Ablauf kein Stripe-Aufruf; Stripe-Fehler bleibt im Log, die Seite lädt', async () => {
|
||
await pendingCardSwitch()
|
||
const before = st.calls.length
|
||
const view = await get('/api/abo', { cookie: customerCookie() })
|
||
assert.ok(view.subscription.switchPending)
|
||
assert.deepEqual(st.calls.slice(before).filter((c) => c.path === '/v1/subscriptions/sub_h'), [], 'kein Abruf vor Ablauf')
|
||
|
||
const [ev] = await listContractEvents('c1')
|
||
await updateContractEvent(ev.$id, { details: { pendingExpiresAt: new Date(Date.now() - 60000).toISOString() } })
|
||
st.failNext({ method: 'GET', path: '/v1/subscriptions/sub_h', status: 400 })
|
||
let stillOpen
|
||
const logs = await withCapturedLogs(async () => {
|
||
stillOpen = await get('/api/abo', { cookie: customerCookie() })
|
||
})
|
||
assert.ok(stillOpen.subscription.switchPending)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'offen')
|
||
assert.ok(logs.error.some((e) => e.includes('Abgleich')), logs.error.join('\n'))
|
||
})
|
||
|
||
test('Abgleich in Vorschau und Wechsel: ein abgelaufener Wechsel sperrt den neuen nicht', async () => {
|
||
await staleCardSwitch()
|
||
st.expirePendingUpdate('sub_h')
|
||
st.invoicePreview = previewInvoice(line('price_hosting', -900, { proration: true, periodStart: nowUnix() }), line('price_wartung', 5000))
|
||
const p = await previewSwitch('c1')
|
||
assert.equal(p.amountDueCents, 4100)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'gescheitert')
|
||
})
|
||
|
||
// Fix 1 (3): Gutschrift netto nach Rabatt, damit die Uebersicht aufgeht
|
||
test('Vorschau mit Rabatt: Gutschrift abzüglich des Rabatts auf der Gutschriftzeile', async () => {
|
||
await resetHosting()
|
||
const credit = { ...line('price_hosting', -900, { proration: true, periodStart: nowUnix() }), discount_amounts: [{ amount: -450, discount: 'di_1' }] }
|
||
const debit = { ...line('price_wartung', 5000), discount_amounts: [{ amount: 2500, discount: 'di_1' }] }
|
||
st.invoicePreview = { object: 'invoice', lines: { object: 'list', data: [credit, debit], has_more: false }, amount_due: 2050 }
|
||
const p = await previewSwitch('c1')
|
||
assert.equal(p.creditCents, 450)
|
||
assert.equal(p.amountDueCents, 2050)
|
||
})
|
||
|
||
// Fix 1 (4): zwei Webhooks zugleich (invoice.paid und pending_update_applied, Wiederholungen) -> T12/K14 genau einmal
|
||
test('Gleichzeitige Webhooks: T12 bzw. K14 genau einmal', async () => {
|
||
await pendingCardSwitch('in_gleichzeitig')
|
||
st.applyPendingUpdate('sub_h')
|
||
st.invoices.set('in_gleichzeitig', paidInvoice('in_gleichzeitig'))
|
||
try {
|
||
const applied = webhookEvent('customer.subscription.pending_update_applied', { id: 'sub_h', object: 'subscription' })
|
||
const paid = webhookEvent('invoice.paid', { id: 'in_gleichzeitig', object: 'invoice', billing_reason: 'subscription_update', parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_h' } } })
|
||
const results = await Promise.all([postWebhook(applied), postWebhook(applied), postWebhook(paid)])
|
||
assert.deepEqual(results.map((r) => r.status), [200, 200, 200])
|
||
assert.equal(t12Count(), 1)
|
||
assert.equal((await listContractEvents('c1'))[0].status, 'erledigt')
|
||
} finally {
|
||
await deleteDocument(config.collections.hourCredits, 'in_gleichzeitig').catch(() => {})
|
||
}
|
||
|
||
await pendingCardSwitch()
|
||
st.expirePendingUpdate('sub_h')
|
||
const expired = webhookEvent('customer.subscription.pending_update_expired', { id: 'sub_h', object: 'subscription' })
|
||
await Promise.all([postWebhook(expired), postWebhook(expired), postWebhook(expired)])
|
||
assert.equal(mailsWithSubject(K14_SUBJECT).length, 1)
|
||
})
|
||
|
||
// Fix 1 (8): der Wechsel prueft den angezeigten Betrag gegen eine neue Vorschau
|
||
test('Wechsel mit geändertem Betrag: 409 ohne Stripe-Änderung', async () => {
|
||
await resetHosting()
|
||
st.invoicePreview = previewInvoice(line('price_hosting', -900, { proration: true, periodStart: nowUnix() }), line('price_wartung', 5000))
|
||
const before = st.calls.length
|
||
await assert.rejects(
|
||
switchToWartung('c1', consent, nowUnix(), { expectedAmountCents: 4000 }),
|
||
(e) => e.status === 409 && e.message === 'Der Betrag hat sich geändert – bitte Seite neu laden.'
|
||
)
|
||
assert.deepEqual(updateCalls('sub_h', before), [])
|
||
const res = await post(
|
||
'/api/abo/switch',
|
||
{ acceptTerms: true, earlyStart: true, termsVersion: config.abo.termsVersion, prorationDate: nowUnix(), amountDueCents: 4000 },
|
||
{ cookie: customerCookie() }
|
||
)
|
||
assert.equal(res.status, 409)
|
||
assert.match(res.body.error, /Betrag hat sich geändert/)
|
||
// Passender Betrag: Wechsel laeuft, die Vorschau nutzt dasselbe proration_date
|
||
st.nextSubscriptionUpdate = { latest_invoice: switchInvoice() }
|
||
const prorationDate = nowUnix()
|
||
const from = st.calls.length
|
||
await switchToWartung('c1', consent, prorationDate, { expectedAmountCents: 4100 })
|
||
const [previewCall] = previewCalls(from)
|
||
assert.equal(previewCall.body['subscription_details[proration_date]'], String(prorationDate))
|
||
assert.equal(updateCalls('sub_h', from).length, 1)
|
||
})
|
||
|
||
// Fix 1 (4): wer mit einem veralteten Stand des Ereignisses kommt (Webhook war schneller), aendert nichts mehr
|
||
test('Abgleich mit veraltetem Ereignis nach dem Webhook: kein zweites T12', async () => {
|
||
const stale = await staleCardSwitch()
|
||
const snapshot = { ...(await listContractEvents('c1'))[0] }
|
||
assert.equal(snapshot.status, 'offen')
|
||
st.applyPendingUpdate('sub_h')
|
||
await postWebhook(webhookEvent('customer.subscription.pending_update_applied', { id: 'sub_h', object: 'subscription' }))
|
||
assert.equal(t12Count(), 1)
|
||
assert.equal(await reconcilePendingSwitch(snapshot), null)
|
||
assert.equal(t12Count(), 1)
|
||
assert.equal((await listContractEvents('c1'))[0].$id, stale.$id)
|
||
assert.equal((await listContractEvents('c1'))[0].doneBy, 'stripe')
|
||
})
|