Files
MikrotikManager/backend/src/services/acme-settings-test.test.ts
T

53 lines
3.3 KiB
TypeScript

import assert from "node:assert/strict"
import { createServer } from "node:http"
import { performAcmeSettingsTest, probeAcmeCloudflareToken } from "./acme-settings-test.js"
const token = "test-only-sensitive-token"
let requests = 0, mode = "accept"
const server = createServer((req, res) => {
requests++
assert.equal(req.method, "GET")
assert.equal(req.url, "/client/v4/zones?per_page=1")
assert.equal(req.headers.authorization, `Bearer ${token}`)
if (mode === "redirect") { res.writeHead(302, { location: "/unapproved" }); res.end(); return }
if (mode === "large") { res.end("x".repeat(65537)); return }
if (mode === "malformed") { res.end("invalid"); return }
res.writeHead(mode === "reject" ? 403 : 200, { "content-type": "application/json" })
res.end(JSON.stringify(mode === "reject" ? { success: false, errors: [{ message: token }] } : { success: true, result: [{ id: "private-zone", name: "private.example" }] }))
})
await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve))
const address = server.address()
assert.ok(address && typeof address !== "string")
const fetcher: typeof fetch = (url, init) => {
assert.equal(String(url), "https://api.cloudflare.com/client/v4/zones?per_page=1")
assert.equal(init?.redirect, "error")
return fetch(`http://127.0.0.1:${address.port}/client/v4/zones?per_page=1`, init)
}
try {
for (const [scenario, outcome] of [["accept", "accepted"], ["reject", "rejected"], ["large", "unknown"], ["malformed", "unknown"], ["redirect", "unknown"]] as const) {
mode = scenario
const before = requests, result = await probeAcmeCloudflareToken(token, undefined, fetcher)
assert.equal(result.outcome, outcome)
assert.equal(requests, before + 1)
assert.ok(!JSON.stringify(result).includes(token))
assert.ok(!JSON.stringify(result).includes("private-zone"))
}
let dispatches = 0, checks = 0
const probe: typeof probeAcmeCloudflareToken = async value => { assert.equal(value, token); dispatches++; return { ok: true, outcome: "accepted", message: "ok" } }
const guard = async <T>(work: () => Promise<T>) => work()
const dependencies = { readStored: async () => token, probe, guard }
await performAcmeSettingsTest({}, { ...dependencies, beforeDispatch: async () => { checks++ }, afterDispatch: async () => { checks++ } })
assert.equal(dispatches, 1); assert.equal(checks, 2)
for (const reason of ["revoke", "source drift", "protection", "pause"]) {
await assert.rejects(performAcmeSettingsTest({}, { ...dependencies, beforeDispatch: async () => { throw Error(reason) } }), new RegExp(reason))
}
const abort = new AbortController(); abort.abort()
await assert.rejects(performAcmeSettingsTest({}, { ...dependencies, signal: abort.signal }))
assert.equal(dispatches, 1)
await assert.rejects(performAcmeSettingsTest({}, { ...dependencies, afterDispatch: async () => { throw Error("late revoke") } }), /late revoke/)
assert.equal(dispatches, 2)
await assert.rejects(performAcmeSettingsTest({ endpoint: "https://other.example" }, dependencies))
assert.equal(dispatches, 2)
console.log("ACME token test: local HTTP, safe output, one dispatch, redirect/size/malformed, late/pre-dispatch fences and cancel passed")
} finally { await new Promise<void>((resolve, reject) => server.close(error => error ? reject(error) : resolve())); server.closeAllConnections() }