@ai-setting/roy-agent-core 1.0.0

package/src/env/environment-service.test.ts

@@ -0,0 +1,332 @@
+/**
+ * @fileoverview Environment Service 集成测试
+ * 
+ * TDD: 测试 Environment 从配置文件加载组件配置并初始化组件的能力
+ */
+
+import { describe, test, expect, beforeEach, afterEach, vi } from "bun:test";
+import { BaseEnvironment } from "./environment";
+import { ConfigComponent } from "../config/config-component";
+import { BaseComponent } from "./component";
+import * as fsSync from "fs";
+import * as path from "path";
+import * as os from "os";
+
+// ============================================================================
+// 测试用的 Mock Component
+// ============================================================================
+
+/**
+ * Mock LLMComponent - 模拟 LLMComponent 的配置加载
+ */
+class MockLLMComponent extends BaseComponent {
+  readonly name = "llm";
+  readonly version = "1.0.0";
+  
+  // 存储初始化时的配置
+  initOptions: any = null;
+  loadedConfig: any = null;
+  
+  async init(config: import("./component").ComponentConfig): Promise<void> {
+    await super.init(config);
+    
+    // 从 options 获取配置
+    const options = config.options as any;
+    this.initOptions = options;
+    this.loadedConfig = options?.config;
+    
+    this.setStatus("running");
+  }
+  
+  getLoadedConfig() {
+    return this.loadedConfig;
+  }
+}
+
+/**
+ * Mock ToolComponent - 模拟 ToolComponent 的配置加载
+ */
+class MockToolComponent extends BaseComponent {
+  readonly name = "tool";
+  readonly version = "1.0.0";
+  
+  initOptions: any = null;
+  loadedConfig: any = null;
+  
+  async init(config: import("./component").ComponentConfig): Promise<void> {
+    await super.init(config);
+    
+    const options = config.options as any;
+    this.initOptions = options;
+    this.loadedConfig = options?.config;
+    
+    this.setStatus("running");
+  }
+  
+  getLoadedConfig() {
+    return this.loadedConfig;
+  }
+}
+
+// ============================================================================
+// 测试
+// ============================================================================
+
+describe("Environment Service Configuration", () => {
+  let env: BaseEnvironment;
+  let configComponent: ConfigComponent;
+  let tempDir: string;
+
+  beforeEach(() => {
+    env = new BaseEnvironment({ name: "test-service-env" });
+    configComponent = new ConfigComponent();
+    
+    // Create temp directory for config files
+    tempDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "env-service-test-"));
+    configComponent.setXdgDataHome(tempDir);
+    
+    // 注册 ConfigComponent
+    env.registerComponent(configComponent);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    // Clean up environment variables
+    Object.keys(process.env)
+      .filter(k => k.startsWith("TEST_"))
+      .forEach(k => delete process.env[k]);
+    // Clean up temp directory
+    try {
+      fsSync.rmSync(tempDir, { recursive: true });
+    } catch {}
+  });
+
+  describe("loadServiceConfig", () => {
+    test("should load service config from file", async () => {
+      // 创建服务配置文件
+      const serviceConfig = {
+        environment: {
+          name: "my-service",
+          version: "1.0.0",
+        },
+        components: {
+          llm: {
+            config: {
+              defaultModel: "gpt-4",
+              temperature: 0.5,
+            }
+          }
+        }
+      };
+      
+      fsSync.writeFileSync(
+        path.join(tempDir, "service-config.jsonc"),
+        JSON.stringify(serviceConfig),
+        "utf-8"
+      );
+      
+      // 调用 loadServiceConfig 方法
+      const loadedConfig = await env.loadServiceConfig("service-config.jsonc");
+      
+      // 验证配置被正确加载
+      expect(loadedConfig).toBeDefined();
+      expect(loadedConfig.environment.name).toBe("my-service");
+      expect(loadedConfig.components.llm.config.defaultModel).toBe("gpt-4");
+    });
+
+    test("should throw error if service config not found", async () => {
+      // 尝试加载不存在的配置文件应该抛出错误
+      await expect(
+        env.loadServiceConfig("non-existent-config.jsonc")
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("generateComponentOptions", () => {
+    test("should generate component options from service config", async () => {
+      // 创建服务配置
+      const serviceConfig = {
+        environment: {
+          name: "test-env",
+        },
+        components: {
+          llm: {
+            configPath: "llm.jsonc",
+            envPrefix: "LLM",
+            config: {
+              defaultModel: "gpt-4",
+              temperature: 0.7,
+            }
+          }
+        }
+      };
+      
+      // 生成 LLM 组件的 Options
+      const options = env.generateComponentOptions("llm", serviceConfig.components.llm);
+      
+      // 验证生成的 Options 包含正确的配置
+      expect(options.configComponent).toBe(configComponent);
+      expect(options.config.defaultModel).toBe("gpt-4");
+      expect(options.config.temperature).toBe(0.7);
+      expect(options.envPrefix).toBe("LLM");
+      expect(options.configPath).toBe("llm.jsonc");
+    });
+
+    test("should include configComponent in generated options", async () => {
+      const serviceConfig = {
+        components: {
+          tool: {
+            config: {
+              toolsDir: "./tools",
+            }
+          }
+        }
+      };
+      
+      const options = env.generateComponentOptions("tool", serviceConfig.components.tool);
+      
+      // 必须包含 ConfigComponent
+      expect(options.configComponent).toBeDefined();
+      expect(options.configComponent).toBe(configComponent);
+    });
+  });
+
+  describe("registerComponentWithConfig", () => {
+    test("should register component and initialize with config", async () => {
+      const llmComponent = new MockLLMComponent();
+      const componentConfig = {
+        config: {
+          defaultModel: "gpt-4",
+          temperature: 0.8,
+        }
+      };
+      
+      // 使用新 API 注册并初始化组件
+      await env.registerComponentWithConfig(llmComponent, componentConfig);
+      
+      // 验证组件被正确初始化
+      expect(llmComponent.getStatus()).toBe("running");
+      expect(llmComponent.getLoadedConfig()).toEqual(componentConfig.config);
+    });
+
+    test("should support envPrefix in component registration", async () => {
+      const toolComponent = new MockToolComponent();
+      const componentConfig = {
+        envPrefix: "TOOL",
+        config: {
+          toolsDir: "./custom-tools",
+        }
+      };
+      
+      await env.registerComponentWithConfig(toolComponent, componentConfig);
+      
+      expect(toolComponent.getStatus()).toBe("running");
+      expect(toolComponent.initOptions.envPrefix).toBe("TOOL");
+    });
+  });
+
+  describe("initFromConfig", () => {
+    test("should initialize environment from service config file", async () => {
+      // 创建完整的服务配置文件
+      const serviceConfig = {
+        environment: {
+          name: "auto-init-env",
+          version: "1.0.0",
+        },
+        components: {
+          llm: {
+            config: {
+              defaultModel: "gpt-4",
+            }
+          },
+          tool: {
+            config: {
+              toolsDir: "./tools",
+            }
+          }
+        }
+      };
+      
+      fsSync.writeFileSync(
+        path.join(tempDir, "auto-service.jsonc"),
+        JSON.stringify(serviceConfig),
+        "utf-8"
+      );
+      
+      // 创建新的 Environment
+      const autoEnv = new BaseEnvironment();
+      autoEnv.registerComponent(configComponent);
+      
+      // 注册 mock components
+      const llmComponent = new MockLLMComponent();
+      const toolComponent = new MockToolComponent();
+      autoEnv.registerComponent(llmComponent);
+      autoEnv.registerComponent(toolComponent);
+      
+      // 从配置文件初始化
+      await autoEnv.initFromConfig("auto-service.jsonc");
+      
+      // 验证环境初始化成功
+      expect(autoEnv.getStatus()).toBe("running");
+      
+      // 验证组件被正确初始化
+      expect(llmComponent.getStatus()).toBe("running");
+      expect(llmComponent.getLoadedConfig().defaultModel).toBe("gpt-4");
+      
+      expect(toolComponent.getStatus()).toBe("running");
+      expect(toolComponent.getLoadedConfig().toolsDir).toBe("./tools");
+    });
+
+    test("should set environment name from config", async () => {
+      const serviceConfig = {
+        environment: {
+          name: "custom-named-env",
+          version: "2.0.0",
+        },
+        components: {}
+      };
+      
+      fsSync.writeFileSync(
+        path.join(tempDir, "named-service.jsonc"),
+        JSON.stringify(serviceConfig),
+        "utf-8"
+      );
+      
+      const namedEnv = new BaseEnvironment();
+      namedEnv.registerComponent(configComponent);
+      
+      await namedEnv.initFromConfig("named-service.jsonc");
+      
+      // 验证环境名称被正确设置
+      expect(namedEnv.name).toBe("custom-named-env");
+      expect(namedEnv.version).toBe("2.0.0");
+    });
+  });
+
+  describe("environment variable resolution", () => {
+    test("should resolve environment variables in config", async () => {
+      // 设置环境变量
+      process.env.TEST_LLM_MODEL = "gpt-5";
+      
+      const serviceConfig = {
+        environment: { name: "env-test" },
+        components: {
+          llm: {
+            envPrefix: "TEST",
+            config: {
+              // 配置值应该能引用环境变量
+              defaultModel: "gpt-4",  // 静态值测试
+            }
+          }
+        }
+      };
+      
+      const options = env.generateComponentOptions("llm", serviceConfig.components.llm);
+      
+      // 验证配置被正确传递
+      expect(options.config.defaultModel).toBe("gpt-4");
+      
+      delete process.env.TEST_LLM_MODEL;
+    });
+  });
+});

package/src/env/environment.handle-query.test.ts

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview handle_query 集成测试
+ */
+
+import { describe, it, expect, vi, beforeEach } from "bun:test";
+import { BaseEnvironment } from "./environment";
+import { AgentComponent } from "./agent/agent-component";
+import { ConfigComponent } from "../config/config-component";
+import type { EnvEvent } from "./types";
+
+describe("BaseEnvironment.handle_query", () => {
+  let env: BaseEnvironment;
+  let agentComponent: AgentComponent;
+  let configComponent: ConfigComponent;
+
+  beforeEach(async () => {
+    env = new BaseEnvironment({ name: "test-env" });
+    configComponent = new ConfigComponent();
+    agentComponent = new AgentComponent();
+    
+    // 注册到 Environment
+    env.registerComponent(configComponent);
+    env.registerComponent(agentComponent);
+    
+    // 通过 init 方法设置 env（BaseComponent 需要 env）
+    // AgentComponent 需要 ConfigComponent
+    await agentComponent.init({
+      name: "agent",
+      version: "1.0.0",
+      enabled: true,
+      env: env as any,
+      options: { configComponent },
+    });
+  });
+
+  it("should delegate to AgentComponent.run", async () => {
+    const result = await env.handle_query("Hello");
+    
+    // AgentComponent 没有 LLMComponent 时会返回 Mock 响应
+    expect(result).toBe("Mock response: Hello!");
+  });
+
+  it("should pass context to AgentComponent.run", async () => {
+    const context = {
+      sessionId: "test-session-123",
+      metadata: { key: "value" },
+    };
+
+    // 由于没有 LLMComponent，使用 mock
+    // 这个测试主要验证 context 被正确传递
+    const result = await env.handle_query("Test query", context);
+    expect(result).toBe("Mock response: Hello!");
+  });
+
+  it("should emit events via subscribe", async () => {
+    const events: EnvEvent[] = [];
+    
+    // 订阅 EnvEvent
+    const unsubscribe = env.subscribe((event) => {
+      events.push(event);
+    });
+    
+    const result = await env.handle_query("Hello");
+
+    expect(result).toBe("Mock response: Hello!");
+    
+    // 验证事件被触发
+    expect(events.length).toBeGreaterThan(0);
+    
+    // 应该包含 agent.start 和 agent.completed 事件
+    // 注意：llm.content 事件只有在有真实 LLMComponent 时才会发送
+    const eventTypes = events.map(e => e.type);
+    expect(eventTypes).toContain("agent.start");
+    expect(eventTypes).toContain("agent.completed");
+    
+    unsubscribe();
+  });
+
+  it("should throw error if AgentComponent is not registered", async () => {
+    const emptyEnv = new BaseEnvironment({ name: "empty-env" });
+    
+    await expect(
+      emptyEnv.handle_query("Hello")
+    ).rejects.toThrow("AgentComponent not found");
+  });
+
+  it("should work without event subscription", async () => {
+    const result = await env.handle_query("Hello");
+    expect(result).toBe("Mock response: Hello!");
+  });
+
+  it("should work without context", async () => {
+    const result = await env.handle_query("Hello");
+    expect(result).toBe("Mock response: Hello!");
+  });
+});

package/src/env/environment.test.ts

@@ -0,0 +1,232 @@
+/**
+ * @fileoverview BaseEnvironment Unit Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { BaseEnvironment, type BaseEnvironmentConfig } from "./environment";
+import type { EnvEvent, EnvEventHandler, Action, ToolResult, Context } from "./types";
+
+describe("BaseEnvironment", () => {
+  let env: BaseEnvironment;
+
+  beforeEach(() => {
+    env = new BaseEnvironment({ name: "test-env", version: "1.0.0" });
+  });
+
+  afterEach(async () => {
+    await env.stop();
+  });
+
+  describe("构造函数", () => {
+    it("应该使用默认配置", () => {
+      const defaultEnv = new BaseEnvironment();
+      expect(defaultEnv.name).toBe("base-environment");
+      expect(defaultEnv.version).toBe("1.0.0");
+    });
+
+    it("应该使用提供的配置", () => {
+      expect(env.name).toBe("test-env");
+      expect(env.version).toBe("1.0.0");
+    });
+  });
+
+  describe("getConfig()", () => {
+    it("应该返回正确的配置", () => {
+      const config = env.getConfig();
+      expect(config.name).toBe("test-env");
+      expect(config.version).toBe("1.0.0");
+      expect(config.enabled).toBe(true);
+    });
+  });
+
+  describe("组件管理", () => {
+    it("应该注册和获取组件", () => {
+      const mockComponent = {
+        name: "test-component",
+        version: "1.0.0",
+        hooks: {},
+        getStatus: () => "created" as const,
+        getConfig: () => ({ name: "test-component", version: "1.0.0", enabled: true }),
+        init: vi.fn(),
+        start: vi.fn(),
+        stop: vi.fn(),
+      };
+
+      env.registerComponent(mockComponent as any);
+      expect(env.getComponent("test-component")).toBe(mockComponent);
+      expect(env.listComponents()).toHaveLength(1);
+    });
+
+    it("应该注销组件", () => {
+      const mockComponent = {
+        name: "test-component",
+        version: "1.0.0",
+        hooks: {},
+        getStatus: () => "created" as const,
+        getConfig: () => ({ name: "test-component", version: "1.0.0", enabled: true }),
+        init: vi.fn(),
+        start: vi.fn(),
+        stop: vi.fn(),
+      };
+
+      env.registerComponent(mockComponent as any);
+      env.unregisterComponent("test-component");
+      expect(env.getComponent("test-component")).toBeUndefined();
+      expect(env.listComponents()).toHaveLength(0);
+    });
+
+    it("获取不存在的组件应返回 undefined", () => {
+      expect(env.getComponent("non-existent")).toBeUndefined();
+    });
+  });
+
+  describe("handle_query", () => {
+    it("应该抛出错误（AgentComponent 未注册）", async () => {
+      await env.init();
+      await expect(env.handle_query("hello")).rejects.toThrow("AgentComponent not found");
+    });
+  });
+
+  describe("handle_action", () => {
+    it("应该抛出错误（未实现）", async () => {
+      await env.init();
+      const action: Action = { type: "test", params: {} };
+      const context: Context = {};
+      await expect(env.handle_action(action, context)).rejects.toThrow("handle_action not implemented");
+    });
+  });
+
+  describe("EnvEvent 机制", () => {
+    it("应该订阅和取消订阅", () => {
+      const handler = vi.fn();
+      const unsubscribe = env.subscribe(handler);
+      
+      // 推送事件
+      env.pushEnvEvent({
+        id: "test-id",
+        type: "test.event",
+        timestamp: Date.now(),
+        metadata: { env_name: "test" },
+        payload: {},
+      });
+      
+      expect(handler).toHaveBeenCalledTimes(1);
+      
+      // 取消订阅
+      unsubscribe();
+      
+      // 再次推送事件
+      env.pushEnvEvent({
+        id: "test-id-2",
+        type: "test.event",
+        timestamp: Date.now(),
+        metadata: { env_name: "test" },
+        payload: {},
+      });
+      
+      expect(handler).toHaveBeenCalledTimes(1); // 不应再调用
+    });
+
+    it("subscribeAll 应该等同于 subscribe", () => {
+      const handler = vi.fn();
+      const unsubscribe = env.subscribeAll(handler);
+      
+      env.pushEnvEvent({ id: "1", type: "any.event", timestamp: Date.now(), metadata: {}, payload: {} });
+      env.pushEnvEvent({ id: "2", type: "another.event", timestamp: Date.now(), metadata: {}, payload: {} });
+      
+      expect(handler).toHaveBeenCalledTimes(2);
+      
+      unsubscribe();
+    });
+
+    it("应该订阅指定类型事件", () => {
+      const handler = vi.fn();
+      const unsubscribe = env.subscribeTo("specific.event", handler);
+      
+      // 推送指定类型事件
+      env.pushEnvEvent({
+        id: "test-id",
+        type: "specific.event",
+        timestamp: Date.now(),
+        metadata: { env_name: "test" },
+        payload: {},
+      });
+      
+      // 推送其他类型事件
+      env.pushEnvEvent({
+        id: "test-id-2",
+        type: "other.event",
+        timestamp: Date.now(),
+        metadata: { env_name: "test" },
+        payload: {},
+      });
+      
+      expect(handler).toHaveBeenCalledTimes(1);
+      
+      unsubscribe();
+    });
+
+    it("应该订阅多个类型事件", () => {
+      const handler = vi.fn();
+      const unsubscribe = env.subscribeTo(["event1", "event2"], handler);
+      
+      env.pushEnvEvent({ id: "1", type: "event1", timestamp: Date.now(), metadata: {}, payload: {} });
+      env.pushEnvEvent({ id: "2", type: "event2", timestamp: Date.now(), metadata: {}, payload: {} });
+      env.pushEnvEvent({ id: "3", type: "event3", timestamp: Date.now(), metadata: {}, payload: {} });
+      
+      expect(handler).toHaveBeenCalledTimes(2);
+      
+      unsubscribe();
+    });
+
+    it("pushEnvEvent 应该自动填充元信息", () => {
+      const handler = vi.fn();
+      env.subscribe(handler);
+      
+      env.pushEnvEvent({
+        type: "test.event",
+        payload: { data: "test" },
+      } as any);
+      
+      const event = handler.mock.calls[0][0] as EnvEvent;
+      expect(event.id).toBeDefined();
+      expect(event.timestamp).toBeDefined();
+      expect(event.metadata.env_name).toBe("test-env");
+    });
+  });
+
+  describe("生命周期", () => {
+    it("应该正确初始化", async () => {
+      await env.init();
+      expect(env.getStatus()).toBe("running");
+    });
+
+    it("应该正确启动", async () => {
+      await env.start();
+      expect(env.getStatus()).toBe("running");
+    });
+
+    it("重复启动不应报错", async () => {
+      await env.start();
+      await env.start();
+      expect(env.getStatus()).toBe("running");
+    });
+
+    it("应该正确停止", async () => {
+      await env.stop();
+      expect(env.getStatus()).toBe("stopped");
+    });
+
+    it("停止后应清理事件处理器", async () => {
+      const handler = vi.fn();
+      env.subscribe(handler);
+      
+      await env.stop();
+      
+      // 停止后推送事件应该不触发
+      env.pushEnvEvent({ id: "test", type: "test", timestamp: Date.now(), metadata: {}, payload: {} });
+      
+      expect(handler).not.toHaveBeenCalled();
+    });
+  });
+});