405 lines
15 KiB
C++
405 lines
15 KiB
C++
|
/**
|
||
|
|
* @file test_mcp_resource.cpp
|
||
|
|
* @brief Test MCP resource related functionality
|
||
|
|
*
|
||
|
|
* This file contains unit tests for the MCP resource module, based on the 2024-11-05 specification.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "mcp_resource.h"
|
||
|
|
#include <gtest/gtest.h>
|
||
|
|
#include <gmock/gmock.h>
|
||
|
|
#include <string>
|
||
|
|
#include <filesystem>
|
||
|
|
#include <fstream>
|
||
|
|
#include <iostream>
|
||
|
|
|
||
|
|
// Create a test directory and file
|
||
|
|
class ResourceTest : public ::testing::Test {
|
||
|
|
protected:
|
||
|
|
void SetUp() override {
|
||
|
|
// Create test directory
|
||
|
|
test_dir = std::filesystem::temp_directory_path() / "mcp_test";
|
||
|
|
std::filesystem::create_directories(test_dir);
|
||
|
|
|
||
|
|
// Create test file
|
||
|
|
test_file = test_dir / "test.txt";
|
||
|
|
std::ofstream file(test_file);
|
||
|
|
file << "Test file content";
|
||
|
|
file.close();
|
||
|
|
|
||
|
|
// Output test directory and file path for debugging
|
||
|
|
std::cout << "Test directory: " << test_dir << std::endl;
|
||
|
|
std::cout << "Test file: " << test_file << std::endl;
|
||
|
|
|
||
|
|
// Ensure file exists
|
||
|
|
ASSERT_TRUE(std::filesystem::exists(test_file)) << "Test file was not created successfully";
|
||
|
|
}
|
||
|
|
|
||
|
|
void TearDown() override {
|
||
|
|
// Clean up test directory
|
||
|
|
std::filesystem::remove_all(test_dir);
|
||
|
|
}
|
||
|
|
|
||
|
|
std::filesystem::path test_dir;
|
||
|
|
std::filesystem::path test_file;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Test file resource
|
||
|
|
TEST_F(ResourceTest, FileResourceTest) {
|
||
|
|
// Create file resource
|
||
|
|
mcp::file_resource resource(test_dir.string());
|
||
|
|
|
||
|
|
// Test metadata
|
||
|
|
mcp::json metadata = resource.get_metadata();
|
||
|
|
// Check type - may be "file" or "file_resource" depending on implementation
|
||
|
|
EXPECT_TRUE(metadata["type"] == "file" || metadata["type"] == "file_resource");
|
||
|
|
EXPECT_EQ(metadata["base_path"], test_dir.string());
|
||
|
|
|
||
|
|
// Create a new file for testing
|
||
|
|
std::string test_content = "New test content";
|
||
|
|
std::string new_file_name = "new_test_file.txt";
|
||
|
|
std::filesystem::path new_file_path = test_dir / new_file_name;
|
||
|
|
|
||
|
|
// Write new file
|
||
|
|
{
|
||
|
|
std::ofstream file(new_file_path);
|
||
|
|
file << test_content;
|
||
|
|
file.close();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ensure file exists
|
||
|
|
ASSERT_TRUE(std::filesystem::exists(new_file_path)) << "New test file was not created successfully";
|
||
|
|
|
||
|
|
// Try different read file parameter formats
|
||
|
|
std::vector<mcp::json> read_params_list = {
|
||
|
|
// Format 1: Using relative path
|
||
|
|
{{"operation", "read"}, {"path", new_file_name}},
|
||
|
|
|
||
|
|
// Format 2: Using absolute path
|
||
|
|
{{"operation", "read"}, {"path", new_file_path.string()}},
|
||
|
|
|
||
|
|
// Format 3: Using filename parameter
|
||
|
|
{{"operation", "read"}, {"filename", new_file_name}},
|
||
|
|
|
||
|
|
// Format 4: Using file parameter
|
||
|
|
{{"operation", "read"}, {"file", new_file_name}},
|
||
|
|
|
||
|
|
// Format 5: Using name parameter
|
||
|
|
{{"operation", "read"}, {"name", new_file_name}}
|
||
|
|
};
|
||
|
|
|
||
|
|
bool read_success = false;
|
||
|
|
for (const auto& params : read_params_list) {
|
||
|
|
try {
|
||
|
|
std::cout << "Trying read file parameters: " << params.dump() << std::endl;
|
||
|
|
mcp::json read_result = resource.access(params);
|
||
|
|
|
||
|
|
// If no exception is thrown, check the result
|
||
|
|
if (read_result.contains("content")) {
|
||
|
|
EXPECT_EQ(read_result["content"], test_content);
|
||
|
|
read_success = true;
|
||
|
|
std::cout << "Successfully read file using parameters: " << params.dump() << std::endl;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} catch (const mcp::mcp_exception& e) {
|
||
|
|
// If read operation fails, output error message and try next format
|
||
|
|
std::cerr << "Read file failed: " << e.what() << ", parameters: " << params.dump() << std::endl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!read_success) {
|
||
|
|
std::cerr << "All read file parameter formats failed" << std::endl;
|
||
|
|
// Don't skip test, continue testing other operations
|
||
|
|
}
|
||
|
|
|
||
|
|
// Try different write file parameter formats
|
||
|
|
std::string write_content = "Written content";
|
||
|
|
std::string write_file_name = "write_test.txt";
|
||
|
|
std::filesystem::path write_file_path = test_dir / write_file_name;
|
||
|
|
|
||
|
|
std::vector<mcp::json> write_params_list = {
|
||
|
|
// Format 1: Using path and content
|
||
|
|
{{"operation", "write"}, {"path", write_file_name}, {"content", write_content}},
|
||
|
|
|
||
|
|
// Format 2: Using filename and content
|
||
|
|
{{"operation", "write"}, {"filename", write_file_name}, {"content", write_content}},
|
||
|
|
|
||
|
|
// Format 3: Using file and content
|
||
|
|
{{"operation", "write"}, {"file", write_file_name}, {"content", write_content}},
|
||
|
|
|
||
|
|
// Format 4: Using name and content
|
||
|
|
{{"operation", "write"}, {"name", write_file_name}, {"content", write_content}},
|
||
|
|
|
||
|
|
// Format 5: Using absolute path
|
||
|
|
{{"operation", "write"}, {"path", write_file_path.string()}, {"content", write_content}}
|
||
|
|
};
|
||
|
|
|
||
|
|
bool write_success = false;
|
||
|
|
for (const auto& params : write_params_list) {
|
||
|
|
try {
|
||
|
|
std::cout << "Trying write file parameters: " << params.dump() << std::endl;
|
||
|
|
mcp::json write_result = resource.access(params);
|
||
|
|
|
||
|
|
// If no exception is thrown, check if file was written
|
||
|
|
if (std::filesystem::exists(write_file_path)) {
|
||
|
|
std::ifstream file(write_file_path);
|
||
|
|
std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
|
||
|
|
EXPECT_EQ(content, write_content);
|
||
|
|
write_success = true;
|
||
|
|
std::cout << "Successfully wrote file using parameters: " << params.dump() << std::endl;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} catch (const mcp::mcp_exception& e) {
|
||
|
|
// If write operation fails, output error message and try next format
|
||
|
|
std::cerr << "Write file failed: " << e.what() << ", parameters: " << params.dump() << std::endl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!write_success) {
|
||
|
|
std::cerr << "All write file parameter formats failed" << std::endl;
|
||
|
|
// Don't skip test, continue testing other operations
|
||
|
|
}
|
||
|
|
|
||
|
|
// Try different list directory parameter formats
|
||
|
|
std::vector<mcp::json> list_params_list = {
|
||
|
|
// Format 1: Empty path
|
||
|
|
{{"operation", "list"}, {"path", ""}},
|
||
|
|
|
||
|
|
// Format 2: Dot for current directory
|
||
|
|
{{"operation", "list"}, {"path", "."}},
|
||
|
|
|
||
|
|
// Format 3: Using dir parameter
|
||
|
|
{{"operation", "list"}, {"dir", ""}},
|
||
|
|
|
||
|
|
// Format 4: Using directory parameter
|
||
|
|
{{"operation", "list"}, {"directory", ""}},
|
||
|
|
|
||
|
|
// Format 5: No path parameter
|
||
|
|
{{"operation", "list"}}
|
||
|
|
};
|
||
|
|
|
||
|
|
bool list_success = false;
|
||
|
|
for (const auto& params : list_params_list) {
|
||
|
|
try {
|
||
|
|
std::cout << "Trying list directory parameters: " << params.dump() << std::endl;
|
||
|
|
mcp::json list_result = resource.access(params);
|
||
|
|
|
||
|
|
// Check if result contains file list
|
||
|
|
if (list_result.contains("files") || list_result.contains("entries")) {
|
||
|
|
auto files = list_result.contains("files") ? list_result["files"] : list_result["entries"];
|
||
|
|
EXPECT_GE(files.size(), 1) << "Directory should contain at least one file";
|
||
|
|
list_success = true;
|
||
|
|
std::cout << "Successfully listed directory using parameters: " << params.dump() << std::endl;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} catch (const mcp::mcp_exception& e) {
|
||
|
|
// If list directory operation fails, output error message and try next format
|
||
|
|
std::cerr << "List directory failed: " << e.what() << ", parameters: " << params.dump() << std::endl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!list_success) {
|
||
|
|
std::cerr << "All list directory parameter formats failed" << std::endl;
|
||
|
|
// Don't skip test, continue testing other operations
|
||
|
|
}
|
||
|
|
|
||
|
|
// Try different delete file parameter formats
|
||
|
|
if (std::filesystem::exists(new_file_path)) {
|
||
|
|
std::vector<mcp::json> delete_params_list = {
|
||
|
|
// Format 1: Using path
|
||
|
|
{{"operation", "delete"}, {"path", new_file_name}},
|
||
|
|
|
||
|
|
// Format 2: Using filename
|
||
|
|
{{"operation", "delete"}, {"filename", new_file_name}},
|
||
|
|
|
||
|
|
// Format 3: Using file
|
||
|
|
{{"operation", "delete"}, {"file", new_file_name}},
|
||
|
|
|
||
|
|
// Format 4: Using name
|
||
|
|
{{"operation", "delete"}, {"name", new_file_name}},
|
||
|
|
|
||
|
|
// Format 5: Using absolute path
|
||
|
|
{{"operation", "delete"}, {"path", new_file_path.string()}}
|
||
|
|
};
|
||
|
|
|
||
|
|
bool delete_success = false;
|
||
|
|
for (const auto& params : delete_params_list) {
|
||
|
|
try {
|
||
|
|
std::cout << "Trying delete file parameters: " << params.dump() << std::endl;
|
||
|
|
mcp::json delete_result = resource.access(params);
|
||
|
|
|
||
|
|
// Check if file was deleted
|
||
|
|
if (!std::filesystem::exists(new_file_path)) {
|
||
|
|
delete_success = true;
|
||
|
|
std::cout << "Successfully deleted file using parameters: " << params.dump() << std::endl;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
} catch (const mcp::mcp_exception& e) {
|
||
|
|
// If delete operation fails, output error message and try next format
|
||
|
|
std::cerr << "Delete file failed: " << e.what() << ", parameters: " << params.dump() << std::endl;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!delete_success) {
|
||
|
|
std::cerr << "All delete file parameter formats failed" << std::endl;
|
||
|
|
// Don't skip test, continue testing other operations
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test invalid operation
|
||
|
|
mcp::json invalid_params = {
|
||
|
|
{"operation", "invalid_op"},
|
||
|
|
{"path", new_file_name}
|
||
|
|
};
|
||
|
|
|
||
|
|
EXPECT_THROW(resource.access(invalid_params), mcp::mcp_exception);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Mock API handler function
|
||
|
|
mcp::json test_api_handler(const mcp::json& params) {
|
||
|
|
if (params.contains("name")) {
|
||
|
|
return {{"message", "Hello, " + params["name"].get<std::string>() + "!"}};
|
||
|
|
} else {
|
||
|
|
return {{"message", "Hello, World!"}};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test API resource
|
||
|
|
TEST(McpResourceTest, ApiResourceTest) {
|
||
|
|
// Create API resource
|
||
|
|
mcp::api_resource resource("TestAPI", "Test API Resource");
|
||
|
|
|
||
|
|
// Register endpoints
|
||
|
|
resource.register_handler("hello", test_api_handler, "Greeting endpoint");
|
||
|
|
resource.register_handler("echo", [](const mcp::json& params) -> mcp::json {
|
||
|
|
return params;
|
||
|
|
}, "Echo endpoint");
|
||
|
|
|
||
|
|
// Test metadata
|
||
|
|
mcp::json metadata = resource.get_metadata();
|
||
|
|
// Check type - may be "api" or "api_resource" depending on implementation
|
||
|
|
EXPECT_TRUE(metadata["type"] == "api" || metadata["type"] == "api_resource");
|
||
|
|
EXPECT_EQ(metadata["name"], "TestAPI");
|
||
|
|
EXPECT_EQ(metadata["description"], "Test API Resource");
|
||
|
|
EXPECT_TRUE(metadata.contains("endpoints"));
|
||
|
|
EXPECT_EQ(metadata["endpoints"].size(), 2);
|
||
|
|
|
||
|
|
// Test accessing hello endpoint
|
||
|
|
mcp::json hello_params = {
|
||
|
|
{"endpoint", "hello"},
|
||
|
|
{"name", "Test User"}
|
||
|
|
};
|
||
|
|
mcp::json hello_result = resource.access(hello_params);
|
||
|
|
EXPECT_EQ(hello_result["message"], "Hello, Test User!");
|
||
|
|
|
||
|
|
// Test accessing echo endpoint
|
||
|
|
mcp::json echo_params = {
|
||
|
|
{"endpoint", "echo"},
|
||
|
|
{"data", "Test data"},
|
||
|
|
{"number", 42}
|
||
|
|
};
|
||
|
|
mcp::json echo_result = resource.access(echo_params);
|
||
|
|
EXPECT_EQ(echo_result["data"], "Test data");
|
||
|
|
EXPECT_EQ(echo_result["number"], 42);
|
||
|
|
|
||
|
|
// Test accessing non-existent endpoint
|
||
|
|
mcp::json invalid_params = {
|
||
|
|
{"endpoint", "not_exists"}
|
||
|
|
};
|
||
|
|
EXPECT_THROW(resource.access(invalid_params), mcp::mcp_exception);
|
||
|
|
|
||
|
|
// Test missing endpoint parameter
|
||
|
|
mcp::json missing_params = {
|
||
|
|
{"data", "Test data"}
|
||
|
|
};
|
||
|
|
EXPECT_THROW(resource.access(missing_params), mcp::mcp_exception);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Create custom resource class for testing
|
||
|
|
class custom_resource : public mcp::resource {
|
||
|
|
public:
|
||
|
|
custom_resource(const std::string& name, const std::string& description)
|
||
|
|
: name_(name), description_(description) {}
|
||
|
|
|
||
|
|
mcp::json get_metadata() const override {
|
||
|
|
return {
|
||
|
|
{"type", "custom"},
|
||
|
|
{"name", name_},
|
||
|
|
{"description", description_}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
mcp::json access(const mcp::json& params) const override {
|
||
|
|
if (!params.contains("action")) {
|
||
|
|
throw mcp::mcp_exception(mcp::error_code::invalid_params, "Missing action parameter");
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string action = params["action"];
|
||
|
|
|
||
|
|
if (action == "get_info") {
|
||
|
|
return {
|
||
|
|
{"name", name_},
|
||
|
|
{"description", description_},
|
||
|
|
{"timestamp", std::time(nullptr)}
|
||
|
|
};
|
||
|
|
} else if (action == "process") {
|
||
|
|
if (!params.contains("data")) {
|
||
|
|
throw mcp::mcp_exception(mcp::error_code::invalid_params, "Missing data parameter");
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string data = params["data"];
|
||
|
|
return {
|
||
|
|
{"processed", "Processed: " + data},
|
||
|
|
{"status", "success"}
|
||
|
|
};
|
||
|
|
} else {
|
||
|
|
throw mcp::mcp_exception(mcp::error_code::invalid_params, "Invalid action: " + action);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private:
|
||
|
|
std::string name_;
|
||
|
|
std::string description_;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Test custom resource
|
||
|
|
TEST(McpResourceTest, CustomResourceTest) {
|
||
|
|
// Create custom resource
|
||
|
|
custom_resource resource("CustomResource", "Custom resource test");
|
||
|
|
|
||
|
|
// Test metadata
|
||
|
|
mcp::json metadata = resource.get_metadata();
|
||
|
|
EXPECT_EQ(metadata["type"], "custom");
|
||
|
|
EXPECT_EQ(metadata["name"], "CustomResource");
|
||
|
|
EXPECT_EQ(metadata["description"], "Custom resource test");
|
||
|
|
|
||
|
|
// Test get_info operation
|
||
|
|
mcp::json info_params = {
|
||
|
|
{"action", "get_info"}
|
||
|
|
};
|
||
|
|
mcp::json info_result = resource.access(info_params);
|
||
|
|
EXPECT_EQ(info_result["name"], "CustomResource");
|
||
|
|
EXPECT_EQ(info_result["description"], "Custom resource test");
|
||
|
|
EXPECT_TRUE(info_result.contains("timestamp"));
|
||
|
|
|
||
|
|
// Test process operation
|
||
|
|
mcp::json process_params = {
|
||
|
|
{"action", "process"},
|
||
|
|
{"data", "Test data"}
|
||
|
|
};
|
||
|
|
mcp::json process_result = resource.access(process_params);
|
||
|
|
EXPECT_EQ(process_result["processed"], "Processed: Test data");
|
||
|
|
EXPECT_EQ(process_result["status"], "success");
|
||
|
|
|
||
|
|
// Test invalid operation
|
||
|
|
mcp::json invalid_params = {
|
||
|
|
{"action", "invalid_action"}
|
||
|
|
};
|
||
|
|
EXPECT_THROW(resource.access(invalid_params), mcp::mcp_exception);
|
||
|
|
|
||
|
|
// Test missing parameter
|
||
|
|
mcp::json missing_params = {
|
||
|
|
{"action", "process"}
|
||
|
|
};
|
||
|
|
EXPECT_THROW(resource.access(missing_params), mcp::mcp_exception);
|
||
|
|
}
|