| import fs from "node:fs"; |
| import path from "node:path"; |
| import { afterEach, beforeEach, describe, expect, it } from "vitest"; |
| import { closeOpenClawStateDatabaseForTest } from "../state/openclaw-state-db.js"; |
| import { createSuiteTempRootTracker } from "../test-helpers/temp-dir.js"; |
| import { |
| acquireFleetCellOperation, |
| deleteFleetCell, |
| getFleetCell, |
| listFleetCells, |
| reserveFleetCell, |
| updateFleetCellImage, |
| } from "./registry.js"; |
|
|
| type ReserveFleetCellParams = Parameters<typeof reserveFleetCell>[1]; |
|
|
| describe("fleet cell registry", () => { |
| let root: string | undefined; |
| let env: NodeJS.ProcessEnv; |
|
|
| const tempRoot = createSuiteTempRootTracker({ prefix: "openclaw-fleet-registry-" }); |
|
|
| beforeEach(async () => { |
| root = await tempRoot.setup(); |
| env = { ...process.env, OPENCLAW_STATE_DIR: root }; |
| }); |
|
|
| afterEach(async () => { |
| closeOpenClawStateDatabaseForTest(); |
| await tempRoot.cleanup(); |
| root = undefined; |
| }); |
|
|
| function params(tenantId: string, requestedPort?: number): ReserveFleetCellParams { |
| if (!root) { |
| throw new Error("test root not initialized"); |
| } |
| return { |
| tenantId, |
| createdAtMs: 1, |
| image: "ghcr.io/openclaw/openclaw:latest", |
| runtime: "docker", |
| containerName: `openclaw-cell-${tenantId}`, |
| dataDir: path.join(root, "fleet", "cells", tenantId), |
| ...(requestedPort === undefined ? {} : { requestedPort }), |
| }; |
| } |
|
|
| it("returns empty reads without creating state on a fresh install", () => { |
| if (!root) { |
| throw new Error("test root not initialized"); |
| } |
| const databasePath = path.join(root, "state", "openclaw.sqlite"); |
|
|
| expect(listFleetCells(env)).toEqual([]); |
| expect(getFleetCell(env, "missing")).toBeUndefined(); |
| expect(fs.existsSync(databasePath)).toBe(false); |
| }); |
|
|
| it("persists, orders, updates, and deletes cells", () => { |
| const zulu = reserveFleetCell(env, { |
| ...params("zulu", 19_250), |
| createdAtMs: 20, |
| runtime: "podman", |
| }); |
| const alpha = reserveFleetCell(env, { |
| ...params("alpha"), |
| createdAtMs: 10, |
| }); |
|
|
| expect(alpha.hostPort).toBe(19_100); |
| expect(zulu.hostPort).toBe(19_250); |
| expect(listFleetCells(env).map((cell) => cell.tenantId)).toEqual(["alpha", "zulu"]); |
| expect(getFleetCell(env, "zulu")).toEqual(zulu); |
|
|
| updateFleetCellImage(env, "zulu", "ghcr.io/openclaw/openclaw:v2"); |
| expect(getFleetCell(env, "zulu")?.image).toBe("ghcr.io/openclaw/openclaw:v2"); |
|
|
| deleteFleetCell(env, "alpha"); |
| expect(getFleetCell(env, "alpha")).toBeUndefined(); |
| }); |
|
|
| it("rejects duplicate tenant ids without replacing the row", () => { |
| const original = reserveFleetCell(env, params("alpha", 19_300)); |
|
|
| expect(() => |
| reserveFleetCell(env, { |
| ...params("alpha", 19_301), |
| image: "ghcr.io/openclaw/openclaw:other", |
| }), |
| ).toThrow("Fleet cell already exists: alpha"); |
| expect(getFleetCell(env, "alpha")).toEqual(original); |
| }); |
|
|
| it("allocates the first free port and rejects explicit collisions", () => { |
| expect(reserveFleetCell(env, params("alpha")).hostPort).toBe(19_100); |
| expect(reserveFleetCell(env, params("beta")).hostPort).toBe(19_101); |
|
|
| expect(() => reserveFleetCell(env, params("gamma", 19_100))).toThrow(/19100/); |
| expect(getFleetCell(env, "gamma")).toBeUndefined(); |
| expect(reserveFleetCell(env, params("delta", 20_000)).hostPort).toBe(20_000); |
| }); |
|
|
| it("serializes tenant mutations with renewable expiring leases", () => { |
| const first = acquireFleetCellOperation({ |
| env, |
| tenantId: "alpha", |
| operation: "upgrade", |
| owner: "first", |
| nowMs: 1_000, |
| }); |
|
|
| expect(() => |
| acquireFleetCellOperation({ |
| env, |
| tenantId: "alpha", |
| operation: "rm", |
| owner: "second", |
| nowMs: 1_001, |
| }), |
| ).toThrow(/fleet upgrade.*already running/iu); |
|
|
| first.heartbeat(200_000); |
| expect(() => |
| acquireFleetCellOperation({ |
| env, |
| tenantId: "alpha", |
| operation: "rm", |
| owner: "second", |
| nowMs: 400_000, |
| }), |
| ).toThrow(/already running/iu); |
|
|
| first.release(); |
| const second = acquireFleetCellOperation({ |
| env, |
| tenantId: "alpha", |
| operation: "rm", |
| owner: "second", |
| nowMs: 400_001, |
| }); |
| second.release(); |
| }); |
|
|
| it("fences an expired owner from its replacement lease", () => { |
| const first = acquireFleetCellOperation({ |
| env, |
| tenantId: "alpha", |
| operation: "upgrade", |
| owner: "first", |
| nowMs: 1_000, |
| }); |
| const successor = acquireFleetCellOperation({ |
| env, |
| tenantId: "alpha", |
| operation: "rm", |
| owner: "successor", |
| nowMs: 301_000, |
| }); |
|
|
| expect(() => first.heartbeat(301_001)).toThrow(/lease was lost/iu); |
| first.release(); |
| expect(() => |
| acquireFleetCellOperation({ |
| env, |
| tenantId: "alpha", |
| operation: "create", |
| owner: "third", |
| nowMs: 301_002, |
| }), |
| ).toThrow(/fleet rm.*already running/iu); |
|
|
| successor.release(); |
| }); |
|
|
| it("fails image updates when the cell row disappeared", () => { |
| expect(() => updateFleetCellImage(env, "missing", "image:v2")).toThrow(/disappeared/iu); |
| }); |
| }); |
|
|
