llm-mock-server 1.0.1 → 1.0.3

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,13 +12,15 @@ 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", () => {
     engine.add(/explain (\w+)/i, "Here is an explanation.");
-    const rule = engine.match(makeReq({ lastMessage: "Can you explain recursion?" }));
+    const rule = engine.match(
+      makeReq({ lastMessage: "Can you explain recursion?" }),
+    );
     expect(rule).toBeDefined();
   });
 
@@ -59,15 +46,25 @@ describe("RuleEngine", () => {
 
   it("matches a MatchObject with message + model", () => {
     engine.add({ model: "gpt-5.4", message: "hello" }, "Hi from GPT-5.4");
-    expect(engine.match(makeReq({ model: "gpt-5.4", lastMessage: "hello" }))).toBeDefined();
-    expect(engine.match(makeReq({ model: "gpt-5.4", lastMessage: "bye" }))).toBeUndefined();
-    expect(engine.match(makeReq({ model: "claude", lastMessage: "hello" }))).toBeUndefined();
+    expect(
+      engine.match(makeReq({ model: "gpt-5.4", lastMessage: "hello" })),
+    ).toBeDefined();
+    expect(
+      engine.match(makeReq({ model: "gpt-5.4", lastMessage: "bye" })),
+    ).toBeUndefined();
+    expect(
+      engine.match(makeReq({ model: "claude", lastMessage: "hello" })),
+    ).toBeUndefined();
   });
 
   it("matches a MatchObject with system", () => {
     engine.add({ system: /pirate/i }, "Arrr!");
-    expect(engine.match(makeReq({ systemMessage: "You are a pirate" }))).toBeDefined();
-    expect(engine.match(makeReq({ systemMessage: "You are helpful" }))).toBeUndefined();
+    expect(
+      engine.match(makeReq({ systemMessage: "You are a pirate" })),
+    ).toBeDefined();
+    expect(
+      engine.match(makeReq({ systemMessage: "You are helpful" })),
+    ).toBeUndefined();
   });
 
   it("matches a MatchObject with format", () => {
@@ -80,7 +77,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", () => {
@@ -129,13 +127,17 @@ describe("RuleEngine", () => {
       (req) => req.lastMessage.includes("test"),
       "Handler reply",
     );
-    expect(engine.match(makeReq({ lastMessage: "this is a test" }))).toBeDefined();
+    expect(
+      engine.match(makeReq({ lastMessage: "this is a test" })),
+    ).toBeDefined();
   });
 
   describe("toolName matching", () => {
     it("matches when toolNames includes the specified tool", () => {
       engine.add({ toolName: "get_weather" }, "Weather tool present");
-      expect(engine.match(makeReq({ toolNames: ["get_weather", "search"] }))).toBeDefined();
+      expect(
+        engine.match(makeReq({ toolNames: ["get_weather", "search"] })),
+      ).toBeDefined();
       expect(engine.match(makeReq({ toolNames: ["search"] }))).toBeUndefined();
     });
   });
@@ -143,8 +145,12 @@ describe("RuleEngine", () => {
   describe("toolCallId matching", () => {
     it("matches when lastToolCallId equals the specified id", () => {
       engine.add({ toolCallId: "call_abc" }, "Tool result");
-      expect(engine.match(makeReq({ lastToolCallId: "call_abc" }))).toBeDefined();
-      expect(engine.match(makeReq({ lastToolCallId: "call_xyz" }))).toBeUndefined();
+      expect(
+        engine.match(makeReq({ lastToolCallId: "call_abc" })),
+      ).toBeDefined();
+      expect(
+        engine.match(makeReq({ lastToolCallId: "call_xyz" })),
+      ).toBeUndefined();
       expect(engine.match(makeReq())).toBeUndefined();
     });
   });
@@ -155,7 +161,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,23 +172,32 @@ 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: [
-          { role: "system", content: "sys" },
-          { role: "user", content: "a" },
-          { role: "assistant", content: "b" },
-        ],
-      }))).toBeDefined();
+
+      expect(
+        engine.match(
+          makeReq({
+            model: "gpt-5.4",
+            messages: [
+              { role: "system", content: "sys" },
+              { role: "user", content: "a" },
+              { role: "assistant", content: "b" },
+            ],
+          }),
+        ),
+      ).toBeDefined();
     });
 
     it("predicate runs after other fields (short-circuits)", () => {
       let called = false;
       engine.add(
-        { model: "claude", predicate: () => { called = true; return true; } },
+        {
+          model: "claude",
+          predicate: () => {
+            called = true;
+            return true;
+          },
+        },
         "Never reached",
       );
       engine.match(makeReq({ model: "gpt-5.4" }));

package/src/types/index.ts

@@ -1,4 +0,0 @@
-export type { FormatName, MockRequest, Message, ToolDef } from "./request.js";
-export type { Reply, ReplyObject, ErrorReply, ToolCall, Resolver, ReplyOptions, SequenceEntry } from "./reply.js";
-export type { Match, MatchObject, PendingRule, RuleHandle, RuleSummary, Handler, Rule } from "./rule.js";
-export type { RecordedRequest } from "../history.js";