@flink-app/test-utils 1.0.0 → 2.0.0-alpha.49

package/spec/ai/mockLLMAdapter.spec.ts

@@ -0,0 +1,533 @@
+import { mockLLMAdapter, createStreamingChunks } from "../../src/ai/mockLLMAdapter";
+import { LLMStreamChunk } from "@flink-app/flink/ai";
+
+// Helper to consume stream and extract result
+async function consumeStream(adapter: any, params: any) {
+  const chunks: LLMStreamChunk[] = [];
+  for await (const chunk of adapter.stream(params)) {
+    chunks.push(chunk);
+  }
+
+  const textChunks = chunks.filter(c => c.type === "text");
+  const toolCallChunks = chunks.filter(c => c.type === "tool_call");
+  const usageChunk = chunks.find(c => c.type === "usage") as any;
+  const doneChunk = chunks.find(c => c.type === "done") as any;
+
+  return {
+    textContent: textChunks.length > 0 ? textChunks.map((c: any) => c.delta).join("") : undefined,
+    toolCalls: toolCallChunks.map((c: any) => c.toolCall),
+    usage: usageChunk?.usage,
+    stopReason: doneChunk?.stopReason,
+    chunks,
+  };
+}
+
+describe("mockLLMAdapter", () => {
+  describe("simple response", () => {
+    it("should return canned response", async () => {
+      const adapter = mockLLMAdapter({ response: "Hello!" });
+
+      const result = await consumeStream(adapter, {
+        instructions: "You are helpful",
+        messages: [{ role: "user", content: "Hi" }],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result.textContent).toBe("Hello!");
+      expect(result.toolCalls).toEqual([]);
+      expect(result.stopReason).toBe("end_turn");
+      expect(result.usage).toEqual({ inputTokens: 10, outputTokens: 20 });
+    });
+
+    it("should track invocations", async () => {
+      const adapter = mockLLMAdapter({ response: "Test" });
+
+      await consumeStream(adapter, {
+        instructions: "System",
+        messages: [{ role: "user", content: "Hello" }],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(adapter.invocations.length).toBe(1);
+      expect(adapter.getInvocationCount()).toBe(1);
+      expect(adapter.getLastInvocation()?.instructions).toBe("System");
+      expect(adapter.getLastInvocation()?.messages[0]).toEqual({
+        role: "user",
+        content: "Hello",
+      });
+    });
+  });
+
+  describe("multi-turn responses", () => {
+    it("should queue multiple responses", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [
+          { text: "First response" },
+          { text: "Second response" },
+          { text: "Third response" },
+        ],
+      });
+
+      const result1 = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [{ role: "user", content: "1" }],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      const result2 = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [{ role: "user", content: "2" }],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      const result3 = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [{ role: "user", content: "3" }],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result1.textContent).toBe("First response");
+      expect(result2.textContent).toBe("Second response");
+      expect(result3.textContent).toBe("Third response");
+      expect(adapter.invocations.length).toBe(3);
+    });
+
+    it("should reuse last response when queue exhausted", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [{ text: "First" }, { text: "Last" }],
+      });
+
+      await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+      await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+      const result3 = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result3.textContent).toBe("Last");
+    });
+  });
+
+  describe("tool calls", () => {
+    it("should return tool calls", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [
+          {
+            text: "Let me check",
+            toolCalls: [
+              { id: "1", name: "get_weather", input: { city: "Stockholm" } },
+            ],
+          },
+        ],
+      });
+
+      const result = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [{ role: "user", content: "Weather?" }],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result.textContent).toBe("Let me check");
+      expect(result.toolCalls).toEqual([
+        { id: "1", name: "get_weather", input: { city: "Stockholm" } },
+      ]);
+      expect(result.stopReason).toBe("tool_use");
+    });
+
+    it("should set stop reason to tool_use when tool calls present", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [
+          {
+            toolCalls: [{ id: "1", name: "test", input: {} }],
+          },
+        ],
+      });
+
+      const result = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result.stopReason).toBe("tool_use");
+    });
+
+    it("should respect explicit stop reason", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [
+          {
+            text: "Partial",
+            stopReason: "max_tokens",
+          },
+        ],
+      });
+
+      const result = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result.stopReason).toBe("max_tokens");
+    });
+  });
+
+  describe("error simulation", () => {
+    it("should throw configured error", async () => {
+      const testError = new Error("Rate limit exceeded");
+      const adapter = mockLLMAdapter({ error: testError });
+
+      await expectAsync(
+        consumeStream(adapter, {
+          instructions: "System",
+          messages: [],
+          tools: [],
+          maxTokens: 1024,
+          temperature: 0.7,
+        })
+      ).toBeRejectedWith(testError);
+    });
+
+    it("should track invocations before throwing", async () => {
+      const adapter = mockLLMAdapter({ error: new Error("Test error") });
+
+      try {
+        await consumeStream(adapter, {
+          instructions: "System",
+          messages: [{ role: "user", content: "Test" }],
+          tools: [],
+          maxTokens: 1024,
+          temperature: 0.7,
+        });
+      } catch (e) {
+        // Expected
+      }
+
+      expect(adapter.invocations.length).toBe(1);
+      expect(adapter.getLastInvocation()?.messages[0]).toEqual({
+        role: "user",
+        content: "Test",
+      });
+    });
+  });
+
+  describe("utilities", () => {
+    it("should reset invocations", async () => {
+      const adapter = mockLLMAdapter({ response: "Test" });
+
+      await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+      await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(adapter.invocations.length).toBe(2);
+
+      adapter.reset();
+
+      expect(adapter.invocations.length).toBe(0);
+      expect(adapter.getInvocationCount()).toBe(0);
+      expect(adapter.getLastInvocation()).toBeUndefined();
+    });
+
+    it("should reset response queue index", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [{ text: "First" }, { text: "Second" }],
+      });
+
+      await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+      await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      adapter.reset();
+
+      const result = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result.textContent).toBe("First");
+    });
+  });
+
+  describe("custom usage", () => {
+    it("should use custom token usage", async () => {
+      const adapter = mockLLMAdapter({
+        response: "Test",
+        usage: { inputTokens: 100, outputTokens: 50 },
+      });
+
+      const result = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result.usage).toEqual({ inputTokens: 100, outputTokens: 50 });
+    });
+  });
+
+  describe("streaming", () => {
+    it("should stream text deltas progressively", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [{
+          text: "Hello world",
+          streamChunks: [
+            { type: "text", delta: "Hello " },
+            { type: "text", delta: "world" },
+            { type: "usage", usage: { inputTokens: 10, outputTokens: 5 } },
+            { type: "done", stopReason: "end_turn" },
+          ],
+        }],
+      });
+
+      const chunks: any[] = [];
+      for await (const chunk of adapter.stream({
+        instructions: "Test",
+        messages: [{ role: "user", content: "Hello" }],
+        tools: [],
+        maxTokens: 100,
+        temperature: 0.7,
+      })) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks).toEqual([
+        { type: "text", delta: "Hello " },
+        { type: "text", delta: "world" },
+        { type: "usage", usage: { inputTokens: 10, outputTokens: 5 } },
+        { type: "done", stopReason: "end_turn" },
+      ]);
+    });
+
+    it("should stream tool calls", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [{
+          text: "",
+          toolCalls: [
+            { id: "tool1", name: "search", input: { query: "test" } },
+          ],
+          streamChunks: [
+            {
+              type: "tool_call",
+              toolCall: { id: "tool1", name: "search", input: { query: "test" } }
+            },
+            { type: "usage", usage: { inputTokens: 10, outputTokens: 5 } },
+            { type: "done", stopReason: "tool_use" },
+          ],
+        }],
+      });
+
+      const chunks: any[] = [];
+      for await (const chunk of adapter.stream({
+        instructions: "Test",
+        messages: [{ role: "user", content: "Search" }],
+        tools: [{ name: "search", description: "Search", inputSchema: {} }],
+        maxTokens: 100,
+        temperature: 0.7,
+      })) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks.length).toBe(3);
+      expect(chunks[0].type).toBe("tool_call");
+      expect(chunks[1].type).toBe("usage");
+      expect(chunks[2].type).toBe("done");
+    });
+
+    it("should generate chunks from response if streamChunks not provided", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [{
+          text: "Hello world",
+          toolCalls: [],
+        }],
+        usage: { inputTokens: 10, outputTokens: 5 },
+      });
+
+      const chunks: any[] = [];
+      for await (const chunk of adapter.stream({
+        instructions: "Test",
+        messages: [{ role: "user", content: "Hello" }],
+        tools: [],
+        maxTokens: 100,
+        temperature: 0.7,
+      })) {
+        chunks.push(chunk);
+      }
+
+      expect(chunks.length).toBe(3); // text, usage, done
+      expect(chunks[0].type).toBe("text");
+      expect(chunks[0].delta).toBe("Hello world");
+      expect(chunks[1].type).toBe("usage");
+      expect(chunks[2].type).toBe("done");
+    });
+
+    it("should track invocations for streaming", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [{ text: "Test" }],
+      });
+
+      const generator = adapter.stream({
+        instructions: "Stream system",
+        messages: [{ role: "user", content: "Stream test" }],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      // Consume the stream
+      for await (const chunk of generator) {
+        // Just consume
+      }
+
+      expect(adapter.invocations.length).toBe(1);
+      expect(adapter.getLastInvocation()?.instructions).toBe(
+        "Stream system"
+      );
+    });
+  });
+
+  describe("edge cases", () => {
+    it("should throw when no responses configured", async () => {
+      const adapter = mockLLMAdapter({});
+
+      await expectAsync(
+        consumeStream(adapter, {
+          instructions: "System",
+          messages: [],
+          tools: [],
+          maxTokens: 1024,
+          temperature: 0.7,
+        })
+      ).toBeRejectedWithError("No responses configured for mockLLMAdapter");
+    });
+
+    it("should handle undefined text content", async () => {
+      const adapter = mockLLMAdapter({
+        responses: [{ toolCalls: [{ id: "1", name: "test", input: {} }] }],
+      });
+
+      const result = await consumeStream(adapter, {
+        instructions: "System",
+        messages: [],
+        tools: [],
+        maxTokens: 1024,
+        temperature: 0.7,
+      });
+
+      expect(result.textContent).toBeUndefined();
+      expect(result.toolCalls.length).toBe(1);
+    });
+  });
+
+  describe("createStreamingChunks helper", () => {
+    it("should create chunks with single text delta", () => {
+      const chunks = createStreamingChunks({
+        text: "Hello world",
+        chunkText: false,
+      });
+
+      expect(chunks.length).toBe(3); // text, usage, done
+      expect(chunks[0]).toEqual({ type: "text", delta: "Hello world" });
+      expect(chunks[1].type).toBe("usage");
+      expect(chunks[2].type).toBe("done");
+    });
+
+    it("should create chunks with multiple text deltas", () => {
+      const chunks = createStreamingChunks({
+        text: "Hello world",
+        chunkText: true,
+      });
+
+      expect(chunks.filter(c => c.type === "text").length).toBeGreaterThan(1);
+      const textChunks = chunks.filter(c => c.type === "text");
+      const fullText = textChunks.map((c: any) => c.delta).join("");
+      expect(fullText).toBe("Hello world ");
+      expect(chunks.some(c => c.type === "usage")).toBe(true);
+      expect(chunks.some(c => c.type === "done")).toBe(true);
+    });
+
+    it("should create chunks with tool calls", () => {
+      const chunks = createStreamingChunks({
+        text: "Searching...",
+        toolCalls: [
+          { id: "1", name: "search", input: { query: "test" } },
+        ],
+      });
+
+      const toolCallChunk = chunks.find(c => c.type === "tool_call");
+      expect(toolCallChunk).toBeDefined();
+      expect((toolCallChunk as any).toolCall.name).toBe("search");
+    });
+
+    it("should create chunks with custom usage and stop reason", () => {
+      const chunks = createStreamingChunks({
+        text: "Done",
+        usage: { inputTokens: 200, outputTokens: 100 },
+        stopReason: "max_tokens",
+      });
+
+      const usageChunk = chunks.find(c => c.type === "usage");
+      const doneChunk = chunks.find(c => c.type === "done");
+
+      expect((usageChunk as any).usage).toEqual({ inputTokens: 200, outputTokens: 100 });
+      expect((doneChunk as any).stopReason).toBe("max_tokens");
+    });
+  });
+});