Files
MikrotikManager/backend/src/services/bandwidth-node-observation.test.ts
T

182 lines
15 KiB
TypeScript

import assert from "node:assert/strict"
import { randomUUID } from "node:crypto"
import { createServer } from "node:http"
import { once } from "node:events"
import { createBandwidthNodeObservationReader, BandwidthNodeObservationError, type BandwidthNodeSourceSnapshot, type BandwidthNodeObservationScope } from "./bandwidth-node-observation.js"
const deferred = () => { let resolve!: () => void; const promise = new Promise<void>(done => { resolve = done }); return { promise, resolve } }
const bounded = <T>(work: Promise<T>) => Promise.race([work, new Promise<never>((_resolve, reject) => { const timer = setTimeout(() => reject(Error("Owned localhost fixture timed out")), 3000); timer.unref(); void work.finally(() => clearTimeout(timer)).catch(() => {}) })])
const scope = (ms = 4000): BandwidthNodeObservationScope => ({ deadlineAt: Date.now() + ms })
const denied = (code?: BandwidthNodeObservationError["code"]) => (error: unknown) => error instanceof BandwidthNodeObservationError && (!code || error.code === code)
const cases: string[] = [], requests: Array<{ method: string | undefined; path: string | undefined; authenticated: boolean }> = []
let response: unknown = { "system-id": "SYS-001", "software-id": "SOFT-002" }, status = 200, hold = false
let onRequest: (() => void) | undefined, onClosed: (() => void) | undefined
const username = "NODE_OBSERVATION_PRIVATE_USER", password = "NODE_OBSERVATION_PRIVATE_PASSWORD"
const authorization = "Basic " + Buffer.from(username + ":" + password).toString("base64")
const server = createServer((req, res) => {
requests.push({ method: req.method, path: req.url, authenticated: req.headers.authorization === authorization })
const closed = onClosed; res.once("close", () => { if (!res.writableEnded) closed?.() })
onRequest?.()
if (hold) { res.writeHead(200); res.flushHeaders(); return }
res.writeHead(status, { "content-type": "application/json", ...(status === 302 ? { location: "/must-not-follow" } : {}) })
res.end(JSON.stringify(response))
})
server.listen(0, "127.0.0.1"); await once(server, "listening")
const address = server.address(); assert(address && typeof address !== "string")
const initial: BandwidthNodeSourceSnapshot = { serverId: 17, enabled: true, sourceProof: "a".repeat(64), authorityGeneration: "trusted-source-generation",
endpoint: { host: "127.0.0.1", port: address.port, useSsl: false, verifySsl: true, username, password, routingEndpointEpoch: randomUUID() } }
let current = structuredClone(initial), reads = 0, readHook: (() => void) | undefined
const readers: ReturnType<typeof createBandwidthNodeObservationReader>[] = []
const make = () => {
const source = { async read() { reads++; readHook?.(); return current } }
const reader = createBandwidthNodeObservationReader(source); readers.push(reader); return { reader, source }
}
const reset = () => { current = structuredClone(initial); response = { "system-id": "SYS-001", "software-id": "SOFT-002" }; status = 200; hold = false; onRequest = undefined; onClosed = undefined; readHook = undefined }
const inert = make(); assert.equal(reads, 0); assert.equal(requests.length, 0)
// The client transitively allocates its existing default pool on import. Prove
// actual GET observation never borrows it; no test database is configured/read.
const { pool, closePool } = await import("../db/index.js")
const originalQuery = pool.query, originalConnect = pool.connect
let databaseCalls = 0
pool.query = (() => { databaseCalls++; throw Error("Default database access forbidden in native observation fixture") }) as typeof pool.query
pool.connect = (() => { databaseCalls++; throw Error("Default database checkout forbidden in native observation fixture") }) as typeof pool.connect
try {
const observation = await inert.reader.observe(17, scope()).catch(error => {
console.error("Owned initial native observation diagnostic:", JSON.stringify({ databaseCalls, requests, reads }))
throw error
}), evidence = await inert.reader.inspect(observation, scope())
assert.deepEqual(evidence.claims, [{ kind: "system-id", value: "SYS-001" }, { kind: "software-id", value: "SOFT-002" }])
assert.equal(evidence.sourceProof, initial.sourceProof); assert.equal(evidence.authorityGeneration, initial.authorityGeneration)
assert.equal(evidence.physicalUniquenessVerified, false); assert.equal(evidence.cloneResistanceVerified, false)
assert(!JSON.stringify(evidence).includes(username)); assert(!JSON.stringify(evidence).includes(password))
assert.equal(requests.length, 1); assert.deepEqual(requests[0], { method: "GET", path: "/rest/system/license", authenticated: true })
cases.push("inert reader construction then actual authenticated MikrotikClient GET, fixed path and ordered typed two-kind claims, no physical uniqueness/clone-resistance assertion or exposed credentials")
for (const native of [{ "system-id": "SAME" }, [{ "software-id": "SAME" }], [{ "software-id": "SAME", "system-id": "SAME" }]]) {
reset(); response = native
const reader = make().reader, token = await reader.observe(17, scope()), projected = await reader.inspect(token, scope())
const row = Array.isArray(native) ? native[0] : native
assert.deepEqual(projected.claims.map(item => item.kind), ["system-id", "software-id"].filter(kind => Object.hasOwn(row, kind)))
assert(projected.claims.every(item => item.value === "SAME"))
}
cases.push("strict object or array-one responses preserve system-id/software-id kind, including equal values and fixed vector order")
const beforeFake = requests.length, beforeFakeReads = reads
for (const fake of [JSON.parse(JSON.stringify(observation)), { ...observation }, evidence, { kind: "routeros-license-observation", claims: [{ kind: "system-id", value: "FORGED" }] }])
await assert.rejects(inert.reader.inspect(fake, scope()), denied("NOT_GENUINE"))
const other = make().reader
await assert.rejects(other.inspect(observation, scope()), denied("NOT_GENUINE"))
assert.equal(reads, beforeFakeReads); assert.equal(requests.length, beforeFake)
assert.equal(Reflect.set(observation, "kind", "forged"), false)
assert.equal(Reflect.set(evidence.claims[0], "value", "forged"), false)
cases.push("serialized, copied, mutated and another-reader observations cannot manufacture private provenance; frozen claim metadata cannot mutate stored evidence")
for (const malformed of [[], [{ "system-id": "A" }, { "system-id": "B" }], null, "A", {}, { "system-id": 1 }, { "system-id": " " }, { "system-id": " A" }, { "system-id": "A\u0000B" }, { "system-id": "x".repeat(257) }, { "system-id": null, "software-id": "VALID" }]) {
reset(); response = malformed
await assert.rejects(make().reader.observe(17, scope()), denied("INVALID_LICENSE_RESPONSE"))
}
reset(); response = Object.fromEntries([["system-id", "VALID"], ...Array.from({ length: 64 }, (_, n) => ["field" + n, "x"])])
await assert.rejects(make().reader.observe(17, scope()), denied("INVALID_LICENSE_RESPONSE"))
cases.push("ambiguous/missing/non-string/empty/control/oversize claims and too many native fields refuse; invalid present claim never falls back to another kind")
reset(); response = { "system-id": "x".repeat(20000) }
await assert.rejects(make().reader.observe(17, scope()), denied())
reset(); status = 500; response = { error: password }
const nativeError = await make().reader.observe(17, scope()).then(() => assert.fail("Expected HTTP error"), error => error as Error)
assert(!nativeError.message.includes(password)); assert(!nativeError.message.includes(username))
reset(); status = 302; const beforeRedirect = requests.length
await assert.rejects(make().reader.observe(17, scope()), denied()); assert.equal(requests.length, beforeRedirect + 1)
cases.push("wire-byte cap, HTTP rejection and redirect refuse without reflecting provider secrets or following another URL")
reset(); const preSend = requests.length, at = reads
readHook = () => { if (reads === at + 2) current.endpoint.password = "CHANGED_BEFORE_DISPATCH" }
await assert.rejects(make().reader.observe(17, scope()), denied("SOURCE_CHANGED")); assert.equal(requests.length, preSend)
reset(); onRequest = () => { current.endpoint.password = "CHANGED_AFTER_SEND" }
await assert.rejects(make().reader.observe(17, scope()), denied("SOURCE_CHANGED"))
reset(); onRequest = () => { current.sourceProof = "b".repeat(64) }
await assert.rejects(make().reader.observe(17, scope()), denied("SOURCE_CHANGED"))
cases.push("trusted endpoint credentials drift before dispatch gives zero GET; credential/source proof drift during real GET prevents publishing an observation")
reset(); const stableReader = make().reader, stable = await stableReader.observe(17, scope()), countBeforeInspect = requests.length
current.authorityGeneration = "NEW_GENERATION"
await assert.rejects(stableReader.inspect(stable, scope()), denied("SOURCE_CHANGED")); assert.equal(requests.length, countBeforeInspect)
reset(); const revoked = make().reader, revokedToken = await revoked.observe(17, scope())
current.enabled = false
await assert.rejects(revoked.inspect(revokedToken, scope()), denied())
cases.push("issuer inspection re-reads fixed trusted source; changed authority or disabled source refuses without another native GET")
reset(); const composed = make()
composed.source.read = async () => { throw Error("Replacement must not redirect the captured trusted reader") }
const composedToken = await composed.reader.observe(17, scope()); await composed.reader.inspect(composedToken, scope())
const beforeRequestCallback = requests.length, beforeCallbackReads = reads
await assert.rejects(composed.reader.observe(17, Object.assign(scope(), { read: async () => initial })), denied("INVALID_INPUT"))
assert.equal(requests.length, beforeRequestCallback); assert.equal(reads, beforeCallbackReads)
cases.push("constructor captures its fixed trusted source method; request scope cannot inject a source or transport callback")
reset(); const alreadyCancelled = new AbortController(); alreadyCancelled.abort()
const cancelledRequests = requests.length, cancelledReads = reads
await assert.rejects(make().reader.observe(17, { ...scope(), signal: alreadyCancelled.signal }), denied("CANCELLED"))
assert.equal(reads, cancelledReads); assert.equal(requests.length, cancelledRequests)
reset(); hold = true; const arrived = deferred(), socketClosed = deferred(), controller = new AbortController()
onRequest = arrived.resolve; onClosed = socketClosed.resolve
const cancelled = make().reader.observe(17, { ...scope(), signal: controller.signal })
await bounded(arrived.promise); controller.abort()
await assert.rejects(cancelled, denied()); await bounded(socketClosed.promise)
cases.push("pre-abort performs no source/native work; cancellation during actual localhost GET closes owned response socket and publishes no observation")
reset(); hold = true; const timedOutClosed = deferred(), timeoutArrived = deferred()
onClosed = timedOutClosed.resolve; onRequest = timeoutArrived.resolve
const timedOut = make().reader.observe(17, scope(300))
await bounded(timeoutArrived.promise); await assert.rejects(timedOut, denied()); await bounded(timedOutClosed.promise)
cases.push("absolute caller deadline bounds a real stalled HTTP response and closes its owned socket")
reset(); const shortReader = make().reader, expires = Date.now() + 250
const short = await shortReader.observe(17, { deadlineAt: expires })
await new Promise<void>(resolve => setTimeout(resolve, Math.max(1, expires - Date.now() + 10)))
const beforeExpired = reads
await assert.rejects(shortReader.inspect(short, scope()), denied("CANCELLED")); assert.equal(reads, beforeExpired)
reset(); const originalAbort = new AbortController(), originalReader = make().reader
const originalToken = await originalReader.observe(17, { ...scope(), signal: originalAbort.signal }); originalAbort.abort()
await assert.rejects(originalReader.inspect(originalToken, scope()), denied("CANCELLED"))
cases.push("new inspection scope cannot extend original observation expiry or resurrect its cancelled original signal")
reset()
const clientReader=make().reader,clientToken=await clientReader.observe(17,scope())
const strictClient=await clientReader.strictClient(clientToken,scope()),clientRequests=requests.length,clientReads=reads
await assert.rejects(strictClient.post("/tool/bandwidth-test",{address:"192.0.2.1",user:"synthetic",password:"synthetic",duration:"3s"}))
assert.equal(requests.length,clientRequests);assert.equal(databaseCalls,0)
await assert.rejects(make().reader.strictClient(clientToken,scope()),denied("NOT_GENUINE"))
await assert.rejects(clientReader.strictClient(JSON.parse(JSON.stringify(clientToken)),scope()),denied("NOT_GENUINE"))
assert.equal(reads,clientReads)
current.endpoint.password+="-drift"
await assert.rejects(clientReader.strictClient(clientToken,scope()),denied("SOURCE_CHANGED"))
await assert.rejects(shortReader.strictClient(short,scope()),denied("CANCELLED"))
assert.equal(requests.length,clientRequests);assert.equal(databaseCalls,0)
cases.push("same-reader genuine observation creates only strict frozen native client; unadmitted bandwidth refuses before SQL/HTTP, foreign/copy/expired/drifted factory inputs refuse without endpoint injection")
reset(); const beforeStall = requests.length
let resolveLate!: (snapshot: BandwidthNodeSourceSnapshot) => void
const late = new Promise<BandwidthNodeSourceSnapshot>(resolve => { resolveLate = resolve })
const stalled = createBandwidthNodeObservationReader({ read: async () => late }); readers.push(stalled)
await assert.rejects(stalled.observe(17, scope(50)), denied("CANCELLED")); assert.equal(requests.length, beforeStall)
resolveLate(structuredClone(initial)); await new Promise<void>(resolve => setImmediate(resolve))
assert.equal(requests.length, beforeStall)
reset(); hold = true; const closeArrived = deferred(), closeSocket = deferred(), closing = make().reader
onRequest = closeArrived.resolve; onClosed = closeSocket.resolve
const closePending = closing.observe(17, scope()); await bounded(closeArrived.promise); closing.close()
await assert.rejects(closePending, denied()); await bounded(closeSocket.promise)
await assert.rejects(closing.inspect(observation, scope()), denied("CLOSED"))
await assert.rejects(closing.observe(17, scope()), denied("CLOSED"))
cases.push("stalled trusted source cannot trigger late native IO after timeout; close cancels active HTTP and invalidates observation/reader use")
assert.equal(databaseCalls, 0)
assert(requests.every(item => item.method === "GET" && item.path === "/rest/system/license" && item.authenticated))
console.log("Bandwidth node native observation:", JSON.stringify({ cases: cases.length, checks: cases, actualLocalhostGets: requests.length,
defaultDatabaseCalls: databaseCalls, productionWired: false, canonicalNodeIdsCreated: 0, physicalUniquenessVerified: false, cloneResistanceVerified: false, realChrCalls: 0 }))
} finally {
for (const reader of readers) reader.close()
pool.query = originalQuery; pool.connect = originalConnect
server.closeAllConnections(); await new Promise<void>(resolve => server.close(() => resolve()))
await closePool()
}