Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

24.3 KB
Raw Blame
"""
合并后的WebSocket测试
整合了多个WebSocket相关的测试文件,消除重复代码
"""

import json
import unittest
from unittest.mock import AsyncMock

import pytest

from tests.shared import create_test_components


@pytest.mark.slow
class TestWebSocket(unittest.IsolatedAsyncioTestCase):
    """合并后的WebSocket测试"""

    def setUp(self):
        """设置测试组件"""
        self.components = create_test_components()
        self.test_messages = []
        self.test_connections = {}

    async def test_websocket_connection_management(self):
        """测试WebSocket连接管理"""
        print("\n=== 测试WebSocket连接管理 ===")

        # 导入WebSocket管理器
        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 测试连接
        websocket1 = AsyncMock()
        websocket2 = AsyncMock()

        # 模拟连接
        await manager.connect(websocket1, 1)
        await manager.connect(websocket2, 2)

        # 验证连接
        self.assertEqual(len(manager.active_connections), 2)
        self.assertIn(1, manager.active_connections)
        self.assertIn(2, manager.active_connections)

        # 测试断开连接
        manager.disconnect(websocket1)

        # 验证断开连接
        self.assertEqual(len(manager.active_connections), 1)
        self.assertNotIn(1, manager.active_connections)
        self.assertIn(2, manager.active_connections)

        print("连接管理验证: ✅")
        print(f"  活跃连接数: {len(manager.active_connections)}")
        print(f"  剩余连接: {list(manager.active_connections.keys())}")

    async def test_websocket_message_broadcast(self):
        """测试WebSocket消息广播"""
        print("\n=== 测试WebSocket消息广播 ===")

        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 创建模拟的WebSocket连接
        websocket1 = AsyncMock()
        websocket2 = AsyncMock()

        # 连接
        await manager.connect(websocket1, 1)
        await manager.connect(websocket2, 2)

        # 广播消息
        test_message = {
            "type": "test_message",
            "data": {"content": "Hello, WebSocket!"},
        }

        await manager.broadcast_to_task(test_message, 1)

        # 验证消息发送
        websocket1.send_text.assert_called_once_with(json.dumps(test_message))
        websocket2.send_text.assert_not_called()  # 不应该发送到task_2

        print("消息广播验证: ✅")
        print("  目标task: task_1")
        print(f"  websocket1调用次数: {websocket1.send_text.call_count}")
        print(f"  websocket2调用次数: {websocket2.send_text.call_count}")

    async def test_websocket_message_handling(self):
        """测试WebSocket消息处理"""
        print("\n=== 测试WebSocket消息处理 ===")

        # 测试不同类型的消息处理
        test_messages = [
            {"type": "subscribe", "task_id": "task_1"},
            {"type": "unsubscribe", "task_id": "task_1"},
            {"type": "ping", "data": {"timestamp": "2023-01-01T00:00:00"}},
            {"type": "get_status", "task_id": "task_1"},
        ]

        for message in test_messages:
            # 模拟消息处理
            message_type = message.get("type")

            if message_type == "subscribe":
                # 订阅逻辑
                task_id = message.get("task_id")
                print(f"  处理订阅消息: task_id={task_id}")

            elif message_type == "unsubscribe":
                # 取消订阅逻辑
                task_id = message.get("task_id")
                print(f"  处理取消订阅消息: task_id={task_id}")

            elif message_type == "ping":
                # ping响应
                print(f"  处理ping消息: {message.get('data')}")

            elif message_type == "get_status":
                # 状态查询
                task_id = message.get("task_id")
                print(f"  处理状态查询: task_id={task_id}")

        print("消息处理验证: ✅")
        print(f"  处理消息数量: {len(test_messages)}")

    async def test_websocket_error_handling(self):
        """测试WebSocket错误处理"""
        print("\n=== 测试WebSocket错误处理 ===")

        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 创建会抛出异常的WebSocket
        failing_websocket = AsyncMock()
        failing_websocket.send_text.side_effect = Exception("Connection failed")

        # 连接
        await manager.connect(failing_websocket, "task_1")

        # 尝试发送消息 - 应该处理异常
        test_message = {"type": "test", "data": {"content": "test"}}

        try:
            await manager.broadcast_to_task(test_message, 1)
        except Exception as e:
            print(f"  捕获到异常: {e}")

        # 验证连接仍然存在
        self.assertEqual(len(manager.active_connections), 1)

        print("错误处理验证: ✅")
        print(f"  连接数保持: {len(manager.active_connections)}")

    async def test_websocket_trace_integration(self):
        """测试WebSocket与追踪集成"""
        print("\n=== 测试WebSocket与追踪集成 ===")

        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 创建模拟WebSocket
        websocket = AsyncMock()
        await manager.connect(websocket, 1)

        # 创建追踪事件
        trace_events = [
            {
                "type": "trace_start",
                "task_id": "task_1",
                "data": {"timestamp": "2023-01-01T00:00:00"},
            },
            {
                "type": "dag_step_start",
                "task_id": "task_1",
                "data": {"step_id": "step1", "step_name": "test_step"},
            },
            {
                "type": "llm_call_start",
                "task_id": "task_1",
                "data": {"model": "gpt-3.5-turbo"},
            },
        ]

        # 模拟追踪事件通过WebSocket发送
        for event in trace_events:
            websocket_message = {"type": "trace_event", "data": event}
            await manager.broadcast_to_task(websocket_message, 1)

        # 验证WebSocket发送
        self.assertEqual(websocket.send_text.call_count, len(trace_events))

        print("追踪集成验证: ✅")
        print(f"  发送追踪事件数: {len(trace_events)}")
        print(f"  WebSocket调用次数: {websocket.send_text.call_count}")

    async def test_websocket_step_update(self):
        """测试WebSocket步骤更新"""
        print("\n=== 测试WebSocket步骤更新 ===")

        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 创建多个WebSocket连接
        websockets = []
        for i in range(3):
            websocket = AsyncMock()
            await manager.connect(websocket, i)
            websockets.append(websocket)

        # 发送步骤更新
        step_update = {
            "type": "step_update",
            "task_id": "task_1",
            "data": {
                "step_id": "step1",
                "status": "completed",
                "result": {"output": "Step completed successfully"},
            },
        }

        await manager.broadcast_to_task(step_update, 1)

        # 验证只有task_1的WebSocket接收到消息
        websockets[0].send_text.assert_not_called()
        websockets[1].send_text.assert_called_once_with(json.dumps(step_update))
        websockets[2].send_text.assert_not_called()

        print("步骤更新验证: ✅")
        print("  目标task: task_1")
        print("  正确接收的WebSocket: 1/3")

    async def test_websocket_task_isolation(self):
        """测试WebSocket任务隔离"""
        print("\n=== 测试WebSocket任务隔离 ===")

        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 创建不同任务的WebSocket连接
        task_connections = {}
        for i in [1, 2, 3]:
            websocket = AsyncMock()
            await manager.connect(websocket, i)
            task_connections[i] = websocket

        # 向不同任务发送消息
        for i in [1, 2, 3]:
            message = {
                "type": "task_message",
                "task_id": f"task_{i}",
                "data": {"content": f"Message for task_{i}"},
            }
            await manager.broadcast_to_task(message, i)

        # 验证任务隔离
        for task_id, websocket in task_connections.items():
            self.assertEqual(websocket.send_text.call_count, 1)
            call_args = websocket.send_text.call_args[0][0]
            # 消息是JSON字符串,需要解析
            import json

            parsed_message = json.loads(call_args)
            self.assertEqual(parsed_message["task_id"], f"task_{task_id}")

        print("任务隔离验证: ✅")
        print(f"  任务数量: {len(task_connections)}")
        print("  每个任务接收消息数: 1")

    async def test_websocket_connection_limits(self):
        """测试WebSocket连接限制"""
        print("\n=== 测试WebSocket连接限制 ===")

        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 创建大量连接
        max_connections = 100
        websockets = []

        for i in range(max_connections):
            websocket = AsyncMock()
            await manager.connect(websocket, i)
            websockets.append(websocket)

        # 验证连接数量
        self.assertEqual(len(manager.active_connections), max_connections)

        # 测试广播性能
        test_message = {"type": "broadcast_test", "data": {"content": "test"}}

        import time

        start_time = time.thread_time()

        # 向所有连接广播消息
        for i in range(max_connections):
            await manager.broadcast_to_task(test_message, i)

        end_time = time.thread_time()
        duration = end_time - start_time

        # Count only CPU work; CI scheduling stalls are not a broadcast regression.
        for websocket in websockets:
            websocket.send_text.assert_awaited_once()
            self.assertEqual(
                json.loads(websocket.send_text.call_args.args[0]), test_message
            )

        self.assertLess(duration, 5.0, f"{max_connections}次广播应该在5个 CPU 秒内完成")

        print("连接限制验证: ✅")
        print(f"  最大连接数: {max_connections}")
        print(f"  广播 CPU 耗时: {duration:.3f}秒")
        print(f"  平均每次广播: {duration / max_connections * 1000:.3f}毫秒")

    async def test_websocket_message_validation(self):
        """测试WebSocket消息验证"""
        print("\n=== 测试WebSocket消息验证 ===")

        # 测试不同类型的消息验证
        test_cases = [
            {
                "name": "有效消息",
                "message": {
                    "type": "trace_event",
                    "task_id": "task_1",
                    "data": {"event_type": "test"},
                },
                "should_pass": True,
            },
            {
                "name": "缺少类型",
                "message": {"task_id": "task_1", "data": {"event_type": "test"}},
                "should_pass": False,
            },
            {
                "name": "缺少task_id",
                "message": {"type": "trace_event", "data": {"event_type": "test"}},
                "should_pass": False,
            },
            {"name": "空消息", "message": {}, "should_pass": False},
            {"name": "非字典消息", "message": "invalid_message", "should_pass": False},
        ]

        for test_case in test_cases:
            message = test_case["message"]
            should_pass = test_case["should_pass"]

            # 简单的消息验证逻辑
            is_valid = True
            if not isinstance(message, dict):
                is_valid = False
            elif "type" not in message:
                is_valid = False
            elif "task_id" not in message:
                is_valid = False

            self.assertEqual(
                is_valid, should_pass, f"消息 '{test_case['name']}' 验证失败"
            )

            print(f"  {test_case['name']}: {'✅' if is_valid == should_pass else '❌'}")

        print("消息验证验证: ✅")
        print(f"  测试用例数: {len(test_cases)}")

    async def test_websocket_stream_event_format(self):
        """测试WebSocket流式事件格式统一"""
        print("\n=== 测试WebSocket流式事件格式统一 ===")

        from datetime import datetime, timezone

        from xagent.web.services.task_execution import create_stream_event

        # 测试创建流式事件
        test_data = {
            "step_id": "step1",
            "step_name": "test_step",
            "status": "completed",
            "result": "test_result",
        }

        stream_event = create_stream_event(
            "dag_step_info",
            task_id=1,
            data=test_data,
            timestamp=datetime.now(timezone.utc),
        )

        # 验证流式事件格式
        self.assertEqual(stream_event["type"], "trace_event")
        self.assertEqual(stream_event["event_type"], "dag_step_info")
        self.assertEqual(stream_event["task_id"], 1)
        self.assertIn("event_id", stream_event)
        self.assertIn("timestamp", stream_event)
        self.assertEqual(stream_event["data"], test_data)

        print("流式事件格式验证: ✅")
        print(f"  事件类型: {stream_event['event_type']}")
        print(f"  任务ID: {stream_event['task_id']}")
        print(f"  事件ID: {stream_event['event_id']}")
        print(f"  数据键: {list(stream_event['data'].keys())}")

    async def test_websocket_reconnection_handling(self):
        """测试WebSocket重连处理"""
        print("\n=== 测试WebSocket重连处理 ===")

        from xagent.web.api.websocket import ConnectionManager

        manager = ConnectionManager()

        # 创建WebSocket连接
        websocket1 = AsyncMock()
        await manager.connect(websocket1, 1)

        # 模拟连接断开
        manager.disconnect(websocket1)

        # 验证连接已断开
        self.assertEqual(len(manager.active_connections), 0)

        # 重新连接
        websocket2 = AsyncMock()
        await manager.connect(websocket2, 1)

        # 验证重新连接成功
        self.assertEqual(len(manager.active_connections), 1)
        self.assertIn(1, manager.active_connections)

        # 测试重连后消息发送
        test_message = {"type": "reconnection_test", "data": {"content": "test"}}
        await manager.broadcast_to_task(test_message, 1)

        # 验证新连接能接收消息
        websocket2.send_text.assert_called_once_with(json.dumps(test_message))

        print("重连处理验证: ✅")
        print("  断开后连接数: 0")
        print(f"  重连后连接数: {len(manager.active_connections)}")
        print(f"  消息发送成功: {websocket2.send_text.call_count}")

    async def test_historical_data_streaming(self):
        """测试历史数据流式发送"""
        print("\n=== 测试历史数据流式发送 ===")

        from datetime import datetime, timezone
        from unittest.mock import AsyncMock

        from xagent.web.services.task_execution import create_stream_event

        # 创建模拟的WebSocket和数据库
        websocket = AsyncMock()

        # 模拟数据库数据
        now = datetime.now(timezone.utc)
        mock_task_data = {
            "id": 1,
            "title": "Test Task",
            "description": "Test Description",
            "status": "completed",
            "created_at": now.isoformat(),
            "updated_at": now.isoformat(),
        }

        # 模拟历史数据事件
        historical_events = [
            create_stream_event("task_info", 1, mock_task_data, now),
            create_stream_event(
                "task_message", 1, {"role": "user", "content": "Hello"}, now
            ),
            create_stream_event(
                "dag_step_info",
                1,
                {"id": "step1", "name": "test_step", "status": "completed"},
                now,
            ),
            create_stream_event(
                "execution_log", 1, {"level": "info", "message": "Step completed"}, now
            ),
            create_stream_event(
                "historical_data_complete",
                1,
                {"message": "Historical data loaded"},
                now,
            ),
        ]

        # 模拟发送历史数据
        for event in historical_events:
            await websocket.send_text(json.dumps(event))

        # 验证历史数据发送
        self.assertEqual(websocket.send_text.call_count, len(historical_events))

        # 验证事件格式
        for i, call in enumerate(websocket.send_text.call_args_list):
            sent_data = json.loads(call[0][0])
            self.assertEqual(sent_data["type"], "trace_event")
            self.assertIn("event_id", sent_data)
            self.assertIn("timestamp", sent_data)
            self.assertEqual(sent_data["task_id"], 1)

        print("历史数据流式发送验证: ✅")
        print(f"  发送事件数量: {len(historical_events)}")
        print(f"  WebSocket调用次数: {websocket.send_text.call_count}")

    async def test_rewrite_file_links_supports_legacy_preview_paths(self):
        from xagent.web.services.task_execution import _rewrite_file_links_to_file_id

        output_text = (
            "Legacy link: [report](/preview/web_task_12/output/report.html)\n"
            "Legacy uploads link: [img](/uploads/user_3/web_task_12/output/a.png)\n"
            "File link: [doc](file:/preview/web_task_12/output/readme.md)\n"
            "Task-local link: [poster](output/poster.html)"
        )
        path_to_file_id = {
            "preview/web_task_12/output/report.html": "fid-report",
            "uploads/user_3/web_task_12/output/a.png": "fid-image",
            "preview/web_task_12/output/readme.md": "fid-readme",
            "output/poster.html": "fid-poster",
        }

        rewritten = _rewrite_file_links_to_file_id(output_text, path_to_file_id)

        self.assertIn("[report](file:fid-report)", rewritten)
        self.assertIn("[img](file:fid-image)", rewritten)
        self.assertIn("[doc](file:fid-readme)", rewritten)
        self.assertIn("[poster](file:fid-poster)", rewritten)

    async def test_rewrite_file_links_preserves_non_legacy_urls(self):
        from xagent.web.services.task_execution import _rewrite_file_links_to_file_id

        output_text = "[site](https://example.com) and [local](/not-preview/path)"
        rewritten = _rewrite_file_links_to_file_id(output_text, {})
        self.assertEqual(rewritten, output_text)

    async def test_rewrite_file_links_preserves_unmapped_absolute_paths(self):
        from xagent.web.services.task_execution import _rewrite_file_links_to_file_id

        absolute_image_path = (
            "/Users/bsbds/workspace/xagent_1/src/xagent/web/uploads/"
            "user_1/web_task_15/output/generated_image_9836e259.png"
        )
        output_text = (
            f"Image: ![generated image]({absolute_image_path})\n"
            f"Link: [generated image]({absolute_image_path})"
        )

        rewritten = _rewrite_file_links_to_file_id(output_text, {})

        self.assertEqual(rewritten, output_text)

    async def test_websocket_trace_handler_integration(self):
        """测试WebSocket追踪处理器集成"""
        print("\n=== 测试WebSocket追踪处理器集成 ===")

        from unittest.mock import AsyncMock, patch

        from xagent.core.agent.trace import (
            TraceAction,
            TraceCategory,
            TraceEvent,
            TraceEventType,
            TraceScope,
        )
        from xagent.web.api.websocket import ConnectionManager
        from xagent.web.services import task_events
        from xagent.web.services.task_event_trace_handler import TaskEventTraceHandler

        # 创建模拟的WebSocket管理器
        mock_manager = AsyncMock()

        # This case assumes the task has an audience. Register a stand-in
        # connection on a real connection manager so the audience question
        # runs through the production path instead of a hard-coded answer.
        audience_manager = ConnectionManager()
        audience_manager.register_connection(AsyncMock(), 1)

        # 用patch替换manager
        with (
            patch(
                "xagent.web.services.task_event_trace_handler.publish_task_event",
                mock_manager.broadcast_to_task,
            ),
            patch.object(
                task_events,
                "_task_audience_probe",
                audience_manager.has_connections_for_task,
            ),
        ):
            # 创建WebSocket追踪处理器
            handler = TaskEventTraceHandler(task_id=1)

            # 创建测试事件
            event_type = TraceEventType(
                TraceScope.STEP, TraceAction.START, TraceCategory.DAG
            )
            trace_event = TraceEvent(
                event_type=event_type,
                task_id=1,
                step_id="step1",
                data={"step_name": "test_step", "tool_name": "test_tool"},
            )

            # 处理事件
            await handler.handle_event(trace_event)

            # 验证事件被转换为流式格式并发送
            mock_manager.broadcast_to_task.assert_called_once()

            # 获取发送的消息
            sent_message = mock_manager.broadcast_to_task.call_args[0][0]

            # 验证消息格式
            self.assertEqual(sent_message["type"], "trace_event")
            self.assertEqual(sent_message["event_type"], "dag_step_start")
            self.assertEqual(sent_message["task_id"], 1)
            self.assertIn("event_id", sent_message)
            self.assertIn("timestamp", sent_message)
            self.assertIn("data", sent_message)

            # 验证数据内容
            self.assertEqual(sent_message["data"]["step_name"], "test_step")
            self.assertEqual(sent_message["data"]["tool_name"], "test_tool")

            print("WebSocket追踪处理器集成验证: ✅")
            print(f"  事件类型: {sent_message['event_type']}")
            print(f"  任务ID: {sent_message['task_id']}")
            print(f"  步骤名称: {sent_message['data']['step_name']}")
            print(f"  工具名称: {sent_message['data']['tool_name']}")

    async def test_websocket_pause_resume_handlers_exist(self):
        """测试WebSocket暂停恢复处理器存在性"""
        print("\n=== 测试WebSocket暂停恢复处理器存在性 ===")

        # 测试导入
        from xagent.web.api.websocket import handle_pause_task, handle_resume_task

        # 验证函数存在
        assert callable(handle_pause_task)
        assert callable(handle_resume_task)

        print("  WebSocket暂停恢复处理器存在性验证完成")

    async def test_websocket_pause_resume_error_handling_simple(self):
        """测试WebSocket暂停恢复错误处理(简化版)"""
        print("\n=== 测试WebSocket暂停恢复错误处理(简化版) ===")

        from unittest.mock import AsyncMock, patch

        from xagent.web.api.websocket import handle_pause_task

        # 创建模拟WebSocket
        websocket = AsyncMock()
        task_id = 123

        # 模拟agent manager返回None(agent不存在的情况)
        mock_agent_manager = AsyncMock()
        mock_agent_manager.get_agent_for_task = AsyncMock(return_value=None)

        # 模拟chat模块的agent_manager
        mock_chat_module = AsyncMock()
        mock_chat_module.agent_manager = mock_agent_manager

        # 模拟全局manager
        mock_manager = AsyncMock()

        with patch.dict("sys.modules", {"xagent.web.api.chat": mock_chat_module}):
            with patch("xagent.web.api.websocket.manager", mock_manager):
                # 测试暂停 - 应该发送错误消息
                message_data = {
                    "type": "pause_task",
                    "task_id": task_id,
                    "timestamp": "2024-01-01T00:00:00Z",
                }

                await handle_pause_task(websocket, task_id, message_data)

                # 验证发送了错误消息
                mock_manager.send_personal_message.assert_called()

        print("  WebSocket暂停恢复错误处理测试完成")


if __name__ == "__main__":
    unittest.main()