Abo-Abgleich: Abo endet vor der Einrichtung ⇒ abgeschaltet, T19 und K22
Terminplaner TP2 E5. Schritt 1b in gleicheAboAb: Dokumente im Zustand ordered oder setup werden bei fehlendem Wartungs-Abo unter feature-admin:<projectId> nach frischem Lesen von Dokument und Abo mit Grund abo_ende_vor_einrichtung abgeschaltet. Die Meldelogik liegt in meldeAboEnde (auch für den Sofortpfad E9): bei bezahlter Einrichtung zuerst T19 über meldeErstattung (außerhalb jeder feature-admin-Sperre), dann K22 mit Block vor_einrichtung, dann der Marker aboEndeMailAt; scheitert T19, folgen weder K22 noch Marker und der nächste Tag wiederholt beides. Ein unbezahltes ordered-Dokument wird nur abgeschaltet. Schritt 2 holt auch abo_ende_vor_einrichtung nach. Die Stripe-Sitzung und das Ticket bleiben unangetastet. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Sonnet 5.5 committed
1 parent
17f933dbc7
commit
addb88d5fd
2 files changed
+450
-43
No files matched your search
@@ -5,9 +5,10 @@ import { mailSink } from './support/mailSink.js'
|
||||
import { schemaKeys } from './support/schema.js'
|
||||
import { useTestEnv } from './support/testEnv.js'
|
||||
|
||||
// Abo-Abgleich des Terminplaners (server/services/termine/aboAbgleich.js, Terminplaner TP2 E4): aktive Terminplaner ohne laufendes
|
||||
// Wartungs-Abo abschalten (Schritt 1) und die Mail K22 nachholen (Schritt 2). Aufbau wie termineJobs.test.js: Nachbau von
|
||||
// Appwrite mit Schema und Standard-Limit 25, Mails in der Senke, feste Zeit JETZT. Stripe wird nie erreicht (Port 1).
|
||||
// Abo-Abgleich des Terminplaners (server/services/termine/aboAbgleich.js, Terminplaner TP2 E4/E5): aktive Terminplaner ohne laufendes
|
||||
// Wartungs-Abo abschalten (Schritt 1), Einrichtungen, die das Abo-Ende erreicht, abschalten und erstatten (Schritt 1b, E5) und die
|
||||
// Mail K22 nachholen (Schritt 2). Aufbau wie termineJobs.test.js: Nachbau von Appwrite mit Schema und Standard-Limit 25, Mails in
|
||||
// der Senke, feste Zeit JETZT. Stripe wird nie erreicht (Port 1).
|
||||
const aw = await startAppwriteMock({
|
||||
schema: {
|
||||
portalFeatures: schemaKeys('portalFeatures'),
|
||||
@@ -25,7 +26,7 @@ const { subscriptionDoc, hostingDoc, wartungDoc } = await import('./support/fixt
|
||||
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
||||
const { setMailTransportForTests } = await import('../server/services/mailer.js')
|
||||
const { withLocks } = await import('../server/services/keyedLock.js')
|
||||
const { disable } = await import('../server/services/siteFeatures.js')
|
||||
const { disable, activateClosedTickets, handleFeatureCheckoutEvent } = await import('../server/services/siteFeatures.js')
|
||||
const { gleicheAboAb, meldeAboEnde } = await import('../server/services/termine/aboAbgleich.js')
|
||||
after(() => setMailTransportForTests(null))
|
||||
|
||||
@@ -42,7 +43,7 @@ let sink
|
||||
let log
|
||||
|
||||
beforeEach(async () => {
|
||||
for (const collection of ['portalFeatures', 'subscriptions', 'contractEvents', 'termineConfig', 'customers', 'websiteProjects']) {
|
||||
for (const collection of ['portalFeatures', 'subscriptions', 'contractEvents', 'termineConfig', 'customers', 'websiteProjects', 'workorders']) {
|
||||
for (const id of aw.docs(collection).keys()) await deleteDocument(collection, id)
|
||||
}
|
||||
aw.resetListCalls()
|
||||
@@ -85,6 +86,26 @@ function legeFunktion(nr = 1, over = {}, { projekt = 'Praxis Muster', kunde = KU
|
||||
}
|
||||
const funktion = (id = F1) => aw.docs('portalFeatures').get(id)
|
||||
|
||||
const T19_BETREFF = '[Abo] Erstattung fällig: Terminplaner-Einrichtung'
|
||||
const K22_BETREFF = /^Dein Terminplaner wurde beendet/
|
||||
|
||||
/** Bezahlte Einrichtung im Aufbau (setup): Sitzung cs_test_1, Rechnungslink, offenes Ticket WO-4711 (Dokument t_<nr> in workorders). */
|
||||
function legeAufbau(nr = 1, over = {}) {
|
||||
aw.seed('workorders', { $id: `t_${nr}`, woid: 'WO-4711', status: 'Open', topic: 'Terminplaner einbauen – Praxis Muster' })
|
||||
return legeFunktion(nr, {
|
||||
state: 'setup',
|
||||
enabled: false,
|
||||
stripeSessionId: 'cs_test_1',
|
||||
stripeInvoiceId: 'in_1',
|
||||
invoiceUrl: 'https://invoice.stripe.test/in_1',
|
||||
ticketId: `t_${nr}`,
|
||||
...over,
|
||||
})
|
||||
}
|
||||
/** Bestellung ohne Zahlung (ordered): die Stripe-Sitzung ist offen, unlockedByPurchase fehlt. */
|
||||
const legeBestellung = (nr = 1, over = {}) =>
|
||||
legeFunktion(nr, { state: 'ordered', enabled: false, unlockedByPurchase: false, purchaseStatus: 'ordered', stripeSessionId: 'cs_test_1', ...over })
|
||||
|
||||
/** Wartungs-Abo von KUNDE (ersetzt nichts: ein einziges Abo-Dokument je Test). */
|
||||
const wartung = (status, over = {}) => aw.seed('subscriptions', subscriptionDoc('sub_w', { ...wartungDoc, customerId: KUNDE, status, ...over }))
|
||||
const hosting = (status = 'active', over = {}) => aw.seed('subscriptions', subscriptionDoc('sub_h', { ...hostingDoc, customerId: KUNDE, status, ...over }))
|
||||
@@ -103,6 +124,8 @@ const ERGEBNIS_LEER = { geprueft: 0, abgeschaltet: 0, wiederEin: 0, mails: 0, au
|
||||
const ergebnis = (over) => ({ ...ERGEBNIS_LEER, ...over })
|
||||
|
||||
const mails = () => sink.sent
|
||||
const t19 = () => mails().filter((m) => m.subject === T19_BETREFF)
|
||||
const k22 = () => mails().filter((m) => K22_BETREFF.test(m.subject))
|
||||
const abfragenAufAbos = () => aw.listCalls('subscriptions').length
|
||||
|
||||
/**
|
||||
@@ -312,9 +335,10 @@ test('Entwuerfe (off) werden nicht gelesen: eine Abfrage mit featureKey termine
|
||||
assert.equal(abfragenAufAbos(), 0)
|
||||
})
|
||||
|
||||
test('ordered, setup und abo_ende_vor_einrichtung zaehlen als geprueft, E4 aendert daran nichts (E5 erweitert)', async () => {
|
||||
legeFunktion(1, { state: 'ordered', enabled: false })
|
||||
legeFunktion(2, { state: 'setup', enabled: false })
|
||||
test('Laeuft das Abo: ordered, setup und ein abgeschaltetes abo_ende_vor_einrichtung zaehlen als geprueft und bleiben unberuehrt (kein T19, kein K22)', async () => {
|
||||
wartung('active')
|
||||
legeBestellung(1)
|
||||
legeAufbau(2)
|
||||
legeFunktion(3, { state: 'disabled', enabled: false, disabledReason: 'abo_ende_vor_einrichtung', disabledAt: plus(JETZT, -TAG).toISOString() })
|
||||
const vorher = [1, 2, 3].map((nr) => ({ ...funktion(funktionsId(nr)) }))
|
||||
assert.deepEqual(await laufe(), ergebnis({ geprueft: 3 }))
|
||||
@@ -573,3 +597,339 @@ test('meldeAboEnde: unbekannter Projektname faellt auf "Dein Projekt" zurueck, e
|
||||
assert.ok(!funktion(id2).aboEndeMailAt)
|
||||
assert.equal(mails().length, 1)
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Schritt 1b: Abo endet vor der Einrichtung (E5)
|
||||
|
||||
test('Bezahlt im Aufbau (setup, Ticket) ohne Abo: abgeschaltet, ein T19 an das Team, K22 vor_einrichtung, Ticket bleibt offen, am Folgetag nichts', async () => {
|
||||
legeAufbau(1)
|
||||
const ticketVorher = { ...aw.docs('workorders').get('t_1') }
|
||||
|
||||
assert.deepEqual(await laufe(JETZT), ergebnis({ geprueft: 1, abgeschaltet: 1, mails: 1 }))
|
||||
const doc = funktion()
|
||||
assert.equal(doc.state, 'disabled')
|
||||
assert.equal(doc.enabled, false)
|
||||
assert.equal(doc.disabledReason, 'abo_ende_vor_einrichtung')
|
||||
assert.equal(ms(doc.disabledAt), JETZT.getTime())
|
||||
assert.equal(doc.adminNote, 'Abgeschaltet: Wartungs-Abo endete vor der Einrichtung')
|
||||
assert.equal(doc.purchaseStatus, 'paid', 'die Zahlung bleibt gebucht')
|
||||
assert.equal(doc.zahlungMeldung, 'gemeldet', 'T19 ist raus')
|
||||
assert.equal(doc.stripeSessionId, 'cs_test_1')
|
||||
assert.equal(ms(doc.aboEndeMailAt), JETZT.getTime(), 'Marker erst nach T19 und K22')
|
||||
|
||||
// T19: genau einmal, an das Team, mit Kunde, Projekt, Sitzung, Rechnungslink und Ticketnummer
|
||||
assert.equal(t19().length, 1)
|
||||
const mailT19 = t19()[0]
|
||||
assert.deepEqual(mailT19.to.map((a) => a.address).sort(), [...config.chatNotify.emails].sort())
|
||||
assert.match(mailT19.text, /Silke Müller/)
|
||||
assert.match(mailT19.text, /Praxis Muster/)
|
||||
assert.match(mailT19.text, /cs_test_1/)
|
||||
assert.ok(mailT19.html.includes('https://invoice.stripe.test/in_1'), 'Rechnungslink')
|
||||
assert.match(mailT19.text, /WO-4711/)
|
||||
assert.match(mailT19.text, /Ticket noch offen/)
|
||||
assert.doesNotMatch(mailT19.text, /Zahlung nach dem Abo-Ende/, 'die Zahlung kam vor dem Abo-Ende')
|
||||
|
||||
// K22 an den Kunden: Block vor_einrichtung mit Preis, ohne den Kasten "Was jetzt gilt"
|
||||
assert.equal(k22().length, 1)
|
||||
const mailK22 = k22()[0]
|
||||
assert.deepEqual(mailK22.to.map((a) => a.address), ['silke@example.com'])
|
||||
assert.equal(mailK22.subject, 'Dein Terminplaner wurde beendet – Praxis Muster')
|
||||
assert.match(mailK22.text, /Dein Wartungs-Abo wurde am 05\.10\.2026 beendet, noch vor der Einrichtung Deines Terminplaners/)
|
||||
assert.match(mailK22.text, /erstatten Dir die Einrichtung \(149 €\) vollständig/)
|
||||
assert.doesNotMatch(mailK22.text, /Was jetzt gilt|löschen wir|Hosting-Abo|weil Dein Wartungs-Abo/, 'kein Loeschkasten, nicht die anderen Gruende')
|
||||
assert.deepEqual(mails().map((m) => m.subject === T19_BETREFF), [true, false], 'zuerst T19, dann K22')
|
||||
|
||||
// das Ticket wird nicht angefasst
|
||||
assert.deepEqual(aw.docs('workorders').get('t_1'), ticketVorher)
|
||||
assert.equal(aw.docs('workorders').get('t_1').status, 'Open')
|
||||
|
||||
// zweiter Lauf: weder T19 noch K22, nichts geaendert
|
||||
const vorher = { ...funktion() }
|
||||
assert.deepEqual(await laufe(plus(JETZT, TAG)), ergebnis({ geprueft: 1 }))
|
||||
assert.deepEqual(funktion(), vorher)
|
||||
assert.equal(t19().length, 1)
|
||||
assert.equal(k22().length, 1)
|
||||
})
|
||||
|
||||
test('T19 schlaegt fehl: abgeschaltet, kein Marker, kein K22, fehler; der naechste Lauf sendet T19 und danach K22, spaetere Stripe-Ereignisse kein zweites T19', async () => {
|
||||
legeAufbau(1)
|
||||
setMailTransportForTests({
|
||||
sendMail: async (mail) => {
|
||||
if (mail.subject === T19_BETREFF) throw new Error('Verbindung abgebrochen')
|
||||
return sink.sendMail(mail)
|
||||
},
|
||||
})
|
||||
assert.deepEqual(await laufe(JETZT), ergebnis({ geprueft: 1, abgeschaltet: 1, fehler: 1 }))
|
||||
let doc = funktion()
|
||||
assert.equal(doc.state, 'disabled', 'abgeschaltet wird trotzdem')
|
||||
assert.equal(doc.disabledReason, 'abo_ende_vor_einrichtung')
|
||||
assert.ok(!doc.zahlungMeldung, 'Marker gemeldet erst nach gesendetem T19')
|
||||
assert.ok(!doc.aboEndeMailAt, 'Marker aboEndeMailAt erst nach T19 und K22')
|
||||
assert.equal(doc.purchaseStatus, 'paid')
|
||||
assert.equal(mails().length, 0, 'auch K22 ging nicht (T19 zuerst)')
|
||||
const disabledAt = doc.disabledAt
|
||||
|
||||
setMailTransportForTests(sink)
|
||||
const naechster = plus(JETZT, TAG)
|
||||
assert.deepEqual(await laufe(naechster), ergebnis({ geprueft: 1, mails: 1 }))
|
||||
assert.equal(t19().length, 1)
|
||||
assert.equal(k22().length, 1)
|
||||
assert.deepEqual(mails().map((m) => m.subject === T19_BETREFF), [true, false], 'T19 vor K22')
|
||||
assert.match(k22()[0].text, /am 05\.10\.2026 beendet/, 'Enddatum aus disabledAt, nicht vom Folgetag')
|
||||
doc = funktion()
|
||||
assert.equal(doc.zahlungMeldung, 'gemeldet')
|
||||
assert.equal(doc.purchaseStatus, 'paid')
|
||||
assert.equal(ms(doc.aboEndeMailAt), naechster.getTime())
|
||||
assert.equal(doc.disabledAt, disabledAt, 'die Frist wuchs nicht')
|
||||
|
||||
assert.deepEqual(await laufe(plus(naechster, TAG)), ergebnis({ geprueft: 1 }), 'danach nie wieder')
|
||||
assert.equal(mails().length, 2)
|
||||
|
||||
// ein spaeteres Stripe-Ereignis zur selben Sitzung bucht nichts und meldet nichts mehr
|
||||
await handleFeatureCheckoutEvent({
|
||||
type: 'checkout.session.async_payment_succeeded',
|
||||
data: { object: { id: 'cs_test_1', payment_status: 'paid', metadata: { customerId: KUNDE, projectId: 'p_projekt01', featureKey: 'termine' } } },
|
||||
})
|
||||
assert.equal(t19().length, 1, 'kein zweites T19')
|
||||
assert.equal(mails().length, 2)
|
||||
assert.equal(funktion().state, 'disabled')
|
||||
})
|
||||
|
||||
test('T19 schlaegt fehl und K22 wuerde gehen: K22 wird nicht vorgezogen (Reihenfolge T19, K22, Marker), fehler zaehlt je Lauf', async () => {
|
||||
legeAufbau(1)
|
||||
setMailTransportForTests({
|
||||
sendMail: async (mail) => {
|
||||
if (mail.subject === T19_BETREFF) throw new Error('Verbindung abgebrochen')
|
||||
return sink.sendMail(mail)
|
||||
},
|
||||
})
|
||||
assert.deepEqual(await laufe(JETZT), ergebnis({ geprueft: 1, abgeschaltet: 1, fehler: 1 }))
|
||||
assert.deepEqual(await laufe(plus(JETZT, TAG)), ergebnis({ geprueft: 1, fehler: 1 }), 'auch der zweite Tag scheitert an T19')
|
||||
assert.equal(k22().length, 0)
|
||||
assert.ok(!funktion().aboEndeMailAt)
|
||||
assert.ok(!funktion().zahlungMeldung)
|
||||
})
|
||||
|
||||
test('Unbezahltes ordered ohne Abo: abgeschaltet, kein T19, kein K22, kein Marker, Sitzung unveraendert, auch am Folgetag nichts', async () => {
|
||||
legeBestellung(1)
|
||||
assert.deepEqual(await laufe(JETZT), ergebnis({ geprueft: 1, abgeschaltet: 1 }))
|
||||
const doc = funktion()
|
||||
assert.equal(doc.state, 'disabled')
|
||||
assert.equal(doc.enabled, false)
|
||||
assert.equal(doc.disabledReason, 'abo_ende_vor_einrichtung')
|
||||
assert.equal(doc.adminNote, 'Abgeschaltet: Wartungs-Abo endete vor der Einrichtung')
|
||||
assert.ok(!doc.aboEndeMailAt, 'kein Marker')
|
||||
assert.ok(!doc.zahlungMeldung)
|
||||
assert.equal(doc.stripeSessionId, 'cs_test_1', 'die offene Stripe-Sitzung wird nicht angefasst')
|
||||
assert.equal(doc.purchaseStatus, 'ordered')
|
||||
assert.equal(doc.unlockedByPurchase, false)
|
||||
assert.equal(mails().length, 0)
|
||||
|
||||
const vorher = { ...funktion() }
|
||||
assert.deepEqual(await laufe(plus(JETZT, TAG)), ergebnis({ geprueft: 1 }))
|
||||
assert.deepEqual(funktion(), vorher, 'kein Schreibzugriff')
|
||||
assert.equal(mails().length, 0)
|
||||
})
|
||||
|
||||
test('Unbezahltes ordered, danach trifft die Zahlung ein: das Webhook-Ereignis meldet T19 genau einmal (nach dem Abo-Ende), der naechste Lauf sendet K22 vor_einrichtung', async () => {
|
||||
legeBestellung(1)
|
||||
await laufe(JETZT)
|
||||
assert.equal(mails().length, 0)
|
||||
|
||||
await handleFeatureCheckoutEvent({
|
||||
type: 'checkout.session.completed',
|
||||
data: { object: { id: 'cs_test_1', payment_status: 'paid', metadata: { customerId: KUNDE, projectId: 'p_projekt01', featureKey: 'termine' } } },
|
||||
})
|
||||
assert.equal(t19().length, 1)
|
||||
assert.match(t19()[0].text, /Zahlung nach dem Abo-Ende/)
|
||||
assert.equal(funktion().state, 'disabled')
|
||||
assert.equal(funktion().unlockedByPurchase, true)
|
||||
assert.equal(funktion().zahlungMeldung, 'gemeldet')
|
||||
assert.equal(k22().length, 0, 'K22 gehoert dem Abgleich')
|
||||
|
||||
assert.deepEqual(await laufe(plus(JETZT, TAG)), ergebnis({ geprueft: 1, mails: 1 }))
|
||||
assert.equal(t19().length, 1, 'kein zweites T19')
|
||||
assert.equal(k22().length, 1)
|
||||
assert.match(k22()[0].text, /noch vor der Einrichtung Deines Terminplaners/)
|
||||
assert.ok(funktion().aboEndeMailAt)
|
||||
assert.deepEqual(await laufe(plus(JETZT, 2 * TAG)), ergebnis({ geprueft: 1 }))
|
||||
assert.equal(mails().length, 2)
|
||||
})
|
||||
|
||||
test('setup ohne ticketId ("Ticket fehlt"): T19 ohne den Block ticket_offen, K22 vor_einrichtung', async () => {
|
||||
legeAufbau(1, { ticketId: '' })
|
||||
assert.deepEqual(await laufe(), ergebnis({ geprueft: 1, abgeschaltet: 1, mails: 1 }))
|
||||
assert.equal(t19().length, 1)
|
||||
assert.doesNotMatch(t19()[0].text, /Ticket noch offen/)
|
||||
assert.doesNotMatch(t19()[0].text, /WO-4711/)
|
||||
assert.equal(k22().length, 1)
|
||||
assert.equal(funktion().zahlungMeldung, 'gemeldet')
|
||||
})
|
||||
|
||||
for (const status of ['past_due', 'trialing', 'active']) {
|
||||
test(`Abo ${status}: ordered und setup bleiben unberuehrt, keine Mail`, async () => {
|
||||
legeBestellung(1)
|
||||
legeAufbau(2)
|
||||
wartung(status)
|
||||
const vorher = [1, 2].map((nr) => ({ ...funktion(funktionsId(nr)) }))
|
||||
assert.deepEqual(await laufe(), ergebnis({ geprueft: 2 }))
|
||||
assert.deepEqual([1, 2].map((nr) => funktion(funktionsId(nr))), vorher)
|
||||
assert.equal(mails().length, 0)
|
||||
})
|
||||
}
|
||||
|
||||
test('Lesefehler beim Abo: ordered und setup bleiben unberuehrt, fehler 1; der naechste Lauf schaltet ab (auch beim Fehler der frischen Pruefung)', async () => {
|
||||
legeBestellung(1)
|
||||
legeAufbau(2)
|
||||
aw.failNext({ collection: 'subscriptions', method: 'GET', status: 500 })
|
||||
assert.deepEqual(await laufe(), ergebnis({ fehler: 1 }))
|
||||
assert.deepEqual([funktion(funktionsId(1)).state, funktion(funktionsId(2)).state], ['ordered', 'setup'])
|
||||
assert.equal(mails().length, 0)
|
||||
|
||||
aw.failNext({ collection: 'subscriptions', method: 'GET', status: 500, after: 1 }) // Vorauswahl ok, die frische Pruefung des ersten Dokuments scheitert
|
||||
const zweiter = await laufe(plus(JETZT, TAG))
|
||||
assert.equal(zweiter.fehler, 1)
|
||||
assert.equal(zweiter.abgeschaltet, 1, 'das andere Dokument kommt dran')
|
||||
|
||||
const dritter = await laufe(plus(JETZT, 2 * TAG))
|
||||
assert.equal(dritter.fehler, 0)
|
||||
assert.deepEqual([funktion(funktionsId(1)).state, funktion(funktionsId(2)).state], ['disabled', 'disabled'])
|
||||
assert.equal(t19().length, 1, 'T19 nur fuer die bezahlte Einrichtung')
|
||||
assert.equal(k22().length, 1)
|
||||
})
|
||||
|
||||
test('Rennen: das Abo kommt zwischen Vorauswahl und Sperre zurueck - ordered und setup bleiben, nichts wird gesendet', async () => {
|
||||
legeBestellung(1)
|
||||
legeAufbau(2)
|
||||
const erg = await mitEinwurf(liste('subscriptions'), async () => wartung('active'), () => laufe())
|
||||
assert.deepEqual(erg, ergebnis({ geprueft: 2 }))
|
||||
assert.deepEqual([funktion(funktionsId(1)).state, funktion(funktionsId(2)).state], ['ordered', 'setup'])
|
||||
assert.equal(mails().length, 0)
|
||||
})
|
||||
|
||||
test('Rennen: das Team aktiviert zwischen Liste und Sperre - das frisch gelesene Dokument ist active, Schritt 1b greift nicht', async () => {
|
||||
legeAufbau(1)
|
||||
const erg = await mitEinwurf(
|
||||
liste('portalFeatures'),
|
||||
async () => aw.seed('portalFeatures', { ...funktion(), state: 'active', enabled: true }),
|
||||
() => laufe(),
|
||||
)
|
||||
assert.deepEqual(erg, ergebnis({ geprueft: 1 }))
|
||||
assert.equal(funktion().state, 'active')
|
||||
assert.equal(funktion().disabledReason, undefined)
|
||||
assert.equal(mails().length, 0)
|
||||
})
|
||||
|
||||
test('Review Focus 1, nie ohne Spur: das Ticket wird nach dem Abo-Ende geschlossen - activateClosedTickets aktiviert das abgeschaltete Dokument nicht', async () => {
|
||||
legeAufbau(1)
|
||||
assert.deepEqual(await laufe(), ergebnis({ geprueft: 1, abgeschaltet: 1, mails: 1 }))
|
||||
assert.equal(t19().length, 1, 'die Spur: T19 mit dem offenen Ticket')
|
||||
|
||||
aw.seed('workorders', { ...aw.docs('workorders').get('t_1'), status: 'Closed' })
|
||||
assert.deepEqual(await activateClosedTickets({ now: plus(JETZT, TAG) }), [])
|
||||
const doc = funktion()
|
||||
assert.equal(doc.state, 'disabled')
|
||||
assert.equal(doc.disabledReason, 'abo_ende_vor_einrichtung')
|
||||
assert.equal(doc.enabled, false)
|
||||
assert.equal(mails().length, 2, 'keine weitere Mail')
|
||||
})
|
||||
|
||||
test('abo_ende_vor_einrichtung-Dokument mit Abo-Rueckkehr: bleibt wie es ist (die Rueckkehr gilt nur fuer abo_ende)', async () => {
|
||||
legeFunktion(1, { state: 'disabled', enabled: false, disabledReason: 'abo_ende_vor_einrichtung', disabledAt: plus(JETZT, -TAG).toISOString() })
|
||||
wartung('active')
|
||||
const vorher = { ...funktion() }
|
||||
assert.deepEqual(await laufe(), ergebnis({ geprueft: 1 }))
|
||||
assert.deepEqual(funktion(), vorher)
|
||||
assert.equal(mails().length, 0)
|
||||
})
|
||||
|
||||
test('Unbezahltes, abgeschaltetes abo_ende_vor_einrichtung-Dokument wird taeglich uebergangen: kein Schreibzugriff, keine Mail', async () => {
|
||||
legeBestellung(1, { state: 'disabled', disabledReason: 'abo_ende_vor_einrichtung', disabledAt: plus(JETZT, -3 * TAG).toISOString() })
|
||||
const vorher = { ...funktion() }
|
||||
assert.deepEqual(await laufe(), ergebnis({ geprueft: 1 }))
|
||||
assert.deepEqual(funktion(), vorher)
|
||||
assert.equal(mails().length, 0)
|
||||
assert.equal(abfragenAufAbos(), 1, 'nur die Vorauswahl: fuer das Dokument ohne Aufgabe gibt es keine frische Pruefung unter der Sperre')
|
||||
})
|
||||
|
||||
test('Mehrere Projekte: bezahlter Aufbau, unbezahlte Bestellung und aktiver Terminplaner eines Kunden - je Dokument das Richtige', async () => {
|
||||
legeFunktion(1, {}, { projekt: 'Projekt Alpha' }) // aktiv
|
||||
legeAufbau(2)
|
||||
legeBestellung(3)
|
||||
assert.deepEqual(await laufe(), ergebnis({ geprueft: 3, abgeschaltet: 3, mails: 2 }))
|
||||
assert.equal(funktion(funktionsId(1)).disabledReason, 'abo_ende')
|
||||
assert.equal(funktion(funktionsId(2)).disabledReason, 'abo_ende_vor_einrichtung')
|
||||
assert.equal(funktion(funktionsId(3)).disabledReason, 'abo_ende_vor_einrichtung')
|
||||
assert.equal(t19().length, 1, 'T19 nur fuer die bezahlte Einrichtung')
|
||||
assert.equal(k22().length, 2, 'K22 fuer den aktiven (abo_ende) und den bezahlten Aufbau (vor_einrichtung)')
|
||||
assert.ok(!funktion(funktionsId(3)).aboEndeMailAt)
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- meldeAboEnde fuer abo_ende_vor_einrichtung (der Aufruf, den E9 nutzt)
|
||||
|
||||
test('meldeAboEnde direkt: bezahltes Dokument mit Grund abo_ende_vor_einrichtung - ein T19, ein K22 vor_einrichtung, Marker, true; zweiter Aufruf nichts', async () => {
|
||||
const id = legeAufbau(1, { state: 'disabled', disabledReason: 'abo_ende_vor_einrichtung', disabledAt: JETZT.toISOString() })
|
||||
const lage = { laeuft: false, art: 'beendet', endedAt: null }
|
||||
let gesendet = 0
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: JETZT, onGesendet: () => (gesendet += 1) }), true)
|
||||
assert.equal(t19().length, 1)
|
||||
assert.equal(k22().length, 1)
|
||||
assert.match(k22()[0].text, /noch vor der Einrichtung Deines Terminplaners/)
|
||||
assert.deepEqual(mails().map((m) => m.subject === T19_BETREFF), [true, false])
|
||||
assert.equal(gesendet, 1, 'onGesendet zaehlt K22')
|
||||
assert.equal(ms(funktion(id).aboEndeMailAt), JETZT.getTime())
|
||||
assert.equal(funktion(id).zahlungMeldung, 'gemeldet')
|
||||
assert.equal(funktion(id).purchaseStatus, 'paid')
|
||||
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: plus(JETZT, TAG) }), true)
|
||||
assert.equal(mails().length, 2, 'zweiter Aufruf: weder T19 noch K22')
|
||||
assert.equal(ms(funktion(id).aboEndeMailAt), JETZT.getTime(), 'Marker unveraendert')
|
||||
})
|
||||
|
||||
test('meldeAboEnde direkt: unbezahltes ordered-Dokument - weder T19 noch K22 noch Marker, true, Dokument unveraendert', async () => {
|
||||
const id = legeBestellung(1, { state: 'disabled', disabledReason: 'abo_ende_vor_einrichtung', disabledAt: JETZT.toISOString() })
|
||||
const vorher = { ...funktion(id) }
|
||||
const lage = { laeuft: false, art: 'beendet', endedAt: null }
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: JETZT }), true)
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: plus(JETZT, TAG) }), true)
|
||||
assert.equal(mails().length, 0)
|
||||
assert.deepEqual(funktion(id), vorher)
|
||||
})
|
||||
|
||||
test('meldeAboEnde direkt: T19 scheitert - false, kein K22, kein Marker; der naechste Aufruf sendet T19 und K22 in dieser Reihenfolge', async () => {
|
||||
const id = legeAufbau(1, { state: 'disabled', disabledReason: 'abo_ende_vor_einrichtung', disabledAt: JETZT.toISOString() })
|
||||
const lage = { laeuft: false, art: 'beendet', endedAt: null }
|
||||
setMailTransportForTests({ sendMail: async () => { throw new Error('Verbindung abgebrochen') } })
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: JETZT }), false)
|
||||
assert.ok(!funktion(id).zahlungMeldung)
|
||||
assert.ok(!funktion(id).aboEndeMailAt)
|
||||
|
||||
setMailTransportForTests(sink)
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: plus(JETZT, TAG) }), true)
|
||||
assert.deepEqual(mails().map((m) => m.subject === T19_BETREFF), [true, false])
|
||||
assert.ok(funktion(id).aboEndeMailAt)
|
||||
})
|
||||
|
||||
test('meldeAboEnde direkt: T19 war schon draussen (gemeldet) - kein zweites T19, K22 und Marker folgen; K22 scheitert - Marker leer, T19 nicht wiederholt', async () => {
|
||||
const id = legeAufbau(1, { state: 'disabled', disabledReason: 'abo_ende_vor_einrichtung', disabledAt: JETZT.toISOString(), zahlungMeldung: 'gemeldet' })
|
||||
const lage = { laeuft: false, art: 'beendet', endedAt: null }
|
||||
setMailTransportForTests({ sendMail: async () => { throw new Error('Verbindung abgebrochen') } })
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: JETZT }), false, 'K22 scheitert')
|
||||
assert.ok(!funktion(id).aboEndeMailAt)
|
||||
|
||||
setMailTransportForTests(sink)
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: plus(JETZT, TAG) }), true)
|
||||
assert.equal(t19().length, 0, 'T19 war schon gemeldet')
|
||||
assert.equal(k22().length, 1)
|
||||
assert.ok(funktion(id).aboEndeMailAt)
|
||||
})
|
||||
|
||||
test('meldeAboEnde direkt: bezahlt, aber Kunde nicht mehr vorhanden - T19 geht trotzdem an das Team, kein K22, Marker gesetzt', async () => {
|
||||
const id = legeAufbau(1, { state: 'disabled', disabledReason: 'abo_ende_vor_einrichtung', disabledAt: JETZT.toISOString() })
|
||||
await deleteDocument('customers', KUNDE)
|
||||
const lage = { laeuft: false, art: 'beendet', endedAt: null }
|
||||
assert.equal(await meldeAboEnde(funktion(id), { lage, now: JETZT }), true)
|
||||
assert.equal(t19().length, 1, 'das Geld hat eine Spur, auch ohne Kunden')
|
||||
assert.equal(k22().length, 0)
|
||||
assert.equal(funktion(id).zahlungMeldung, 'gemeldet')
|
||||
assert.ok(funktion(id).aboEndeMailAt, 'kein Wiederholen')
|
||||
})
|
||||
Reference in new issue
Block a user