llm-mock-server 1.0.0 → 1.0.2

package/test/loader.test.ts

@@ -4,26 +4,10 @@ import { join } from "node:path";
 import { RuleEngine } from "../src/rule-engine.js";
 import { loadRulesFromPath } from "../src/loader.js";
 import type { MockRequest } from "../src/types.js";
+import { makeReq } from "./helpers/make-req.js";
 
 const tmpDir = join(import.meta.dirname, ".tmp-loader-test");
 
-function makeReq(overrides: Partial<MockRequest> = {}): MockRequest {
-  return {
-    format: "openai",
-    model: "gpt-5.4",
-    streaming: true,
-    messages: [{ role: "user", content: "hello" }],
-    lastMessage: "hello",
-    systemMessage: "",
-    toolNames: [],
-    lastToolCallId: undefined,
-    raw: {},
-    headers: {},
-    path: "/v1/chat/completions",
-    ...overrides,
-  };
-}
-
 describe("Loader", () => {
   let engine: RuleEngine;
 
@@ -57,8 +41,8 @@ describe("Loader", () => {
       expect(engine.ruleCount).toBe(2);
 
       const match1 = engine.match(makeReq({ lastMessage: "Please explain recursion" }));
-      expect(match1).toBeDefined();
-      expect(match1!.resolve).toBe("A function that calls itself.");
+      if (!match1) throw new Error("expected match for 'explain'");
+      expect(match1.resolve).toBe("A function that calls itself.");
 
       const match2 = engine.match(makeReq({ model: "gpt-5.4", lastMessage: "hello" }));
       expect(match2).toBeDefined();
@@ -154,12 +138,12 @@ describe("Loader", () => {
 
       const req = makeReq({ lastMessage: "step" });
       const match1 = engine.match(req);
-      expect(match1).toBeDefined();
-      expect((match1!.resolve as () => string)()).toBe("First.");
+      if (!match1) throw new Error("expected match1");
+      expect((match1.resolve as () => string)()).toBe("First.");
 
       const match2 = engine.match(req);
-      expect(match2).toBeDefined();
-      expect((match2!.resolve as () => string)()).toBe("Second.");
+      if (!match2) throw new Error("expected match2");
+      expect((match2.resolve as () => string)()).toBe("Second.");
 
       expect(engine.match(req)).toBeUndefined();
     });
@@ -200,8 +184,8 @@ describe("Loader", () => {
       expect(engine.ruleCount).toBe(1);
 
       const match = engine.match(makeReq({ lastMessage: "summarize this article" }));
-      expect(match).toBeDefined();
-      expect(match!.resolve).toBeTypeOf("function");
+      if (!match) throw new Error("expected match for 'summarize'");
+      expect(match.resolve).toBeTypeOf("function");
     });
 
     it("loads an array of handlers from a .ts file", async () => {
@@ -240,9 +224,9 @@ describe("Loader", () => {
 
       await loadRulesFromPath(handlerPath, { engine });
       const rule = engine.match(makeReq({ lastMessage: "echo this" }));
-      expect(rule).toBeDefined();
+      if (!rule) throw new Error("expected match for 'echo'");
 
-      const resolver = rule!.resolve as (req: MockRequest) => string;
+      const resolver = rule.resolve as (req: MockRequest) => string;
       const result = resolver(makeReq({ lastMessage: "echo this" }));
       expect(result).toBe("Echo: echo this");
     });

package/test/logger.test.ts

@@ -0,0 +1,294 @@
+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

@@ -299,7 +299,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",
       );
     });
   });

package/test/rule-engine.test.ts

@@ -1,21 +1,6 @@
 import { describe, it, expect, beforeEach } from "vitest";
 import { RuleEngine } from "../src/rule-engine.js";
-import type { MockRequest } from "../src/types.js";
-
-function makeReq(overrides: Partial<MockRequest> = {}): MockRequest {
-  return {
-    format: "openai",
-    model: "gpt-5.4",
-    streaming: true,
-    messages: [{ role: "user", content: "hello" }],
-    lastMessage: "hello",
-    systemMessage: "",
-    toolNames: [],
-    lastToolCallId: undefined,
-    raw: {},
-    ...overrides,
-  };
-}
+import { makeReq } from "./helpers/make-req.js";
 
 describe("RuleEngine", () => {
   let engine: RuleEngine;
@@ -27,8 +12,8 @@ describe("RuleEngine", () => {
   it("matches a string (substring, case-insensitive)", () => {
     engine.add("hello", "Hi!");
     const rule = engine.match(makeReq({ lastMessage: "say Hello world" }));
-    expect(rule).toBeDefined();
-    expect(rule!.description).toBe('"hello"');
+    if (!rule) throw new Error("expected match");
+    expect(rule.description).toBe('"hello"');
   });
 
   it("matches a regex", () => {
@@ -80,7 +65,8 @@ describe("RuleEngine", () => {
     engine.add("hello", "First");
     engine.add("hello", "Second");
     const rule = engine.match(makeReq());
-    expect(rule!.resolve).toBe("First");
+    if (!rule) throw new Error("expected match");
+    expect(rule.resolve).toBe("First");
   });
 
   it("returns undefined when no rules match", () => {
@@ -155,7 +141,8 @@ describe("RuleEngine", () => {
       const rule = engine.add("hello", "Second");
       engine.moveToFront(rule);
       const matched = engine.match(makeReq());
-      expect(matched!.resolve).toBe("Second");
+      if (!matched) throw new Error("expected match");
+      expect(matched.resolve).toBe("Second");
     });
   });
 
@@ -165,9 +152,8 @@ describe("RuleEngine", () => {
         { model: "gpt-5.4", predicate: (req) => req.messages.length > 2 },
         "Complex match",
       );
-      // Model matches but predicate fails (only 1 message)
       expect(engine.match(makeReq({ model: "gpt-5.4" }))).toBeUndefined();
-      // Both model and predicate pass
+
       expect(engine.match(makeReq({
         model: "gpt-5.4",
         messages: [

package/test/formats/anthropic-schema.test.ts

@@ -1,192 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { AnthropicRequestSchema } from "../../src/formats/anthropic/schema.js";
-
-describe("AnthropicRequestSchema", () => {
-  const validRequest = {
-    model: "claude-sonnet-4-6",
-    max_tokens: 1024,
-    messages: [{ role: "user", content: "Hello" }],
-  };
-
-  it("accepts a valid minimal request", () => {
-    expect(AnthropicRequestSchema.safeParse(validRequest).success).toBe(true);
-  });
-
-  it("rejects missing model", () => {
-    const { model: _model, ...rest } = validRequest;
-    expect(AnthropicRequestSchema.safeParse(rest).success).toBe(false);
-  });
-
-  it("rejects empty model string", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest, model: "",
-    }).success).toBe(false);
-  });
-
-  it("rejects missing max_tokens", () => {
-    const { max_tokens: _mt, ...rest } = validRequest;
-    expect(AnthropicRequestSchema.safeParse(rest).success).toBe(false);
-  });
-
-  it("rejects non-positive max_tokens", () => {
-    expect(AnthropicRequestSchema.safeParse({ ...validRequest, max_tokens: 0 }).success).toBe(false);
-    expect(AnthropicRequestSchema.safeParse({ ...validRequest, max_tokens: -1 }).success).toBe(false);
-  });
-
-  it("rejects empty messages array", () => {
-    expect(AnthropicRequestSchema.safeParse({ ...validRequest, messages: [] }).success).toBe(false);
-  });
-
-  it("rejects missing messages", () => {
-    const { messages: _m, ...rest } = validRequest;
-    expect(AnthropicRequestSchema.safeParse(rest).success).toBe(false);
-  });
-
-  it("accepts string content shorthand", () => {
-    expect(AnthropicRequestSchema.safeParse(validRequest).success).toBe(true);
-  });
-
-  it("accepts array content with text blocks", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      messages: [{ role: "user", content: [{ type: "text", text: "Hello" }] }],
-    }).success).toBe(true);
-  });
-
-  it("accepts array content with tool_use blocks", () => {
-    const result = AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      messages: [{
-        role: "assistant",
-        content: [{
-          type: "tool_use", id: "toolu_01", name: "get_weather", input: { location: "SF" },
-        }],
-      }],
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.messages[0]!.content).toEqual([
-        { type: "tool_use", id: "toolu_01", name: "get_weather", input: { location: "SF" } },
-      ]);
-    }
-  });
-
-  it("accepts tool_result blocks with string content", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      messages: [{
-        role: "user",
-        content: [{ type: "tool_result", tool_use_id: "toolu_01", content: "Sunny, 72F" }],
-      }],
-    }).success).toBe(true);
-  });
-
-  it("accepts tool_result blocks with TextBlock[] content", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      messages: [{
-        role: "user",
-        content: [{ type: "tool_result", tool_use_id: "toolu_02", content: [{ type: "text", text: "Result" }] }],
-      }],
-    }).success).toBe(true);
-  });
-
-  it("accepts mixed content blocks in a single message", () => {
-    const result = AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      messages: [{
-        role: "assistant",
-        content: [
-          { type: "text", text: "Let me check." },
-          { type: "tool_use", id: "toolu_01", name: "get_weather", input: { location: "SF" } },
-        ],
-      }],
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.messages[0]!.content).toHaveLength(2);
-    }
-  });
-
-  it("filters out unknown content block types", () => {
-    const result = AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      messages: [{
-        role: "assistant",
-        content: [
-          { type: "thinking", thinking: "Let me consider..." },
-          { type: "text", text: "Here is my answer." },
-        ],
-      }],
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      const blocks = result.data.messages[0]!.content;
-      expect(blocks).toHaveLength(1);
-      expect(blocks).toEqual([{ type: "text", text: "Here is my answer." }]);
-    }
-  });
-
-  it("accepts a message where all blocks are unknown", () => {
-    const result = AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      messages: [{
-        role: "assistant",
-        content: [
-          { type: "thinking", thinking: "hmm" },
-          { type: "server_tool_use", id: "st_01", name: "web_search" },
-        ],
-      }],
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.messages[0]!.content).toHaveLength(0);
-    }
-  });
-
-  it("accepts system as string", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest, system: "You are a helpful assistant.",
-    }).success).toBe(true);
-  });
-
-  it("accepts system as TextBlock array", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest, system: [{ type: "text", text: "You are a helpful assistant." }],
-    }).success).toBe(true);
-  });
-
-  it("accepts stream: true", () => {
-    const result = AnthropicRequestSchema.safeParse({ ...validRequest, stream: true });
-    expect(result.success).toBe(true);
-    if (result.success) expect(result.data.stream).toBe(true);
-  });
-
-  it("accepts stream: false", () => {
-    const result = AnthropicRequestSchema.safeParse({ ...validRequest, stream: false });
-    expect(result.success).toBe(true);
-    if (result.success) expect(result.data.stream).toBe(false);
-  });
-
-  it("accepts optional fields", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      temperature: 0.7,
-      top_p: 0.9,
-      top_k: 40,
-      stop_sequences: ["Human:"],
-      metadata: { user_id: "test" },
-    }).success).toBe(true);
-  });
-
-  it("accepts tools array", () => {
-    expect(AnthropicRequestSchema.safeParse({
-      ...validRequest,
-      tools: [{
-        name: "get_weather",
-        description: "Get the weather",
-        input_schema: { type: "object", properties: { location: { type: "string" } } },
-      }],
-    }).success).toBe(true);
-  });
-});