Files
MikrotikManager/backend/src/services/bandwidth-peer-metadata-source.test.ts
T

124 lines
10 KiB
TypeScript

/** Actual checker; synthetic application driver boundary only. No DB/native/Q. */
import assert from "node:assert/strict"
import { test, mock } from "node:test"
import { setImmediate as immediate } from "node:timers/promises"
import { EventEmitter } from "node:events"
import type { BandwidthPeerSourceSnapshot } from "./bandwidth-peer-observation.js"
import type { assertManagedBandwidthPeerMetadataChecker as AssertChecker } from "./bandwidth-peer-metadata-source.js"
type Query = { text: string; values: unknown[]; query_timeout: number }
const fresh = (): BandwidthPeerSourceSnapshot => ({ peerRef: { kind: "server", serverId: 23 }, enabled: true,
sourceProof: "a".repeat(64), authorityGeneration: "original-server-owned-generation",
endpoint: { host: "127.0.0.1", port: 8729, useSsl: true, verifySsl: false, username: "private-user", password: "private-password", routingEndpointEpoch: "163cd719-185a-489b-a985-cdc9630c3d0f" } })
let connects = 0, queries: Query[] = [], releases: boolean[] = []
let acquire: (() => Promise<void>) | undefined, queryWait: (() => Promise<void>) | undefined
let current = fresh(), override: unknown, releaseThrows = false
const client = Object.assign(new EventEmitter(), { release(destroy = false) { releases.push(destroy); if (releaseThrows) throw Error("raw release error") }, async query(config: Query) {
queries.push(config); await queryWait?.()
if (override !== undefined) return override
const e = current.endpoint, expected = [current.peerRef.kind === "server" ? current.peerRef.serverId : -1, e.host, e.port, e.useSsl, e.verifySsl, e.username, e.password, e.routingEndpointEpoch]
return { command: "SELECT", rowCount: 1, rows: [{ metadata_current: current.enabled && expected.every((value, index) => value === config.values[index]) }] }
} })
mock.module("../db/index.js", { namedExports: { pool: { async connect() { connects++; await acquire?.(); return client } } } })
const { createManagedBandwidthPeerMetadataChecker, assertManagedBandwidthPeerMetadataChecker: assertChecker } = await import("./bandwidth-peer-metadata-source.js")
const assertManagedBandwidthPeerMetadataChecker: typeof AssertChecker = assertChecker
const scope = (signal?: AbortSignal) => ({ deadlineAt: Date.now() + 5000, ...(signal ? { signal } : {}) })
const reset = () => { connects = 0; queries = []; releases = []; current = fresh(); override = undefined; acquire = undefined; queryWait = undefined; releaseThrows = false; client.removeAllListeners() }
const entered = async () => { for (let count = 0; !connects && count < 100; count++) await immediate(); assert.equal(connects, 1) }
test("managed metadata checker: actual fixed source, synthetic app SQL only", async t => {
await t.test("construction/brand do no I/O; forged wrappers and external input refuse before checkout", async () => {
reset(); const checker = createManagedBandwidthPeerMetadataChecker()
assertManagedBandwidthPeerMetadataChecker(checker); assert.throws(() => assertManagedBandwidthPeerMetadataChecker({ ...checker }))
assert.equal(connects, 0)
await assert.rejects(checker.assertMetadataCurrent({ ...fresh(), peerRef: { kind: "external", enrollmentId: "163cd719-185a-489b-a985-cdc9630c3d0f" } }, scope()))
assert.equal(connects, 0); assert.equal(queries.length, 0)
})
await t.test("descriptor/proxy malformed originals/scopes cannot execute getters or driver", async () => {
reset(); const checker = createManagedBandwidthPeerMetadataChecker(); let traps = 0
const getter = Object.defineProperty(fresh(), "endpoint", { enumerable: true, get() { traps++; throw Error("getter") } })
const proxy = new Proxy(fresh(), { getPrototypeOf() { traps++; throw Error("proxy") } })
const scopeProxy = new Proxy(scope(), { getOwnPropertyDescriptor() { traps++; throw Error("scope proxy") } })
await assert.rejects(checker.assertMetadataCurrent(getter, scope()))
await assert.rejects(checker.assertMetadataCurrent(proxy, scope()))
await assert.rejects(checker.assertMetadataCurrent(fresh(), scopeProxy))
for (const value of [NaN, Infinity, -1]) await assert.rejects(checker.assertMetadataCurrent(fresh(), { deadlineAt: value }))
assert.equal(traps, 0); assert.equal(connects, 0)
})
await t.test("fixed SQL returns void; private primitives captured before first await, no credential projection", async () => {
reset(); const checker = createManagedBandwidthPeerMetadataChecker(), expected = fresh()
const pending = checker.assertMetadataCurrent(expected, scope())
expected.endpoint.password = "later-caller-mutation"; expected.endpoint.host = "changed.invalid"
assert.equal(await pending, undefined)
assert.deepEqual(releases, [false]); assert.equal(queries.length, 1)
const query = queries[0]
assert.match(query.text, /^\/\* bandwidth-managed:metadata-current \*\/ SELECT EXISTS/)
assert.match(query.text, /username=\$6::text AND password=\$7::text/)
assert.match(query.text, /\) AS metadata_current$/)
assert(!/RETURNING|md5|digest|INSERT|UPDATE|DELETE|COMMIT|pg_advisory/i.test(query.text))
assert.equal(query.values[6], "private-password"); assert.equal(query.values[1], "127.0.0.1")
assert(query.query_timeout > 0 && query.query_timeout <= 5000)
})
await t.test("all current endpoint/credential/epoch/id/enabled drifts refuse, one fixed boolean statement", async () => {
const mutations: Array<(value: BandwidthPeerSourceSnapshot) => void> = [
value => { value.peerRef = { kind: "server", serverId: 24 } }, value => { value.enabled = false },
value => { value.endpoint.host = "other.invalid" }, value => { value.endpoint.port++ },
value => { value.endpoint.useSsl = false }, value => { value.endpoint.verifySsl = true },
value => { value.endpoint.username += "x" }, value => { value.endpoint.password += "x" },
value => { value.endpoint.routingEndpointEpoch = "263cd719-185a-489b-a985-cdc9630c3d0f" },
]
for (const mutate of mutations) {
reset(); mutate(current)
await assert.rejects(createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope()))
assert.equal(queries.length, 1); assert.deepEqual(releases, [true])
}
})
await t.test("rows-only, extra credential fields, truthy string and malformed driver ACK fail closed", async () => {
for (const result of [ { rows: [{ metadata_current: true }] }, { command: "SELECT", rowCount: 1, rows: [{ metadata_current: true, password: "never-adopt" }] },
{ command: "SELECT", rowCount: 1, rows: [{ metadata_current: "true" }] }, { command: "UPDATE", rowCount: 1, rows: [{ metadata_current: true }] },
{ command: "SELECT", rowCount: 0, rows: [{ metadata_current: true }] } ]) {
reset(); override = result
await assert.rejects(createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope()))
assert.deepEqual(releases, [true])
}
})
await t.test("original abort destroys pending query; late true result cannot publish", async () => {
reset(); let finish!: () => void; queryWait = () => new Promise<void>(resolve => { finish = resolve })
const controller = new AbortController(), pending = createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope(controller.signal))
await entered(); while (!queries.length) await immediate()
controller.abort(); await assert.rejects(pending); assert.deepEqual(releases, [true])
finish(); await immediate(); assert.deepEqual(releases, [true])
})
await t.test("canceled queued checkout destroys its late lease and does not dispatch SQL", async () => {
reset(); let finish!: () => void; acquire = () => new Promise<void>(resolve => { finish = resolve })
const controller = new AbortController(), pending = createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope(controller.signal))
await entered(); controller.abort(); await assert.rejects(pending)
finish(); await immediate(); assert.deepEqual(releases, [true]); assert.equal(queries.length, 0)
})
await t.test("original deadline expires pending SQL without renewal", async () => {
reset(); let finish!: () => void; queryWait = () => new Promise<void>(resolve => { finish = resolve })
const pending = createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), { deadlineAt: Date.now() + 30 })
await assert.rejects(pending); assert.deepEqual(releases, [true]); finish(); await immediate()
})
await t.test("socket error aborts pending SQL and late errors after destruction remain absorbed", async () => {
reset(); let finish!: () => void; queryWait = () => new Promise<void>(resolve => { finish = resolve })
const pending = createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope())
await entered(); while (!queries.length) await immediate()
client.emit("error", Error("owned socket failure")); await assert.rejects(pending)
assert.deepEqual(releases, [true]); assert.doesNotThrow(() => client.emit("error", Error("late socket failure")))
finish(); await immediate()
})
await t.test("healthy/destroyed/late-checkout release exceptions are sanitized without a retry", async () => {
reset(); releaseThrows = true
await assert.rejects(createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope()), { code: "BANDWIDTH_PEER_METADATA_SOURCE_REFUSED" })
assert.deepEqual(releases, [false]); assert.doesNotThrow(() => client.emit("error", Error("late uncertain release")))
reset(); releaseThrows = true; override = { command: "SELECT", rowCount: 1, rows: [{ metadata_current: false }] }
await assert.rejects(createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope()), { code: "BANDWIDTH_PEER_METADATA_SOURCE_REFUSED" })
assert.deepEqual(releases, [true]); assert.doesNotThrow(() => client.emit("error", Error("late destroy error")))
reset(); releaseThrows = true; let finish!: () => void; acquire = () => new Promise<void>(resolve => { finish = resolve })
const controller = new AbortController(), pending = createManagedBandwidthPeerMetadataChecker().assertMetadataCurrent(fresh(), scope(controller.signal))
await entered(); controller.abort(); await assert.rejects(pending); finish(); await immediate()
assert.deepEqual(releases, [true]); assert.doesNotThrow(() => client.emit("error", Error("late checkout error")))
})
})