socketduct 0.1.25 → 0.1.26

package/test/unit/client/multiplexed-spool-budget.test.js

@@ -1,11 +1,10 @@
 /* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param, jsdoc/require-returns */
-import assert from "node:assert/strict"
+import {describe, expect, it, withTestCleanup} from "@velocious/testing"
 import {EventEmitter} from "node:events"
 import {mkdtemp, rm} from "node:fs/promises"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
 import {Duplex} from "node:stream"
-import test from "node:test"
 
 import {MultiplexedSocketductTransportSet} from "../../../src/client/multiplexed-transport-set.js"
 import {decodeV3Control, encodeV3Control, encodeV3Frame, V3FrameDecoder, V3FrameType} from "../../../src/protocol/v3-frame.js"
@@ -102,7 +101,7 @@ function deferred() {
 /** @template T @param {T[]} values - Values. @param {number} index - Index. @returns {T} */
 function at(values, index) {
   const value = values[index]
-  assert(value !== undefined)
+  if (value === undefined) throw new Error(`expected a value at index ${index}`)
   return value
 }
 
@@ -145,165 +144,167 @@ async function settle() {
   await new Promise((resolve) => setImmediate(resolve))
 }
 
-test("destroy keeps shared spool capacity reserved until remove succeeds", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-destroy-spool-budget-"))
-  const originalRemove = SessionSpool.prototype.remove
-  const removeGate = deferred()
-  const removeCalled = deferred()
-  const removeFinished = deferred()
-  SessionSpool.prototype.remove = async function (/** @type {string} */ identifier) {
-    if (identifier === "destroy_stream_01") {
-      removeCalled.resolve()
-      await removeGate.promise
+describe("multiplexed spool budget", () => {
+  it("destroy keeps shared spool capacity reserved until remove succeeds", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-destroy-spool-budget-"))
+    const originalRemove = SessionSpool.prototype.remove
+    const removeGate = deferred()
+    const removeCalled = deferred()
+    const removeFinished = deferred()
+    SessionSpool.prototype.remove = async function (/** @type {string} */ identifier) {
+      if (identifier === "destroy_stream_01") {
+        removeCalled.resolve()
+        await removeGate.promise
+      }
+      await originalRemove.call(this, identifier)
+      if (identifier === "destroy_stream_01") removeFinished.resolve()
     }
-    await originalRemove.call(this, identifier)
-    if (identifier === "destroy_stream_01") removeFinished.resolve()
-  }
-  const {set, controllers} = createFixture(root)
-  t.after(async () => {
-    removeGate.resolve()
-    SessionSpool.prototype.remove = originalRemove
-    await set.close().catch(() => {})
-    await rm(root, {recursive: true, force: true})
-  })
-  await set.start()
-  const first = set.createConnection({host: "target.internal", port: 443, identifier: "destroy_stream_01"})
-  await onceEvent(first, "connect")
-  assert.equal(await writeResult(first, 6), null)
-  await at(controllers, 0).nextFrame()
-  first.destroy()
-  await removeCalled.promise
-  await settle()
-  assert.equal(set.status().budgets.dataBytes, 0)
-  assert.equal(set.status().budgets.spoolBytes, 6)
+    const {set, controllers} = createFixture(root)
+    after(async () => {
+      removeGate.resolve()
+      SessionSpool.prototype.remove = originalRemove
+      await set.close().catch(() => {})
+      await rm(root, {recursive: true, force: true})
+    })
+    await set.start()
+    const first = set.createConnection({host: "target.internal", port: 443, identifier: "destroy_stream_01"})
+    await onceEvent(first, "connect")
+    expect(await writeResult(first, 6)).toBe(null)
+    await at(controllers, 0).nextFrame()
+    first.destroy()
+    await removeCalled.promise
+    await settle()
+    expect(set.status().budgets.dataBytes).toBe(0)
+    expect(set.status().budgets.spoolBytes).toBe(6)
 
-  const sibling = set.createConnection({host: "target.internal", port: 443, identifier: "destroy_stream_02"})
-  await onceEvent(sibling, "connect")
-  const blocked = await writeResult(sibling, 3)
-  let closeSettled = false
-  const closing = set.close().then(() => { closeSettled = true })
-  await settle()
-  assert.equal(closeSettled, false)
-  removeGate.resolve()
-  await removeFinished.promise
-  await closing
-  assert.equal(/** @type {{code?: string}} */ (blocked).code, "SOCKETDUCT_SET_SPOOL_LIMIT")
-  assert.equal(set.status().budgets.spoolBytes, 0)
-})
+    const sibling = set.createConnection({host: "target.internal", port: 443, identifier: "destroy_stream_02"})
+    await onceEvent(sibling, "connect")
+    const blocked = await writeResult(sibling, 3)
+    let closeSettled = false
+    const closing = set.close().then(() => { closeSettled = true })
+    await settle()
+    expect(closeSettled).toBe(false)
+    removeGate.resolve()
+    await removeFinished.promise
+    await closing
+    expect(/** @type {{code?: string}} */ (blocked).code).toBe("SOCKETDUCT_SET_SPOOL_LIMIT")
+    expect(set.status().budgets.spoolBytes).toBe(0)
+  }))
 
-test("failed destroy removal retains spool accounting and fails the member visibly", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-failed-remove-budget-"))
-  const originalRemove = SessionSpool.prototype.remove
-  const removeCalled = deferred()
-  SessionSpool.prototype.remove = async function (/** @type {string} */ identifier) {
-    if (identifier === "failed_remove_stream_01") {
-      removeCalled.resolve()
-      throw new Error("injected remove failure")
+  it("failed destroy removal retains spool accounting and fails the member visibly", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-failed-remove-budget-"))
+    const originalRemove = SessionSpool.prototype.remove
+    const removeCalled = deferred()
+    SessionSpool.prototype.remove = async function (/** @type {string} */ identifier) {
+      if (identifier === "failed_remove_stream_01") {
+        removeCalled.resolve()
+        throw new Error("injected remove failure")
+      }
+      await originalRemove.call(this, identifier)
     }
-    await originalRemove.call(this, identifier)
-  }
-  const {set, controllers} = createFixture(root)
-  t.after(async () => {
-    SessionSpool.prototype.remove = originalRemove
-    await set.close().catch(() => {})
-    await rm(root, {recursive: true, force: true})
-  })
-  await set.start()
-  const socket = set.createConnection({host: "target.internal", port: 443, identifier: "failed_remove_stream_01"})
-  await onceEvent(socket, "connect")
-  assert.equal(await writeResult(socket, 6), null)
-  await at(controllers, 0).nextFrame()
-  socket.destroy()
-  await removeCalled.promise
-  await settle()
-  assert.equal(set.status().budgets.dataBytes, 0)
-  assert.equal(set.status().budgets.spoolBytes, 6)
-  assert.equal(at(set.status().members, 0).spoolCleanupFailures, 1)
-  assert.equal(at(set.status().members, 0).state, "closed")
-})
+    const {set, controllers} = createFixture(root)
+    after(async () => {
+      SessionSpool.prototype.remove = originalRemove
+      await set.close().catch(() => {})
+      await rm(root, {recursive: true, force: true})
+    })
+    await set.start()
+    const socket = set.createConnection({host: "target.internal", port: 443, identifier: "failed_remove_stream_01"})
+    await onceEvent(socket, "connect")
+    expect(await writeResult(socket, 6)).toBe(null)
+    await at(controllers, 0).nextFrame()
+    socket.destroy()
+    await removeCalled.promise
+    await settle()
+    expect(set.status().budgets.dataBytes).toBe(0)
+    expect(set.status().budgets.spoolBytes).toBe(6)
+    expect(at(set.status().members, 0).spoolCleanupFailures).toBe(1)
+    expect(at(set.status().members, 0).state).toBe("closed")
+  }))
 
-test("ACK keeps shared spool capacity reserved until truncate succeeds", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-ack-spool-budget-"))
-  const originalTruncate = SessionSpool.prototype.truncateAcked
-  const truncateGate = deferred()
-  const truncateCalled = deferred()
-  const truncateFinished = deferred()
-  SessionSpool.prototype.truncateAcked = async function (/** @type {string} */ identifier, /** @type {number} */ sequence) {
-    if (identifier === "ack_stream_01") {
-      truncateCalled.resolve()
-      await truncateGate.promise
+  it("ACK keeps shared spool capacity reserved until truncate succeeds", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-ack-spool-budget-"))
+    const originalTruncate = SessionSpool.prototype.truncateAcked
+    const truncateGate = deferred()
+    const truncateCalled = deferred()
+    const truncateFinished = deferred()
+    SessionSpool.prototype.truncateAcked = async function (/** @type {string} */ identifier, /** @type {number} */ sequence) {
+      if (identifier === "ack_stream_01") {
+        truncateCalled.resolve()
+        await truncateGate.promise
+      }
+      await originalTruncate.call(this, identifier, sequence)
+      if (identifier === "ack_stream_01") truncateFinished.resolve()
     }
-    await originalTruncate.call(this, identifier, sequence)
-    if (identifier === "ack_stream_01") truncateFinished.resolve()
-  }
-  const {set, controllers} = createFixture(root)
-  t.after(async () => {
-    truncateGate.resolve()
-    SessionSpool.prototype.truncateAcked = originalTruncate
-    await set.close().catch(() => {})
-    await rm(root, {recursive: true, force: true})
-  })
-  await set.start()
-  const first = set.createConnection({host: "target.internal", port: 443, identifier: "ack_stream_01"})
-  await onceEvent(first, "connect")
-  assert.equal(await writeResult(first, 6), null)
-  const sent = await at(controllers, 0).nextFrame()
-  sent.socket.ack(sent.frame)
-  await truncateCalled.promise
-  await settle()
-  assert.equal(set.status().budgets.dataBytes, 0)
-  assert.equal(set.status().budgets.spoolBytes, 6)
+    const {set, controllers} = createFixture(root)
+    after(async () => {
+      truncateGate.resolve()
+      SessionSpool.prototype.truncateAcked = originalTruncate
+      await set.close().catch(() => {})
+      await rm(root, {recursive: true, force: true})
+    })
+    await set.start()
+    const first = set.createConnection({host: "target.internal", port: 443, identifier: "ack_stream_01"})
+    await onceEvent(first, "connect")
+    expect(await writeResult(first, 6)).toBe(null)
+    const sent = await at(controllers, 0).nextFrame()
+    sent.socket.ack(sent.frame)
+    await truncateCalled.promise
+    await settle()
+    expect(set.status().budgets.dataBytes).toBe(0)
+    expect(set.status().budgets.spoolBytes).toBe(6)
 
-  const sibling = set.createConnection({host: "target.internal", port: 443, identifier: "ack_stream_02"})
-  await onceEvent(sibling, "connect")
-  const blocked = await writeResult(sibling, 3)
-  truncateGate.resolve()
-  await truncateFinished.promise
-  await settle()
-  assert.equal(/** @type {{code?: string}} */ (blocked).code, "SOCKETDUCT_SET_SPOOL_LIMIT")
-  assert.equal(set.status().budgets.spoolBytes, 0)
-})
+    const sibling = set.createConnection({host: "target.internal", port: 443, identifier: "ack_stream_02"})
+    await onceEvent(sibling, "connect")
+    const blocked = await writeResult(sibling, 3)
+    truncateGate.resolve()
+    await truncateFinished.promise
+    await settle()
+    expect(/** @type {{code?: string}} */ (blocked).code).toBe("SOCKETDUCT_SET_SPOOL_LIMIT")
+    expect(set.status().budgets.spoolBytes).toBe(0)
+  }))
 
-test("failed ACK truncate and removal retain spool accounting and surface cleanup failure", async (t) => {
-  const root = await mkdtemp(join(tmpdir(), "socketduct-failed-truncate-budget-"))
-  const originalTruncate = SessionSpool.prototype.truncateAcked
-  const originalRemove = SessionSpool.prototype.remove
-  const truncateCalled = deferred()
-  const removeCalled = deferred()
-  SessionSpool.prototype.truncateAcked = async function (/** @type {string} */ identifier, /** @type {number} */ sequence) {
-    if (identifier === "failed_ack_stream_01") {
-      truncateCalled.resolve()
-      throw new Error("injected truncate failure")
+  it("failed ACK truncate and removal retain spool accounting and surface cleanup failure", async () => withTestCleanup(async (after) => {
+    const root = await mkdtemp(join(tmpdir(), "socketduct-failed-truncate-budget-"))
+    const originalTruncate = SessionSpool.prototype.truncateAcked
+    const originalRemove = SessionSpool.prototype.remove
+    const truncateCalled = deferred()
+    const removeCalled = deferred()
+    SessionSpool.prototype.truncateAcked = async function (/** @type {string} */ identifier, /** @type {number} */ sequence) {
+      if (identifier === "failed_ack_stream_01") {
+        truncateCalled.resolve()
+        throw new Error("injected truncate failure")
+      }
+      await originalTruncate.call(this, identifier, sequence)
     }
-    await originalTruncate.call(this, identifier, sequence)
-  }
-  SessionSpool.prototype.remove = async function (/** @type {string} */ identifier) {
-    if (identifier === "failed_ack_stream_01") {
-      removeCalled.resolve()
-      throw new Error("injected remove failure")
+    SessionSpool.prototype.remove = async function (/** @type {string} */ identifier) {
+      if (identifier === "failed_ack_stream_01") {
+        removeCalled.resolve()
+        throw new Error("injected remove failure")
+      }
+      await originalRemove.call(this, identifier)
     }
-    await originalRemove.call(this, identifier)
-  }
-  const {set, controllers} = createFixture(root)
-  t.after(async () => {
-    SessionSpool.prototype.truncateAcked = originalTruncate
-    SessionSpool.prototype.remove = originalRemove
-    await set.close().catch(() => {})
-    await rm(root, {recursive: true, force: true})
-  })
-  await set.start()
-  const socket = set.createConnection({host: "target.internal", port: 443, identifier: "failed_ack_stream_01"})
-  await onceEvent(socket, "connect")
-  assert.equal(await writeResult(socket, 6), null)
-  const sent = await at(controllers, 0).nextFrame()
-  const streamError = onceEvent(socket, "error").catch((error) => error)
-  sent.socket.ack(sent.frame)
-  await truncateCalled.promise
-  await removeCalled.promise
-  await streamError
-  await settle()
-  assert.equal(set.status().budgets.dataBytes, 0)
-  assert.equal(set.status().budgets.spoolBytes, 6)
-  assert.equal(at(set.status().members, 0).spoolCleanupFailures, 1)
-  assert.equal(at(set.status().members, 0).state, "closed")
+    const {set, controllers} = createFixture(root)
+    after(async () => {
+      SessionSpool.prototype.truncateAcked = originalTruncate
+      SessionSpool.prototype.remove = originalRemove
+      await set.close().catch(() => {})
+      await rm(root, {recursive: true, force: true})
+    })
+    await set.start()
+    const socket = set.createConnection({host: "target.internal", port: 443, identifier: "failed_ack_stream_01"})
+    await onceEvent(socket, "connect")
+    expect(await writeResult(socket, 6)).toBe(null)
+    const sent = await at(controllers, 0).nextFrame()
+    const streamError = onceEvent(socket, "error").catch((error) => error)
+    sent.socket.ack(sent.frame)
+    await truncateCalled.promise
+    await removeCalled.promise
+    await streamError
+    await settle()
+    expect(set.status().budgets.dataBytes).toBe(0)
+    expect(set.status().budgets.spoolBytes).toBe(6)
+    expect(at(set.status().members, 0).spoolCleanupFailures).toBe(1)
+    expect(at(set.status().members, 0).state).toBe("closed")
+  }))
 })