tickte-system/tests/unit/workersApi.test.mjs

import test from 'node:test'
import assert from 'node:assert/strict'
import { loadModule } from './load.mjs'

// API-Client der Hustler-Seite: URLs, Methoden, Header, deutsche Fehlertexte, JWT-Wiederholung, Pult-Prüfungen
const { createWorkersApi, REQUEST_TIMEOUT_MS, AUTH_COOLDOWN_MS } = await loadModule('src/lib/workersApi.js')
const { createJwtCache } = await loadModule('src/lib/serverpulsAuth.js')

const jwts = []
const getJwt = async (o) => {
  jwts.push(o?.fresh === true)
  return o?.fresh ? 'jwt-neu' : 'jwt-alt'
}

function fakeFetch(replies) {
  const calls = []
  const fn = async (url, init) => {
    calls.push({ url, init })
    const r = replies.shift()
    if (r instanceof Error) throw r
    return {
      ok: r.status >= 200 && r.status < 300,
      status: r.status,
      json: async () => {
        if (r.body === undefined) throw new SyntaxError('kein JSON')
        return r.body
      },
    }
  }
  fn.calls = calls
  return fn
}

const okReplies = (n) => Array.from({ length: n }, () => ({ status: 200, body: {} }))

test('URLs, Methoden, Header, Body', async () => {
  const f = fakeFetch(okReplies(12))
  const api = createWorkersApi({ getJwt, fetchImpl: f })
  await api.state()
  await api.events('2026-10-17T20:00:00.000+00:00')
  await api.events(null, 500)
  await api.trace('kim')
  await api.pause(true)
  await api.settings()
  await api.saveSettings({ warnPct: 70 })
  await api.pult()
  await api.pultAction('p1', 'claim')
  await api.botleads({ room: 'netz', q: 'Bäcker', page: 2 })
  await api.botleads({ id: 'p1' })
  await api.prospect('x/y')
  assert.deepEqual(f.calls.map((c) => [c.init.method || 'GET', c.url]), [
    ['GET', '/api/workers/state'],
    ['GET', '/api/workers/events?after=2026-10-17T20%3A00%3A00.000%2B00%3A00&limit=200'],
    ['GET', '/api/workers/events?limit=200'],
    ['GET', '/api/workers/worker/kim/trace?limit=50'],
    ['POST', '/api/workers/pause'],
    ['GET', '/api/workers/settings'],
    ['PUT', '/api/workers/settings'],
    ['GET', '/api/workers/pult?status=offen'],
    ['POST', '/api/workers/pult/p1/claim'],
    ['GET', '/api/workers/botleads?room=netz&q=B%C3%A4cker&page=2'],
    ['GET', '/api/workers/botleads?id=p1'],
    ['GET', '/api/workers/prospect/x%2Fy'],
  ])
  assert.equal(f.calls[0].init.headers['X-Appwrite-JWT'], 'jwt-alt')
  assert.equal(f.calls[4].init.body, JSON.stringify({ paused: true }))
  assert.equal(f.calls[4].init.headers['Content-Type'], 'application/json')
  assert.equal(f.calls[6].init.body, JSON.stringify({ warnPct: 70 }))
})

test('Fehlertexte (Review Focus 1)', async () => {
  const run = (reply) => createWorkersApi({ getJwt, fetchImpl: fakeFetch([reply]) }).state().then(() => null, (e) => [e.message, e.status])
  assert.deepEqual(await run({ status: 200, body: undefined }), ['Der Hustler-Dienst antwortet nicht richtig.', 200]) // nginx liefert index.html
  assert.deepEqual(await run({ status: 404, body: undefined }), ['Der Hustler-Dienst antwortet nicht richtig.', 404])
  assert.deepEqual(await run({ status: 502, body: undefined }), ['Der Hustler-Dienst ist gerade nicht erreichbar.', 502])
  assert.deepEqual(await run(new TypeError('fetch failed')), ['Der Hustler-Dienst ist gerade nicht erreichbar.', 0])
  assert.deepEqual(await run({ status: 403, body: {} }), ['Dafür fehlt dir die Berechtigung.', 403])
  assert.deepEqual(await run({ status: 400, body: { error: 'Tagesgrenze ungültig.' } }), ['Tagesgrenze ungültig.', 400])
  assert.deepEqual(await run({ status: 500, body: {} }), ['Hustler-Fehler 500', 500])
  await assert.rejects(
    createWorkersApi({ getJwt: async () => { throw Object.assign(new Error('x'), { code: 401 }) }, fetchImpl: fakeFetch([]) }).state(),
    { message: 'Anmeldung abgelaufen. Bitte neu anmelden.', status: 401 },
  )
})

test('401 ⇒ einmal mit frischem JWT wiederholen, danach Meldung', async () => {
  jwts.length = 0
  const f = fakeFetch([{ status: 401, body: {} }, { status: 200, body: { ok: 1 } }])
  assert.deepEqual(await createWorkersApi({ getJwt, fetchImpl: f }).state(), { ok: 1 })
  assert.deepEqual(jwts, [false, true])
  assert.equal(f.calls[1].init.headers['X-Appwrite-JWT'], 'jwt-neu')
  await assert.rejects(
    createWorkersApi({ getJwt, fetchImpl: fakeFetch([{ status: 401, body: {} }, { status: 401, body: {} }]) }).state(),
    { message: 'Anmeldung abgelaufen. Bitte neu anmelden.', status: 401 },
  )
})

test('pult: ein Status, Komma-Liste oder Array (Übersicht §7); unbekannte Status werden abgewiesen, ohne Anfrage', async () => {
  const f = fakeFetch(okReplies(5))
  const api = createWorkersApi({ getJwt, fetchImpl: f })
  await api.pult('offen,in_arbeit')
  await api.pult(['gesendet', 'verworfen', 'erledigt'])
  await api.pult(' veraltet ')
  await api.pult('')
  await api.pult('gesendet, verworfen , erledigt')
  // Kommas bleiben unkodiert, Einträge getrimmt, leer = offen
  assert.deepEqual(f.calls.map((c) => c.url), [
    '/api/workers/pult?status=offen,in_arbeit',
    '/api/workers/pult?status=gesendet,verworfen,erledigt',
    '/api/workers/pult?status=veraltet',
    '/api/workers/pult?status=offen',
    '/api/workers/pult?status=gesendet,verworfen,erledigt',
  ])
  for (const bad of ['offen,../x', 'quatsch', ['offen', 'x y'], 'offen;in_arbeit', 'offen,,in_arbeit']) {
    await assert.rejects(api.pult(bad), /Unbekannter Pult-Status/)
  }
  assert.equal(f.calls.length, 5) // die fünf abgewiesenen Aufrufe haben nichts gesendet
})

test('pultAction: nur bekannte Aktionen, Pfad-Tricks abgewiesen', async () => {
  const f = fakeFetch(okReplies(7))
  const api = createWorkersApi({ getJwt, fetchImpl: f })
  for (const bad of ['../x', 'delete', '']) {
    await assert.rejects(api.pultAction('p1', bad), /Unbekannte Aktion/)
  }
  assert.equal(f.calls.length, 0)
  for (const a of ['claim', 'sent', 'discard', 'done', 'reply', 'approve-preview', 'paste']) {
    await api.pultAction('p1', a, a === 'reply' || a === 'paste' ? { text: 'x' } : undefined)
  }
  assert.deepEqual(f.calls.map((c) => c.url.split('/').pop()), ['claim', 'sent', 'discard', 'done', 'reply', 'approve-preview', 'paste'])
  assert.equal(f.calls[4].init.body, JSON.stringify({ text: 'x' }))
  // Plattform-Folge-Antwort einfügen (P4-T34)
  assert.deepEqual([f.calls[6].url, f.calls[6].init.method, f.calls[6].init.body], ['/api/workers/pult/p1/paste', 'POST', JSON.stringify({ text: 'x' })])
})

test('limit wird geklemmt (Ereignisse 1..200, Spur 1..50)', async () => {
  const f = fakeFetch(okReplies(3))
  const api = createWorkersApi({ getJwt, fetchImpl: f })
  await api.trace('kim', 999)
  await api.events(null, 0)
  await api.events(null, 150)
  assert.deepEqual(f.calls.map((c) => c.url), [
    '/api/workers/worker/kim/trace?limit=50',
    '/api/workers/events?limit=1',
    '/api/workers/events?limit=150',
  ])
})

// ---- Endprüfung P2: Zeitgrenze je Abruf und Sperre für frische JWTs nach einer 401-Folge ----

const DOWN = 'Der Hustler-Dienst ist gerade nicht erreichbar.'
const SESSION = 'Anmeldung abgelaufen. Bitte neu anmelden.'

test('Zeitgrenze: ein hängender fetch endet mit der Dienst-Meldung (status 0), das Signal wird abgebrochen', async () => {
  const signals = []
  const hang = (url, init) => {
    signals.push(init.signal)
    return new Promise(() => {}) // beachtet das Signal nicht einmal: die Zeitgrenze muss trotzdem greifen
  }
  const api = createWorkersApi({ getJwt, fetchImpl: hang, timeoutMs: 30 })
  const t0 = Date.now()
  await assert.rejects(api.state(), { message: DOWN, status: 0 })
  assert.ok(Date.now() - t0 < 2000)
  assert.equal(signals.length, 1)
  assert.equal(signals[0].aborted, true)
  // jeder Aufruf hat seine eigene Zeitgrenze (hier: Schreibaufruf und Spur)
  await assert.rejects(api.pause(true), { message: DOWN, status: 0 })
  await assert.rejects(api.trace('kim'), { message: DOWN, status: 0 })
  assert.equal(signals.length, 3)
})

test('Zeitgrenze: auch eine Antwort, deren Rumpf nie ankommt, und ein hängendes createJWT enden mit der Dienst-Meldung', async () => {
  const stalledBody = async () => ({ ok: true, status: 200, json: () => new Promise(() => {}) })
  await assert.rejects(createWorkersApi({ getJwt, fetchImpl: stalledBody, timeoutMs: 30 }).state(), { message: DOWN, status: 0 })
  const hungJwt = () => new Promise(() => {})
  const f = fakeFetch(okReplies(1))
  await assert.rejects(createWorkersApi({ getJwt: hungJwt, fetchImpl: f, timeoutMs: 30 }).state(), { message: DOWN, status: 0 })
  assert.equal(f.calls.length, 0) // ohne JWT ging nichts hinaus
})

test('Zeitgrenze: rechtzeitige Antworten bleiben unberührt, ein späterer Abruf klappt wieder (Schleife wird frei)', async () => {
  let n = 0
  const flaky = async () => {
    n += 1
    if (n === 1) return new Promise(() => {})
    return { ok: true, status: 200, json: async () => ({ n }) }
  }
  const api = createWorkersApi({ getJwt, fetchImpl: flaky, timeoutMs: 40 })
  await assert.rejects(api.state(), { message: DOWN, status: 0 })
  assert.deepEqual(await api.state(), { n: 2 })
  const quick = createWorkersApi({ getJwt, fetchImpl: fakeFetch(okReplies(1)) }) // Standard-Zeitgrenze 20 s: wird nach der Antwort aufgeräumt
  assert.deepEqual(await quick.state(), {})
})

test('Zeitgrenze: Standardwerte 20 s und 2 min', () => {
  assert.equal(REQUEST_TIMEOUT_MS, 20000)
  assert.equal(AUTH_COOLDOWN_MS, 120000)
})

test('401-Folge: danach kein frisches JWT mehr, bis die Sperre abgelaufen ist (höchstens ein createJWT je Sperre)', async () => {
  jwts.length = 0
  let t = 1_000_000
  const calls = []
  const always401 = async (url, init) => {
    calls.push(init.headers['X-Appwrite-JWT'])
    return { ok: false, status: 401, json: async () => ({}) }
  }
  const api = createWorkersApi({ getJwt, fetchImpl: always401, now: () => t, authCooldownMs: 60000 })
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.deepEqual(jwts, [false, true])
  assert.deepEqual(calls, ['jwt-alt', 'jwt-neu'])   // Versuch und Wiederholung

  // innerhalb der Sperre: je Abruf genau eine Anfrage mit dem gespeicherten JWT, nie ein frisches, die Meldung bleibt
  for (let i = 0; i < 20; i += 1) {
    t += 2900   // 20 Schleifendurchläufe innerhalb der Sperre von 60 s (Zustand, Ereignisse und Spur zusammen)
    await assert.rejects(api.events(null), { message: SESSION, status: 401 })
  }
  assert.equal(jwts.filter((fresh) => fresh).length, 1)
  assert.equal(calls.length, 2 + 20)

  // nach Ablauf der Sperre wird wieder einmal erneuert, danach beginnt die nächste Sperre
  t += 2100
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.equal(jwts.filter((fresh) => fresh).length, 2)
  t += 5000
  await assert.rejects(api.trace('kim'), { message: SESSION, status: 401 })
  assert.equal(jwts.filter((fresh) => fresh).length, 2)
})

test('401-Folge: Erfolg hebt die Sperre auf, ein einzelnes 401 danach wird wieder mit frischem JWT wiederholt', async () => {
  jwts.length = 0
  let t = 0
  const replies = [
    { status: 401, body: {} }, { status: 401, body: {} },          // Folge ⇒ Sperre
    { status: 200, body: { ok: 1 } },                              // Dienst nimmt das gespeicherte JWT wieder an ⇒ Sperre weg
    { status: 401, body: {} }, { status: 200, body: { ok: 2 } },   // einzelnes 401 ⇒ Wiederholung mit frischem JWT hilft
  ]
  const api = createWorkersApi({ getJwt, fetchImpl: fakeFetch(replies), now: () => t })
  await assert.rejects(api.state(), { status: 401 })
  t += 5000
  assert.deepEqual(await api.state(), { ok: 1 })
  assert.deepEqual(await api.state(), { ok: 2 })
  assert.deepEqual(jwts, [false, true, false, false, true])
})

test('401-Folge: scheitert schon die Erzeugung des frischen JWT, beginnt dieselbe Sperre', async () => {
  let t = 0
  const mints = []
  const brokenFresh = async (o) => {
    mints.push(o?.fresh === true)
    if (o?.fresh) throw Object.assign(new Error('429 Too Many Requests'), { code: 429 })
    return 'jwt-alt'
  }
  const api = createWorkersApi({ getJwt: brokenFresh, fetchImpl: fakeFetch(Array.from({ length: 6 }, () => ({ status: 401, body: {} }))), now: () => t, authCooldownMs: 60000 })
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  t += 10000
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  t += 10000
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.deepEqual(mints, [false, true])   // ein einziger Versuch, ein frisches JWT zu erzeugen; danach bis zum Ende der Sperre gar keiner mehr (Endprüfung P3)
  t += 60000
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.deepEqual(mints, [false, true, false, true])   // nach der Sperre genau ein neuer Versuch (gespeichertes JWT, 401, frisches JWT scheitert wieder)
})

test('401-Folge: andere Fehler (403, 500, 502) heben die Sperre auf, weil der Dienst das JWT angenommen hat', async () => {
  jwts.length = 0
  let t = 0
  const api = createWorkersApi({
    getJwt,
    fetchImpl: fakeFetch([{ status: 401, body: {} }, { status: 401, body: {} }, { status: 403, body: {} }, { status: 401, body: {} }, { status: 200, body: {} }]),
    now: () => t,
  })
  await assert.rejects(api.state(), { status: 401 })
  await assert.rejects(api.state(), { status: 403 })
  assert.deepEqual(await api.state(), {})   // 401, Wiederholung frisch ⇒ 200
  assert.deepEqual(jwts, [false, true, false, false, true])
})

// ---- P3-T21: Kennungen im Pfad, Sperre auch beim Scheitern von createJWT, Zurücksetzen beim Abmelden ----

test('Kennungen im Pfad: leer, ".", ".." oder keine Zeichenkette ⇒ "Ungültige Kennung." ohne Netzaufruf', async () => {
  const f = fakeFetch(okReplies(4))
  const api = createWorkersApi({ getJwt, fetchImpl: f })
  const bad = [['pultAction', '..', 'claim'], ['pultAction', '.', 'sent'], ['pultAction', '', 'done'], ['pultAction', null, 'claim'], ['pultAction', 7, 'claim'],
    ['prospect', ''], ['prospect', '.'], ['prospect', '..'], ['prospect', undefined], ['prospect', { toString: () => 'x' }],
    ['trace', ''], ['trace', '..'], ['trace', '.'], ['trace', null], ['trace', ['kim']]]
  for (const [method, ...args] of bad) {
    const out = api[method](...args)
    assert.ok(out instanceof Promise, `${method}(${String(args[0])}) liefert ein Promise, wirft nicht synchron`)
    await assert.rejects(out, { message: 'Ungültige Kennung.' }, `${method}(${String(args[0])})`)
  }
  assert.equal(f.calls.length, 0)
  // sonst wird kodiert, auch Schrägstriche und Prozentzeichen; Punkte allein sind nur als ganze Kennung verboten
  await api.prospect('a/b')
  await api.pultAction('a b%', 'claim')
  await api.trace('k/../m')
  await api.prospect('p..1')
  assert.deepEqual(f.calls.map((c) => c.url), [
    '/api/workers/prospect/a%2Fb',
    '/api/workers/pult/a%20b%25/claim',
    '/api/workers/worker/k%2F..%2Fm/trace?limit=50',
    '/api/workers/prospect/p..1',
  ])
})

test('Kennungen im Pfad: die Aktionsprüfung bleibt vorn (unbekannte Aktion wird weiter als solche gemeldet)', async () => {
  const f = fakeFetch([])
  const api = createWorkersApi({ getJwt, fetchImpl: f })
  await assert.rejects(api.pultAction('p1', 'delete'), /Unbekannte Aktion/)
  await assert.rejects(api.pultAction('..', 'delete'), /Unbekannte Aktion/)
  assert.equal(f.calls.length, 0)
})

// Verdrahtung wie in workersClient.js: echter JWT-Cache, `fresh` verwirft ihn vor dem Holen
function cachedJwt(createJWT, now) {
  const cache = createJwtCache({ createJWT, now })
  return (options) => {
    if (options?.fresh) cache.invalidate()
    return cache.get()
  }
}

test('createJWT scheitert (Appwrite 429): Sperre wie nach der zweiten 401, auch bei leerem Cache; danach genau ein neuer Versuch', async () => {
  let t = 0
  let creates = 0
  let failing = true
  const getJwtCached = cachedJwt(async () => {
    creates += 1
    if (failing) throw Object.assign(new Error('Rate limit'), { code: 429 })
    return { jwt: `jwt-${creates}` }
  }, () => t)
  const f = fakeFetch(okReplies(8))
  const api = createWorkersApi({ getJwt: getJwtCached, fetchImpl: f, now: () => t, authCooldownMs: 60000 })

  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.equal(creates, 1)
  // Schleifen (5 s / 15 s) innerhalb der Sperre: kein weiterer createJWT-Aufruf, keine Anfrage an den Dienst, immer SESSION_TEXT
  for (let i = 0; i < 11; i += 1) {
    t += 5000
    await assert.rejects([api.state, api.events, api.settings][i % 3](), { message: SESSION, status: 401 })
  }
  assert.equal(t, 55000)
  assert.equal(creates, 1)
  assert.equal(f.calls.length, 0)

  // Sperre vorbei: genau ein Versuch, er scheitert wieder ⇒ neue Sperre
  t += 6000
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.equal(creates, 2)
  t += 30000
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.equal(creates, 2)

  // Appwrite erholt sich: nach der Sperre klappt der nächste Versuch, das JWT wird gecacht und der Dienst erreicht
  failing = false
  t += 31000
  assert.deepEqual(await api.state(), {})
  assert.equal(creates, 3)
  assert.equal(f.calls.length, 1)
  assert.equal(f.calls[0].init.headers['X-Appwrite-JWT'], 'jwt-3')
  assert.deepEqual(await api.state(), {})
  assert.equal(creates, 3)
})

test('createJWT scheitert beim frischen JWT nach einer 401: der leere Cache löst innerhalb der Sperre kein weiteres createJWT aus', async () => {
  let t = 0
  let creates = 0
  const getJwtCached = cachedJwt(async () => {
    creates += 1
    if (creates >= 2) throw Object.assign(new Error('Rate limit'), { code: 429 })   // das erste JWT klappt, jedes weitere nicht
    return { jwt: 'jwt-1' }
  }, () => t)
  const f = fakeFetch([{ status: 401, body: {} }, ...okReplies(4)])
  const api = createWorkersApi({ getJwt: getJwtCached, fetchImpl: f, now: () => t, authCooldownMs: 60000 })
  await assert.rejects(api.state(), { message: SESSION, status: 401 })   // 401, dann scheitert das frische JWT (Cache ist danach leer)
  assert.equal(creates, 2)
  assert.equal(f.calls.length, 1)
  for (let i = 0; i < 5; i += 1) {
    t += 10000
    await assert.rejects(api.events(null), { message: SESSION, status: 401 })
  }
  assert.equal(creates, 2)
  assert.equal(f.calls.length, 1)
  t += 20000   // 70 s nach dem Scheitern: Sperre vorbei
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.equal(creates, 3)
})

test('resetAuth (Abmelden): hebt die Sperre auf, der nächste Abruf holt sofort wieder ein JWT', async () => {
  let t = 0
  const asked = []
  const failing = { on: true }
  const getJwtFlaky = async (o) => {
    asked.push(o?.fresh === true)
    if (failing.on) throw Object.assign(new Error('429'), { code: 429 })
    return 'jwt-neu'
  }
  const f = fakeFetch(okReplies(2))
  const api = createWorkersApi({ getJwt: getJwtFlaky, fetchImpl: f, now: () => t, authCooldownMs: 60000 })
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  t += 1000
  await assert.rejects(api.state(), { message: SESSION, status: 401 })
  assert.deepEqual(asked, [false])   // gesperrt
  failing.on = false
  assert.equal(typeof api.resetAuth, 'function')
  api.resetAuth()
  assert.deepEqual(await api.state(), {})
  assert.deepEqual(asked, [false, false])
  assert.equal(f.calls.length, 1)

  // auch die Sperre nach einer 401-Folge fällt: ein neues einzelnes 401 darf wieder mit frischem JWT wiederholt werden
  const g = fakeFetch([{ status: 401, body: {} }, { status: 401, body: {} }, { status: 401, body: {} }, { status: 200, body: { ok: 1 } }])
  const api2 = createWorkersApi({ getJwt, fetchImpl: g, now: () => t, authCooldownMs: 60000 })
  jwts.length = 0
  await assert.rejects(api2.state(), { status: 401 })   // 401 + 401 ⇒ Sperre
  api2.resetAuth()
  assert.deepEqual(await api2.state(), { ok: 1 })
  assert.deepEqual(jwts, [false, true, false, true])
})

test('ein hängendes createJWT (Zeitgrenze) ist kein Scheitern und löst keine Sperre aus', async () => {
  let asked = 0
  const hung = () => { asked += 1; return new Promise(() => {}) }
  const api = createWorkersApi({ getJwt: hung, fetchImpl: fakeFetch([]), timeoutMs: 20 })
  await assert.rejects(api.state(), { message: DOWN, status: 0 })
  await assert.rejects(api.state(), { message: DOWN, status: 0 })
  assert.equal(asked, 2)   // die Zeitgrenze (Netz/Ruhezustand) sperrt nichts: ein nächster Abruf versucht es wieder
})

// ---- Endprüfung P3 (W1): gesperrt wird nur, wenn Appwrite createJWT mit einem HTTP-Code ab 400 abgelehnt hat; Übertragungsfehler nicht ----

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

test('createJWT: Übertragungsfehler (TypeError, SDK-Fehler mit code 0, Fehler ohne Code) geben DOWN/0 und sperren nichts', async () => {
  const transport = [
    new TypeError('Failed to fetch'),
    Object.assign(new Error('Load failed'), { code: 0 }),   // so meldet das Appwrite-SDK einen Netzfehler (client.ts: AppwriteException mit code 0)
    new Error('irgendwas'),
    Object.assign(new Error('Code ist keine Zahl'), { code: '429' }),
    Object.assign(new Error('Code nicht ganzzahlig'), { code: 429.5 }),
    Object.assign(new Error('Code unter 400'), { code: 399 }),
    null,
    undefined,
  ]
  for (const failure of transport) {
    const calls = []
    const getJwtFlaky = async () => { calls.push(1); throw failure }
    const f = fakeFetch(okReplies(1))
    const api = createWorkersApi({ getJwt: getJwtFlaky, fetchImpl: f, now: () => 0 })
    await assert.rejects(api.state(), { message: DOWN, status: 0 }, String(failure))
    await assert.rejects(api.state(), { message: DOWN, status: 0 }, String(failure))   // zweiter Abruf: nicht gesperrt, getJwt wird wieder gerufen
    assert.equal(calls.length, 2, String(failure))
    assert.equal(f.calls.length, 0)
  }
})

test('createJWT: jeder HTTP-Code ab 400 sperrt (401, 403, 429, 500, 503), nur Appwrites echte Ablehnung zählt', async () => {
  for (const code of [400, 401, 403, 429, 500, 503]) {
    let t = 0
    let creates = 0
    const getJwtRefused = async () => { creates += 1; throw Object.assign(new Error('abgelehnt'), { code }) }
    const api = createWorkersApi({ getJwt: getJwtRefused, fetchImpl: fakeFetch([]), now: () => t, authCooldownMs: 60000 })
    await assert.rejects(api.state(), { message: SESSION, status: 401 }, `code ${code}`)
    t += 10000
    await assert.rejects(api.events(null), { message: SESSION, status: 401 }, `code ${code}`)
    assert.equal(creates, 1, `code ${code}`)   // gesperrt: kein zweiter createJWT-Aufruf
  }
})

test('createJWT: offline (TypeError) gibt DOWN/0, ein Abruf 10 s später mit zurückgekehrtem Netz klappt sofort', async () => {
  let t = 0
  let online = false
  let creates = 0
  const getJwtNet = async () => {
    creates += 1
    if (!online) throw new TypeError('Failed to fetch')
    return 'jwt-1'
  }
  const f = fakeFetch(okReplies(2))
  const api = createWorkersApi({ getJwt: getJwtNet, fetchImpl: f, now: () => t })   // Standard-Sperre 2 min: sie darf nicht greifen
  await assert.rejects(api.state(), { message: DOWN, status: 0 })
  assert.equal(creates, 1)
  assert.equal(f.calls.length, 0)
  t += 10000
  online = true
  assert.deepEqual(await api.state(), {})
  assert.equal(creates, 2)
  assert.equal(f.calls.length, 1)
  assert.equal(f.calls[0].init.headers['X-Appwrite-JWT'], 'jwt-1')
})

test('createJWT: späte Ablehnung nach der Zeitgrenze (TypeError und code 0) sperrt nicht', async () => {
  for (const failure of [new TypeError('Failed to fetch'), Object.assign(new Error('Load failed'), { code: 0 })]) {
    let t = 0
    let creates = 0
    let online = false
    const getJwtLate = async () => {
      creates += 1
      if (online) return 'jwt-1'
      await sleep(25)   // trifft erst nach der Zeitgrenze (10 ms) ein: der Aufrufer hat DOWN/0 schon bekommen
      throw failure
    }
    const f = fakeFetch(okReplies(1))
    const api = createWorkersApi({ getJwt: getJwtLate, fetchImpl: f, now: () => t, timeoutMs: 10 })
    await assert.rejects(api.state(), { message: DOWN, status: 0 })
    await sleep(40)   // die späte Ablehnung ist inzwischen angekommen
    t += 5000
    online = true
    assert.deepEqual(await api.state(), {})   // nicht gesperrt: der nächste Takt holt ein JWT
    assert.equal(creates, 2)
    assert.equal(f.calls.length, 1)
  }
})

test('createJWT: späte Ablehnung nach der Zeitgrenze mit code 429 sperrt weiter', async () => {
  let t = 0
  let creates = 0
  const getJwtLate429 = async () => {
    creates += 1
    await sleep(25)
    throw Object.assign(new Error('Rate limit'), { code: 429 })
  }
  const f = fakeFetch(okReplies(2))
  const api = createWorkersApi({ getJwt: getJwtLate429, fetchImpl: f, now: () => t, timeoutMs: 10, authCooldownMs: 60000 })
  await assert.rejects(api.state(), { message: DOWN, status: 0 })   // dem Aufrufer wurde schon DOWN/0 gemeldet
  await sleep(40)
  t += 5000
  await assert.rejects(api.state(), { message: SESSION, status: 401 })   // die echte Ablehnung zählt gegen die Begrenzung: Sperre
  assert.equal(creates, 1)
  assert.equal(f.calls.length, 0)
  t += 60000
  await assert.rejects(api.state(), { message: DOWN, status: 0 })   // nach der Sperre genau ein neuer Versuch
  assert.equal(creates, 2)
})

test('createJWT: Übertragungsfehler beim frischen JWT nach einer 401 sperrt nicht (nur die 401-Folge selbst)', async () => {
  let t = 0
  const mints = []
  let online = true
  const getJwtFresh = async (o) => {
    mints.push(o?.fresh === true)
    if (o?.fresh && !online) throw new TypeError('Failed to fetch')
    return o?.fresh ? 'jwt-neu' : 'jwt-alt'
  }
  const f = fakeFetch([{ status: 401, body: {} }, { status: 401, body: {} }, { status: 200, body: { ok: 1 } }])
  const api = createWorkersApi({ getJwt: getJwtFresh, fetchImpl: f, now: () => t })
  online = false
  await assert.rejects(api.state(), { message: DOWN, status: 0 })   // 401, dann Netz weg beim frischen JWT
  t += 5000
  online = true
  assert.deepEqual(await api.state(), { ok: 1 })   // 401 mit dem gespeicherten JWT, die Wiederholung mit frischem JWT darf wieder erfolgen und klappt
  assert.deepEqual(mints, [false, true, false, true])   // keine Sperre: weder für frische JWTs noch für createJWT überhaupt
})