720 lines
37 KiB
JavaScript
720 lines
37 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'
|
||
|
||
// 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 })
|
||
const { config } = await import('../server/config.js')
|
||
const { startTestApp, post, rawGet, postWebhook } = await import('./support/testApp.js')
|
||
const { hostingDoc, consent, customerCookie, viewAsCookie, seedFixtures, stripeSubscription } = await import('./support/fixtures.js')
|
||
const { default: aboRoutes } = await import('../server/routes/abo.js')
|
||
const { planStorageChange, paidUnitsOf, previewStorageChange, changeStorage, recordPaidStorage } =
|
||
await import('../server/services/mailStorage.js')
|
||
const { listContractEvents, listOpenStorageTasks, recordContractEvent } = await import('../server/services/contractEvents.js')
|
||
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
||
|
||
const app = await startTestApp({ '/api/abo': aboRoutes })
|
||
after(() => 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_mailStorage', price('price_mailStorage', config.mailStorage.lookupKey, config.mailStorage.amountCents))
|
||
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))
|
||
|
||
const unix = (iso) => Math.floor(new Date(iso).getTime() / 1000)
|
||
const PERIOD_END_UNIX = unix(hostingDoc.currentPeriodEnd)
|
||
|
||
async function clearEvents(customerId) {
|
||
for (const e of await listContractEvents(customerId)) await deleteDocument(config.collections.contractEvents, e.$id)
|
||
}
|
||
|
||
/**
|
||
* Hosting-Abo sub_h von c1 in beiden Nachbauten auf einen Stand setzen: units Pakete bei Stripe und im
|
||
* Spiegel; paidUnits (mit storagePaidPeriodEnd = currentPeriodEnd) als schon bezahlte Menge dieses Monats,
|
||
* sonst wie die Fixture (keine Buchung: bezahlt gilt dann die aktuelle Menge). patch aendert den Spiegel,
|
||
* stripe das Stripe-Abo (der Spiegel wird nach jeder Aenderung aus Stripe neu geschrieben).
|
||
*/
|
||
async function resetSubH({ units = 0, paidUnits = null, patch = {}, stripe = {} } = {}) {
|
||
await clearEvents('c1')
|
||
aw.seed('subscriptions', {
|
||
...hostingDoc,
|
||
storageUnits: units,
|
||
storagePaidUnits: paidUnits ?? 0,
|
||
storagePaidPeriodEnd: paidUnits === null ? null : hostingDoc.currentPeriodEnd,
|
||
...patch,
|
||
})
|
||
st.subscriptions.set('sub_h', stripeSubscription({ id: 'sub_h', customerId: 'c1', productKey: 'hosting', storageUnits: units, ...stripe }))
|
||
}
|
||
|
||
// Rechnungszeilen in der Form der SDK-API-Version (2025-10-29.clover)
|
||
const line = (priceId, amount, { quantity = 1, proration = false, subscription = 'sub_h', periodStart = null, periodEnd = PERIOD_END_UNIX } = {}) => ({
|
||
amount,
|
||
quantity,
|
||
period: { start: periodStart ?? unix(hostingDoc.startedAt), end: periodEnd },
|
||
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),
|
||
})
|
||
const subscriptionUpdates = (from = 0) => st.calls.slice(from).filter((c) => c.method === 'POST' && c.path === '/v1/subscriptions/sub_h')
|
||
const previewCalls = (from = 0) => st.calls.slice(from).filter((c) => c.method === 'POST' && c.path === '/v1/invoices/create_preview')
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Reine Funktionen: Plan und bezahlte Menge
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Plan: erstes Plus anteilig', () => {
|
||
assert.deepEqual(planStorageChange({ currentUnits: 0, paidUnits: 0, newUnits: 2, maxUnits: 10 }), {
|
||
direction: 'plus',
|
||
steps: [{ quantity: 2, proration_behavior: 'create_prorations' }],
|
||
})
|
||
})
|
||
|
||
test('Plan: Minus ohne Erstattung', () => {
|
||
assert.deepEqual(planStorageChange({ currentUnits: 3, paidUnits: 3, newUnits: 1, maxUnits: 10 }).steps, [
|
||
{ quantity: 1, proration_behavior: 'none' },
|
||
])
|
||
assert.equal(planStorageChange({ currentUnits: 3, paidUnits: 3, newUnits: 1, maxUnits: 10 }).direction, 'minus')
|
||
})
|
||
|
||
test('Plan: erneutes Plus bis zur bezahlten Menge kostet nichts', () => {
|
||
assert.deepEqual(planStorageChange({ currentUnits: 1, paidUnits: 3, newUnits: 3, maxUnits: 10 }).steps, [
|
||
{ quantity: 3, proration_behavior: 'none' },
|
||
])
|
||
assert.deepEqual(planStorageChange({ currentUnits: 1, paidUnits: 3, newUnits: 5, maxUnits: 10 }).steps, [
|
||
{ quantity: 3, proration_behavior: 'none' },
|
||
{ quantity: 5, proration_behavior: 'create_prorations' },
|
||
])
|
||
// Bezahlt weniger als aktuell (z. B. altes Dokument ohne Buchung): ein Schritt anteilig
|
||
assert.deepEqual(planStorageChange({ currentUnits: 2, paidUnits: 0, newUnits: 3, maxUnits: 10 }).steps, [
|
||
{ quantity: 3, proration_behavior: 'create_prorations' },
|
||
])
|
||
})
|
||
|
||
test('Plan: Grenzen', () => {
|
||
for (const n of [-1, 11, 1.5, '2', null, undefined, NaN]) {
|
||
assert.throws(() => planStorageChange({ currentUnits: 0, paidUnits: 0, newUnits: n, maxUnits: 10 }), (e) => e.status === 400, String(n))
|
||
}
|
||
assert.equal(planStorageChange({ currentUnits: 2, paidUnits: 2, newUnits: 2, maxUnits: 10 }).direction, 'none')
|
||
assert.deepEqual(planStorageChange({ currentUnits: 2, paidUnits: 2, newUnits: 2, maxUnits: 10 }).steps, [])
|
||
assert.equal(planStorageChange({ currentUnits: 0, paidUnits: 0, newUnits: 10, maxUnits: 10 }).direction, 'plus')
|
||
assert.equal(planStorageChange({ currentUnits: 1, paidUnits: 1, newUnits: 0, maxUnits: 10 }).direction, 'minus')
|
||
})
|
||
|
||
test('Bezahlte Menge gilt nur im laufenden Zeitraum', () => {
|
||
assert.equal(paidUnitsOf({ storageUnits: 1, storagePaidUnits: 3, storagePaidPeriodEnd: 'A', currentPeriodEnd: 'A' }), 3)
|
||
assert.equal(paidUnitsOf({ storageUnits: 1, storagePaidUnits: 3, storagePaidPeriodEnd: 'A', currentPeriodEnd: 'B' }), 1)
|
||
// Appwrite gibt Datumswerte mit +00:00 zurueck, Stripe-Spiegel schreibt Z: gleicher Zeitpunkt zaehlt
|
||
assert.equal(
|
||
paidUnitsOf({ storageUnits: 1, storagePaidUnits: 3, storagePaidPeriodEnd: '2026-10-18T10:00:00.000+00:00', currentPeriodEnd: '2026-10-18T10:00:00.000Z' }),
|
||
3
|
||
)
|
||
// Ohne Buchung (null) oder ohne Attribut (Altbestand) gilt die aktuelle Menge
|
||
assert.equal(paidUnitsOf({ storageUnits: 2, storagePaidUnits: 0, storagePaidPeriodEnd: null, currentPeriodEnd: null }), 2)
|
||
assert.equal(paidUnitsOf({ storageUnits: 2 }), 2)
|
||
assert.equal(paidUnitsOf({}), 0)
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Vorschau
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Vorschau Plus: anteiliger Betrag aus der Stripe-Vorschau, Gesamtgröße, nächste Abbuchung', async () => {
|
||
await resetSubH({ units: 0 })
|
||
// Stripe-Vorschau = naechste Rechnung: anteilige Speicher-Zeile fuer den Rest des Monats plus die
|
||
// regulaeren Zeilen des naechsten Monats (die zaehlen nicht zum anteiligen Betrag)
|
||
st.invoicePreview = previewInvoice(
|
||
line('price_mailStorage', 133, { quantity: 2, proration: true, periodStart: Math.floor(Date.now() / 1000) }),
|
||
line('price_hosting', 1500),
|
||
line('price_mailStorage', 200, { quantity: 2 })
|
||
)
|
||
const before = st.calls.length
|
||
const p = await previewStorageChange('c1', 2)
|
||
assert.equal(p.direction, 'plus')
|
||
assert.equal(p.units, 2)
|
||
assert.equal(p.totalGb, 15)
|
||
assert.equal(p.monthlyCents, 200)
|
||
assert.equal(p.deltaMonthlyCents, 200)
|
||
assert.equal(p.prorationCents, 133)
|
||
assert.equal(p.nextChargeAt, hostingDoc.currentPeriodEnd)
|
||
assert.ok(Math.abs(new Date(p.effectiveAt).getTime() - Date.now()) < 5000, 'wirksam jetzt')
|
||
const [call] = previewCalls(before)
|
||
assert.ok(call, 'invoices.createPreview aufgerufen')
|
||
assert.equal(call.body['subscription'], 'sub_h')
|
||
// Noch kein Speicher-Posten: Vorschau mit Preis statt Posten-ID
|
||
assert.equal(call.body['subscription_details[items][0][price]'], 'price_mailStorage')
|
||
assert.equal(call.body['subscription_details[items][0][quantity]'], '2')
|
||
assert.equal(call.body['subscription_details[proration_behavior]'], 'create_prorations')
|
||
assert.match(call.body['subscription_details[proration_date]'], /^\d{10}$/)
|
||
// Keine Aenderung bei Stripe durch eine Vorschau
|
||
assert.deepEqual(subscriptionUpdates(before), [])
|
||
})
|
||
|
||
test('Vorschau Plus mit Posten: Gutschrift und Belastung der Speicher-Zeilen, ältere anteilige Zeilen zählen nicht', async () => {
|
||
await resetSubH({ units: 1 })
|
||
const now = Math.floor(Date.now() / 1000)
|
||
st.invoicePreview = previewInvoice(
|
||
// Aenderung von vorhin (schon als offene Rechnungsposition vorgemerkt): nicht Teil dieser Bestellung
|
||
line('price_mailStorage', 40, { quantity: 1, proration: true, periodStart: now - 3600 }),
|
||
line('price_mailStorage', -67, { quantity: 1, proration: true, periodStart: now }),
|
||
line('price_mailStorage', 200, { quantity: 3, proration: true, periodStart: now }),
|
||
line('price_hosting', 1500),
|
||
line('price_mailStorage', 300, { quantity: 3 })
|
||
)
|
||
const before = st.calls.length
|
||
const p = await previewStorageChange('c1', 3)
|
||
assert.equal(p.prorationCents, 133)
|
||
assert.equal(p.deltaMonthlyCents, 200)
|
||
assert.equal(p.totalGb, 20)
|
||
const [call] = previewCalls(before)
|
||
assert.equal(call.body['subscription_details[items][0][id]'], 'si_sub_h_speicher')
|
||
assert.equal(call.body['subscription_details[items][0][price]'], undefined)
|
||
assert.equal(call.body['subscription_details[items][0][quantity]'], '3')
|
||
})
|
||
|
||
test('Vorschau Minus: keine Stripe-Vorschau, wirksam zum Periodenende, keine Erstattung', async () => {
|
||
await resetSubH({ units: 3 })
|
||
const before = st.calls.length
|
||
const p = await previewStorageChange('c1', 1)
|
||
assert.deepEqual(p, {
|
||
direction: 'minus',
|
||
units: 1,
|
||
totalGb: 10,
|
||
monthlyCents: 100,
|
||
deltaMonthlyCents: -200,
|
||
prorationCents: 0,
|
||
nextChargeAt: hostingDoc.currentPeriodEnd,
|
||
effectiveAt: hostingDoc.currentPeriodEnd,
|
||
})
|
||
assert.deepEqual(previewCalls(before), [])
|
||
})
|
||
|
||
test('Vorschau Minus bei gekündigtem Abo: wirksam mit dem Abo-Ende, wenn das früher liegt', async () => {
|
||
const cancelAt = new Date(new Date(hostingDoc.currentPeriodEnd).getTime() - 86400000).toISOString()
|
||
await resetSubH({ units: 3, patch: { cancelAtPeriodEnd: false, cancelAt } })
|
||
assert.equal((await previewStorageChange('c1', 1)).effectiveAt, cancelAt)
|
||
})
|
||
|
||
// F19: Stripe rechnet die Vorschau von der heutigen Stueckzahl (1) aus; bis zur schon bezahlten Menge (3)
|
||
// laeuft der erste Schritt ohne Verrechnung, berechnet werden nur die 2 Pakete darueber
|
||
test('Vorschau Plus in zwei Schritten: anteilig nur für die Pakete über der bezahlten Menge', async () => {
|
||
await resetSubH({ units: 1, paidUnits: 3 })
|
||
const now = Math.floor(Date.now() / 1000)
|
||
// Vorschau 1 -> 5: Gutschrift fuer 1 Paket (-67), Belastung fuer 5 Pakete (333) = 266 fuer 4 Pakete
|
||
st.invoicePreview = previewInvoice(
|
||
line('price_mailStorage', -67, { quantity: 1, proration: true, periodStart: now }),
|
||
line('price_mailStorage', 333, { quantity: 5, proration: true, periodStart: now }),
|
||
line('price_hosting', 1500),
|
||
line('price_mailStorage', 500, { quantity: 5 })
|
||
)
|
||
const before = st.calls.length
|
||
const p = await previewStorageChange('c1', 5)
|
||
// 266 × (5 − max(1, 3)) / (5 − 1) = 133
|
||
assert.equal(p.prorationCents, 133)
|
||
assert.equal(p.direction, 'plus')
|
||
assert.equal(p.deltaMonthlyCents, 400)
|
||
assert.equal(previewCalls(before)[0].body['subscription_details[items][0][quantity]'], '5')
|
||
|
||
// Plus bis zur bezahlten Menge: nichts anteilig, keine Vorschau bei Stripe
|
||
const before2 = st.calls.length
|
||
const p2 = await previewStorageChange('c1', 3)
|
||
assert.equal(p2.prorationCents, 0)
|
||
assert.equal(p2.direction, 'plus')
|
||
assert.equal(p2.deltaMonthlyCents, 200)
|
||
assert.deepEqual(previewCalls(before2), [])
|
||
})
|
||
|
||
test('Vorschau: unveränderte Menge ohne Stripe-Aufruf, Grenzen 400, kein Abo 404', async () => {
|
||
await resetSubH({ units: 2 })
|
||
const before = st.calls.length
|
||
const p = await previewStorageChange('c1', 2)
|
||
assert.equal(p.direction, 'none')
|
||
assert.equal(p.prorationCents, 0)
|
||
assert.equal(p.deltaMonthlyCents, 0)
|
||
assert.equal(st.calls.length, before)
|
||
await assert.rejects(previewStorageChange('c1', 11), (e) => e.status === 400)
|
||
await assert.rejects(previewStorageChange('c1', '2'), (e) => e.status === 400)
|
||
await assert.rejects(previewStorageChange('c3', 1), (e) => e.status === 404)
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Aenderung: Plus
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Plus: Stripe-Aufrufe, Ereignis offen, bezahlte Menge', async () => {
|
||
await resetSubH({ units: 0 }) // Nachbauten: sub_h active, ohne Speicher
|
||
const before = st.calls.length
|
||
const result = await changeStorage('c1', 2, consent)
|
||
const upd = st.calls.filter((c) => c.path === '/v1/subscriptions/sub_h' && c.method === 'POST')
|
||
assert.equal(upd.at(-1).body['proration_behavior'], 'create_prorations')
|
||
assert.equal(upd.at(-1).body['items[0][quantity]'], '2')
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.type, 'speicher')
|
||
assert.equal(ev.status, 'offen')
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').storagePaidUnits, 2)
|
||
|
||
// Erste Position: mit Preis angelegt, nicht mit Posten-ID; anteilig ab jetzt (proration_date)
|
||
assert.equal(subscriptionUpdates(before).length, 1)
|
||
assert.equal(upd.at(-1).body['items[0][price]'], 'price_mailStorage')
|
||
assert.equal(upd.at(-1).body['items[0][id]'], undefined)
|
||
assert.match(upd.at(-1).body['proration_date'], /^\d{10}$/)
|
||
// Stripe-Nachbau hat jetzt den Speicher-Posten mit Menge 2, der Spiegel ebenso
|
||
const stripeSub = st.subscriptions.get('sub_h')
|
||
const storageItem = stripeSub.items.data.find((i) => i.price.lookup_key === config.mailStorage.lookupKey)
|
||
assert.equal(storageItem.quantity, 2)
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.storageUnits, 2)
|
||
assert.equal(doc.storagePaidPeriodEnd, hostingDoc.currentPeriodEnd)
|
||
// Ereignis: Nachweis mit Zustimmung, Aufgabe faellig jetzt, Ziel und Wirksamkeit in den details
|
||
assert.equal(ev.subscriptionId, 'sub_h')
|
||
assert.equal(ev.customerId, 'c1')
|
||
assert.equal(ev.productKey, 'hosting')
|
||
assert.equal(ev.termsVersion, consent.termsVersion)
|
||
assert.equal(ev.consentAt, consent.consentAt)
|
||
assert.equal(ev.consentIp, '127.0.0.1')
|
||
assert.equal(ev.consentUserAgent, 'test')
|
||
assert.equal(ev.earlyStartConsentAt ?? null, null)
|
||
assert.equal(ev.details.fromUnits, 0)
|
||
assert.equal(ev.details.toUnits, 2)
|
||
assert.equal(ev.details.totalGb, 15)
|
||
assert.equal(ev.details.monthlyCents, 200)
|
||
assert.ok(Math.abs(new Date(ev.dueAt).getTime() - Date.now()) < 5000, 'faellig jetzt')
|
||
assert.equal(ev.details.effectiveAt, ev.dueAt)
|
||
// Rueckgabe
|
||
assert.equal(result.subscription.storageUnits, 2)
|
||
assert.equal(result.event.$id, ev.$id)
|
||
assert.deepEqual(
|
||
{ direction: result.change.direction, fromUnits: result.change.fromUnits, toUnits: result.change.toUnits },
|
||
{ direction: 'plus', fromUnits: 0, toUnits: 2 }
|
||
)
|
||
})
|
||
|
||
test('Plus in zwei Schritten: erst die bezahlte Menge ohne Verrechnung, dann anteilig', async () => {
|
||
await resetSubH({ units: 1, paidUnits: 3 })
|
||
const before = st.calls.length
|
||
await changeStorage('c1', 5, consent)
|
||
const upd = subscriptionUpdates(before)
|
||
assert.equal(upd.length, 2)
|
||
assert.equal(upd[0].body['items[0][id]'], 'si_sub_h_speicher')
|
||
assert.equal(upd[0].body['items[0][quantity]'], '3')
|
||
assert.equal(upd[0].body['proration_behavior'], 'none')
|
||
assert.equal(upd[0].body['proration_date'], undefined)
|
||
assert.equal(upd[1].body['items[0][id]'], 'si_sub_h_speicher')
|
||
assert.equal(upd[1].body['items[0][quantity]'], '5')
|
||
assert.equal(upd[1].body['proration_behavior'], 'create_prorations')
|
||
assert.match(upd[1].body['proration_date'], /^\d{10}$/)
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.storageUnits, 5)
|
||
assert.equal(doc.storagePaidUnits, 5)
|
||
assert.equal(doc.storagePaidPeriodEnd, hostingDoc.currentPeriodEnd)
|
||
})
|
||
|
||
test('Plus bis zur bezahlten Menge: ein Schritt ohne Verrechnung, bezahlte Menge bleibt', async () => {
|
||
await resetSubH({ units: 1, paidUnits: 3 })
|
||
const before = st.calls.length
|
||
await changeStorage('c1', 3, consent)
|
||
const upd = subscriptionUpdates(before)
|
||
assert.equal(upd.length, 1)
|
||
assert.equal(upd[0].body['items[0][quantity]'], '3')
|
||
assert.equal(upd[0].body['proration_behavior'], 'none')
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.storageUnits, 3)
|
||
assert.equal(doc.storagePaidUnits, 3)
|
||
})
|
||
|
||
test('Plus ohne Zustimmung: 400; gekündigt: 409', async () => {
|
||
await assert.rejects(changeStorage('c1', 3, null), (e) => e.status === 400)
|
||
aw.seed('subscriptions', { ...hostingDoc, $id: 'sub_h', cancelAtPeriodEnd: true })
|
||
await assert.rejects(changeStorage('c1', 3, consent), (e) => e.status === 409)
|
||
})
|
||
|
||
test('Plus ohne Zustimmung nennt die Regeln zum Zusatzspeicher, ohne Stripe-Aufruf', async () => {
|
||
await resetSubH({ units: 0 })
|
||
const before = st.calls.length
|
||
await assert.rejects(changeStorage('c1', 1, null), (e) => e.status === 400 && /Regeln zum Zusatzspeicher/.test(e.message))
|
||
await assert.rejects(changeStorage('c1', 1, {}), (e) => e.status === 400)
|
||
assert.equal(st.calls.length, before)
|
||
assert.deepEqual(await listContractEvents('c1'), [])
|
||
})
|
||
|
||
test('Keine Änderung bei trialing, past_due, cancelAt oder offenem Wechsel (409)', async () => {
|
||
for (const patch of [
|
||
{ status: 'trialing', trialEnd: '2026-11-01T05:00:00.000Z', startChoice: 'nach_frist' },
|
||
{ status: 'past_due' },
|
||
{ cancelAtPeriodEnd: false, cancelAt: '2027-10-05T10:00:00.000Z' },
|
||
]) {
|
||
await resetSubH({ units: 1, patch })
|
||
const before = st.calls.length
|
||
await assert.rejects(changeStorage('c1', 2, consent), (e) => e.status === 409, JSON.stringify(patch))
|
||
await assert.rejects(changeStorage('c1', 0, null), (e) => e.status === 409, JSON.stringify(patch))
|
||
assert.equal(st.calls.length, before, 'kein Stripe-Aufruf')
|
||
}
|
||
// F12: solange ein Wechsel auf die Zahlung wartet, keine Speicheraenderung (wie canChangeStorage)
|
||
await resetSubH({ units: 1 })
|
||
await recordContractEvent({
|
||
customerId: 'c1', subscriptionId: 'sub_h', type: 'wechsel', productKey: 'wartung',
|
||
details: { from: 'hosting' }, consent, status: 'offen',
|
||
})
|
||
await assert.rejects(changeStorage('c1', 2, consent), (e) => e.status === 409 && /Wechsel/.test(e.message))
|
||
await clearEvents('c1')
|
||
})
|
||
|
||
test('Grenzen: 11 Pakete oder unveränderte Menge 400, kein Abo 404, ohne Stripe-Aufruf', async () => {
|
||
await resetSubH({ units: 2 })
|
||
const before = st.calls.length
|
||
await assert.rejects(changeStorage('c1', 11, consent), (e) => e.status === 400)
|
||
await assert.rejects(changeStorage('c1', 2, consent), (e) => e.status === 400 && /unverändert/.test(e.message))
|
||
await assert.rejects(changeStorage('c3', 1, consent), (e) => e.status === 404)
|
||
assert.equal(st.calls.length, before)
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Aenderung: Minus
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// Rechtsrunde 28.09.2026: ein Minus hat kein Pflicht-Haekchen, das Ereignis traegt keine Zustimmungsdaten
|
||
test('Minus: sofort bei Stripe ohne Erstattung, Aufgabe zum Periodenende, keine Zustimmungsdaten', async () => {
|
||
await resetSubH({ units: 3, paidUnits: 3 })
|
||
const before = st.calls.length
|
||
const result = await changeStorage('c1', 1, null)
|
||
const upd = subscriptionUpdates(before)
|
||
assert.equal(upd.length, 1)
|
||
assert.equal(upd[0].body['items[0][id]'], 'si_sub_h_speicher')
|
||
assert.equal(upd[0].body['items[0][quantity]'], '1')
|
||
assert.equal(upd[0].body['proration_behavior'], 'none')
|
||
assert.equal(upd[0].body['proration_date'], undefined)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.type, 'speicher')
|
||
assert.equal(ev.status, 'offen')
|
||
assert.equal(ev.dueAt, hostingDoc.currentPeriodEnd)
|
||
assert.deepEqual([ev.details.fromUnits, ev.details.toUnits, ev.details.effectiveAt], [3, 1, hostingDoc.currentPeriodEnd])
|
||
assert.equal(ev.consentIp ?? null, null)
|
||
assert.equal(ev.consentUserAgent ?? null, null)
|
||
assert.equal(ev.termsVersion ?? null, null)
|
||
assert.equal(ev.consentAt ?? null, null)
|
||
// Spiegel: Stripe-Menge sofort 1, bezahlt bleiben 3 fuer diesen Monat (ein Plus zurueck auf 3 kostet nichts)
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.storageUnits, 1)
|
||
assert.equal(doc.storagePaidUnits, 3)
|
||
assert.equal(doc.storagePaidPeriodEnd, hostingDoc.currentPeriodEnd)
|
||
assert.equal(result.change.direction, 'minus')
|
||
assert.equal(result.change.effectiveAt, hostingDoc.currentPeriodEnd)
|
||
|
||
// Plus zurueck auf 3 im selben Monat: ohne Verrechnung
|
||
const before2 = st.calls.length
|
||
await changeStorage('c1', 3, consent)
|
||
assert.equal(subscriptionUpdates(before2).length, 1)
|
||
assert.equal(subscriptionUpdates(before2)[0].body['proration_behavior'], 'none')
|
||
})
|
||
|
||
test('Minus auf 0: Position bleibt mit Menge 0, ein späteres Plus nutzt sie wieder', async () => {
|
||
await resetSubH({ units: 2, paidUnits: 2 })
|
||
const before = st.calls.length
|
||
await changeStorage('c1', 0, null)
|
||
assert.equal(subscriptionUpdates(before)[0].body['items[0][quantity]'], '0')
|
||
const storageItem = () => st.subscriptions.get('sub_h').items.data.find((i) => i.price.lookup_key === config.mailStorage.lookupKey)
|
||
assert.equal(storageItem().quantity, 0)
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').storageUnits, 0)
|
||
const before2 = st.calls.length
|
||
await changeStorage('c1', 4, consent)
|
||
const upd = subscriptionUpdates(before2)
|
||
assert.equal(upd[0].body['items[0][id]'], 'si_sub_h_speicher')
|
||
assert.equal(upd[0].body['items[0][price]'], undefined)
|
||
assert.equal(storageItem().quantity, 4)
|
||
assert.equal(st.subscriptions.get('sub_h').items.data.length, 2, 'kein zweiter Speicher-Posten')
|
||
})
|
||
|
||
// F21: aeltere offene Aufgaben desselben Abos sind ueberholt; fuers Team zaehlt eine Aufgabe je Abo
|
||
test('Neue Änderung ersetzt die offene Aufgabe: eine Aufgabe je Abo mit Zielgröße und Datum', async () => {
|
||
await resetSubH({ units: 0 })
|
||
await changeStorage('c1', 2, consent)
|
||
const [plusEvent] = await listContractEvents('c1')
|
||
await changeStorage('c1', 1, null)
|
||
const events = await listContractEvents('c1')
|
||
assert.equal(events.length, 2)
|
||
const superseded = events.find((e) => e.$id === plusEvent.$id)
|
||
assert.equal(superseded.status, 'erledigt')
|
||
assert.equal(superseded.doneBy, 'ersetzt')
|
||
assert.ok(superseded.doneAt)
|
||
assert.deepEqual(superseded.details, plusEvent.details, 'details des ersetzten Ereignisses bleiben')
|
||
const open = (await listOpenStorageTasks()).filter((t) => t.subscriptionId === 'sub_h')
|
||
assert.equal(open.length, 1)
|
||
assert.equal(open[0].details.toUnits, 1)
|
||
assert.equal(open[0].dueAt, hostingDoc.currentPeriodEnd)
|
||
// Ein fremdes Abo (c2) bleibt unberuehrt
|
||
await recordContractEvent({
|
||
customerId: 'c2', subscriptionId: 'sub_h2', type: 'speicher', productKey: 'hosting',
|
||
details: { fromUnits: 0, toUnits: 1 }, consent, status: 'offen', dueAt: new Date().toISOString(),
|
||
})
|
||
await changeStorage('c1', 2, consent)
|
||
assert.equal((await listContractEvents('c2'))[0].status, 'offen')
|
||
await clearEvents('c2')
|
||
})
|
||
|
||
// F20 / Rechtsrunde: ueber das Kuendigungsformular (viaCancellation) sind Verringerungen bei jedem
|
||
// laufenden Status und auch bei gekuendigtem Abo erlaubt, Erhoehungen nie; K13 entfaellt dort (F31)
|
||
test('Kündigungsweg: Verringerung auch bei gekündigtem Abo, Erhöhung nie', async () => {
|
||
await resetSubH({
|
||
units: 2,
|
||
patch: { cancelAtPeriodEnd: true, cancelAt: hostingDoc.currentPeriodEnd },
|
||
stripe: { cancel_at_period_end: true },
|
||
})
|
||
const errors = []
|
||
const original = console.error
|
||
console.error = (...args) => errors.push(args.join(' '))
|
||
try {
|
||
const result = await changeStorage('c1', 1, null, { viaCancellation: true })
|
||
assert.equal(result.change.direction, 'minus')
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').storageUnits, 1)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.type, 'speicher')
|
||
assert.equal(ev.status, 'offen')
|
||
assert.equal(ev.details.viaCancellation, true)
|
||
assert.equal(ev.consentIp ?? null, null)
|
||
assert.ok(!errors.some((e) => e.includes('K13')), 'K13 entfaellt beim Kuendigungsformular (K03 bestaetigt)')
|
||
|
||
await assert.rejects(changeStorage('c1', 3, consent, { viaCancellation: true }), (e) => e.status === 409)
|
||
// Der Spiegel bleibt gekuendigt (aus Stripe); ohne viaCancellation bleibt er gesperrt, auch fuer ein Minus
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').cancelAtPeriodEnd, true)
|
||
await assert.rejects(changeStorage('c1', 0, null), (e) => e.status === 409)
|
||
|
||
// past_due: Verringerung erlaubt; beendetes Abo (canceled): nicht mehr
|
||
await resetSubH({ units: 2, patch: { status: 'past_due' }, stripe: { status: 'past_due' } })
|
||
assert.equal((await changeStorage('c1', 0, null, { viaCancellation: true })).change.toUnits, 0)
|
||
assert.equal(aw.docs('subscriptions').get('sub_h').status, 'past_due')
|
||
await resetSubH({ units: 2, patch: { status: 'canceled', endedAt: new Date().toISOString() } })
|
||
await assert.rejects(changeStorage('c1', 1, null, { viaCancellation: true }), (e) => e.status === 409)
|
||
|
||
// Zum Vergleich: ein Minus im Portal versucht K13 (scheitert hier nur am fehlenden SMTP)
|
||
errors.length = 0
|
||
await resetSubH({ units: 2 })
|
||
await changeStorage('c1', 1, null)
|
||
assert.ok(errors.some((e) => e.includes('K13')), 'K13 wird im Portal versucht')
|
||
} finally {
|
||
console.error = original
|
||
}
|
||
})
|
||
|
||
test('Bezahlte Menge nicht speicherbar: Stripe-Änderung bleibt, Ereignis und Aufruf gelingen, Fehler im Log', async () => {
|
||
await resetSubH({ units: 0 })
|
||
const errors = []
|
||
const original = console.error
|
||
console.error = (...args) => errors.push(args.join(' '))
|
||
try {
|
||
// Erste PATCH ist der Spiegel (syncSubscription), die zweite die bezahlte Menge - nur die scheitert
|
||
aw.failNext({ collection: config.collections.subscriptions, method: 'PATCH', status: 400, after: 1, message: 'Invalid document structure: Unknown attribute: "storagePaidUnits"' })
|
||
const result = await changeStorage('c1', 2, consent)
|
||
assert.equal(result.change.direction, 'plus')
|
||
assert.ok(result.event)
|
||
assert.equal(result.subscription.storageUnits, 2)
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.storageUnits, 2)
|
||
assert.equal(doc.storagePaidUnits, 0, 'Buchung fehlt, der Rest lief durch')
|
||
assert.ok(errors.some((e) => /Bezahlte Menge/.test(e) && /sub_h/.test(e) && /400/.test(e)))
|
||
assert.equal((await listContractEvents('c1')).length, 1)
|
||
} finally {
|
||
console.error = original
|
||
}
|
||
})
|
||
|
||
test('Ereignis nicht speicherbar: Stripe-Änderung bleibt, Aufruf gelingt, Fehler im Log', async () => {
|
||
await resetSubH({ units: 0 })
|
||
const errors = []
|
||
const original = console.error
|
||
console.error = (...args) => errors.push(args.join(' '))
|
||
try {
|
||
aw.failNext({ collection: config.collections.contractEvents, method: 'POST', status: 500 })
|
||
const result = await changeStorage('c1', 1, consent)
|
||
assert.equal(result.event, null)
|
||
assert.equal(result.subscription.storageUnits, 1)
|
||
assert.ok(errors.some((e) => /Ereignis/.test(e) && /sub_h/.test(e)))
|
||
assert.deepEqual(await listContractEvents('c1'), [])
|
||
} finally {
|
||
console.error = original
|
||
}
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Bezahlte Menge aus Rechnungen (Webhook invoice.paid)
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('invoice.paid: bezahlte Menge aus regulärer Speicher-Zeile', async () => {
|
||
await resetSubH({ units: 3 })
|
||
await recordPaidStorage({
|
||
lines: {
|
||
data: [
|
||
{
|
||
amount: 300,
|
||
quantity: 3,
|
||
period: { end: 1793000000 },
|
||
pricing: { price_details: { price: 'price_mailStorage' } },
|
||
parent: { type: 'subscription_item_details', subscription_item_details: { proration: false, subscription: 'sub_h' } },
|
||
},
|
||
],
|
||
},
|
||
})
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.storagePaidUnits, 3)
|
||
assert.equal(doc.storagePaidPeriodEnd, new Date(1793000000 * 1000).toISOString())
|
||
})
|
||
|
||
test('invoice.paid: anteilige Speicher-Zeile oder Rechnung ohne Speicher ändert nichts', async () => {
|
||
await resetSubH({ units: 2, paidUnits: 2 })
|
||
const r1 = await recordPaidStorage({ id: 'in_x', lines: { data: [line('price_mailStorage', 90, { quantity: 3, proration: true })] } })
|
||
assert.ok(r1.skipped)
|
||
const r2 = await recordPaidStorage({ id: 'in_y', lines: { data: [line('price_hosting', 1500)] } })
|
||
assert.ok(r2.skipped)
|
||
const doc = aw.docs('subscriptions').get('sub_h')
|
||
assert.equal(doc.storagePaidUnits, 2)
|
||
assert.equal(doc.storagePaidPeriodEnd, hostingDoc.currentPeriodEnd)
|
||
})
|
||
|
||
test('invoice.paid: Spiegel fehlt noch → aus Stripe angelegt, dann gebucht', async () => {
|
||
const subId = 'sub_1SD6yStorageNeuAbCdEfGhIj'
|
||
st.subscriptions.set(subId, stripeSubscription({ id: subId, customerId: 'c2', productKey: 'hosting', storageUnits: 1 }))
|
||
try {
|
||
const r = await recordPaidStorage({ id: 'in_z', lines: { data: [line('price_mailStorage', 100, { quantity: 1, subscription: subId, periodEnd: 1793000000 })] } })
|
||
assert.equal(r.recorded, true)
|
||
const doc = aw.docs('subscriptions').get(subId)
|
||
assert.equal(doc.customerId, 'c2')
|
||
assert.equal(doc.storageUnits, 1)
|
||
assert.equal(doc.storagePaidUnits, 1)
|
||
assert.equal(doc.storagePaidPeriodEnd, new Date(1793000000 * 1000).toISOString())
|
||
} finally {
|
||
await deleteDocument(config.collections.subscriptions, subId).catch(() => {})
|
||
}
|
||
})
|
||
|
||
// F18: der Webhook laedt die Rechnung genau einmal frisch (mit allen Zeilen, auch ueber die 10 eingebetteten
|
||
// hinaus) und bucht daraus Stundengutschrift und bezahlte Speichermenge
|
||
test('Webhook invoice.paid: Rechnung einmal frisch geladen, alle Zeilen, Stunde und bezahlte Speichermenge', async () => {
|
||
st.subscriptions.set('sub_w', stripeSubscription({ id: 'sub_w', customerId: 'c1', productKey: 'wartung', storageUnits: 2 }))
|
||
const now = Math.floor(Date.now() / 1000)
|
||
// 10 anteilige Speicher-Zeilen (Aenderungen im Monat) stehen vor den regulaeren Zeilen
|
||
const prorations = Array.from({ length: 10 }, (_, i) => line('price_mailStorage', 10 + i, { proration: true, subscription: 'sub_w', periodStart: now - i * 60 }))
|
||
st.invoices.set('in_w12', {
|
||
id: 'in_w12',
|
||
object: 'invoice',
|
||
number: 'WK-12',
|
||
created: now,
|
||
status_transitions: { paid_at: now },
|
||
parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_w' } },
|
||
lines: {
|
||
object: 'list',
|
||
data: [...prorations, line('price_wartung', 5000, { subscription: 'sub_w', periodEnd: 1793000000 }), line('price_mailStorage', 200, { quantity: 2, subscription: 'sub_w', periodEnd: 1793000000 })],
|
||
},
|
||
})
|
||
const before = st.calls.length
|
||
try {
|
||
const res = await postWebhook({
|
||
id: 'evt_in_w12',
|
||
object: 'event',
|
||
type: 'invoice.paid',
|
||
created: now,
|
||
data: { object: { id: 'in_w12', object: 'invoice', parent: { type: 'subscription_details', subscription_details: { subscription: 'sub_w' } } } },
|
||
})
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
const calls = st.calls.slice(before)
|
||
assert.equal(calls.filter((c) => c.method === 'GET' && c.path === '/v1/invoices/in_w12').length, 1, 'genau einmal frisch geladen')
|
||
assert.ok(calls.some((c) => c.method === 'GET' && c.path === '/v1/invoices/in_w12/lines'), 'weitere Zeilen nachgeladen')
|
||
assert.equal(aw.docs('hourCredits').get('in_w12').minutes, 60)
|
||
const doc = aw.docs('subscriptions').get('sub_w')
|
||
assert.equal(doc.productKey, 'wartung')
|
||
assert.equal(doc.storageUnits, 2)
|
||
assert.equal(doc.storagePaidUnits, 2)
|
||
assert.equal(doc.storagePaidPeriodEnd, new Date(1793000000 * 1000).toISOString())
|
||
} finally {
|
||
await deleteDocument(config.collections.subscriptions, 'sub_w').catch(() => {})
|
||
await deleteDocument(config.collections.hourCredits, 'in_w12').catch(() => {})
|
||
}
|
||
})
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Routen
|
||
// ---------------------------------------------------------------------------
|
||
|
||
test('Routen: ohne Session 401, im Modus „Als Kunde ansehen“ 403, ohne Stripe-Aufruf', async () => {
|
||
await resetSubH({ units: 0 })
|
||
const before = st.calls.length
|
||
assert.equal((await post('/api/abo/storage/preview', { units: 2 })).status, 401)
|
||
assert.equal((await post('/api/abo/storage', { units: 2, acceptTerms: true, termsVersion: config.abo.termsVersion })).status, 401)
|
||
assert.equal((await post('/api/abo/storage/preview', { units: 2 }, { cookie: viewAsCookie() })).status, 403)
|
||
assert.equal((await post('/api/abo/storage', { units: 2, acceptTerms: true, termsVersion: config.abo.termsVersion }, { cookie: viewAsCookie() })).status, 403)
|
||
assert.equal(st.calls.length, before)
|
||
assert.equal((await rawGet('/api/abo/storage')).status, 404)
|
||
})
|
||
|
||
test('Route Vorschau: { units } → Vorschau; Grenzen 400', async () => {
|
||
await resetSubH({ units: 0 })
|
||
st.invoicePreview = previewInvoice(line('price_mailStorage', 133, { quantity: 2, proration: true, periodStart: Math.floor(Date.now() / 1000) }))
|
||
const res = await post('/api/abo/storage/preview', { units: 2 }, { cookie: customerCookie() })
|
||
assert.equal(res.status, 200, JSON.stringify(res.body))
|
||
assert.equal(res.body.direction, 'plus')
|
||
assert.equal(res.body.prorationCents, 133)
|
||
assert.equal(res.body.totalGb, 15)
|
||
assert.equal(res.body.nextChargeAt, hostingDoc.currentPeriodEnd)
|
||
assert.equal((await post('/api/abo/storage/preview', { units: 11 }, { cookie: customerCookie() })).status, 400)
|
||
assert.equal((await post('/api/abo/storage/preview', { units: '2' }, { cookie: customerCookie() })).status, 400)
|
||
assert.equal((await post('/api/abo/storage/preview', {}, { cookie: customerCookie() })).status, 400)
|
||
})
|
||
|
||
test('Route Änderung: Plus braucht acceptTerms und die aktuelle Fassung, Antwort mit Abo-Ansicht', async () => {
|
||
await resetSubH({ units: 0 })
|
||
const cookie = customerCookie()
|
||
const before = st.calls.length
|
||
const noTerms = await post('/api/abo/storage', { units: 2 }, { cookie })
|
||
assert.equal(noTerms.status, 400)
|
||
assert.match(noTerms.body.error, /Regeln zum Zusatzspeicher/)
|
||
const stale = await post('/api/abo/storage', { units: 2, acceptTerms: true, termsVersion: '2026-09-25-v3' }, { cookie })
|
||
assert.equal(stale.status, 409)
|
||
assert.equal(subscriptionUpdates(before).length, 0)
|
||
|
||
const plus = await post('/api/abo/storage', { units: 2, acceptTerms: true, termsVersion: config.abo.termsVersion }, { cookie })
|
||
assert.equal(plus.status, 200, JSON.stringify(plus.body))
|
||
assert.deepEqual(plus.body.subscription.storage, { units: 2, pendingSetup: true, pendingReduction: null })
|
||
assert.equal(plus.body.subscription.withdrawalOpen, true)
|
||
assert.deepEqual(plus.body.subscription.withdrawals.map((w) => w.type), ['speicher'])
|
||
assert.equal(plus.body.change.direction, 'plus')
|
||
assert.equal(plus.body.change.toUnits, 2)
|
||
assert.equal(subscriptionUpdates(before).length, 1)
|
||
const [ev] = await listContractEvents('c1')
|
||
assert.equal(ev.termsVersion, config.abo.termsVersion)
|
||
assert.equal(ev.consentIp, '127.0.0.1')
|
||
assert.ok(ev.consentAt)
|
||
|
||
// Minus ohne Haekchen: Speichern; Antwort zeigt die geplante Verringerung
|
||
const minus = await post('/api/abo/storage', { units: 1 }, { cookie })
|
||
assert.equal(minus.status, 200, JSON.stringify(minus.body))
|
||
assert.deepEqual(minus.body.subscription.storage, {
|
||
units: 1,
|
||
pendingSetup: false,
|
||
pendingReduction: { units: 1, effectiveAt: minus.body.subscription.currentPeriodEnd },
|
||
})
|
||
assert.equal(minus.body.change.direction, 'minus')
|
||
assert.equal(minus.body.change.effectiveAt, minus.body.subscription.currentPeriodEnd)
|
||
|
||
// Gekuendigt: 409 mit Fehlertext
|
||
aw.seed('subscriptions', { ...hostingDoc, storageUnits: 1, cancelAtPeriodEnd: true })
|
||
const cancelled = await post('/api/abo/storage', { units: 2, acceptTerms: true, termsVersion: config.abo.termsVersion }, { cookie })
|
||
assert.equal(cancelled.status, 409)
|
||
assert.ok(cancelled.body.error)
|
||
await clearEvents('c1')
|
||
})
|