@ai-setting/roy-agent-cli 1.0.0

package/src/commands/interactive.shutdown.test.ts

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Interactive Shutdown Tests
+ * 
+ * TDD: 测试 InteractiveCommand 的 shutdown 功能和 EventSource 清理
+ */
+
+import { describe, test, expect, vi, beforeEach, afterEach } from "bun:test";
+
+describe("Interactive Shutdown Tests", () => {
+  describe("REPL should support graceful shutdown", () => {
+    test("REPL should have shutdown capability in options", async () => {
+      // Arrange - 测试接口定义是否包含 shutdown
+      const options = {
+        sessionId: "test",
+        sessionTitle: "Test",
+        onExecute: vi.fn(),
+        onStatus: vi.fn(),
+        onSwitchSession: vi.fn(),
+        onCompact: vi.fn(),
+        onShutdown: vi.fn(),  // 应该有 onShutdown 回调
+      };
+      
+      expect(typeof options.onShutdown).toBe("function");
+    });
+
+    test("exit commands should trigger shutdown callback", async () => {
+      // 这个测试验证 exit 命令会调用 onShutdown
+      // 由于 REPL 是内部类，我们通过集成测试来验证
+      // 这里我们验证 shutdown 逻辑的存在性
+      const mockShutdown = vi.fn();
+      
+      // 模拟 shutdown 逻辑
+      const shutdown = async () => {
+        await mockShutdown();
+      };
+      
+      await shutdown();
+      
+      expect(mockShutdown).toHaveBeenCalled();
+    });
+  });
+
+  describe("EventSource cleanup during shutdown", () => {
+    test("should stop running EventSource sources when shutting down", async () => {
+      // 验证 shutdown 时应该停止所有运行中的事件源
+      const mockStopSource = vi.fn().mockResolvedValue(undefined);
+      
+      // 模拟 EventSourceComponent
+      const mockEventSourceComponent = {
+        list: vi.fn().mockReturnValue([
+          { id: "es1", name: "Event Source 1" },
+          { id: "es2", name: "Event Source 2" },
+        ]),
+        getStatus: vi.fn().mockImplementation((id: string) => {
+          return id === "es1" ? "running" : "stopped";
+        }),
+        stopSource: mockStopSource,
+      };
+      
+      // 模拟 shutdown 逻辑
+      const shutdown = async () => {
+        const sources = mockEventSourceComponent.list();
+        for (const source of sources) {
+          const status = mockEventSourceComponent.getStatus(source.id);
+          if (status === "running") {
+            await mockEventSourceComponent.stopSource(source.id);
+          }
+        }
+      };
+      
+      await shutdown();
+      
+      // 验证只停止了运行中的源
+      expect(mockStopSource).toHaveBeenCalledTimes(1);
+      expect(mockStopSource).toHaveBeenCalledWith("es1");
+      expect(mockStopSource).not.toHaveBeenCalledWith("es2");
+    });
+
+    test("should handle multiple running EventSource sources", async () => {
+      const mockStopSource = vi.fn().mockResolvedValue(undefined);
+      
+      const mockEventSourceComponent = {
+        list: vi.fn().mockReturnValue([
+          { id: "es1", name: "Source 1" },
+          { id: "es2", name: "Source 2" },
+          { id: "es3", name: "Source 3" },
+        ]),
+        getStatus: vi.fn().mockImplementation((id: string) => {
+          return id === "es1" || id === "es3" ? "running" : "stopped";
+        }),
+        stopSource: mockStopSource,
+      };
+      
+      const shutdown = async () => {
+        const sources = mockEventSourceComponent.list();
+        for (const source of sources) {
+          const status = mockEventSourceComponent.getStatus(source.id);
+          if (status === "running") {
+            await mockEventSourceComponent.stopSource(source.id);
+          }
+        }
+      };
+      
+      await shutdown();
+      
+      expect(mockStopSource).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe("SIGINT handling", () => {
+    test("should register SIGINT handler for graceful shutdown", async () => {
+      // 验证 SIGINT 处理器应该被注册
+      const mockOn = vi.spyOn(process, "on").mockImplementation(() => process);
+      
+      // 模拟注册
+      const sigintHandler = vi.fn();
+      process.on("SIGINT", sigintHandler);
+      
+      expect(mockOn).toHaveBeenCalledWith("SIGINT", expect.any(Function));
+    });
+  });
+});

package/src/commands/interactive.test.ts

@@ -0,0 +1,221 @@
+/**
+ * @fileoverview InteractiveCommand Test
+ * 
+ * TDD: 测试 InteractiveCommand 的核心功能
+ * 
+ * 注意：由于 InteractiveCommand 涉及 readline 交互式输入，
+ * 我们主要测试其选项解析和命令注册逻辑
+ */
+
+import { describe, test, expect, vi, beforeEach, afterEach } from "bun:test";
+import { InteractiveCommand, type InteractiveOptions } from "./interactive";
+
+describe("InteractiveCommand", () => {
+  describe("command definition", () => {
+    test("should have correct command name", () => {
+      expect(InteractiveCommand.command).toBe("interactive");
+    });
+
+    test("should have aliases defined", () => {
+      expect(InteractiveCommand.aliases).toEqual(["i", "repl"]);
+    });
+
+    test("should have describe text", () => {
+      expect(typeof InteractiveCommand.describe).toBe("string");
+      expect(InteractiveCommand.describe.length).toBeGreaterThan(0);
+    });
+
+    test("should have builder function", () => {
+      expect(typeof InteractiveCommand.builder).toBe("function");
+    });
+
+    test("should have handler function", () => {
+      expect(typeof InteractiveCommand.handler).toBe("function");
+    });
+  });
+
+  describe("builder", () => {
+    test("should add options via builder", () => {
+      // Given
+      const mockYargs = {
+        option: vi.fn().mockReturnThis(),
+        positional: vi.fn().mockReturnThis(),
+      };
+
+      // When
+      InteractiveCommand.builder(mockYargs as any);
+
+      // Then - verify options were added
+      expect(mockYargs.option).toHaveBeenCalled();
+    });
+
+    test("should add session option", () => {
+      // Given
+      const mockYargs = {
+        option: vi.fn().mockReturnThis(),
+        positional: vi.fn().mockReturnThis(),
+      };
+
+      // When
+      InteractiveCommand.builder(mockYargs as any);
+
+      // Then - check if session option was added
+      const optionCalls = mockYargs.option.mock.calls;
+      const sessionOption = optionCalls.find(
+        (call: any[]) => call[0] === "session"
+      );
+      expect(sessionOption).toBeDefined();
+      expect(sessionOption[1].alias).toBe("s");
+    });
+
+    test("should add continue option", () => {
+      // Given
+      const mockYargs = {
+        option: vi.fn().mockReturnThis(),
+        positional: vi.fn().mockReturnThis(),
+      };
+
+      // When
+      InteractiveCommand.builder(mockYargs as any);
+
+      // Then - check if continue option was added
+      const optionCalls = mockYargs.option.mock.calls;
+      const continueOption = optionCalls.find(
+        (call: any[]) => call[0] === "continue"
+      );
+      expect(continueOption).toBeDefined();
+      expect(continueOption[1].alias).toBe("c");
+    });
+
+    test("should add config option", () => {
+      // Given
+      const mockYargs = {
+        option: vi.fn().mockReturnThis(),
+        positional: vi.fn().mockReturnThis(),
+      };
+
+      // When
+      InteractiveCommand.builder(mockYargs as any);
+
+      // Then - check if config option was added
+      const optionCalls = mockYargs.option.mock.calls;
+      const configOption = optionCalls.find(
+        (call: any[]) => call[0] === "config"
+      );
+      expect(configOption).toBeDefined();
+      expect(configOption[1].alias).toBe("C");
+    });
+
+    test("should add reasoning option", () => {
+      // Given
+      const mockYargs = {
+        option: vi.fn().mockReturnThis(),
+        positional: vi.fn().mockReturnThis(),
+      };
+
+      // When
+      InteractiveCommand.builder(mockYargs as any);
+
+      // Then - check if reasoning option was added
+      const optionCalls = mockYargs.option.mock.calls;
+      const reasoningOption = optionCalls.find(
+        (call: any[]) => call[0] === "reasoning"
+      );
+      expect(reasoningOption).toBeDefined();
+      expect(reasoningOption[1].alias).toBe("r");
+    });
+
+    test("should add tool-calls option", () => {
+      // Given
+      const mockYargs = {
+        option: vi.fn().mockReturnThis(),
+        positional: vi.fn().mockReturnThis(),
+      };
+
+      // When
+      InteractiveCommand.builder(mockYargs as any);
+
+      // Then - check if tool-calls option was added
+      const optionCalls = mockYargs.option.mock.calls;
+      const toolCallsOption = optionCalls.find(
+        (call: any[]) => call[0] === "tool-calls"
+      );
+      expect(toolCallsOption).toBeDefined();
+    });
+
+    test("should add tool-results option", () => {
+      // Given
+      const mockYargs = {
+        option: vi.fn().mockReturnThis(),
+        positional: vi.fn().mockReturnThis(),
+      };
+
+      // When
+      InteractiveCommand.builder(mockYargs as any);
+
+      // Then - check if tool-results option was added
+      const optionCalls = mockYargs.option.mock.calls;
+      const toolResultsOption = optionCalls.find(
+        (call: any[]) => call[0] === "tool-results"
+      );
+      expect(toolResultsOption).toBeDefined();
+    });
+  });
+
+  describe("InteractiveOptions interface", () => {
+    test("should allow optional session", () => {
+      const options: InteractiveOptions = {
+        session: undefined,
+        continue: false,
+        config: undefined,
+        reasoning: false,
+        toolCalls: false,
+        toolResults: false,
+      };
+      expect(options.session).toBeUndefined();
+    });
+
+    test("should allow explicit session", () => {
+      const options: InteractiveOptions = {
+        session: "sess_123",
+      };
+      expect(options.session).toBe("sess_123");
+    });
+
+    test("should allow continue flag", () => {
+      const options: InteractiveOptions = {
+        continue: true,
+      };
+      expect(options.continue).toBe(true);
+    });
+
+    test("should allow reasoning flag", () => {
+      const options: InteractiveOptions = {
+        reasoning: true,
+      };
+      expect(options.reasoning).toBe(true);
+    });
+
+    test("should allow tool-calls flag", () => {
+      const options: InteractiveOptions = {
+        toolCalls: true,
+      };
+      expect(options.toolCalls).toBe(true);
+    });
+
+    test("should allow tool-results flag", () => {
+      const options: InteractiveOptions = {
+        toolResults: true,
+      };
+      expect(options.toolResults).toBe(true);
+    });
+  });
+});
+
+describe("Interactive Command Integration", () => {
+  test("should have handler that handles options", async () => {
+    // Note: This test verifies the handler exists and is callable
+    // Actual handler testing would require mocking the entire environment
+    expect(typeof InteractiveCommand.handler).toBe("function");
+  });
+});