@ai-setting/roy-agent-cli 1.0.0

package/src/commands/shared/query-executor.test.ts

@@ -0,0 +1,434 @@
+/**
+ * @fileoverview QueryExecutor Test
+ * 
+ * TDD: 测试 QueryExecutor 的核心功能
+ */
+
+import { describe, test, expect, vi, beforeEach, afterEach } from "bun:test";
+import { QueryExecutor } from "./query-executor";
+import { OutputService } from "../../services/output.service";
+import { StreamOutputService, resetStreamAbort } from "../../services/stream-output.service";
+import { ContextHandlerService } from "../../services/context-handler.service";
+
+// Mock types
+interface MockEnvironment {
+  subscribeTo: ReturnType<typeof vi.fn>;
+  getComponent: ReturnType<typeof vi.fn>;
+}
+
+interface MockSessionComponent {
+  setSummaryComponents: ReturnType<typeof vi.fn>;
+}
+
+describe("QueryExecutor", () => {
+  let queryExecutor: QueryExecutor;
+  let mockEnv: MockEnvironment;
+  let mockSessionComponent: MockSessionComponent;
+  let mockOutput: OutputService;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // 重置全局 abort 状态，避免被其他测试污染
+    resetStreamAbort();
+    
+    // Create mock Environment
+    const mockUnsubscribe = vi.fn();
+    mockEnv = {
+      subscribeTo: vi.fn().mockReturnValue(mockUnsubscribe),
+      getComponent: vi.fn(),
+    };
+
+    mockSessionComponent = {
+      setSummaryComponents: vi.fn(),
+    };
+
+    mockOutput = new OutputService();
+    mockOutput.configure({ quiet: true });
+
+    // Spy on console
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    queryExecutor = new QueryExecutor({
+      env: mockEnv as any,
+      sessionComponent: mockSessionComponent as any,
+      output: mockOutput,
+      quiet: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    queryExecutor.dispose();
+  });
+
+  describe("constructor", () => {
+    test("should create instance with options", () => {
+      expect(queryExecutor).toBeDefined();
+    });
+  });
+
+  describe("initSummaryAgent()", () => {
+    test("should call setSummaryComponents on sessionComponent", () => {
+      // Given
+      const mockLLMComponent = {};
+      const mockPromptComponent = {};
+
+      // When
+      queryExecutor.initSummaryAgent(
+        mockLLMComponent as any,
+        mockPromptComponent as any
+      );
+
+      // Then
+      expect(mockSessionComponent.setSummaryComponents).toHaveBeenCalledWith(
+        mockPromptComponent,
+        mockLLMComponent
+      );
+    });
+  });
+
+  describe("subscribeToEvents()", () => {
+    test("should call env.subscribeTo with correct events", () => {
+      // Given
+      const options = {
+        showReasoning: true,
+        showToolCalls: false,
+        showToolResults: false,
+      };
+
+      // When
+      queryExecutor.subscribeToEvents(options);
+
+      // Then
+      expect(mockEnv.subscribeTo).toHaveBeenCalledWith(
+        expect.arrayContaining([
+          "llm.start",
+          "llm.text",
+          "llm.reasoning",
+          "llm.tool_call",
+          "llm.completed",
+          "llm.error",
+          "tool.result",
+          "tool.error",
+          "context.threshold_exceeded",
+          "context.compacting",
+          "context.compacted",
+        ]),
+        expect.any(Function)
+      );
+    });
+
+    test("should only subscribe once", () => {
+      // Given
+      const options = {
+        showReasoning: true,
+        showToolCalls: false,
+        showToolResults: false,
+      };
+
+      // When
+      queryExecutor.subscribeToEvents(options);
+      queryExecutor.subscribeToEvents(options);
+
+      // Then
+      expect(mockEnv.subscribeTo).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("dispose()", () => {
+    test("should call unsubscribe when disposed", () => {
+      // Given
+      const options = {
+        showReasoning: false,
+        showToolCalls: false,
+        showToolResults: false,
+      };
+      queryExecutor.subscribeToEvents(options);
+
+      // When
+      queryExecutor.dispose();
+
+      // Then
+      expect(mockEnv.subscribeTo).toHaveBeenCalled(); // unsubscribe was called via dispose
+    });
+
+    test("should handle dispose when not subscribed", () => {
+      // When & Then - should not throw
+      expect(() => queryExecutor.dispose()).not.toThrow();
+    });
+  });
+
+  describe("getFullText()", () => {
+    test("should return empty string when no stream service", () => {
+      // When
+      const result = queryExecutor.getFullText();
+
+      // Then
+      expect(result).toBe("");
+    });
+  });
+});
+
+describe("QueryExecutor compact", () => {
+  let queryExecutor: QueryExecutor;
+  let mockEnv: {
+    subscribeTo: ReturnType<typeof vi.fn>;
+    getComponent: ReturnType<typeof vi.fn>;
+  };
+  let mockSessionComponent: {
+    setSummaryComponents: ReturnType<typeof vi.fn>;
+    compact: ReturnType<typeof vi.fn>;
+  };
+  let mockOutput: OutputService;
+
+  beforeEach(() => {
+    const mockUnsubscribe = vi.fn();
+    mockEnv = {
+      subscribeTo: vi.fn().mockReturnValue(mockUnsubscribe),
+      getComponent: vi.fn().mockReturnValue({
+        pushEnvEvent: vi.fn(),
+      }),
+    };
+
+    mockSessionComponent = {
+      setSummaryComponents: vi.fn(),
+      compact: vi.fn().mockResolvedValue({
+        checkpoint: {
+          id: "cp_test_123",
+          sessionId: "s_test",
+          summary: "Test summary",
+          createdAt: new Date().toISOString(),
+        },
+        deletedMessageCount: 5,
+      }),
+    };
+
+    mockOutput = new OutputService();
+    mockOutput.configure({ quiet: true });
+
+    queryExecutor = new QueryExecutor({
+      env: mockEnv as any,
+      sessionComponent: mockSessionComponent as any,
+      output: mockOutput,
+      quiet: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    queryExecutor.dispose();
+  });
+
+  describe("compact()", () => {
+    test("should call sessionComponent.compact with sessionId", async () => {
+      // Given
+      const sessionId = "s_test_123";
+
+      // When
+      await queryExecutor.compact(sessionId);
+
+      // Then
+      expect(mockSessionComponent.compact).toHaveBeenCalledWith(
+        sessionId,
+        expect.objectContaining({
+          summary: expect.any(String),
+        })
+      );
+    });
+
+    test("should publish context.compacting event before compact", async () => {
+      // Given
+      const sessionId = "s_test_123";
+      const pushEnvEvent = vi.fn();
+      (mockEnv.getComponent as any).mockReturnValue({
+        pushEnvEvent,
+      });
+
+      // When
+      await queryExecutor.compact(sessionId);
+
+      // Then
+      expect(pushEnvEvent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "context.compacting",
+        })
+      );
+    });
+
+    test("should publish context.compacted event after compact", async () => {
+      // Given
+      const sessionId = "s_test_123";
+      const pushEnvEvent = vi.fn();
+      (mockEnv.getComponent as any).mockReturnValue({
+        pushEnvEvent,
+      });
+
+      // When
+      await queryExecutor.compact(sessionId);
+
+      // Then
+      expect(pushEnvEvent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: "context.compacted",
+          payload: expect.objectContaining({
+            checkpointId: "cp_test_123",
+            messagesCompacted: 5,
+          }),
+        })
+      );
+    });
+
+    test("should return compact result", async () => {
+      // Given
+      const sessionId = "s_test_123";
+
+      // When
+      const result = await queryExecutor.compact(sessionId);
+
+      // Then
+      expect(result).toEqual({
+        success: true,
+        checkpoint: expect.objectContaining({
+          id: "cp_test_123",
+        }),
+        deletedMessageCount: 5,
+      });
+    });
+
+    test("should return error result when compact fails", async () => {
+      // Given
+      const sessionId = "s_test_123";
+      mockSessionComponent.compact = vi.fn().mockRejectedValue(
+        new Error("Compact failed")
+      );
+
+      // When
+      const result = await queryExecutor.compact(sessionId);
+
+      // Then
+      expect(result).toEqual({
+        success: false,
+        error: "Compact failed",
+      });
+    });
+  });
+});
+
+describe("QueryExecutor Event Handling", () => {
+  let queryExecutor: QueryExecutor;
+  let mockEnv: MockEnvironment;
+  let mockSessionComponent: MockSessionComponent;
+  let mockOutput: OutputService;
+  let eventHandler: (event: any) => void;
+  let mockUnsubscribe: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    mockUnsubscribe = vi.fn();
+    mockEnv = {
+      subscribeTo: vi.fn().mockImplementation((events, handler) => {
+        eventHandler = handler;
+        return mockUnsubscribe;
+      }),
+      getComponent: vi.fn(),
+    };
+
+    mockSessionComponent = {
+      setSummaryComponents: vi.fn(),
+    };
+
+    mockOutput = new OutputService();
+    mockOutput.configure({ quiet: true });
+
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+
+    queryExecutor = new QueryExecutor({
+      env: mockEnv as any,
+      sessionComponent: mockSessionComponent as any,
+      output: mockOutput,
+      quiet: true,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    queryExecutor.dispose();
+  });
+
+  describe("handleEvent", () => {
+    test("should handle llm.tool_call event when showToolCalls is true", () => {
+      // Given
+      queryExecutor.subscribeToEvents({
+        showReasoning: false,
+        showToolCalls: true,
+        showToolResults: false,
+      });
+
+      const event = {
+        type: "llm.tool_call",
+        payload: {
+          toolCall: {
+            name: "testTool",
+            arguments: '{"input": "test"}',
+          },
+        },
+      };
+
+      // When
+      eventHandler(event);
+
+      // Then
+      expect(console.log).toHaveBeenCalled();
+    });
+
+    test("should not log tool_call when showToolCalls is false", () => {
+      // Given
+      queryExecutor.subscribeToEvents({
+        showReasoning: false,
+        showToolCalls: false,
+        showToolResults: false,
+      });
+
+      const event = {
+        type: "llm.tool_call",
+        payload: {
+          toolCall: {
+            name: "testTool",
+            arguments: '{"input": "test"}',
+          },
+        },
+      };
+
+      // When
+      eventHandler(event);
+
+      // Then
+      expect(console.log).not.toHaveBeenCalled();
+    });
+
+    test("should handle tool.error event", () => {
+      // Given
+      queryExecutor.subscribeToEvents({
+        showReasoning: false,
+        showToolCalls: false,
+        showToolResults: false,
+      });
+
+      const event = {
+        type: "tool.error",
+        payload: {
+          toolName: "failingTool",
+          error: "Tool execution failed",
+        },
+      };
+
+      // When
+      eventHandler(event);
+
+      // Then
+      expect(console.error).toHaveBeenCalled();
+    });
+  });
+});