pi-soly 1.9.3 → 1.11.0

package/mcp/__tests__/logger.upstream-test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { logger, type LogEntry, type LogLevel } from "../logger.ts";
+
+describe("Logger", () => {
+  beforeEach(() => {
+    vi.spyOn(console, "debug").mockImplementation(() => undefined);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "warn").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+
+    logger.clearHandlers();
+    logger.setLevel("debug"); // Enable all levels for testing
+    logger.setDefaultContext({});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("log levels", () => {
+    it("respects minimum log level", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+
+      logger.setLevel("warn");
+      logger.debug("debug message");
+      logger.info("info message");
+      logger.warn("warn message");
+      logger.error("error message");
+
+      expect(entries).toHaveLength(2);
+      expect(entries[0].level).toBe("warn");
+      expect(entries[1].level).toBe("error");
+    });
+
+    it("logs all levels when set to debug", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+
+      logger.setLevel("debug");
+      logger.debug("d");
+      logger.info("i");
+      logger.warn("w");
+      logger.error("e");
+
+      expect(entries).toHaveLength(4);
+    });
+  });
+
+  describe("context", () => {
+    it("includes context in log entries", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+
+      logger.info("test", { server: "test-server", tool: "test-tool" });
+
+      expect(entries[0].context).toEqual({
+        server: "test-server",
+        tool: "test-tool",
+      });
+    });
+
+    it("merges default context with call context", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+      logger.setDefaultContext({ server: "default-server" });
+
+      logger.info("test", { tool: "my-tool" });
+
+      expect(entries[0].context).toEqual({
+        server: "default-server",
+        tool: "my-tool",
+      });
+    });
+
+    it("call context overrides default context", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+      logger.setDefaultContext({ server: "default-server" });
+
+      logger.info("test", { server: "override-server" });
+
+      expect(entries[0].context?.server).toBe("override-server");
+    });
+  });
+
+  describe("child logger", () => {
+    it("inherits parent context", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+
+      const child = logger.child({ server: "child-server" });
+      child.info("child message");
+
+      expect(entries[0].context?.server).toBe("child-server");
+    });
+
+    it("can add additional context", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+
+      const child = logger.child({ server: "child-server" });
+      child.info("message", { tool: "child-tool" });
+
+      expect(entries[0].context).toEqual({
+        server: "child-server",
+        tool: "child-tool",
+      });
+    });
+
+    it("can create nested children", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+
+      const child1 = logger.child({ server: "server" });
+      const child2 = child1.child({ session: "session123" });
+      child2.info("nested message");
+
+      expect(entries[0].context).toEqual({
+        server: "server",
+        session: "session123",
+      });
+    });
+  });
+
+  describe("error logging", () => {
+    it("includes error object", () => {
+      const entries: LogEntry[] = [];
+      logger.addHandler((entry) => entries.push(entry));
+
+      const error = new Error("test error");
+      logger.error("something failed", error, { server: "test" });
+
+      expect(entries[0].error).toBe(error);
+      expect(entries[0].message).toBe("something failed");
+    });
+  });
+
+  describe("handlers", () => {
+    it("calls all registered handlers", () => {
+      const handler1 = vi.fn();
+      const handler2 = vi.fn();
+      logger.addHandler(handler1);
+      logger.addHandler(handler2);
+
+      logger.info("test");
+
+      expect(handler1).toHaveBeenCalledTimes(1);
+      expect(handler2).toHaveBeenCalledTimes(1);
+    });
+
+    it("ignores handler errors", () => {
+      const badHandler = vi.fn().mockImplementation(() => {
+        throw new Error("handler error");
+      });
+      const goodHandler = vi.fn();
+      logger.addHandler(badHandler);
+      logger.addHandler(goodHandler);
+
+      // Should not throw
+      expect(() => logger.info("test")).not.toThrow();
+      expect(goodHandler).toHaveBeenCalled();
+    });
+
+    it("clearHandlers removes all handlers", () => {
+      const handler = vi.fn();
+      logger.addHandler(handler);
+      logger.clearHandlers();
+
+      logger.info("test");
+
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+});