@xiaozhi-client/cli 1.9.4-beta.10

package/src/commands/__tests__/CommandHandlerFactory.test.ts

@@ -0,0 +1,323 @@
+/**
+ * CommandHandlerFactory 单元测试
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { IDIContainer } from "../../interfaces/Config.js";
+import { CommandHandlerFactory } from "../CommandHandlerFactory.js";
+
+describe("CommandHandlerFactory", () => {
+  let mockContainer: IDIContainer;
+  let factory: CommandHandlerFactory;
+
+  beforeEach(() => {
+    mockContainer = {
+      register: vi.fn(),
+      get: vi.fn(),
+      has: vi.fn(),
+    };
+
+    factory = new CommandHandlerFactory(mockContainer);
+    vi.clearAllMocks();
+  });
+
+  describe("构造函数", () => {
+    it("应该正确初始化工厂实例", () => {
+      expect(factory).toBeInstanceOf(CommandHandlerFactory);
+      expect(factory).toBeDefined();
+    });
+
+    it("应该接受依赖注入容器", () => {
+      // 验证工厂可以被创建，说明容器参数被正确接受
+      expect(factory).toBeDefined();
+    });
+  });
+
+  describe("createHandler - 错误处理", () => {
+    it("对于未知类型应该抛出错误", () => {
+      expect(() => {
+        factory.createHandler("unknown");
+      }).toThrow("未知的命令处理器类型: unknown");
+    });
+
+    it("应该抛出包含具体类型信息的错误", () => {
+      try {
+        factory.createHandler("invalid_type");
+        expect.fail("应该抛出错误");
+      } catch (error) {
+        const err = error as Error;
+        expect(err).toBeInstanceOf(Error);
+        expect(err.message).toContain("invalid_type");
+        expect(err.message).toContain("未知的命令处理器类型");
+      }
+    });
+
+    it("应该处理空字符串类型", () => {
+      expect(() => {
+        factory.createHandler("");
+      }).toThrow("未知的命令处理器类型: ");
+    });
+
+    it("应该处理特殊字符类型", () => {
+      expect(() => {
+        factory.createHandler("@#$%");
+      }).toThrow("未知的命令处理器类型: @#$%");
+    });
+
+    it("应该处理数字类型字符串", () => {
+      expect(() => {
+        factory.createHandler("123");
+      }).toThrow("未知的命令处理器类型: 123");
+    });
+
+    it("应该处理混合大小写类型", () => {
+      expect(() => {
+        factory.createHandler("Service");
+      }).toThrow("未知的命令处理器类型: Service");
+    });
+
+    it("应该处理 null 和 undefined 类型", () => {
+      expect(() => {
+        factory.createHandler(null as any);
+      }).toThrow("未知的命令处理器类型: null");
+
+      expect(() => {
+        factory.createHandler(undefined as any);
+      }).toThrow("未知的命令处理器类型: undefined");
+    });
+
+    it("应该处理对象类型的参数", () => {
+      expect(() => {
+        factory.createHandler({} as any);
+      }).toThrow("未知的命令处理器类型: [object Object]");
+    });
+
+    it("应该处理数组类型的参数", () => {
+      expect(() => {
+        factory.createHandler([] as any);
+      }).toThrow("未知的命令处理器类型: ");
+    });
+
+    it("应该处理函数类型的参数", () => {
+      expect(() => {
+        factory.createHandler((() => {}) as any);
+      }).toThrow(/未知的命令处理器类型: /);
+    });
+  });
+
+  describe("错误处理的完整性", () => {
+    it("应该提供清晰的错误信息", () => {
+      const invalidTypes = [
+        "",
+        "nonexistent",
+        "123",
+        "Service",
+        null,
+        undefined,
+      ];
+
+      for (const type of invalidTypes) {
+        try {
+          factory.createHandler(type as any);
+          expect.fail(`应该为类型 ${type} 抛出错误`);
+        } catch (error) {
+          const err = error as Error;
+          expect(err).toBeInstanceOf(Error);
+          expect(err.message).toContain("未知的命令处理器类型");
+          expect(err.message).toContain(String(type));
+        }
+      }
+    });
+
+    it("应该保证错误信息的一致性", () => {
+      try {
+        factory.createHandler("test");
+      } catch (error1) {
+        try {
+          factory.createHandler("another");
+        } catch (error2) {
+          const err1 = error1 as Error;
+          const err2 = error2 as Error;
+          expect(err1.message).toContain("未知的命令处理器类型");
+          expect(err2.message).toContain("未知的命令处理器类型");
+          expect(err1.message.length).toBeGreaterThan(0);
+          expect(err2.message.length).toBeGreaterThan(0);
+        }
+      }
+    });
+  });
+
+  describe("依赖注入容器的使用", () => {
+    it("应该能够在不同容器实例间独立工作", () => {
+      const container1: IDIContainer = {
+        register: vi.fn(),
+        get: vi.fn(),
+        has: vi.fn(),
+      };
+
+      const container2: IDIContainer = {
+        register: vi.fn(),
+        get: vi.fn(),
+        has: vi.fn(),
+      };
+
+      const factory1 = new CommandHandlerFactory(container1);
+      const factory2 = new CommandHandlerFactory(container2);
+
+      expect(factory1).toBeDefined();
+      expect(factory2).toBeDefined();
+      expect(container1).not.toBe(container2);
+    });
+
+    it("应该保存容器的引用", () => {
+      // 验证工厂实例被正确创建，说明容器被保存
+      expect(factory).toBeDefined();
+    });
+  });
+
+  describe("createHandler 方法的参数验证", () => {
+    it("应该正确处理各种无效输入", () => {
+      const invalidInputs = [
+        null,
+        undefined,
+        "",
+        123,
+        {},
+        [],
+        () => {},
+        true,
+        false,
+        0,
+        -1,
+        Number.POSITIVE_INFINITY,
+        Number.NaN,
+      ];
+
+      for (const input of invalidInputs) {
+        expect(() => {
+          factory.createHandler(input as any);
+        }).toThrow();
+      }
+    });
+
+    it("应该为所有支持的处理器类型抛出模块不存在的错误", () => {
+      const supportedTypes = [
+        "service",
+        "config",
+        "project",
+        "mcp",
+        "endpoint",
+      ];
+
+      for (const type of supportedTypes) {
+        expect(() => {
+          factory.createHandler(type);
+        }).toThrow();
+      }
+    });
+  });
+
+  describe("工厂模式的核心逻辑", () => {
+    it("应该有正确的类型判断逻辑", () => {
+      // 测试 switch 语句的逻辑
+      const types = ["service", "config", "project", "mcp", "endpoint"];
+
+      for (const type of types) {
+        // 这些应该尝试加载模块（会失败，但不会在 switch 语句中抛出错误）
+        expect(() => {
+          try {
+            factory.createHandler(type);
+          } catch (error) {
+            // 错误应该来自模块加载，而不是类型判断
+            const err = error as Error;
+            expect(err.message).not.toContain("switch");
+            throw error;
+          }
+        }).toThrow();
+      }
+    });
+
+    it("应该为所有已知类型提供错误处理", () => {
+      const knownTypes = [
+        { type: "service", module: "ServiceCommandHandler.js" },
+        { type: "config", module: "ConfigCommandHandler.js" },
+        { type: "project", module: "ProjectCommandHandler.js" },
+        { type: "mcp", module: "McpCommandHandler.js" },
+        { type: "endpoint", module: "EndpointCommandHandler.js" },
+      ];
+
+      for (const { type, module } of knownTypes) {
+        try {
+          factory.createHandler(type);
+        } catch (error) {
+          // 错误应该是模块加载错误，而不是类型错误
+          const err = error as Error;
+          expect(err.message).toContain("Cannot find module");
+          expect(err.message).toContain(module);
+        }
+      }
+    });
+  });
+
+  describe("接口实现验证", () => {
+    it("应该实现 ICommandHandlerFactory 接口", () => {
+      expect(factory.createHandlers).toBeDefined();
+      expect(factory.createHandler).toBeDefined();
+      expect(typeof factory.createHandlers).toBe("function");
+      expect(typeof factory.createHandler).toBe("function");
+    });
+
+    it("应该有正确的方法签名", () => {
+      // createHandlers 不需要参数
+      expect(() => factory.createHandlers()).toThrow();
+
+      // createHandler 需要一个字符串参数
+      expect(() => factory.createHandler("test")).toThrow();
+      expect(() => factory.createHandler(undefined as any)).toThrow();
+    });
+  });
+
+  describe("错误边界", () => {
+    it("应该处理极端的输入情况", () => {
+      const extremeInputs = [
+        -0,
+        +0,
+        "",
+        " ",
+        "\t",
+        "\n",
+        "\r",
+        "\u0000",
+        "\uFFFF",
+        {},
+        { toString: () => "test" },
+        [],
+        [1, 2, 3],
+        new Date(0),
+        /regex/,
+        new Error("test"),
+      ];
+
+      for (const input of extremeInputs) {
+        expect(() => {
+          factory.createHandler(input as any);
+        }).toThrow();
+      }
+    });
+
+    it("应该为所有错误提供一致的错误格式", () => {
+      const testCases = ["", "test", "123", null, undefined];
+
+      for (const input of testCases) {
+        try {
+          factory.createHandler(input as any);
+        } catch (error) {
+          const err = error as Error;
+          expect(err).toBeInstanceOf(Error);
+          expect(err.message).toContain("未知的命令处理器类型");
+          expect(err.message.length).toBeGreaterThan(0);
+        }
+      }
+    });
+  });
+});

package/src/commands/__tests__/CommandRegistry.test.ts

@@ -0,0 +1,287 @@
+import { Command } from "commander";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { IDIContainer } from "../../interfaces/Config";
+import { CommandRegistry } from "../index";
+
+// Mock ServiceCommandHandler
+const mockServiceCommandHandler = {
+  name: "service",
+  description: "服务管理命令",
+  execute: vi.fn(),
+  subcommands: [
+    {
+      name: "start",
+      description: "启动服务",
+      options: [
+        { flags: "-d, --daemon", description: "后台运行模式" },
+        { flags: "-p, --port <port>", description: "指定端口" },
+      ],
+      execute: vi.fn(),
+    },
+    {
+      name: "stop",
+      description: "停止服务",
+      execute: vi.fn(),
+    },
+    {
+      name: "status",
+      description: "检查服务状态",
+      execute: vi.fn(),
+    },
+  ],
+};
+
+// Mock other command handlers
+const mockConfigCommandHandler = {
+  name: "config",
+  description: "配置管理命令",
+  execute: vi.fn(),
+  subcommands: [],
+};
+
+const mockProjectCommandHandler = {
+  name: "project",
+  description: "项目管理命令",
+  execute: vi.fn(),
+  subcommands: [],
+};
+
+const mockMcpCommandHandler = {
+  name: "mcp",
+  description: "MCP 服务和工具管理",
+  execute: vi.fn(),
+  subcommands: [],
+};
+
+const mockEndpointCommandHandler = {
+  name: "endpoint",
+  description: "端点管理命令",
+  execute: vi.fn(),
+  subcommands: [],
+};
+
+// Mock CommandHandlerFactory
+vi.mock("./CommandHandlerFactory.js", () => ({
+  CommandHandlerFactory: vi.fn().mockImplementation(() => ({
+    createHandlers: vi
+      .fn()
+      .mockReturnValue([
+        mockServiceCommandHandler,
+        mockConfigCommandHandler,
+        mockProjectCommandHandler,
+        mockMcpCommandHandler,
+        mockEndpointCommandHandler,
+      ]),
+  })),
+}));
+
+// Mock ErrorHandler
+vi.mock("../errors/ErrorHandlers.js", () => ({
+  ErrorHandler: {
+    handle: vi.fn(),
+  },
+}));
+
+// Create mock DI container
+const mockContainer: IDIContainer = {
+  get: vi.fn().mockImplementation(<T>(serviceName: string): T => {
+    switch (serviceName) {
+      case "versionUtils":
+        return {
+          getVersion: vi.fn().mockReturnValue("1.0.0"),
+        } as T;
+      default:
+        return {} as T;
+    }
+  }),
+  register: vi.fn(),
+  has: vi.fn(),
+};
+
+describe("CommandRegistry - 传统服务命令", () => {
+  let commandRegistry: CommandRegistry;
+  let program: Command;
+
+  beforeEach(() => {
+    commandRegistry = new CommandRegistry(mockContainer);
+    program = new Command();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("registerLegacyServiceCommands 注册传统服务命令", () => {
+    it("应注册传统服务命令并正确解析选项", async () => {
+      // 创建 handlers 数组
+      const handlers = [mockServiceCommandHandler];
+
+      // 注册命令
+      (commandRegistry as any).registerLegacyServiceCommands(program, handlers);
+
+      // 验证命令是否正确注册
+      const startCommand = program.commands.find(
+        (cmd) => cmd.name() === "start"
+      );
+      expect(startCommand).toBeDefined();
+      expect(startCommand!.description()).toBe("启动服务");
+
+      // 验证选项是否正确注册
+      const options = startCommand!.options;
+      expect(options.some((opt) => opt.flags === "-d, --daemon")).toBe(true);
+      expect(options.some((opt) => opt.flags === "-p, --port <port>")).toBe(
+        true
+      );
+    });
+
+    it("应注册所有服务子命令", async () => {
+      const handlers = [mockServiceCommandHandler];
+      (commandRegistry as any).registerLegacyServiceCommands(program, handlers);
+
+      // 验证所有子命令都被注册为顶级命令
+      const startCommand = program.commands.find(
+        (cmd) => cmd.name() === "start"
+      );
+      const stopCommand = program.commands.find((cmd) => cmd.name() === "stop");
+      const statusCommand = program.commands.find(
+        (cmd) => cmd.name() === "status"
+      );
+
+      expect(startCommand).toBeDefined();
+      expect(stopCommand).toBeDefined();
+      expect(statusCommand).toBeDefined();
+
+      expect(startCommand!.description()).toBe("启动服务");
+      expect(stopCommand!.description()).toBe("停止服务");
+      expect(statusCommand!.description()).toBe("检查服务状态");
+    });
+
+    it("应处理没有服务处理器的情况", async () => {
+      const handlers = [mockConfigCommandHandler]; // 没有服务处理器
+      (commandRegistry as any).registerLegacyServiceCommands(program, handlers);
+
+      // 验证没有注册任何服务命令
+      const startCommand = program.commands.find(
+        (cmd) => cmd.name() === "start"
+      );
+      expect(startCommand).toBeUndefined();
+    });
+
+    it("应处理服务处理器没有子命令的情况", async () => {
+      const handlerWithoutSubcommands = {
+        ...mockServiceCommandHandler,
+        subcommands: undefined,
+      };
+      const handlers = [handlerWithoutSubcommands];
+
+      (commandRegistry as any).registerLegacyServiceCommands(program, handlers);
+
+      // 验证没有注册任何服务命令
+      const startCommand = program.commands.find(
+        (cmd) => cmd.name() === "start"
+      );
+      expect(startCommand).toBeUndefined();
+    });
+  });
+
+  describe("服务命令业务逻辑测试", () => {
+    it("应正确执行 start 命令并传递选项", async () => {
+      const startSubcommand = mockServiceCommandHandler.subcommands[0];
+
+      await startSubcommand.execute([], {
+        daemon: true,
+        port: "3000",
+      });
+
+      expect(
+        mockServiceCommandHandler.subcommands[0].execute
+      ).toHaveBeenCalledWith([], {
+        daemon: true,
+        port: "3000",
+      });
+    });
+
+    it("应正确执行 start 命令并传递位置参数", async () => {
+      const startSubcommand = mockServiceCommandHandler.subcommands[0];
+
+      await startSubcommand.execute(["arg1", "arg2"], {
+        daemon: true,
+      });
+
+      expect(
+        mockServiceCommandHandler.subcommands[0].execute
+      ).toHaveBeenCalledWith(["arg1", "arg2"], {
+        daemon: true,
+      });
+    });
+
+    it("应正确执行 stop 命令", async () => {
+      const stopSubcommand = mockServiceCommandHandler.subcommands[1];
+
+      await stopSubcommand.execute([], {});
+
+      expect(
+        mockServiceCommandHandler.subcommands[1].execute
+      ).toHaveBeenCalledWith([], {});
+    });
+
+    it("应正确执行 status 命令", async () => {
+      const statusSubcommand = mockServiceCommandHandler.subcommands[2];
+
+      await statusSubcommand.execute([], {});
+
+      expect(
+        mockServiceCommandHandler.subcommands[2].execute
+      ).toHaveBeenCalledWith([], {});
+    });
+  });
+
+  describe("选项解析边界情况", () => {
+    it("应正确处理布尔标志", async () => {
+      const startSubcommand = mockServiceCommandHandler.subcommands[0];
+
+      await startSubcommand.execute([], {
+        daemon: true,
+        verbose: false,
+        help: undefined,
+      });
+
+      expect(
+        mockServiceCommandHandler.subcommands[0].execute
+      ).toHaveBeenCalledWith([], {
+        daemon: true,
+        verbose: false,
+        help: undefined,
+      });
+    });
+
+    it("应正确处理字符串选项", async () => {
+      const startSubcommand = mockServiceCommandHandler.subcommands[0];
+
+      await startSubcommand.execute([], {
+        port: "8080",
+        config: "/path/to/config",
+        mode: "production",
+      });
+
+      expect(
+        mockServiceCommandHandler.subcommands[0].execute
+      ).toHaveBeenCalledWith([], {
+        port: "8080",
+        config: "/path/to/config",
+        mode: "production",
+      });
+    });
+
+    it("应正确处理空选项对象", async () => {
+      const startSubcommand = mockServiceCommandHandler.subcommands[0];
+
+      await startSubcommand.execute([], {});
+
+      expect(
+        mockServiceCommandHandler.subcommands[0].execute
+      ).toHaveBeenCalledWith([], {});
+    });
+  });
+});