socketduct 0.1.25 → 0.1.26

package/test/unit/client/virtual-socket.test.js

@@ -1,6 +1,5 @@
 /* eslint-disable jsdoc/escape-inline-tags, jsdoc/require-param-type, jsdoc/require-returns */
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, it} from "@velocious/testing"
 
 import {VirtualSocket} from "../../../src/client/virtual-socket.js"
 
@@ -27,7 +26,7 @@ function fakeConnection() {
       _resumeReadable: () => { calls.resumed += 1 },
       _deliverReadable: (/** @type {number} */ _id, /** @type {number} */ bytes) => { calls.delivered += bytes },
       _acknowledgeReadable: (/** @type {number} */ _id, /** @type {number} */ bytes) => {
-        assert(bytes <= calls.delivered - calls.acknowledged)
+        if (!(bytes <= calls.delivered - calls.acknowledged)) throw new Error("ACK exceeds delivered bytes")
         calls.acknowledged += bytes
         return Promise.resolve(calls.acknowledged)
       },
@@ -42,179 +41,210 @@ function fakeConnection() {
   }
 }
 
-test("VirtualSocket exposes normal connect metadata and compatibility methods", async () => {
-  const fake = fakeConnection()
-  const socket = new VirtualSocket(fake.connection, 1, {host: "target.internal", port: 443})
-  /** @type {string[]} */
-  const events = []
-  socket.on("connect", () => events.push("connect"))
-  socket.on("ready", () => events.push("ready"))
-  socket._markConnected()
-
-  assert.deepEqual(events, ["connect", "ready"])
-  assert.equal(socket.connecting, false)
-  assert.equal(socket.pending, false)
-  assert.equal(socket.remoteAddress, "target.internal")
-  assert.equal(socket.remotePort, 443)
-  assert.deepEqual(socket.address(), {address: "127.0.0.1", family: "IPv4", port: 43210})
-  assert.equal(socket.setNoDelay(), socket)
-  assert.equal(socket.setKeepAlive(), socket)
-  assert.equal(socket.ref(), socket)
-  assert.equal(socket.unref(), socket)
-  assert.equal(fake.calls.refs, 1)
-  assert.equal(fake.calls.unrefs, 1)
-  socket.destroy()
-  await new Promise((resolve) => socket.once("close", resolve))
-})
-
-test("VirtualSocket write backpressure emits drain and end emits finish", async () => {
-  const fake = fakeConnection()
-  const socket = new VirtualSocket(fake.connection, 3, {
-    host: "127.0.0.1",
-    port: 80,
-    writableHighWaterMark: 1,
-    allowHalfOpen: true
+describe("VirtualSocket", () => {
+  it("VirtualSocket exposes normal connect metadata and compatibility methods", async () => {
+    const fake = fakeConnection()
+    const socket = new VirtualSocket(fake.connection, 1, {host: "target.internal", port: 443})
+    /** @type {string[]} */
+    const events = []
+    socket.on("connect", () => events.push("connect"))
+    socket.on("ready", () => events.push("ready"))
+    socket._markConnected()
+
+    expect(events).toEqual(["connect", "ready"])
+    expect(socket.connecting).toBe(false)
+    expect(socket.pending).toBe(false)
+    expect(socket.remoteAddress).toBe("target.internal")
+    expect(socket.remotePort).toBe(443)
+    expect(socket.address()).toEqual({address: "127.0.0.1", family: "IPv4", port: 43210})
+    expect(socket.setNoDelay()).toBe(socket)
+    expect(socket.setKeepAlive()).toBe(socket)
+    expect(socket.ref()).toBe(socket)
+    expect(socket.unref()).toBe(socket)
+    expect(fake.calls.refs).toBe(1)
+    expect(fake.calls.unrefs).toBe(1)
+    socket.destroy()
+    await new Promise((resolve) => socket.once("close", resolve))
   })
-  socket._markConnected()
-  const drained = new Promise((resolve) => socket.once("drain", resolve))
-  assert.equal(socket.write("payload"), false)
-  await drained
-  assert.equal(socket.bytesWritten, 7)
-  const finished = new Promise((resolve) => socket.once("finish", resolve))
-  socket.end()
-  await finished
-  assert.equal(fake.calls.ended, 1)
-  socket.destroy()
-})
 
-test("VirtualSocket pause/resume, timeout, data and half-close remain stream-local", async () => {
-  const fake = fakeConnection()
-  const socket = new VirtualSocket(fake.connection, 5, {host: "127.0.0.1", port: 80, allowHalfOpen: true})
-  socket._markConnected()
-  socket.pause()
-  const timeout = new Promise((resolve) => socket.setTimeout(10, () => resolve(undefined)))
-  await timeout
-  socket.setTimeout(0)
-  const data = new Promise((resolve) => socket.once("data", (chunk) => resolve(chunk.toString())))
-  socket._receive(Buffer.from("hello"))
-  socket.resume()
-  assert.equal(await data, "hello")
-  assert.equal(socket.bytesRead, 5)
-  const ended = new Promise((resolve) => socket.once("end", resolve))
-  socket._receiveEnd()
-  await ended
-  assert(fake.calls.resumed > 0)
-  socket.destroy()
-})
+  it("VirtualSocket write backpressure emits drain and end emits finish", async () => {
+    const fake = fakeConnection()
+    const socket = new VirtualSocket(fake.connection, 3, {
+      host: "127.0.0.1",
+      port: 80,
+      writableHighWaterMark: 1,
+      allowHalfOpen: true
+    })
+    socket._markConnected()
+    const drained = new Promise((resolve) => socket.once("drain", resolve))
+    expect(socket.write("payload")).toBe(false)
+    await drained
+    expect(socket.bytesWritten).toBe(7)
+    const finished = new Promise((resolve) => socket.once("finish", resolve))
+    socket.end()
+    await finished
+    expect(fake.calls.ended).toBe(1)
+    socket.destroy()
+  })
 
-test("VirtualSocket exposes opt-in manual receive ACK and durable write contracts", async () => {
-  const fake = fakeConnection()
-  const socket = new VirtualSocket(fake.connection, 7, {
-    host: "127.0.0.1",
-    port: 80,
-    manualReceiveAck: true
+  it("VirtualSocket pause/resume, timeout, data and half-close remain stream-local", async () => {
+    const fake = fakeConnection()
+    const socket = new VirtualSocket(fake.connection, 5, {host: "127.0.0.1", port: 80, allowHalfOpen: true})
+    socket._markConnected()
+    socket.pause()
+    const timeout = new Promise((resolve) => socket.setTimeout(10, () => resolve(undefined)))
+    await timeout
+    socket.setTimeout(0)
+    const data = new Promise((resolve) => socket.once("data", (chunk) => resolve(chunk.toString())))
+    socket._receive(Buffer.from("hello"))
+    socket.resume()
+    expect(await data).toBe("hello")
+    expect(socket.bytesRead).toBe(5)
+    const ended = new Promise((resolve) => socket.once("end", resolve))
+    socket._receiveEnd()
+    await ended
+    expect(fake.calls.resumed > 0).toBeTruthy()
+    socket.destroy()
   })
-  socket._markConnected()
 
-  const acknowledged = new Promise((resolve, reject) => {
-    socket.once("data", (chunk) => {
-      socket.acknowledgeReceive(chunk.length).then(resolve, reject)
+  it("VirtualSocket exposes opt-in manual receive ACK and durable write contracts", async () => {
+    const fake = fakeConnection()
+    const socket = new VirtualSocket(fake.connection, 7, {
+      host: "127.0.0.1",
+      port: 80,
+      manualReceiveAck: true
+    })
+    socket._markConnected()
+
+    const acknowledged = new Promise((resolve, reject) => {
+      socket.once("data", (chunk) => {
+        socket.acknowledgeReceive(chunk.length).then(resolve, reject)
+      })
     })
+    socket._receive(Buffer.from("response"))
+    expect(await acknowledged).toBe(8)
+    expect(fake.calls.delivered).toBe(8)
+    expect(fake.calls.acknowledged).toBe(8)
+
+    await socket.writeDurable(new Uint8Array(Buffer.from("request")))
+    expect(fake.calls.durableWrites).toHaveLength(1)
+    const durableWrite = fake.calls.durableWrites[0]
+    expect(durableWrite).toBeDefined()
+    expect(durableWrite?.equals(Buffer.from("request"))).toBe(true)
+    expect(socket.bytesWritten).toBe(7)
+    // predicate-based check: thrown error must carry SOCKETDUCT_INVALID_RECEIVE_ACK
+    let error
+    try {
+      socket.acknowledgeReceive(1)
+    } catch (caught) {
+      error = caught
+    }
+    expect(error).toBeDefined()
+    expect(/** @type {{code?: string}} */ (error).code).toBe("SOCKETDUCT_INVALID_RECEIVE_ACK")
+    const closed = new Promise((resolve) => socket.once("close", resolve))
+    socket.destroy()
+    await closed
+    // predicate-based rejection: code ERR_STREAM_DESTROYED
+    let rejection
+    try {
+      await socket.acknowledgeReceive(1)
+    } catch (caught) {
+      rejection = caught
+    }
+    expect(rejection).toBeDefined()
+    expect(/** @type {{code?: string}} */ (rejection).code).toBe("ERR_STREAM_DESTROYED")
   })
-  socket._receive(Buffer.from("response"))
-  assert.equal(await acknowledged, 8)
-  assert.equal(fake.calls.delivered, 8)
-  assert.equal(fake.calls.acknowledged, 8)
-
-  await socket.writeDurable(new Uint8Array(Buffer.from("request")))
-  assert.deepEqual(fake.calls.durableWrites, [Buffer.from("request")])
-  assert.equal(socket.bytesWritten, 7)
-  assert.throws(
-    () => socket.acknowledgeReceive(1),
-    (error) => /** @type {{code?: string}} */ (error).code === "SOCKETDUCT_INVALID_RECEIVE_ACK"
-  )
-  const closed = new Promise((resolve) => socket.once("close", resolve))
-  socket.destroy()
-  await closed
-  await assert.rejects(
-    socket.acknowledgeReceive(1),
-    (error) => /** @type {{code?: string}} */ (error).code === "ERR_STREAM_DESTROYED"
-  )
-})
 
-test("VirtualSocket orders durable writes behind queued ordinary writes", async () => {
-  const fake = fakeConnection()
-  /** @type {string[]} */
-  const delivered = []
-  /** @type {(() => void) | undefined} */
-  let releaseFirst
-  const connection = /** @type {{_writeStream: (id: number, data: Buffer, callback: (error?: Error | null) => void) => void, _writeDurableStream: (id: number, data: Buffer, callback: (error?: Error | null) => void) => void}} */ (/** @type {unknown} */ (fake.connection))
-  connection._writeStream = (_id, data, callback) => {
-    delivered.push(data.toString())
-    if (data.toString() === "A") releaseFirst = callback
-    else callback()
-  }
-  connection._writeDurableStream = (_id, data, callback) => {
-    delivered.push(data.toString())
-    callback()
-  }
-  const socket = new VirtualSocket(fake.connection, 9, {host: "127.0.0.1", port: 80})
-
-  const first = new Promise((resolve, reject) => socket.write("A", (error) => error ? reject(error) : resolve(undefined)))
-  const second = new Promise((resolve, reject) => socket.write("B", (error) => error ? reject(error) : resolve(undefined)))
-  const durable = socket.writeDurable("C")
-  assert(releaseFirst !== undefined)
-  releaseFirst()
-  await Promise.all([first, second, durable])
-
-  assert.deepEqual(delivered, ["A", "B", "C"])
-  assert.equal(socket.bytesWritten, 3)
-  socket.destroy()
-})
+  it("VirtualSocket orders durable writes behind queued ordinary writes", async () => {
+    const fake = fakeConnection()
+    /** @type {string[]} */
+    const delivered = []
+    /** @type {(() => void) | undefined} */
+    let releaseFirst
+    const connection = /** @type {{_writeStream: (id: number, data: Buffer, callback: (error?: Error | null) => void) => void, _writeDurableStream: (id: number, data: Buffer, callback: (error?: Error | null) => void) => void}} */ (/** @type {unknown} */ (fake.connection))
+    connection._writeStream = (_id, data, callback) => {
+      delivered.push(data.toString())
+      if (data.toString() === "A") releaseFirst = callback
+      else callback()
+    }
+    connection._writeDurableStream = (_id, data, callback) => {
+      delivered.push(data.toString())
+      callback()
+    }
+    const socket = new VirtualSocket(fake.connection, 9, {host: "127.0.0.1", port: 80})
+
+    const first = new Promise((resolve, reject) => socket.write("A", (error) => error ? reject(error) : resolve(undefined)))
+    const second = new Promise((resolve, reject) => socket.write("B", (error) => error ? reject(error) : resolve(undefined)))
+    const durable = socket.writeDurable("C")
+    if (releaseFirst === undefined) throw new Error("expected first write callback to be captured")
+    releaseFirst()
+    await Promise.all([first, second, durable])
+
+    expect(delivered).toEqual(["A", "B", "C"])
+    expect(socket.bytesWritten).toBe(3)
+    socket.destroy()
+  })
 
-test("VirtualSocket rejects durable writes after end while ordinary writes remain queued", async () => {
-  const fake = fakeConnection()
-  /** @type {string[]} */
-  const delivered = []
-  /** @type {(() => void) | undefined} */
-  let releaseFirst
-  const connection = /** @type {{_writeStream: (id: number, data: Buffer, callback: (error?: Error | null) => void) => void}} */ (/** @type {unknown} */ (fake.connection))
-  connection._writeStream = (_id, data, callback) => {
-    delivered.push(data.toString())
-    if (data.toString() === "A") releaseFirst = callback
-    else callback()
-  }
-  const socket = new VirtualSocket(fake.connection, 11, {host: "127.0.0.1", port: 80})
-
-  const first = new Promise((resolve, reject) => socket.write("A", (error) => error ? reject(error) : resolve(undefined)))
-  const second = new Promise((resolve, reject) => socket.write("B", (error) => error ? reject(error) : resolve(undefined)))
-  const finished = new Promise((resolve) => socket.once("finish", resolve))
-  socket.end()
-  const rejected = assert.rejects(
-    socket.writeDurable("late"),
-    (error) => /** @type {{code?: string}} */ (error).code === "ERR_STREAM_WRITE_AFTER_END"
-  )
-
-  assert(releaseFirst !== undefined)
-  releaseFirst()
-  await Promise.all([first, second, finished, rejected])
-  assert.deepEqual(delivered, ["A", "B"])
-  assert.deepEqual(fake.calls.durableWrites, [])
-  socket.destroy()
-})
+  it("VirtualSocket rejects durable writes after end while ordinary writes remain queued", async () => {
+    const fake = fakeConnection()
+    /** @type {string[]} */
+    const delivered = []
+    /** @type {(() => void) | undefined} */
+    let releaseFirst
+    const connection = /** @type {{_writeStream: (id: number, data: Buffer, callback: (error?: Error | null) => void) => void}} */ (/** @type {unknown} */ (fake.connection))
+    connection._writeStream = (_id, data, callback) => {
+      delivered.push(data.toString())
+      if (data.toString() === "A") releaseFirst = callback
+      else callback()
+    }
+    const socket = new VirtualSocket(fake.connection, 11, {host: "127.0.0.1", port: 80})
+
+    const first = new Promise((resolve, reject) => socket.write("A", (error) => error ? reject(error) : resolve(undefined)))
+    const second = new Promise((resolve, reject) => socket.write("B", (error) => error ? reject(error) : resolve(undefined)))
+    const finished = new Promise((resolve) => socket.once("finish", resolve))
+    socket.end()
+    // predicate-based rejection: code ERR_STREAM_WRITE_AFTER_END
+    const rejected = (async () => {
+      try {
+        await socket.writeDurable("late")
+        throw new Error("expected writeDurable to reject")
+      } catch (caught) {
+        const code = /** @type {{code?: string}} */ (caught).code
+        if (code !== "ERR_STREAM_WRITE_AFTER_END") throw caught
+      }
+    })()
+
+    if (releaseFirst === undefined) throw new Error("expected first write callback to be captured")
+    releaseFirst()
+    await Promise.all([first, second, finished, rejected])
+    expect(delivered).toEqual(["A", "B"])
+    expect(fake.calls.durableWrites).toEqual([])
+    socket.destroy()
+  })
 
-test("VirtualSocket keeps manual ACK opt-in and reports unsupported durable admission", async () => {
-  const fake = fakeConnection()
-  delete /** @type {{_writeDurableStream?: unknown}} */ (fake.connection)._writeDurableStream
-  const socket = new VirtualSocket(fake.connection, 9, {host: "127.0.0.1", port: 80})
-
-  assert.throws(
-    () => socket.acknowledgeReceive(1),
-    (error) => /** @type {{code?: string}} */ (error).code === "SOCKETDUCT_MANUAL_ACK_DISABLED"
-  )
-  await assert.rejects(
-    socket.writeDurable("request"),
-    (error) => /** @type {{code?: string}} */ (error).code === "SOCKETDUCT_DURABLE_WRITE_UNSUPPORTED"
-  )
-  socket.destroy()
+  it("VirtualSocket keeps manual ACK opt-in and reports unsupported durable admission", async () => {
+    const fake = fakeConnection()
+    delete /** @type {{_writeDurableStream?: unknown}} */ (fake.connection)._writeDurableStream
+    const socket = new VirtualSocket(fake.connection, 9, {host: "127.0.0.1", port: 80})
+
+    // predicate-based check: thrown error must carry SOCKETDUCT_MANUAL_ACK_DISABLED
+    let error
+    try {
+      socket.acknowledgeReceive(1)
+    } catch (caught) {
+      error = caught
+    }
+    expect(error).toBeDefined()
+    expect(/** @type {{code?: string}} */ (error).code).toBe("SOCKETDUCT_MANUAL_ACK_DISABLED")
+    // predicate-based rejection: code SOCKETDUCT_DURABLE_WRITE_UNSUPPORTED
+    let rejection
+    try {
+      await socket.writeDurable("request")
+    } catch (caught) {
+      rejection = caught
+    }
+    expect(rejection).toBeDefined()
+    expect(/** @type {{code?: string}} */ (rejection).code).toBe("SOCKETDUCT_DURABLE_WRITE_UNSUPPORTED")
+    socket.destroy()
+  })
 })