78 lines
5.8 KiB
TypeScript
78 lines
5.8 KiB
TypeScript
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<string>()
|
|
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<void>(resolve => { entered = resolve })
|
|
const second: BandwidthNativeDispatchGate = { async acquire(current) { entered(); await new Promise<void>(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<void>(resolve => { entered = resolve })
|
|
const mapping: BandwidthNativeDispatchGate = { async acquire() { return {
|
|
async verify() { entered(); await new Promise<void>(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)
|
|
})
|