innomind-vita/tests/agents/single/error.agent.test.ts

InnoMind Vita - AI-Powered Industrial Software Platform

import { Agent } from '@innomind-vita/core';

describe('Agent Error Handling', () => {
  let agent: Agent;

  beforeEach(() => {
    agent = new Agent({
      id: 'error-test-agent',
      name: '错误处理测试智能体',
      maxProcessTime: 1000
    });
  });

  afterEach(() => {
    agent.destroy();
  });

  describe('输入验证', () => {
    it('应该处理空消息内容', async () => {
      const response = await agent.process({
        type: 'command',
        content: ''
      });

      expect(response.type).toBe('error');
      expect(response.content).toContain('消息内容不能为空');
    });

    it('应该处理无效的消息类型', async () => {
      const response = await agent.process({
        type: 'invalid' as any,
        content: '测试'
      });

      expect(response.type).toBe('error');
      expect(response.content).toContain('无效的消息类型');
    });
  });

  describe('并发处理', () => {
    it('应该正确处理并发请求', async () => {
      const requests = Array(5).fill(null).map((_, index) => 
        agent.process({
          type: 'command',
          content: `并发请求 ${index + 1}`
        })
      );

      const responses = await Promise.all(requests);
      const successResponses = responses.filter(r => r.type === 'response');
      const errorResponses = responses.filter(r => r.type === 'error');

      expect(successResponses.length).toBe(1); // 只有第一个请求成功
      expect(errorResponses.length).toBe(4); // 其他请求返回错误
      expect(errorResponses.every(r => r.content === 'Agent is busy')).toBe(true);
    });
  });

  describe('超时处理', () => {
    it('应该在超时后自动重置状态', async () => {
      jest.useFakeTimers();

      const processPromise = agent.process({
        type: 'command',
        content: '超时测试'
      });

      jest.advanceTimersByTime(1500); // 超过maxProcessTime
      
      const response = await processPromise;
      expect(response.type).toBe('error');
      expect(response.content).toBe('Processing timeout');
      expect(agent.currentStatus).toBe('error');

      // 等待一段时间后应该自动重置
      jest.advanceTimersByTime(1000);
      expect(agent.currentStatus).toBe('idle');

      jest.useRealTimers();
    });
  });

  describe('错误恢复', () => {
    it('应该能在错误后恢复正常工作', async () => {
      // 首先触发一个错误
      const errorResponse = await agent.process({
        type: 'invalid' as any,
        content: '触发错误'
      });
      expect(errorResponse.type).toBe('error');

      // 等待自动重置
      await new Promise(resolve => setTimeout(resolve, 1100));

      // 验证能否正常处理新请求
      const response = await agent.process({
        type: 'command',
        content: '测试恢复'
      });

      expect(response.type).toBe('response');
      expect(agent.currentStatus).toBe('idle');
    });
  });
});