socketduct 0.1.24 → 0.1.26

package/test/unit/auth/auth.test.js

@@ -1,5 +1,4 @@
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, it} from "@velocious/testing"
 
 import {
   createPasswordHash,
@@ -11,54 +10,54 @@ import {
   TokenStore
 } from "../../../src/auth/user-store.js"
 
-test("createPasswordHash stores a salted scrypt hash instead of plaintext", async () => {
-  const hash = await createPasswordHash("correct horse battery staple")
+describe("auth", () => {
+  it("createPasswordHash stores a salted scrypt hash instead of plaintext", async () => {
+    const hash = await createPasswordHash("correct horse battery staple")
 
-  assert.notEqual(hash, "correct horse battery staple")
-  assert.match(hash, /^scrypt\$/)
-  assert.equal(await verifyPassword("correct horse battery staple", hash), true)
-  assert.equal(await verifyPassword("wrong password", hash), false)
-})
-
-test("login returns an opaque token for valid username and password", async () => {
-  const users = new InMemoryUserStore()
-  const tokens = new TokenStore({now: () => 1_000})
-  await users.createUser({username: "kasper", password: "secret-password"})
-
-  const token = await login(users, tokens, {
-    username: "kasper",
-    password: "secret-password"
+    expect(hash).not.toBe("correct horse battery staple")
+    expect(hash).toMatch(/^scrypt\$/)
+    expect(await verifyPassword("correct horse battery staple", hash)).toBe(true)
+    expect(await verifyPassword("wrong password", hash)).toBe(false)
   })
 
-  assert.match(token.value, /^[a-zA-Z0-9_-]{32,}$/)
-  assert.equal(tokens.authenticate(token.value)?.username, "kasper")
-})
+  it("login returns an opaque token for valid username and password", async () => {
+    const users = new InMemoryUserStore()
+    const tokens = new TokenStore({now: () => 1_000})
+    await users.createUser({username: "kasper", password: "secret-password"})
 
-test("login rejects invalid username or password", async () => {
-  const users = new InMemoryUserStore()
-  const tokens = new TokenStore()
-  await users.createUser({username: "kasper", password: "secret-password"})
+    const token = await login(users, tokens, {
+      username: "kasper",
+      password: "secret-password"
+    })
 
-  await assert.rejects(
-    login(users, tokens, {username: "missing", password: "secret-password"}),
-    /invalid username or password/i
-  )
-  await assert.rejects(
-    login(users, tokens, {username: "kasper", password: "wrong-password"}),
-    /invalid username or password/i
-  )
-})
+    expect(token.value).toMatch(/^[a-zA-Z0-9_-]{32,}$/)
+    expect(tokens.authenticate(token.value)?.username).toBe("kasper")
+  })
+
+  it("login rejects invalid username or password", async () => {
+    const users = new InMemoryUserStore()
+    const tokens = new TokenStore()
+    await users.createUser({username: "kasper", password: "secret-password"})
+
+    await expect(
+      login(users, tokens, {username: "missing", password: "secret-password"})
+    ).rejects.toThrow(/invalid username or password/i)
+    await expect(
+      login(users, tokens, {username: "kasper", password: "wrong-password"})
+    ).rejects.toThrow(/invalid username or password/i)
+  })
 
-test("TokenStore expires and revokes tokens", () => {
-  let now = 1_000
-  const tokens = new TokenStore({now: () => now, tokenTtlMs: 500})
-  const token = tokens.issue({userId: "user-1", username: "kasper"})
+  it("TokenStore expires and revokes tokens", () => {
+    let now = 1_000
+    const tokens = new TokenStore({now: () => now, tokenTtlMs: 500})
+    const token = tokens.issue({userId: "user-1", username: "kasper"})
 
-  assert.equal(tokens.authenticate(token.value)?.userId, "user-1")
-  now = 1_501
-  assert.equal(tokens.authenticate(token.value), undefined)
+    expect(tokens.authenticate(token.value)?.userId).toBe("user-1")
+    now = 1_501
+    expect(tokens.authenticate(token.value)).toBeUndefined()
 
-  const revoked = tokens.issue({userId: "user-1", username: "kasper"})
-  assert.equal(tokens.revoke(revoked.value), true)
-  assert.equal(tokens.authenticate(revoked.value), undefined)
+    const revoked = tokens.issue({userId: "user-1", username: "kasper"})
+    expect(tokens.revoke(revoked.value)).toBe(true)
+    expect(tokens.authenticate(revoked.value)).toBeUndefined()
+  })
 })

package/test/unit/auth/static-token-store.test.js

@@ -1,14 +1,15 @@
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, it} from "@velocious/testing"
 
 import {StaticTokenStore} from "../../../src/auth/static-token-store.js"
 
-test("StaticTokenStore authenticates configured bearer tokens", () => {
-  const tokens = new StaticTokenStore([{username: "edge", token: "secret-token"}])
+describe("static token store", () => {
+  it("StaticTokenStore authenticates configured bearer tokens", () => {
+    const tokens = new StaticTokenStore([{username: "edge", token: "secret-token"}])
 
-  const principal = tokens.authenticate("secret-token")
+    const principal = tokens.authenticate("secret-token")
 
-  assert.equal(principal?.username, "edge")
-  assert.equal(principal?.userId.startsWith("static:"), true)
-  assert.equal(tokens.authenticate("wrong-token"), undefined)
+    expect(principal?.username).toBe("edge")
+    expect(principal?.userId.startsWith("static:")).toBe(true)
+    expect(tokens.authenticate("wrong-token")).toBeUndefined()
+  })
 })

package/test/unit/client/connect.test.js

@@ -1,8 +1,7 @@
-import assert from "node:assert/strict"
+import {describe, expect, it} from "@velocious/testing"
 import {mkdtemp, rm} from "node:fs/promises"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
-import test from "node:test"
 
 import {createSocketductConnectionFactory} from "../../../src/client/connect.js"
 import {SocketductSocket} from "../../../src/client/socketduct-socket.js"
@@ -14,45 +13,47 @@ async function createSpoolRoot() {
   return await mkdtemp(join(tmpdir(), "socketduct-connect-test-"))
 }
 
-test("createSocketductConnectionFactory merges base relay options with per-call targets", async () => {
-  const spoolDirectory = await createSpoolRoot()
-  const createConnection = createSocketductConnectionFactory({
-    relay: {host: "relay.local", port: 3100, token: "token"},
-    spoolDirectory,
-    reconnect: {initialDelayMs: 25},
-    sessionNamePrefix: "docker"
+describe("createSocketductConnectionFactory", () => {
+  it("createSocketductConnectionFactory merges base relay options with per-call targets", async () => {
+    const spoolDirectory = await createSpoolRoot()
+    const createConnection = createSocketductConnectionFactory({
+      relay: {host: "relay.local", port: 3100, token: "token"},
+      spoolDirectory,
+      reconnect: {initialDelayMs: 25},
+      sessionNamePrefix: "docker"
+    })
+
+    const socket = createConnection({host: "docker-api", port: 2375})
+
+    expect(socket instanceof SocketductSocket).toBe(true)
+    expect(socket.remoteAddress).toBe("docker-api")
+    expect(socket.remotePort).toBe(2375)
+    expect(socket.connecting).toBe(true)
+    socket.destroy()
+    await rm(spoolDirectory, {recursive: true, force: true})
   })
 
-  const socket = createConnection({host: "docker-api", port: 2375})
-
-  assert.equal(socket instanceof SocketductSocket, true)
-  assert.equal(socket.remoteAddress, "docker-api")
-  assert.equal(socket.remotePort, 2375)
-  assert.equal(socket.connecting, true)
-  socket.destroy()
-  await rm(spoolDirectory, {recursive: true, force: true})
-})
-
-test("createSocketductConnectionFactory accepts explicit target and connect listener", async () => {
-  const spoolDirectory = await createSpoolRoot()
-  const createConnection = createSocketductConnectionFactory({
-    relay: {host: "relay.local", port: 3100, token: "token"},
-    spoolDirectory,
-    sessionNamePrefix: "explicit"
+  it("createSocketductConnectionFactory accepts explicit target and connect listener", async () => {
+    const spoolDirectory = await createSpoolRoot()
+    const createConnection = createSocketductConnectionFactory({
+      relay: {host: "relay.local", port: 3100, token: "token"},
+      spoolDirectory,
+      sessionNamePrefix: "explicit"
+    })
+    let listenerCalled = false
+
+    const socket = createConnection({
+      target: {host: "docker-socket-shim", port: 2375},
+      sessionName: "custom session"
+    }, () => {
+      listenerCalled = true
+    })
+
+    expect(socket.remoteAddress).toBe("docker-socket-shim")
+    expect(socket.remotePort).toBe(2375)
+    socket.emit("connect")
+    expect(listenerCalled).toBe(true)
+    socket.destroy()
+    await rm(spoolDirectory, {recursive: true, force: true})
   })
-  let listenerCalled = false
-
-  const socket = createConnection({
-    target: {host: "docker-socket-shim", port: 2375},
-    sessionName: "custom session"
-  }, () => {
-    listenerCalled = true
-  })
-
-  assert.equal(socket.remoteAddress, "docker-socket-shim")
-  assert.equal(socket.remotePort, 2375)
-  socket.emit("connect")
-  assert.equal(listenerCalled, true)
-  socket.destroy()
-  await rm(spoolDirectory, {recursive: true, force: true})
 })

package/test/unit/client/deferred-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 {DeferredVirtualSocket} from "../../../src/client/deferred-virtual-socket.js"
 import {VirtualSocket} from "../../../src/client/virtual-socket.js"
@@ -63,108 +62,110 @@ function memberConnection() {
   }
 }
 
-test("DeferredVirtualSocket write ignores non-function callback values in both parameter slots", async () => {
-  const first = deferredSocket()
-  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
-  assert.equal(first.socket.write("hello", null), true)
-  const closed = new Promise((resolve) => first.socket.once("close", resolve))
-  first.socket.destroy()
-  await closed
-  assert.equal(first.socket.destroyed, true)
-
-  const second = deferredSocket()
-  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
-  assert.equal(second.socket.write("hello", "utf8", null), true)
-  const closedAgain = new Promise((resolve) => second.socket.once("close", resolve))
-  assert.doesNotThrow(() => second.socket.destroy())
-  await closedAgain
-  assert.equal(second.socket.destroyed, true)
-})
+describe("DeferredVirtualSocket", () => {
+  it("DeferredVirtualSocket write ignores non-function callback values in both parameter slots", async () => {
+    const first = deferredSocket()
+    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+    expect(first.socket.write("hello", null)).toBe(true)
+    const closed = new Promise((resolve) => first.socket.once("close", resolve))
+    first.socket.destroy()
+    await closed
+    expect(first.socket.destroyed).toBe(true)
 
-test("DeferredVirtualSocket write budget failure destroys the socket without crashing on non-function callback values", async () => {
-  const failure = new Error("budget exhausted")
-  const {socket} = deferredSocket({reserveMemoryError: failure})
-  const error = new Promise((resolve) => socket.once("error", resolve))
-  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
-  assert.equal(socket.write("hello", "utf8", null), false)
-  assert.equal(await error, failure)
-  assert.equal(socket.destroyed, true)
-})
+    const second = deferredSocket()
+    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+    expect(second.socket.write("hello", "utf8", null)).toBe(true)
+    const closedAgain = new Promise((resolve) => second.socket.once("close", resolve))
+    await expect(() => second.socket.destroy()).not.toThrow()
+    await closedAgain
+    expect(second.socket.destroyed).toBe(true)
+  })
 
-test("DeferredVirtualSocket write budget failure invokes the completion callback with the failure", async () => {
-  const failure = new Error("budget exhausted")
-  const {reservedBytes, socket} = deferredSocket({reserveMemoryError: failure})
-  /** @type {Error | null | undefined} */
-  let callbackError
-  const error = new Promise((resolve) => socket.once("error", resolve))
-  assert.equal(socket.write("hello", "utf8", (received) => {
-    callbackError = received
-  }), false)
-  await error
-  assert.equal(callbackError, failure)
-  assert.equal(reservedBytes(), 0)
-  assert.equal(socket.destroyed, true)
-})
+  it("DeferredVirtualSocket write budget failure destroys the socket without crashing on non-function callback values", async () => {
+    const failure = new Error("budget exhausted")
+    const {socket} = deferredSocket({reserveMemoryError: failure})
+    const error = new Promise((resolve) => socket.once("error", resolve))
+    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+    expect(socket.write("hello", "utf8", null)).toBe(false)
+    expect(await error).toBe(failure)
+    expect(socket.destroyed).toBe(true)
+  })
 
-test("DeferredVirtualSocket write completion after member assignment ignores non-function callback values", async () => {
-  const {socket} = deferredSocket()
-  const member = memberConnection()
-  socket.assign(new VirtualSocket(member.connection, 1, {host: "127.0.0.1", port: 4793}), "gateway-1")
-  // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
-  assert.equal(socket.write("hello", "utf8", null), true)
-  await new Promise((resolve) => setImmediate(resolve))
-  const written = member.writes[0]
-  assert(written !== undefined)
-  assert.equal(written.toString(), "hello")
-})
+  it("DeferredVirtualSocket write budget failure invokes the completion callback with the failure", async () => {
+    const failure = new Error("budget exhausted")
+    const {reservedBytes, socket} = deferredSocket({reserveMemoryError: failure})
+    /** @type {Error | null | undefined} */
+    let callbackError
+    const error = new Promise((resolve) => socket.once("error", resolve))
+    expect(socket.write("hello", "utf8", (received) => {
+      callbackError = received
+    })).toBe(false)
+    await error
+    expect(callbackError).toBe(failure)
+    expect(reservedBytes()).toBe(0)
+    expect(socket.destroyed).toBe(true)
+  })
 
-test("DeferredVirtualSocket end ignores non-function callback values in both parameter slots", async () => {
-  const first = deferredSocket()
-  assert.doesNotThrow(() => {
+  it("DeferredVirtualSocket write completion after member assignment ignores non-function callback values", async () => {
+    const {socket} = deferredSocket()
+    const member = memberConnection()
+    socket.assign(new VirtualSocket(member.connection, 1, {host: "127.0.0.1", port: 4793}), "gateway-1")
     // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
-    first.socket.end("hello", null)
+    expect(socket.write("hello", "utf8", null)).toBe(true)
+    await new Promise((resolve) => setImmediate(resolve))
+    const written = member.writes[0]
+    expect(written).toBeDefined()
+    expect(written?.toString()).toBe("hello")
   })
-  assert.equal(first.socket.writableEnded, true)
-  const closed = new Promise((resolve) => first.socket.once("close", resolve))
-  first.socket.destroy()
-  await closed
-  assert.equal(first.socket.destroyed, true)
 
-  const second = deferredSocket()
-  assert.doesNotThrow(() => {
-    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
-    second.socket.end("hello", "utf8", null)
+  it("DeferredVirtualSocket end ignores non-function callback values in both parameter slots", async () => {
+    const first = deferredSocket()
+    await expect(() => {
+      // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+      first.socket.end("hello", null)
+    }).not.toThrow()
+    expect(first.socket.writableEnded).toBe(true)
+    const closed = new Promise((resolve) => first.socket.once("close", resolve))
+    first.socket.destroy()
+    await closed
+    expect(first.socket.destroyed).toBe(true)
+
+    const second = deferredSocket()
+    await expect(() => {
+      // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+      second.socket.end("hello", "utf8", null)
+    }).not.toThrow()
+    expect(second.socket.writableEnded).toBe(true)
+    const closedAgain = new Promise((resolve) => second.socket.once("close", resolve))
+    second.socket.destroy()
+    await closedAgain
+    expect(second.socket.destroyed).toBe(true)
   })
-  assert.equal(second.socket.writableEnded, true)
-  const closedAgain = new Promise((resolve) => second.socket.once("close", resolve))
-  second.socket.destroy()
-  await closedAgain
-  assert.equal(second.socket.destroyed, true)
-})
 
-test("DeferredVirtualSocket end does not forward non-function callback values to the stream", async () => {
-  const {socket} = deferredSocket()
-  assert.doesNotThrow(() => {
-    // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
-    socket.end("hello", "utf8", 42)
+  it("DeferredVirtualSocket end does not forward non-function callback values to the stream", async () => {
+    const {socket} = deferredSocket()
+    await expect(() => {
+      // @ts-expect-error Deliberate non-function callback value; the socket must ignore it.
+      socket.end("hello", "utf8", 42)
+    }).not.toThrow()
+    expect(socket.writableEnded).toBe(true)
+    const closed = new Promise((resolve) => socket.once("close", resolve))
+    socket.destroy()
+    await closed
   })
-  assert.equal(socket.writableEnded, true)
-  const closed = new Promise((resolve) => socket.once("close", resolve))
-  socket.destroy()
-  await closed
-})
 
-test("DeferredVirtualSocket end completion after member assignment invokes the callback on finish", async () => {
-  const {socket} = deferredSocket()
-  const member = memberConnection()
-  socket.assign(new VirtualSocket(member.connection, 1, {host: "127.0.0.1", port: 4793}), "gateway-1")
-  let finishedCallback = false
-  const finished = new Promise((resolve) => socket.once("finish", resolve))
-  socket.end("hello", "utf8", () => {
-    finishedCallback = true
+  it("DeferredVirtualSocket end completion after member assignment invokes the callback on finish", async () => {
+    const {socket} = deferredSocket()
+    const member = memberConnection()
+    socket.assign(new VirtualSocket(member.connection, 1, {host: "127.0.0.1", port: 4793}), "gateway-1")
+    let finishedCallback = false
+    const finished = new Promise((resolve) => socket.once("finish", resolve))
+    socket.end("hello", "utf8", () => {
+      finishedCallback = true
+    })
+    await finished
+    expect(finishedCallback).toBe(true)
+    expect(socket.writableFinished).toBe(true)
+    expect(member.ended()).toBe(1)
   })
-  await finished
-  assert.equal(finishedCallback, true)
-  assert.equal(socket.writableFinished, true)
-  assert.equal(member.ended(), 1)
 })