001/tests/basic_test.cpp

#include "../include/app.hpp"
#include <cassert>
#include <iostream>

// 测试智能体元数据结构
void test_agent_metadata() {
    std::cout << "Testing AgentMetadata...\n";
    
    multi_agent::AgentMetadata metadata{
        "test_agent",
        "Test Agent",
        "1.0.0",
        "http://localhost:8080",
        {"test", "demo"},
        "{}",
        "{}",
        multi_agent::AgentStatus::IDLE,
        std::chrono::system_clock::now()
    };
    
    assert(metadata.id == "test_agent");
    assert(metadata.name == "Test Agent");
    assert(metadata.version == "1.0.0");
    assert(metadata.service_url == "http://localhost:8080");
    assert(metadata.capabilities.size() == 2);
    assert(metadata.capabilities[0] == "test");
    assert(metadata.capabilities[1] == "demo");
    assert(metadata.status == multi_agent::AgentStatus::IDLE);
    
    std::cout << "  AgentMetadata test passed.\n";
}

// 测试智能体类
void test_agent_class() {
    std::cout << "Testing Agent class...\n";
    
    multi_agent::AgentMetadata metadata{
        "test_agent",
        "Test Agent",
        "1.0.0",
        "http://localhost:8080",
        {"test"},
        "{}",
        "{}",
        multi_agent::AgentStatus::IDLE,
        std::chrono::system_clock::now()
    };
    
    multi_agent::Agent agent(metadata);
    
    // 检查元数据获取
    const auto& agent_metadata = agent.get_metadata();
    assert(agent_metadata.id == "test_agent");
    assert(agent_metadata.name == "Test Agent");
    
    // 测试执行
    std::string result = agent.execute("test input");
    assert(!result.empty());
    assert(result.find("test_agent") != std::string::npos);
    
    std::cout << "  Agent class test passed.\n";
}

// 测试执行节点
void test_execution_node() {
    std::cout << "Testing ExecutionNode...\n";
    
    multi_agent::ExecutionNode node("node1", "agent1");
    
    assert(node.get_id() == "node1");
    assert(node.get_agent_id() == "agent1");
    assert(node.get_status() == multi_agent::ExecutionStatus::PENDING);
    
    // 测试依赖添加
    node.add_dependency("node0");
    const auto& deps = node.get_dependencies();
    assert(deps.size() == 1);
    assert(deps[0] == "node0");
    
    node.set_status(multi_agent::ExecutionStatus::COMPLETED);
    assert(node.get_status() == multi_agent::ExecutionStatus::COMPLETED);
    
    std::cout << "  ExecutionNode test passed.\n";
}

// 测试执行上下文
void test_execution_context() {
    std::cout << "Testing ExecutionContext...\n";
    
    multi_agent::ExecutionContext context;
    
    // 测试全局上下文
    context.set_global_value("key1", "value1");
    assert(context.get_global_value("key1") == "value1");
    assert(context.get_global_value("nonexistent").empty());
    
    // 测试节点输出
    context.set_node_output("node1", "output1");
    assert(context.get_node_output("node1") == "output1");
    assert(context.get_node_output("nonexistent").empty());
    
    // 测试序列化（简化版本）
    std::string snapshot = context.serialize();
    assert(!snapshot.empty());
    
    std::cout << "  ExecutionContext test passed.\n";
}

// 测试流引擎基础功能
void test_flow_engine_basic() {
    std::cout << "Testing FlowEngine basic functionality...\n";
    
    multi_agent::FlowEngine engine;
    
    // 注册智能体
    multi_agent::AgentMetadata metadata{
        "test_agent",
        "Test Agent",
        "1.0.0",
        "http://localhost:8080",
        {"test"},
        "{}",
        "{}",
        multi_agent::AgentStatus::IDLE,
        std::chrono::system_clock::now()
    };
    
    engine.register_agent(metadata);
    
    // 获取智能体
    auto agent = engine.get_agent("test_agent");
    assert(agent != nullptr);
    assert(agent->get_metadata().id == "test_agent");
    
    // 获取不存在的智能体
    auto non_existent = engine.get_agent("non_existent");
    assert(non_existent == nullptr);
    
    std::cout << "  FlowEngine basic test passed.\n";
}

// 测试拓扑排序（简单DAG）
void test_topological_sort() {
    std::cout << "Testing topological sort...\n";
    
    multi_agent::FlowEngine engine;
    
    // 创建节点：node1 -> node2 -> node3
    auto node1 = std::make_shared<multi_agent::ExecutionNode>("node1", "agent1");
    auto node2 = std::make_shared<multi_agent::ExecutionNode>("node2", "agent2");
    auto node3 = std::make_shared<multi_agent::ExecutionNode>("node3", "agent3");
    
    node2->add_dependency("node1");
    node3->add_dependency("node2");
    
    engine.add_node(node1);
    engine.add_node(node2);
    engine.add_node(node3);
    
    // 注意：由于FlowEngine的拓扑排序是私有方法，我们无法直接测试
    // 这里只是验证节点添加成功
    auto status = engine.get_execution_status();
    assert(status.size() == 3);
    
    std::cout << "  Topological sort test framework ready.\n";
}

// 主测试函数
int main() {
    std::cout << "========================================\n";
    std::cout << "Running Multi-Agent System Tests\n";
    std::cout << "========================================\n\n";
    
    try {
        test_agent_metadata();
        test_agent_class();
        test_execution_node();
        test_execution_context();
        test_flow_engine_basic();
        test_topological_sort();
        
        std::cout << "\n========================================\n";
        std::cout << "All tests passed successfully!\n";
        std::cout << "========================================\n";
        
        return 0;
        
    } catch (const std::exception& e) {
        std::cerr << "\nTest failed with exception: " << e.what() << "\n";
        return 1;
    } catch (...) {
        std::cerr << "\nTest failed with unknown exception.\n";
        return 1;
    }
}