rollbridge 0.1.49 → 0.1.55

package/test/package-metadata.test.js

@@ -1,68 +1,77 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import {execFile} from "node:child_process"
 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 {fileURLToPath} from "node:url"
 import {promisify} from "node:util"
 
+describe("package-metadata", () => {
+
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const execFileAsync = promisify(execFile)
 
 test("package.json declares publish metadata", async () => {
   const pkg = JSON.parse(await fs.readFile(path.join(repoRoot, "package.json"), "utf8"))
 
-  assert.equal(pkg.name, "rollbridge")
-  assert.equal(pkg.license, "MIT")
-  assert.equal(pkg.homepage, "https://github.com/kaspernj/rollbridge#readme")
-  assert.equal(pkg.bugs.url, "https://github.com/kaspernj/rollbridge/issues")
-  assert.equal(pkg.repository.type, "git")
-  assert.match(pkg.repository.url, /github\.com\/kaspernj\/rollbridge/)
-  assert.ok(typeof pkg.author === "string" && pkg.author.length > 0)
-  assert.ok(Array.isArray(pkg.keywords) && pkg.keywords.length > 0)
+  expect(pkg.name).toBe("rollbridge")
+  expect(pkg.license).toBe("MIT")
+  expect(pkg.homepage).toBe("https://github.com/kaspernj/rollbridge#readme")
+  expect(pkg.bugs.url).toBe("https://github.com/kaspernj/rollbridge/issues")
+  expect(pkg.repository.type).toBe("git")
+  expect(pkg.repository.url).toMatch(/github\.com\/kaspernj\/rollbridge/)
+  expect(typeof pkg.author === "string" && pkg.author.length > 0).toBeTruthy()
+  expect(Array.isArray(pkg.keywords) && pkg.keywords.length > 0).toBeTruthy()
 })
 
 test("a LICENSE file matching the declared license exists", async () => {
   const license = await fs.readFile(path.join(repoRoot, "LICENSE"), "utf8")
 
-  assert.match(license, /MIT License/)
-  assert.match(license, /Copyright \(c\) \d{4} kaspernj/)
+  expect(license).toMatch(/MIT License/)
+  expect(license).toMatch(/Copyright \(c\) \d{4} kaspernj/)
 })
 
-test("package manifest excludes unexpected operational and coverage files", async (t) => {
+test("package manifest excludes unexpected operational and coverage files", async () => {
   const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-pack-"))
-  t.after(() => fs.rm(fixtureRoot, {force: true, recursive: true}))
 
-  await fs.cp(repoRoot, fixtureRoot, {
-    filter: (source) => {
-      const relative = path.relative(repoRoot, source)
-      return relative !== ".git" && relative !== "node_modules" && relative !== "tmp"
-    },
-    recursive: true,
-  })
+  try {
+    await fs.cp(repoRoot, fixtureRoot, {
+      filter: (source) => {
+        const relative = path.relative(repoRoot, source)
+        return relative !== ".git" && relative !== "node_modules" && relative !== "tmp"
+      },
+      recursive: true,
+    })
+
+    const unexpectedTmpPath = path.join(fixtureRoot, "tmp", "worker-control", "unexpected-transcript.jsonl")
+    const unexpectedCoveragePath = path.join(fixtureRoot, "coverage", "unexpected.txt")
+    await Promise.all([
+      fs.mkdir(path.dirname(unexpectedTmpPath), {recursive: true}),
+      fs.mkdir(path.dirname(unexpectedCoveragePath), {recursive: true}),
+    ])
+    await Promise.all([
+      fs.writeFile(unexpectedTmpPath, '{"operational":"state"}\n'),
+      fs.writeFile(unexpectedCoveragePath, "unexpected coverage output\n"),
+    ])
 
-  const unexpectedTmpPath = path.join(fixtureRoot, "tmp", "worker-control", "unexpected-transcript.jsonl")
-  const unexpectedCoveragePath = path.join(fixtureRoot, "coverage", "unexpected.txt")
-  await Promise.all([
-    fs.mkdir(path.dirname(unexpectedTmpPath), {recursive: true}),
-    fs.mkdir(path.dirname(unexpectedCoveragePath), {recursive: true}),
-  ])
-  await Promise.all([
-    fs.writeFile(unexpectedTmpPath, '{"operational":"state"}\n'),
-    fs.writeFile(unexpectedCoveragePath, "unexpected coverage output\n"),
-  ])
+    const {stdout} = await execFileAsync("npm", ["pack", "--dry-run", "--json"], {cwd: fixtureRoot})
+    const packageOutput = JSON.parse(stdout)
+    const packageArchive = Array.isArray(packageOutput) ? packageOutput[0] : Object.values(packageOutput)[0]
 
-  const {stdout} = await execFileAsync("npm", ["pack", "--dry-run", "--json"], {cwd: fixtureRoot})
-  /** @type {Array<{path: string}>} */
-  const packageFiles = JSON.parse(stdout)[0].files
-  const packagePaths = packageFiles.map((file) => file.path)
+    if (!(packageArchive && Array.isArray(packageArchive.files))) throw new Error("Expected package archive file list")
+    /** @type {Array<{path: string}>} */
+    const packageFiles = packageArchive.files
+    const packagePaths = packageFiles.map((file) => file.path)
 
-  for (const requiredPath of ["LICENSE", "README.md", "bin/rollbridge", "package.json", "src/cli.js", "src/daemon-runtime.js"]) {
-    assert.ok(packagePaths.includes(requiredPath), `expected package to include ${requiredPath}`)
+    for (const requiredPath of ["LICENSE", "README.md", "bin/rollbridge", "package.json", "src/cli.js", "src/daemon-runtime.js"]) {
+      expect({value: Boolean(packagePaths.includes(requiredPath)), context: `expected package to include ${requiredPath}`}).toMatchObject({value: true})
+    }
+    expect(!packagePaths.some((packagePath) => packagePath === "tmp" || packagePath.startsWith("tmp/"))).toBeTruthy()
+    expect(!packagePaths.some((packagePath) => packagePath === "coverage" || packagePath.startsWith("coverage/"))).toBeTruthy()
+  } finally {
+    await fs.rm(fixtureRoot, {force: true, recursive: true})
   }
-  assert.ok(!packagePaths.some((packagePath) => packagePath === "tmp" || packagePath.startsWith("tmp/")))
-  assert.ok(!packagePaths.some((packagePath) => packagePath === "coverage" || packagePath.startsWith("coverage/")))
+})
 })

package/test/port-allocator.test.js

@@ -1,10 +1,11 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import net from "node:net"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import {findAvailablePort} from "../src/port-allocator.js"
 
+describe("port-allocator", () => {
+
 const host = "127.0.0.1"
 
 /**
@@ -40,18 +41,13 @@ test("findAvailablePort reports reserved and in-use counts when a range is exhau
   const range = {from: reservedPort, to: port}
 
   try {
-    await assert.rejects(
-      () => findAvailablePort({host, range, usedPorts: new Set([reservedPort])}),
-      (error) => {
-        assert.ok(error instanceof Error)
-        assert.match(error.message, new RegExp(`No available ports in range ${reservedPort}-${port}`))
-        assert.match(error.message, /2 ports on 127\.0\.0\.1/)
-        assert.match(error.message, /1 reserved by this deploy/)
-        assert.match(error.message, /1 already in use/)
+    const allocation = findAvailablePort({host, range, usedPorts: new Set([reservedPort])})
 
-        return true
-      }
-    )
+    await expect(allocation).rejects.toBeInstanceOf(Error)
+    await expect(allocation).rejects.toMatchObject({message: expect.stringMatching(new RegExp(`No available ports in range ${reservedPort}-${port}`))})
+    await expect(allocation).rejects.toMatchObject({message: expect.stringMatching(/2 ports on 127\.0\.0\.1/)})
+    await expect(allocation).rejects.toMatchObject({message: expect.stringMatching(/1 reserved by this deploy/)})
+    await expect(allocation).rejects.toMatchObject({message: expect.stringMatching(/1 already in use/)})
   } finally {
     await closeServer(server)
   }
@@ -67,10 +63,11 @@ test("findAvailablePort skips the occupied port and records the allocated one",
   try {
     const allocated = await findAvailablePort({host, range: {from, to}, usedPorts})
 
-    assert.notEqual(allocated, port)
-    assert.ok(allocated >= from && allocated <= to)
-    assert.ok(usedPorts.has(allocated))
+    expect(allocated).not.toBe(port)
+    expect(allocated >= from && allocated <= to).toBeTruthy()
+    expect(usedPorts.has(allocated)).toBeTruthy()
   } finally {
     await closeServer(server)
   }
 })
+})

package/test/predeploy-cleanup.test.js

@@ -1,16 +1,17 @@
 // @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 os from "node:os"
 import path from "node:path"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import {normalizeConfig} from "../src/config.js"
 import {isProcessAlive} from "../src/state-store.js"
 import {predeployCleanup} from "../src/predeploy-cleanup.js"
 
+describe("predeploy-cleanup", () => {
+
 /**
  * @param {string} dir - Working directory.
  * @param {string} marker - Unique process marker.
@@ -39,11 +40,11 @@ test("predeploy cleanup stops configured legacy process when no daemon is active
   try {
     const result = await predeployCleanup({config: buildConfig(dir, marker)})
 
-    assert.equal(result.action, "no-daemon-cleaned")
-    assert.equal(result.recoveredOrphans, 0)
-    assert.equal(result.legacyProcesses.length, 1)
-    assert.equal(result.legacyProcesses[0].pid, legacy.pid)
-    assert.ok(legacy.pid === undefined || !isProcessAlive(legacy.pid))
+    expect(result.action).toBe("no-daemon-cleaned")
+    expect(result.recoveredOrphans).toBe(0)
+    expect(result.legacyProcesses.length).toBe(1)
+    expect(result.legacyProcesses[0].pid).toBe(legacy.pid)
+    expect(legacy.pid === undefined || !isProcessAlive(legacy.pid)).toBeTruthy()
   } finally {
     legacy.kill("SIGKILL")
     await fs.rm(dir, {force: true, recursive: true})
@@ -74,7 +75,7 @@ test("predeploy cleanup leaves legacy processes alone when daemon already has an
       })
     })
 
-    assert.deepEqual(result, {
+    expect(result).toEqual({
       action: "daemon-active",
       legacyProcesses: [],
       recoveredOrphans: 0
@@ -123,9 +124,10 @@ test("predeploy cleanup stops an active daemon when the proxy config changed", a
       }
     })
 
-    assert.equal(result.action, "daemon-stopped")
-    assert.deepEqual(commands.map((command) => command.command), ["status", "shutdown"])
+    expect(result.action).toBe("daemon-stopped")
+    expect(commands.map((command) => command.command)).toEqual(["status", "shutdown"])
   } finally {
     await fs.rm(dir, {force: true, recursive: true})
   }
 })
+})

package/test/process-memory.test.js

@@ -1,13 +1,14 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import fs from "node:fs"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import os from "node:os"
 import path from "node:path"
 import {measureProcessGroupRssBytes, processGroupHasLiveMembers, processGroupMembers} from "../src/process-memory.js"
 
-const linuxOnly = process.platform !== "linux" && "requires /proc (Linux)"
+describe("process-memory", () => {
+
+const linuxTest = process.platform === "linux" ? test : test.skip
 
 /**
  * @returns {number} The current process's group id, read from /proc.
@@ -18,27 +19,27 @@ function currentProcessGroupId() {
   return Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[2])
 }
 
-test("measures the resident memory of a live process group", {skip: linuxOnly}, () => {
+linuxTest("measures the resident memory of a live process group", () => {
   const rssBytes = measureProcessGroupRssBytes(currentProcessGroupId())
 
-  assert.ok(typeof rssBytes === "number" && rssBytes > 0, `expected a positive RSS, got ${rssBytes}`)
+  expect({value: Boolean(typeof rssBytes === "number" && rssBytes > 0), context: `expected a positive RSS, got ${rssBytes}`}).toMatchObject({value: true})
 })
 
-test("returns undefined for a process group with no members", {skip: linuxOnly}, () => {
-  assert.equal(measureProcessGroupRssBytes(2147483646), undefined)
+linuxTest("returns undefined for a process group with no members", () => {
+  expect(measureProcessGroupRssBytes(2147483646)).toBe(undefined)
 })
 
-test("lists process-group members with their command and resident memory", {skip: linuxOnly}, () => {
+linuxTest("lists process-group members with their command and resident memory", () => {
   const members = processGroupMembers(currentProcessGroupId())
   const self = members.find((member) => member.pid === process.pid)
 
-  assert.ok(self, "the current process should be a group member")
-  assert.ok(typeof self.rssBytes === "number" && self.rssBytes > 0)
-  assert.equal(typeof self.command, "string")
+  if (!self) throw new Error("the current process should be a group member")
+  expect(typeof self.rssBytes === "number" && self.rssBytes > 0).toBeTruthy()
+  expect(typeof self.command).toBe("string")
 })
 
-test("returns an empty list for a process group with no members", {skip: linuxOnly}, () => {
-  assert.deepEqual(processGroupMembers(2147483646), [])
+linuxTest("returns an empty list for a process group with no members", () => {
+  expect(processGroupMembers(2147483646)).toEqual([])
 })
 
 test("treats a process group containing only defunct members as stopped", () => {
@@ -48,13 +49,14 @@ test("treats a process group containing only defunct members as stopped", () =>
     fs.mkdirSync(path.join(procPath, "101"))
     fs.writeFileSync(path.join(procPath, "101", "stat"), "101 (worker) Z 1 77 0 0")
 
-    assert.equal(processGroupHasLiveMembers(77, procPath), false)
+    expect(processGroupHasLiveMembers(77, procPath)).toBe(false)
 
     fs.mkdirSync(path.join(procPath, "102"))
     fs.writeFileSync(path.join(procPath, "102", "stat"), "102 (worker) S 1 77 0 0")
 
-    assert.equal(processGroupHasLiveMembers(77, procPath), true)
+    expect(processGroupHasLiveMembers(77, procPath)).toBe(true)
   } finally {
     fs.rmSync(procPath, {force: true, recursive: true})
   }
 })
+})

package/test/proxy.test.js

@@ -1,14 +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 {fileURLToPath} from "node:url"
 import RollbridgeDaemon from "../src/daemon.js"
 import {normalizeConfig} from "../src/config.js"
 
+describe("proxy", () => {
+
 const currentDir = path.dirname(fileURLToPath(import.meta.url))
 const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
 
@@ -52,11 +53,11 @@ async function proxyFetch(daemon, pathName) {
 function webPid(daemon, releaseId) {
   const release = daemon.status().releases.find((candidate) => candidate.releaseId === releaseId)
 
-  assert.ok(release, `Release ${releaseId} should be present`)
+  if (!release) throw new Error(`Release ${releaseId} should be present`)
 
   const web = release.processes.find((candidate) => candidate.id === "web")
 
-  assert.ok(web && typeof web.pid === "number", "web process should report a pid")
+  if (!(web && typeof web.pid === "number")) throw new Error("web process should report a pid")
 
   return web.pid
 }
@@ -84,7 +85,7 @@ test("proxy returns 502 while the active release web process is down", async ()
 
   try {
     await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
-    assert.equal((await proxyFetch(daemon, "/release")).status, 200)
+    expect((await proxyFetch(daemon, "/release")).status).toBe(200)
 
     // Kill the web process group so the active release exits unexpectedly; restart is held off for 60s.
     process.kill(-webPid(daemon, "v1"), "SIGKILL")
@@ -97,7 +98,7 @@ test("proxy returns 502 while the active release web process is down", async ()
       return lastStatus === 502
     })
 
-    assert.equal(lastStatus, 502)
+    expect(lastStatus).toBe(502)
   } finally {
     await daemon.shutdown()
     await fs.rm(root, {force: true, recursive: true})
@@ -112,7 +113,7 @@ test("proxy recovers once the crashed web process restarts", async () => {
 
   try {
     await daemon.deploy({releaseId: "v1", releasePath: root, revision: "v1"})
-    assert.equal((await proxyFetch(daemon, "/release")).status, 200)
+    expect((await proxyFetch(daemon, "/release")).status).toBe(200)
 
     process.kill(-webPid(daemon, "v1"), "SIGKILL")
 
@@ -120,9 +121,10 @@ test("proxy recovers once the crashed web process restarts", async () => {
     // observing the outage, then confirm the restart brings the proxy back to 200.
     await waitFor(async () => (await proxyFetch(daemon, "/release")).status === 502)
     await waitFor(async () => (await proxyFetch(daemon, "/release")).status === 200)
-    assert.equal((await proxyFetch(daemon, "/release")).status, 200)
+    expect((await proxyFetch(daemon, "/release")).status).toBe(200)
   } finally {
     await daemon.shutdown()
     await fs.rm(root, {force: true, recursive: true})
   }
 })
+})

package/test/recover.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 os from "node:os"
 import path from "node:path"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import RollbridgeDaemon from "../src/daemon.js"
 import {normalizeConfig} from "../src/config.js"
 import {recoverOrphans} from "../src/recover.js"
 import {isProcessAlive, readState, writeState} from "../src/state-store.js"
 
+describe("recover", () => {
+
 /**
  * @param {string} dir - Working directory.
  * @param {{statePath?: string}} [options] - Config options.
@@ -68,7 +69,7 @@ test("recover requires a configured statePath", async () => {
   try {
     const result = await recoverOrphans({config: buildConfig(dir), force: true})
 
-    assert.ok("error" in result && /statePath/.test(result.error))
+    expect("error" in result && /statePath/.test(result.error)).toBeTruthy()
   } finally {
     await fs.rm(dir, {force: true, recursive: true})
   }
@@ -84,14 +85,16 @@ test("recover lists orphans without stopping them unless forced", async () => {
 
     const result = await recoverOrphans({config: buildConfig(dir, {statePath}), force: false})
 
-    assert.ok(!("error" in result))
-    assert.equal(result.forced, false)
-    assert.equal(result.cleared, false)
-    assert.deepEqual(result.remaining, [])
-    assert.equal(result.orphans.length, 1)
-    assert.equal(result.orphans[0].pid, orphan.pid)
-    assert.ok(orphan.pid !== undefined && isProcessAlive(orphan.pid), "the orphan must not be stopped by a dry run")
-    assert.ok(await readState(statePath), "a dry run must not clear the state file")
+    if ("error" in result) throw new Error(`Recovery failed: ${result.error}`)
+    expect(result.forced).toBe(false)
+    expect(result.cleared).toBe(false)
+    expect(result.remaining).toEqual([])
+    expect(result.orphans.length).toBe(1)
+    expect(result.orphans[0].pid).toBe(orphan.pid)
+    // The orphan must not be stopped by a dry run.
+    expect(orphan.pid !== undefined && isProcessAlive(orphan.pid)).toBeTruthy()
+    // A dry run must not clear the state file.
+    expect(await readState(statePath)).toBeTruthy()
   } finally {
     orphan.kill("SIGKILL")
     await fs.rm(dir, {force: true, recursive: true})
@@ -108,12 +111,13 @@ test("recover --force stops orphan process groups and clears the state file", as
 
     const result = await recoverOrphans({config: buildConfig(dir, {statePath}), force: true})
 
-    assert.ok(!("error" in result))
-    assert.equal(result.forced, true)
-    assert.equal(result.cleared, true)
-    assert.deepEqual(result.remaining, [])
+    if ("error" in result) throw new Error(`Recovery failed: ${result.error}`)
+    expect(result.forced).toBe(true)
+    expect(result.cleared).toBe(true)
+    expect(result.remaining).toEqual([])
     await waitFor(() => orphan.pid === undefined || !isProcessAlive(orphan.pid))
-    assert.equal(await readState(statePath), undefined, "the state file is cleared after a forced recovery")
+    // The state file is cleared after a forced recovery.
+    expect(await readState(statePath)).toBe(undefined)
   } finally {
     orphan.kill("SIGKILL")
     await fs.rm(dir, {force: true, recursive: true})
@@ -132,12 +136,14 @@ test("recover --force keeps the state file when an orphan cannot be stopped", as
     // reports it is still alive.
     const result = await recoverOrphans({config: buildConfig(dir, {statePath}), force: true, stopGroup: async () => false})
 
-    assert.ok(!("error" in result))
-    assert.equal(result.forced, true)
-    assert.equal(result.cleared, false, "the state file is kept when an orphan survives")
-    assert.equal(result.remaining.length, 1)
-    assert.equal(result.remaining[0].pid, orphan.pid)
-    assert.ok(await readState(statePath), "the state file must remain so the operator can retry")
+    if ("error" in result) throw new Error(`Recovery failed: ${result.error}`)
+    expect(result.forced).toBe(true)
+    // The state file is kept when an orphan survives.
+    expect(result.cleared).toBe(false)
+    expect(result.remaining.length).toBe(1)
+    expect(result.remaining[0].pid).toBe(orphan.pid)
+    // The state file must remain so the operator can retry.
+    expect(await readState(statePath)).toBeTruthy()
   } finally {
     orphan.kill("SIGKILL")
     await fs.rm(dir, {force: true, recursive: true})
@@ -154,9 +160,10 @@ test("recover refuses while a daemon is running", async () => {
   try {
     const result = await recoverOrphans({config, force: true})
 
-    assert.ok("error" in result && /is using/.test(result.error))
+    expect("error" in result && /is using/.test(result.error)).toBeTruthy()
   } finally {
     await daemon.shutdown()
     await fs.rm(dir, {force: true, recursive: true})
   }
 })
+})

package/test/release-group.test.js

@@ -1,10 +1,11 @@
 // @ts-check
 
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import ReleaseGroup from "../src/release-group.js"
 import {normalizeConfig} from "../src/config.js"
 
+describe("release-group", () => {
+
 /**
  * @param {import("../src/json.js").JsonValue} webProcess - The single proxied process definition.
  * @param {() => boolean} [shouldStart] - Whether process starts remain allowed.
@@ -35,8 +36,8 @@ test("templates interpolate values from the daemon environment", () => {
   try {
     const managed = release.buildProcess(release.config.processes[0])
 
-    assert.equal(managed.command, "run --token from-daemon")
-    assert.equal(managed.env.DOWNSTREAM_TOKEN, "from-daemon")
+    expect(managed.command).toBe("run --token from-daemon")
+    expect(managed.env.DOWNSTREAM_TOKEN).toBe("from-daemon")
   } finally {
     delete process.env.ROLLBRIDGE_ENV_TEST
   }
@@ -56,15 +57,15 @@ test("replica processes get a replica index, count, and template context", () =>
   const workerConfig = release.config.processes[1]
   const replica = release.buildProcess(workerConfig, {count: 3, index: 1, instanceId: "worker#1"})
 
-  assert.equal(replica.id, "worker#1")
-  assert.equal(replica.command, "worker 1/3")
-  assert.equal(replica.env.ROLLBRIDGE_REPLICA_INDEX, "1")
-  assert.equal(replica.env.ROLLBRIDGE_REPLICA_COUNT, "3")
-  assert.equal(replica.env.ROLLBRIDGE_PROCESS_ID, "worker")
-  assert.equal(replica.env.SLOT, "1")
+  expect(replica.id).toBe("worker#1")
+  expect(replica.command).toBe("worker 1/3")
+  expect(replica.env.ROLLBRIDGE_REPLICA_INDEX).toBe("1")
+  expect(replica.env.ROLLBRIDGE_REPLICA_COUNT).toBe("3")
+  expect(replica.env.ROLLBRIDGE_PROCESS_ID).toBe("worker")
+  expect(replica.env.SLOT).toBe("1")
 })
 
-test("a referenced daemon environment variable that is unset fails fast", () => {
+test("a referenced daemon environment variable that is unset fails fast", async () => {
   const release = buildRelease({
     command: "run {{env.ROLLBRIDGE_ENV_MISSING}}",
     id: "web",
@@ -74,10 +75,7 @@ test("a referenced daemon environment variable that is unset fails fast", () =>
 
   delete process.env.ROLLBRIDGE_ENV_MISSING
 
-  assert.throws(
-    () => release.buildProcess(release.config.processes[0]),
-    /Missing template value for \{\{env.ROLLBRIDGE_ENV_MISSING\}\}/
-  )
+  await expect(() => release.buildProcess(release.config.processes[0])).toThrow(/Missing template value for \{\{env.ROLLBRIDGE_ENV_MISSING\}\}/)
 })
 
 test("committed generation restoration does not start after shutdown begins", async () => {
@@ -92,6 +90,7 @@ test("committed generation restoration does not start after shutdown begins", as
   }
   release.processes.set("web", process)
 
-  await assert.rejects(() => release.restartCommittedGeneration(), /shutting down/)
-  assert.equal(starts, 0)
+  await expect(release.restartCommittedGeneration()).rejects.toThrow(/shutting down/)
+  expect(starts).toBe(0)
+})
 })

package/test/release-retention.test.js

@@ -1,14 +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 {fileURLToPath} from "node:url"
 import RollbridgeDaemon, {releasesToPrune} from "../src/daemon.js"
 import {normalizeConfig} from "../src/config.js"
 
+describe("release-retention", () => {
+
 const currentDir = path.dirname(fileURLToPath(import.meta.url))
 const dummyAppPath = path.join(currentDir, "fixtures", "dummy-app.js")
 
@@ -23,7 +24,7 @@ test("releasesToPrune keeps the most recent stopped releases and never active or
 
   const remove = releasesToPrune(releases, {keep: 1, maxAgeMs: 0}, Date.parse("2026-05-22T00:00:10.000Z"))
 
-  assert.deepEqual([...remove].sort(), ["v1", "v2"])
+  expect([...remove].sort()).toEqual(["v1", "v2"])
 })
 
 test("releasesToPrune keeps the later-deployed release when stoppedAt ties", () => {
@@ -36,7 +37,7 @@ test("releasesToPrune keeps the later-deployed release when stoppedAt ties", ()
 
   const remove = releasesToPrune(releases, {keep: 1, maxAgeMs: 0}, Date.parse("2026-05-22T00:00:10.000Z"))
 
-  assert.deepEqual(remove, ["v1"])
+  expect(remove).toEqual(["v1"])
 })
 
 test("releasesToPrune prunes stopped releases older than maxAgeMs", () => {
@@ -48,7 +49,7 @@ test("releasesToPrune prunes stopped releases older than maxAgeMs", () => {
 
   const remove = releasesToPrune(releases, {keep: 100, maxAgeMs: 30000}, now)
 
-  assert.deepEqual(remove, ["old"])
+  expect(remove).toEqual(["old"])
 })
 
 test("the daemon prunes stopped releases beyond the retention count across deploys", async () => {
@@ -82,9 +83,9 @@ test("the daemon prunes stopped releases beyond the retention count across deplo
 
     const ids = daemon.status().releases.map((release) => release.releaseId)
 
-    assert.ok(ids.includes("v3"), `active release should be retained, got ${JSON.stringify(ids)}`)
-    assert.ok(!ids.includes("v1"), `oldest stopped release should be pruned, got ${JSON.stringify(ids)}`)
-    assert.ok(ids.length <= 2, `expected at most the active release plus one stopped, got ${JSON.stringify(ids)}`)
+    expect({value: Boolean(ids.includes("v3")), context: `active release should be retained, got ${JSON.stringify(ids)}`}).toMatchObject({value: true})
+    expect({value: Boolean(!ids.includes("v1")), context: `oldest stopped release should be pruned, got ${JSON.stringify(ids)}`}).toMatchObject({value: true})
+    expect({value: Boolean(ids.length <= 2), context: `expected at most the active release plus one stopped, got ${JSON.stringify(ids)}`}).toMatchObject({value: true})
   } finally {
     await daemon.shutdown()
     await fs.rm(root, {force: true, recursive: true})
@@ -105,3 +106,4 @@ async function waitFor(callback) {
 
   throw new Error("Timed out waiting for condition")
 }
+})