import assert from "node:assert/strict" import { setTimeout as delay } from "node:timers/promises" import { test } from "node:test" import { createBandwidthNativeDispatchCompositeGate } from "./bandwidth-native-dispatch-composite.js" import type { BandwidthNativeDispatchGate } from "./bandwidth-native-dispatch.js" const scope = (signal = new AbortController().signal, ms = 2000) => ({ deadlineAt: Date.now() + ms, signal }) function fixture() { const events: string[] = [] const held = new Set() const gate = (name: string): BandwidthNativeDispatchGate => ({ async acquire() { events.push("open:" + name); held.add(name) return { async verify() { assert(held.has(name)); events.push("verify:" + name) }, close() { events.push("close:" + name); held.delete(name) } } } }) return { events, held, gate } } test("fixed mapping-first order, captured gates, repeated same-scope checks and reverse physical close", async () => { const f = fixture(), mapping = f.gate("mapping"), registry = f.gate("registry") const composite = createBandwidthNativeDispatchCompositeGate([mapping, registry]) mapping.acquire = async () => { throw Error("mutable callback replacement") } const current = scope(), lease = await composite.acquire(current) assert.deepEqual([...f.held], ["mapping", "registry"]) await lease.verify(current); await lease.verify({ ...current }) lease.close(); lease.close() assert.deepEqual(f.events, ["open:mapping", "open:registry", "verify:mapping", "verify:registry", "verify:mapping", "verify:registry", "close:registry", "close:mapping"]) await assert.rejects(lease.verify(current)); await assert.rejects(composite.acquire(current)); assert.equal(f.held.size, 0) }) test("second acquisition failure releases the already held global barrier", async () => { const f = fixture() const composite = createBandwidthNativeDispatchCompositeGate([f.gate("mapping"), { async acquire() { throw Error("registry unavailable") } }]) await assert.rejects(composite.acquire(scope()), /registry unavailable/) assert.deepEqual(f.events, ["open:mapping", "close:mapping"]); assert.equal(f.held.size, 0) }) test("abort while acquiring registry immediately releases mapping and destroys a later returned lease", async () => { const f = fixture(), controller = new AbortController() let resume!: () => void, entered!: () => void const waiting = new Promise(resolve => { entered = resolve }) const second: BandwidthNativeDispatchGate = { async acquire(current) { entered(); await new Promise(resolve => { resume = resolve }); return f.gate("registry").acquire(current) } } const composite = createBandwidthNativeDispatchCompositeGate([f.gate("mapping"), second]) const pending = composite.acquire(scope(controller.signal)); await waiting; controller.abort() await assert.rejects(pending); assert.equal(f.held.size, 0) resume(); await delay(10) assert.deepEqual(f.events, ["open:mapping", "close:mapping", "open:registry", "close:registry"]); assert.equal(f.held.size, 0) }) test("revoked mapping prevents the next registry query and retires both physical leases", async () => { const f = fixture(), mapping: BandwidthNativeDispatchGate = { async acquire() { f.held.add("mapping"); return { async verify() { throw Error("mapping revoked") }, close() { f.events.push("close:mapping"); f.held.delete("mapping") } } } } const current = scope(), lease = await createBandwidthNativeDispatchCompositeGate([mapping, f.gate("registry")]).acquire(current) await assert.rejects(lease.verify(current), /mapping revoked/) assert(!f.events.includes("verify:registry")); assert.equal(f.held.size, 0) }) test("a stalled verification aborts promptly and its late continuation cannot check the next gate", async () => { const f = fixture(), controller = new AbortController(); let resume!: () => void, entered!: () => void const waiting = new Promise(resolve => { entered = resolve }) const mapping: BandwidthNativeDispatchGate = { async acquire() { return { async verify() { entered(); await new Promise(resolve => { resume = resolve }) }, close() { f.events.push("close:mapping") }, } } } const current = scope(controller.signal), lease = await createBandwidthNativeDispatchCompositeGate([mapping, f.gate("registry")]).acquire(current) const pending = lease.verify(current); await waiting; controller.abort(); await assert.rejects(pending) resume(); await delay(10); assert(!f.events.includes("verify:registry")); assert.equal(f.held.size, 0) }) test("one failing close does not skip the other barrier and can be retried", async () => { const f = fixture(); let closes = 0 const registry: BandwidthNativeDispatchGate = { async acquire() { return { async verify() {}, close() { closes++; if (closes === 1) throw Error("physical close failed") } } } } const lease = await createBandwidthNativeDispatchCompositeGate([f.gate("mapping"), registry]).acquire(scope()) assert.throws(() => lease.close(), /physical close failed/); assert.equal(f.held.size, 0) lease.close(); assert.equal(closes, 2) }) test("pre-abort and structurally changed scopes refuse without another gate query", async () => { const f = fixture(), mapping = f.gate("mapping"), registry = f.gate("registry"), controller = new AbortController(); controller.abort() await assert.rejects(createBandwidthNativeDispatchCompositeGate([mapping, registry]).acquire(scope(controller.signal))); assert.equal(f.events.length, 0) assert.throws(() => createBandwidthNativeDispatchCompositeGate([mapping, mapping])) const current = scope(), lease = await createBandwidthNativeDispatchCompositeGate([mapping, registry]).acquire(current) await assert.rejects(lease.verify({ ...current, deadlineAt: current.deadlineAt + 1 })) assert.equal(f.events.filter(value => value.startsWith("verify:")).length, 0); assert.equal(f.held.size, 0) })