@jango-blockchained/hoox-cli 0.3.4

package/src/commands/check/check-command.test.ts

@@ -0,0 +1,468 @@
+/**
+ * Unit tests for the check command.
+ *
+ * Uses prototype mocking on ConfigService, CloudflareService, and SecretsService
+ * to verify the command logic in isolation. @clack/prompts spinner is not
+ * mocked — it degrades gracefully in non-TTY test environments.
+ */
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Stub service prototypes
+// ---------------------------------------------------------------------------
+
+import { ConfigService } from "../../services/config/config-service.js";
+import { CloudflareService } from "../../services/cloudflare/cloudflare-service.js";
+import { SecretsService } from "../../services/secrets/secrets-service.js";
+
+// ---------------------------------------------------------------------------
+// Stub variables — reassigned in beforeEach
+// ---------------------------------------------------------------------------
+
+let loadMock: ReturnType<typeof mock>;
+let validateMock: ReturnType<typeof mock>;
+let getGlobalMock: ReturnType<typeof mock>;
+let listWorkersMock: ReturnType<typeof mock>;
+let listEnabledWorkersMock: ReturnType<typeof mock>;
+let getWorkerMock: ReturnType<typeof mock>;
+
+let d1ListMock: ReturnType<typeof mock>;
+let kvListMock: ReturnType<typeof mock>;
+let r2ListMock: ReturnType<typeof mock>;
+let queueListMock: ReturnType<typeof mock>;
+let tailMock: ReturnType<typeof mock>;
+let secretListMock: ReturnType<typeof mock>;
+
+let secretsCreateMock: ReturnType<typeof mock>;
+let checkLocalSecretsMock: ReturnType<typeof mock>;
+let listSecretsMock: ReturnType<typeof mock>;
+
+// Preserve originals for cleanup
+const origLoad = ConfigService.prototype.load;
+const origValidate = ConfigService.prototype.validate;
+const origGetGlobal = ConfigService.prototype.getGlobal;
+const origListWorkers = ConfigService.prototype.listWorkers;
+const origListEnabled = ConfigService.prototype.listEnabledWorkers;
+const origGetWorker = ConfigService.prototype.getWorker;
+
+const origD1List = CloudflareService.prototype.d1List;
+const origKvList = CloudflareService.prototype.kvList;
+const origR2List = CloudflareService.prototype.r2List;
+const origQueueList = CloudflareService.prototype.queueList;
+const origTail = CloudflareService.prototype.tail;
+const origSecretList = CloudflareService.prototype.secretList;
+
+const origCreate = SecretsService.create;
+const origCheckLocal = SecretsService.prototype.checkLocalSecrets;
+const origListSecrets = SecretsService.prototype.listSecrets;
+
+beforeEach(() => {
+  mock.restore();
+
+  // Reset process.exitCode between tests
+  process.exitCode = undefined;
+
+  // Reset to originals on prototypes
+  ConfigService.prototype.load = origLoad;
+  ConfigService.prototype.validate = origValidate;
+  ConfigService.prototype.getGlobal = origGetGlobal;
+  ConfigService.prototype.listWorkers = origListWorkers;
+  ConfigService.prototype.listEnabledWorkers = origListEnabled;
+  ConfigService.prototype.getWorker = origGetWorker;
+
+  CloudflareService.prototype.d1List = origD1List;
+  CloudflareService.prototype.kvList = origKvList;
+  CloudflareService.prototype.r2List = origR2List;
+  CloudflareService.prototype.queueList = origQueueList;
+  CloudflareService.prototype.tail = origTail;
+  CloudflareService.prototype.secretList = origSecretList;
+
+  // Fresh mocks
+  loadMock = mock(async () => ({}));
+  validateMock = mock(() => ({ valid: true, errors: [] }));
+  getGlobalMock = mock(() => ({
+    cloudflare_account_id: "abc123",
+  }));
+  listWorkersMock = mock(() => ["d1-worker", "hoox", "trade-worker"]);
+  listEnabledWorkersMock = mock(() => ["d1-worker", "hoox", "trade-worker"]);
+  getWorkerMock = mock((_name: string) => ({
+    enabled: true,
+    path: "workers/test-worker",
+  }));
+
+  d1ListMock = mock(async () => ({
+    ok: true as const,
+    data: "my-database (abc-123)",
+  }));
+  kvListMock = mock(async () => ({
+    ok: true as const,
+    data: "namespace-1 (id1)\nnamespace-2 (id2)",
+  }));
+  r2ListMock = mock(async () => ({
+    ok: true as const,
+    data: "bucket-1\nbucket-2",
+  }));
+  queueListMock = mock(async () => ({
+    ok: true as const,
+    data: "queue-1\nqueue-2",
+  }));
+  tailMock = mock(async () => ({
+    ok: true as const,
+    data: "Connected to worker",
+  }));
+  secretListMock = mock(async () => ({
+    ok: true as const,
+    data: "Secret names: API_KEY, DB_PASSWORD",
+  }));
+
+  secretsCreateMock = mock(async () =>
+    Object.create(SecretsService.prototype, {
+      checkLocalSecrets: {
+        value: mock(async () => ({ allSet: true, missing: [], secrets: [] })),
+      },
+      listSecrets: { value: mock(() => []) },
+    })
+  );
+
+  checkLocalSecretsMock = mock(async () => ({
+    worker: "test-worker",
+    secrets: [],
+    allSet: true,
+    missing: [],
+  }));
+  listSecretsMock = mock(() => ["API_KEY"]);
+
+  // Apply stubs
+  ConfigService.prototype.load = loadMock;
+  ConfigService.prototype.validate = validateMock;
+  ConfigService.prototype.getGlobal = getGlobalMock;
+  ConfigService.prototype.listWorkers = listWorkersMock;
+  ConfigService.prototype.listEnabledWorkers = listEnabledWorkersMock;
+  ConfigService.prototype.getWorker = getWorkerMock;
+
+  CloudflareService.prototype.d1List = d1ListMock;
+  CloudflareService.prototype.kvList = kvListMock;
+  CloudflareService.prototype.r2List = r2ListMock;
+  CloudflareService.prototype.queueList = queueListMock;
+  CloudflareService.prototype.tail = tailMock;
+  CloudflareService.prototype.secretList = secretListMock;
+
+  // Replace static create on SecretsService
+  (SecretsService as unknown as Record<string, unknown>).create =
+    secretsCreateMock;
+});
+
+afterEach(() => {
+  mock.restore();
+
+  // Restore originals
+  ConfigService.prototype.load = origLoad;
+  ConfigService.prototype.validate = origValidate;
+  ConfigService.prototype.getGlobal = origGetGlobal;
+  ConfigService.prototype.listWorkers = origListWorkers;
+  ConfigService.prototype.listEnabledWorkers = origListEnabled;
+  ConfigService.prototype.getWorker = origGetWorker;
+
+  CloudflareService.prototype.d1List = origD1List;
+  CloudflareService.prototype.kvList = origKvList;
+  CloudflareService.prototype.r2List = origR2List;
+  CloudflareService.prototype.queueList = origQueueList;
+  CloudflareService.prototype.tail = origTail;
+  CloudflareService.prototype.secretList = origSecretList;
+
+  (SecretsService as unknown as Record<string, unknown>).create = origCreate;
+  SecretsService.prototype.checkLocalSecrets = origCheckLocal;
+  SecretsService.prototype.listSecrets = origListSecrets;
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Dynamically import the check command after mocks are in place.
+ */
+async function importCheckCommand(): Promise<{
+  registerCheckCommand: typeof import("./check-command.js").registerCheckCommand;
+}> {
+  return import("./check-command.js");
+}
+
+import { Command } from "commander";
+import { ExitCode } from "../../utils/errors.js";
+
+async function createProgram() {
+  const { registerCheckCommand } = await importCheckCommand();
+  const program = new Command()
+    .name("hoox-test")
+    .option("--json", "Output in JSON format")
+    .option("--quiet", "Minimal output")
+    .exitOverride(() => {
+      // Suppress Commander's own exit during tests
+    });
+  registerCheckCommand(program);
+  return program;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("registerCheckCommand", () => {
+  // -- Command registration -------------------------------------------------
+
+  it("registers 'check' as a command on the program", async () => {
+    const program = await createProgram();
+    const checkCmd = program.commands.find((c) => c.name() === "check");
+    expect(checkCmd).toBeDefined();
+  });
+
+  it("registers 'check setup' subcommand", async () => {
+    const program = await createProgram();
+    const checkCmd = program.commands.find((c) => c.name() === "check")!;
+    const setupCmd = checkCmd.commands.find((c) => c.name() === "setup");
+    expect(setupCmd).toBeDefined();
+    expect(setupCmd!.description()).toContain("validation");
+  });
+
+  it("registers 'check health' subcommand", async () => {
+    const program = await createProgram();
+    const checkCmd = program.commands.find((c) => c.name() === "check")!;
+    const healthCmd = checkCmd.commands.find((c) => c.name() === "health");
+    expect(healthCmd).toBeDefined();
+    expect(healthCmd!.description()).toContain("health");
+  });
+
+  it("registers 'check fix' subcommand", async () => {
+    const program = await createProgram();
+    const checkCmd = program.commands.find((c) => c.name() === "check")!;
+    const fixCmd = checkCmd.commands.find((c) => c.name() === "fix");
+    expect(fixCmd).toBeDefined();
+    expect(fixCmd!.description()).toContain("Repair");
+  });
+
+  // -- check setup ----------------------------------------------------------
+
+  describe("check setup", () => {
+    it("loads config and runs all 4 categories", { timeout: 30000 }, async () => {
+      const program = await createProgram();
+      await program.parseAsync(["check", "setup"], { from: "user" });
+
+      expect(loadMock).toHaveBeenCalled();
+      expect(d1ListMock).toHaveBeenCalled();
+      expect(kvListMock).toHaveBeenCalled();
+      expect(r2ListMock).toHaveBeenCalled();
+      expect(queueListMock).toHaveBeenCalled();
+    });
+
+    it("outputs JSON when --json flag is set", { timeout: 30000 }, async () => {
+      const program = await createProgram();
+      const logSpy = mock((..._args: unknown[]) => {});
+      const origWrite = process.stdout.write;
+      (process.stdout as unknown as Record<string, unknown>).write = logSpy;
+
+      try {
+        await program.parseAsync(["--json", "check", "setup"], {
+          from: "user",
+        });
+
+        // Should have called stdout.write with JSON
+        const jsonCalls = (
+          logSpy as unknown as { mock: { calls: Array<unknown[]> } }
+        ).mock.calls.filter((call: unknown[]) => {
+          const str = String(call[0] ?? "");
+          try {
+            JSON.parse(str);
+            return str.includes("categories") && str.includes("summary");
+          } catch {
+            return false;
+          }
+        });
+        expect(jsonCalls.length).toBeGreaterThan(0);
+      } finally {
+        (process.stdout as unknown as Record<string, unknown>).write =
+          origWrite;
+      }
+    });
+
+    it("sets exitCode to ERROR when validation fails", { timeout: 30000 }, async () => {
+      validateMock = mock(() => ({
+        valid: false,
+        errors: ["global.cloudflare_account_id is required"],
+      }));
+      ConfigService.prototype.validate = validateMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["check", "setup"], { from: "user" });
+
+      expect(process.exitCode).toBe(ExitCode.ERROR);
+    });
+
+    it("sets exitCode to ERROR when infra check fails", async () => {
+      d1ListMock = mock(async () => ({
+        ok: false as const,
+        error: "Authentication failed",
+      }));
+      CloudflareService.prototype.d1List = d1ListMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["check", "setup"], { from: "user" });
+
+      expect(process.exitCode).toBe(ExitCode.ERROR);
+    });
+
+    it("handles config load failure gracefully", async () => {
+      loadMock = mock(async () => {
+        throw new Error("Config file not found");
+      });
+      ConfigService.prototype.load = loadMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["check", "setup"], { from: "user" });
+
+      expect(process.exitCode).toBe(ExitCode.ERROR);
+    });
+  });
+
+  // -- check health ---------------------------------------------------------
+
+  describe("check health", () => {
+    it("checks connectivity for all enabled workers", async () => {
+      const program = await createProgram();
+      await program.parseAsync(["check", "health"], { from: "user" });
+
+      expect(loadMock).toHaveBeenCalled();
+      // tailMock should have been called for each enabled worker
+      expect(tailMock).toHaveBeenCalled();
+    });
+
+    it("outputs JSON when --json flag is set", async () => {
+      const program = await createProgram();
+      const logSpy = mock((..._args: unknown[]) => {});
+      const origWrite = process.stdout.write;
+      (process.stdout as unknown as Record<string, unknown>).write = logSpy;
+
+      try {
+        await program.parseAsync(["--json", "check", "health"], {
+          from: "user",
+        });
+
+        const jsonCalls = (
+          logSpy as unknown as { mock: { calls: Array<unknown[]> } }
+        ).mock.calls.filter((call: unknown[]) => {
+          const str = String(call[0] ?? "");
+          try {
+            const parsed = JSON.parse(str);
+            return Array.isArray(parsed) && parsed.length > 0;
+          } catch {
+            return false;
+          }
+        });
+        expect(jsonCalls.length).toBeGreaterThan(0);
+      } finally {
+        (process.stdout as unknown as Record<string, unknown>).write =
+          origWrite;
+      }
+    });
+
+    it("sets exitCode to ERROR when any worker is unhealthy", async () => {
+      tailMock = mock(async () => ({
+        ok: false as const,
+        error: "Worker not reachable",
+      }));
+      CloudflareService.prototype.tail = tailMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["check", "health"], { from: "user" });
+
+      expect(process.exitCode).toBe(ExitCode.ERROR);
+    });
+
+    it("handles empty worker list gracefully", async () => {
+      listEnabledWorkersMock = mock(() => []);
+      ConfigService.prototype.listEnabledWorkers = listEnabledWorkersMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["check", "health"], { from: "user" });
+
+      // Should exit cleanly — the handler outputs success message
+      expect(process.exitCode).toBe(1);
+    });
+  });
+
+  // -- check fix ------------------------------------------------------------
+
+  describe("check fix", () => {
+    it("scans for issues and reports when dry-run", async () => {
+      const program = await createProgram();
+
+      // Mock Bun.file so .dev.vars doesn't exist (triggers fix action)
+      const origBunFile = Bun.file;
+      (Bun as Record<string, unknown>).file = mock((_path: string) => ({
+        exists: mock(async () => false),
+        text: mock(async () => ""),
+        name: _path,
+      }));
+
+      try {
+        await program.parseAsync(["check", "fix", "--dry-run"], {
+          from: "user",
+        });
+
+        // Should complete without errors
+        // In dry-run mode, exitCode should not be ERROR (no actual failures to apply)
+      } finally {
+        (Bun as Record<string, unknown>).file = origBunFile;
+      }
+    });
+
+    it("outputs JSON when --json flag is set", async () => {
+      const program = await createProgram();
+      const logSpy = mock((..._args: unknown[]) => {});
+      const origWrite = process.stdout.write;
+      (process.stdout as unknown as Record<string, unknown>).write = logSpy;
+
+      const origBunFile = Bun.file;
+      (Bun as Record<string, unknown>).file = mock((_path: string) => ({
+        exists: mock(async () => false),
+        text: mock(async () => ""),
+        name: _path,
+      }));
+
+      try {
+        await program.parseAsync(["--json", "check", "fix", "--dry-run"], {
+          from: "user",
+        });
+
+        const jsonCalls = (
+          logSpy as unknown as { mock: { calls: Array<unknown[]> } }
+        ).mock.calls.filter((call: unknown[]) => {
+          const str = String(call[0] ?? "");
+          try {
+            const parsed = JSON.parse(str);
+            return parsed.actions !== undefined && parsed.summary !== undefined;
+          } catch {
+            return false;
+          }
+        });
+        expect(jsonCalls.length).toBeGreaterThan(0);
+      } finally {
+        (process.stdout as unknown as Record<string, unknown>).write =
+          origWrite;
+        (Bun as Record<string, unknown>).file = origBunFile;
+      }
+    });
+
+    it("handles config load failure gracefully", async () => {
+      loadMock = mock(async () => {
+        throw new Error("Config file not found");
+      });
+      ConfigService.prototype.load = loadMock;
+
+      const program = await createProgram();
+      await program.parseAsync(["check", "fix"], { from: "user" });
+
+      expect(process.exitCode).toBe(ExitCode.ERROR);
+    });
+  });
+});