53 lines
3.3 KiB
TypeScript
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() }
|