mirror of
https://github.com/hanzoai/stack.git
synced 2026-11-19 03:06:57 +00:00
172 lines
6.8 KiB
Python
172 lines
6.8 KiB
Python
"""CI tests for all agent tools to ensure they work properly."""
|
|
|
|
from pathlib import Path
|
|
from unittest.mock import Mock, AsyncMock, patch
|
|
|
|
import pytest
|
|
from hanzo_mcp.tools.agent import register_agent_tools
|
|
from hanzo_mcp.tools.agent.agent_tool import AgentTool
|
|
from hanzo_mcp.tools.agent.swarm_alias import SwarmTool
|
|
from hanzo_mcp.tools.agent.network_tool import NetworkTool
|
|
from hanzo_mcp.tools.common.permissions import PermissionManager
|
|
from hanzo_mcp.tools.agent.claude_cli_tool import ClaudeCLITool
|
|
|
|
|
|
@pytest.fixture
|
|
def permission_manager():
|
|
"""Create a permission manager for testing."""
|
|
pm = PermissionManager()
|
|
pm.allowed_paths = ["/tmp", str(Path.home())]
|
|
return pm
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_mcp_server():
|
|
"""Create a mock MCP server."""
|
|
server = Mock()
|
|
server.tool = Mock(return_value=lambda f: f)
|
|
return server
|
|
|
|
|
|
class TestAgentTools:
|
|
"""Test all agent tools work correctly."""
|
|
|
|
def test_agent_tool_creation(self, permission_manager):
|
|
"""Test AgentTool can be created."""
|
|
tool = AgentTool(
|
|
permission_manager=permission_manager,
|
|
model="claude-3-sonnet",
|
|
max_iterations=10,
|
|
)
|
|
assert tool.name == "agent"
|
|
# Check description contains either delegate or fallback message
|
|
desc_lower = tool.description.lower()
|
|
assert "delegate" in desc_lower or "fallback" in desc_lower
|
|
|
|
def test_network_tool_creation(self, permission_manager):
|
|
"""Test NetworkTool can be created."""
|
|
tool = NetworkTool(permission_manager=permission_manager, default_mode="hybrid")
|
|
assert tool.name == "network"
|
|
assert "distributed" in tool.description.lower()
|
|
|
|
def test_swarm_is_alias_to_network(self, permission_manager):
|
|
"""Test SwarmTool is an alias to NetworkTool."""
|
|
tool = SwarmTool(permission_manager=permission_manager)
|
|
assert tool.name == "swarm"
|
|
assert "alias" in tool.description.lower()
|
|
assert "network" in tool.description.lower()
|
|
# SwarmTool should inherit from NetworkTool
|
|
assert isinstance(tool, NetworkTool)
|
|
|
|
def test_claude_cli_tool_creation(self, permission_manager):
|
|
"""Test ClaudeCLITool can be created."""
|
|
tool = ClaudeCLITool(permission_manager=permission_manager)
|
|
assert tool.name == "claude_cli"
|
|
assert "claude" in tool.description.lower()
|
|
|
|
def test_all_tools_register(self, mock_mcp_server, permission_manager):
|
|
"""Test all agent tools register correctly."""
|
|
tools = register_agent_tools(
|
|
mcp_server=mock_mcp_server,
|
|
permission_manager=permission_manager,
|
|
agent_model="claude-3-sonnet",
|
|
)
|
|
|
|
# Should return list of registered tools
|
|
assert len(tools) >= 4 # At least agent, network, swarm, claude_cli
|
|
|
|
# Check tool names
|
|
tool_names = [t.name for t in tools]
|
|
assert "agent" in tool_names or any("agent" in n for n in tool_names)
|
|
assert "network" in tool_names or any("network" in n for n in tool_names)
|
|
assert "claude_cli" in tool_names or any("claude" in n for n in tool_names)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_agent_tool_basic_call(self, permission_manager):
|
|
"""Test AgentTool can handle basic calls."""
|
|
tool = AgentTool(permission_manager=permission_manager, model="claude-3-sonnet")
|
|
|
|
# We can't properly test call() without a real MCPContext
|
|
# Just verify the tool was created and has expected properties
|
|
assert tool.name == "agent"
|
|
assert tool.permission_manager == permission_manager
|
|
assert tool.max_iterations == 10
|
|
assert tool.max_tool_uses == 30
|
|
assert len(tool.available_tools) > 0 # Should have some tools available
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_network_tool_modes(self, permission_manager):
|
|
"""Test NetworkTool supports different modes."""
|
|
tool = NetworkTool(permission_manager=permission_manager)
|
|
|
|
# Test mode validation happens
|
|
with patch.object(tool, "_ensure_cluster", new_callable=AsyncMock):
|
|
# These modes should be accepted
|
|
for mode in ["local", "distributed", "hybrid"]:
|
|
try:
|
|
# Just test parameter acceptance, not execution
|
|
params = tool._validate_params(task="test", mode=mode)
|
|
assert params is not None or True # Either validates or we're OK
|
|
except AttributeError:
|
|
# Method might not exist, that's OK for this test
|
|
pass
|
|
|
|
def test_pagination_support(self, permission_manager):
|
|
"""Test tools support pagination where applicable."""
|
|
# Agent tools typically don't paginate, but check they handle params
|
|
tool = AgentTool(permission_manager=permission_manager)
|
|
|
|
# Should not error with pagination params
|
|
try:
|
|
# Tools should gracefully handle unexpected params
|
|
tool._prepare_params = Mock()
|
|
tool._prepare_params(page=1, page_size=10)
|
|
except Exception:
|
|
# If method doesn't exist, that's fine
|
|
pass
|
|
|
|
def test_tool_naming_consistency(self, permission_manager):
|
|
"""Ensure tool naming is consistent."""
|
|
# Create all tools
|
|
agent = AgentTool(permission_manager=permission_manager)
|
|
network = NetworkTool(permission_manager=permission_manager)
|
|
swarm = SwarmTool(permission_manager=permission_manager)
|
|
claude = ClaudeCLITool(permission_manager=permission_manager)
|
|
|
|
# Check names match expectations
|
|
assert agent.name == "agent" # Not "dispatch_agent"
|
|
assert network.name == "network"
|
|
assert swarm.name == "swarm"
|
|
assert claude.name == "claude_cli"
|
|
|
|
# Swarm should be network-based
|
|
assert isinstance(swarm, NetworkTool)
|
|
|
|
def test_default_configuration(self):
|
|
"""Test default configuration enables agent tools."""
|
|
import json
|
|
from pathlib import Path
|
|
|
|
config_path = (
|
|
Path(__file__).parent.parent / "hanzo_mcp" / "config" / "default_tools.json"
|
|
)
|
|
if config_path.exists():
|
|
with open(config_path) as f:
|
|
config = json.load(f)
|
|
|
|
# Check agent tools are enabled by default
|
|
assert config["tools"].get("agent", False) == True
|
|
assert config["tools"].get("network", False) == True
|
|
assert config["tools"].get("swarm", False) == True
|
|
assert config["tools"].get("claude_cli", False) == True
|
|
|
|
# dispatch_agent should not exist (replaced by agent)
|
|
assert (
|
|
"dispatch_agent" not in config["tools"]
|
|
or config["tools"]["dispatch_agent"] == False
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
pytest.main([__file__, "-v"])
|