llm-mock-server 1.0.1 → 1.0.3

package/test/logger.test.ts

@@ -0,0 +1,344 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { Logger, LEVEL_PRIORITY } from "../src/logger.js";
+import type { LogLevel } from "../src/logger.js";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("LEVEL_PRIORITY", () => {
+  it("has the expected keys and ascending values", () => {
+    expect(LEVEL_PRIORITY).toEqual({
+      none: 0,
+      error: 1,
+      warning: 2,
+      info: 3,
+      debug: 4,
+      all: 5,
+    });
+  });
+
+  it("is ordered so that each named level is strictly higher than the previous", () => {
+    expect(LEVEL_PRIORITY.none).toBeLessThan(LEVEL_PRIORITY.error);
+    expect(LEVEL_PRIORITY.error).toBeLessThan(LEVEL_PRIORITY.warning);
+    expect(LEVEL_PRIORITY.warning).toBeLessThan(LEVEL_PRIORITY.info);
+    expect(LEVEL_PRIORITY.info).toBeLessThan(LEVEL_PRIORITY.debug);
+    expect(LEVEL_PRIORITY.debug).toBeLessThan(LEVEL_PRIORITY.all);
+  });
+});
+
+describe("Logger", () => {
+  describe("constructor", () => {
+    it("defaults to 'info' level when no argument is provided", () => {
+      const logger = new Logger();
+      expect(logger.level).toBe("info");
+    });
+
+    it("accepts an explicit level", () => {
+      const logger = new Logger("debug");
+      expect(logger.level).toBe("debug");
+    });
+
+    it("level property is readonly and accessible", () => {
+      const logger = new Logger("warning");
+      expect(logger.level).toBe("warning");
+    });
+  });
+
+  describe("error()", () => {
+    it("logs to console.error when level is 'error'", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const logger = new Logger("error");
+      logger.error("something broke");
+      expect(spy).toHaveBeenCalledOnce();
+      expect(spy.mock.calls[0]![0]).toContain("something broke");
+    });
+
+    it("logs to console.error when level is 'info' (threshold above error)", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const logger = new Logger("info");
+      logger.error("boom");
+      expect(spy).toHaveBeenCalledOnce();
+    });
+
+    it("logs to console.error when level is 'all'", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const logger = new Logger("all");
+      logger.error("critical");
+      expect(spy).toHaveBeenCalledOnce();
+    });
+
+    it("is silent when level is 'none'", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const logger = new Logger("none");
+      logger.error("should not appear");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("passes extra arguments through to console.error", () => {
+      const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const logger = new Logger("error");
+      const extra = { code: 500 };
+      logger.error("fail", extra);
+      expect(spy).toHaveBeenCalledOnce();
+      expect(spy.mock.calls[0]).toContain(extra);
+    });
+  });
+
+  describe("warn()", () => {
+    it("logs to console.warn when level is 'warning'", () => {
+      const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const logger = new Logger("warning");
+      logger.warn("heads up");
+      expect(spy).toHaveBeenCalledOnce();
+      expect(spy.mock.calls[0]![0]).toContain("heads up");
+    });
+
+    it("logs to console.warn when level is 'info' (threshold above warning)", () => {
+      const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const logger = new Logger("info");
+      logger.warn("watch out");
+      expect(spy).toHaveBeenCalledOnce();
+    });
+
+    it("logs to console.warn when level is 'debug'", () => {
+      const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const logger = new Logger("debug");
+      logger.warn("careful");
+      expect(spy).toHaveBeenCalledOnce();
+    });
+
+    it("is silent when level is 'error' (threshold below warning)", () => {
+      const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const logger = new Logger("error");
+      logger.warn("should not appear");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("is silent when level is 'none'", () => {
+      const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const logger = new Logger("none");
+      logger.warn("nope");
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("info()", () => {
+    it("logs to console.log when level is 'info'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("info");
+      logger.info("status update");
+      expect(spy).toHaveBeenCalledOnce();
+      expect(spy.mock.calls[0]![0]).toContain("status update");
+    });
+
+    it("logs to console.log when level is 'debug' (threshold above info)", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("debug");
+      logger.info("still visible");
+      expect(spy).toHaveBeenCalledOnce();
+    });
+
+    it("logs to console.log when level is 'all'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("all");
+      logger.info("everything mode");
+      expect(spy).toHaveBeenCalledOnce();
+    });
+
+    it("is silent when level is 'warning' (threshold below info)", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("warning");
+      logger.info("should not appear");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("is silent when level is 'error'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("error");
+      logger.info("nope");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("is silent when level is 'none'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("none");
+      logger.info("nothing");
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("debug()", () => {
+    it("logs to console.log when level is 'debug'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("debug");
+      logger.debug("trace data");
+      expect(spy).toHaveBeenCalledOnce();
+      expect(spy.mock.calls[0]![0]).toContain("trace data");
+    });
+
+    it("logs to console.log when level is 'all'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("all");
+      logger.debug("everything");
+      expect(spy).toHaveBeenCalledOnce();
+    });
+
+    it("is silent when level is 'info' (threshold below debug)", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("info");
+      logger.debug("should not appear");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("is silent when level is 'warning'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("warning");
+      logger.debug("nope");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("is silent when level is 'error'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("error");
+      logger.debug("nope");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("is silent when level is 'none'", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("none");
+      logger.debug("nothing");
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it("passes extra arguments through to console.log", () => {
+      const spy = vi.spyOn(console, "log").mockImplementation(() => {});
+      const logger = new Logger("debug");
+      const obj = { detail: true };
+      logger.debug("check", obj);
+      expect(spy).toHaveBeenCalledOnce();
+      expect(spy.mock.calls[0]).toContain(obj);
+    });
+  });
+
+  describe("all methods silent at level 'none'", () => {
+    it("produces no output for any method", () => {
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+      const logger = new Logger("none");
+      logger.error("e");
+      logger.warn("w");
+      logger.info("i");
+      logger.debug("d");
+
+      expect(errorSpy).not.toHaveBeenCalled();
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(logSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("all methods active at level 'all'", () => {
+    it("produces output for every method", () => {
+      const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+      const logger = new Logger("all");
+      logger.error("e");
+      logger.warn("w");
+      logger.info("i");
+      logger.debug("d");
+
+      expect(errorSpy).toHaveBeenCalledOnce();
+      expect(warnSpy).toHaveBeenCalledOnce();
+      // Info and debug both use console.log
+      expect(logSpy).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("each level as constructor argument", () => {
+    const cases: Array<{
+      level: LogLevel;
+      expectError: boolean;
+      expectWarn: boolean;
+      expectInfo: boolean;
+      expectDebug: boolean;
+    }> = [
+      {
+        level: "none",
+        expectError: false,
+        expectWarn: false,
+        expectInfo: false,
+        expectDebug: false,
+      },
+      {
+        level: "error",
+        expectError: true,
+        expectWarn: false,
+        expectInfo: false,
+        expectDebug: false,
+      },
+      {
+        level: "warning",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: false,
+        expectDebug: false,
+      },
+      {
+        level: "info",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: true,
+        expectDebug: false,
+      },
+      {
+        level: "debug",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: true,
+        expectDebug: true,
+      },
+      {
+        level: "all",
+        expectError: true,
+        expectWarn: true,
+        expectInfo: true,
+        expectDebug: true,
+      },
+    ];
+
+    for (const {
+      level,
+      expectError,
+      expectWarn,
+      expectInfo,
+      expectDebug,
+    } of cases) {
+      it(`level '${level}' enables the correct methods`, () => {
+        const errorSpy = vi
+          .spyOn(console, "error")
+          .mockImplementation(() => {});
+        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+        const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+        const logger = new Logger(level);
+        logger.error("e");
+        logger.warn("w");
+        logger.info("i");
+        logger.debug("d");
+
+        expect(errorSpy).toHaveBeenCalledTimes(expectError ? 1 : 0);
+        expect(warnSpy).toHaveBeenCalledTimes(expectWarn ? 1 : 0);
+
+        let expectedLogCalls = 0;
+        if (expectInfo) expectedLogCalls++;
+        if (expectDebug) expectedLogCalls++;
+        expect(logSpy).toHaveBeenCalledTimes(expectedLogCalls);
+      });
+    }
+  });
+});

package/test/mock-server.test.ts

@@ -2,7 +2,10 @@ import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { createMock, MockServer } from "../src/index.js";
 
 interface OpenAIResponse {
-  choices: { message: { role: string; content: string }; finish_reason: string }[];
+  choices: {
+    message: { role: string; content: string };
+    finish_reason: string;
+  }[];
   error?: { type: string; message: string };
 }
 
@@ -34,7 +37,10 @@ describe("MockServer (end-to-end)", () => {
     });
   }
 
-  async function postOpenAI(content: string, opts: Record<string, unknown> = {}): Promise<OpenAIResponse> {
+  async function postOpenAI(
+    content: string,
+    opts: Record<string, unknown> = {},
+  ): Promise<OpenAIResponse> {
     const res = await post("/v1/chat/completions", {
       model: "gpt-5.4",
       messages: [{ role: "user", content }],
@@ -44,7 +50,10 @@ describe("MockServer (end-to-end)", () => {
     return res.json() as Promise<OpenAIResponse>;
   }
 
-  async function postAnthropic(content: string, opts: Record<string, unknown> = {}): Promise<AnthropicResponse> {
+  async function postAnthropic(
+    content: string,
+    opts: Record<string, unknown> = {},
+  ): Promise<AnthropicResponse> {
     const res = await post("/v1/messages", {
       model: "claude-sonnet-4-6",
       messages: [{ role: "user", content }],
@@ -55,7 +64,10 @@ describe("MockServer (end-to-end)", () => {
     return res.json() as Promise<AnthropicResponse>;
   }
 
-  async function postResponses(input: string, opts: Record<string, unknown> = {}): Promise<ResponsesAPIResponse> {
+  async function postResponses(
+    input: string,
+    opts: Record<string, unknown> = {},
+  ): Promise<ResponsesAPIResponse> {
     const res = await post("/v1/responses", {
       model: "codex-mini",
       input,
@@ -216,7 +228,10 @@ describe("MockServer (end-to-end)", () => {
       server.when("hello").reply("Hi!");
       await fetch(`${server.url}/v1/chat/completions`, {
         method: "POST",
-        headers: { "Content-Type": "application/json", "X-Custom": "test-value" },
+        headers: {
+          "Content-Type": "application/json",
+          "X-Custom": "test-value",
+        },
         body: JSON.stringify({
           model: "gpt-5.4",
           messages: [{ role: "user", content: "hello" }],
@@ -232,7 +247,9 @@ describe("MockServer (end-to-end)", () => {
 
   describe("request metadata in predicates", () => {
     it("matches on headers", async () => {
-      server.when({ predicate: (req) => req.headers["x-team"] === "alpha" }).reply("Alpha team!");
+      server
+        .when({ predicate: (req) => req.headers["x-team"] === "alpha" })
+        .reply("Alpha team!");
       server.when("hello").reply("Default");
 
       const res = await fetch(`${server.url}/v1/chat/completions`, {
@@ -288,10 +305,12 @@ describe("MockServer (end-to-end)", () => {
     });
 
     it("supports per-step options", async () => {
-      server.when("step").replySequence([
-        "Plain.",
-        { reply: { text: "With options." }, options: { chunkSize: 5 } },
-      ]);
+      server
+        .when("step")
+        .replySequence([
+          "Plain.",
+          { reply: { text: "With options." }, options: { chunkSize: 5 } },
+        ]);
 
       const json = await postOpenAI("step");
       expect(json.choices[0]!.message.content).toBe("Plain.");
@@ -299,7 +318,7 @@ describe("MockServer (end-to-end)", () => {
 
     it("throws on empty sequence", () => {
       expect(() => server.when("step").replySequence([])).toThrow(
-        "replySequence requires at least one entry",
+        "Sequence requires at least one entry",
       );
     });
   });
@@ -407,7 +426,9 @@ describe("MockServer (end-to-end)", () => {
     });
 
     it("error reply works as a normal rule", async () => {
-      server.when("fail").reply({ error: { status: 500, message: "Internal error" } });
+      server
+        .when("fail")
+        .reply({ error: { status: 500, message: "Internal error" } });
       server.when("hello").reply("Hi!");
 
       const r1 = await post("/v1/chat/completions", {
@@ -437,11 +458,13 @@ describe("MockServer (end-to-end)", () => {
       const contentDeltas = data
         .filter((d) => d !== "[DONE]")
         .map((d) => JSON.parse(d))
-        .filter((d: { choices?: { delta?: { content?: string } }[] }) =>
-          d.choices?.[0]?.delta?.content !== undefined,
+        .filter(
+          (d: { choices?: { delta?: { content?: string } }[] }) =>
+            d.choices?.[0]?.delta?.content !== undefined,
         )
-        .map((d: { choices: { delta: { content: string } }[] }) =>
-          d.choices[0]!.delta.content,
+        .map(
+          (d: { choices: { delta: { content: string } }[] }) =>
+            d.choices[0]!.delta.content,
         );
       expect(contentDeltas.length).toBe(3);
       expect(contentDeltas.join("")).toBe("Hello, world!");
@@ -454,7 +477,12 @@ describe("MockServer (end-to-end)", () => {
       server.fallback("No match.");
 
       const j1 = await postOpenAI("what's the weather?", {
-        tools: [{ type: "function", function: { name: "get_weather", parameters: {} } }],
+        tools: [
+          {
+            type: "function",
+            function: { name: "get_weather", parameters: {} },
+          },
+        ],
       });
       expect(j1.choices[0]!.message.content).toBe("Weather tool detected!");
 
@@ -471,7 +499,17 @@ describe("MockServer (end-to-end)", () => {
       const json = await postOpenAI("use the tool", {
         messages: [
           { role: "user", content: "use the tool" },
-          { role: "assistant", content: null, tool_calls: [{ id: "call_abc", type: "function", function: { name: "test", arguments: "{}" } }] },
+          {
+            role: "assistant",
+            content: null,
+            tool_calls: [
+              {
+                id: "call_abc",
+                type: "function",
+                function: { name: "test", arguments: "{}" },
+              },
+            ],
+          },
           { role: "tool", tool_call_id: "call_abc", content: "result data" },
         ],
       });
@@ -505,7 +543,9 @@ describe("MockServer (end-to-end)", () => {
 
   describe("resolver error handling", () => {
     it("falls back when resolver throws", async () => {
-      server.when("boom").reply(() => { throw new Error("resolver failed"); });
+      server.when("boom").reply(() => {
+        throw new Error("resolver failed");
+      });
       server.fallback("Safe fallback.");
 
       const json = await postOpenAI("boom");
@@ -530,20 +570,34 @@ describe("MockServer (end-to-end)", () => {
       await fetch(`${s.url}/v1/chat/completions`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ model: "gpt-5.4", messages: [{ role: "user", content: "test" }], stream: false }),
+        body: JSON.stringify({
+          model: "gpt-5.4",
+          messages: [{ role: "user", content: "test" }],
+          stream: false,
+        }),
       });
 
       await fetch(`${s.url}/v1/chat/completions`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ model: "gpt-5.4", messages: [{ role: "user", content: "unmatched" }], stream: false }),
+        body: JSON.stringify({
+          model: "gpt-5.4",
+          messages: [{ role: "user", content: "unmatched" }],
+          stream: false,
+        }),
       });
 
-      s.when("throw").reply(() => { throw new Error("boom"); });
+      s.when("throw").reply(() => {
+        throw new Error("boom");
+      });
       await fetch(`${s.url}/v1/chat/completions`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ model: "gpt-5.4", messages: [{ role: "user", content: "throw" }], stream: false }),
+        body: JSON.stringify({
+          model: "gpt-5.4",
+          messages: [{ role: "user", content: "throw" }],
+          stream: false,
+        }),
       });
 
       await s.stop();