socketduct 0.1.25 → 0.1.26

package/test/integration/multiplexed-failures.test.js

@@ -1,8 +1,7 @@
 /* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param-type, jsdoc/require-returns */
-import assert from "node:assert/strict"
+import {describe, expect, it, withTestCleanup} from "@velocious/testing"
 import {createConnection, createServer} from "node:net"
 import {Duplex} from "node:stream"
-import test from "node:test"
 
 import {StaticTokenStore} from "../../src/auth/static-token-store.js"
 import {MultiplexedSocketductConnection} from "../../src/client/multiplexed-connection.js"
@@ -25,7 +24,7 @@ async function listen(server) {
     server.listen(0, "127.0.0.1", () => { server.off("error", reject); resolve(undefined) })
   })
   const address = server.address()
-  assert(address !== null && typeof address !== "string")
+  if (address === null || typeof address === "string") throw new Error("Expected a bound TCP address")
   return address.port
 }
 
@@ -77,263 +76,266 @@ function tokens() {
   return new StaticTokenStore([{username: "edge", token: "valid-token"}])
 }
 
-test("authentication and exact-target authorization fail closed", async (t) => {
-  const relay = await startMultiplexedTcpRelay({tokens: tokens(), authorizeTarget: () => false})
-  t.after(() => relay.close())
-  const unauthorizedConnection = new MultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"}
-  })
-  t.after(() => unauthorizedConnection.close())
-  const denied = unauthorizedConnection.createConnection({host: "127.0.0.1", port: 9})
-  const deniedError = await nextError(denied)
-  assert(deniedError instanceof SocketductStreamError)
-  assert.equal(deniedError.code, "TARGET_UNAUTHORIZED")
-  assert.equal(relay.status().activeTargets, 0)
-
-  const invalidConnection = new MultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: relay.port, token: "wrong-token"},
-    maxReconnectAttempts: 2
-  })
-  t.after(() => invalidConnection.close())
-  const invalid = invalidConnection.createConnection({host: "127.0.0.1", port: 9})
-  const authError = await nextError(invalid)
-  assert(authError instanceof SocketductSessionLostError)
-  assert.equal(authError.code, "AUTH_REQUIRED")
-  await new Promise((resolve) => setTimeout(resolve, 30))
-  assert.equal(invalidConnection.status().reconnectAttempts, 0)
-})
+describe("multiplexed failures", () => {
+  it("authentication and exact-target authorization fail closed", async () => withTestCleanup(async (after) => {
+    const relay = await startMultiplexedTcpRelay({tokens: tokens(), authorizeTarget: () => false})
+    after(() => relay.close())
+    const unauthorizedConnection = new MultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"}
+    })
+    after(() => unauthorizedConnection.close())
+    const denied = unauthorizedConnection.createConnection({host: "127.0.0.1", port: 9})
+    const deniedError = await nextError(denied)
+    expect(deniedError instanceof SocketductStreamError).toBeTruthy()
+    expect(deniedError.code).toBe("TARGET_UNAUTHORIZED")
+    expect(relay.status().activeTargets).toBe(0)
 
-test("target open failure and stream reset are isolated from siblings", async (t) => {
-  const echo = createServer((socket) => socket.on("data", (chunk) => socket.write(chunk)))
-  const echoPort = await listen(echo)
-  t.after(() => closeServer(echo))
-  const unused = createServer()
-  const failedPort = await listen(unused)
-  await closeServer(unused)
-  const relay = await startMultiplexedTcpRelay({
-    tokens: tokens(),
-    authorizeTarget: ({target}) => target.host === "127.0.0.1" && (target.port === echoPort || target.port === failedPort)
-  })
-  t.after(() => relay.close())
-  const connection = new MultiplexedSocketductConnection({relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"}})
-  t.after(() => connection.close())
-  const failed = connection.createConnection({host: "127.0.0.1", port: failedPort})
-  const sibling = connection.createConnection({host: "127.0.0.1", port: echoPort})
-  const failure = await nextError(failed)
-  assert.equal(failure.code, "TARGET_OPEN_FAILED")
-  await onceEvent(sibling, "connect")
-  const response = readText(sibling)
-  sibling.write("still-open")
-  assert.equal(await response, "still-open")
-  assert.equal(relay.status().physicalConnections, 1)
-  sibling.destroy()
-})
+    const invalidConnection = new MultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: relay.port, token: "wrong-token"},
+      maxReconnectAttempts: 2
+    })
+    after(() => invalidConnection.close())
+    const invalid = invalidConnection.createConnection({host: "127.0.0.1", port: 9})
+    const authError = await nextError(invalid)
+    expect(authError instanceof SocketductSessionLostError).toBeTruthy()
+    expect(authError.code).toBe("AUTH_REQUIRED")
+    await new Promise((resolve) => setTimeout(resolve, 30))
+    expect(invalidConnection.status().reconnectAttempts).toBe(0)
+  }))
 
-test("resume loss resets only the affected stream while its sibling resumes", async (t) => {
-  /** @type {import('node:net').Socket[]} */
-  const accepted = []
-  const target = createServer((socket) => {
-    accepted.push(socket)
-    socket.on("data", (chunk) => socket.write(chunk))
-  })
-  const targetPort = await listen(target)
-  t.after(() => closeServer(target))
-  const relay = await startMultiplexedTcpRelay({
-    tokens: tokens(),
-    authorizeTarget: ({target: requested}) => requested.port === targetPort,
-    resumeWindowMs: 2_000
-  })
-  t.after(() => relay.close())
-  const connection = new MultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
-    reconnectDelayMs: 40
-  })
-  t.after(() => connection.close())
-  const lost = connection.createConnection({host: "127.0.0.1", port: targetPort, sessionName: "lost"})
-  const survivor = connection.createConnection({host: "127.0.0.1", port: targetPort, sessionName: "survivor"})
-  await Promise.all([onceEvent(lost, "connect"), onceEvent(survivor, "connect")])
-  assert.equal(accepted.length, 2)
-  const lostError = nextError(lost)
-  const survivorReady = onceEvent(survivor, "ready")
-  await relay.closeActiveTransport()
-  const targetToLose = accepted[0]
-  assert(targetToLose !== undefined)
-  targetToLose.destroy()
-  const error = await lostError
-  assert(error instanceof SocketductSessionLostError)
-  assert.equal(error.code, "RESUME_SESSION_LOST")
-  await survivorReady
-  const response = readText(survivor)
-  survivor.write("resumed")
-  assert.equal(await response, "resumed")
-  assert.equal(connection.status().reconnectAttempts, 1)
-  survivor.destroy()
-})
+  it("target open failure and stream reset are isolated from siblings", async () => withTestCleanup(async (after) => {
+    const echo = createServer((socket) => socket.on("data", (chunk) => socket.write(chunk)))
+    const echoPort = await listen(echo)
+    after(() => closeServer(echo))
+    const unused = createServer()
+    const failedPort = await listen(unused)
+    await closeServer(unused)
+    const relay = await startMultiplexedTcpRelay({
+      tokens: tokens(),
+      authorizeTarget: ({target}) => target.host === "127.0.0.1" && (target.port === echoPort || target.port === failedPort)
+    })
+    after(() => relay.close())
+    const connection = new MultiplexedSocketductConnection({relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"}})
+    after(() => connection.close())
+    const failed = connection.createConnection({host: "127.0.0.1", port: failedPort})
+    const sibling = connection.createConnection({host: "127.0.0.1", port: echoPort})
+    const failure = await nextError(failed)
+    expect(failure.code).toBe("TARGET_OPEN_FAILED")
+    await onceEvent(sibling, "connect")
+    const response = readText(sibling)
+    sibling.write("still-open")
+    expect(await response).toBe("still-open")
+    expect(relay.status().physicalConnections).toBe(1)
+    sibling.destroy()
+  }))
 
-test("a drop between OPEN and OPENED resumes the same stream ID safely", async (t) => {
-  /** @type {Duplex | undefined} */
-  let delayedTarget
-  const relay = await startMultiplexedTcpRelay({
-    tokens: tokens(),
-    authorizeTarget: () => true,
-    createTargetConnection: () => {
-      delayedTarget = new Duplex({
-        read() {},
-        write(_chunk, _encoding, callback) { callback() }
-      })
-      return /** @type {import('node:net').Socket} */ (/** @type {unknown} */ (delayedTarget))
-    }
-  })
-  t.after(() => relay.close())
-  const connection = new MultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
-    reconnectDelayMs: 30
-  })
-  t.after(() => connection.close())
-  const socket = connection.createConnection({host: "target.internal", port: 1234})
-  const connected = onceEvent(socket, "connect")
-  await waitUntil(() => delayedTarget !== undefined)
-  await relay.closeActiveTransport()
-  delayedTarget?.emit("connect")
-  await connected
-  assert.equal(socket.streamId, 1)
-  assert.equal(connection.status().reconnectAttempts, 1)
-  assert.equal(relay.status().resumeSuccesses, 1)
-  socket.destroy()
-})
+  it("resume loss resets only the affected stream while its sibling resumes", async () => withTestCleanup(async (after) => {
+    /** @type {import('node:net').Socket[]} */
+    const accepted = []
+    const target = createServer((socket) => {
+      accepted.push(socket)
+      socket.on("data", (chunk) => socket.write(chunk))
+    })
+    const targetPort = await listen(target)
+    after(() => closeServer(target))
+    const relay = await startMultiplexedTcpRelay({
+      tokens: tokens(),
+      authorizeTarget: ({target: requested}) => requested.port === targetPort,
+      resumeWindowMs: 2_000
+    })
+    after(() => relay.close())
+    const connection = new MultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
+      reconnectDelayMs: 40
+    })
+    after(() => connection.close())
+    const lost = connection.createConnection({host: "127.0.0.1", port: targetPort, sessionName: "lost"})
+    const survivor = connection.createConnection({host: "127.0.0.1", port: targetPort, sessionName: "survivor"})
+    await Promise.all([onceEvent(lost, "connect"), onceEvent(survivor, "connect")])
+    expect(accepted.length).toBe(2)
+    const lostError = nextError(lost)
+    const survivorReady = onceEvent(survivor, "ready")
+    await relay.closeActiveTransport()
+    const targetToLose = accepted[0]
+    expect(targetToLose).toBeDefined()
+    if (targetToLose === undefined) throw new Error("Expected an accepted socket")
+    targetToLose.destroy()
+    const error = await lostError
+    expect(error instanceof SocketductSessionLostError).toBeTruthy()
+    expect(error.code).toBe("RESUME_SESSION_LOST")
+    await survivorReady
+    const response = readText(survivor)
+    survivor.write("resumed")
+    expect(await response).toBe("resumed")
+    expect(connection.status().reconnectAttempts).toBe(1)
+    survivor.destroy()
+  }))
 
-test("bounded per-stream and aggregate queues fail only the offending stream", async (t) => {
-  const target = createServer((socket) => socket.pause())
-  const targetPort = await listen(target)
-  t.after(() => closeServer(target))
-  const relay = await startMultiplexedTcpRelay({tokens: tokens(), authorizeTarget: ({target: requested}) => requested.port === targetPort})
-  t.after(() => relay.close())
-  const connection = new MultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
-    maxStreamBufferBytes: 32,
-    maxConnectionBufferBytes: 48,
-    maxFrameBytes: 16,
-    initialWindowBytes: 32
-  })
-  t.after(() => connection.close())
-  const offender = connection.createConnection({host: "127.0.0.1", port: targetPort})
-  const sibling = connection.createConnection({host: "127.0.0.1", port: targetPort})
-  await Promise.all([onceEvent(offender, "connect"), onceEvent(sibling, "connect")])
-  const errorPromise = nextError(offender)
-  offender.write(Buffer.alloc(33))
-  const error = await errorPromise
-  assert.equal(error.code, "SOCKETDUCT_BUFFER_LIMIT")
-  assert.equal(sibling.destroyed, false)
-  assert(connection.status().dataQueuedBytes <= 48)
-  assert(connection.status().controlQueuedBytes <= 1024 * 1024)
-  sibling.destroy()
-})
+  it("a drop between OPEN and OPENED resumes the same stream ID safely", async () => withTestCleanup(async (after) => {
+    /** @type {Duplex | undefined} */
+    let delayedTarget
+    const relay = await startMultiplexedTcpRelay({
+      tokens: tokens(),
+      authorizeTarget: () => true,
+      createTargetConnection: () => {
+        delayedTarget = new Duplex({
+          read() {},
+          write(_chunk, _encoding, callback) { callback() }
+        })
+        return /** @type {import('node:net').Socket} */ (/** @type {unknown} */ (delayedTarget))
+      }
+    })
+    after(() => relay.close())
+    const connection = new MultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
+      reconnectDelayMs: 30
+    })
+    after(() => connection.close())
+    const socket = connection.createConnection({host: "target.internal", port: 1234})
+    const connected = onceEvent(socket, "connect")
+    await waitUntil(() => delayedTarget !== undefined)
+    await relay.closeActiveTransport()
+    delayedTarget?.emit("connect")
+    await connected
+    expect(socket.streamId).toBe(1)
+    expect(connection.status().reconnectAttempts).toBe(1)
+    expect(relay.status().resumeSuccesses).toBe(1)
+    socket.destroy()
+  }))
 
-test("round-robin data scheduling lets a small control flow pass a large upload", async (t) => {
-  let largeBytesObserved = 0
-  let largeCompleted = false
-  let smallObservedAfterLargeCompleted
-  const largeTarget = createServer((socket) => socket.on("data", (chunk) => {
-    largeBytesObserved += chunk.length
-    if (largeBytesObserved === 64 * 1024) largeCompleted = true
+  it("bounded per-stream and aggregate queues fail only the offending stream", async () => withTestCleanup(async (after) => {
+    const target = createServer((socket) => socket.pause())
+    const targetPort = await listen(target)
+    after(() => closeServer(target))
+    const relay = await startMultiplexedTcpRelay({tokens: tokens(), authorizeTarget: ({target: requested}) => requested.port === targetPort})
+    after(() => relay.close())
+    const connection = new MultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
+      maxStreamBufferBytes: 32,
+      maxConnectionBufferBytes: 48,
+      maxFrameBytes: 16,
+      initialWindowBytes: 32
+    })
+    after(() => connection.close())
+    const offender = connection.createConnection({host: "127.0.0.1", port: targetPort})
+    const sibling = connection.createConnection({host: "127.0.0.1", port: targetPort})
+    await Promise.all([onceEvent(offender, "connect"), onceEvent(sibling, "connect")])
+    const errorPromise = nextError(offender)
+    offender.write(Buffer.alloc(33))
+    const error = await errorPromise
+    expect(error.code).toBe("SOCKETDUCT_BUFFER_LIMIT")
+    expect(sibling.destroyed).toBe(false)
+    expect(connection.status().dataQueuedBytes <= 48).toBeTruthy()
+    expect(connection.status().controlQueuedBytes <= 1024 * 1024).toBeTruthy()
+    sibling.destroy()
   }))
-  const largePort = await listen(largeTarget)
-  t.after(() => closeServer(largeTarget))
-  const smallTarget = createServer((socket) => socket.on("data", (chunk) => {
-    smallObservedAfterLargeCompleted = largeCompleted
-    socket.write(chunk)
+
+  it("round-robin data scheduling lets a small control flow pass a large upload", async () => withTestCleanup(async (after) => {
+    let largeBytesObserved = 0
+    let largeCompleted = false
+    let smallObservedAfterLargeCompleted
+    const largeTarget = createServer((socket) => socket.on("data", (chunk) => {
+      largeBytesObserved += chunk.length
+      if (largeBytesObserved === 64 * 1024) largeCompleted = true
+    }))
+    const largePort = await listen(largeTarget)
+    after(() => closeServer(largeTarget))
+    const smallTarget = createServer((socket) => socket.on("data", (chunk) => {
+      smallObservedAfterLargeCompleted = largeCompleted
+      socket.write(chunk)
+    }))
+    const smallPort = await listen(smallTarget)
+    after(() => closeServer(smallTarget))
+    const relay = await startMultiplexedTcpRelay({
+      tokens: tokens(),
+      authorizeTarget: ({target}) => target.port === largePort || target.port === smallPort,
+      maxFrameBytes: 1024
+    })
+    after(() => relay.close())
+    const connection = new MultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
+      maxFrameBytes: 1024
+    })
+    after(() => connection.close())
+    const large = connection.createConnection({host: "127.0.0.1", port: largePort})
+    const small = connection.createConnection({host: "127.0.0.1", port: smallPort})
+    await Promise.all([onceEvent(large, "connect"), onceEvent(small, "connect")])
+    const smallResponse = readText(small)
+    large.write(Buffer.alloc(64 * 1024))
+    small.write("control")
+    expect(await smallResponse).toBe("control")
+    expect(smallObservedAfterLargeCompleted).toBe(false)
+    expect(largeBytesObserved < 64 * 1024).toBeTruthy()
+    large.destroy()
+    small.destroy()
   }))
-  const smallPort = await listen(smallTarget)
-  t.after(() => closeServer(smallTarget))
-  const relay = await startMultiplexedTcpRelay({
-    tokens: tokens(),
-    authorizeTarget: ({target}) => target.port === largePort || target.port === smallPort,
-    maxFrameBytes: 1024
-  })
-  t.after(() => relay.close())
-  const connection = new MultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
-    maxFrameBytes: 1024
-  })
-  t.after(() => connection.close())
-  const large = connection.createConnection({host: "127.0.0.1", port: largePort})
-  const small = connection.createConnection({host: "127.0.0.1", port: smallPort})
-  await Promise.all([onceEvent(large, "connect"), onceEvent(small, "connect")])
-  const smallResponse = readText(small)
-  large.write(Buffer.alloc(64 * 1024))
-  small.write("control")
-  assert.equal(await smallResponse, "control")
-  assert.equal(smallObservedAfterLargeCompleted, false)
-  assert(largeBytesObserved < 64 * 1024)
-  large.destroy()
-  small.destroy()
-})
 
-test("per-stream receive windows bound a paused consumer and resume independently", async (t) => {
-  const payload = Buffer.alloc(4 * 1024, 0x61)
-  const target = createServer((socket) => socket.write(payload))
-  const targetPort = await listen(target)
-  t.after(() => closeServer(target))
-  const relay = await startMultiplexedTcpRelay({
-    tokens: tokens(),
-    authorizeTarget: ({target: requested}) => requested.port === targetPort,
-    initialWindowBytes: 1024,
-    maxFrameBytes: 512,
-    maxStreamBufferBytes: 8 * 1024
-  })
-  t.after(() => relay.close())
-  const connection = new MultiplexedSocketductConnection({
-    relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
-    initialWindowBytes: 1024,
-    maxFrameBytes: 512
-  })
-  t.after(() => connection.close())
-  const paused = connection.createConnection({
-    host: "127.0.0.1",
-    port: targetPort,
-    readableHighWaterMark: 256
-  })
-  await onceEvent(paused, "connect")
-  await waitUntil(() => relay.status().queuedBytes === payload.length)
-  assert.equal(relay.status().resets, 0)
-  assert(relay.status().queuedBytes <= 8 * 1024)
+  it("per-stream receive windows bound a paused consumer and resume independently", async () => withTestCleanup(async (after) => {
+    const payload = Buffer.alloc(4 * 1024, 0x61)
+    const target = createServer((socket) => socket.write(payload))
+    const targetPort = await listen(target)
+    after(() => closeServer(target))
+    const relay = await startMultiplexedTcpRelay({
+      tokens: tokens(),
+      authorizeTarget: ({target: requested}) => requested.port === targetPort,
+      initialWindowBytes: 1024,
+      maxFrameBytes: 512,
+      maxStreamBufferBytes: 8 * 1024
+    })
+    after(() => relay.close())
+    const connection = new MultiplexedSocketductConnection({
+      relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"},
+      initialWindowBytes: 1024,
+      maxFrameBytes: 512
+    })
+    after(() => connection.close())
+    const paused = connection.createConnection({
+      host: "127.0.0.1",
+      port: targetPort,
+      readableHighWaterMark: 256
+    })
+    await onceEvent(paused, "connect")
+    await waitUntil(() => relay.status().queuedBytes === payload.length)
+    expect(relay.status().resets).toBe(0)
+    expect(relay.status().queuedBytes <= 8 * 1024).toBeTruthy()
 
-  const received = await new Promise((resolve, reject) => {
-    /** @type {Buffer[]} */
-    const chunks = []
-    let bytes = 0
-    paused.on("data", (chunk) => {
-      chunks.push(chunk)
-      bytes += chunk.length
-      if (bytes === payload.length) resolve(Buffer.concat(chunks))
+    const received = await new Promise((resolve, reject) => {
+      /** @type {Buffer[]} */
+      const chunks = []
+      let bytes = 0
+      paused.on("data", (chunk) => {
+        chunks.push(chunk)
+        bytes += chunk.length
+        if (bytes === payload.length) resolve(Buffer.concat(chunks))
+      })
+      paused.once("error", reject)
+      paused.resume()
     })
-    paused.once("error", reject)
-    paused.resume()
-  })
-  assert.deepEqual(received, payload)
-  await waitUntil(() => relay.status().queuedBytes === 0)
-  paused.destroy()
-})
+    expect(received.equals(payload)).toBe(true)
+    await waitUntil(() => relay.status().queuedBytes === 0)
+    paused.destroy()
+  }))
 
-test("relay accepts local target sockets without creating extra WAN transports", async (t) => {
-  const target = createServer((socket) => socket.end())
-  const port = await listen(target)
-  t.after(() => closeServer(target))
-  let localConnects = 0
-  const relay = await startMultiplexedTcpRelay({
-    tokens: tokens(),
-    authorizeTarget: ({target: requested}) => requested.port === port,
-    createTargetConnection: (requested) => {
-      localConnects += 1
-      return createConnection(requested)
-    }
-  })
-  t.after(() => relay.close())
-  const connection = new MultiplexedSocketductConnection({relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"}})
-  t.after(() => connection.close())
-  const streams = Array.from({length: 4}, () => connection.createConnection({host: "127.0.0.1", port}))
-  await Promise.all(streams.map((socket) => onceEvent(socket, "connect")))
-  assert.equal(localConnects, 4)
-  assert.equal(relay.status().physicalAccepts, 1)
-  streams.forEach((socket) => socket.destroy())
+  it("relay accepts local target sockets without creating extra WAN transports", async () => withTestCleanup(async (after) => {
+    const target = createServer((socket) => socket.end())
+    const port = await listen(target)
+    after(() => closeServer(target))
+    let localConnects = 0
+    const relay = await startMultiplexedTcpRelay({
+      tokens: tokens(),
+      authorizeTarget: ({target: requested}) => requested.port === port,
+      createTargetConnection: (requested) => {
+        localConnects += 1
+        return createConnection(requested)
+      }
+    })
+    after(() => relay.close())
+    const connection = new MultiplexedSocketductConnection({relay: {host: "127.0.0.1", port: relay.port, token: "valid-token"}})
+    after(() => connection.close())
+    const streams = Array.from({length: 4}, () => connection.createConnection({host: "127.0.0.1", port}))
+    await Promise.all(streams.map((socket) => onceEvent(socket, "connect")))
+    expect(localConnects).toBe(4)
+    expect(relay.status().physicalAccepts).toBe(1)
+    streams.forEach((socket) => socket.destroy())
+  }))
 })