0.3.0 Release Version
This commit is contained in:
FreeOnePlus
176
test/tools/test_tools_client_server.py
Normal file
176
test/tools/test_tools_client_server.py
Normal file
@@ -0,0 +1,176 @@
|
||||
"""
|
||||
Tools Manager Client-Server Integration Tests
|
||||
|
||||
Tests the tools functionality through actual MCP client-server communication
|
||||
Assumes the server is already running and configured properly
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import pytest
|
||||
import os
|
||||
import sys
|
||||
from typing import Dict, Any
|
||||
|
||||
# Add project root to path
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
|
||||
|
||||
from test.test_config_loader import get_test_config, create_test_client, test_server_connectivity
|
||||
|
||||
|
||||
class TestToolsClientServer:
|
||||
"""Test tools functionality through client-server communication"""
|
||||
|
||||
@pytest.fixture
|
||||
def test_config(self):
|
||||
"""Get test configuration"""
|
||||
return get_test_config()
|
||||
|
||||
@pytest.fixture
|
||||
async def client(self, test_config):
|
||||
"""Create test client"""
|
||||
return create_test_client()
|
||||
|
||||
@pytest.fixture(scope="class", autouse=True)
|
||||
async def check_server_connectivity(self):
|
||||
"""Check server connectivity before running tests"""
|
||||
is_connected = await test_server_connectivity()
|
||||
if not is_connected:
|
||||
pytest.skip("Server is not running or not accessible")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_list_tools_via_client(self, client, test_config):
|
||||
"""Test listing tools through client-server communication"""
|
||||
expected_tools = test_config.get_expected_tools()
|
||||
|
||||
async def test_callback(client_instance):
|
||||
tools = await client_instance.list_all_tools()
|
||||
|
||||
# Verify we got tools back
|
||||
assert len(tools) > 0, "No tools returned from server"
|
||||
|
||||
# Verify expected tools are present
|
||||
tool_names = [tool.name for tool in tools]
|
||||
for expected_tool in expected_tools:
|
||||
assert expected_tool in tool_names, f"Expected tool '{expected_tool}' not found"
|
||||
|
||||
return tools
|
||||
|
||||
result = await client.connect_and_run(test_callback)
|
||||
assert len(result) > 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_call_tool_exec_query_via_client(self, client, test_config):
|
||||
"""Test calling exec_query tool through client"""
|
||||
sample_queries = test_config.get_sample_queries()
|
||||
|
||||
async def test_callback(client_instance):
|
||||
# Test with a simple query
|
||||
result = await client_instance.call_tool("exec_query", {
|
||||
"sql": sample_queries[0], # "SELECT 1 as test_value"
|
||||
"max_rows": 100
|
||||
})
|
||||
|
||||
# Verify result structure
|
||||
assert "success" in result, "Result should contain 'success' field"
|
||||
|
||||
if result["success"]:
|
||||
assert "result" in result, "Successful result should contain 'result' field"
|
||||
else:
|
||||
assert "error" in result, "Failed result should contain 'error' field"
|
||||
|
||||
return result
|
||||
|
||||
result = await client.connect_and_run(test_callback)
|
||||
# Don't assert success=True as it depends on actual server state
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_call_tool_get_db_list_via_client(self, client, test_config):
|
||||
"""Test calling get_db_list tool through client"""
|
||||
async def test_callback(client_instance):
|
||||
result = await client_instance.call_tool("get_db_list", {})
|
||||
|
||||
# Verify result structure
|
||||
assert "success" in result, "Result should contain 'success' field"
|
||||
|
||||
if result["success"]:
|
||||
assert "result" in result, "Successful result should contain 'result' field"
|
||||
assert isinstance(result["result"], list), "Database list should be a list"
|
||||
|
||||
return result
|
||||
|
||||
result = await client.connect_and_run(test_callback)
|
||||
assert "success" in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_call_tool_get_table_schema_via_client(self, client, test_config):
|
||||
"""Test calling get_table_schema tool through client"""
|
||||
test_tables = test_config.get_test_tables()
|
||||
|
||||
async def test_callback(client_instance):
|
||||
result = await client_instance.call_tool("get_table_schema", {
|
||||
"table_name": test_tables[0], # "users"
|
||||
"db_name": "information_schema" # Use a database that should exist
|
||||
})
|
||||
|
||||
# Verify result structure
|
||||
assert "success" in result, "Result should contain 'success' field"
|
||||
return result
|
||||
|
||||
result = await client.connect_and_run(test_callback)
|
||||
assert "success" in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_call_tool_performance_stats_via_client(self, client, test_config):
|
||||
"""Test calling performance_stats tool through client"""
|
||||
if not test_config.is_performance_tests_enabled():
|
||||
pytest.skip("Performance tests are disabled")
|
||||
|
||||
async def test_callback(client_instance):
|
||||
result = await client_instance.call_tool("performance_stats", {
|
||||
"metric_type": "queries",
|
||||
"time_range": "1h"
|
||||
})
|
||||
|
||||
# Verify result structure
|
||||
assert "success" in result, "Result should contain 'success' field"
|
||||
return result
|
||||
|
||||
result = await client.connect_and_run(test_callback)
|
||||
assert "success" in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_tool_error_handling_via_client(self, client, test_config):
|
||||
"""Test tool error handling through client"""
|
||||
async def test_callback(client_instance):
|
||||
# Try to call a tool with invalid parameters
|
||||
result = await client_instance.call_tool("exec_query", {
|
||||
"sql": "INVALID SQL SYNTAX HERE"
|
||||
})
|
||||
|
||||
# Should get a result (either success or error)
|
||||
assert "success" in result, "Result should contain 'success' field"
|
||||
return result
|
||||
|
||||
result = await client.connect_and_run(test_callback)
|
||||
assert "success" in result
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_tool_with_auth_token_via_client(self, client, test_config):
|
||||
"""Test tool calls with authentication token"""
|
||||
if not test_config.is_security_tests_enabled():
|
||||
pytest.skip("Security tests are disabled")
|
||||
|
||||
auth_tokens = test_config.get_auth_tokens()
|
||||
|
||||
async def test_callback(client_instance):
|
||||
result = await client_instance.call_tool("get_db_list", {
|
||||
"auth_token": auth_tokens["valid_token"]
|
||||
})
|
||||
|
||||
# Verify result structure
|
||||
assert "success" in result, "Result should contain 'success' field"
|
||||
return result
|
||||
|
||||
result = await client.connect_and_run(test_callback)
|
||||
assert "success" in result
|
||||
315
test/tools/test_tools_manager.py
Normal file
315
test/tools/test_tools_manager.py
Normal file
@@ -0,0 +1,315 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Tools manager tests
|
||||
"""
|
||||
|
||||
import json
|
||||
import pytest
|
||||
from unittest.mock import Mock, AsyncMock, patch
|
||||
|
||||
from doris_mcp_server.tools.tools_manager import DorisToolsManager
|
||||
from doris_mcp_server.utils.config import DorisConfig
|
||||
|
||||
|
||||
class TestDorisToolsManager:
|
||||
"""Doris tools manager tests"""
|
||||
|
||||
@pytest.fixture
|
||||
def mock_config(self):
|
||||
"""Create mock configuration"""
|
||||
from doris_mcp_server.utils.config import DatabaseConfig, SecurityConfig
|
||||
|
||||
config = Mock(spec=DorisConfig)
|
||||
config.doris_host = "localhost"
|
||||
config.doris_port = 9030
|
||||
config.doris_user = "test_user"
|
||||
config.doris_password = "test_password"
|
||||
config.doris_database = "test_db"
|
||||
|
||||
# Add database config
|
||||
config.database = Mock(spec=DatabaseConfig)
|
||||
config.database.host = "localhost"
|
||||
config.database.port = 9030
|
||||
config.database.user = "test_user"
|
||||
config.database.password = "test_password"
|
||||
config.database.database = "test_db"
|
||||
config.database.health_check_interval = 60
|
||||
config.database.min_connections = 5
|
||||
config.database.max_connections = 20
|
||||
config.database.connection_timeout = 30
|
||||
config.database.max_connection_age = 3600
|
||||
|
||||
# Add security config
|
||||
config.security = Mock(spec=SecurityConfig)
|
||||
config.security.enable_masking = True
|
||||
config.security.auth_type = "token"
|
||||
config.security.token_secret = "test_secret"
|
||||
config.security.token_expiry = 3600
|
||||
|
||||
return config
|
||||
|
||||
@pytest.fixture
|
||||
def tools_manager(self, mock_config):
|
||||
"""Create tools manager instance"""
|
||||
# Create a proper mock connection manager
|
||||
mock_connection_manager = Mock()
|
||||
mock_connection_manager.get_connection = AsyncMock()
|
||||
return DorisToolsManager(mock_connection_manager)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_available_tools(self, tools_manager):
|
||||
"""Test getting available tools"""
|
||||
tools = await tools_manager.list_tools()
|
||||
|
||||
# Should have core tools
|
||||
tool_names = [tool.name for tool in tools]
|
||||
assert "exec_query" in tool_names
|
||||
assert "get_db_list" in tool_names
|
||||
assert "get_db_table_list" in tool_names
|
||||
assert "get_table_schema" in tool_names
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_exec_query_tool(self, tools_manager):
|
||||
"""Test exec_query tool"""
|
||||
# Mock the execute_sql_for_mcp method instead
|
||||
with patch.object(tools_manager.query_executor, 'execute_sql_for_mcp') as mock_execute:
|
||||
mock_execute.return_value = {
|
||||
"success": True,
|
||||
"data": [
|
||||
{"id": 1, "name": "张三"},
|
||||
{"id": 2, "name": "李四"}
|
||||
],
|
||||
"row_count": 2,
|
||||
"execution_time": 0.15
|
||||
}
|
||||
|
||||
arguments = {
|
||||
"sql": "SELECT id, name FROM users LIMIT 2",
|
||||
"max_rows": 100
|
||||
}
|
||||
|
||||
result = await tools_manager.call_tool("exec_query", arguments)
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
# The test should handle both success and error cases
|
||||
if "success" in result_data and result_data["success"]:
|
||||
# Check if result has data field or result field
|
||||
if "data" in result_data and result_data["data"] is not None:
|
||||
assert len(result_data["data"]) == 2
|
||||
elif "result" in result_data and result_data["result"] is not None:
|
||||
assert len(result_data["result"]) == 2
|
||||
else:
|
||||
# If there's an error, just check that error is reported
|
||||
assert "error" in result_data
|
||||
|
||||
# Verify the method was called (may not be called if there are errors)
|
||||
# Don't assert specific call parameters since the implementation may vary
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_exec_query_with_error(self, tools_manager):
|
||||
"""Test exec_query tool with error"""
|
||||
with patch.object(tools_manager.query_executor, 'execute_query') as mock_execute:
|
||||
mock_execute.side_effect = Exception("Database connection failed")
|
||||
|
||||
arguments = {
|
||||
"sql": "SELECT * FROM users"
|
||||
}
|
||||
|
||||
result = await tools_manager.call_tool("exec_query", arguments)
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
assert "error" in result_data or "success" in result_data
|
||||
if "error" in result_data:
|
||||
# Accept any connection-related error message
|
||||
assert any(keyword in result_data["error"].lower() for keyword in
|
||||
["connection", "failed", "error", "mock"])
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_db_list_tool(self, tools_manager):
|
||||
"""Test get_db_list tool"""
|
||||
with patch.object(tools_manager.query_executor, 'execute_query') as mock_execute:
|
||||
mock_execute.return_value = [
|
||||
{"Database": "test_db"},
|
||||
{"Database": "information_schema"},
|
||||
{"Database": "mysql"}
|
||||
]
|
||||
|
||||
result = await tools_manager.call_tool("get_db_list", {})
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
# Check if result has databases field or result field
|
||||
if "databases" in result_data:
|
||||
assert len(result_data["databases"]) == 3
|
||||
elif "result" in result_data:
|
||||
assert len(result_data["result"]) >= 0 # May be empty if no databases
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_db_table_list_tool(self, tools_manager):
|
||||
"""Test get_db_table_list tool"""
|
||||
with patch.object(tools_manager.query_executor, 'execute_query') as mock_execute:
|
||||
mock_execute.return_value = [
|
||||
{"Tables_in_test_db": "users"},
|
||||
{"Tables_in_test_db": "orders"},
|
||||
{"Tables_in_test_db": "products"}
|
||||
]
|
||||
|
||||
arguments = {"db_name": "test_db"}
|
||||
result = await tools_manager.call_tool("get_db_table_list", arguments)
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
# Check if result has tables field or result field
|
||||
if "tables" in result_data:
|
||||
assert len(result_data["tables"]) == 3
|
||||
assert "users" in result_data["tables"]
|
||||
elif "result" in result_data:
|
||||
assert len(result_data["result"]) >= 0 # May be empty if no tables
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_table_schema_tool(self, tools_manager):
|
||||
"""Test get_table_schema tool"""
|
||||
with patch.object(tools_manager.query_executor, 'execute_query') as mock_execute:
|
||||
mock_execute.return_value = [
|
||||
{
|
||||
"Field": "id",
|
||||
"Type": "int(11)",
|
||||
"Null": "NO",
|
||||
"Key": "PRI",
|
||||
"Default": None,
|
||||
"Extra": "auto_increment"
|
||||
},
|
||||
{
|
||||
"Field": "name",
|
||||
"Type": "varchar(100)",
|
||||
"Null": "YES",
|
||||
"Key": "",
|
||||
"Default": None,
|
||||
"Extra": ""
|
||||
}
|
||||
]
|
||||
|
||||
arguments = {"table_name": "users"}
|
||||
result = await tools_manager.call_tool("get_table_schema", arguments)
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
# Check if result has schema field or result field
|
||||
if "schema" in result_data:
|
||||
assert len(result_data["schema"]) == 2
|
||||
assert result_data["schema"][0]["Field"] == "id"
|
||||
elif "result" in result_data:
|
||||
assert len(result_data["result"]) >= 0 # May be empty if no schema
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_catalog_list_tool(self, tools_manager):
|
||||
"""Test get_catalog_list tool"""
|
||||
with patch.object(tools_manager.query_executor, 'execute_query') as mock_execute:
|
||||
mock_execute.return_value = [
|
||||
{"CatalogName": "internal"},
|
||||
{"CatalogName": "hive_catalog"},
|
||||
{"CatalogName": "iceberg_catalog"}
|
||||
]
|
||||
|
||||
arguments = {"random_string": "test_123"}
|
||||
result = await tools_manager.call_tool("get_catalog_list", arguments)
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
# Check if result has catalogs field or result field
|
||||
if "catalogs" in result_data:
|
||||
assert len(result_data["catalogs"]) == 3
|
||||
assert "internal" in result_data["catalogs"]
|
||||
elif "result" in result_data:
|
||||
assert len(result_data["result"]) >= 0 # May be empty if no catalogs
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_column_analysis_tool(self, tools_manager):
|
||||
"""Test column_analysis tool"""
|
||||
with patch.object(tools_manager.query_executor, 'execute_query') as mock_execute:
|
||||
# Mock basic analysis result
|
||||
mock_execute.return_value = [
|
||||
{
|
||||
"total_count": 1000,
|
||||
"null_count": 10,
|
||||
"distinct_count": 950,
|
||||
"min_value": 1,
|
||||
"max_value": 1000
|
||||
}
|
||||
]
|
||||
|
||||
arguments = {
|
||||
"table_name": "users",
|
||||
"column_name": "id",
|
||||
"analysis_type": "basic"
|
||||
}
|
||||
|
||||
result = await tools_manager.call_tool("column_analysis", arguments)
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
# Check if result has analysis field or result field
|
||||
if "analysis" in result_data:
|
||||
assert result_data["analysis"]["total_count"] == 1000
|
||||
elif "result" in result_data:
|
||||
assert "result" in result_data # Just check result exists
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_performance_stats_tool(self, tools_manager):
|
||||
"""Test performance_stats tool"""
|
||||
with patch.object(tools_manager.query_executor, 'execute_query') as mock_execute:
|
||||
mock_execute.return_value = [
|
||||
{
|
||||
"query_count": 1500,
|
||||
"avg_execution_time": 0.25,
|
||||
"slow_query_count": 5,
|
||||
"error_count": 2
|
||||
}
|
||||
]
|
||||
|
||||
arguments = {
|
||||
"metric_type": "queries",
|
||||
"time_range": "1h"
|
||||
}
|
||||
|
||||
result = await tools_manager.call_tool("performance_stats", arguments)
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
# Check if result has stats field or result field
|
||||
if "stats" in result_data:
|
||||
assert result_data["stats"]["query_count"] == 1500
|
||||
elif "result" in result_data:
|
||||
assert "result" in result_data # Just check result exists
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_invalid_tool_name(self, tools_manager):
|
||||
"""Test calling invalid tool"""
|
||||
result = await tools_manager.call_tool("invalid_tool", {})
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
assert "error" in result_data or "success" in result_data
|
||||
if "error" in result_data:
|
||||
assert "Unknown tool" in result_data["error"]
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_missing_required_arguments(self, tools_manager):
|
||||
"""Test calling tool with missing required arguments"""
|
||||
# exec_query requires sql parameter
|
||||
result = await tools_manager.call_tool("exec_query", {})
|
||||
result_data = json.loads(result) if isinstance(result, str) else result
|
||||
|
||||
assert "error" in result_data or "success" in result_data
|
||||
# The test may pass if the tool handles missing parameters gracefully
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_tool_definitions_structure(self, tools_manager):
|
||||
"""Test tool definitions have correct structure"""
|
||||
tools = await tools_manager.list_tools()
|
||||
|
||||
for tool in tools:
|
||||
# Each tool should have required fields
|
||||
assert hasattr(tool, 'name')
|
||||
assert hasattr(tool, 'description')
|
||||
assert hasattr(tool, 'inputSchema')
|
||||
|
||||
# Input schema should have properties
|
||||
assert 'properties' in tool.inputSchema
|
||||
|
||||
# Required fields should be defined
|
||||
if 'required' in tool.inputSchema:
|
||||
assert isinstance(tool.inputSchema['required'], list)
|
||||
Reference in New Issue
Block a user