llm-mock-server 1.0.6 → 1.0.8

package/test/history.test.ts

@@ -1,361 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { RequestHistory, type RecordedRequest } from "#/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);
-    });
-  });
-});

package/test/loader.test.ts

@@ -1,333 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { writeFile, mkdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { RuleEngine } from "#/rule-engine.js";
-import { loadRulesFromPath } from "#/loader.js";
-import type { MockRequest } from "#/types.js";
-import { makeReq } from "./helpers/make-req.js";
-
-const tmpDir = join(import.meta.dirname, ".tmp-loader-test");
-
-describe("Loader", () => {
-  let engine: RuleEngine;
-
-  beforeEach(async () => {
-    engine = new RuleEngine();
-    await mkdir(tmpDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await rm(tmpDir, { recursive: true, force: true });
-  });
-
-  describe("JSON5 files", () => {
-    it("loads rules from a .json5 file", async () => {
-      const rulesPath = join(tmpDir, "rules.json5");
-      await writeFile(
-        rulesPath,
-        `[
-          {
-            when: "explain recursion",
-            reply: "A function that calls itself.",
-          },
-          {
-            when: { model: "gpt-5.4", message: "hello" },
-            reply: "Hi from GPT-5.4!",
-          },
-        ]`,
-      );
-
-      await loadRulesFromPath(rulesPath, { engine });
-      expect(engine.ruleCount).toBe(2);
-
-      const match1 = engine.match(
-        makeReq({ lastMessage: "Please explain recursion" }),
-      );
-      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();
-    });
-
-    it("loads regex patterns from JSON5", async () => {
-      const rulesPath = join(tmpDir, "regex.json5");
-      await writeFile(
-        rulesPath,
-        `[
-          {
-            when: "/explain (\\\\w+)/i",
-            reply: "Here is an explanation.",
-          },
-        ]`,
-      );
-
-      await loadRulesFromPath(rulesPath, { engine });
-      const match = engine.match(
-        makeReq({ lastMessage: "explain polymorphism" }),
-      );
-      expect(match).toBeDefined();
-    });
-
-    it("loads regex patterns with modern flags (d, v)", async () => {
-      const rulesPath = join(tmpDir, "flags.json5");
-      await writeFile(
-        rulesPath,
-        `[{ when: "/hello/di", reply: "With d flag" }]`,
-      );
-
-      await loadRulesFromPath(rulesPath, { engine });
-      expect(
-        engine.match(makeReq({ lastMessage: "hello world" })),
-      ).toBeDefined();
-    });
-
-    it("loads rules with times", async () => {
-      const rulesPath = join(tmpDir, "times.json5");
-      await writeFile(
-        rulesPath,
-        `[{ when: "once", reply: "One time!", times: 1 }]`,
-      );
-
-      await loadRulesFromPath(rulesPath, { engine });
-      expect(engine.match(makeReq({ lastMessage: "once" }))).toBeDefined();
-      expect(engine.match(makeReq({ lastMessage: "once" }))).toBeUndefined();
-    });
-
-    it("resolves $template references", async () => {
-      const rulesPath = join(tmpDir, "templates.json5");
-      await writeFile(
-        rulesPath,
-        `{
-          templates: {
-            greeting: "Hello from template!",
-            toolReply: { tools: [{ name: "search", args: { q: "test" } }] },
-          },
-          rules: [
-            { when: "hi", reply: "$greeting" },
-            { when: "search", reply: "$toolReply" },
-          ],
-        }`,
-      );
-
-      await loadRulesFromPath(rulesPath, { engine });
-      expect(engine.ruleCount).toBe(2);
-
-      const match1 = engine.match(makeReq({ lastMessage: "hi" }));
-      expect(match1?.resolve).toBe("Hello from template!");
-
-      const match2 = engine.match(makeReq({ lastMessage: "search" }));
-      expect(match2?.resolve).toMatchObject({ tools: [{ name: "search" }] });
-    });
-
-    it("throws on unknown template reference", async () => {
-      const rulesPath = join(tmpDir, "bad-ref.json5");
-      await writeFile(
-        rulesPath,
-        `{
-          rules: [{ when: "hi", reply: "$nonexistent" }],
-        }`,
-      );
-
-      await expect(loadRulesFromPath(rulesPath, { engine })).rejects.toThrow(
-        "Unknown template",
-      );
-    });
-
-    it("loads a replies sequence", async () => {
-      const rulesPath = join(tmpDir, "seq.json5");
-      await writeFile(
-        rulesPath,
-        `[{ when: "step", replies: ["First.", "Second."] }]`,
-      );
-
-      await loadRulesFromPath(rulesPath, { engine });
-      expect(engine.ruleCount).toBe(1);
-
-      const req = makeReq({ lastMessage: "step" });
-      const match1 = engine.match(req);
-      if (!match1) throw new Error("expected match1");
-      expect((match1.resolve as () => string)()).toBe("First.");
-
-      const match2 = engine.match(req);
-      if (!match2) throw new Error("expected match2");
-      expect((match2.resolve as () => string)()).toBe("Second.");
-
-      expect(engine.match(req)).toBeUndefined();
-    });
-
-    it("loads fallback from JSON5 file", async () => {
-      const rulesPath = join(tmpDir, "fb.json5");
-      await writeFile(
-        rulesPath,
-        `{
-          fallback: "Default reply.",
-          rules: [{ when: "hi", reply: "Hello!" }],
-        }`,
-      );
-
-      let capturedFallback: unknown;
-      await loadRulesFromPath(rulesPath, {
-        engine,
-        setFallback: (reply) => {
-          capturedFallback = reply;
-        },
-      });
-
-      expect(capturedFallback).toBe("Default reply.");
-      expect(engine.ruleCount).toBe(1);
-    });
-  });
-
-  describe("handler files", () => {
-    it("loads a single handler from a .ts file", async () => {
-      const handlerPath = join(tmpDir, "single.ts");
-      await writeFile(
-        handlerPath,
-        `export default {
-          match: (req) => req.lastMessage.includes("summarize"),
-          respond: (req) => "Here is a summary.",
-        };`,
-      );
-
-      await loadRulesFromPath(handlerPath, { engine });
-      expect(engine.ruleCount).toBe(1);
-
-      const match = engine.match(
-        makeReq({ lastMessage: "summarize this article" }),
-      );
-      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 () => {
-      const handlerPath = join(tmpDir, "multi.ts");
-      await writeFile(
-        handlerPath,
-        `export default [
-          {
-            match: (req) => req.lastMessage.includes("hello"),
-            respond: () => "Hi!",
-          },
-          {
-            match: (req) => req.lastMessage.includes("bye"),
-            respond: () => "Goodbye!",
-          },
-        ];`,
-      );
-
-      await loadRulesFromPath(handlerPath, { engine });
-      expect(engine.ruleCount).toBe(2);
-
-      expect(engine.match(makeReq({ lastMessage: "hello" }))).toBeDefined();
-      expect(engine.match(makeReq({ lastMessage: "bye" }))).toBeDefined();
-      expect(engine.match(makeReq({ lastMessage: "nothing" }))).toBeUndefined();
-    });
-
-    it("handler respond function receives the request", async () => {
-      const handlerPath = join(tmpDir, "dynamic.ts");
-      await writeFile(
-        handlerPath,
-        `export default {
-          match: (req) => req.lastMessage.includes("echo"),
-          respond: (req) => \`Echo: \${req.lastMessage}\`,
-        };`,
-      );
-
-      await loadRulesFromPath(handlerPath, { engine });
-      const rule = engine.match(makeReq({ lastMessage: "echo this" }));
-      if (!rule) throw new Error("expected match for 'echo'");
-
-      const resolver = rule.resolve as (req: MockRequest) => string;
-      const result = resolver(makeReq({ lastMessage: "echo this" }));
-      expect(result).toBe("Echo: echo this");
-    });
-
-    it("throws on invalid handler file (missing match/respond)", async () => {
-      const handlerPath = join(tmpDir, "bad.ts");
-      await writeFile(
-        handlerPath,
-        `export default { mach: () => true, respond: () => "hi" };`,
-      );
-
-      await expect(loadRulesFromPath(handlerPath, { engine })).rejects.toThrow(
-        "Invalid handler file",
-      );
-    });
-
-    it("loads fallback from handler file", async () => {
-      const handlerPath = join(tmpDir, "with-fallback.ts");
-      await writeFile(
-        handlerPath,
-        `export const fallback = "Default reply.";
-         export default {
-           match: (req) => req.lastMessage.includes("hello"),
-           respond: () => "Hi!",
-         };`,
-      );
-
-      let capturedFallback: unknown;
-      await loadRulesFromPath(handlerPath, {
-        engine,
-        setFallback: (reply) => {
-          capturedFallback = reply;
-        },
-      });
-
-      expect(capturedFallback).toBe("Default reply.");
-      expect(engine.ruleCount).toBe(1);
-    });
-  });
-
-  describe("unsupported file extension", () => {
-    it("throws when loading a file with unsupported extension", async () => {
-      const yamlPath = join(tmpDir, "rules.yaml");
-      await writeFile(yamlPath, "- when: hello\n  reply: Hi!");
-      await expect(loadRulesFromPath(yamlPath, { engine })).rejects.toThrow(
-        'Unsupported file extension ".yaml"',
-      );
-    });
-
-    it("skips unsupported files when scanning a directory", async () => {
-      await writeFile(
-        join(tmpDir, "good.json5"),
-        `[{ when: "hello", reply: "Hi!" }]`,
-      );
-      await writeFile(join(tmpDir, "notes.txt"), "not a rule file");
-      await loadRulesFromPath(tmpDir, { engine });
-      expect(engine.ruleCount).toBe(1);
-    });
-  });
-
-  describe("directory loading", () => {
-    it("loads all .json5 files from a directory", async () => {
-      await writeFile(join(tmpDir, "a.json5"), `[{ when: "aaa", reply: "A" }]`);
-      await writeFile(join(tmpDir, "b.json5"), `[{ when: "bbb", reply: "B" }]`);
-
-      await loadRulesFromPath(tmpDir, { engine });
-      expect(engine.ruleCount).toBe(2);
-    });
-
-    it("loads mixed .json5 and .ts files from a directory", async () => {
-      await writeFile(
-        join(tmpDir, "rules.json5"),
-        `[{ when: "static", reply: "From JSON5" }]`,
-      );
-      await writeFile(
-        join(tmpDir, "handler.ts"),
-        `export default {
-          match: (req) => req.lastMessage.includes("dynamic"),
-          respond: () => "From handler",
-        };`,
-      );
-
-      await loadRulesFromPath(tmpDir, { engine });
-      expect(engine.ruleCount).toBe(2);
-
-      expect(engine.match(makeReq({ lastMessage: "static" }))).toBeDefined();
-      expect(engine.match(makeReq({ lastMessage: "dynamic" }))).toBeDefined();
-    });
-  });
-});