miravo 0.2.3 → 0.4.0

package/src/lib/daemon-registry.test.ts

@@ -0,0 +1,429 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { DaemonRegistryEntry } from "./daemon-registry.ts";
+import {
+  acquireNameLock,
+  checkNameConflict,
+  checkPortConflicts,
+  displayHost,
+  isPidAlive,
+  listEntries,
+  probeEntryIdentity,
+  readEntry,
+  removeEntry,
+  sweepStaleEntries,
+  writeEntry,
+} from "./daemon-registry.ts";
+
+/** Override MIRAVO_HOME to isolate tests from real daemon state. */
+let testHome: string;
+const serverHandles: Array<{ stop: () => void }> = [];
+
+async function setupTestHome(): Promise<void> {
+  testHome = await mkdtemp(join(tmpdir(), "miravo-daemon-test-"));
+  Bun.env["MIRAVO_HOME"] = testHome;
+}
+
+afterEach(async () => {
+  for (const handle of serverHandles) {
+    handle.stop();
+  }
+  serverHandles.length = 0;
+  delete Bun.env["MIRAVO_HOME"];
+  if (testHome) {
+    await rm(testHome, { recursive: true, force: true });
+  }
+});
+
+function makeEntry(overrides: Partial<DaemonRegistryEntry> = {}): DaemonRegistryEntry {
+  return {
+    name: "test-sim",
+    pid: 99999,
+    adminPort: 8080,
+    adminHost: "127.0.0.1",
+    adapters: {
+      mqtt: { port: 1883, host: "0.0.0.0" },
+    },
+    templatePath: "/tmp/test.miravo.yaml",
+    startedAt: "2026-03-17T10:00:00Z",
+    seed: 42,
+    runId: "test-run-id",
+    ...overrides,
+  };
+}
+
+describe("daemon-registry", () => {
+  describe("writeEntry + readEntry", () => {
+    test("round-trip writes and reads an entry", async () => {
+      await setupTestHome();
+      const entry = makeEntry();
+      await writeEntry(entry);
+      const read = await readEntry("test-sim");
+      expect(read).toEqual(entry);
+    });
+
+    test("overwrites existing entry", async () => {
+      await setupTestHome();
+      const entry1 = makeEntry({ pid: 111 });
+      const entry2 = makeEntry({ pid: 222 });
+      await writeEntry(entry1);
+      await writeEntry(entry2);
+      const read = await readEntry("test-sim");
+      expect(read?.pid).toBe(222);
+    });
+  });
+
+  describe("readEntry", () => {
+    test("returns null for missing file", async () => {
+      await setupTestHome();
+      const result = await readEntry("nonexistent");
+      expect(result).toBeNull();
+    });
+
+    test("returns null for invalid JSON", async () => {
+      await setupTestHome();
+      const dir = join(testHome, "daemon");
+      const { mkdir } = await import("node:fs/promises");
+      await mkdir(dir, { recursive: true });
+      await Bun.write(join(dir, "bad.json"), "not json");
+      const result = await readEntry("bad");
+      expect(result).toBeNull();
+    });
+
+    test("returns null for valid JSON that fails schema", async () => {
+      await setupTestHome();
+      const dir = join(testHome, "daemon");
+      const { mkdir } = await import("node:fs/promises");
+      await mkdir(dir, { recursive: true });
+      await Bun.write(join(dir, "partial.json"), JSON.stringify({ name: "partial" }));
+      const result = await readEntry("partial");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("removeEntry", () => {
+    test("removes an existing entry", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry());
+      await removeEntry("test-sim");
+      const result = await readEntry("test-sim");
+      expect(result).toBeNull();
+    });
+
+    test("does not throw for missing entry", async () => {
+      await setupTestHome();
+      await expect(removeEntry("nonexistent")).resolves.toBeUndefined();
+    });
+  });
+
+  describe("listEntries", () => {
+    test("returns empty array when daemon dir does not exist", async () => {
+      await setupTestHome();
+      const entries = await listEntries();
+      expect(entries).toEqual([]);
+    });
+
+    test("returns all valid entries", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "sim-a" }));
+      await writeEntry(makeEntry({ name: "sim-b" }));
+      const entries = await listEntries();
+      expect(entries).toHaveLength(2);
+      const names = entries.map((e) => e.name).sort();
+      expect(names).toEqual(["sim-a", "sim-b"]);
+    });
+
+    test("skips invalid files", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "valid" }));
+      const dir = join(testHome, "daemon");
+      await Bun.write(join(dir, "invalid.json"), "broken");
+      const entries = await listEntries();
+      expect(entries).toHaveLength(1);
+      expect(entries[0]?.name).toBe("valid");
+    });
+
+    test("skips .tmp files", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "valid" }));
+      const dir = join(testHome, "daemon");
+      await Bun.write(join(dir, "leftover.json.tmp"), JSON.stringify(makeEntry({ name: "tmp" })));
+      const entries = await listEntries();
+      expect(entries).toHaveLength(1);
+    });
+  });
+
+  describe("isPidAlive", () => {
+    test("returns true for own PID", () => {
+      expect(isPidAlive(process.pid)).toBe(true);
+    });
+
+    test("returns false for impossible PID", () => {
+      // PID 2^30 is extremely unlikely to exist
+      expect(isPidAlive(1_073_741_824)).toBe(false);
+    });
+  });
+
+  describe("sweepStaleEntries", () => {
+    test("removes entries with dead PIDs", async () => {
+      await setupTestHome();
+      // Use impossible PIDs so they're guaranteed dead
+      await writeEntry(makeEntry({ name: "dead-sim-a", pid: 1_073_741_824 }));
+      await writeEntry(makeEntry({ name: "dead-sim-b", pid: 1_073_741_825 }));
+
+      await sweepStaleEntries();
+
+      const entries = await listEntries();
+      expect(entries).toHaveLength(0);
+    });
+
+    test("keeps entries whose /readyz reports the same runId with 503", async () => {
+      await setupTestHome();
+      const server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        fetch() {
+          return Response.json(
+            { status: "degraded", reason: "mqtt disconnected", runId: "test-run-id" },
+            { status: 503 },
+          );
+        },
+      });
+      serverHandles.push(server);
+      const port = server.port;
+      if (port === undefined) {
+        throw new Error("Failed to allocate test port.");
+      }
+
+      await writeEntry(
+        makeEntry({
+          name: "paused-sim",
+          pid: process.pid,
+          adminPort: port,
+          runId: "test-run-id",
+        }),
+      );
+
+      await sweepStaleEntries();
+
+      expect(await readEntry("paused-sim")).not.toBeNull();
+    });
+  });
+
+  describe("probeEntryIdentity", () => {
+    test("treats non-ready responses with a matching runId as verified", async () => {
+      const server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        fetch() {
+          return Response.json({ status: "paused", runId: "test-run-id" }, { status: 503 });
+        },
+      });
+      serverHandles.push(server);
+      const port = server.port;
+      if (port === undefined) {
+        throw new Error("Failed to allocate test port.");
+      }
+
+      const result = await probeEntryIdentity(
+        makeEntry({
+          pid: process.pid,
+          adminPort: port,
+          runId: "test-run-id",
+        }),
+      );
+
+      expect(result).toEqual({ status: "verified", ready: false });
+    });
+
+    test("fails closed on malformed /readyz bodies", async () => {
+      const server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        fetch() {
+          return new Response("<html>not json</html>", {
+            status: 200,
+            headers: { "content-type": "text/html" },
+          });
+        },
+      });
+      serverHandles.push(server);
+      const port = server.port;
+      if (port === undefined) {
+        throw new Error("Failed to allocate test port.");
+      }
+
+      const result = await probeEntryIdentity(
+        makeEntry({
+          pid: process.pid,
+          adminPort: port,
+          runId: "test-run-id",
+        }),
+      );
+
+      expect(result).toEqual({ status: "mismatch", ready: false });
+    });
+  });
+
+  describe("checkPortConflicts", () => {
+    test("detects admin port conflict", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "existing", pid: process.pid, adminPort: 8080 }));
+
+      const ports = new Map([["admin", 8080]]);
+      const conflicts = await checkPortConflicts(ports);
+      expect(conflicts).toHaveLength(1);
+      expect(conflicts[0]).toContain("8080");
+      expect(conflicts[0]).toContain("existing");
+    });
+
+    test("detects adapter port conflict", async () => {
+      await setupTestHome();
+      await writeEntry(
+        makeEntry({
+          name: "existing",
+          pid: process.pid,
+          adapters: { mqtt: { port: 1883, host: "0.0.0.0" } },
+        }),
+      );
+
+      const ports = new Map([["mqtt", 1883]]);
+      const conflicts = await checkPortConflicts(ports);
+      expect(conflicts.length).toBeGreaterThan(0);
+      expect(conflicts[0]).toContain("1883");
+    });
+
+    test("excludes named entry from conflict check", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "self", pid: process.pid, adminPort: 8080 }));
+
+      const ports = new Map([["admin", 8080]]);
+      const conflicts = await checkPortConflicts(ports, "self");
+      expect(conflicts).toHaveLength(0);
+    });
+
+    test("ignores entries with dead PIDs", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "dead", pid: 1_073_741_824, adminPort: 8080 }));
+
+      const ports = new Map([["admin", 8080]]);
+      const conflicts = await checkPortConflicts(ports);
+      expect(conflicts).toHaveLength(0);
+    });
+
+    test("returns empty array when no conflicts", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "existing", pid: process.pid, adminPort: 9090 }));
+
+      const ports = new Map([["admin", 8080]]);
+      const conflicts = await checkPortConflicts(ports);
+      expect(conflicts).toHaveLength(0);
+    });
+  });
+
+  describe("checkNameConflict", () => {
+    test("returns null when no entry exists", async () => {
+      await setupTestHome();
+      const result = await checkNameConflict("nonexistent");
+      expect(result).toBeNull();
+    });
+
+    test("removes entry when PID is dead", async () => {
+      await setupTestHome();
+      await writeEntry(makeEntry({ name: "stale", pid: 1_073_741_824 }));
+      const result = await checkNameConflict("stale");
+      expect(result).toBeNull();
+      // Verify file was cleaned up
+      const entry = await readEntry("stale");
+      expect(entry).toBeNull();
+    });
+
+    test("keeps the entry when the daemon is alive but not ready", async () => {
+      await setupTestHome();
+      const server = Bun.serve({
+        hostname: "127.0.0.1",
+        port: 0,
+        fetch() {
+          return Response.json({ status: "paused", runId: "test-run-id" }, { status: 503 });
+        },
+      });
+      serverHandles.push(server);
+      const port = server.port;
+      if (port === undefined) {
+        throw new Error("Failed to allocate test port.");
+      }
+
+      await writeEntry(
+        makeEntry({
+          name: "paused-sim",
+          pid: process.pid,
+          adminPort: port,
+          runId: "test-run-id",
+        }),
+      );
+
+      const result = await checkNameConflict("paused-sim");
+
+      expect(result?.name).toBe("paused-sim");
+      expect(await readEntry("paused-sim")).not.toBeNull();
+    });
+  });
+
+  describe("acquireNameLock", () => {
+    test("acquires lock when none exists", async () => {
+      await setupTestHome();
+      const release = await acquireNameLock("test-sim");
+      await release();
+    });
+
+    test("throws when lock is held by a live process", async () => {
+      await setupTestHome();
+      const dir = join(testHome, "daemon");
+      await mkdir(dir, { recursive: true });
+      await Bun.write(join(dir, "test-sim.lock"), String(process.pid));
+
+      await expect(acquireNameLock("test-sim")).rejects.toThrow("already starting");
+
+      // Clean up the manually created lock so afterEach can remove the dir
+      await Bun.file(join(dir, "test-sim.lock"))
+        .exists()
+        .then(async (exists) => {
+          if (exists) {
+            const { unlink } = await import("node:fs/promises");
+            await unlink(join(dir, "test-sim.lock")).catch(() => {});
+          }
+        });
+    });
+
+    test("clears stale lock from a dead process and succeeds", async () => {
+      await setupTestHome();
+      const dir = join(testHome, "daemon");
+      await mkdir(dir, { recursive: true });
+      // Write a lock with an impossible PID — guaranteed to be dead
+      await Bun.write(join(dir, "test-sim.lock"), "1073741824");
+
+      const release = await acquireNameLock("test-sim");
+      await release();
+    });
+  });
+
+  describe("displayHost", () => {
+    test("maps 0.0.0.0 to 127.0.0.1", () => {
+      expect(displayHost("0.0.0.0")).toBe("127.0.0.1");
+    });
+
+    test("maps :: to 127.0.0.1", () => {
+      expect(displayHost("::")).toBe("127.0.0.1");
+    });
+
+    test("passes through 127.0.0.1", () => {
+      expect(displayHost("127.0.0.1")).toBe("127.0.0.1");
+    });
+
+    test("passes through custom host", () => {
+      expect(displayHost("192.168.1.100")).toBe("192.168.1.100");
+    });
+  });
+});