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(done => { resolve = done }); return { promise, resolve } } const bounded = (work: Promise) => Promise.race([work, new Promise((_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[] = [] 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(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(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(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(resolve => server.close(() => resolve())) await closePool() }