@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

package/dist/core/src/env/event-source/event-source-platform.test.js

@@ -1,536 +0,0 @@
-/**
- * @fileoverview EventSourceComponent Cross-Platform Process Cleanup Tests
- *
- * TDD: 测试跨平台进程清理功能
- *
- * 支持平台:
- * - Linux: pgrep -f " pattern"
- * - macOS: pgrep -f " pattern"
- * - Windows: PowerShell Get-Process + Where-Object
- */
-import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
-import { EventSourceComponent, setExecAsync } from "./event-source-component.js";
-import { ConfigComponent } from "../../config/config-component.js";
-// Mock process.kill
-const mockProcessKill = vi.fn((pid, signal) => {
-    return true;
-});
-// Mock spawn
-const mockSpawnKill = vi.fn((signal) => true);
-const mockExitCallbacks = [];
-// Mock execAsync - 直接 mock 函数
-const mockExecAsync = vi.fn().mockImplementation((cmd) => {
-    return Promise.resolve({ stdout: "12345\n67890", stderr: "" });
-});
-// 存储 mock execAsync 的返回值
-let mockExecResult = { stdout: "12345\n67890", stderr: "" };
-let mockExecError = null;
-/**
- * 设置 mock execAsync 的返回值
- */
-function setMockExecResult(stdout, stderr = "") {
-    mockExecResult = { stdout, stderr };
-    mockExecError = null;
-    // 同时更新 setExecAsync，使用 mockExecAsync 确保可以追踪调用
-    setExecAsync(async (cmd) => {
-        // 记录调用以便测试断言
-        mockExecAsync(cmd);
-        if (mockExecError) {
-            throw mockExecError;
-        }
-        return mockExecResult;
-    });
-}
-/**
- * 设置 mock execAsync 返回错误
- */
-function setMockExecError(error) {
-    mockExecError = error;
-    mockExecResult = { stdout: "", stderr: "" };
-    setExecAsync(async (cmd) => {
-        // 记录调用以便测试断言
-        mockExecAsync(cmd);
-        if (mockExecError) {
-            throw mockExecError;
-        }
-        return mockExecResult;
-    });
-}
-vi.mock("child_process", () => {
-    // mock exec 直接调用 callback
-    const mockExec = vi.fn().mockImplementation((cmd, callback) => {
-        // 同步调用 callback（exec 可以接受回调）
-        callback(null, { stdout: "12345\n67890", stderr: "" });
-        return { stdout: "", stderr: "" };
-    });
-    // mock execAsync 直接返回 Promise
-    const mockExecAsync = vi.fn().mockImplementation((cmd) => {
-        return Promise.resolve({ stdout: "12345\n67890", stderr: "" });
-    });
-    return {
-        spawn: vi.fn(() => ({
-            pid: 12345,
-            pgid: 12340,
-            on: vi.fn((event, cb) => {
-                if (event === "exit") {
-                    mockExitCallbacks.push(cb);
-                }
-                return {
-                    once: vi.fn((eventName, handler) => {
-                        return { once: vi.fn() };
-                    }),
-                };
-            }),
-            stdout: { on: vi.fn(), removeAllListeners: vi.fn() },
-            stderr: { on: vi.fn(), removeAllListeners: vi.fn() },
-            removeAllListeners: vi.fn(),
-            kill: mockSpawnKill,
-        })),
-        exec: mockExec,
-        promisify: vi.fn(() => mockExecAsync), // mock promisify 返回 mockExecAsync
-    };
-});
-// 创建 Mock Environment
-const createMockEnv = () => ({
-    name: "mock-env",
-    version: "1.0.0",
-    getConfig: () => ({ name: "mock-env", version: "1.0.0", enabled: true, env: null }),
-    registerComponent: () => { },
-    unregisterComponent: () => { },
-    getComponent: vi.fn(() => undefined),
-    hasComponent: vi.fn(() => false),
-    listComponents: () => [],
-    handle_query: async () => "",
-    handle_action: async () => ({ success: true, output: "" }),
-    subscribe: vi.fn(() => () => { }),
-    subscribeTo: vi.fn(() => () => { }),
-    subscribeAll: vi.fn(() => () => { }),
-    pushEnvEvent: vi.fn(),
-    logger: {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        debug: vi.fn(),
-    },
-    trace: vi.fn(),
-});
-describe("EventSourceComponent Cross-Platform Process Cleanup - TDD", () => {
-    let component;
-    let mockEnv;
-    let configComponent;
-    let originalKill;
-    let originalPlatform;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockProcessKill.mockClear();
-        mockSpawnKill.mockClear();
-        mockExitCallbacks.length = 0;
-        // 重置 mockExecResult 为默认值，并设置 setExecAsync
-        setMockExecResult("12345\n67890");
-        originalKill = process.kill.bind(process);
-        Object.defineProperty(process, "kill", {
-            value: mockProcessKill,
-            writable: true,
-            configurable: true,
-        });
-        // 保存原始 platform
-        originalPlatform = Object.getOwnPropertyDescriptor(process, "platform")?.value;
-        component = new EventSourceComponent();
-        configComponent = new ConfigComponent();
-        component.persistenceEnabled = false;
-        component.sources.clear();
-        component.statuses.clear();
-        component.processes.clear();
-        component.timers.clear();
-        mockEnv = createMockEnv();
-    });
-    afterEach(() => {
-        Object.defineProperty(process, "kill", {
-            value: originalKill,
-            writable: true,
-            configurable: true,
-        });
-        // 恢复原始 platform
-        Object.defineProperty(process, "platform", {
-            value: originalPlatform,
-            writable: true,
-            configurable: true,
-        });
-        vi.restoreAllMocks();
-    });
-    describe("shell 选择 (spawn)", () => {
-        test("RED: Linux 平台应使用 sh 作为 shell", async () => {
-            /**
-             * RED: 验证 Linux 平台使用 sh
-             */
-            Object.defineProperty(process, "platform", {
-                value: "linux",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345\n67890");
-            await component.startSource("test-source");
-            // 验证 spawn 被调用（通过检查进程信息中的命令）
-            const processInfo = component.processes.get("test-source");
-            expect(processInfo).toBeDefined();
-            expect(processInfo.command).toBe("lark-cli event +subscribe --quiet");
-            // 验证是 Linux 平台，shell 应该是 sh
-            const platform = Object.getOwnPropertyDescriptor(process, "platform")?.value;
-            expect(platform).toBe("linux");
-        });
-        test("RED: Windows 平台应使用 cmd.exe 作为 shell", async () => {
-            /**
-             * RED: 验证 Windows 平台使用 cmd.exe
-             */
-            Object.defineProperty(process, "platform", {
-                value: "win32",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345\r\n67890");
-            await component.startSource("test-source");
-            // 验证 spawn 被调用（通过检查进程信息中的命令）
-            const processInfo = component.processes.get("test-source");
-            expect(processInfo).toBeDefined();
-            expect(processInfo.command).toBe("lark-cli event +subscribe --quiet");
-            // 验证是 Windows 平台
-            const platform = Object.getOwnPropertyDescriptor(process, "platform")?.value;
-            expect(platform).toBe("win32");
-        });
-    });
-    describe("跨平台命令生成", () => {
-        test("RED: Linux 平台应使用 pgrep -f 命令", async () => {
-            /**
-             * RED: 验证在 Linux 平台使用 pgrep 命令
-             */
-            Object.defineProperty(process, "platform", {
-                value: "linux",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345\n67890");
-            await component.startSource("test-source");
-            // 验证调用了 exec
-            expect(mockExecAsync).toHaveBeenCalled();
-            // 验证命令包含 pgrep
-            const callArgs = mockExecAsync.mock.calls[0]?.[0] || "";
-            expect(callArgs).toContain("pgrep");
-        });
-        test("RED: macOS 平台应使用 pgrep -f 命令（与 Linux 相同）", async () => {
-            /**
-             * RED: 验证在 macOS 平台也使用 pgrep 命令
-             */
-            Object.defineProperty(process, "platform", {
-                value: "darwin",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345");
-            await component.startSource("test-source");
-            expect(mockExecAsync).toHaveBeenCalled();
-            const callArgs = mockExecAsync.mock.calls[0]?.[0] || "";
-            expect(callArgs).toContain("pgrep");
-        });
-        test("RED: Windows 平台应使用 PowerShell 命令", async () => {
-            /**
-             * RED: 验证在 Windows 平台使用 PowerShell (Get-CimInstance)
-             */
-            Object.defineProperty(process, "platform", {
-                value: "win32",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345\r\n67890");
-            await component.startSource("test-source");
-            expect(mockExecAsync).toHaveBeenCalled();
-            // 验证命令包含 PowerShell 和 Get-CimInstance
-            const callArgs = mockExecAsync.mock.calls[0]?.[0] || "";
-            expect(callArgs).toMatch(/(powershell|Get-CimInstance)/i);
-        });
-    });
-    describe("进程 PID 解析", () => {
-        test("RED: Unix 平台应正确解析 pgrep 输出（换行符分隔）", async () => {
-            /**
-             * RED: 验证正确解析 Unix 平台 pgrep 输出
-             */
-            Object.defineProperty(process, "platform", {
-                value: "linux",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345\n67890\n11111\n");
-            await component.startSource("test-source");
-            const processInfo = component.processes.get("test-source");
-            expect(processInfo.pids).toContain(12345);
-            expect(processInfo.pids).toContain(67890);
-            expect(processInfo.pids).toContain(11111);
-        });
-        test("RED: Windows 平台应正确解析输出（处理 \\r\\n）", async () => {
-            /**
-             * RED: 验证正确解析 Windows 输出（可能有回车换行）
-             */
-            Object.defineProperty(process, "platform", {
-                value: "win32",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345\r\n67890\r\n");
-            await component.startSource("test-source");
-            const processInfo = component.processes.get("test-source");
-            expect(processInfo.pids).toContain(12345);
-            expect(processInfo.pids).toContain(67890);
-        });
-        test("RED: 应过滤掉无效的 PID（非数字）", async () => {
-            /**
-             * RED: 验证过滤掉输出中的非数字内容
-             */
-            Object.defineProperty(process, "platform", {
-                value: "linux",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecResult("12345\nabc\n67890\n\n");
-            await component.startSource("test-source");
-            const processInfo = component.processes.get("test-source");
-            expect(processInfo.pids).toContain(12345);
-            expect(processInfo.pids).toContain(67890);
-            // abc 应该被过滤掉
-            expect(processInfo.pids.filter((p) => isNaN(p))).toHaveLength(0);
-        });
-    });
-    describe("命令转义和安全", () => {
-        test("RED: 命令模式应正确转义避免注入（Unix）", async () => {
-            /**
-             * RED: 验证 Unix 命令模式正确转义
-             */
-            Object.defineProperty(process, "platform", {
-                value: "linux",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event; rm -rf /",
-            });
-            setMockExecResult("12345");
-            await component.startSource("test-source");
-            const callArgs = mockExecAsync.mock.calls[0]?.[0] || "";
-            // 应该使用引号包裹模式，避免分号被解释为命令分隔符
-            expect(callArgs).toMatch(/pgrep.*['"].*['"]/);
-        });
-        test("RED: Windows 单引号应正确转义", async () => {
-            /**
-             * RED: 验证 Windows 命令中的单引号转义
-             * 注意：这个测试需要命令包含单引号，以确保转义逻辑正确
-             */
-            Object.defineProperty(process, "platform", {
-                value: "win32",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event --name='test app'",
-            });
-            setMockExecResult("12345");
-            await component.startSource("test-source");
-            const callArgs = mockExecAsync.mock.calls[0]?.[0] || "";
-            // PowerShell 需要转义单引号，但当前 trackRelatedProcesses 只提取 baseCommand (lark-cli)，不含单引号
-            // 这个测试暂时跳过，直到实现完整命令模式的转义
-            // 如果要测试完整功能，需要修改 trackRelatedProcesses 以使用完整命令
-        });
-    });
-    describe("错误处理", () => {
-        test("RED: Unix pgrep 无匹配时应返回空数组", async () => {
-            /**
-             * RED: 验证 pgrep 无匹配时返回空数组而非报错
-             */
-            Object.defineProperty(process, "platform", {
-                value: "linux",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "nonexistent-command-xyz",
-            });
-            // pgrep 无匹配时返回错误
-            setMockExecError(new Error("No processes found"));
-            await component.startSource("test-source");
-            const processInfo = component.processes.get("test-source");
-            expect(processInfo.pids).toBeDefined();
-            expect(Array.isArray(processInfo.pids)).toBe(true);
-        });
-        test("RED: Windows PowerShell 失败时应优雅处理", async () => {
-            /**
-             * RED: 验证 Windows PowerShell 失败时不崩溃
-             */
-            Object.defineProperty(process, "platform", {
-                value: "win32",
-                writable: true,
-                configurable: true,
-            });
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-source",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                command: "lark-cli event +subscribe --quiet",
-            });
-            setMockExecError(new Error("PowerShell failed"));
-            await component.startSource("test-source");
-            const processInfo = component.processes.get("test-source");
-            expect(processInfo).toBeDefined();
-        });
-    });
-});
-//# sourceMappingURL=event-source-platform.test.js.map