Terminplaner: Betriebspruefung mit Abkuehlzeit fuer die Team-Mail
pruefeBetrieb (neu: termine/betrieb.js) prueft am Ende jedes Minutenjobs Mailbudget (ab 70 %), Warteschlange (aeltester faelliger Eintrag > 10 Min ueberfaellig, neu outbox.warteschlangeAlter) und Anmeldepause (pausiertBis). Der gemeinsame Melder meldeVorfall schreibt je Schluessel hoechstens stuendlich ein Warnlog und schickt die Team-Mail T20 beim Beginn und danach fruehestens nach 6 Stunden; Lesefehler und Mailfehler stehen nur im Log. T20 steht jetzt auch im Test der Team-Fusszeile. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Sonnet 5.5 committed
1 parent
3a3319ec14
commit
689a21f9ac
5 files changed
+691
-4
No files matched your search
@@ -0,0 +1,157 @@
|
||||
import { sendAdminNotice } from '../mailer.js'
|
||||
import { mailBudget, pausiertBis, warteschlangeAlter } from './outbox.js'
|
||||
import { pruefeNow, pruefeText } from './util.js'
|
||||
import { datumKurz, uhrzeit } from './zeit.js'
|
||||
|
||||
/**
|
||||
* Betriebspruefung des Terminplaners (Spezifikation 2026-10-03-terminplaner-tp2-verkauf-design.md, Abschnitt 8, Punkt 5
|
||||
* „Sichtbarkeit“): Das Team soll es erfahren, bevor Gaeste es merken. Der Minutenjob ruft pruefeBetrieb am Ende jedes Laufs auf (Modus off: gar nicht).
|
||||
*
|
||||
* Vorfaelle dieses Bausteins (Schluessel):
|
||||
* budget mindestens 70 % von config.termine.mailsProStunde im Stundenfenster belegt (mailBudget)
|
||||
* queue der aelteste faellige Eintrag der Warteschlange ist mehr als 10 Minuten ueberfaellig (warteschlangeAlter);
|
||||
* eine Wiederholung mit naechsterVersuch in der Zukunft ist nicht faellig und zaehlt nicht
|
||||
* pause die Anmeldepause des Mailservers laeuft (pausiertBis)
|
||||
*
|
||||
* Gemeinsamer Melder (meldeVorfall, auch fuer die Tagesjob-Vorfaelle von A10a3): je Schluessel
|
||||
* - Warnlog `[termine-betrieb] ...` hoechstens stuendlich (nur Zahlen, nie Adresse oder Name eines Gastes),
|
||||
* - Team-Mail T20 (sendAdminNotice) beim Beginn und danach fruehestens nach 6 Stunden, auch wenn der Vorfall zwischendurch
|
||||
* endete. Die Abkuehlzeit beginnt mit dem Versuch, nicht erst mit dem Erfolg: faellt der Mailserver aus (bei der Anmeldepause
|
||||
* ist er es), scheitert auch die Team-Mail, und das Log bleibt der Rueckfall, statt dass jede Minute ein neuer Versuch folgt.
|
||||
* Zustand (Zeit der letzten Warnung und der letzten Mail je Schluessel) lebt im Speicher dieses Prozesses wie das Mailbudget.
|
||||
*
|
||||
* Lesefehler (Appwrite) ergeben keinen Vorfall und keine Mail, nur ein Log (ebenfalls hoechstens stuendlich je Pruefung).
|
||||
* `now` ist immer ein Parameter (feste Uhr in Tests).
|
||||
*/
|
||||
|
||||
const LOG = '[termine-betrieb]'
|
||||
const MIN_MS = 60 * 1000
|
||||
const STUNDE_MS = 60 * MIN_MS
|
||||
const LOG_ABSTAND_MS = STUNDE_MS
|
||||
const MAIL_ABKUEHLZEIT_MS = 6 * STUNDE_MS
|
||||
/** Die Warteschlange gilt als gestaut, wenn der aelteste faellige Eintrag laenger als so viele Minuten ueberfaellig ist. */
|
||||
const QUEUE_ALTER_MIN = 10
|
||||
/** Das Budget gilt als fast aufgebraucht ab 7/10 (ganzzahlig gerechnet: benutzt x 10 >= max x 7, kein Fliesskommafehler). */
|
||||
const budgetErreicht = (benutzt, max) => max > 0 && benutzt * 10 >= max * 7
|
||||
|
||||
/** Kurze Ueberschrift der Team-Mail (Betreff `[Terminplaner] <Ueberschrift>`); ohne Eintrag gilt die allgemeine. */
|
||||
const UEBERSCHRIFTEN = new Map([
|
||||
['budget', 'Mailbudget fast aufgebraucht'],
|
||||
['queue', 'Mail-Warteschlange staut sich'],
|
||||
['pause', 'Mailversand pausiert'],
|
||||
])
|
||||
const ALLGEMEINE_UEBERSCHRIFT = 'Betriebsmeldung'
|
||||
|
||||
/** schluessel => { logMs, mailMs } (null = noch nie). */
|
||||
const gemerkt = new Map()
|
||||
|
||||
function merkzettel(schluessel) {
|
||||
let zettel = gemerkt.get(schluessel)
|
||||
if (!zettel) {
|
||||
zettel = { logMs: null, mailMs: null }
|
||||
gemerkt.set(schluessel, zettel)
|
||||
}
|
||||
return zettel
|
||||
}
|
||||
|
||||
/** Ist seit dem letzten Mal (ms oder null = nie) mindestens abstandMs vergangen? */
|
||||
const abgelaufen = (letzteMs, nowMs, abstandMs) => letzteMs === null || nowMs - letzteMs >= abstandMs
|
||||
|
||||
/** '05.10.2026, 10:15' (Berliner Wanduhr), so steht die Zeit in T20 und in den Meldungen. */
|
||||
const zeitText = (date) => `${datumKurz(date)}, ${uhrzeit(date)}`
|
||||
|
||||
const fehlerText = (err) => `${err?.name ?? 'Fehler'} ${String(err?.message ?? '').replace(/\s+/g, ' ').slice(0, 200)}`
|
||||
|
||||
/**
|
||||
* Meldet einen Vorfall: Warnlog (hoechstens stuendlich je Schluessel) und Team-Mail T20 (beim Beginn und danach fruehestens nach
|
||||
* 6 Stunden je Schluessel). Wirft nur bei ungueltigen Eingaben (TypeError); ein Mailfehler steht im Log.
|
||||
* @param {string} schluessel Kennung des Vorfalls ('budget', 'queue', 'pause', ...); die Abkuehlzeit gilt je Schluessel
|
||||
* @param {string} text die Meldung (Log und Mail-Details): nur Zahlen, nie Adressen oder Namen
|
||||
* @param {Date} now
|
||||
* @returns {Promise<void>}
|
||||
*/
|
||||
export async function meldeVorfall(schluessel, text, now) {
|
||||
pruefeText(schluessel, 'schluessel')
|
||||
pruefeText(text, 'text')
|
||||
const nowMs = pruefeNow(now, 'meldeVorfall')
|
||||
const zettel = merkzettel(schluessel)
|
||||
|
||||
if (abgelaufen(zettel.logMs, nowMs, LOG_ABSTAND_MS)) {
|
||||
zettel.logMs = nowMs
|
||||
console.warn(`${LOG} ${text}`)
|
||||
}
|
||||
if (!abgelaufen(zettel.mailMs, nowMs, MAIL_ABKUEHLZEIT_MS)) return
|
||||
// Vor dem Senden gemerkt: ein zweiter Aufruf, waehrend die Mail noch unterwegs ist, sendet nicht noch einmal
|
||||
zettel.mailMs = nowMs
|
||||
const ergebnis = await sendAdminNotice({
|
||||
template: 'T20',
|
||||
values: { vorfall: UEBERSCHRIFTEN.get(schluessel) ?? ALLGEMEINE_UEBERSCHRIFT, details: text, zeit: zeitText(now) },
|
||||
})
|
||||
if (!ergebnis?.sent) {
|
||||
console.error(`${LOG} Team-Mail zu „${schluessel}“ nicht gesendet: ${String(ergebnis?.reason ?? 'unbekannt').slice(0, 200)}`)
|
||||
}
|
||||
}
|
||||
|
||||
/** Lesefehler einer Pruefung ins Log: hoechstens stuendlich je Pruefung, damit ein langer Ausfall das Log nicht fuellt. */
|
||||
function meldeFehler(schluessel, err, nowMs) {
|
||||
const zettel = merkzettel(`fehler:${schluessel}`)
|
||||
if (!abgelaufen(zettel.logMs, nowMs, LOG_ABSTAND_MS)) return
|
||||
zettel.logMs = nowMs
|
||||
console.error(`${LOG} Prüfung „${schluessel}“ nicht möglich: ${fehlerText(err)}`)
|
||||
}
|
||||
|
||||
// Die Pruefungen: Text des Vorfalls oder null (kein Vorfall); werfen duerfen sie (Lesefehler), pruefeBetrieb faengt das ab.
|
||||
|
||||
function budgetVorfall(now) {
|
||||
const { benutzt, max } = mailBudget(now).stunde
|
||||
if (!budgetErreicht(benutzt, max)) return null
|
||||
return `Mailbudget ${benutzt}/${max} in der letzten Stunde (Hinweis ab 70 %); ist es voll, warten weitere Mails bis zur nächsten freien Stunde`
|
||||
}
|
||||
|
||||
async function queueVorfall(now) {
|
||||
const { wartet, aeltesteMin } = await warteschlangeAlter(now)
|
||||
if (!(aeltesteMin > QUEUE_ALTER_MIN)) return null
|
||||
const anzahl = wartet === null ? '' : `, ${wartet} wartend`
|
||||
return `Mail-Warteschlange: der älteste fällige Eintrag ist seit ${aeltesteMin} Min überfällig${anzahl}`
|
||||
}
|
||||
|
||||
function pauseVorfall(now) {
|
||||
const bis = pausiertBis()
|
||||
if (!bis || !(bis.getTime() > now.getTime())) return null
|
||||
return `Mailversand pausiert bis ${zeitText(bis)} Uhr (SMTP-Anmeldung fehlgeschlagen), die Mails warten in der Warteschlange`
|
||||
}
|
||||
|
||||
/** In dieser Reihenfolge werden Vorfaelle geprueft und gemeldet. */
|
||||
const PRUEFUNGEN = [
|
||||
['budget', budgetVorfall],
|
||||
['queue', queueVorfall],
|
||||
['pause', pauseVorfall],
|
||||
]
|
||||
|
||||
/**
|
||||
* Prueft Mailbudget, Warteschlange und Anmeldepause und meldet jeden aktiven Vorfall ueber meldeVorfall. Wirft nie (ausser mit
|
||||
* TypeError bei ungueltigem `now`, wie alle Termine-Bausteine): ein Lesefehler oder ein fehlgeschlagener Mailversand steht im Log
|
||||
* und laesst die uebrigen Pruefungen laufen. Eine Pruefung, die nicht lesen konnte, meldet keinen Vorfall.
|
||||
* @param {Date} now
|
||||
* @returns {Promise<string[]>} die Schluessel der aktiven Vorfaelle ('budget', 'queue', 'pause')
|
||||
*/
|
||||
export async function pruefeBetrieb(now) {
|
||||
const nowMs = pruefeNow(now, 'pruefeBetrieb')
|
||||
const aktiv = []
|
||||
for (const [schluessel, pruefe] of PRUEFUNGEN) {
|
||||
try {
|
||||
const text = await pruefe(now)
|
||||
if (text === null) continue
|
||||
aktiv.push(schluessel)
|
||||
await meldeVorfall(schluessel, text, now)
|
||||
} catch (err) {
|
||||
meldeFehler(schluessel, err, nowMs)
|
||||
}
|
||||
}
|
||||
return aktiv
|
||||
}
|
||||
|
||||
/** Nur fuer Tests: den gemerkten Zustand (Zeit der letzten Warnung und Mail je Schluessel) zuruecksetzen. */
|
||||
export function resetBetriebForTests() {
|
||||
gemerkt.clear()
|
||||
}
|
||||
@@ -2,6 +2,7 @@ import { config } from '../../config.js'
|
||||
import { Query, deleteDocument, getDocument, listAllDocuments } from '../appwriteAdmin.js'
|
||||
import { withLocks } from '../keyedLock.js'
|
||||
import { gibFreiSicher, iso, vertragAm } from './ablauf.js'
|
||||
import { pruefeBetrieb } from './betrieb.js'
|
||||
import {
|
||||
abgelaufeneHaltungen,
|
||||
aendere,
|
||||
@@ -26,7 +27,8 @@ import { gibZellenFrei, raeumeVerwaisteZellen } from './zellen.js'
|
||||
* Hintergrund-Jobs des Terminplaners (Spezifikation 2026-10-02-terminplaner-design.md, Abschnitte 4 und 11). server/index.js
|
||||
* ruft sie mit new Date() auf; `now` ist hier immer ein Parameter.
|
||||
*
|
||||
* minutenJob jede Minute abgelaufene Haltungen => verfallen (Zellen frei); Mail-Warteschlange senden
|
||||
* minutenJob jede Minute abgelaufene Haltungen => verfallen (Zellen frei); Mail-Warteschlange senden; zuletzt die
|
||||
* Betriebspruefung (Budget, Warteschlange, Anmeldepause => Log und Team-Mail, betrieb.js)
|
||||
* fuenfMinutenJob alle 5 Minuten Erinnerungen (G05); bestaetigt 1 Stunde nach Ende => erledigt; Anfragen mit Beginn in
|
||||
* der Vergangenheit => abgelehnt (vom System, Zellen frei, keine Mail)
|
||||
* taeglicherJob taeglich Loeschfristen (11), festgefahrene und alte Mails, abgeschaltete Funktionen, verwaiste Zellen
|
||||
@@ -210,7 +212,8 @@ async function verfalleHaltungen(lauf, now) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Jede Minute: abgelaufene Haltungen verfallen lassen, Warteschlange senden.
|
||||
* Jede Minute: abgelaufene Haltungen verfallen lassen, Warteschlange senden, zuletzt den Betrieb pruefen (Vorfaelle stehen im Log und
|
||||
* gehen als T20 ans Team; die Pruefung wirft nie und aendert das Ergebnis des Laufs nicht).
|
||||
* @param {Date} now
|
||||
* @returns {Promise<{ verfallen: number, faellig: number, gesendet: number, fehler: number } | { aus: true } | { uebersprungen: true }>}
|
||||
*/
|
||||
@@ -218,6 +221,8 @@ export async function minutenJob(now) {
|
||||
return fuehreAus('minutenJob', now, async (lauf) => {
|
||||
const verfallen = await schritt(lauf, 'Verfall', () => verfalleHaltungen(lauf, now), 0)
|
||||
const { faellig, gesendet } = await schritt(lauf, 'Warteschlange', () => verarbeite(now), { faellig: 0, gesendet: 0 })
|
||||
// Zuletzt: die Pruefung sieht den Stand nach Verfall und Versand (ein eben gesendeter Eintrag staut nichts mehr)
|
||||
await schritt(lauf, 'Betriebsprüfung', () => pruefeBetrieb(now), [])
|
||||
return { verfallen, faellig, gesendet, fehler: lauf.fehler }
|
||||
})
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { config } from '../../config.js'
|
||||
import { Query, createDocument, deleteDocument, getDocument, listAllDocuments, listDocuments, updateDocument } from '../appwriteAdmin.js'
|
||||
import { Query, countDocuments, createDocument, deleteDocument, getDocument, listAllDocuments, listDocuments, updateDocument } from '../appwriteAdmin.js'
|
||||
import { withLocks } from '../keyedLock.js'
|
||||
import { sendGuestMail } from '../mailer.js'
|
||||
import { renderMail } from '../mailTemplates.js'
|
||||
@@ -457,6 +457,31 @@ export async function verarbeite(now) {
|
||||
return { faellig: lauf.faellig, gesendet: lauf.gesendet }
|
||||
}
|
||||
|
||||
/**
|
||||
* Stand der Warteschlange fuer die Betriebspruefung und die Statusroute: nur Zahlen, nie ein Mailtext. `wartet` = alle Eintraege mit
|
||||
* Status `wartet` (auch Wiederholungen, die erst spaeter faellig werden), `aeltesteMin` = ganze Minuten (abgerundet), die der aelteste
|
||||
* faellige Eintrag (naechsterVersuch <= jetzt) schon ueberfaellig ist, 0 ohne faelligen Eintrag. Zwei kurze Abfragen ueber den Index
|
||||
* idx_status_next, parallel: die Anzahl und der aelteste faellige Eintrag (limit 1, nur $id und naechsterVersuch). Scheitert eine,
|
||||
* wirft die Funktion; der Aufrufer meldet den Lesefehler.
|
||||
* @param {Date} now
|
||||
* @returns {Promise<{ wartet: number|null, aeltesteMin: number }>} wartet ist null, wenn Appwrite keine Anzahl liefert
|
||||
*/
|
||||
export async function warteschlangeAlter(now) {
|
||||
const nowMs = pruefeNow(now, 'warteschlangeAlter')
|
||||
const [wartet, aelteste] = await Promise.all([
|
||||
countDocuments(col(), [Query.equal('status', 'wartet')]),
|
||||
listDocuments(col(), [
|
||||
Query.equal('status', 'wartet'),
|
||||
Query.lessThanEqual('naechsterVersuch', iso(nowMs)),
|
||||
Query.orderAsc('naechsterVersuch'),
|
||||
Query.limit(1),
|
||||
Query.select(['$id', 'naechsterVersuch']),
|
||||
]),
|
||||
])
|
||||
const faelligSeit = aelteste.length > 0 ? zeitMs(aelteste[0].naechsterVersuch) : Number.NaN
|
||||
return { wartet, aeltesteMin: Number.isNaN(faelligSeit) ? 0 : Math.max(0, Math.floor((nowMs - faelligSeit) / MIN_MS)) }
|
||||
}
|
||||
|
||||
/** Nur fuer Tests: wartet, bis alle laufenden Sendeversuche (auch die aus einreihen) beendet sind. */
|
||||
export async function warteAufVersand() {
|
||||
while (laufend.size > 0) await Promise.allSettled([...laufend])
|
||||
|
||||
@@ -503,7 +503,7 @@ test('T07: Hinweis auf nicht genutzte Arbeitszeit nur im Block wartung', () => {
|
||||
})
|
||||
|
||||
// Etappe 4: das Admin-Panel ist abgeschaltet, Team-Mails fuehren ins Ticketsystem
|
||||
const TEAM_FOOTER = ['T01', 'T02', 'T03', 'T04', 'T05', 'T06', 'T07', 'T08', 'T09', 'T10', 'T11', 'T12', 'T13', 'T14', 'T16']
|
||||
const TEAM_FOOTER = ['T01', 'T02', 'T03', 'T04', 'T05', 'T06', 'T07', 'T08', 'T09', 'T10', 'T11', 'T12', 'T13', 'T14', 'T16', 'T20']
|
||||
|
||||
test('keine Vorlage verlinkt admin.html oder nennt den Admin-Bereich', () => {
|
||||
for (const id of EXPECTED) {
|
||||
|
||||
@@ -0,0 +1,500 @@
|
||||
import { test, after, beforeEach, afterEach, mock } from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { startAppwriteMock } from './support/appwriteMock.js'
|
||||
import { mailSink } from './support/mailSink.js'
|
||||
import { schemaKeys } from './support/schema.js'
|
||||
import { useTestEnv } from './support/testEnv.js'
|
||||
import { TERMINE_DATETIMES } from '../server/services/termine/schema.js'
|
||||
|
||||
// Betriebspruefung des Terminplaners (Budget, Warteschlange, Anmeldepause) mit Abkuehlzeit fuer die Team-Mail (T20):
|
||||
// Nachbau von Appwrite mit Schema, Mails landen in der Senke (ueber einen Fake, der Sendeversuche zaehlt und gezielt
|
||||
// scheitert), alle Zeiten sind feste Parameter.
|
||||
const aw = await startAppwriteMock({
|
||||
schema: {
|
||||
portalFeatures: schemaKeys('portalFeatures'),
|
||||
termineConfig: schemaKeys('termineConfig'),
|
||||
termineBookings: schemaKeys('termineBookings'),
|
||||
termineClaims: schemaKeys('termineClaims'),
|
||||
termineOutbox: schemaKeys('termineOutbox'),
|
||||
},
|
||||
datetimes: TERMINE_DATETIMES,
|
||||
defaultLimit: 25,
|
||||
})
|
||||
after(() => aw.close())
|
||||
useTestEnv({ appwriteUrl: aw.url, stripeUrl: 'http://127.0.0.1:1' })
|
||||
|
||||
const { config } = await import('../server/config.js')
|
||||
const { deleteDocument } = await import('../server/services/appwriteAdmin.js')
|
||||
const { setMailTransportForTests } = await import('../server/services/mailer.js')
|
||||
const { loadTemplate } = await import('../server/services/mailTemplates.js')
|
||||
const { einreihen, warteAufVersand, warteschlangeAlter, pausiertBis, resetOutboxForTests } = await import('../server/services/termine/outbox.js')
|
||||
const { pruefeBetrieb, meldeVorfall, resetBetriebForTests } = await import('../server/services/termine/betrieb.js')
|
||||
const { minutenJob, resetJobsForTests } = await import('../server/services/termine/jobs.js')
|
||||
after(() => setMailTransportForTests(null))
|
||||
|
||||
const MIN = 60000
|
||||
const STUNDE = 60 * MIN
|
||||
const JETZT = new Date('2026-10-05T08:00:00.000Z') // Montag, 10:00 Berlin
|
||||
const plus = (ms, von = JETZT) => new Date(von.getTime() + ms)
|
||||
const iso = (wert) => new Date(wert).toISOString()
|
||||
const col = () => config.collections.termineOutbox
|
||||
|
||||
const TEAM = ['kenso@example.test', 'andrej@example.test']
|
||||
const EAUTH = Object.assign(new Error('Invalid login: 535 Authentication failed'), { code: 'EAUTH', responseCode: 535 })
|
||||
const ist20 = (mail) => /^\[Terminplaner\]/.test(mail.subject)
|
||||
|
||||
/** Transport: zaehlt Sendeversuche (gesamt und fuer die Team-Mail T20), wirft die Fehler aus `fehler` der Reihe nach, sonst entscheidet `wirf(mail)`. */
|
||||
function fakeTransport() {
|
||||
const senke = mailSink()
|
||||
const transport = {
|
||||
senke,
|
||||
aufrufe: 0,
|
||||
teamVersuche: 0,
|
||||
fehler: [],
|
||||
wirf: null,
|
||||
async sendMail(mail) {
|
||||
transport.aufrufe += 1
|
||||
if (ist20(mail)) transport.teamVersuche += 1
|
||||
const fehler = transport.fehler.shift() ?? transport.wirf?.(mail)
|
||||
if (fehler) throw fehler
|
||||
return senke.sendMail(mail)
|
||||
},
|
||||
}
|
||||
return transport
|
||||
}
|
||||
|
||||
const VORHER = {
|
||||
modus: config.termine.mode,
|
||||
empfaenger: config.chatNotify.emails,
|
||||
absender: config.smtp.from,
|
||||
}
|
||||
let tr
|
||||
let log
|
||||
beforeEach(async () => {
|
||||
for (const collection of ['termineOutbox', 'termineBookings', 'termineClaims', 'portalFeatures', 'termineConfig']) {
|
||||
for (const id of aw.docs(collection).keys()) await deleteDocument(collection, id)
|
||||
}
|
||||
resetOutboxForTests()
|
||||
resetBetriebForTests()
|
||||
resetJobsForTests()
|
||||
aw.resetListCalls()
|
||||
config.termine.mode = 'pilot'
|
||||
config.termine.mailsProStunde = 200
|
||||
config.termine.mailsProFunktion = 40
|
||||
config.termine.mailsReserve = 0.25
|
||||
config.chatNotify.emails = [...TEAM]
|
||||
config.smtp.from = 'noreply@webklar.com'
|
||||
tr = fakeTransport()
|
||||
setMailTransportForTests(tr)
|
||||
log = { error: mock.method(console, 'error', () => {}), warn: mock.method(console, 'warn', () => {}) }
|
||||
})
|
||||
afterEach(async () => {
|
||||
await warteAufVersand()
|
||||
const zeilen = [...log.error.mock.calls, ...log.warn.mock.calls].map((aufruf) => aufruf.arguments.map(String).join(' '))
|
||||
mock.restoreAll()
|
||||
config.termine.mode = VORHER.modus
|
||||
config.termine.mailsProStunde = 200
|
||||
config.termine.mailsProFunktion = 40
|
||||
config.chatNotify.emails = VORHER.empfaenger
|
||||
config.smtp.from = VORHER.absender
|
||||
// Logs enthalten nie Adressen oder Namen der Gaeste
|
||||
assert.doesNotMatch(zeilen.join('\n'), /anna@example\.com|Anna/, 'keine Gastadresse und kein Gastname im Log')
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Hilfen
|
||||
|
||||
const werte = (id, extra = {}) => ({ ...Object.fromEntries(loadTemplate(id).placeholders.map((p) => [p, `Wert-${p}`])), ...extra })
|
||||
let nummer = 0
|
||||
/** Mail an einen Gast (Vorrang-Art G02, Vorlage G01): belegt beim Senden einen Platz im Stundenbudget. */
|
||||
const gastMail = (featureId = 'f_A') => ({
|
||||
featureId,
|
||||
bookingId: `b_${featureId}_${++nummer}`,
|
||||
art: 'G02',
|
||||
an: 'anna@example.com',
|
||||
fromName: 'Salon Muster',
|
||||
replyTo: 'info@salon-muster.de',
|
||||
template: 'G01',
|
||||
values: werte('G01', { betreff: 'Bitte bestätigen Sie Ihren Termin bei Salon Muster' }),
|
||||
blocks: { sie: true, bestaetigen: true },
|
||||
})
|
||||
|
||||
/** `anzahl` Gastmails zum Zeitpunkt `now` senden (je Funktion hoechstens 20 gleichzeitig; das Kontingent je Funktion ist hier nicht das Thema). */
|
||||
async function belegeBudget(anzahl, now = JETZT) {
|
||||
config.termine.mailsProFunktion = 1000
|
||||
for (let i = 0; i < anzahl; i += 20) {
|
||||
await Promise.all(Array.from({ length: Math.min(20, anzahl - i) }, (_, k) => einreihen(gastMail(`f_${(i + k) % 7}`), now)))
|
||||
}
|
||||
await warteAufVersand()
|
||||
config.termine.mailsProFunktion = 40
|
||||
}
|
||||
|
||||
/** Eintrag direkt in der Datenbank (ohne Sendeversuch). */
|
||||
function legeEintrag(id, over = {}) {
|
||||
aw.seed('termineOutbox', {
|
||||
$id: id,
|
||||
featureId: 'f_A',
|
||||
bookingId: 'b_direkt',
|
||||
art: 'G05',
|
||||
an: 'anna@example.com',
|
||||
fromName: 'Salon Muster',
|
||||
replyTo: 'info@salon-muster.de',
|
||||
subject: 'Erinnerung: Ihr Termin',
|
||||
html: '<p>Hallo</p>',
|
||||
text: 'Hallo',
|
||||
ics: '',
|
||||
icsMethod: '',
|
||||
status: 'wartet',
|
||||
versuche: 0,
|
||||
naechsterVersuch: iso(JETZT),
|
||||
fehler: '',
|
||||
createdAt: iso(JETZT),
|
||||
...over,
|
||||
})
|
||||
}
|
||||
|
||||
/** Anmeldepause ausloesen: ein Anmeldefehler beim Senden zum Zeitpunkt `now` (Pause bis now + 15 Minuten); der Eintrag bleibt danach nicht stehen. */
|
||||
async function loeseAnmeldepauseAus(now) {
|
||||
tr.fehler.push(EAUTH)
|
||||
const doc = await einreihen(gastMail('f_P'), now)
|
||||
await warteAufVersand()
|
||||
await deleteDocument(col(), doc.$id)
|
||||
}
|
||||
|
||||
const teamMails = () => tr.senke.sent.filter(ist20)
|
||||
const logZeilen = () => [...log.warn.mock.calls, ...log.error.mock.calls].map((aufruf) => aufruf.arguments.map(String).join(' '))
|
||||
const betriebLog = () => logZeilen().filter((zeile) => zeile.startsWith('[termine-betrieb]'))
|
||||
const betriebLogMit = (muster) => betriebLog().filter((zeile) => muster.test(zeile))
|
||||
|
||||
/** Alle drei Vorfaelle zum Zeitpunkt JETZT: Budget 7/10, ein 11 Minuten ueberfaelliger Eintrag, Anmeldepause bis JETZT + 4 Minuten. */
|
||||
async function richteAlleVorfaelleEin() {
|
||||
config.termine.mailsProStunde = 10
|
||||
await belegeBudget(7, plus(-12 * MIN))
|
||||
tr.fehler.push(EAUTH)
|
||||
await einreihen(gastMail('f_B'), plus(-11 * MIN))
|
||||
await warteAufVersand()
|
||||
assert.equal(pausiertBis().getTime(), plus(4 * MIN).getTime())
|
||||
}
|
||||
|
||||
/** Alle Lese-Anfragen an die Collection scheitern mit 500, solange fn laeuft. */
|
||||
async function mitLesefehler(collection, fn) {
|
||||
const echt = globalThis.fetch
|
||||
globalThis.fetch = async (url, optionen) => {
|
||||
if (new RegExp(`/collections/${collection}/documents`).test(String(url)) && (optionen?.method ?? 'GET') === 'GET') {
|
||||
return new Response(JSON.stringify({ message: 'Nachbau kaputt', code: 500, type: 'general_server_error' }), { status: 500, headers: { 'content-type': 'application/json' } })
|
||||
}
|
||||
return echt(url, optionen)
|
||||
}
|
||||
try {
|
||||
return await fn()
|
||||
} finally {
|
||||
globalThis.fetch = echt
|
||||
}
|
||||
}
|
||||
|
||||
/** Anzahl der Anfragen, die fn ausloest. */
|
||||
async function zaehleAnfragen(fn) {
|
||||
const echt = globalThis.fetch
|
||||
let n = 0
|
||||
globalThis.fetch = (url, optionen) => {
|
||||
n += 1
|
||||
return echt(url, optionen)
|
||||
}
|
||||
try {
|
||||
await fn()
|
||||
} finally {
|
||||
globalThis.fetch = echt
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- warteschlangeAlter
|
||||
|
||||
test('warteschlangeAlter: Anzahl der Wartenden und Minuten des ältesten fälligen Eintrags; leere Warteschlange ⇒ 0 / 0', async () => {
|
||||
assert.deepEqual(await warteschlangeAlter(JETZT), { wartet: 0, aeltesteMin: 0 })
|
||||
legeEintrag('o_alt', { naechsterVersuch: iso(plus(-30 * MIN - 59000)) })
|
||||
legeEintrag('o_neu', { naechsterVersuch: iso(plus(-12 * MIN)) })
|
||||
legeEintrag('o_spaeter', { naechsterVersuch: iso(plus(5 * MIN)) })
|
||||
assert.deepEqual(await warteschlangeAlter(JETZT), { wartet: 3, aeltesteMin: 30 }, 'ganze Minuten, abgerundet; die Wiederholung in der Zukunft zählt zu den Wartenden, nicht zur Überfälligkeit')
|
||||
assert.deepEqual(await warteschlangeAlter(plus(MIN)), { wartet: 3, aeltesteMin: 31 })
|
||||
await assert.rejects(() => warteschlangeAlter('jetzt'), TypeError)
|
||||
})
|
||||
|
||||
test('warteschlangeAlter: nur Einträge mit Status wartet; gesendete, fehlgeschlagene und verworfene zählen nicht, auch wenn ihr Löschtermin vorbei ist', async () => {
|
||||
for (const status of ['gesendet', 'fehler', 'verworfen']) legeEintrag(`o_${status}`, { status, naechsterVersuch: iso(plus(-3 * 24 * STUNDE)) })
|
||||
assert.deepEqual(await warteschlangeAlter(JETZT), { wartet: 0, aeltesteMin: 0 })
|
||||
})
|
||||
|
||||
test('warteschlangeAlter: zwei kurze Abfragen über status/naechsterVersuch, die Liste mit limit 1, sortiert, nur die Felder $id und naechsterVersuch (nie ein Mailtext)', async () => {
|
||||
legeEintrag('o_1')
|
||||
aw.resetListCalls()
|
||||
await warteschlangeAlter(JETZT)
|
||||
const abfragen = aw.listCalls('termineOutbox').map((aufruf) => aufruf.queries)
|
||||
assert.equal(abfragen.length, 2)
|
||||
const liste = abfragen.find((queries) => queries.some((q) => q.method === 'select'))
|
||||
assert.ok(liste, 'die Liste des ältesten Eintrags')
|
||||
assert.deepEqual(liste.find((q) => q.method === 'select').values, ['$id', 'naechsterVersuch'])
|
||||
assert.deepEqual(liste.find((q) => q.method === 'limit').values, [1])
|
||||
assert.equal(liste.find((q) => q.method === 'orderAsc').attribute, 'naechsterVersuch')
|
||||
assert.ok(liste.some((q) => q.method === 'lessThanEqual'), 'nur fällige')
|
||||
assert.ok(abfragen.every((queries) => queries.some((q) => q.method === 'equal')), 'beide nur für den Status wartet')
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Budget
|
||||
|
||||
test('Budget: 139 von 200 ⇒ kein Vorfall, 140 ⇒ Vorfall; das Log „Mailbudget 140/200“ genau einmal, 30 Minuten später kein zweites; T20 genau einmal ohne Adresse und Namen', async () => {
|
||||
await belegeBudget(139)
|
||||
assert.equal(tr.senke.sent.length, 139)
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), [])
|
||||
assert.equal(betriebLog().length, 0)
|
||||
assert.equal(teamMails().length, 0)
|
||||
|
||||
await belegeBudget(1)
|
||||
assert.equal(tr.senke.sent.length, 140)
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), ['budget'])
|
||||
assert.equal(betriebLogMit(/Mailbudget 140\/200/).length, 1)
|
||||
assert.equal(teamMails().length, 1)
|
||||
|
||||
assert.deepEqual(await pruefeBetrieb(plus(30 * MIN)), ['budget'], 'die Plätze stehen noch im Stundenfenster')
|
||||
assert.equal(betriebLogMit(/Mailbudget 140\/200/).length, 1, 'kein zweites Log nach 30 Minuten')
|
||||
assert.equal(teamMails().length, 1, 'keine zweite Mail')
|
||||
|
||||
const mail = teamMails()[0]
|
||||
assert.match(mail.subject, /^\[Terminplaner\] /)
|
||||
assert.deepEqual(mail.to.map((adresse) => adresse.address), TEAM, 'an das Team')
|
||||
assert.match(mail.text, /Mailbudget 140\/200/)
|
||||
assert.match(mail.text, /05\.10\.2026, 10:00/, 'Zeit in Berliner Wanduhr')
|
||||
for (const teil of [mail.subject, mail.text, mail.html]) assert.doesNotMatch(teil, /anna|Anna|Salon Muster|Wert-/, 'kein Gast, kein Betrieb im Text')
|
||||
assert.doesNotMatch(mail.text, /@/, 'keine Adresse im Text')
|
||||
})
|
||||
|
||||
test('Budget: dauert die Überlastung über eine Stunde, folgt das Log nach 61 Minuten wieder, die Team-Mail erst nach der Abkühlzeit', async () => {
|
||||
config.termine.mailsProStunde = 10 // Hinweis ab 7 Plätzen
|
||||
const sende = async (minute) => {
|
||||
await einreihen(gastMail('f_A'), plus(minute * MIN))
|
||||
await warteAufVersand()
|
||||
}
|
||||
for (let minute = 0; minute <= 40; minute += 8) await sende(minute) // 6 Mails
|
||||
assert.deepEqual(await pruefeBetrieb(plus(47 * MIN)), [], '6 von 10')
|
||||
await sende(48) // 7 Mails im Fenster
|
||||
assert.deepEqual(await pruefeBetrieb(plus(48 * MIN)), ['budget'])
|
||||
assert.equal(betriebLogMit(/Mailbudget 7\/10/).length, 1)
|
||||
assert.equal(teamMails().length, 1)
|
||||
|
||||
for (let minute = 56; minute <= 72; minute += 8) await sende(minute)
|
||||
assert.deepEqual(await pruefeBetrieb(plus(78 * MIN)), ['budget'])
|
||||
assert.equal(betriebLogMit(/Mailbudget/).length, 1, '30 Minuten später kein zweites Log')
|
||||
|
||||
for (let minute = 80; minute <= 104; minute += 8) await sende(minute)
|
||||
assert.deepEqual(await pruefeBetrieb(plus(109 * MIN)), ['budget'], 'Fenster (49, 109]: 7 Mails')
|
||||
assert.equal(betriebLogMit(/Mailbudget 7\/10/).length, 2, '61 Minuten nach dem ersten Log wieder')
|
||||
assert.equal(teamMails().length, 1, 'die Mail kommt erst nach 6 Stunden wieder')
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Warteschlange
|
||||
|
||||
test('Warteschlange: ein Eintrag 10 Minuten überfällig ⇒ kein Vorfall, 11 Minuten ⇒ Vorfall mit Zahlen im Log und in der Mail', async () => {
|
||||
legeEintrag('o_zehn', { naechsterVersuch: iso(plus(-10 * MIN)) })
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), [])
|
||||
assert.equal(betriebLog().length, 0)
|
||||
assert.equal(teamMails().length, 0)
|
||||
|
||||
assert.deepEqual(await pruefeBetrieb(plus(MIN)), ['queue'], 'dieselbe Fälligkeit, eine Minute später: 11 Minuten')
|
||||
assert.equal(betriebLogMit(/älteste fällige Eintrag ist seit 11 Min überfällig, 1 wartend/).length, 1)
|
||||
assert.equal(teamMails().length, 1)
|
||||
assert.match(teamMails()[0].text, /11 Min/)
|
||||
assert.doesNotMatch(teamMails()[0].text, /@|anna|Anna/)
|
||||
})
|
||||
|
||||
test('Warteschlange: der älteste fällige Eintrag zählt; eine Wiederholung in der Zukunft und Einträge anderer Status zählen nicht', async () => {
|
||||
legeEintrag('o_wiederholung', { versuche: 2, naechsterVersuch: iso(plus(5 * MIN)), createdAt: iso(plus(-2 * STUNDE)) })
|
||||
legeEintrag('o_gesendet', { status: 'gesendet', naechsterVersuch: iso(plus(-3 * 24 * STUNDE)) })
|
||||
legeEintrag('o_fehler', { status: 'fehler', naechsterVersuch: iso(plus(-60 * MIN)) })
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), [], 'nichts fällig und überfällig')
|
||||
|
||||
legeEintrag('o_ueberfaellig', { naechsterVersuch: iso(plus(-12 * MIN)) })
|
||||
legeEintrag('o_aelter', { naechsterVersuch: iso(plus(-45 * MIN)) })
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), ['queue'])
|
||||
assert.equal(betriebLogMit(/seit 45 Min überfällig, 3 wartend/).length, 1, 'ältester Eintrag 45 Minuten; wartend = alle Einträge mit Status wartet')
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Anmeldepause
|
||||
|
||||
test('Pause: Anmeldefehler ⇒ Vorfall pause mit Endzeit im Log, nach Ablauf kein Vorfall mehr', async () => {
|
||||
await loeseAnmeldepauseAus(JETZT)
|
||||
assert.equal(pausiertBis().getTime(), plus(15 * MIN).getTime())
|
||||
|
||||
assert.deepEqual(await pruefeBetrieb(plus(MIN)), ['pause'])
|
||||
assert.equal(betriebLogMit(/pausiert bis 05\.10\.2026, 10:15 Uhr/).length, 1, 'Endzeit in Berliner Wanduhr')
|
||||
assert.equal(teamMails().length, 1)
|
||||
assert.match(teamMails()[0].subject, /^\[Terminplaner\] /)
|
||||
assert.match(teamMails()[0].text, /10:15/)
|
||||
|
||||
assert.deepEqual(await pruefeBetrieb(plus(14 * MIN)), ['pause'], 'eine Minute vor dem Ende')
|
||||
assert.deepEqual(await pruefeBetrieb(plus(15 * MIN)), [], 'zum Ende der Pause ist der Vorfall vorbei')
|
||||
assert.equal(teamMails().length, 1)
|
||||
})
|
||||
|
||||
test('Pause: eine zweite Pause innerhalb von 6 Stunden ⇒ Log ja, Mail nein; nach 6 Stunden wieder Mail', async () => {
|
||||
await loeseAnmeldepauseAus(JETZT)
|
||||
assert.deepEqual(await pruefeBetrieb(plus(MIN)), ['pause']) // Mail um 10:01
|
||||
assert.equal(teamMails().length, 1)
|
||||
assert.deepEqual(await pruefeBetrieb(plus(20 * MIN)), [])
|
||||
|
||||
await loeseAnmeldepauseAus(plus(2 * STUNDE))
|
||||
assert.deepEqual(await pruefeBetrieb(plus(2 * STUNDE + MIN)), ['pause'])
|
||||
assert.equal(betriebLogMit(/pausiert bis/).length, 2, 'die zweite Pause steht im Log')
|
||||
assert.equal(teamMails().length, 1, 'aber die Abkühlzeit hält die Mail zurück, obwohl der Vorfall dazwischen endete')
|
||||
|
||||
await loeseAnmeldepauseAus(plus(6 * STUNDE))
|
||||
assert.deepEqual(await pruefeBetrieb(plus(6 * STUNDE + 30000)), ['pause'])
|
||||
assert.equal(teamMails().length, 1, '5 Stunden 59 Minuten und 30 Sekunden nach der ersten Mail')
|
||||
assert.deepEqual(await pruefeBetrieb(plus(6 * STUNDE + MIN)), ['pause'])
|
||||
assert.equal(teamMails().length, 2, 'genau 6 Stunden nach der ersten Mail wieder')
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Gemeinsamer Melder
|
||||
|
||||
test('meldeVorfall: Log höchstens stündlich, Mail erst nach 6 Stunden, je Schlüssel getrennt', async () => {
|
||||
await meldeVorfall('beispiel', 'Beispiel-Vorfall 1', JETZT)
|
||||
assert.equal(betriebLogMit(/Beispiel-Vorfall 1/).length, 1)
|
||||
assert.equal(teamMails().length, 1)
|
||||
assert.equal(teamMails()[0].subject, '[Terminplaner] Betriebsmeldung', 'ohne eigene Überschrift die allgemeine')
|
||||
assert.match(teamMails()[0].text, /Beispiel-Vorfall 1/)
|
||||
|
||||
await meldeVorfall('beispiel', 'Beispiel-Vorfall 2', plus(59 * MIN))
|
||||
assert.equal(betriebLog().length, 1, 'keine Stunde')
|
||||
await meldeVorfall('beispiel', 'Beispiel-Vorfall 3', plus(60 * MIN))
|
||||
assert.equal(betriebLogMit(/Beispiel-Vorfall 3/).length, 1, 'nach einer Stunde wieder')
|
||||
assert.equal(teamMails().length, 1)
|
||||
|
||||
await meldeVorfall('anderer', 'Anderer Vorfall', plus(61 * MIN))
|
||||
assert.equal(teamMails().length, 2, 'ein anderer Schlüssel hat seine eigene Abkühlzeit')
|
||||
|
||||
await meldeVorfall('beispiel', 'Beispiel-Vorfall 4', plus(6 * STUNDE - 1))
|
||||
assert.equal(teamMails().length, 2)
|
||||
await meldeVorfall('beispiel', 'Beispiel-Vorfall 5', plus(6 * STUNDE))
|
||||
assert.equal(teamMails().length, 3)
|
||||
assert.match(teamMails()[2].text, /Beispiel-Vorfall 5/)
|
||||
|
||||
resetBetriebForTests()
|
||||
await meldeVorfall('beispiel', 'Nach dem Zurücksetzen', plus(6 * STUNDE + MIN))
|
||||
assert.equal(teamMails().length, 4, 'resetBetriebForTests vergisst die Abkühlzeit')
|
||||
})
|
||||
|
||||
test('meldeVorfall: verlangt Schlüssel, Text und eine gültige Uhrzeit', async () => {
|
||||
await assert.rejects(() => meldeVorfall('', 'x', JETZT), TypeError)
|
||||
await assert.rejects(() => meldeVorfall('a', '', JETZT), TypeError)
|
||||
await assert.rejects(() => meldeVorfall('a', 'x', 'jetzt'), TypeError)
|
||||
assert.equal(teamMails().length, 0)
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Fehlerfälle
|
||||
|
||||
test('pruefeBetrieb wirft nie: ein Lesefehler (Appwrite 500) ⇒ ein Log, kein vorgetäuschter Vorfall, keine Mail', async () => {
|
||||
aw.failNext({ collection: 'termineOutbox', method: 'GET', status: 500, message: 'Nachbau kaputt' })
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), [])
|
||||
assert.equal(betriebLog().length, 1)
|
||||
assert.match(betriebLog()[0], /Nachbau kaputt/)
|
||||
assert.equal(teamMails().length, 0)
|
||||
assert.equal(tr.aufrufe, 0)
|
||||
|
||||
assert.deepEqual(await pruefeBetrieb(plus(MIN)), [], 'beim nächsten Lauf geht es normal weiter')
|
||||
assert.equal(betriebLog().length, 1)
|
||||
})
|
||||
|
||||
test('pruefeBetrieb: ein dauerhafter Lesefehler loggt höchstens stündlich und löst nie eine Mail-Schleife aus; das Budget wird trotzdem geprüft', async () => {
|
||||
config.termine.mailsProStunde = 10
|
||||
await belegeBudget(7)
|
||||
await mitLesefehler('termineOutbox', async () => {
|
||||
for (let minute = 1; minute <= 5; minute++) assert.deepEqual(await pruefeBetrieb(plus(minute * MIN)), ['budget'], 'das Budget liest nichts aus Appwrite')
|
||||
assert.equal(betriebLogMit(/nicht möglich/).length, 1, 'ein Log für fünf Läufe')
|
||||
assert.deepEqual(await pruefeBetrieb(plus(61 * MIN)), [])
|
||||
assert.equal(betriebLogMit(/nicht möglich/).length, 2, 'nach einer Stunde wieder')
|
||||
})
|
||||
assert.equal(teamMails().length, 1, 'nur die Budget-Mail')
|
||||
})
|
||||
|
||||
test('pruefeBetrieb: scheitert die Team-Mail, steht das im Log, der Vorfall bleibt gemerkt und die Mail wird nicht jede Minute neu versucht', async () => {
|
||||
config.termine.mailsProStunde = 10
|
||||
await belegeBudget(7)
|
||||
tr.wirf = (mail) => (ist20(mail) ? new Error('Verbindung abgelehnt') : null)
|
||||
|
||||
assert.deepEqual(await pruefeBetrieb(plus(MIN)), ['budget'])
|
||||
assert.equal(tr.teamVersuche, 1)
|
||||
assert.equal(teamMails().length, 0)
|
||||
assert.equal(betriebLogMit(/Mailbudget 7\/10/).length, 1, 'der Vorfall steht im Log (Rückfall)')
|
||||
assert.ok(logZeilen().some((zeile) => /Admin-Hinweis fehlgeschlagen/.test(zeile)), 'der Mailer protokolliert den Fehler')
|
||||
assert.equal(betriebLogMit(/Team-Mail.*nicht gesendet/).length, 1)
|
||||
|
||||
for (let minute = 2; minute <= 10; minute++) assert.deepEqual(await pruefeBetrieb(plus(minute * MIN)), ['budget'])
|
||||
assert.equal(tr.teamVersuche, 1, 'kein weiterer Versuch innerhalb der Abkühlzeit')
|
||||
assert.equal(betriebLogMit(/Mailbudget 7\/10/).length, 1)
|
||||
|
||||
tr.wirf = null
|
||||
await meldeVorfall('budget', 'Noch einmal', plus(6 * STUNDE + MIN))
|
||||
assert.equal(teamMails().length, 1, 'nach der Abkühlzeit klappt es wieder')
|
||||
})
|
||||
|
||||
test('pruefeBetrieb: ohne Empfänger (CHAT_NOTIFY_EMAILS leer) wirft nichts, das Log bleibt', async () => {
|
||||
config.chatNotify.emails = []
|
||||
config.termine.mailsProStunde = 10
|
||||
await belegeBudget(7)
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), ['budget'])
|
||||
assert.equal(betriebLogMit(/Mailbudget 7\/10/).length, 1)
|
||||
assert.equal(betriebLogMit(/Team-Mail.*nicht gesendet.*nicht konfiguriert/).length, 1)
|
||||
assert.equal(tr.teamVersuche, 0)
|
||||
})
|
||||
|
||||
test('pruefeBetrieb: mehrere Vorfälle zugleich, jeder mit eigener Meldung und eigener Überschrift; verlangt eine gültige Uhrzeit', async () => {
|
||||
await richteAlleVorfaelleEin()
|
||||
assert.deepEqual(await pruefeBetrieb(JETZT), ['budget', 'queue', 'pause'])
|
||||
assert.equal(teamMails().length, 3)
|
||||
assert.deepEqual(
|
||||
teamMails().map((mail) => mail.subject).sort(),
|
||||
['[Terminplaner] Mail-Warteschlange staut sich', '[Terminplaner] Mailbudget fast aufgebraucht', '[Terminplaner] Mailversand pausiert'],
|
||||
)
|
||||
assert.equal(betriebLog().length, 3)
|
||||
await assert.rejects(() => pruefeBetrieb('jetzt'), TypeError)
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------- Minutenjob
|
||||
|
||||
test('minutenJob im Modus off ruft die Betriebsprüfung nicht auf: 0 Anfragen, keine Mail, kein Log', async () => {
|
||||
await richteAlleVorfaelleEin()
|
||||
tr.aufrufe = 0
|
||||
tr.senke.sent.length = 0
|
||||
log.warn.mock.resetCalls()
|
||||
log.error.mock.resetCalls()
|
||||
config.termine.mode = 'off'
|
||||
|
||||
let ergebnis
|
||||
const n = await zaehleAnfragen(async () => {
|
||||
ergebnis = await minutenJob(JETZT)
|
||||
})
|
||||
assert.deepEqual(ergebnis, { aus: true })
|
||||
assert.equal(n, 0)
|
||||
assert.equal(tr.aufrufe, 0)
|
||||
assert.equal(betriebLog().length, 0)
|
||||
})
|
||||
|
||||
test('minutenJob prüft den Betrieb am Ende des Laufs: Vorfälle führen zu Log und Team-Mail, das Ergebnis des Laufs bleibt unverändert', async () => {
|
||||
await richteAlleVorfaelleEin()
|
||||
tr.senke.sent.length = 0
|
||||
|
||||
const ergebnis = await minutenJob(JETZT)
|
||||
assert.deepEqual(ergebnis, { verfallen: 0, faellig: 0, gesendet: 0, fehler: 0 }, 'die Pause hält die Warteschlange an, die Prüfung zählt nicht als Fehler')
|
||||
assert.equal(teamMails().length, 3)
|
||||
assert.equal(betriebLogMit(/Mailbudget 7\/10/).length, 1)
|
||||
assert.equal(betriebLogMit(/seit 11 Min überfällig/).length, 1)
|
||||
assert.equal(betriebLogMit(/pausiert bis 05\.10\.2026, 10:04 Uhr/).length, 1)
|
||||
|
||||
await minutenJob(plus(MIN))
|
||||
assert.equal(teamMails().length, 3, 'der nächste Takt meldet nichts doppelt')
|
||||
assert.equal(betriebLog().length, 3)
|
||||
})
|
||||
|
||||
test('minutenJob: eine unlesbare Warteschlange für die Betriebsprüfung ändert nichts am Lauf (kein Wurf, Lauf ohne zusätzlichen Fehler)', async () => {
|
||||
const ergebnis = await mitLesefehler('termineOutbox', () => minutenJob(JETZT))
|
||||
assert.equal(ergebnis.verfallen, 0)
|
||||
assert.equal(ergebnis.fehler, 1, 'nur der Schritt Warteschlange zählt; die Betriebsprüfung fügt keinen Fehler hinzu')
|
||||
})
|
||||
Reference in new issue
Block a user