@mingxy/cerebro 1.20.5 → 1.20.6

package/src/logger.test.ts

@@ -0,0 +1,640 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// ── Mocks (hoisted so they exist before module import) ──────────────────
+
+const {
+  mockAppendFileSync,
+  mockMkdirSync,
+  mockExistsSync,
+  mockStatSync,
+  mockRenameSync,
+  mockReaddirSync,
+  mockUnlinkSync,
+  mockLoadPluginConfig,
+  importTimeUnlinkCalls,
+  importTimeStatCalls,
+} = vi.hoisted(() => {
+  // Capture calls that happen during module import (cleanupOldLogs)
+  const importTimeUnlinkCalls: string[] = [];
+  const importTimeStatCalls: string[] = [];
+
+  return {
+    mockAppendFileSync: vi.fn(),
+    mockMkdirSync: vi.fn(),
+    mockExistsSync: vi.fn<() => boolean>().mockReturnValue(true),
+    mockStatSync: vi.fn().mockImplementation(() => {
+      throw new Error("ENOENT");
+    }),
+    mockRenameSync: vi.fn(),
+    mockReaddirSync: vi.fn<() => string[]>().mockReturnValue([]),
+    mockUnlinkSync: vi.fn((p: string) => {
+      importTimeUnlinkCalls.push(p);
+    }),
+    mockLoadPluginConfig: vi.fn().mockReturnValue({
+      logging: {
+        logEnabled: true,
+        logLevel: "INFO",
+        logDir: "/tmp/test-cerebro-logs",
+      },
+    }),
+    importTimeUnlinkCalls,
+    importTimeStatCalls,
+  };
+});
+
+vi.mock("node:fs", () => ({
+  appendFileSync: mockAppendFileSync,
+  mkdirSync: mockMkdirSync,
+  existsSync: mockExistsSync,
+  statSync: mockStatSync,
+  renameSync: mockRenameSync,
+  readdirSync: mockReaddirSync,
+  unlinkSync: mockUnlinkSync,
+}));
+
+vi.mock("./config.js", () => ({
+  loadPluginConfig: mockLoadPluginConfig,
+}));
+
+const {
+  logInfo,
+  logWarn,
+  logError,
+  logDebug,
+  setOpencodeClient,
+} = await import("./logger.js");
+
+function lastFileWrite(): string {
+  const calls = mockAppendFileSync.mock.calls;
+  if (calls.length === 0) return "";
+  return calls[calls.length - 1][1] as string;
+}
+
+describe("logger", () => {
+  // Cumulative offset ensures each test's fake time is far enough ahead
+  // to expire the previous test's TTL cache (30s). 120s margin is safe.
+  let timeOffset = 0;
+
+  beforeEach(() => {
+    timeOffset += 120_000;
+    vi.useFakeTimers({ now: new Date(Date.now() + timeOffset) });
+
+    mockAppendFileSync.mockReset();
+    mockMkdirSync.mockReset();
+    mockExistsSync.mockReset().mockReturnValue(true);
+    mockStatSync.mockReset().mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+    mockRenameSync.mockReset();
+    mockReaddirSync.mockReset().mockReturnValue([]);
+    mockUnlinkSync.mockReset();
+    mockLoadPluginConfig.mockReset().mockReturnValue({
+      logging: {
+        logEnabled: true,
+        logLevel: "INFO",
+        logDir: "/tmp/test-cerebro-logs",
+      },
+    });
+
+    // Warmup: first log call triggers config refresh (previous cache expired
+    // since we jumped 120s ahead) and resets lastLogTime for delta tests.
+    logInfo("warmup");
+
+    // Reset write-related mocks for clean test state
+    mockAppendFileSync.mockReset();
+    mockMkdirSync.mockReset();
+    mockExistsSync.mockReset().mockReturnValue(true);
+    mockStatSync.mockReset().mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+    mockRenameSync.mockReset();
+  });
+
+  afterEach(() => {
+    setOpencodeClient(null);
+    vi.useRealTimers();
+  });
+
+  // ── Level filtering ────────────────────────────────────────────────
+
+  describe("level filtering", () => {
+    it("writes INFO messages at INFO level", () => {
+      logInfo("hello");
+      expect(mockAppendFileSync).toHaveBeenCalled();
+      expect(lastFileWrite()).toContain("INFO");
+      expect(lastFileWrite()).toContain("hello");
+    });
+
+    it("writes WARN messages at INFO level", () => {
+      logWarn("warning msg");
+      expect(mockAppendFileSync).toHaveBeenCalled();
+      expect(lastFileWrite()).toContain("WARN");
+    });
+
+    it("writes ERROR messages at INFO level", () => {
+      logError("error msg");
+      expect(mockAppendFileSync).toHaveBeenCalled();
+      expect(lastFileWrite()).toContain("ERROR");
+    });
+
+    it("suppresses DEBUG messages at INFO level", () => {
+      logDebug("debug msg");
+      expect(mockAppendFileSync).not.toHaveBeenCalled();
+    });
+
+    it("writes DEBUG messages at DEBUG level", () => {
+      mockLoadPluginConfig.mockReturnValue({
+        logging: { logEnabled: true, logLevel: "DEBUG", logDir: "/tmp/test-logs" },
+      });
+      vi.advanceTimersByTime(31_000);
+      logDebug("debug msg");
+      expect(mockAppendFileSync).toHaveBeenCalled();
+      expect(lastFileWrite()).toContain("DEBUG");
+    });
+
+    it("suppresses INFO messages at WARN level", () => {
+      mockLoadPluginConfig.mockReturnValue({
+        logging: { logEnabled: true, logLevel: "WARN", logDir: "/tmp/test-logs" },
+      });
+      vi.advanceTimersByTime(31_000);
+      logInfo("should be suppressed");
+      expect(mockAppendFileSync).not.toHaveBeenCalled();
+    });
+
+    it("suppresses INFO and DEBUG at ERROR level", () => {
+      mockLoadPluginConfig.mockReturnValue({
+        logging: { logEnabled: true, logLevel: "ERROR", logDir: "/tmp/test-logs" },
+      });
+      vi.advanceTimersByTime(31_000);
+
+      logDebug("debug suppressed");
+      logInfo("info suppressed");
+      logWarn("warn suppressed");
+
+      expect(mockAppendFileSync).not.toHaveBeenCalled();
+
+      logError("error passes");
+      expect(mockAppendFileSync).toHaveBeenCalledTimes(1);
+      expect(lastFileWrite()).toContain("ERROR");
+    });
+
+    it("writes all levels at DEBUG level", () => {
+      mockLoadPluginConfig.mockReturnValue({
+        logging: { logEnabled: true, logLevel: "DEBUG", logDir: "/tmp/test-logs" },
+      });
+      vi.advanceTimersByTime(31_000);
+
+      logDebug("d");
+      logInfo("i");
+      logWarn("w");
+      logError("e");
+
+      expect(mockAppendFileSync).toHaveBeenCalledTimes(4);
+    });
+
+    it("defaults to INFO for unknown log level string", () => {
+      mockLoadPluginConfig.mockReturnValue({
+        logging: { logEnabled: true, logLevel: "VERBOSE" as "DEBUG" | "INFO" | "WARN" | "ERROR", logDir: "/tmp/test-logs" },
+      });
+      vi.advanceTimersByTime(31_000);
+
+      logInfo("passes at default INFO");
+      expect(mockAppendFileSync).toHaveBeenCalled();
+
+      mockAppendFileSync.mockClear();
+      logDebug("suppressed at default INFO");
+      expect(mockAppendFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── Log disabled ──────────────────────────────────────────────────
+
+  describe("log disabled", () => {
+    it("does not write when logEnabled=false", () => {
+      mockLoadPluginConfig.mockReturnValue({
+        logging: { logEnabled: false, logLevel: "INFO", logDir: "/tmp/test-logs" },
+      });
+      vi.advanceTimersByTime(31_000);
+      logError("should not appear");
+      expect(mockAppendFileSync).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── Log format ────────────────────────────────────────────────────
+
+  describe("log format", () => {
+    it("includes level, timestamp, delta, service=cerebro, and message", () => {
+      logInfo("test message");
+      const line = lastFileWrite();
+      expect(line).toMatch(/^INFO  /);
+      expect(line).toMatch(/\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/);
+      expect(line).toMatch(/\+[\d.]+s/);
+      expect(line).toContain("service=cerebro");
+      expect(line).toContain("test message");
+      expect(line).toMatch(/\n$/);
+    });
+
+    it("includes field key=value pairs", () => {
+      logInfo("msg", { key1: "val1", count: 42 });
+      const line = lastFileWrite();
+      expect(line).toContain("key1=val1");
+      expect(line).toContain("count=42");
+    });
+
+    it("JSON-stringifies non-string field values", () => {
+      logInfo("msg", { obj: { a: 1 } });
+      const line = lastFileWrite();
+      expect(line).toContain('obj={"a":1}');
+    });
+
+    it("pads level to 5 characters", () => {
+      logInfo("pad test");
+      expect(lastFileWrite()).toMatch(/^INFO  /);
+
+      logWarn("warn pad");
+      expect(lastFileWrite()).toMatch(/^WARN  /);
+
+      logError("error pad");
+      expect(lastFileWrite()).toMatch(/^ERROR /);
+    });
+  });
+
+  // ── Log file path ─────────────────────────────────────────────────
+
+  describe("log file path", () => {
+    it("uses cerebro.log by default", () => {
+      logInfo("default path");
+      const filePath = mockAppendFileSync.mock.calls[0][0] as string;
+      expect(filePath).toMatch(/cerebro\.log$/);
+    });
+
+    it("uses cerebro-{sessionId}.log when sessionId is provided in fields", () => {
+      logInfo("session log", { sessionId: "abc-123" });
+      const filePath = mockAppendFileSync.mock.calls[0][0] as string;
+      expect(filePath).toMatch(/cerebro-abc-123\.log$/);
+    });
+
+    it("recognizes sessionID (uppercase D) field", () => {
+      logInfo("alt session field", { sessionID: "xyz-789" });
+      const filePath = mockAppendFileSync.mock.calls[0][0] as string;
+      expect(filePath).toMatch(/cerebro-xyz-789\.log$/);
+    });
+  });
+
+  // ── Log rotation ──────────────────────────────────────────────────
+
+  describe("log rotation", () => {
+    it("renames file when size > 5MB", () => {
+      mockStatSync.mockReturnValue({ size: 6 * 1024 * 1024 });
+      logInfo("trigger rotation");
+      expect(mockRenameSync).toHaveBeenCalled();
+      const [oldPath, newPath] = mockRenameSync.mock.calls[0];
+      expect(oldPath).toMatch(/cerebro\.log$/);
+      expect(newPath).toMatch(/cerebro\.old\.log$/);
+    });
+
+    it("does not rename when file is under 5MB", () => {
+      mockStatSync.mockReturnValue({ size: 4 * 1024 * 1024 });
+      logInfo("no rotation");
+      expect(mockRenameSync).not.toHaveBeenCalled();
+    });
+
+    it("handles statSync throwing (file not found) gracefully", () => {
+      mockStatSync.mockImplementation(() => {
+        throw new Error("ENOENT");
+      });
+      expect(() => logInfo("first write")).not.toThrow();
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+
+    it("rotation happens before file write", () => {
+      mockStatSync.mockReturnValue({ size: 6 * 1024 * 1024 });
+      logInfo("rotation order test");
+      expect(mockRenameSync).toHaveBeenCalled();
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+  });
+
+  // ── Directory creation ────────────────────────────────────────────
+
+  describe("directory creation", () => {
+    it("creates log directory if it does not exist", () => {
+      mockExistsSync.mockReturnValue(false);
+      logInfo("ensure dir");
+      expect(mockMkdirSync).toHaveBeenCalledWith(
+        expect.any(String),
+        { recursive: true },
+      );
+    });
+
+    it("skips mkdir when directory exists", () => {
+      mockExistsSync.mockReturnValue(true);
+      logInfo("dir exists");
+      expect(mockMkdirSync).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── Dual-track: opencodeClient ────────────────────────────────────
+
+  describe("dual-track logging (opencodeClient)", () => {
+    it("calls opencodeClient.app.log() when client is set", () => {
+      const mockLog = vi.fn(() => ({ catch: vi.fn() }));
+      const client = { app: { log: mockLog } };
+      setOpencodeClient(client);
+
+      logInfo("dual track");
+
+      expect(mockLog).toHaveBeenCalledWith({
+        body: {
+          service: "cerebro",
+          level: "info",
+          message: "dual track",
+          extra: undefined,
+        },
+      });
+    });
+
+    it("passes fields as extra to opencodeClient", () => {
+      const mockLog = vi.fn(() => ({ catch: vi.fn() }));
+      const client = { app: { log: mockLog } };
+      setOpencodeClient(client);
+
+      const fields = { foo: "bar" };
+      logWarn("with fields", fields);
+
+      expect(mockLog).toHaveBeenCalledWith({
+        body: {
+          service: "cerebro",
+          level: "warn",
+          message: "with fields",
+          extra: fields,
+        },
+      });
+    });
+
+    it("uses lowercase level for opencodeClient", () => {
+      const mockLog = vi.fn(() => ({ catch: vi.fn() }));
+      const client = { app: { log: mockLog } };
+      setOpencodeClient(client);
+
+      logError("error test");
+      const call = mockLog.mock.calls[0][0];
+      expect(call.body.level).toBe("error");
+    });
+
+    it("does not crash when opencodeClient throws", () => {
+      const badClient = {
+        app: {
+          log: vi.fn(() => {
+            throw new Error("client broken");
+          }),
+        },
+      };
+      setOpencodeClient(badClient);
+
+      expect(() => logInfo("safe")).not.toThrow();
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+
+    it("does not crash when opencodeClient is null", () => {
+      setOpencodeClient(null);
+      expect(() => logInfo("no client")).not.toThrow();
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+  });
+
+  // ── setOpencodeClient ─────────────────────────────────────────────
+
+  describe("setOpencodeClient", () => {
+    it("stores the client reference for subsequent log calls", () => {
+      const mockLog = vi.fn(() => ({ catch: vi.fn() }));
+      const client = { app: { log: mockLog } };
+      setOpencodeClient(client);
+
+      logInfo("verify stored");
+      expect(mockLog).toHaveBeenCalled();
+    });
+
+    it("can be replaced with a different client", () => {
+      const mockLog1 = vi.fn(() => ({ catch: vi.fn() }));
+      const client1 = { app: { log: mockLog1 } };
+      setOpencodeClient(client1);
+      logInfo("first client");
+
+      const mockLog2 = vi.fn(() => ({ catch: vi.fn() }));
+      const client2 = { app: { log: mockLog2 } };
+      setOpencodeClient(client2);
+      logInfo("second client");
+
+      expect(mockLog1).toHaveBeenCalledTimes(1);
+      expect(mockLog2).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  // ── opencodeClient .catch() rejection prevention ──────────────────
+
+  describe("opencodeClient .catch() rejection prevention", () => {
+    it("calls .catch() on the returned promise-like object", () => {
+      const mockCatch = vi.fn();
+      const mockLog = vi.fn(() => ({ catch: mockCatch }));
+      const client = { app: { log: mockLog } };
+      setOpencodeClient(client);
+
+      logInfo("verify catch");
+
+      expect(mockCatch).toHaveBeenCalledTimes(1);
+    });
+
+    it("handles app.log() returning undefined (no promise)", () => {
+      const mockLog = vi.fn(() => undefined);
+      const client = { app: { log: mockLog } };
+      setOpencodeClient(client);
+
+      expect(() => logInfo("no promise")).not.toThrow();
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+
+    it("handles client with no app property", () => {
+      setOpencodeClient({});
+
+      expect(() => logInfo("no app")).not.toThrow();
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+
+    it("handles client with app.log not being a function", () => {
+      setOpencodeClient({ app: { log: "not a function" } });
+
+      expect(() => logInfo("bad log")).not.toThrow();
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+  });
+
+  // ── TTL config cache (30-second) ────────────────────────────────
+
+  describe("TTL config cache (30-second)", () => {
+    it("caches config within TTL window", () => {
+      logInfo("call 1");
+      expect(mockLoadPluginConfig).toHaveBeenCalledTimes(1);
+      logInfo("call 2");
+      expect(mockLoadPluginConfig).toHaveBeenCalledTimes(1);
+    });
+
+    it("refreshes config after TTL expires", () => {
+      logInfo("cached call");
+      expect(mockLoadPluginConfig).toHaveBeenCalledTimes(1);
+
+      vi.advanceTimersByTime(31_000);
+
+      logInfo("refreshed call");
+      expect(mockLoadPluginConfig).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  // ── Startup cleanup (7-day) ────────────────────────────────────────
+  // cleanupOldLogs() runs only once at module load. We test it by
+  // re-importing the module with vi.resetModules().
+
+  describe("startup cleanup (delete old logs)", () => {
+    it("deletes .log files older than 7 days on import", async () => {
+      const cutoffTime = Date.now() - 8 * 24 * 60 * 60 * 1000;
+
+      // Set up mocks for re-import
+      mockReaddirSync.mockReturnValue(["old.log", "recent.log"]);
+      mockStatSync.mockImplementation((fp: string) => {
+        if (fp.endsWith("old.log")) return { size: 100, mtimeMs: cutoffTime };
+        return { size: 100, mtimeMs: Date.now() };
+      });
+
+      vi.resetModules();
+      await import("./logger.js");
+
+      expect(mockUnlinkSync).toHaveBeenCalled();
+      const deletedPaths = mockUnlinkSync.mock.calls.map((c: unknown[]) => c[0] as string);
+      expect(deletedPaths.some((p: string) => p.endsWith("old.log"))).toBe(true);
+    });
+
+    it("deletes .old.log files older than 7 days on import", async () => {
+      const cutoffTime = Date.now() - 10 * 24 * 60 * 60 * 1000;
+
+      mockReaddirSync.mockReturnValue(["rotated.old.log"]);
+      mockStatSync.mockReturnValue({ size: 100, mtimeMs: cutoffTime });
+
+      vi.resetModules();
+      await import("./logger.js");
+
+      expect(mockUnlinkSync).toHaveBeenCalled();
+      const deletedPaths = mockUnlinkSync.mock.calls.map((c: unknown[]) => c[0] as string);
+      expect(deletedPaths.some((p: string) => p.endsWith("rotated.old.log"))).toBe(true);
+    });
+
+    it("keeps files newer than 7 days", async () => {
+      mockReaddirSync.mockReturnValue(["fresh.log"]);
+      mockStatSync.mockReturnValue({ size: 100, mtimeMs: Date.now() - 1 * 24 * 60 * 60 * 1000 });
+
+      vi.resetModules();
+      await import("./logger.js");
+
+      expect(mockUnlinkSync).not.toHaveBeenCalled();
+    });
+
+    it("skips non-log files during cleanup", async () => {
+      mockReaddirSync.mockReturnValue(["readme.txt", "data.json"]);
+
+      vi.resetModules();
+      await import("./logger.js");
+
+      // statSync should NOT be called for non-log files
+      const statCalls = mockStatSync.mock.calls.map((c: unknown[]) => c[0] as string);
+      expect(statCalls.every((p: string) => !p.endsWith(".txt") && !p.endsWith(".json"))).toBe(true);
+    });
+
+    it("handles readdirSync throwing gracefully", async () => {
+      mockReaddirSync.mockImplementation(() => {
+        throw new Error("ENOENT");
+      });
+
+      vi.resetModules();
+      // Should not throw — module import succeeds
+      await expect(import("./logger.js")).resolves.toBeDefined();
+    });
+
+    it("handles statSync throwing for individual files gracefully", async () => {
+      mockReaddirSync.mockReturnValue(["broken.log"]);
+      mockStatSync.mockImplementation(() => {
+        throw new Error("permission denied");
+      });
+
+      vi.resetModules();
+      await expect(import("./logger.js")).resolves.toBeDefined();
+      // Should NOT delete since we couldn't stat
+      expect(mockUnlinkSync).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── Delta tracking ───────────────────────────────────────────────
+
+  describe("delta tracking", () => {
+    it("shows increasing delta between log calls", () => {
+      logInfo("first");
+      const line1 = lastFileWrite();
+
+      vi.advanceTimersByTime(1500);
+
+      logInfo("second");
+      const line2 = lastFileWrite();
+
+      const delta1 = parseFloat(line1.match(/\+([\d.]+)s/)![1]);
+      const delta2 = parseFloat(line2.match(/\+([\d.]+)s/)![1]);
+      expect(delta2).toBeGreaterThanOrEqual(delta1 + 1.4);
+    });
+
+    it("first log after warmup shows near-zero delta", () => {
+      logInfo("first");
+      const line = lastFileWrite();
+      const delta = parseFloat(line.match(/\+([\d.]+)s/)![1]);
+      expect(delta).toBeLessThan(0.1);
+    });
+  });
+
+  // ── Edge cases ────────────────────────────────────────────────────
+
+  describe("edge cases", () => {
+    it("handles appendFileSync throwing gracefully", () => {
+      mockAppendFileSync.mockImplementation(() => {
+        throw new Error("disk full");
+      });
+      expect(() => logInfo("safe")).not.toThrow();
+    });
+
+    it("handles fields being undefined", () => {
+      logInfo("no fields", undefined);
+      expect(mockAppendFileSync).toHaveBeenCalled();
+      const line = lastFileWrite();
+      expect(line).toContain("no fields");
+    });
+
+    it("handles empty fields object", () => {
+      logInfo("empty fields", {});
+      expect(mockAppendFileSync).toHaveBeenCalled();
+    });
+
+    it("handles mkdirSync throwing gracefully", () => {
+      mockExistsSync.mockReturnValue(false);
+      mockMkdirSync.mockImplementation(() => {
+        throw new Error("permission denied");
+      });
+      expect(() => logInfo("mkdir fails")).not.toThrow();
+    });
+
+    it("writes to correct logDir from config after TTL expiry", () => {
+      mockLoadPluginConfig.mockReturnValue({
+        logging: { logEnabled: true, logLevel: "INFO", logDir: "/custom/log/path" },
+      });
+      vi.advanceTimersByTime(31_000);
+
+      logInfo("custom dir");
+      const filePath = mockAppendFileSync.mock.calls[0][0] as string;
+      expect(filePath).toContain("/custom/log/path/cerebro.log");
+    });
+  });
+});