* Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
*/
#include <gtest/gtest.h>
#include <memory>
#include <string>
#include <vector>
#include <stdexcept>
#include <thread>
#include <future>
#include "server/tool_manager.h"
static constexpr int LOOP_NUM = 3;
static constexpr int TOOL_NUM = 2;
namespace Mcp {
static ToolReturn TestToolFunc(const ServerContext& , const std::string& name,
const std::string& arguments)
{
CallToolResult result;
result.isError = false;
TextContent textContent;
textContent.text = R"(Tool )" + name + R"( executed with arguments: )" + arguments;
result.content.push_back(textContent);
return result;
}
static ToolReturn TestCallbackToolFunc(const ServerContext& , const std::string& name,
const std::string& arguments)
{
(void)arguments;
CallToolResult result;
result.isError = false;
TextContent textContent;
textContent.text = R"({"callback": "yes", "tool": ")" + name + "\"}";
result.content.push_back(textContent);
return result;
}
class ToolManagerTest : public ::testing::Test {
public:
~ToolManagerTest() {}
protected:
void SetUp() override
{
toolManager = std::make_unique<ToolManager>(true);
}
void TearDown() override
{
toolManager.reset();
}
ServerTool CreateTestTool(const std::string& name = "test_tool",
const std::string& description = "Test tool description")
{
ServerTool tool;
tool.name = name;
tool.description = description;
tool.inputSchema = R"({"type": "object", "properties": {}})";
tool.func = TestToolFunc;
return tool;
}
ServerTool CreateComplexSchemaTool(const std::string& name = "complex_tool")
{
ServerTool tool;
tool.name = name;
tool.description = "Tool with complex input schema";
tool.inputSchema = R"({
"type": "object",
"properties": {
"param1": {"type": "string"},
"param2": {"type": "number"},
"param3": {"type": "boolean"}
},
"required": ["param1"]
})";
tool.func = TestToolFunc;
return tool;
}
ServerTool CreateErrorThrowingTool(const std::string& name = "error_tool")
{
auto errorFunc = [](const ServerContext& , const std::string& name, const std::string& arguments)
-> ToolReturn {
(void)arguments;
if (name == "error_tool") {
throw std::runtime_error("Simulated tool error");
}
CallToolResult result;
result.isError = false;
TextContent textContent;
textContent.text = "Normal execution";
result.content.push_back(textContent);
return result;
};
ServerTool tool;
tool.name = name;
tool.description = "Tool that throws exceptions";
tool.inputSchema = R"({"type": "object"})";
tool.func = errorFunc;
return tool;
}
std::unique_ptr<ToolManager> toolManager;
};
TEST_F(ToolManagerTest, ConstructorWithOverwriteTrue)
{
ToolManager manager(true);
EXPECT_TRUE(manager.GetOverwrite());
}
TEST_F(ToolManagerTest, ConstructorWithOverwriteFalse)
{
ToolManager manager(false);
EXPECT_FALSE(manager.GetOverwrite());
}
TEST_F(ToolManagerTest, SetOverwrite)
{
EXPECT_TRUE(toolManager->GetOverwrite());
toolManager->SetOverwrite(false);
EXPECT_FALSE(toolManager->GetOverwrite());
toolManager->SetOverwrite(true);
EXPECT_TRUE(toolManager->GetOverwrite());
}
TEST_F(ToolManagerTest, DefaultConstructor)
{
ToolManager manager;
EXPECT_TRUE(manager.GetOverwrite());
}
TEST_F(ToolManagerTest, AddToolSuccess)
{
ServerTool tool = CreateTestTool();
EXPECT_NO_THROW(toolManager->AddTool(tool));
}
TEST_F(ToolManagerTest, AddToolWithComplexSchema)
{
ServerTool tool = CreateComplexSchemaTool();
EXPECT_NO_THROW(toolManager->AddTool(tool));
}
TEST_F(ToolManagerTest, AddToolEmptyName)
{
ServerTool tool = CreateTestTool();
tool.name = "";
EXPECT_NO_THROW(toolManager->AddTool(tool));
}
TEST_F(ToolManagerTest, AddToolEmptyDescription)
{
ServerTool tool = CreateTestTool();
tool.description = "";
EXPECT_NO_THROW(toolManager->AddTool(tool));
}
TEST_F(ToolManagerTest, AddToolNullFunction)
{
ServerTool tool = CreateTestTool();
tool.func = nullptr;
EXPECT_NO_THROW(toolManager->AddTool(tool));
}
TEST_F(ToolManagerTest, AddToolOverwriteWhenOverwriteTrue)
{
ServerTool tool1 = CreateTestTool("same_tool", "First description");
ServerTool tool2 = CreateTestTool("same_tool", "Second description");
tool2.func = TestCallbackToolFunc;
EXPECT_NO_THROW(toolManager->AddTool(tool1));
EXPECT_NO_THROW(toolManager->AddTool(tool2));
}
TEST_F(ToolManagerTest, AddToolNoOverwriteWhenOverwriteFalse)
{
toolManager->SetOverwrite(false);
ServerTool tool1 = CreateTestTool("same_tool", "First description");
ServerTool tool2 = CreateTestTool("same_tool", "Second description");
EXPECT_NO_THROW(toolManager->AddTool(tool1));
EXPECT_THROW(toolManager->AddTool(tool2), std::runtime_error);
}
TEST_F(ToolManagerTest, AddMultipleTools)
{
std::vector<ServerTool> tools;
for (int i = 0; i < LOOP_NUM; i++) {
ServerTool tool = CreateTestTool("tool_" + std::to_string(i), "Tool " + std::to_string(i));
EXPECT_NO_THROW(toolManager->AddTool(tool));
}
}
TEST_F(ToolManagerTest, RemoveToolSuccess)
{
ServerTool tool = CreateTestTool("tool_to_remove");
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->RemoveTool("tool_to_remove"));
}
TEST_F(ToolManagerTest, RemoveToolEmptyName)
{
EXPECT_THROW(toolManager->RemoveTool(""), std::invalid_argument);
}
TEST_F(ToolManagerTest, RemoveNonExistentTool)
{
EXPECT_THROW(toolManager->RemoveTool("non_existent_tool"), std::runtime_error);
}
TEST_F(ToolManagerTest, RemoveToolMultipleTimes)
{
ServerTool tool = CreateTestTool("tool_to_remove");
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->RemoveTool("tool_to_remove"));
EXPECT_THROW(toolManager->RemoveTool("tool_to_remove"), std::runtime_error);
}
TEST_F(ToolManagerTest, ListToolsEmpty)
{
ListToolsResult result = toolManager->ListTools();
EXPECT_EQ(result.tools.size(), 0);
}
TEST_F(ToolManagerTest, ListToolsSingleTool)
{
ServerTool tool = CreateTestTool("tool1", "First tool");
toolManager->AddTool(tool);
ListToolsResult result = toolManager->ListTools();
ASSERT_EQ(result.tools.size(), 1);
EXPECT_EQ(result.tools[0].name, "tool1");
EXPECT_EQ(result.tools[0].description, "First tool");
EXPECT_TRUE(result.tools[0].inputSchema.has_value());
}
TEST_F(ToolManagerTest, ListToolsMultipleTools)
{
const int numTools = LOOP_NUM;
for (int i = 0; i < numTools; i++) {
ServerTool tool = CreateTestTool("tool_" + std::to_string(i), "Tool " + std::to_string(i));
toolManager->AddTool(tool);
}
ListToolsResult result = toolManager->ListTools();
EXPECT_EQ(result.tools.size(), numTools);
std::set<std::string> expectedNames;
for (int i = 0; i < numTools; i++) {
expectedNames.insert("tool_" + std::to_string(i));
}
std::set<std::string> actualNames;
for (const auto& tool : result.tools) {
actualNames.insert(tool.name);
}
EXPECT_EQ(expectedNames, actualNames);
}
TEST_F(ToolManagerTest, ListToolsAfterRemove)
{
for (int i = 0; i < LOOP_NUM; i++) {
ServerTool tool = CreateTestTool("tool_" + std::to_string(i));
toolManager->AddTool(tool);
}
toolManager->RemoveTool("tool_1");
ListToolsResult result = toolManager->ListTools();
EXPECT_EQ(result.tools.size(), TOOL_NUM);
std::set<std::string> expectedNames = {"tool_0", "tool_2"};
std::set<std::string> actualNames;
for (const auto& tool : result.tools) {
actualNames.insert(tool.name);
}
EXPECT_EQ(expectedNames, actualNames);
}
TEST_F(ToolManagerTest, CallToolSuccess)
{
ServerTool tool = CreateTestTool("test_tool");
toolManager->AddTool(tool);
JsonValue arguments = R"({"param": "value"})"_json;
CallToolResult result = toolManager->CallTool("test_tool", arguments.dump());
EXPECT_FALSE(result.isError);
EXPECT_FALSE(result.content.empty());
EXPECT_TRUE(std::holds_alternative<TextContent>(result.content[0]));
auto& textContent = std::get<TextContent>(result.content[0]);
EXPECT_EQ(textContent.type, "text");
EXPECT_FALSE(textContent.text.empty());
}
TEST_F(ToolManagerTest, CallToolWithJsonArguments)
{
ServerTool tool = CreateTestTool("json_tool");
toolManager->AddTool(tool);
std::string arguments = R"({"key1": "value1", "key2": 123, "key3": true})";
CallToolResult result = toolManager->CallTool("json_tool", arguments);
EXPECT_FALSE(result.isError);
EXPECT_FALSE(result.content.empty());
}
TEST_F(ToolManagerTest, CallNonExistentTool)
{
EXPECT_THROW(toolManager->CallTool("non_existent_tool", R"({})"), std::runtime_error);
}
TEST_F(ToolManagerTest, CallToolEmptyName)
{
EXPECT_THROW(toolManager->CallTool("", R"({})"), std::runtime_error);
}
TEST_F(ToolManagerTest, CallToolThrowsException)
{
ServerTool tool = CreateErrorThrowingTool("error_tool");
toolManager->AddTool(tool);
CallToolResult result = toolManager->CallTool("error_tool", R"({})");
EXPECT_TRUE(result.isError);
ASSERT_FALSE(result.content.empty());
ASSERT_TRUE(std::holds_alternative<TextContent>(result.content[0]));
const auto& textContent = std::get<TextContent>(result.content[0]);
EXPECT_EQ(textContent.type, "text");
EXPECT_EQ(textContent.text, "Simulated tool error");
}
TEST_F(ToolManagerTest, CallToolAfterRemove)
{
ServerTool tool = CreateTestTool("temp_tool");
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("temp_tool", R"({})"));
toolManager->RemoveTool("temp_tool");
EXPECT_THROW(toolManager->CallTool("temp_tool", R"({})"), std::runtime_error);
}
TEST_F(ToolManagerTest, CallToolAfterOverwrite)
{
ServerTool tool1 = CreateTestTool("tool", "First tool");
ServerTool tool2 = CreateTestTool("tool", "Second tool");
tool2.func = TestCallbackToolFunc;
toolManager->AddTool(tool1);
toolManager->AddTool(tool2);
CallToolResult result = toolManager->CallTool("tool", R"({})");
EXPECT_FALSE(result.isError);
EXPECT_FALSE(result.content.empty());
}
TEST_F(ToolManagerTest, AddToolWithVeryLongName)
{
std::string longName(1000, 'a');
ServerTool tool = CreateTestTool(longName);
EXPECT_NO_THROW(toolManager->AddTool(tool));
ListToolsResult result = toolManager->ListTools();
ASSERT_EQ(result.tools.size(), 1);
EXPECT_EQ(result.tools[0].name, longName);
EXPECT_NO_THROW(toolManager->CallTool(longName, R"({})"));
}
TEST_F(ToolManagerTest, AddManyTools)
{
const int numTools = 1000;
for (int i = 0; i < numTools; i++) {
ServerTool tool = CreateTestTool("tool_" + std::to_string(i));
EXPECT_NO_THROW(toolManager->AddTool(tool));
}
std::optional<std::string> cursor;
std::size_t total = 0;
do {
ListToolsResult page = toolManager->ListTools(cursor);
total += page.tools.size();
cursor = page.nextCursor;
} while (cursor.has_value());
EXPECT_EQ(total, static_cast<std::size_t>(numTools));
}
TEST_F(ToolManagerTest, RemoveToolExceptionMessages)
{
try {
toolManager->RemoveTool("");
FAIL() << "Expected std::invalid_argument";
} catch (const std::invalid_argument& e) {
EXPECT_STREQ(e.what(), "Tool name cannot be empty");
}
try {
toolManager->RemoveTool("non_existent");
FAIL() << "Expected std::runtime_error";
} catch (const std::runtime_error& e) {
EXPECT_STREQ(e.what(), "Tool 'non_existent' not found");
}
}
TEST_F(ToolManagerTest, CallToolExceptionMessages)
{
try {
toolManager->CallTool("non_existent", R"({})");
FAIL() << "Expected std::runtime_error";
} catch (const std::runtime_error& e) {
EXPECT_STREQ(e.what(), "Tool not found: non_existent");
}
ServerTool tool = CreateErrorThrowingTool("error_tool");
toolManager->AddTool(tool);
CallToolResult result = toolManager->CallTool("error_tool", R"({})");
EXPECT_TRUE(result.isError);
ASSERT_FALSE(result.content.empty());
ASSERT_TRUE(std::holds_alternative<TextContent>(result.content[0]));
EXPECT_EQ(std::get<TextContent>(result.content[0]).text, "Simulated tool error");
}
static ToolReturn StructuredOutputToolFunc(const ServerContext& , const std::string& name,
const std::string& arguments)
{
(void)name;
JsonValue argumentsJson = JsonValue::parse(arguments);
if (argumentsJson.contains("returnData")) {
return argumentsJson["returnData"].dump();
}
return R"({"status": "success", "code": 200})";
}
static ToolReturn ErrorResultToolFunc(const ServerContext& , const std::string& name,
const std::string& arguments)
{
(void)name;
(void)arguments;
CallToolResult result;
result.isError = true;
result.structuredContent = R"({"invalid": "data"})";
return result;
}
TEST_F(ToolManagerTest, OutputSchemaValidation_Pass)
{
ServerTool tool;
tool.name = "test";
tool.outputSchema = R"({"type": "object", "properties": {"status": {"type": "string"},
"code": {"type": "number"}}, "required": ["status", "code"]})";
tool.func = StructuredOutputToolFunc;
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({})"));
}
TEST_F(ToolManagerTest, OutputSchemaValidation_Fail)
{
ServerTool tool;
tool.name = "test";
tool.outputSchema = R"({"type": "object", "properties": {"required_field": {"type": "string"}},
"required": ["required_field"]})";
tool.func = StructuredOutputToolFunc;
toolManager->AddTool(tool);
EXPECT_THROW(toolManager->CallTool("test", R"({})"), std::runtime_error);
}
TEST_F(ToolManagerTest, OutputSchemaValidation_NotObject)
{
auto arrayFunc = [](const ServerContext&, const std::string&, const std::string&) -> ToolReturn {
return R"([1, 2, 3])";
};
ServerTool tool;
tool.name = "test";
tool.outputSchema = R"({"type": "object"})";
tool.func = arrayFunc;
toolManager->AddTool(tool);
EXPECT_THROW(toolManager->CallTool("test", R"({})"), std::runtime_error);
}
TEST_F(ToolManagerTest, OutputSchemaValidation_NoStructuredContent)
{
auto noStructuredFunc = [](const ServerContext&, const std::string&, const std::string&) -> ToolReturn {
CallToolResult result;
TextContent text;
text.text = "no structured";
result.content.push_back(text);
return result;
};
ServerTool tool;
tool.name = "test";
tool.outputSchema = R"({"type": "object"})";
tool.func = noStructuredFunc;
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({})"));
}
TEST_F(ToolManagerTest, OutputSchemaValidation_ErrorSkipValidation)
{
ServerTool tool;
tool.name = "test";
tool.outputSchema = R"({"type": "object",
"properties": {"required": {"type": "string"}}, "required": ["required"]})";
tool.func = ErrorResultToolFunc;
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({})"));
}
static ServerTool MakeInputSchemaTool(const std::string& name, const std::string& schema)
{
ServerTool tool;
tool.name = name;
tool.inputSchema = schema;
tool.func = TestToolFunc;
return tool;
}
TEST_F(ToolManagerTest, InputSchemaValidation_Pass)
{
auto tool = MakeInputSchemaTool("test", R"({
"type": "object",
"properties": {"name": {"type": "string"}, "count": {"type": "integer"}},
"required": ["name"]
})");
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({"name":"a","count":1})"));
}
TEST_F(ToolManagerTest, InputSchemaValidation_MissingRequired)
{
auto tool = MakeInputSchemaTool("test", R"({
"type": "object",
"properties": {"name": {"type": "string"}},
"required": ["name"]
})");
toolManager->AddTool(tool);
try {
(void)toolManager->CallTool("test", R"({})");
FAIL() << "Expected ToolInputValidationError";
} catch (const ToolInputValidationError& e) {
EXPECT_NE(std::string(e.what()).find("Input validation failed"), std::string::npos);
EXPECT_NE(std::string(e.what()).find("name"), std::string::npos);
const JsonValue& data = e.Data();
EXPECT_EQ(data.value("tool", std::string()), "test");
ASSERT_TRUE(data.contains("error"));
ASSERT_TRUE(data["error"].is_object());
const std::string errorMessage = data["error"].value("message", std::string());
EXPECT_NE(errorMessage.find("name"), std::string::npos);
}
}
TEST_F(ToolManagerTest, InputSchemaValidation_TypeMismatch)
{
auto tool = MakeInputSchemaTool("test", R"({
"type": "object",
"properties": {"name": {"type": "string"}}
})");
toolManager->AddTool(tool);
try {
(void)toolManager->CallTool("test", R"({"name":123})");
FAIL() << "Expected ToolInputValidationError";
} catch (const ToolInputValidationError& e) {
const JsonValue& data = e.Data();
ASSERT_TRUE(data.contains("error"));
EXPECT_EQ(data["error"].value("instancePath", std::string()), "/name");
}
}
TEST_F(ToolManagerTest, InputSchemaValidation_RejectAdditionalProperty)
{
auto tool = MakeInputSchemaTool("test", R"({
"type": "object",
"properties": {"name": {"type": "string"}},
"additionalProperties": false
})");
toolManager->AddTool(tool);
EXPECT_THROW(toolManager->CallTool("test", R"({"name":"a","extra":1})"), ToolInputValidationError);
}
TEST_F(ToolManagerTest, InputSchemaValidation_AllowAdditionalPropertyByDefault)
{
auto tool = MakeInputSchemaTool("test", R"({
"type": "object",
"properties": {"name": {"type": "string"}}
})");
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({"name":"a","extra":1})"));
}
TEST_F(ToolManagerTest, InputSchemaValidation_NullArguments)
{
auto tool = MakeInputSchemaTool("test", R"({
"type": "object",
"properties": {"name": {"type": "string"}},
"required": ["name"]
})");
toolManager->AddTool(tool);
EXPECT_THROW(toolManager->CallTool("test", "null"), ToolInputValidationError);
}
static ToolFunc MakeTrackingToolFunc(bool& handlerCalled)
{
return [&handlerCalled](const ServerContext&, const std::string&, const std::string&) -> ToolReturn {
handlerCalled = true;
return CallToolResult{};
};
}
TEST_F(ToolManagerTest, InputSchemaValidation_AnyOfProbeDoesNotRejectValidInput)
{
bool handlerCalled = false;
ServerTool tool;
tool.name = "test";
tool.inputSchema = R"({
"type": "object",
"anyOf": [
{"required": ["a"]},
{"required": ["b"]}
]
})";
tool.func = MakeTrackingToolFunc(handlerCalled);
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({"b":1})"));
EXPECT_TRUE(handlerCalled);
}
TEST_F(ToolManagerTest, InputSchemaValidation_OneOfProbeDoesNotRejectValidInput)
{
bool handlerCalled = false;
ServerTool tool;
tool.name = "test";
tool.inputSchema = R"({
"type": "object",
"oneOf": [
{"required": ["a"]},
{"required": ["b"]}
]
})";
tool.func = MakeTrackingToolFunc(handlerCalled);
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({"b":1})"));
EXPECT_TRUE(handlerCalled);
}
TEST_F(ToolManagerTest, InputSchemaValidation_NotProbeDoesNotRejectValidInput)
{
bool handlerCalled = false;
ServerTool tool;
tool.name = "test";
tool.inputSchema = R"({
"type": "object",
"not": {"required": ["a"]}
})";
tool.func = MakeTrackingToolFunc(handlerCalled);
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({"b":1})"));
EXPECT_TRUE(handlerCalled);
}
TEST_F(ToolManagerTest, InputSchemaValidation_IfThenElseProbeDoesNotRejectValidInput)
{
bool handlerCalled = false;
ServerTool tool;
tool.name = "test";
tool.inputSchema = R"({
"type": "object",
"if": {"required": ["a"]},
"then": {"required": ["b"]},
"else": {"required": ["c"]}
})";
tool.func = MakeTrackingToolFunc(handlerCalled);
toolManager->AddTool(tool);
EXPECT_NO_THROW(toolManager->CallTool("test", R"({"c":1})"));
EXPECT_TRUE(handlerCalled);
}
}