llm-mock-server 1.0.0 → 1.0.2

package/test/formats/parse-helpers.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, it } from "vitest";
+import {
+  splitText,
+  genId,
+  toolId,
+  shouldEmitText,
+  finishReason,
+  MS_PER_SECOND,
+  DEFAULT_USAGE,
+} from "../../src/formats/serialize-helpers.js";
+import {
+  isStreaming,
+  buildMockRequest,
+} from "../../src/formats/request-helpers.js";
+import type { ReplyObject } from "../../src/types.js";
+
+describe("parse-helpers", () => {
+  describe("constants", () => {
+    it("MS_PER_SECOND is 1000", () => {
+      expect(MS_PER_SECOND).toBe(1000);
+    });
+
+    it("DEFAULT_USAGE has expected shape", () => {
+      expect(DEFAULT_USAGE).toEqual({ input: 10, output: 5 });
+    });
+  });
+
+  describe("splitText", () => {
+    it("returns the full string when chunkSize is 0", () => {
+      expect(splitText("hello", 0)).toEqual(["hello"]);
+    });
+
+    it("returns the full string when chunkSize is negative", () => {
+      expect(splitText("hello", -1)).toEqual(["hello"]);
+    });
+
+    it("returns the full string when text fits in one chunk", () => {
+      expect(splitText("hello", 10)).toEqual(["hello"]);
+    });
+
+    it("returns the full string when chunkSize equals text length", () => {
+      expect(splitText("hello", 5)).toEqual(["hello"]);
+    });
+
+    it("splits text into equal chunks", () => {
+      expect(splitText("abcdef", 2)).toEqual(["ab", "cd", "ef"]);
+    });
+
+    it("handles a remainder chunk", () => {
+      expect(splitText("abcde", 2)).toEqual(["ab", "cd", "e"]);
+    });
+
+    it("splits into single characters with chunkSize 1", () => {
+      expect(splitText("abc", 1)).toEqual(["a", "b", "c"]);
+    });
+
+    it("returns single-element array for empty string", () => {
+      expect(splitText("", 5)).toEqual([""]);
+    });
+  });
+
+  describe("genId", () => {
+    it("starts with the given prefix", () => {
+      const id = genId("chatcmpl");
+      expect(id).toMatch(/^chatcmpl_/);
+    });
+
+    it("generates unique ids", () => {
+      const a = genId("msg");
+      const b = genId("msg");
+      // Could collide if Date.now() returns the same ms, but format is still valid
+      expect(a).toMatch(/^msg_[a-z0-9]+$/);
+      expect(b).toMatch(/^msg_[a-z0-9]+$/);
+    });
+  });
+
+  describe("toolId", () => {
+    it("uses the tool's own id when present", () => {
+      expect(toolId({ id: "call_abc" }, "call", 0)).toBe("call_abc");
+    });
+
+    it("generates an id when tool has no id", () => {
+      const id = toolId({}, "call", 2);
+      expect(id).toMatch(/^call_[a-z0-9]+_2$/);
+    });
+
+    it("generates an id when tool id is undefined", () => {
+      const id = toolId({ id: undefined }, "call", 0);
+      expect(id).toMatch(/^call_[a-z0-9]+_0$/);
+    });
+  });
+
+  describe("shouldEmitText", () => {
+    it("returns true when reply has text", () => {
+      expect(shouldEmitText({ text: "hello" })).toBe(true);
+    });
+
+    it("returns true when reply has no text, no tools, no reasoning", () => {
+      expect(shouldEmitText({})).toBe(true);
+    });
+
+    it("returns false when reply has only tools", () => {
+      expect(shouldEmitText({ tools: [{ name: "fn", args: {} }] })).toBe(false);
+    });
+
+    it("returns false when reply has only reasoning", () => {
+      expect(shouldEmitText({ reasoning: "thinking..." })).toBe(false);
+    });
+
+    it("returns true when reply has text and tools", () => {
+      expect(shouldEmitText({ text: "hi", tools: [{ name: "fn", args: {} }] })).toBe(true);
+    });
+
+    it("returns true for empty text with no tools or reasoning", () => {
+      expect(shouldEmitText({ text: "" })).toBe(true);
+    });
+  });
+
+  describe("finishReason", () => {
+    it("returns onTools when tools are present", () => {
+      const reply: ReplyObject = { tools: [{ name: "fn", args: {} }] };
+      expect(finishReason(reply, "tool_calls", "stop")).toBe("tool_calls");
+    });
+
+    it("returns onStop when no tools", () => {
+      expect(finishReason({ text: "hi" }, "tool_calls", "stop")).toBe("stop");
+    });
+
+    it("returns onStop when tools array is empty", () => {
+      expect(finishReason({ tools: [] }, "tool_calls", "stop")).toBe("stop");
+    });
+
+    it("returns onStop when tools is undefined", () => {
+      expect(finishReason({}, "tool_calls", "stop")).toBe("stop");
+    });
+  });
+
+  describe("isStreaming", () => {
+    it("returns true when stream is true", () => {
+      expect(isStreaming({ stream: true })).toBe(true);
+    });
+
+    it("returns false when stream is false", () => {
+      expect(isStreaming({ stream: false })).toBe(false);
+    });
+
+    it("returns true when stream is absent", () => {
+      expect(isStreaming({})).toBe(true);
+    });
+
+    it("returns true for null body", () => {
+      expect(isStreaming(null)).toBe(true);
+    });
+
+    it("returns true for non-object body", () => {
+      expect(isStreaming("not an object")).toBe(true);
+    });
+
+    it("returns true for undefined body", () => {
+      expect(isStreaming(undefined)).toBe(true);
+    });
+  });
+
+  describe("buildMockRequest", () => {
+    it("builds a minimal request with defaults", () => {
+      const result = buildMockRequest(
+        "openai",
+        {},
+        [{ role: "user", content: "hello" }],
+        undefined,
+        "gpt-4",
+        { messages: [] },
+      );
+
+      expect(result.format).toBe("openai");
+      expect(result.model).toBe("gpt-4");
+      expect(result.streaming).toBe(true);
+      expect(result.lastMessage).toBe("hello");
+      expect(result.systemMessage).toBe("");
+      expect(result.tools).toBeUndefined();
+      expect(result.toolNames).toEqual([]);
+      expect(result.lastToolCallId).toBeUndefined();
+      expect(result.headers).toEqual({});
+      expect(result.path).toBe("");
+    });
+
+    it("uses model from body when provided", () => {
+      const result = buildMockRequest(
+        "anthropic",
+        { model: "claude-sonnet" },
+        [],
+        undefined,
+        "default-model",
+        {},
+      );
+      expect(result.model).toBe("claude-sonnet");
+    });
+
+    it("falls back to default model when body model is empty string", () => {
+      const result = buildMockRequest(
+        "openai",
+        { model: "" },
+        [],
+        undefined,
+        "gpt-4",
+        {},
+      );
+      expect(result.model).toBe("gpt-4");
+    });
+
+    it("extracts last user message", () => {
+      const messages = [
+        { role: "user" as const, content: "first" },
+        { role: "assistant" as const, content: "reply" },
+        { role: "user" as const, content: "second" },
+      ];
+      const result = buildMockRequest("openai", {}, messages, undefined, "m", {});
+      expect(result.lastMessage).toBe("second");
+    });
+
+    it("extracts system message", () => {
+      const messages = [
+        { role: "system" as const, content: "be helpful" },
+        { role: "user" as const, content: "hi" },
+      ];
+      const result = buildMockRequest("openai", {}, messages, undefined, "m", {});
+      expect(result.systemMessage).toBe("be helpful");
+    });
+
+    it("extracts tool names", () => {
+      const tools = [
+        { name: "get_weather", parameters: {} },
+        { name: "search", parameters: {} },
+      ];
+      const result = buildMockRequest("openai", {}, [], tools, "m", {});
+      expect(result.toolNames).toEqual(["get_weather", "search"]);
+    });
+
+    it("extracts last tool call id", () => {
+      const messages = [
+        { role: "tool" as const, content: "result1", toolCallId: "call_1" },
+        { role: "tool" as const, content: "result2", toolCallId: "call_2" },
+      ];
+      const result = buildMockRequest("openai", {}, messages, undefined, "m", {});
+      expect(result.lastToolCallId).toBe("call_2");
+    });
+
+    it("sets streaming to false when stream is false", () => {
+      const result = buildMockRequest("openai", { stream: false }, [], undefined, "m", {});
+      expect(result.streaming).toBe(false);
+    });
+
+    it("uses provided meta for headers and path", () => {
+      const meta = {
+        headers: { authorization: "Bearer sk-test" },
+        path: "/v1/chat/completions",
+      };
+      const result = buildMockRequest("openai", {}, [], undefined, "m", {}, meta);
+      expect(result.headers).toEqual({ authorization: "Bearer sk-test" });
+      expect(result.path).toBe("/v1/chat/completions");
+    });
+
+    it("returns empty lastMessage when no user messages", () => {
+      const result = buildMockRequest(
+        "openai",
+        {},
+        [{ role: "system" as const, content: "sys" }],
+        undefined,
+        "m",
+        {},
+      );
+      expect(result.lastMessage).toBe("");
+    });
+  });
+});

package/test/formats/responses.test.ts

@@ -275,10 +275,10 @@ describe("Responses Format", () => {
         "codex-mini",
       ) as ResponsesComplete;
       const fnCall = result.output.find((o) => o.type === "function_call");
-      expect(fnCall).toBeDefined();
-      expect(fnCall!.name).toBe("read_file");
-      expect(fnCall!.status).toBe("completed");
-      expect(fnCall!.call_id).toBeTypeOf("string");
+      if (!fnCall) throw new Error("expected function_call output");
+      expect(fnCall.name).toBe("read_file");
+      expect(fnCall.status).toBe("completed");
+      expect(fnCall.call_id).toBeTypeOf("string");
     });
 
     it("includes usage tokens", () => {

package/test/helpers/make-req.ts

@@ -0,0 +1,18 @@
+import type { MockRequest } from "../../src/types.js";
+
+export 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,
+  };
+}

package/test/history.test.ts

@@ -0,0 +1,348 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { RequestHistory, type RecordedRequest } from "../src/history.js";
+import { makeReq } from "./helpers/make-req.js";
+
+describe("RequestHistory", () => {
+  let history: RequestHistory;
+
+  beforeEach(() => {
+    history = new RequestHistory();
+  });
+
+  describe("record()", () => {
+    it("adds an entry", () => {
+      history.record(makeReq(), "rule-1");
+      expect(history.count()).toBe(1);
+    });
+
+    it("adds multiple entries in order", () => {
+      history.record(makeReq({ lastMessage: "first" }), "r1");
+      history.record(makeReq({ lastMessage: "second" }), "r2");
+      history.record(makeReq({ lastMessage: "third" }), undefined);
+
+      expect(history.count()).toBe(3);
+      expect(history.first()?.request.lastMessage).toBe("first");
+      expect(history.last()?.request.lastMessage).toBe("third");
+    });
+
+    it("stores the matched rule name", () => {
+      history.record(makeReq(), "my-rule");
+      expect(history.first()?.rule).toBe("my-rule");
+    });
+
+    it("stores undefined rule when fallback was used", () => {
+      history.record(makeReq(), undefined);
+      expect(history.first()?.rule).toBeUndefined();
+    });
+
+    it("sets a numeric timestamp", () => {
+      const before = Date.now();
+      history.record(makeReq(), "r");
+      const after = Date.now();
+
+      const ts = history.first()!.timestamp;
+      expect(ts).toBeGreaterThanOrEqual(before);
+      expect(ts).toBeLessThanOrEqual(after);
+    });
+  });
+
+  describe("count()", () => {
+    it("returns 0 for empty history", () => {
+      expect(history.count()).toBe(0);
+    });
+
+    it("returns the correct count after multiple records", () => {
+      history.record(makeReq(), "a");
+      history.record(makeReq(), "b");
+      history.record(makeReq(), "c");
+      expect(history.count()).toBe(3);
+    });
+
+    it("returns 0 after clear", () => {
+      history.record(makeReq(), "a");
+      history.clear();
+      expect(history.count()).toBe(0);
+    });
+  });
+
+  describe("first()", () => {
+    it("returns undefined when history is empty", () => {
+      expect(history.first()).toBeUndefined();
+    });
+
+    it("returns the first recorded entry", () => {
+      history.record(makeReq({ lastMessage: "alpha" }), "r1");
+      history.record(makeReq({ lastMessage: "beta" }), "r2");
+
+      const entry = history.first();
+      expect(entry).toBeDefined();
+      expect(entry!.request.lastMessage).toBe("alpha");
+      expect(entry!.rule).toBe("r1");
+    });
+  });
+
+  describe("last()", () => {
+    it("returns undefined when history is empty", () => {
+      expect(history.last()).toBeUndefined();
+    });
+
+    it("returns the most recent entry", () => {
+      history.record(makeReq({ lastMessage: "alpha" }), "r1");
+      history.record(makeReq({ lastMessage: "beta" }), "r2");
+
+      const entry = history.last();
+      expect(entry).toBeDefined();
+      expect(entry!.request.lastMessage).toBe("beta");
+      expect(entry!.rule).toBe("r2");
+    });
+
+    it("returns the same entry as first() when there is only one", () => {
+      history.record(makeReq(), "only");
+      expect(history.first()).toBe(history.last());
+    });
+  });
+
+  describe("at()", () => {
+    beforeEach(() => {
+      history.record(makeReq({ lastMessage: "zero" }), "r0");
+      history.record(makeReq({ lastMessage: "one" }), "r1");
+      history.record(makeReq({ lastMessage: "two" }), "r2");
+    });
+
+    it("returns the entry at a positive index", () => {
+      expect(history.at(0)?.request.lastMessage).toBe("zero");
+      expect(history.at(1)?.request.lastMessage).toBe("one");
+      expect(history.at(2)?.request.lastMessage).toBe("two");
+    });
+
+    it("returns the entry at a negative index", () => {
+      expect(history.at(-1)?.request.lastMessage).toBe("two");
+      expect(history.at(-2)?.request.lastMessage).toBe("one");
+      expect(history.at(-3)?.request.lastMessage).toBe("zero");
+    });
+
+    it("returns undefined for out-of-bounds positive index", () => {
+      expect(history.at(3)).toBeUndefined();
+      expect(history.at(100)).toBeUndefined();
+    });
+
+    it("returns undefined for out-of-bounds negative index", () => {
+      expect(history.at(-4)).toBeUndefined();
+      expect(history.at(-100)).toBeUndefined();
+    });
+
+    it("returns undefined when history is empty", () => {
+      const empty = new RequestHistory();
+      expect(empty.at(0)).toBeUndefined();
+      expect(empty.at(-1)).toBeUndefined();
+    });
+  });
+
+  describe("where()", () => {
+    beforeEach(() => {
+      history.record(makeReq({ lastMessage: "hello", model: "gpt-5.4" }), "rule-a");
+      history.record(makeReq({ lastMessage: "world", model: "claude-4" }), undefined);
+      history.record(makeReq({ lastMessage: "hello again", model: "gpt-5.4" }), "rule-b");
+    });
+
+    it("filters entries by predicate", () => {
+      const matched = history.where((e) => e.rule !== undefined);
+      expect(matched).toHaveLength(2);
+      expect(matched[0].rule).toBe("rule-a");
+      expect(matched[1].rule).toBe("rule-b");
+    });
+
+    it("filters by request properties", () => {
+      const claudeRequests = history.where((e) => e.request.model === "claude-4");
+      expect(claudeRequests).toHaveLength(1);
+      expect(claudeRequests[0].request.lastMessage).toBe("world");
+    });
+
+    it("returns an empty array when nothing matches", () => {
+      const none = history.where((e) => e.request.lastMessage === "nonexistent");
+      expect(none).toEqual([]);
+    });
+
+    it("returns all entries when predicate always returns true", () => {
+      const all = history.where(() => true);
+      expect(all).toHaveLength(3);
+    });
+
+    it("returns an empty array on empty history", () => {
+      const empty = new RequestHistory();
+      expect(empty.where(() => true)).toEqual([]);
+    });
+  });
+
+  describe("all getter", () => {
+    it("returns an empty array when history is empty", () => {
+      expect(history.all).toEqual([]);
+      expect(history.all).toHaveLength(0);
+    });
+
+    it("returns all recorded entries in insertion order", () => {
+      history.record(makeReq({ lastMessage: "a" }), "r1");
+      history.record(makeReq({ lastMessage: "b" }), "r2");
+
+      const entries = history.all;
+      expect(entries).toHaveLength(2);
+      expect(entries[0].request.lastMessage).toBe("a");
+      expect(entries[1].request.lastMessage).toBe("b");
+    });
+
+    it("returns a readonly array (same reference as internal entries)", () => {
+      history.record(makeReq(), "r");
+      const a = history.all;
+      const b = history.all;
+      expect(a).toBe(b);
+    });
+
+    it("reflects mutations after further records", () => {
+      history.record(makeReq({ lastMessage: "before" }), "r");
+      const ref = history.all;
+      expect(ref).toHaveLength(1);
+
+      history.record(makeReq({ lastMessage: "after" }), "r2");
+      // `all` exposes the internal array, so the earlier reference sees the new entry
+      expect(ref).toHaveLength(2);
+    });
+  });
+
+  describe("clear()", () => {
+    it("empties the history", () => {
+      history.record(makeReq(), "r1");
+      history.record(makeReq(), "r2");
+      expect(history.count()).toBe(2);
+
+      history.clear();
+      expect(history.count()).toBe(0);
+      expect(history.first()).toBeUndefined();
+      expect(history.last()).toBeUndefined();
+      expect(history.all).toHaveLength(0);
+    });
+
+    it("is idempotent on empty history", () => {
+      history.clear();
+      expect(history.count()).toBe(0);
+      history.clear();
+      expect(history.count()).toBe(0);
+    });
+
+    it("allows recording again after clear", () => {
+      history.record(makeReq({ lastMessage: "old" }), "r1");
+      history.clear();
+      history.record(makeReq({ lastMessage: "new" }), "r2");
+
+      expect(history.count()).toBe(1);
+      expect(history.first()?.request.lastMessage).toBe("new");
+    });
+  });
+
+  describe("Iterator protocol (for...of)", () => {
+    it("iterates over all entries in order", () => {
+      history.record(makeReq({ lastMessage: "a" }), "r1");
+      history.record(makeReq({ lastMessage: "b" }), "r2");
+      history.record(makeReq({ lastMessage: "c" }), "r3");
+
+      const messages: string[] = [];
+      for (const entry of history) {
+        messages.push(entry.request.lastMessage);
+      }
+
+      expect(messages).toEqual(["a", "b", "c"]);
+    });
+
+    it("yields nothing for empty history", () => {
+      const messages: string[] = [];
+      for (const entry of history) {
+        messages.push(entry.request.lastMessage);
+      }
+      expect(messages).toEqual([]);
+    });
+
+    it("works with spread operator", () => {
+      history.record(makeReq({ lastMessage: "x" }), "r1");
+      history.record(makeReq({ lastMessage: "y" }), "r2");
+
+      const entries: RecordedRequest[] = [...history];
+      expect(entries).toHaveLength(2);
+      expect(entries[0].request.lastMessage).toBe("x");
+      expect(entries[1].request.lastMessage).toBe("y");
+    });
+
+    it("works with Array.from()", () => {
+      history.record(makeReq(), "r1");
+      history.record(makeReq(), "r2");
+
+      const arr = Array.from(history);
+      expect(arr).toHaveLength(2);
+    });
+
+    it("supports destructuring", () => {
+      history.record(makeReq({ lastMessage: "first" }), "r1");
+      history.record(makeReq({ lastMessage: "second" }), "r2");
+      history.record(makeReq({ lastMessage: "third" }), "r3");
+
+      const [first, second, third] = history;
+      expect(first.request.lastMessage).toBe("first");
+      expect(second.request.lastMessage).toBe("second");
+      expect(third.request.lastMessage).toBe("third");
+    });
+  });
+
+  describe("edge cases", () => {
+    it("preserves the full MockRequest object", () => {
+      const req = makeReq({
+        format: "anthropic",
+        model: "claude-4",
+        streaming: false,
+        lastMessage: "test message",
+        systemMessage: "be helpful",
+        toolNames: ["search", "calc"],
+        lastToolCallId: "call_123",
+        path: "/v1/messages",
+      });
+
+      history.record(req, "complex-rule");
+      const recorded = history.first()!;
+
+      expect(recorded.request.format).toBe("anthropic");
+      expect(recorded.request.model).toBe("claude-4");
+      expect(recorded.request.streaming).toBe(false);
+      expect(recorded.request.lastMessage).toBe("test message");
+      expect(recorded.request.systemMessage).toBe("be helpful");
+      expect(recorded.request.toolNames).toEqual(["search", "calc"]);
+      expect(recorded.request.lastToolCallId).toBe("call_123");
+      expect(recorded.request.path).toBe("/v1/messages");
+    });
+
+    it("handles many entries without issue", () => {
+      for (let i = 0; i < 1000; i++) {
+        history.record(makeReq({ lastMessage: `msg-${i}` }), `rule-${i}`);
+      }
+
+      expect(history.count()).toBe(1000);
+      expect(history.first()?.request.lastMessage).toBe("msg-0");
+      expect(history.last()?.request.lastMessage).toBe("msg-999");
+      expect(history.at(500)?.request.lastMessage).toBe("msg-500");
+    });
+
+    it("where() does not modify the original entries", () => {
+      history.record(makeReq(), "r1");
+      history.record(makeReq(), "r2");
+
+      const filtered = history.where(() => false);
+      expect(filtered).toHaveLength(0);
+      expect(history.count()).toBe(2);
+    });
+
+    it("each entry gets its own timestamp", () => {
+      history.record(makeReq(), "r1");
+      history.record(makeReq(), "r2");
+
+      const t1 = history.at(0)!.timestamp;
+      const t2 = history.at(1)!.timestamp;
+      expect(t2).toBeGreaterThanOrEqual(t1);
+    });
+  });
+});