Files
MikrotikManager/backend/src/services/bandwidth-native-dispatch-composite.test.ts
T

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)
})