@mingxy/cerebro 1.20.5 → 1.20.6

package/src/updater.test.ts

@@ -0,0 +1,380 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// ── Hoisted mock functions (available to vi.mock factories) ──────────
+
+const {
+  mockOpenSync,
+  mockWriteSync,
+  mockCloseSync,
+  mockUnlinkSync,
+  mockStatSync,
+  mockReaddirSync,
+  mockMkdtempSync,
+  mockRmSync,
+  mockExecFile,
+  mockLoadPluginConfig,
+  mockShowToast,
+  mockLogInfo,
+  mockLogDebug,
+  mockLogError,
+} = vi.hoisted(() => ({
+  mockOpenSync: vi.fn(),
+  mockWriteSync: vi.fn(),
+  mockCloseSync: vi.fn(),
+  mockUnlinkSync: vi.fn(),
+  mockStatSync: vi.fn(),
+  mockReaddirSync: vi.fn(),
+  mockMkdtempSync: vi.fn(),
+  mockRmSync: vi.fn(),
+  mockExecFile: vi.fn(),
+  mockLoadPluginConfig: vi.fn(),
+  mockShowToast: vi.fn(),
+  mockLogInfo: vi.fn(),
+  mockLogDebug: vi.fn(),
+  mockLogError: vi.fn(),
+}));
+
+// ── Mocks ────────────────────────────────────────────────────────────
+
+vi.mock("node:child_process", () => ({
+  execFile: mockExecFile,
+}));
+
+vi.mock("node:util", () => ({
+  promisify: (fn: Function) => {
+    return (...args: unknown[]) =>
+      new Promise((resolve, reject) => {
+        fn(...args, (err: Error | null, stdout: string, stderr: string) => {
+          if (err) reject(err);
+          else resolve({ stdout, stderr });
+        });
+      });
+  },
+}));
+
+vi.mock("node:module", () => ({
+  createRequire: () => ({
+    resolve: vi.fn(),
+  }),
+}));
+
+vi.mock("node:os", () => ({
+  homedir: () => "/home/test",
+  tmpdir: () => "/tmp",
+}));
+
+vi.mock("node:fs", () => ({
+  openSync: mockOpenSync,
+  writeSync: mockWriteSync,
+  closeSync: mockCloseSync,
+  unlinkSync: mockUnlinkSync,
+  statSync: mockStatSync,
+  readdirSync: mockReaddirSync,
+  mkdtempSync: mockMkdtempSync,
+  rmSync: mockRmSync,
+}));
+
+vi.mock("./config.js", () => ({
+  loadPluginConfig: mockLoadPluginConfig,
+}));
+
+vi.mock("./hooks.js", () => ({
+  showToast: mockShowToast,
+}));
+
+vi.mock("./logger.js", () => ({
+  logInfo: mockLogInfo,
+  logDebug: mockLogDebug,
+  logError: mockLogError,
+}));
+
+// ── Imports (post-mock) ──────────────────────────────────────────────
+
+import { checkAndUpdate } from "./updater.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+type CbFn = (err: Error | null, stdout: string, stderr: string) => void;
+
+function mockExecFileSequence(responses: Array<{ stdout?: string; err?: Error }>): void {
+  let idx = 0;
+  mockExecFile.mockImplementation(((...args: unknown[]) => {
+    const cb = args[args.length - 1] as CbFn;
+    const r = responses[Math.min(idx, responses.length - 1)];
+    idx++;
+    if (r.err) cb(r.err, "", "");
+    else cb(null, r.stdout ?? "", "");
+  }) as typeof mockExecFile);
+}
+
+function stubFsForLockAndInstall(overrides?: { readdirFiles?: string[] }) {
+  mockOpenSync.mockReturnValue(42);
+  mockWriteSync.mockReturnValue(4);
+  mockCloseSync.mockImplementation(() => {});
+  mockUnlinkSync.mockImplementation(() => {});
+  mockStatSync.mockImplementation(() => {
+    throw new Error("ENOENT");
+  });
+  mockReaddirSync.mockReturnValue(
+    (overrides?.readdirFiles ?? ["mingxy-cerebro-2.0.0.tgz"]) as any,
+  );
+  mockMkdtempSync.mockReturnValue("/tmp/cerebro-update-xxx");
+  mockRmSync.mockImplementation(() => {});
+}
+
+function clearFsMocks() {
+  [
+    mockOpenSync, mockWriteSync, mockCloseSync, mockUnlinkSync,
+    mockStatSync, mockReaddirSync, mockMkdtempSync, mockRmSync,
+  ].forEach((m) => { m.mockReset(); });
+}
+
+function makeConfig(autoUpdate = true) {
+  return {
+    autoUpdate,
+    connection: { apiUrl: "", apiKey: "", requestTimeoutMs: 15000 },
+    content: { maxQueryLength: 200, maxContentChars: 30000, maxContentLength: 3000 },
+    injection: { recentCount: 5, searchCount: 10, recentTruncateChars: 0, searchTruncateChars: 0 },
+    ingest: { autoCaptureThreshold: 5, ingestMode: "smart" as const },
+    logging: { logEnabled: true, logLevel: "INFO" as const, logDir: "/tmp/cerebro-test-logs" },
+    ui: { toastDelayMs: 7000 },
+    web: { enabled: true },
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
+describe("updater", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockLoadPluginConfig.mockReturnValue(makeConfig());
+  });
+
+  afterEach(() => {
+    clearFsMocks();
+  });
+
+  // ── checkAndUpdate ────────────────────────────────────────────────
+
+  describe("checkAndUpdate", () => {
+    it("skips when autoUpdate is disabled", async () => {
+      mockLoadPluginConfig.mockReturnValue(makeConfig(false));
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogDebug).toHaveBeenCalledWith("updater: autoUpdate disabled, skipping");
+      expect(mockExecFile).not.toHaveBeenCalled();
+    });
+
+    it("skips when latest version fetch fails", async () => {
+      mockExecFileSequence([{ err: new Error("network error") }]);
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogError).toHaveBeenCalledWith("updater: failed to fetch latest version");
+    });
+
+    it("skips when current version equals latest", async () => {
+      mockExecFileSequence([{ stdout: "1.0.0\n" }]);
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogInfo).toHaveBeenCalledWith(
+        "updater: already up to date",
+        expect.objectContaining({ currentVersion: "1.0.0", latest: "1.0.0" }),
+      );
+    });
+
+    it("skips when current version is greater than latest", async () => {
+      mockExecFileSequence([{ stdout: "0.9.0\n" }]);
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogInfo).toHaveBeenCalledWith(
+        "updater: already up to date",
+        expect.objectContaining({ currentVersion: "1.0.0", latest: "0.9.0" }),
+      );
+    });
+
+    it("installs update when newer version is available", async () => {
+      mockExecFileSequence([{ stdout: "2.0.0\n" }, { stdout: "" }, { stdout: "" }]);
+      stubFsForLockAndInstall();
+
+      const tui = {};
+      await checkAndUpdate(tui, "1.0.0");
+
+      expect(mockLogInfo).toHaveBeenCalledWith(
+        "updater: new version available",
+        expect.objectContaining({ currentVersion: "1.0.0", latest: "2.0.0" }),
+      );
+      expect(mockShowToast).toHaveBeenCalledWith(
+        tui,
+        "🧠 Cerebro Updated",
+        expect.stringContaining("1.0.0 → v2.0.0"),
+        "info",
+        2000,
+      );
+    });
+
+    it("handles install failure gracefully", async () => {
+      mockExecFileSequence([{ stdout: "2.0.0\n" }, { err: new Error("npm pack failed") }]);
+      stubFsForLockAndInstall();
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        "updater: update failed",
+        expect.objectContaining({ targetDir: expect.any(String) }),
+      );
+    });
+  });
+
+  // ── Lock mechanism ────────────────────────────────────────────────
+
+  describe("lock mechanism", () => {
+    it("acquires and releases lock on success", async () => {
+      mockExecFileSequence([{ stdout: "2.0.0\n" }, { stdout: "" }, { stdout: "" }]);
+      stubFsForLockAndInstall();
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockOpenSync).toHaveBeenCalled();
+      expect(mockWriteSync).toHaveBeenCalledWith(42, expect.any(String));
+      expect(mockCloseSync).toHaveBeenCalled();
+      expect(mockUnlinkSync).toHaveBeenCalled();
+    });
+
+    it("cleans up stale lock before acquiring", async () => {
+      const staleTime = Date.now() - 6 * 60 * 1000;
+      stubFsForLockAndInstall();
+      mockStatSync.mockReset();
+      mockStatSync.mockReturnValue({ mtimeMs: staleTime } as any);
+
+      mockExecFileSequence([{ stdout: "2.0.0\n" }, { stdout: "" }, { stdout: "" }]);
+
+      await checkAndUpdate({}, "1.0.0");
+
+      // Stale cleanup + final release = 2 unlinkSync calls
+      expect(mockUnlinkSync).toHaveBeenCalledTimes(2);
+    });
+
+    it("does not clean fresh lock and acquisition fails", async () => {
+      const freshTime = Date.now() - 1000;
+      mockStatSync.mockReturnValue({ mtimeMs: freshTime } as any);
+      mockOpenSync.mockImplementation(() => {
+        throw Object.assign(new Error("EEXIST"), { code: "EEXIST" });
+      });
+
+      mockExecFileSequence([{ stdout: "2.0.0\n" }]);
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockUnlinkSync).not.toHaveBeenCalled();
+      expect(mockLogDebug).toHaveBeenCalledWith(
+        "updater: lock acquisition failed (another process updating?)",
+      );
+    });
+
+    it("releases lock even on install failure", async () => {
+      mockExecFileSequence([{ stdout: "2.0.0\n" }, { err: new Error("pack failed") }]);
+      stubFsForLockAndInstall();
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockCloseSync).toHaveBeenCalled();
+      expect(mockUnlinkSync).toHaveBeenCalled();
+    });
+  });
+
+  // ── installUpdate error paths ─────────────────────────────────────
+
+  describe("installUpdate", () => {
+    it("handles no tgz found after npm pack", async () => {
+      mockExecFileSequence([{ stdout: "2.0.0\n" }, { stdout: "" }]);
+      stubFsForLockAndInstall({ readdirFiles: ["readme.md", "package.json"] });
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        "updater: no tgz found after npm pack",
+        expect.objectContaining({ tmpDir: "/tmp/cerebro-update-xxx" }),
+      );
+    });
+
+    it("handles tar extraction failure", async () => {
+      mockExecFileSequence([
+        { stdout: "2.0.0\n" },
+        { stdout: "" },
+        { err: new Error("tar failed") },
+      ]);
+      stubFsForLockAndInstall();
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogError).toHaveBeenCalledWith(
+        "updater: install failed",
+        expect.objectContaining({ error: expect.any(String) }),
+      );
+      expect(mockRmSync).toHaveBeenCalledWith("/tmp/cerebro-update-xxx", { recursive: true });
+    });
+
+    it("cleans up temp dir even on failure", async () => {
+      mockExecFileSequence([{ stdout: "2.0.0\n" }, { err: new Error("pack failed") }]);
+      stubFsForLockAndInstall();
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockRmSync).toHaveBeenCalledWith("/tmp/cerebro-update-xxx", { recursive: true });
+    });
+  });
+
+  // ── Version comparison (indirect) ─────────────────────────────────
+
+  describe("version comparison", () => {
+    it("handles v-prefixed versions", async () => {
+      mockExecFileSequence([{ stdout: "v2.0.0\n" }, { stdout: "" }, { stdout: "" }]);
+      stubFsForLockAndInstall();
+
+      await checkAndUpdate({}, "v1.0.0");
+
+      expect(mockLogInfo).toHaveBeenCalledWith(
+        "updater: new version available",
+        expect.objectContaining({ currentVersion: "v1.0.0", latest: "v2.0.0" }),
+      );
+    });
+
+    it("detects patch-level update", async () => {
+      mockExecFileSequence([{ stdout: "1.0.1\n" }, { stdout: "" }, { stdout: "" }]);
+      stubFsForLockAndInstall();
+
+      await checkAndUpdate({}, "1.0.0");
+
+      expect(mockLogInfo).toHaveBeenCalledWith(
+        "updater: new version available",
+        expect.objectContaining({ currentVersion: "1.0.0", latest: "1.0.1" }),
+      );
+    });
+
+    it("detects minor-level update", async () => {
+      mockExecFileSequence([{ stdout: "1.1.0\n" }]);
+
+      await checkAndUpdate({}, "1.0.9");
+
+      expect(mockLogInfo).toHaveBeenCalledWith(
+        "updater: new version available",
+        expect.objectContaining({ currentVersion: "1.0.9", latest: "1.1.0" }),
+      );
+    });
+
+    it("detects major-level update", async () => {
+      mockExecFileSequence([{ stdout: "2.0.0\n" }]);
+
+      await checkAndUpdate({}, "1.99.99");
+
+      expect(mockLogInfo).toHaveBeenCalledWith(
+        "updater: new version available",
+        expect.objectContaining({ currentVersion: "1.99.99", latest: "2.0.0" }),
+      );
+    });
+  });
+});