rollbridge 0.1.49 → 0.1.55

package/test/control-protocol.test.js

@@ -1,27 +1,36 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import fs from "node:fs/promises"
 import net from "node:net"
 import os from "node:os"
 import path from "node:path"
-import test, {after, before} from "node:test"
+import {afterAll, beforeAll, describe, expect, test} from "@velocious/testing"
+import {fileURLToPath} from "node:url"
 import RollbridgeDaemon from "../src/daemon.js"
 import {normalizeConfig} from "../src/config.js"
 import {sendControlCommand} from "../src/control-client.js"
 
+describe("control-protocol", () => {
+
 let root = ""
 let socketPath = ""
 let daemon = /** @type {RollbridgeDaemon | undefined} */ (undefined)
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
+const runningProcessCommand = `${JSON.stringify(process.execPath)} -e ${JSON.stringify("setInterval(() => {}, 1000)")}`
 
-before(async () => {
+beforeAll(async () => {
   root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-control-"))
   socketPath = path.join(root, "rollbridge.sock")
 
   const config = normalizeConfig({
     application: "rollbridge-control-test",
     control: {path: socketPath},
-    processes: [{command: "true", id: "web", policy: "proxied", port: {from: 0, to: 0}}],
+    processes: [
+      {command: runningProcessCommand, id: "beacon", policy: "service", port: {from: 0, to: 0}},
+      {command: `${JSON.stringify(process.execPath)} ${JSON.stringify(dummyAppPath)}`, health: {intervalMs: 50, path: "/ping", timeoutMs: 3000}, id: "web", policy: "proxied", port: {from: 0, to: 0}},
+      {command: runningProcessCommand, id: "jobs-main", policy: "singleton"}
+    ],
     proxy: {host: "127.0.0.1", port: 0}
   })
 
@@ -29,7 +38,7 @@ before(async () => {
   await daemon.start()
 })
 
-after(async () => {
+afterAll(async () => {
   if (daemon) await daemon.shutdown()
   await fs.rm(root, {force: true, recursive: true})
 })
@@ -63,32 +72,84 @@ async function sendRawControlLine(rawLine) {
 test("malformed JSON returns an error response without crashing the daemon", async () => {
   const response = await sendRawControlLine("this is not json")
 
-  assert.equal(response.status, "error")
-  assert.match(String(response.error), /JSON/)
+  expect(response.status).toBe("error")
+  expect(String(response.error)).toMatch(/JSON/)
 
   // The daemon stays up and still answers valid commands afterwards.
   const status = await sendControlCommand({command: {command: "status"}, path: socketPath})
 
-  assert.equal(status.application, "rollbridge-control-test")
+  expect(status.application).toBe("rollbridge-control-test")
 })
 
 test("non-object JSON is rejected as an invalid control command", async () => {
   const response = await sendRawControlLine("123")
 
-  assert.equal(response.status, "error")
-  assert.equal(response.error, "Control command must be an object")
+  expect(response.status).toBe("error")
+  expect(response.error).toBe("Control command must be an object")
 })
 
 test("an unknown control command returns a clear error", async () => {
   const response = await sendRawControlLine(JSON.stringify({command: "bogus"}))
 
-  assert.equal(response.status, "error")
-  assert.equal(response.error, "Unknown command: bogus")
+  expect(response.status).toBe("error")
+  expect(response.error).toBe("Unknown command: bogus")
 })
 
 test("a known command missing a required field returns a field error", async () => {
   const response = await sendRawControlLine(JSON.stringify({command: "deploy"}))
 
-  assert.equal(response.status, "error")
-  assert.equal(response.error, "releasePath is required")
+  expect(response.status).toBe("error")
+  expect(response.error).toBe("releasePath is required")
+})
+test("status can omit process logs without changing the default status payload", async () => {
+  if (!daemon) throw new Error("Missing required fixture: daemon")
+  await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
+
+  const full = /** @type {import("../src/daemon.js").DaemonStatus} */ (await sendControlCommand({command: {command: "status"}, path: socketPath}))
+  const compact = /** @type {import("../src/daemon.js").DaemonStatusWithoutLogs} */ (await sendControlCommand({command: {command: "status", includeLogs: false}, path: socketPath}))
+  const invalid = await sendRawControlLine(JSON.stringify({command: "status", includeLogs: "false"}))
+
+  expect(full.releases[0]?.processes.every((processStatus) => Array.isArray(processStatus.logs))).toBeTruthy()
+  expect(full.services.every(({process: processStatus}) => Array.isArray(processStatus.logs))).toBeTruthy()
+  expect(full.singletons.every(({process: processStatus}) => Array.isArray(processStatus.logs))).toBeTruthy()
+  expect(statusWithoutProcessUptimes(compact)).toEqual(statusWithoutProcessUptimes({
+    ...full,
+    releases: full.releases.map((release) => ({
+      ...release,
+      processes: release.processes.map(({logs: _logs, ...processStatus}) => processStatus)
+    })),
+    services: full.services.map(({process, ...service}) => ({
+      ...service,
+      process: (({logs: _logs, ...processStatus}) => processStatus)(process)
+    })),
+    singletons: full.singletons.map(({process, ...singleton}) => ({
+      ...singleton,
+      process: (({logs: _logs, ...processStatus}) => processStatus)(process)
+    }))
+  }))
+  expect(invalid.status).toBe("error")
+  expect(invalid.error).toBe("includeLogs must be a boolean")
+})
+
+/**
+ * @param {import("../src/daemon.js").DaemonStatus | import("../src/daemon.js").DaemonStatusWithoutLogs} status - Status response.
+ * @returns {Record<string, import("../src/json.js").JsonValue>} Status without volatile process uptime.
+ */
+function statusWithoutProcessUptimes(status) {
+  return {
+    ...status,
+    releases: status.releases.map((release) => ({
+      ...release,
+      processes: release.processes.map(({uptimeMs: _uptimeMs, ...processStatus}) => processStatus)
+    })),
+    services: status.services.map(({process, ...service}) => ({
+      ...service,
+      process: (({uptimeMs: _uptimeMs, ...processStatus}) => processStatus)(process)
+    })),
+    singletons: status.singletons.map(({process, ...singleton}) => ({
+      ...singleton,
+      process: (({uptimeMs: _uptimeMs, ...processStatus}) => processStatus)(process)
+    }))
+  }
+}
 })

package/test/daemon-bootstrap.test.js

@@ -1,17 +1,18 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import {spawn} from "node:child_process"
 import {once} from "node:events"
 import fs from "node:fs/promises"
 import net from "node:net"
 import os from "node:os"
 import path from "node:path"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import {fileURLToPath} from "node:url"
 import {sendControlCommand} from "../src/control-client.js"
 import {isProcessAlive, liveProcesses, readState, writeState} from "../src/state-store.js"
 
+describe("daemon-bootstrap", () => {
+
 const currentDir = path.dirname(fileURLToPath(import.meta.url))
 const binPath = path.join(currentDir, "..", "bin", "rollbridge")
 const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
@@ -21,43 +22,39 @@ const secondAttestation = `sha256:${"b".repeat(64)}`
 
 /** @typedef {{data?: Record<string, import("../src/json.js").JsonValue>, message?: string}} StructuredRecord */
 
-test("daemon bootstrap requires complete, safe, absolute inputs before binding listeners", async (t) => {
-  const cases = [
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1"], message: /must be provided together/},
-    {args: ["--config", "relative/config.js", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123"], message: /--config must be an absolute path/},
-    {args: ["--config", "CONFIG", "--release-path", "relative/release", "--release-id", "v1", "--revision", "abc123"], message: /--release-path must be an absolute path/},
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE_UNNORMALIZED", "--release-id", "v1", "--revision", "abc123"], message: /--release-path must be normalized/},
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE_MISSING", "--release-id", "v1", "--revision", "abc123"], message: /--release-path is not accessible/},
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "unsafe id", "--revision", "abc123"], message: /--release-id/},
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "unsafe revision"], message: /--revision/},
-    {args: ["--config", "CONFIG", "--boot-attestation", firstAttestation], message: /accepted only with/},
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123", "--boot-attestation", `sha256:${"A".repeat(64)}`], message: /--boot-attestation/},
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123", "--boot-attestation", `sha512:${"a".repeat(64)}`], message: /--boot-attestation/},
-    {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123", "--boot-attestation", `sha256:${"a".repeat(63)}`], message: /--boot-attestation/}
-  ]
-
-  for (const testCase of cases) {
-    await t.test(testCase.message.source, async () => {
-      const fixture = await createFixture()
-      const args = testCase.args.map((arg) => {
-        if (arg === "CONFIG") return fixture.configPath
-        if (arg === "RELEASE") return fixture.root
-        if (arg === "RELEASE_UNNORMALIZED") return `${fixture.root}/child/..`
-        if (arg === "RELEASE_MISSING") return path.join(fixture.root, "missing")
-        return arg
-      })
-
-      try {
-        const result = await runDaemon(args)
-
-        assert.notEqual(result.code, 0)
-        assert.match(result.stderr, testCase.message)
-        await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
-        await assert.rejects(() => fs.stat(fixture.startedPath), {code: "ENOENT"})
-      } finally {
-        await fs.rm(fixture.root, {force: true, recursive: true})
-      }
-    })
+const invalidBootstrapCases = [
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1"], message: /must be provided together/},
+  {args: ["--config", "relative/config.js", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123"], message: /--config must be an absolute path/},
+  {args: ["--config", "CONFIG", "--release-path", "relative/release", "--release-id", "v1", "--revision", "abc123"], message: /--release-path must be an absolute path/},
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE_UNNORMALIZED", "--release-id", "v1", "--revision", "abc123"], message: /--release-path must be normalized/},
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE_MISSING", "--release-id", "v1", "--revision", "abc123"], message: /--release-path is not accessible/},
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "unsafe id", "--revision", "abc123"], message: /--release-id/},
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "unsafe revision"], message: /--revision/},
+  {args: ["--config", "CONFIG", "--boot-attestation", firstAttestation], message: /accepted only with/},
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123", "--boot-attestation", `sha256:${"A".repeat(64)}`], message: /--boot-attestation/},
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123", "--boot-attestation", `sha512:${"a".repeat(64)}`], message: /--boot-attestation/},
+  {args: ["--config", "CONFIG", "--release-path", "RELEASE", "--release-id", "v1", "--revision", "abc123", "--boot-attestation", `sha256:${"a".repeat(63)}`], message: /--boot-attestation/}
+]
+
+test.each(invalidBootstrapCases)("daemon bootstrap rejects invalid startup arguments (%#)", async (/** @type {{args: string[], message: RegExp}} */ testCase) => {
+  const fixture = await createFixture()
+  const args = testCase.args.map((arg) => {
+    if (arg === "CONFIG") return fixture.configPath
+    if (arg === "RELEASE") return fixture.root
+    if (arg === "RELEASE_UNNORMALIZED") return `${fixture.root}/child/..`
+    if (arg === "RELEASE_MISSING") return path.join(fixture.root, "missing")
+    return arg
+  })
+
+  try {
+    const result = await runDaemon(args)
+
+    expect(result.code).not.toBe(0)
+    expect(result.stderr).toMatch(testCase.message)
+    await expect(fs.stat(fixture.socketPath)).rejects.toMatchObject({code: "ENOENT"})
+    await expect(fs.stat(fixture.startedPath)).rejects.toMatchObject({code: "ENOENT"})
+  } finally {
+    await fs.rm(fixture.root, {force: true, recursive: true})
   }
 })
 
@@ -70,19 +67,19 @@ test("daemon bootstrap activates the exact release through the foreground daemon
     const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
     const activeRelease = assertRelease(status, "release-42")
 
-    assert.equal(activeRelease.releasePath, fixture.root)
-    assert.equal(activeRelease.revision, "abc123")
-    assert.deepEqual(status.bootstrap, {
+    expect(activeRelease.releasePath).toBe(fixture.root)
+    expect(activeRelease.revision).toBe("abc123")
+    expect(status.bootstrap).toEqual({
       attestation: firstAttestation,
       releaseId: "release-42",
       releasePath: fixture.root,
       revision: "abc123"
     })
-    assert.ok(status.proxy && typeof status.proxy === "object" && !Array.isArray(status.proxy) && typeof status.proxy.port === "number")
-    assert.equal((await fetch(`http://127.0.0.1:${status.proxy.port}/release`).then((response) => response.text())).trim(), "release-42")
+    if (!(status.proxy && typeof status.proxy === "object" && !Array.isArray(status.proxy) && typeof status.proxy.port === "number")) throw new Error("Expected proxy status with a numeric port")
+    expect((await fetch(`http://127.0.0.1:${status.proxy.port}/release`).then((response) => response.text())).trim()).toBe("release-42")
 
     child.kill("SIGTERM")
-    assert.equal((await once(child, "exit"))[0], 0)
+    expect((await once(child, "exit"))[0]).toBe(0)
   } finally {
     if (child.exitCode === null) child.kill("SIGKILL")
     await fs.rm(fixture.root, {force: true, recursive: true})
@@ -110,21 +107,23 @@ test("failed takeover bootstrap preserves the previously accepted owner", async
       "--takeover-owner"
     ])
 
-    assert.notEqual(result.code, 0)
+    expect(result.code).not.toBe(0)
     const records = parseStructuredOutput(result.output)
     const failure = records.find((record) => record.message === "bootstrap activation failed")
     const candidatePid = Number(await fs.readFile(fixture.startedPath, "utf8"))
 
-    assert.match(String(failure?.data?.error), /Health check failed/)
-    assert.match(String(failure?.data?.stack), /Error: Health check failed/)
-    assert.equal(isProcessAlive(candidatePid), false, "the failed candidate process must be stopped")
+    expect(String(failure?.data?.error)).toMatch(/Health check failed/)
+    expect(String(failure?.data?.stack)).toMatch(/Error: Health check failed/)
+    // The failed candidate process must be stopped.
+    expect(isProcessAlive(candidatePid)).toBe(false)
     const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
-    assert.equal(status.activeReleaseId, "accepted")
-    assert.ok(status.bootstrap && typeof status.bootstrap === "object" && !Array.isArray(status.bootstrap))
-    assert.equal(status.bootstrap.attestation, firstAttestation)
+    expect(status.activeReleaseId).toBe("accepted")
+    if (!(status.bootstrap && typeof status.bootstrap === "object" && !Array.isArray(status.bootstrap))) throw new Error("Expected bootstrap status")
+    expect(status.bootstrap.attestation).toBe(firstAttestation)
     const priorState = await readState(fixture.statePath)
 
-    assert.ok(priorState && typeof priorState === "object" && !Array.isArray(priorState) && priorState.activeReleaseId === "accepted", "candidate cleanup must preserve the prior owner's state")
+    // Candidate cleanup must preserve the prior owner's state.
+    expect(priorState && typeof priorState === "object" && !Array.isArray(priorState) && priorState.activeReleaseId === "accepted").toBeTruthy()
   } finally {
     accepted.kill("SIGTERM")
     if (accepted.exitCode === null) await once(accepted, "exit")
@@ -139,20 +138,20 @@ test("daemon bootstrap does not expose control deploys until activation complete
 
   try {
     await started
-    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+    await expect(fs.stat(fixture.socketPath)).rejects.toMatchObject({code: "ENOENT"})
 
     await fs.writeFile(fixture.healthGatePath, "ready\n")
     await waitForLog(child, "control socket listening")
 
     const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
 
-    assert.equal(status.activeReleaseId, "bootstrap-release")
-    assert.ok(Array.isArray(status.releases))
-    assert.equal(status.releases.length, 1)
+    expect(status.activeReleaseId).toBe("bootstrap-release")
+    if (!Array.isArray(status.releases)) throw new Error("Expected release statuses")
+    expect(status.releases.length).toBe(1)
     assertRelease(status, "bootstrap-release")
 
     child.kill("SIGTERM")
-    assert.equal((await once(child, "exit"))[0], 0)
+    expect((await once(child, "exit"))[0]).toBe(0)
   } finally {
     if (child.exitCode === null) child.kill("SIGKILL")
     await fs.rm(fixture.root, {force: true, recursive: true})
@@ -167,12 +166,12 @@ test("plain daemon startup remains listener-only with no active release", async
     await waitForLog(child, "control socket listening")
     const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
 
-    assert.equal(status.activeReleaseId, null)
-    assert.deepEqual(status.releases, [])
-    assert.equal(status.bootstrap, undefined)
+    expect(status.activeReleaseId).toBe(null)
+    expect(status.releases).toEqual([])
+    expect(status.bootstrap).toBe(undefined)
 
     child.kill("SIGTERM")
-    assert.equal((await once(child, "exit"))[0], 0)
+    expect((await once(child, "exit"))[0]).toBe(0)
   } finally {
     if (child.exitCode === null) child.kill("SIGKILL")
     await fs.rm(fixture.root, {force: true, recursive: true})
@@ -185,10 +184,10 @@ test("ensure-daemon rejects boot attestation instead of inheriting foreground id
   try {
     const result = await runRollbridge(["ensure-daemon", "--config", fixture.configPath, "--boot-attestation", firstAttestation])
 
-    assert.notEqual(result.code, 0)
-    assert.match(result.stderr, /unknown option '--boot-attestation'/)
-    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
-    await assert.rejects(() => fs.stat(fixture.startedPath), {code: "ENOENT"})
+    expect(result.code).not.toBe(0)
+    expect(result.stderr).toMatch(/unknown option '--boot-attestation'/)
+    await expect(fs.stat(fixture.socketPath)).rejects.toMatchObject({code: "ENOENT"})
+    await expect(fs.stat(fixture.startedPath)).rejects.toMatchObject({code: "ENOENT"})
   } finally {
     await fs.rm(fixture.root, {force: true, recursive: true})
   }
@@ -206,15 +205,15 @@ test("otherwise identical foreground boots remain distinguishable by attestation
       await waitForLog(child, "control socket listening")
       const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
 
-      assert.equal(status.activeReleaseId, "same-release")
-      assert.ok(status.bootstrap && typeof status.bootstrap === "object" && !Array.isArray(status.bootstrap))
+      expect(status.activeReleaseId).toBe("same-release")
+      if (!(status.bootstrap && typeof status.bootstrap === "object" && !Array.isArray(status.bootstrap))) throw new Error("Expected bootstrap status")
       attestations.push(status.bootstrap.attestation)
 
       child.kill("SIGTERM")
-      assert.equal((await once(child, "exit"))[0], 0)
+      expect((await once(child, "exit"))[0]).toBe(0)
     }
 
-    assert.deepEqual(attestations, [firstAttestation, secondAttestation])
+    expect(attestations).toEqual([firstAttestation, secondAttestation])
   } finally {
     await fs.rm(fixture.root, {force: true, recursive: true})
   }
@@ -231,10 +230,10 @@ test("SIGTERM during bootstrap activation follows the daemon shutdown path", asy
 
     const [code, signal] = await once(child, "exit")
 
-    assert.equal(code, 0)
-    assert.equal(signal, null)
-    assert.equal(await fs.readFile(fixture.stoppedPath, "utf8"), String(managedPid))
-    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+    expect(code).toBe(0)
+    expect(signal).toBe(null)
+    expect(await fs.readFile(fixture.stoppedPath, "utf8")).toBe(String(managedPid))
+    await expect(fs.stat(fixture.socketPath)).rejects.toMatchObject({code: "ENOENT"})
   } finally {
     if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL")
     await fs.rm(fixture.root, {force: true, recursive: true})
@@ -259,12 +258,12 @@ test("SIGTERM during multi-process bootstrap owns every process started after sh
     const records = output.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line))
     const recordedPids = new Set(records.filter((record) => record.message === "process started").map((record) => record.data?.pid))
 
-    assert.equal(code, 0)
-    assert.equal(signal, null)
-    assert.notEqual(shutdownIndex, -1)
-    assert.ok(startedAfterShutdown.length > 0, `fixture must start a later bootstrap process after triggering shutdown: ${JSON.stringify(events)}`)
-    assert.deepEqual(startedAfterShutdown.filter((event) => !recordedPids.has(event.pid)), [])
-    for (const event of startedAfterShutdown) assert.equal(isProcessAlive(event.pid), false, `expected process ${event.pid} to be stopped before daemon exit`)
+    expect(code).toBe(0)
+    expect(signal).toBe(null)
+    expect(shutdownIndex).not.toBe(-1)
+    expect({value: Boolean(startedAfterShutdown.length > 0), context: `fixture must start a later bootstrap process after triggering shutdown: ${JSON.stringify(events)}`}).toMatchObject({value: true})
+    expect(startedAfterShutdown.filter((event) => !recordedPids.has(event.pid))).toEqual([])
+    for (const event of startedAfterShutdown) expect({value: isProcessAlive(event.pid), context: `expected process ${event.pid} to be stopped before daemon exit`}).toMatchObject({value: false})
   } finally {
     if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL")
 
@@ -295,13 +294,13 @@ test("failed ordinary bootstrap completely shuts down attempt-owned resources an
     const records = parseStructuredOutput(result.output)
     const failure = records.find((record) => record.message === "bootstrap activation failed")
 
-    assert.notEqual(result.code, 0)
-    assert.equal(failure?.data?.releaseId, "ordinary-failure")
-    assert.equal(failure?.data?.status, "error")
-    assert.match(String(failure?.data?.error), /listen (?:EACCES|ENOENT)/)
-    assert.match(String(failure?.data?.stack), /Error: listen (?:EACCES|ENOENT)/)
+    expect(result.code).not.toBe(0)
+    expect(failure?.data?.releaseId).toBe("ordinary-failure")
+    expect(failure?.data?.status).toBe("error")
+    expect(String(failure?.data?.error)).toMatch(/listen (?:EACCES|ENOENT)/)
+    expect(String(failure?.data?.stack)).toMatch(/Error: listen (?:EACCES|ENOENT)/)
     await assertAttemptResourcesStopped(fixture, records)
-    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+    await expect(fs.stat(fixture.socketPath)).rejects.toMatchObject({code: "ENOENT"})
   } finally {
     await killAttemptProcesses(fixture.lifecyclePath)
     await fs.rm(fixture.root, {force: true, recursive: true})
@@ -323,13 +322,13 @@ test("failed takeover retirement completely shuts down and exits non-zero instea
     const records = parseStructuredOutput(result.output)
     const failure = records.find((record) => record.message === "bootstrap activation failed")
 
-    assert.notEqual(result.code, 0)
-    assert.equal(failure?.data?.releaseId, "orphaned-candidate")
-    assert.equal(failure?.data?.status, "error")
-    assert.match(String(failure?.data?.error), /connect ENOENT/)
-    assert.match(String(failure?.data?.stack), /Error: connect ENOENT/)
+    expect(result.code).not.toBe(0)
+    expect(failure?.data?.releaseId).toBe("orphaned-candidate")
+    expect(failure?.data?.status).toBe("error")
+    expect(String(failure?.data?.error)).toMatch(/connect ENOENT/)
+    expect(String(failure?.data?.stack)).toMatch(/Error: connect ENOENT/)
     await assertAttemptResourcesStopped(fixture, records)
-    await assert.rejects(() => fs.stat(fixture.socketPath), {code: "ENOENT"})
+    await expect(fs.stat(fixture.socketPath)).rejects.toMatchObject({code: "ENOENT"})
   } finally {
     await killAttemptProcesses(fixture.lifecyclePath)
     await fs.rm(fixture.root, {force: true, recursive: true})
@@ -354,13 +353,13 @@ test("daemon bootstrap reports but does not kill a live process from statePath",
     await waitForLog(child, "control socket listening")
     const status = await sendControlCommand({command: {command: "status"}, path: fixture.socketPath})
 
-    assert.ok(leftover.pid !== undefined && isProcessAlive(leftover.pid))
-    assert.deepEqual(status.orphans, [{id: "worker", pid: leftover.pid, releaseId: "previous"}])
+    expect(leftover.pid !== undefined && isProcessAlive(leftover.pid)).toBeTruthy()
+    expect(status.orphans).toEqual([{id: "worker", pid: leftover.pid, releaseId: "previous"}])
 
     child.kill("SIGTERM")
     await once(child, "exit")
 
-    assert.deepEqual(liveProcesses(await readState(fixture.statePath)), [{id: "worker", pid: leftover.pid, releaseId: "previous"}])
+    expect(liveProcesses(await readState(fixture.statePath))).toEqual([{id: "worker", pid: leftover.pid, releaseId: "previous"}])
   } finally {
     if (child.exitCode === null) child.kill("SIGKILL")
     leftover.kill("SIGKILL")
@@ -388,8 +387,8 @@ test("failed daemon bootstrap preserves prior live process records in statePath"
       "--revision", "bad123"
     ])
 
-    assert.notEqual(result.code, 0)
-    assert.deepEqual(liveProcesses(await readState(fixture.statePath)), [{id: "worker", pid: leftover.pid, releaseId: "previous"}])
+    expect(result.code).not.toBe(0)
+    expect(liveProcesses(await readState(fixture.statePath))).toEqual([{id: "worker", pid: leftover.pid, releaseId: "previous"}])
   } finally {
     leftover.kill("SIGKILL")
     await fs.rm(fixture.root, {force: true, recursive: true})
@@ -444,7 +443,7 @@ async function createFixture({attemptOwnedProcesses = false, fixedPorts = false,
     const fifo = spawn("mkfifo", [gatePath])
     const [code] = await once(fifo, "exit")
 
-    assert.equal(code, 0)
+    expect(code).toBe(0)
   }
 
   await fs.writeFile(configPath, `${setup}module.exports = ${JSON.stringify(config, null, 2)}\n`)
@@ -578,11 +577,11 @@ async function assertAttemptResourcesStopped(fixture, records) {
   const managedStarts = new Set(records.filter((record) => record.message === "process started").map((record) => record.data?.processId))
   const managedExits = new Set(records.filter((record) => record.message === "process exited").map((record) => record.data?.processId))
 
-  assert.deepEqual(managedStarts, expectedProcessIds)
-  assert.deepEqual(managedExits, expectedProcessIds)
+  expect(managedStarts).toEqual(expectedProcessIds)
+  expect(managedExits).toEqual(expectedProcessIds)
   for (const event of started) {
-    assert.equal(stoppedPids.has(event.pid), true, `${event.processId} must receive graceful shutdown`)
-    assert.equal(isProcessAlive(Number(event.pid)), false, `${event.processId} pid ${event.pid} must be gone before daemon exit`)
+    expect({value: stoppedPids.has(event.pid), context: `${event.processId} must receive graceful shutdown`}).toMatchObject({value: true})
+    expect({value: isProcessAlive(Number(event.pid)), context: `${event.processId} pid ${event.pid} must be gone before daemon exit`}).toMatchObject({value: false})
   }
 
   await assertPortAvailable(fixture.processPort)
@@ -674,9 +673,10 @@ async function waitForLog(child, message) {
  * @returns {Record<string, import("../src/json.js").JsonValue>} Matching release status.
  */
 function assertRelease(status, releaseId) {
-  assert.ok(Array.isArray(status.releases))
+  if (!Array.isArray(status.releases)) throw new Error("Expected release statuses")
   const release = status.releases.find((candidate) => candidate && typeof candidate === "object" && "releaseId" in candidate && candidate.releaseId === releaseId)
 
-  assert.ok(release && typeof release === "object" && !Array.isArray(release))
+  if (!(release && typeof release === "object" && !Array.isArray(release))) throw new Error(`Release ${releaseId} should be present`)
   return release
 }
+})

package/test/daemon-runtime.test.js

@@ -1,12 +1,15 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import {prepareDaemonRuntime} from "../src/daemon-runtime.js"
 
+describe("daemon-runtime", () => {
+
+const posixPermissionsTest = process.platform === "win32" ? test.skip : test
+
 test("concurrent runtime preparation converges on one validated content-addressed snapshot", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-concurrent-"))
 
@@ -17,13 +20,13 @@ test("concurrent runtime preparation converges on one validated content-addresse
       prepareDaemonRuntime(root)
     ])
 
-    assert.deepEqual(identities, [identities[0], identities[0], identities[0]])
-    assert.match(identities[0].digest, /^[a-f0-9]{64}$/)
-    assert.equal(path.dirname(identities[0].path), root)
-    assert.equal(JSON.parse(await fs.readFile(path.join(identities[0].path, "runtime.json"), "utf8")).digest, identities[0].digest)
+    expect(identities).toEqual([identities[0], identities[0], identities[0]])
+    expect(identities[0].digest).toMatch(/^[a-f0-9]{64}$/)
+    expect(path.dirname(identities[0].path)).toBe(root)
+    expect(JSON.parse(await fs.readFile(path.join(identities[0].path, "runtime.json"), "utf8")).digest).toBe(identities[0].digest)
 
     const entries = (await fs.readdir(root)).filter((entry) => entry.startsWith(".prepare-"))
-    assert.deepEqual(entries, [])
+    expect(entries).toEqual([])
   } finally {
     await fs.rm(root, {force: true, recursive: true})
   }
@@ -36,13 +39,13 @@ test("preparation fails closed when an existing content-addressed snapshot is co
     const identity = await prepareDaemonRuntime(root)
 
     await fs.writeFile(path.join(identity.path, "src", "daemon.js"), "corrupt\n")
-    await assert.rejects(() => prepareDaemonRuntime(root), /runtime validation failed/)
+    await expect(prepareDaemonRuntime(root)).rejects.toThrow(/runtime validation failed/)
   } finally {
     await fs.rm(root, {force: true, recursive: true})
   }
 })
 
-test("runtime preparation rejects a symlinked or shared-writable parent", async (t) => {
+posixPermissionsTest("runtime preparation rejects a symlinked or shared-writable parent", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-permissions-"))
   const target = path.join(root, "target")
   const symlink = path.join(root, "symlink")
@@ -51,27 +54,17 @@ test("runtime preparation rejects a symlinked or shared-writable parent", async
   try {
     await fs.mkdir(target)
     await fs.symlink(target, symlink, "dir")
-    await assert.rejects(() => prepareDaemonRuntime(symlink), /must be a real directory/)
-
-    if (process.platform === "win32") {
-      t.skip("POSIX directory permissions are not available on Windows")
-      return
-    }
+    await expect(prepareDaemonRuntime(symlink)).rejects.toThrow(/must be a real directory/)
 
     await fs.mkdir(shared, {mode: 0o777})
     await fs.chmod(shared, 0o777)
-    await assert.rejects(() => prepareDaemonRuntime(shared), /must not be writable by group or other users/)
+    await expect(prepareDaemonRuntime(shared)).rejects.toThrow(/must not be writable by group or other users/)
   } finally {
     await fs.rm(root, {force: true, recursive: true})
   }
 })
 
-test("runtime preparation rejects a private leaf beneath a replaceable ancestor", async (t) => {
-  if (process.platform === "win32") {
-    t.skip("POSIX directory permissions are not available on Windows")
-    return
-  }
-
+posixPermissionsTest("runtime preparation rejects a private leaf beneath a replaceable ancestor", async () => {
   const unsafeAncestor = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-runtime-unsafe-ancestor-"))
   const privateLeaf = path.join(unsafeAncestor, "private-runtime")
 
@@ -79,12 +72,10 @@ test("runtime preparation rejects a private leaf beneath a replaceable ancestor"
     await fs.chmod(unsafeAncestor, 0o777)
     await fs.mkdir(privateLeaf, {mode: 0o700})
 
-    await assert.rejects(
-      () => prepareDaemonRuntime(privateLeaf),
-      /ancestor must be sticky or not writable by group or other users/
-    )
+    await expect(prepareDaemonRuntime(privateLeaf)).rejects.toThrow(/ancestor must be sticky or not writable by group or other users/)
   } finally {
     await fs.chmod(unsafeAncestor, 0o700)
     await fs.rm(unsafeAncestor, {force: true, recursive: true})
   }
 })
+})