90 lines
8.6 KiB
TypeScript
90 lines
8.6 KiB
TypeScript
import assert from "node:assert/strict"
|
|
import { setTimeout as delay } from "node:timers/promises"
|
|
import Fastify from "fastify"
|
|
import { createNetworkRoutes } from "../routes/network.js"
|
|
import { createNetworkHostResolver, resolveHostsSchema } from "./network-host-resolution.js"
|
|
import { permissionForRequest } from "../lib/permissions.js"
|
|
|
|
assert.equal(permissionForRequest("POST", "/api/network/resolve-hosts"), "mm:network:write")
|
|
|
|
for (const host of ["https://example.com", "example.com:80", "x\ny", "../x", "a;b", "__proto__", "a..b", "-bad", "bad-", "256.1.1.1", "001.2.3.4", "", "x".repeat(64) + ".test"]) assert.equal(resolveHostsSchema.safeParse({ hosts: [host] }).success, false, host)
|
|
assert.equal(resolveHostsSchema.safeParse({ hosts: Array<string>(33).fill("127.0.0.1") }).success, false)
|
|
let calls = 0, clock = Date.now()
|
|
const resolver = createNetworkHostResolver({ now: () => clock, cacheLimit: 1, lookup: async () => { calls++; return { address: "192.0.2.1", family: 4 } } })
|
|
let result = await resolver({ hosts: [" Example.Test ", "EXAMPLE.test", "127.0.0.1"] })
|
|
assert.equal(calls, 1); assert.equal(Object.keys(result.results).length, 2); assert.equal(result.observations["127.0.0.1"].state, "literal")
|
|
assert.equal(result.routerResolverVerified, false); assert.equal(result.forwardingVerified, false)
|
|
assert.equal((await resolver({ hosts: ["::1"] })).observations["::1"].state, "unsupported-family"); assert.equal(calls, 1)
|
|
let idnCalls = 0
|
|
const idn = createNetworkHostResolver({ lookup: async host => { idnCalls++; assert.equal(host, "xn--e1afmkfd.xn--p1ai"); return { address: "192.0.2.10", family: 4 } } })
|
|
assert.equal((await idn({ hosts: ["пример.рф", "xn--e1afmkfd.xn--p1ai"] })).results["пример.рф"], "192.0.2.10"); assert.equal(idnCalls, 1)
|
|
assert.equal((await resolver({ hosts: ["example.test"] })).observations["example.test"].source, "cache"); assert.equal(calls, 1)
|
|
await resolver({ hosts: ["other.test"] }); await resolver({ hosts: ["example.test"] }); assert.equal(calls, 3)
|
|
clock += 300001; await resolver({ hosts: ["example.test"] }); assert.equal(calls, 4)
|
|
result = await resolver({ hosts: ["constructor"] }); assert.equal(Object.getPrototypeOf(result.results), null); assert.equal(result.results.constructor, "192.0.2.1")
|
|
let negativeCalls = 0
|
|
const negative = createNetworkHostResolver({ lookup: async () => { negativeCalls++; throw Error("NEVER_DNS_PROVIDER_SECRET") } })
|
|
assert.equal((await negative({ hosts: ["unresolved.test"] })).observations["unresolved.test"].state, "unresolved")
|
|
assert.equal((await negative({ hosts: ["unresolved.test"] })).observations["unresolved.test"].source, "cache"); assert.equal(negativeCalls, 1)
|
|
assert.ok(!JSON.stringify(await negative({ hosts: ["unresolved.test"] })).includes("NEVER_"))
|
|
assert.equal((await createNetworkHostResolver({ lookup: async () => ({ address: "::1", family: 6 }) })({ hosts: ["wrong-family.test"] })).results["wrong-family.test"], null)
|
|
|
|
let release!: (value: { address: string; family: number }) => void, pendingCalls = 0
|
|
const pending = new Promise<{ address: string; family: number }>(resolve => { release = resolve })
|
|
const bounded = createNetworkHostResolver({ timeoutMs: 10, maxPending: 1, lookup: async host => { pendingCalls++; return host === "held.test" ? pending : { address: "192.0.2.2", family: 4 } } })
|
|
result = await bounded({ hosts: ["held.test", "second.test"] })
|
|
assert.equal(result.observations["held.test"].state, "timeout"); assert.equal(result.observations["second.test"].state, "busy"); assert.equal(pendingCalls, 1)
|
|
release({ address: "192.0.2.3", family: 4 }); await delay(0)
|
|
assert.equal((await bounded({ hosts: ["held.test"] })).observations["held.test"].source, "cache")
|
|
assert.equal((await bounded({ hosts: ["second.test"] })).results["second.test"], "192.0.2.2"); assert.equal(pendingCalls, 2)
|
|
|
|
let dedupCalls = 0, complete!: (value: { address: string; family: number }) => void
|
|
const shared = new Promise<{ address: string; family: number }>(resolve => { complete = resolve })
|
|
const dedup = createNetworkHostResolver({ timeoutMs: 1000, lookup: async () => { dedupCalls++; return shared } })
|
|
const reads = [dedup({ hosts: ["same.test"] }), dedup({ hosts: ["SAME.test"] })]
|
|
await delay(0); assert.equal(dedupCalls, 1); complete({ address: "192.0.2.4", family: 4 }); await Promise.all(reads)
|
|
|
|
let permitted = true, gatedCalls = 0, allow!: (value: { address: string; family: number }) => void
|
|
const gate = new Promise<{ address: string; family: number }>(resolve => { allow = resolve })
|
|
const guarded = createNetworkHostResolver({ lookup: async () => { gatedCalls++; return gate } })
|
|
const read = guarded({ hosts: ["first.test", "next.test"] }, { assertReadable: async () => { if (!permitted) throw Error("Access revoked") } }).then(() => null, error => error)
|
|
await delay(0); assert.equal(gatedCalls, 1); permitted = false; allow({ address: "192.0.2.5", family: 4 }); assert.match(String(await read), /Access revoked/); assert.equal(gatedCalls, 1)
|
|
const cancelled = new AbortController(); cancelled.abort()
|
|
await assert.rejects(guarded({ hosts: ["next.test"] }, { signal: cancelled.signal })); assert.equal(gatedCalls, 1)
|
|
let budgetClock = 0, budgetCalls = 0
|
|
const budgeted = createNetworkHostResolver({ now: () => budgetClock, totalTimeoutMs: 10, lookup: async () => { budgetCalls++; budgetClock += 11; return new Promise(() => {}) } })
|
|
result = await budgeted({ hosts: ["budget-one.test", "budget-two.test", "budget-three.test"] })
|
|
assert.equal(budgetCalls, 1); assert.ok(Object.values(result.observations).every(row => row.state === "timeout"))
|
|
let settleAbort!: (value: { address: string; family: number }) => void, abortCalls = 0
|
|
const abortGate = new Promise<{ address: string; family: number }>(resolve => { settleAbort = resolve })
|
|
const abortResolver = createNetworkHostResolver({ maxPending: 1, lookup: async () => { abortCalls++; return abortGate } })
|
|
const midAbort = new AbortController(), abortRead = abortResolver({ hosts: ["abort-one.test", "abort-two.test"] }, { signal: midAbort.signal }).then(() => null, error => error)
|
|
await delay(0); assert.equal(abortCalls, 1); midAbort.abort(); assert.match(String(await abortRead), /cancelled/)
|
|
assert.equal((await abortResolver({ hosts: ["abort-two.test"] })).observations["abort-two.test"].state, "busy"); assert.equal(abortCalls, 1)
|
|
settleAbort({ address: "192.0.2.6", family: 4 }); await delay(0)
|
|
|
|
const app = Fastify(); await app.register(createNetworkRoutes(resolver), { prefix: "/api" })
|
|
const beforeInvalid = calls
|
|
assert.equal((await app.inject({ method: "POST", url: "/api/network/resolve-hosts", payload: { hosts: ["http://invalid.test"] } })).statusCode, 400); assert.equal(calls, beforeInvalid)
|
|
const http = await app.inject({ method: "POST", url: "/api/network/resolve-hosts", payload: { hosts: ["127.0.0.1", "127.0.0.1"] } })
|
|
assert.equal(http.statusCode, 200); assert.deepEqual(http.json(), { results: { "127.0.0.1": "127.0.0.1" } }); await app.close()
|
|
let httpCalls = 0, started!: () => void, finishHttp!: (value: { address: string; family: number }) => void
|
|
const httpStarted = new Promise<void>(resolve => { started = resolve })
|
|
const httpGate = new Promise<{ address: string; family: number }>(resolve => { finishHttp = resolve })
|
|
const httpResolver = createNetworkHostResolver({ maxPending: 1, lookup: async () => { httpCalls++; started(); return httpGate } })
|
|
const live = Fastify(); await live.register(createNetworkRoutes(httpResolver), { prefix: "/api" })
|
|
const url = await live.listen({ host: "127.0.0.1", port: 0 })
|
|
const disconnect = new AbortController()
|
|
try {
|
|
const request = fetch(url + "/api/network/resolve-hosts", { method: "POST", headers: { "content-type": "application/json", connection: "close" }, body: JSON.stringify({ hosts: ["http-first.test", "http-next.test"] }), signal: disconnect.signal }).then(() => null, error => error)
|
|
let startTimer: ReturnType<typeof setTimeout> | undefined
|
|
try { await Promise.race([httpStarted, new Promise<never>((_resolve, reject) => { startTimer = setTimeout(() => reject(new Error("REST request did not reach DNS lookup")), 5000) })]) }
|
|
finally { clearTimeout(startTimer) }
|
|
disconnect.abort(); assert.ok(await request)
|
|
await delay(20)
|
|
assert.equal(httpCalls, 1)
|
|
assert.equal((await httpResolver({ hosts: ["http-next.test"] })).observations["http-next.test"].state, "busy")
|
|
finishHttp({ address: "192.0.2.7", family: 4 }); await delay(0)
|
|
} finally { disconnect.abort(); finishHttp({ address: "192.0.2.7", family: 4 }); live.server.closeAllConnections(); await live.close() }
|
|
console.log("Host resolution: strict IPv4/hostname, dedup, bounded cache/TTL, safe unknown, no prototype/provider payload, retained pending capacity after timeout, shared in-flight lookup, revoke/cancel and actual REST parity; no external DNS")
|