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

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

@@ -1,1036 +0,0 @@
-import { describe, test, expect, beforeEach, vi } from "bun:test";
-import { EventSourceComponent } from "./event-source-component.js";
-import { ConfigComponent } from "../../config/config-component.js";
-// Mock spawn
-vi.mock("child_process", () => ({
-    spawn: vi.fn(() => ({
-        on: vi.fn((event, cb) => {
-            if (event === "exit") {
-                // 模拟子进程退出
-            }
-        }),
-        stdout: { on: vi.fn() },
-        stderr: { on: vi.fn() },
-        kill: vi.fn(),
-    })),
-}));
-// 创建 Mock Environment（参考 tool-component.test.ts 的模式）
-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: vi.fn(),
-    trace: vi.fn(),
-});
-describe("EventSourceComponent", () => {
-    let component;
-    let mockEnv;
-    let configComponent;
-    beforeEach(() => {
-        component = new EventSourceComponent();
-        configComponent = new ConfigComponent();
-        // 禁用持久化，避免测试之间的干扰
-        component.persistenceEnabled = false;
-        component.sources.clear();
-        component.statuses.clear();
-        mockEnv = createMockEnv();
-    });
-    describe("constructor", () => {
-        test("should create instance with correct name and version", () => {
-            expect(component.name).toBe("event-source");
-            expect(component.version).toBe("1.0.0");
-        });
-    });
-    describe("init", () => {
-        test("should initialize and enable event handling", async () => {
-            // 初始化组件
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            // 注册事件源
-            component.register({
-                id: "test-1",
-                name: "Test Source",
-                type: "timer",
-                enabled: true,
-                eventTypes: ["*"],
-            });
-            // 验证可以设置处理器并接收事件
-            let eventReceived = false;
-            component.onEvent("test-1", () => {
-                eventReceived = true;
-            });
-            // 手动触发事件
-            component["handleEvent"]("test-1", JSON.stringify({
-                type: "test.event",
-                payload: { message: "hello" },
-            }));
-            expect(eventReceived).toBe(true);
-            expect(component.getEventSourceStatusById("test-1")).toBe("created");
-        });
-    });
-    describe("register", () => {
-        test("should register a new event source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "timer",
-                enabled: true,
-                interval: 1000,
-            };
-            component.register(config);
-            const retrieved = component.get("test-1");
-            expect(retrieved).toBeDefined();
-            expect(retrieved?.name).toBe("Test Source");
-            expect(retrieved?.type).toBe("timer");
-        });
-        test("should throw error when registering duplicate id", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "timer",
-                enabled: true,
-            };
-            component.register(config);
-            expect(() => component.register(config)).toThrow("EventSource already exists: test-1");
-        });
-        test("should set initial status to created", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-            };
-            component.register(config);
-            expect(component.getEventSourceStatusById("test-1")).toBe("created");
-        });
-    });
-    describe("unregister", () => {
-        test("should unregister an existing event source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "timer",
-                enabled: true,
-            };
-            component.register(config);
-            const result = component.unregister("test-1");
-            expect(result).toBe(true);
-            expect(component.get("test-1")).toBeUndefined();
-        });
-        test("should return false for non-existent event source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const result = component.unregister("non-existent");
-            expect(result).toBe(false);
-        });
-    });
-    describe("list", () => {
-        test("should list all registered event sources", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-1",
-                name: "Source 1",
-                type: "timer",
-                enabled: true,
-            });
-            component.register({
-                id: "test-2",
-                name: "Source 2",
-                type: "lark-cli",
-                enabled: true,
-            });
-            const sources = component.list();
-            expect(sources).toHaveLength(2);
-        });
-        test("should return empty array when no sources registered", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const sources = component.list();
-            expect(sources).toHaveLength(0);
-        });
-    });
-    describe("getStatus", () => {
-        test("should return status for registered source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-1",
-                name: "Test Source",
-                type: "timer",
-                enabled: true,
-            });
-            expect(component.getEventSourceStatusById("test-1")).toBe("created");
-        });
-        test("should return undefined for non-existent source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            expect(component.getEventSourceStatusById("non-existent")).toBeUndefined();
-        });
-    });
-    describe("start", () => {
-        test("should start a timer event source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "timer-1",
-                name: "Timer Source",
-                type: "timer",
-                enabled: true,
-                interval: 100,
-            });
-            await component.startSource("timer-1");
-            // 等待一小段时间让定时器触发
-            await new Promise(resolve => setTimeout(resolve, 150));
-            expect(component.getEventSourceStatusById("timer-1")).toBe("running");
-        });
-        test("should throw error for non-existent source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            await expect(component.startSource("non-existent")).rejects.toThrow("EventSource not found: non-existent");
-        });
-        test("should not restart already running source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "timer-1",
-                name: "Timer Source",
-                type: "timer",
-                enabled: true,
-                interval: 10000,
-            });
-            await component.startSource("timer-1");
-            await component.startSource("timer-1"); // 重复启动
-            expect(component.getEventSourceStatusById("timer-1")).toBe("running");
-        });
-    });
-    describe("stop", () => {
-        test("should stop a running timer source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "timer-1",
-                name: "Timer Source",
-                type: "timer",
-                enabled: true,
-                interval: 10000,
-            });
-            await component.startSource("timer-1");
-            expect(component.getEventSourceStatusById("timer-1")).toBe("running");
-            await component.stopSource("timer-1");
-            expect(component.getEventSourceStatusById("timer-1")).toBe("stopped");
-        });
-        test("should do nothing when stopping non-running source", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "timer-1",
-                name: "Timer Source",
-                type: "timer",
-                enabled: true,
-                interval: 10000,
-            });
-            await component.stopSource("timer-1");
-            expect(component.getEventSourceStatusById("timer-1")).toBe("created");
-        });
-    });
-    describe("onEvent", () => {
-        test("should register event handler and receive events", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            // 先注册事件源
-            component.register({
-                id: "test-1",
-                name: "Test Source",
-                type: "timer",
-                enabled: true,
-                eventTypes: ["*"], // 接收所有事件
-            });
-            const handler = vi.fn();
-            component.onEvent("test-1", handler);
-            // 触发事件
-            component["handleEvent"]("test-1", JSON.stringify({
-                type: "test.event",
-                payload: { message: "hello" },
-            }));
-            expect(handler).toHaveBeenCalled();
-        });
-    });
-    describe("event type matching", () => {
-        test("should match exact event type", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                eventTypes: ["lark.im.message.receive_v1"],
-            };
-            component.register(config);
-            let handlerCalled = false;
-            component.onEvent("test-1", () => {
-                handlerCalled = true;
-            });
-            // 匹配的事件（schema 会被转换为 lark.xxx 格式）
-            component["handleEvent"]("test-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                text: "hello",
-            }));
-            expect(handlerCalled).toBe(true);
-        });
-        test("should match wildcard event type", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                eventTypes: ["lark.im.message.*"], // 通配符模式（schema 会被转换为 lark.xxx）
-            };
-            component.register(config);
-            let handlerCalled = false;
-            component.onEvent("test-1", () => {
-                handlerCalled = true;
-            });
-            // 匹配通配符（schema: "im.message.receive_v1" → type: "lark.im.message.receive_v1"）
-            component["handleEvent"]("test-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                text: "hello",
-            }));
-            expect(handlerCalled).toBe(true);
-        });
-        test("should not match non-matching event type", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                eventTypes: ["im.message.receive_v1"],
-            };
-            component.register(config);
-            let handlerCalled = false;
-            component.onEvent("test-1", () => {
-                handlerCalled = true;
-            });
-            // 不匹配的事件
-            component["handleEvent"]("test-1", JSON.stringify({
-                schema: "contact.user.created",
-                text: "hello",
-            }));
-            expect(handlerCalled).toBe(false);
-        });
-        test("should match wildcard * for all events", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const config = {
-                id: "test-1",
-                name: "Test Source",
-                type: "timer",
-                enabled: true,
-                eventTypes: ["*"],
-            };
-            component.register(config);
-            let handlerCalled = false;
-            component.onEvent("test-1", () => {
-                handlerCalled = true;
-            });
-            component["handleEvent"]("test-1", JSON.stringify({
-                type: "any.event",
-            }));
-            expect(handlerCalled).toBe(true);
-        });
-    });
-    describe("message formatting", () => {
-        test("should format lark-cli event message", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedMessage = "";
-            component.onEvent("lark-1", (event) => {
-                receivedMessage = event.payload.message;
-            });
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                sender: { sender_id: { open_id: "user123" } },
-                text: "Hello, World!",
-            }));
-            expect(receivedMessage).toContain("飞书消息");
-            expect(receivedMessage).toContain("user123");
-            expect(receivedMessage).toContain("Hello, World!");
-        });
-        test("should format timer event message", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "timer-1",
-                name: "Timer Source",
-                type: "timer",
-                enabled: true,
-                interval: 10000,
-                options: { message: "每日检查" },
-            });
-            let receivedMessage = "";
-            component.onEvent("timer-1", (event) => {
-                receivedMessage = event.payload.message;
-            });
-            component["handleEvent"]("timer-1", JSON.stringify({
-                type: "timer.tick",
-                payload: {
-                    message: "每日检查",
-                    timestamp: Date.now(),
-                },
-            }));
-            expect(receivedMessage).toContain("定时任务");
-            expect(receivedMessage).toContain("每日检查");
-        });
-        test("should format lark-cli event with new format (header.event_type)", async () => {
-            // 测试 lark-cli 实际输出的新格式
-            // schema: "2.0", header.event_type: "im.message.receive_v1"
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedMessage = "";
-            component.onEvent("lark-1", (event) => {
-                receivedMessage = event.payload.message;
-            });
-            // 模拟 lark-cli 实际输出的格式
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "2.0",
-                header: {
-                    event_id: "1fcb02757b134ff3aa2764b38ae5405e",
-                    event_type: "im.message.receive_v1",
-                    app_id: "cli_a92ca77188f8dbc9",
-                },
-                event: {
-                    message: {
-                        chat_id: "oc_20ea15b1276eb336a60757bfabdd43f9",
-                        chat_type: "p2p",
-                        content: '{"text":"Hello from Lark!"}',
-                        message_id: "om_x100b5277c7f6c8a0c422a7984156e0e",
-                        message_type: "text",
-                    },
-                    sender: {
-                        sender_id: {
-                            open_id: "ou_b9924f48dc122c3dad0ff4f37851c09b",
-                            union_id: "on_b4bf71136108db21547443d6554776b4",
-                            user_id: null,
-                        },
-                        sender_type: "user",
-                    },
-                },
-            }));
-            expect(receivedMessage).toContain("飞书消息");
-            expect(receivedMessage).toContain("ou_b9924f48dc122c3dad0ff4f37851c09b");
-            expect(receivedMessage).toContain("Hello from Lark!");
-        });
-        test("should extract event type from header.event_type", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-                eventTypes: ["im.message.*"],
-            });
-            let receivedEvent = null;
-            component.onEvent("lark-1", (event) => {
-                receivedEvent = event;
-            });
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "2.0",
-                header: {
-                    event_type: "im.message.receive_v1",
-                },
-                event: {
-                    message: {
-                        content: '{"text":"Test"}',
-                    },
-                    sender: {
-                        sender_id: { open_id: "ou_test" },
-                    },
-                },
-            }));
-            expect(receivedEvent).not.toBeNull();
-            expect(receivedEvent.type).toBe("im.message.receive_v1");
-        });
-    });
-    describe("lark-cli event parsing", () => {
-        test("should parse lark message event with open_id", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedEvent = null;
-            component.onEvent("lark-1", (event) => {
-                receivedEvent = event;
-            });
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                message_id: "msg_abc123",
-                sender: {
-                    sender_id: {
-                        open_id: "ou_123456",
-                        user_id: "user_456",
-                    },
-                },
-                message_type: "text",
-                text: "测试消息内容",
-            }));
-            expect(receivedEvent).not.toBeNull();
-            expect(receivedEvent.type).toBe("lark.im.message.receive_v1");
-            expect(receivedEvent.payload.sourceType).toBe("lark-cli");
-        });
-        test("should parse lark message event with email", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedEvent = null;
-            component.onEvent("lark-1", (event) => {
-                receivedEvent = event;
-            });
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                sender: {
-                    sender_id: {
-                        email: "test@example.com",
-                    },
-                },
-                text: "Hello",
-            }));
-            expect(receivedEvent).not.toBeNull();
-            expect(receivedEvent.payload.message).toContain("test@example.com");
-        });
-        test("should parse lark bot message", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedEvent = null;
-            component.onEvent("lark-1", (event) => {
-                receivedEvent = event;
-            });
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                sender: {
-                    sender_type: "user",
-                    sender_id: {},
-                },
-                text: "Bot message",
-            }));
-            expect(receivedEvent).not.toBeNull();
-            expect(receivedEvent.type).toBe("lark.im.message.receive_v1");
-        });
-        test("should handle non-text message content", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedMessage = "";
-            component.onEvent("lark-1", (event) => {
-                receivedMessage = event.payload.message;
-            });
-            // Post message event with card content
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                content: '{"type":"card","data":{"text":"Card content"}}',
-            }));
-            expect(receivedMessage).toContain("飞书消息");
-        });
-        test("should handle event without schema", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedEvent = null;
-            component.onEvent("lark-1", (event) => {
-                receivedEvent = event;
-            });
-            // Event without schema field
-            component["handleEvent"]("lark-1", JSON.stringify({
-                type: "custom.event",
-                data: "test",
-            }));
-            expect(receivedEvent).not.toBeNull();
-            expect(receivedEvent.type).toBe("custom.event");
-        });
-        test("should filter events by eventTypes", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-1",
-                name: "Lark Source",
-                type: "lark-cli",
-                enabled: true,
-                eventTypes: ["lark.im.message.*"], // 只接收消息事件
-            });
-            let handlerCalled = false;
-            component.onEvent("lark-1", () => {
-                handlerCalled = true;
-            });
-            // 匹配的事件
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "im.message.receive_v1",
-                text: "Hello",
-            }));
-            expect(handlerCalled).toBe(true);
-            handlerCalled = false;
-            // 不匹配的事件（不在过滤列表中）
-            component["handleEvent"]("lark-1", JSON.stringify({
-                schema: "contact.user.created",
-                text: "New user",
-            }));
-            expect(handlerCalled).toBe(false);
-        });
-    });
-    describe("processStream", () => {
-        test("should handle NDJSON lines", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-1",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                eventTypes: ["*"],
-            });
-            let eventsReceived = 0;
-            component.onEvent("test-1", () => {
-                eventsReceived++;
-            });
-            // 模拟 NDJSON 流（多个 JSON 行）
-            const ndjsonData = '{"schema":"im.message.receive_v1","text":"Hello"}\n' +
-                '{"schema":"im.message.receive_v1","text":"World"}\n' +
-                '{"schema":"contact.user.created"}\n';
-            component["processStream"]("test-1", ndjsonData);
-            expect(eventsReceived).toBe(3);
-        });
-        test("should handle incomplete JSON line", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-1",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-                eventTypes: ["*"],
-            });
-            let eventsReceived = 0;
-            component.onEvent("test-1", () => {
-                eventsReceived++;
-            });
-            // 第一行完整，第二行不完整
-            // 缓冲区会保留不完整的数据
-            const data1 = '{"schema":"im.message.receive_v1"}\n{"incomplete":';
-            component["processStream"]("test-1", data1);
-            expect(eventsReceived).toBe(1);
-            // 完成不完整的行
-            // 加上第三行完整数据
-            const data2 = '"complete"}\n{"schema":"im.message.receive_v1"}\n';
-            component["processStream"]("test-1", data2);
-            expect(eventsReceived).toBe(3);
-        });
-    });
-    describe("extractMetadata", () => {
-        test("should extract metadata from lark-cli message event", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            const rawEvent = {
-                schema: "2.0",
-                header: {
-                    event_id: "edb989d37c1793b9f7bf4cb0aedf2816",
-                    event_type: "im.message.receive_v1",
-                    app_id: "cli_a92ca77188f8dbc9",
-                    tenant_key: "2db7908f4d0f575e",
-                },
-                event: {
-                    message: {
-                        chat_id: "oc_20ea15b1276eb336a60757bfabdd43f9",
-                        chat_type: "p2p",
-                        content: '{"text":"阿斯蒂芬"}',
-                        message_id: "om_x100b527e90903084c4925f230b3af4b",
-                        message_type: "text",
-                    },
-                    sender: {
-                        sender_id: {
-                            open_id: "ou_b9924f48dc122c3dad0ff4f37851c09b",
-                            union_id: "on_b4bf71136108db21547443d6554776b4",
-                            user_id: null,
-                        },
-                        sender_type: "user",
-                        tenant_key: "2db7908f4d0f575e",
-                    },
-                },
-            };
-            const result = component["extractMetadata"]("lark-cli", rawEvent, "im.message.receive_v1");
-            // 验证元信息提取
-            expect(result.metadata.eventType).toBe("im.message.receive_v1");
-            expect(result.metadata.appId).toBe("cli_a92ca77188f8dbc9");
-            expect(result.metadata.tenantKey).toBe("2db7908f4d0f575e");
-            expect(result.metadata.chatId).toBe("oc_20ea15b1276eb336a60757bfabdd43f9");
-            expect(result.metadata.chatType).toBe("p2p");
-            expect(result.metadata.messageId).toBe("om_x100b527e90903084c4925f230b3af4b");
-            expect(result.metadata.messageType).toBe("text");
-            expect(result.metadata.senderId).toBe("ou_b9924f48dc122c3dad0ff4f37851c09b");
-            // 验证推荐动作
-            expect(result.recommendedAction).toBeDefined();
-            expect(result.recommendedAction?.action).toBe("处理飞书消息并回复");
-            expect(result.recommendedAction?.replyTo?.appId).toBe("cli_a92ca77188f8dbc9");
-            expect(result.recommendedAction?.replyTo?.chatId).toBe("oc_20ea15b1276eb336a60757bfabdd43f9");
-            expect(result.recommendedAction?.replyTo?.messageId).toBe("om_x100b527e90903084c4925f230b3af4b");
-        });
-        test("should format message with content correctly", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "lark-test",
-                name: "Lark Test",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedMessage = "";
-            component.onEvent("lark-test", (event) => {
-                receivedMessage = event.payload.message;
-            });
-            // 用户实际发送的消息格式（包含 content）
-            component["handleEvent"]("lark-test", JSON.stringify({
-                schema: "2.0",
-                header: {
-                    event_id: "edb989d37c1793b9f7bf4cb0aedf2816",
-                    event_type: "im.message.receive_v1",
-                    app_id: "cli_a92ca77188f8dbc9",
-                    tenant_key: "2db7908f4d0f575e",
-                },
-                event: {
-                    message: {
-                        chat_id: "oc_20ea15b1276eb336a60757bfabdd43f9",
-                        chat_type: "p2p",
-                        content: '{"text":"阿斯蒂芬"}',
-                        message_id: "om_x100b527e90903084c4925f230b3af4b",
-                        message_type: "text",
-                    },
-                    sender: {
-                        sender_id: {
-                            open_id: "ou_b9924f48dc122c3dad0ff4f37851c09b",
-                        },
-                        sender_type: "user",
-                    },
-                },
-            }));
-            // 应该正确解析消息内容
-            expect(receivedMessage).toContain("飞书消息");
-            expect(receivedMessage).toContain("阿斯蒂芬");
-            expect(receivedMessage).not.toContain("not matched");
-        });
-        test("should extract metadata from timer event", async () => {
-            const result = component["extractMetadata"]("timer", {}, "timer.tick");
-            expect(result.metadata.eventType).toBe("timer.tick");
-            expect(result.recommendedAction).toBeDefined();
-            expect(result.recommendedAction?.action).toBe("执行定时任务");
-        });
-        test("should extract metadata from websocket event", async () => {
-            const result = component["extractMetadata"]("websocket", {}, "ws.message");
-            expect(result.metadata.eventType).toBe("ws.message");
-            expect(result.recommendedAction).toBeDefined();
-            expect(result.recommendedAction?.action).toBe("处理 WebSocket 消息");
-        });
-        test("should extract metadata with null sender_id values", async () => {
-            const rawEvent = {
-                header: {
-                    event_type: "im.message.receive_v1",
-                    app_id: "cli_test",
-                },
-                event: {
-                    message: {
-                        chat_id: "oc_test",
-                        message_type: "text",
-                    },
-                    sender: {
-                        sender_id: {
-                            open_id: null,
-                            user_id: null,
-                            email: null,
-                            union_id: null,
-                        },
-                    },
-                },
-            };
-            const result = component["extractMetadata"]("lark-cli", rawEvent, "im.message.receive_v1");
-            // senderId 应该为空字符串（因为所有值都是 null）
-            expect(result.metadata.senderId).toBeDefined();
-        });
-    });
-    describe("EventSourceEvent payload structure", () => {
-        test("should include metadata and recommendedAction in event payload", async () => {
-            await component.init({
-                name: "event-source",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent },
-            });
-            component.register({
-                id: "test-metadata",
-                name: "Test Source",
-                type: "lark-cli",
-                enabled: true,
-            });
-            let receivedEvent = null;
-            component.onEvent("test-metadata", (event) => {
-                receivedEvent = event;
-            });
-            component["handleEvent"]("test-metadata", JSON.stringify({
-                schema: "2.0",
-                header: {
-                    event_type: "im.message.receive_v1",
-                    app_id: "cli_test",
-                },
-                event: {
-                    message: {
-                        chat_id: "oc_test",
-                        content: '{"text":"Hello"}',
-                        message_type: "text",
-                    },
-                    sender: {
-                        sender_id: {
-                            open_id: "ou_test",
-                        },
-                    },
-                },
-            }));
-            expect(receivedEvent).toBeDefined();
-            expect(receivedEvent.payload.metadata).toBeDefined();
-            expect(receivedEvent.payload.metadata.appId).toBe("cli_test");
-            expect(receivedEvent.payload.metadata.chatId).toBe("oc_test");
-            expect(receivedEvent.payload.metadata.eventType).toBe("im.message.receive_v1");
-            expect(receivedEvent.payload.recommendedAction).toBeDefined();
-            expect(receivedEvent.payload.recommendedAction?.action).toBe("处理飞书消息并回复");
-            expect(receivedEvent.payload.recommendedAction?.replyTo?.appId).toBe("cli_test");
-        });
-    });
-});
-//# sourceMappingURL=event-source-component.test.js.map