From c35711caad18f64698c83726e622ca4ccc1c324d Mon Sep 17 00:00:00 2001 From: Claude Date: Sun, 4 Oct 2026 09:54:11 +0000 Subject: [PATCH] Terminplaner: Mailkontingent je Funktion, Vorrang-Reserve und kleinere Haltungsgrenze Co-Authored-By: Claude Sonnet 5.5 --- server/config.js | 5 + server/services/termine/limits.js | 7 +- server/services/termine/outbox.js | 132 ++++++++++++++----- test/publicTermine.test.js | 10 +- test/termineLimits.test.js | 6 +- test/termineOutbox.test.js | 210 +++++++++++++++++++++++++++++- test/termineSchalter.test.js | 2 + 7 files changed, 330 insertions(+), 42 deletions(-) diff --git a/server/config.js b/server/config.js index ba54d8e..e1921d0 100644 --- a/server/config.js +++ b/server/config.js @@ -386,6 +386,11 @@ export const config = { holdMinutes: 30, zelleMin: 5, mailsProStunde: 200, + // Mail-Fairness (outbox.js): hoechstens so viele Mails je Funktion und Stunde (gleitendes Fenster, unter mailsProStunde) + mailsProFunktion: 40, + // Anteil der Stunde, der Vorrang- und Normal-Mails vorbehalten bleibt: nachrangige Mails (G05, K20, K21) nehmen hoechstens + // max(1, floor(mailsProStunde x (1 - mailsReserve))) Plaetze + mailsReserve: 0.25, // Hoechstens so viele Buchungen loescht ein Schritt der Aufbewahrungs-Loeschung je Lauf (Tagesjob): je Status, bei erledigt und // nichterschienen zusammen je Funktion; der Rest folgt am naechsten Tag loeschDeckel: 2000, diff --git a/server/services/termine/limits.js b/server/services/termine/limits.js index bda2b60..a2f088e 100644 --- a/server/services/termine/limits.js +++ b/server/services/termine/limits.js @@ -41,7 +41,7 @@ const ANFRAGEN_JE_SITE = 600 /** Buchungsversuche (jedes POST auf /buchungen, auch Honeypot): je IP und 10 Minuten; gehaltene Termine: je siteKey und Stunde. */ const BUCHUNGEN_JE_IP = 10 const BUCHUNGEN_FENSTER_MS = 10 * MINUTE_MS -const HALTUNGEN_JE_SITE = 60 +const HALTUNGEN_JE_SITE = 25 /** Widerrufserklaerungen: je IP und Stunde. */ const WIDERRUFE_JE_IP = 10 /** G01 (Bestaetigungsmail, auch "zu viele"): je Adresse und Funktion und Tag. */ @@ -182,7 +182,10 @@ export function darfBuchungsversuch(ip, now) { return zaehle(`ip:buchung:${ipSchluessel(ip)}`, BUCHUNGEN_JE_IP, BUCHUNGEN_FENSTER_MS, now) } -/** Darf diese Funktion (siteKey) jetzt einen weiteren Termin halten? Hoechstens 60 je Stunde. */ +/** + * Darf diese Funktion (siteKey) jetzt einen weiteren Termin halten? Hoechstens 25 je Stunde: so loest eine Funktion hoechstens 25 G01 + * je Stunde aus, unter dem Mailkontingent je Funktion (config.termine.mailsProFunktion, outbox.js). + */ export function darfHaltung(siteKey, now) { return zaehle(`haltung-site:${siteKey}`, HALTUNGEN_JE_SITE, STUNDE_MS, now) } diff --git a/server/services/termine/outbox.js b/server/services/termine/outbox.js index ba8d159..628dd80 100644 --- a/server/services/termine/outbox.js +++ b/server/services/termine/outbox.js @@ -24,9 +24,16 @@ import { pruefeNow, pruefeText, zeitMs } from './util.js' * den vorhandenen Index idx_status_next (status, naechsterVersuch); ein eigenes Fehlerdatum gibt es im Schema nicht. * * Stundenbudget (config.termine.mailsProStunde) und Anmeldepause sind Zustand dieses Prozesses: gleitendes Fenster der - * Sendezeitpunkte bzw. ein Zeitpunkt. Ein Platz wird vor dem Senden belegt (gleichzeitige Versuche koennen das Budget - * nicht ueberziehen) und bei einem Fehlschlag wieder freigegeben. `now` ist immer ein Parameter (feste Uhr in Tests); - * ohne Angabe gilt bei einreihen und sendeEintrag die Wanduhr. + * belegten Plaetze { t, f, n } (Zeit, Funktion, nachrangig) bzw. ein Zeitpunkt. Ein Platz wird vor dem Senden belegt + * (gleichzeitige Versuche koennen das Budget nicht ueberziehen) und bei einem Fehlschlag wieder freigegeben. `now` ist + * immer ein Parameter (feste Uhr in Tests); ohne Angabe gilt bei einreihen und sendeEintrag die Wanduhr. + * + * Fairness (pruefePlatz, in dieser Reihenfolge; der Eintrag bleibt dann unveraendert `wartet`, kein Versuch): + * pause Anmeldepause laeuft + * budget Plaetze im Fenster >= mailsProStunde + * reserve nachrangige Mails (G05, K20, K21) im Fenster >= max(1, floor(mailsProStunde x (1 - mailsReserve))): so bleibt + * ein Teil der Stunde den Vorrang-Mails (G01, G02, G08) und den normalen Mails vorbehalten + * kontingent Mails dieser Funktion im Fenster >= mailsProFunktion: eine Funktion kann die Stunde nicht allein fuellen */ const col = () => config.collections.termineOutbox @@ -47,35 +54,91 @@ const ID_BLOCK = 50 const iso = (wertMs) => new Date(wertMs).toISOString() +/** Mails, die vor allen anderen rausgehen duerfen (Bestaetigung, Termin, Eingangsbestaetigung des Widerrufs). */ +export const MAIL_VORRANG = Object.freeze(['G01', 'G02', 'G08']) +/** Mails, die zuerst warten (Erinnerung, Hinweise an den Betrieb): sie nehmen nie die ganze Stunde. */ +export const MAIL_NACHRANGIG = Object.freeze(['G05', 'K20', 'K21']) + +/** 'vorrang' | 'normal' | 'nachrangig' nach der Art (Vorlagen-ID) der Mail. */ +export function mailKlasse(art) { + if (MAIL_VORRANG.includes(art)) return 'vorrang' + if (MAIL_NACHRANGIG.includes(art)) return 'nachrangig' + return 'normal' +} + // Zustand des Prozesses let pauseBisMs = 0 -/** Zeitpunkte (ms) der Sendeversuche im letzten Stundenfenster (belegte Plaetze). */ -let sendeZeiten = [] +/** Belegte Plaetze im letzten Stundenfenster: { t: Sendezeit (ms), f: featureId, n: nachrangig }. */ +let plaetze = [] /** Laufende sendeEintrag-Aufrufe (fuer warteAufVersand). */ const laufend = new Set() /** Eintraege, die schon rausgingen, deren Ergebnis aber nicht gespeichert werden konnte: id => Versandzeitpunkt (ms). */ const unverbucht = new Map() -/** Anzahl freier Plaetze im Stundenbudget zum Zeitpunkt nowMs; raeumt abgelaufene Plaetze aus dem Fenster. */ -function freieBudgetPlaetze(nowMs) { - const grenze = nowMs - STUNDE_MS - sendeZeiten = sendeZeiten.filter((zeit) => zeit > grenze) - return Math.max(0, config.termine.mailsProStunde - sendeZeiten.length) +/** Die Plaetze, die zum Zeitpunkt nowMs noch im Stundenfenster stehen (nur lesen; ein Platz laeuft 60 Minuten nach dem Versand ab). */ +const imFenster = (nowMs) => plaetze.filter((platz) => platz.t > nowMs - STUNDE_MS) + +/** Hoechstens so viele nachrangige Mails (G05, K20, K21) im Stundenfenster; die Toleranz faengt Fliesskommafehler wie 100 x 0.58 ab. */ +const nachrangigMax = () => Math.max(1, Math.floor(config.termine.mailsProStunde * (1 - config.termine.mailsReserve) + 1e-9)) + +/** 'pause' | 'budget' | null: die Bremsen, die fuer jede Mail gelten (nur lesen). */ +function gesamtBremse(nowMs) { + if (pauseBisMs > nowMs) return 'pause' + if (imFenster(nowMs).length >= config.termine.mailsProStunde) return 'budget' + return null } -/** Pause oder ausgeschoepftes Budget (nur lesen). */ -const gebremst = (nowMs) => pauseBisMs > nowMs || freieBudgetPlaetze(nowMs) === 0 - -/** Belegt einen Platz im Budget (synchron, ohne Zwischenschritt); false bei Pause oder leerem Budget. */ -function belegePlatz(nowMs) { - if (gebremst(nowMs)) return false - sendeZeiten.push(nowMs) - return true +/** + * Darf eine Mail dieser Funktion und Art zum Zeitpunkt nowMs raus? null = ja, sonst der erste Grund (siehe Kopfkommentar): + * 'pause' | 'budget' | 'reserve' | 'kontingent'. Nur lesen: belegt keinen Platz. + * @param {number} nowMs + * @param {string} featureId + * @param {string} art Vorlagen-ID der Mail ('G01' ... 'K21') + * @returns {null|'pause'|'budget'|'reserve'|'kontingent'} + */ +export function pruefePlatz(nowMs, featureId, art) { + const bremse = gesamtBremse(nowMs) + if (bremse) return bremse + const fenster = imFenster(nowMs) + if (mailKlasse(art) === 'nachrangig' && fenster.filter((platz) => platz.n).length >= nachrangigMax()) return 'reserve' + if (fenster.filter((platz) => platz.f === featureId).length >= config.termine.mailsProFunktion) return 'kontingent' + return null } -function gibPlatzFrei(nowMs) { - const stelle = sendeZeiten.indexOf(nowMs) - if (stelle >= 0) sendeZeiten.splice(stelle, 1) +/** Belegt einen Platz (synchron, ohne Zwischenschritt); der Platz oder null, wenn pruefePlatz einen Grund nennt. */ +function belegePlatz(nowMs, featureId, art) { + if (pruefePlatz(nowMs, featureId, art) !== null) return null + const platz = { t: nowMs, f: featureId, n: mailKlasse(art) === 'nachrangig' } + plaetze = [...imFenster(nowMs), platz] + return platz +} + +function gibPlatzFrei(platz) { + plaetze = plaetze.filter((belegt) => belegt !== platz) +} + +/** + * Stand des Mailbudgets zum Zeitpunkt now (fuer die Betriebspruefung und die Statusroute): nur Zahlen und Funktions-IDs, + * nie eine Adresse. `spitzen` sind die bis zu drei Funktionen mit den meisten Mails im Fenster, die groesste zuerst. + * @param {Date} now + * @returns {{ stunde: { benutzt: number, max: number }, nachrangig: { benutzt: number, max: number }, jeFunktionMax: number, + * spitzen: Array<{ featureId: string, benutzt: number }> }} + */ +export function mailBudget(now) { + const nowMs = pruefeNow(now, 'mailBudget') + const fenster = imFenster(nowMs) + const jeFunktion = new Map() + for (const platz of fenster) jeFunktion.set(platz.f, (jeFunktion.get(platz.f) ?? 0) + 1) + const spitzen = [...jeFunktion] + .map(([featureId, benutzt]) => ({ featureId, benutzt })) + .sort((a, b) => b.benutzt - a.benutzt || (a.featureId < b.featureId ? -1 : 1)) + .slice(0, 3) + return { + stunde: { benutzt: fenster.length, max: config.termine.mailsProStunde }, + nachrangig: { benutzt: fenster.filter((platz) => platz.n).length, max: nachrangigMax() }, + jeFunktionMax: config.termine.mailsProFunktion, + spitzen, + } } /** 'dauerhaft' | 'anmeldung' | 'vorlaeufig' (siehe Kopfkommentar). */ @@ -145,12 +208,13 @@ export async function einreihen( /** * Einziger Sendepfad. Macht hoechstens einen Sendeversuch fuer den Eintrag, wenn er `wartet`, faellig ist, keine Pause - * laeuft und das Stundenbudget reicht. + * laeuft und Stundenbudget, Vorrang-Reserve und Kontingent der Funktion reichen (pruefePlatz). * @param {string} id * @param {Date} [now] * @returns {Promise<'gesendet'|'wartet'|'fehler'|'uebersprungen'>} gesendet = dieser Aufruf hat die Mail gesendet; - * wartet = Eintrag bleibt in der Warteschlange (Pause, Budget, noch nicht faellig, vorlaeufiger Fehler); fehler = dieser - * Aufruf hat ihn endgueltig scheitern lassen; uebersprungen = Eintrag fehlt oder ist schon gesendet/fehlgeschlagen + * wartet = Eintrag bleibt in der Warteschlange (Pause, Budget, Reserve, Kontingent, noch nicht faellig, vorlaeufiger + * Fehler); fehler = dieser Aufruf hat ihn endgueltig scheitern lassen; uebersprungen = Eintrag fehlt oder ist schon + * gesendet/fehlgeschlagen */ export function sendeEintrag(id, now = new Date()) { const lauf = sende(id, now).finally(() => laufend.delete(lauf)) @@ -161,7 +225,7 @@ export function sendeEintrag(id, now = new Date()) { async function sende(id, now) { const nowMs = pruefeNow(now, 'sendeEintrag') pruefeText(id, 'id') - if (gebremst(nowMs)) return 'wartet' + if (gesamtBremse(nowMs)) return 'wartet' return withLocks([`termine-mail:${id}`], async () => { let doc @@ -180,8 +244,10 @@ async function sende(id, now) { return 'gesendet' } if (new Date(doc.naechsterVersuch).getTime() > nowMs) return 'wartet' - // Der Platz wird ohne Zwischenschritt vor dem Senden belegt: gleichzeitige Versuche koennen das Budget nicht ueberziehen - if (!belegePlatz(nowMs)) return 'wartet' + // Der Platz wird ohne Zwischenschritt vor dem Senden belegt: gleichzeitige Versuche koennen Budget und Kontingent nicht + // ueberziehen. Ein gebremster Eintrag bleibt unveraendert `wartet` (kein Versuch). + const platz = belegePlatz(nowMs, doc.featureId, doc.art) + if (!platz) return 'wartet' try { await sendGuestMail({ @@ -195,7 +261,7 @@ async function sende(id, now) { icsMethod: doc.icsMethod || 'REQUEST', }) } catch (err) { - gibPlatzFrei(nowMs) + gibPlatzFrei(platz) return speichereFehlschlag(doc, err, nowMs) } await speichereGesendet(doc, nowMs) @@ -252,7 +318,8 @@ async function speichereFehlschlag(doc, err, nowMs) { } /** - * Minutenjob: sendet alle faelligen wartenden Eintraege, aelteste zuerst, bis Pause oder Stundenbudget bremsen. + * Minutenjob: sendet alle faelligen wartenden Eintraege, aelteste zuerst, bis Pause oder Stundenbudget bremsen; Eintraege, die + * Vorrang-Reserve oder Kontingent ihrer Funktion bremsen, bleiben `wartet` und die uebrigen kommen trotzdem dran. * Fehler bei einzelnen Eintraegen (z. B. Appwrite) stehen im Log und stoppen den Lauf nicht. * @param {Date} now * @returns {Promise<{ faellig: number, gesendet: number }>} @@ -264,7 +331,10 @@ export async function verarbeite(now) { faellig.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt) || (a.$id < b.$id ? -1 : 1)) let gesendet = 0 for (const eintrag of faellig) { - if (gebremst(nowMs)) break + // Pause und leeres Gesamtbudget beenden den Lauf; Reserve und Kontingent betreffen nur diesen Eintrag (ohne Lesen und Sperre) + const grund = pruefePlatz(nowMs, eintrag.featureId, eintrag.art) + if (grund === 'pause' || grund === 'budget') break + if (grund) continue try { if ((await sendeEintrag(eintrag.$id, now)) === 'gesendet') gesendet += 1 } catch (err) { @@ -395,6 +465,6 @@ export function pausiertBis() { /** Nur fuer Tests: Pause, Budgetfenster und nicht gespeicherte Versände zuruecksetzen. */ export function resetOutboxForTests() { pauseBisMs = 0 - sendeZeiten = [] + plaetze = [] unverbucht.clear() } diff --git a/test/publicTermine.test.js b/test/publicTermine.test.js index 93354c1..66970eb 100644 --- a/test/publicTermine.test.js +++ b/test/publicTermine.test.js @@ -611,19 +611,19 @@ test('die IP kommt vom Proxy: ein selbst gesetzter erster Eintrag in X-Forwarded assert.equal((await buchen({ kontakt_url: 'x' }, { ip: `192.0.2.99, ${ip}` })).status, 429, 'gezaehlt wird der letzte Eintrag (trust proxy 1)') }) -test('je siteKey 60 gehaltene Termine pro Stunde: danach 429, ohne dass eine Buchung entsteht; Honeypot-Versuche zaehlen nicht mit', async () => { +test('je siteKey 25 gehaltene Termine pro Stunde: danach 429, ohne dass eine Buchung entsteht; Honeypot-Versuche zaehlen nicht mit', async () => { await speichere() - for (let i = 0; i < 60; i += 1) assert.equal(darfHaltung(SITE_KEY, JETZT), true) + for (let i = 0; i < 25; i += 1) assert.equal(darfHaltung(SITE_KEY, JETZT), true) const res = await buchen() assert.equal(res.status, 429) assert.deepEqual(Object.keys(res.body.fehler), ['_']) assert.equal(buchungen().length, 0) resetTermineLimitsForTests() - for (let i = 0; i < 59; i += 1) assert.equal(darfHaltung(SITE_KEY, JETZT), true) + for (let i = 0; i < 24; i += 1) assert.equal(darfHaltung(SITE_KEY, JETZT), true) for (let i = 0; i < 3; i += 1) assert.equal((await buchen({ kontakt_url: 'x' }, { ip: `198.51.100.${i + 1}` })).status, 201) - assert.equal((await buchen({ zeit: '10:00' })).status, 201, 'die 60. Haltung geht noch') - assert.equal((await buchen({ zeit: '11:00', email: 'anna@example.com' })).status, 429, 'die 61. nicht') + assert.equal((await buchen({ zeit: '10:00' })).status, 201, 'die 25. Haltung geht noch') + assert.equal((await buchen({ zeit: '11:00', email: 'anna@example.com' })).status, 429, 'die 26. nicht') assert.equal(buchungen().length, 1) }) diff --git a/test/termineLimits.test.js b/test/termineLimits.test.js index cee865c..a7b2f33 100644 --- a/test/termineLimits.test.js +++ b/test/termineLimits.test.js @@ -136,7 +136,7 @@ test('darfAnfrage: 120 je IP und Minute (IPv6 je /64); darfAnfrageSite: 600 je s assert.equal(darfAnfrageSite('abcdefghijklmnop', plus(MINUTE)), true) }) -test('darfBuchungsversuch: 10 je IP und 10 Minuten (IPv6 je /64); darfHaltung: 60 je siteKey und Stunde', () => { +test('darfBuchungsversuch: 10 je IP und 10 Minuten (IPv6 je /64); darfHaltung: 25 je siteKey und Stunde', () => { assert.equal(Array.from({ length: 12 }, () => darfBuchungsversuch('203.0.113.7', T0)).filter(Boolean).length, 10) assert.equal(darfBuchungsversuch('203.0.113.7', plus(10 * MINUTE - 1)), false) assert.equal(darfBuchungsversuch('203.0.113.7', plus(10 * MINUTE)), true) @@ -148,7 +148,7 @@ test('darfBuchungsversuch: 10 je IP und 10 Minuten (IPv6 je /64); darfHaltung: 6 assert.equal(darfBuchungsversuch('2001:db8:9:9:ffff::1', T0), false, 'elf Versuche aus einer /64') resetTermineLimitsForTests() - assert.equal(Array.from({ length: 65 }, () => darfHaltung('abcdefghijklmnop', T0)).filter(Boolean).length, 60) + assert.equal(Array.from({ length: 65 }, () => darfHaltung('abcdefghijklmnop', T0)).filter(Boolean).length, 25) assert.equal(darfHaltung('bcdefghijklmnopq', T0), true) assert.equal(darfHaltung('abcdefghijklmnop', plus(STUNDE)), true) }) @@ -177,7 +177,7 @@ test('Speicher: 10 000 und mehr verschiedene IPs verdraengen keinen laufenden Za // G01 einer Adresse ausgeschoepft, eine Haltungsgrenze angebrochen for (let i = 0; i < 5; i += 1) assert.equal(darfG01('f1', 'opfer@example.com', T0), true) assert.equal(darfG01('f1', 'opfer@example.com', T0), false) - for (let i = 0; i < 60; i += 1) assert.equal(darfHaltung('abcdefghijklmnop', T0), true) + for (let i = 0; i < 25; i += 1) assert.equal(darfHaltung('abcdefghijklmnop', T0), true) assert.equal(darfG08('f1', 'opfer@example.com', T0), true) // ueber 10 000 verschiedene Quelladressen: alle drei IP-Arten diff --git a/test/termineOutbox.test.js b/test/termineOutbox.test.js index f5a0aeb..344bddd 100644 --- a/test/termineOutbox.test.js +++ b/test/termineOutbox.test.js @@ -24,6 +24,7 @@ const { loadTemplate } = await import('../server/services/mailTemplates.js') const { icsTermin } = await import('../server/services/termine/ics.js') const O = await import('../server/services/termine/outbox.js') const { einreihen, sendeEintrag, verarbeite, warteAufVersand, zustellFehler, raeumeAuf, beendeFestgefahrene, verwerfeWartende, pausiertBis, resetOutboxForTests } = O +const { MAIL_VORRANG, MAIL_NACHRANGIG, mailKlasse, pruefePlatz, mailBudget } = O after(() => setMailTransportForTests(null)) const MIN = 60000 @@ -66,6 +67,8 @@ beforeEach(async () => { for (const id of aw.docs('termineOutbox').keys()) await deleteDocument(col(), id) resetOutboxForTests() config.termine.mailsProStunde = 200 + config.termine.mailsProFunktion = 40 + config.termine.mailsReserve = 0.25 tr = fakeTransport() setMailTransportForTests(tr) // Fehler-/Warnlogs der Warteschlange abfangen (Testausgabe bleibt sauber, Logs sind pruefbar) @@ -75,6 +78,8 @@ afterEach(async () => { await warteAufVersand() mock.restoreAll() config.termine.mailsProStunde = 200 + config.termine.mailsProFunktion = 40 + config.termine.mailsReserve = 0.25 config.smtp.from = ABSENDER_VORHER }) @@ -291,6 +296,209 @@ test('Fehlversuche verbrauchen kein Stundenbudget (auch nicht Anmelde- oder Verb assert.equal((await lies(doc.$id)).status, 'gesendet') }) +// --------------------------------------------------------------------------------------------------------------------- +// Mail-Fairness: Kontingent je Funktion, Vorrang-Reserve +// --------------------------------------------------------------------------------------------------------------------- + +/** Eintrag einer bestimmten Funktion und Art (Vorlage bleibt G01: die Warteschlange prueft Art und Vorlage nicht gegeneinander). */ +const von = (featureId, art, nummer, extra = {}) => eintrag({ featureId, art, bookingId: `b_${featureId}_${art}_${nummer}`, ...extra }) + +test('mailKlasse: G01/G02/G08 vorrang, G05/K20/K21 nachrangig, alle anderen normal', () => { + assert.deepEqual(MAIL_VORRANG, ['G01', 'G02', 'G08']) + assert.deepEqual(MAIL_NACHRANGIG, ['G05', 'K20', 'K21']) + const erwartet = { G01: 'vorrang', G02: 'vorrang', G03: 'normal', G04: 'normal', G05: 'nachrangig', G06: 'normal', G07: 'normal', G08: 'vorrang', K20: 'nachrangig', K21: 'nachrangig' } + assert.deepEqual(Object.fromEntries(Object.keys(erwartet).map((art) => [art, mailKlasse(art)])), erwartet) + assert.equal(mailKlasse('unbekannt'), 'normal') +}) + +test('Kontingent je Funktion: die Funktion A bekommt 3 von 5 Mails, B ist unberührt, nach einer Stunde geht der Rest raus', async () => { + config.termine.mailsProFunktion = 3 + for (let i = 1; i <= 5; i++) await einreihen(von('f_A', 'G02', i), JETZT) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 3) + const wartendA = alle().filter((d) => d.status === 'wartet') + assert.equal(wartendA.length, 2) + for (const d of wartendA) { + assert.equal(d.versuche, 0, 'ein gebremster Eintrag ist kein Versuch') + assert.equal(d.fehler, '') + assert.ok(d.an && d.html && d.text, 'Inhalt bleibt erhalten') + assert.equal(ms(d.naechsterVersuch), JETZT.getTime()) + } + assert.equal(tr.aufrufe, 3, 'kein Transportaufruf für die gebremsten Einträge') + + for (let i = 1; i <= 2; i++) await einreihen(von('f_B', 'G02', i), plus(MIN)) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 5, 'Funktion B ist vom Kontingent von A nicht betroffen') + assert.deepEqual(alle().filter((d) => d.status === 'gesendet' && d.featureId === 'f_B').length, 2) + + assert.deepEqual(await verarbeite(plus(59 * MIN)), { faellig: 2, gesendet: 0 }, 'A steht bis 60 Minuten nach dem ersten Versand') + assert.deepEqual(await verarbeite(plus(61 * MIN)), { faellig: 2, gesendet: 2 }) + assert.equal(tr.senke.sent.length, 7) + assert.equal(alle().filter((d) => d.status === 'wartet').length, 0) +}) + +test('verarbeite überspringt Einträge einer ausgeschöpften Funktion und bedient die Funktionen dahinter (älteste zuerst)', async () => { + config.termine.mailsProFunktion = 2 + for (let i = 0; i < 4; i++) await legeAn({ featureId: 'f_A', art: 'G02', bookingId: `b_a${i}`, createdAt: plus(i * 1000).toISOString() }) + for (let i = 0; i < 2; i++) await legeAn({ featureId: 'f_B', art: 'G02', bookingId: `b_b${i}`, createdAt: plus(10000 + i * 1000).toISOString() }) + assert.deepEqual(await verarbeite(plus(MIN)), { faellig: 6, gesendet: 4 }) + const gesendet = alle().filter((d) => d.status === 'gesendet') + assert.deepEqual(gesendet.map((d) => d.bookingId).sort(), ['b_a0', 'b_a1', 'b_b0', 'b_b1']) + const wartend = alle().filter((d) => d.status === 'wartet') + assert.deepEqual(wartend.map((d) => d.bookingId).sort(), ['b_a2', 'b_a3']) + assert.ok(wartend.every((d) => d.versuche === 0)) +}) + +test('Vorrang-Reserve: nachrangige Mails (G05, K20, K21) nehmen höchstens 6 von 8 Plätzen, die letzten gehören dem Vorrang', async () => { + config.termine.mailsProStunde = 8 + for (let i = 1; i <= 10; i++) await einreihen(von('f_A', 'G05', i), JETZT) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 6) + assert.equal(alle().filter((d) => d.status === 'wartet').length, 4) + + await einreihen(von('f_A', 'G01', 1), plus(MIN)) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 7, 'Platz 7 geht an den Vorrang') + + assert.deepEqual(await verarbeite(plus(2 * MIN)), { faellig: 4, gesendet: 0 }, 'das siebte G05 wartet, obwohl noch ein Platz frei ist') + assert.equal(tr.senke.sent.length, 7) + assert.ok(alle().filter((d) => d.status === 'wartet').every((d) => d.versuche === 0 && d.html)) + + await einreihen(von('f_A', 'G08', 1), plus(3 * MIN)) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 8, 'Platz 8 geht an den Vorrang') + await einreihen(von('f_A', 'G03', 1), plus(4 * MIN)) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 8, 'das Gesamtbudget gilt weiter') + + assert.deepEqual(await verarbeite(plus(61 * MIN)), { faellig: 5, gesendet: 5 }, 'nach einer Stunde fließt alles wieder (4 G05 und die G03)') +}) + +test('Vorrang-Reserve: K20 und K21 zählen wie G05; G03/G04/G06/G07 (normal) werden von der Reserve nicht gebremst', async () => { + config.termine.mailsProStunde = 8 + await einreihen(von('f_A', 'G05', 1), JETZT) + await einreihen(von('f_A', 'K20', 1), JETZT) + await einreihen(von('f_A', 'K21', 1), JETZT) + await einreihen(von('f_A', 'G05', 2), JETZT) + await einreihen(von('f_A', 'K20', 2), JETZT) + await einreihen(von('f_A', 'K21', 2), JETZT) + await einreihen(von('f_A', 'K21', 3), JETZT) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 6, 'höchstens 6 nachrangige') + for (const art of ['G03', 'G04']) await einreihen(von('f_A', art, 1), JETZT) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 8, 'die Reserve bremst normale Mails nicht') +}) + +test('pruefePlatz: Reihenfolge Pause, Gesamtbudget, Reserve, Kontingent (nur lesen, belegt nichts)', async () => { + config.termine.mailsProStunde = 4 // nachrangig höchstens 3 + config.termine.mailsProFunktion = 2 + assert.equal(pruefePlatz(JETZT.getTime(), 'f_A', 'G01'), null) + assert.equal(pruefePlatz(JETZT.getTime(), 'f_A', 'G01'), null, 'Prüfen belegt keinen Platz') + await einreihen(von('f_A', 'G05', 1), JETZT) + await einreihen(von('f_A', 'G05', 2), JETZT) + await warteAufVersand() + assert.equal(pruefePlatz(JETZT.getTime(), 'f_A', 'G01'), 'kontingent', 'Funktion A hat 2 von 2') + assert.equal(pruefePlatz(JETZT.getTime(), 'f_A', 'G05'), 'kontingent', '2 nachrangige von höchstens 3: die Reserve greift noch nicht, das Kontingent schon') + assert.equal(pruefePlatz(JETZT.getTime(), 'f_B', 'G05'), null, '2 nachrangige von höchstens 3') + await einreihen(von('f_B', 'G05', 1), JETZT) + await warteAufVersand() + assert.equal(pruefePlatz(JETZT.getTime(), 'f_C', 'K21'), 'reserve', '3 nachrangige von höchstens 3') + assert.equal(pruefePlatz(JETZT.getTime(), 'f_C', 'G02'), null, 'Vorrang darf noch') + await einreihen(von('f_C', 'G02', 1), JETZT) + await warteAufVersand() + assert.equal(pruefePlatz(JETZT.getTime(), 'f_D', 'G01'), 'budget', '4 von 4') + assert.equal(pruefePlatz(JETZT.getTime(), 'f_D', 'G05'), 'budget', 'Gesamtbudget vor Reserve') + + tr.fehler.push(EAUTH) + await einreihen(von('f_D', 'G01', 1), plus(61 * MIN)) + await warteAufVersand() + assert.equal(pruefePlatz(plus(62 * MIN).getTime(), 'f_E', 'G01'), 'pause', 'Pause vor allem anderen') + assert.equal(pruefePlatz(plus(77 * MIN).getTime(), 'f_E', 'G01'), null, 'Pause vorbei (15 Minuten)') +}) + +test('gleitendes Fenster je Funktion: 59 Minuten nach dem Versand noch belegt, nach 60 wieder frei', async () => { + config.termine.mailsProFunktion = 1 + await einreihen(von('f_A', 'G02', 1), JETZT) + await warteAufVersand() + await einreihen(von('f_A', 'G02', 2), plus(10 * MIN)) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 1) + assert.deepEqual(await verarbeite(plus(59 * MIN)), { faellig: 1, gesendet: 0 }) + assert.equal(pruefePlatz(plus(59 * MIN).getTime(), 'f_A', 'G02'), 'kontingent') + assert.equal(pruefePlatz(plus(60 * MIN).getTime(), 'f_A', 'G02'), null) + assert.deepEqual(await verarbeite(plus(60 * MIN)), { faellig: 1, gesendet: 1 }) +}) + +test('Fehlversuche (4xx, Verbindung) und Anmeldepause belegen weder einen Gesamt- noch einen Funktionsplatz', async () => { + config.termine.mailsProFunktion = 1 + config.termine.mailsProStunde = 1 + tr.fehler.push(smtp(451), EAUTH) + const a = await einreihen(von('f_A', 'G02', 1), JETZT) + await warteAufVersand() + assert.equal((await lies(a.$id)).versuche, 1) + assert.equal(mailBudget(JETZT).stunde.benutzt, 0, '4xx belegt nichts') + await verarbeite(plus(MIN)) // Anmeldefehler: Pause, kein Fehlversuch + assert.equal(mailBudget(plus(MIN)).stunde.benutzt, 0, 'die Anmeldepause belegt nichts') + assert.deepEqual(mailBudget(plus(MIN)).spitzen, []) + assert.equal((await verarbeite(plus(16 * MIN))).gesendet, 1, 'der einzige Platz der Funktion und der Stunde war frei') + assert.equal((await lies(a.$id)).status, 'gesendet') +}) + +test('gleichzeitige Versuche einer Funktion halten das Kontingent: 6 Einträge, Kontingent 3 ⇒ genau 3 Transportaufrufe', async () => { + config.termine.mailsProFunktion = 3 + tr.verzoegerungMs = 20 + const ids = [] + for (let i = 0; i < 6; i++) ids.push((await legeAn({ featureId: 'f_A', art: 'G02', bookingId: `b_${i}` })).$id) + const antworten = await Promise.all(ids.map((id) => sendeEintrag(id, JETZT))) + assert.equal(tr.aufrufe, 3) + assert.equal(antworten.filter((a) => a === 'gesendet').length, 3) + assert.equal(antworten.filter((a) => a === 'wartet').length, 3) + assert.equal(alle().filter((d) => d.status === 'gesendet').length, 3) +}) + +test('mailBudget: Zahlen und Funktions-IDs, Spitzen sortiert und auf 3 begrenzt, nie eine Adresse', async () => { + for (let i = 1; i <= 2; i++) await einreihen(von('f_A', 'G02', i), JETZT) + await einreihen(von('f_A', 'G05', 1), JETZT) + for (let i = 1; i <= 2; i++) await einreihen(von('f_B', 'G01', i), JETZT) + await warteAufVersand() + assert.equal(tr.senke.sent.length, 5) + assert.deepEqual(mailBudget(plus(MIN)), { + stunde: { benutzt: 5, max: 200 }, + nachrangig: { benutzt: 1, max: 150 }, + jeFunktionMax: 40, + spitzen: [{ featureId: 'f_A', benutzt: 3 }, { featureId: 'f_B', benutzt: 2 }], + }) + assert.ok(!JSON.stringify(mailBudget(JETZT)).includes('@'), 'keine Adresse') + + for (const [id, anzahl] of [['f_C', 4], ['f_D', 1]]) { + for (let i = 1; i <= anzahl; i++) await einreihen(von(id, 'G03', i), plus(MIN)) + } + await warteAufVersand() + const budget = mailBudget(plus(2 * MIN)) + assert.equal(budget.stunde.benutzt, 10) + assert.deepEqual(budget.spitzen, [{ featureId: 'f_C', benutzt: 4 }, { featureId: 'f_A', benutzt: 3 }, { featureId: 'f_B', benutzt: 2 }], 'höchstens 3, größte zuerst') + + config.termine.mailsProStunde = 8 + config.termine.mailsProFunktion = 5 + config.termine.mailsReserve = 0.5 + const neu = mailBudget(plus(2 * MIN)) + assert.deepEqual([neu.stunde.max, neu.nachrangig.max, neu.jeFunktionMax], [8, 4, 5], 'liest die Werte bei jedem Aufruf') + + assert.equal(mailBudget(plus(60 * MIN)).stunde.benutzt, 5, 'A und B (Versand um 08:00) sind nach 60 Minuten raus, C und D (08:01) noch nicht') + assert.deepEqual(mailBudget(plus(61 * MIN)), { stunde: { benutzt: 0, max: 8 }, nachrangig: { benutzt: 0, max: 4 }, jeFunktionMax: 5, spitzen: [] }) + assert.throws(() => mailBudget('jetzt'), TypeError) +}) + +test('Reserve: mit sehr kleinem Stundenbudget darf mindestens eine nachrangige Mail raus', async () => { + config.termine.mailsProStunde = 1 + assert.equal(pruefePlatz(JETZT.getTime(), 'f_A', 'G05'), null) + assert.equal(mailBudget(JETZT).nachrangig.max, 1) + config.termine.mailsProStunde = 3 + config.termine.mailsReserve = 0.9 + assert.equal(mailBudget(JETZT).nachrangig.max, 1, 'floor(3 × 0.1) = 0 ⇒ mindestens 1') +}) + // --------------------------------------------------------------------------------------------------------------------- // Fehlerklassen // --------------------------------------------------------------------------------------------------------------------- @@ -467,7 +675,7 @@ test('Stundenbudget gilt auch bei gleichzeitigen Versuchen für verschiedene Ein config.termine.mailsProStunde = 3 tr.verzoegerungMs = 20 const ids = [] - for (let i = 0; i < 6; i++) ids.push((await legeAn({ bookingId: `b_${i}` })).$id) + for (let i = 0; i < 6; i++) ids.push((await legeAn({ bookingId: `b_${i}`, art: 'G02' })).$id) await Promise.all(ids.map((id) => sendeEintrag(id, JETZT))) assert.equal(tr.aufrufe, 3) assert.equal(alle().filter((d) => d.status === 'gesendet').length, 3) diff --git a/test/termineSchalter.test.js b/test/termineSchalter.test.js index d8f8492..42cf850 100644 --- a/test/termineSchalter.test.js +++ b/test/termineSchalter.test.js @@ -47,6 +47,8 @@ test('Konfiguration: Vorgaben ohne Umgebungsvariablen', async () => { holdMinutes: 30, zelleMin: 5, mailsProStunde: 200, + mailsProFunktion: 40, + mailsReserve: 0.25, loeschDeckel: 2000, loeschDeckelGesamt: 20000, zellenDeckel: 5000,