cpp-mcp/test/test_mcp_versioning.cpp

/**
 * @file test_mcp_versioning.cpp
 * @brief 测试MCP版本控制相关功能
 * 
 * 本文件包含对MCP版本控制的单元测试，基于规范2024-11-05。
 */

#include "mcp_message.h"
#include "mcp_server.h"
#include "mcp_client.h"
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <string>
#include <thread>
#include <future>
#include <chrono>

// 测试类，用于设置服务器和客户端
class McpVersioningTest : public ::testing::Test {
protected:
    void SetUp() override {
        // 创建服务器
        server = std::make_unique<mcp::server>("localhost", 8097);
        server->set_server_info("TestServer", "2024-11-05");
        
        // 设置服务器能力
        mcp::json capabilities = {
            {"tools", {{"listChanged", true}}},
            {"transport", {{"sse", true}}}
        };
        server->set_capabilities(capabilities);
    }
    
    void TearDown() override {
        // 停止服务器
        if (server && server_thread.joinable()) {
            server->stop();
            server_thread.join();
        }
    }
    
    // 启动服务器
    void start_server() {
        server_thread = std::thread([this]() {
            server->start(false);
        });
        // 等待服务器启动
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
    std::unique_ptr<mcp::server> server;
    std::thread server_thread;
};

// 测试版本常量
TEST(McpVersioningTest, VersionConstantTest) {
    // 验证MCP版本常量
    EXPECT_EQ(std::string(mcp::MCP_VERSION), "2024-11-05");
}

// 测试版本匹配
TEST_F(McpVersioningTest, VersionMatchTest) {
    // 启动服务器
    start_server();
    
    // 创建客户端，使用匹配的版本
    mcp::client client("localhost", 8097);
    client.set_timeout(5);
    
    // 测试初始化，应该成功
    bool init_result = client.initialize("TestClient", mcp::MCP_VERSION);
    EXPECT_TRUE(init_result);
}

// 测试版本不匹配
TEST_F(McpVersioningTest, VersionMismatchTest) {
    // 启动服务器
    start_server();
    
    // 创建客户端，使用不匹配的版本
    mcp::client client("localhost", 8097);
    client.set_timeout(5);
    
    // 测试初始化，应该失败或返回警告
    // 注意：根据实际实现，这可能会成功但有警告，或者完全失败
    bool init_result = client.initialize("TestClient", "2023-01-01");
    
    // 如果实现允许版本不匹配，这个测试可能需要调整
    // 这里我们假设实现会拒绝不匹配的版本
    EXPECT_FALSE(init_result);
}

// 测试服务器版本信息
TEST_F(McpVersioningTest, ServerVersionInfoTest) {
    // 启动服务器
    start_server();
    
    // 创建客户端
    mcp::client client("localhost", 8097);
    client.set_timeout(5);
    client.initialize("TestClient", mcp::MCP_VERSION);
    
    // 获取服务器信息
    mcp::response response = client.send_request("server/info");
    
    // 验证服务器信息
    EXPECT_FALSE(response.is_error());
    EXPECT_EQ(response.result["name"], "TestServer");
    EXPECT_EQ(response.result["version"], "2024-11-05");
    EXPECT_TRUE(response.result.contains("capabilities"));
}

// 测试客户端版本信息
TEST_F(McpVersioningTest, ClientVersionInfoTest) {
    // 创建一个处理器来捕获初始化请求
    mcp::json captured_init_params;
    server->register_method("initialize", [&captured_init_params](const mcp::json& params) -> mcp::json {
        captured_init_params = params;
        return {
            {"name", "TestServer"},
            {"version", "2024-11-05"},
            {"capabilities", {
                {"tools", {{"listChanged", true}}},
                {"transport", {{"sse", true}}}
            }}
        };
    });
    
    // 启动服务器
    start_server();
    
    // 创建客户端
    mcp::client client("localhost", 8097);
    client.set_timeout(5);
    client.initialize("TestClient", "1.0.0");
    
    // 验证客户端版本信息
    EXPECT_EQ(captured_init_params["name"], "TestClient");
    EXPECT_EQ(captured_init_params["version"], "1.0.0");
}