Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
Mirrored from https://github.com/Camo67/composio.git
Synced Nov 21, 04:45 UTC
| 1 | """ |
| 2 | Tests for Claude Code Agents Provider |
| 3 | """ |
| 4 | |
| 5 | import asyncio |
| 6 | import json |
| 7 | from unittest.mock import MagicMock, patch |
| 8 | |
| 9 | import pytest |
| 10 | from composio_claude_agent_sdk.provider import ClaudeAgentSDKProvider |
| 11 | |
| 12 | |
| 13 | @pytest.fixture |
| 14 | def provider(): |
| 15 | """Create a ClaudeAgentSDKProvider instance.""" |
| 16 | return ClaudeAgentSDKProvider() |
| 17 | |
| 18 | |
| 19 | @pytest.fixture |
| 20 | def custom_provider(): |
| 21 | """Create a ClaudeAgentSDKProvider with custom options.""" |
| 22 | return ClaudeAgentSDKProvider( |
| 23 | server_name="custom-server", |
| 24 | server_version="2.0.0", |
| 25 | ) |
| 26 | |
| 27 | |
| 28 | @pytest.fixture |
| 29 | def mock_tool(): |
| 30 | """Create a mock Composio tool.""" |
| 31 | return MagicMock( |
| 32 | slug="GMAIL_SEND_EMAIL", |
| 33 | name="Gmail Send Email", |
| 34 | description="Send an email via Gmail", |
| 35 | input_parameters={ |
| 36 | "type": "object", |
| 37 | "properties": { |
| 38 | "to": { |
| 39 | "type": "string", |
| 40 | "description": "Recipient email address", |
| 41 | }, |
| 42 | "subject": { |
| 43 | "type": "string", |
| 44 | "description": "Email subject", |
| 45 | }, |
| 46 | "body": { |
| 47 | "type": "string", |
| 48 | "description": "Email body content", |
| 49 | }, |
| 50 | }, |
| 51 | "required": ["to", "subject", "body"], |
| 52 | }, |
| 53 | ) |
| 54 | |
| 55 | |
| 56 | @pytest.fixture |
| 57 | def mock_execute_tool(): |
| 58 | """Create a mock execute_tool function.""" |
| 59 | return MagicMock( |
| 60 | return_value={ |
| 61 | "data": {"result": "success"}, |
| 62 | "error": None, |
| 63 | "successful": True, |
| 64 | } |
| 65 | ) |
| 66 | |
| 67 | |
| 68 | class TestClaudeAgentSDKProviderInit: |
| 69 | """Tests for provider initialization.""" |
| 70 | |
| 71 | def test_default_options(self, provider): |
| 72 | """Test provider initializes with default options.""" |
| 73 | assert provider.server_name == "composio" |
| 74 | assert provider.server_version == "1.0.0" |
| 75 | |
| 76 | def test_custom_options(self, custom_provider): |
| 77 | """Test provider initializes with custom options.""" |
| 78 | assert custom_provider.server_name == "custom-server" |
| 79 | assert custom_provider.server_version == "2.0.0" |
| 80 | |
| 81 | def test_name_property(self, provider): |
| 82 | """Test provider has correct name.""" |
| 83 | assert provider.name == "claude_agent_sdk" |
| 84 | |
| 85 | |
| 86 | class TestJsonSchemaConversion: |
| 87 | """Tests for JSON Schema conversion.""" |
| 88 | |
| 89 | def test_simple_schema_passthrough(self, provider): |
| 90 | """Test that JSON Schema is passed through unchanged.""" |
| 91 | schema = { |
| 92 | "type": "object", |
| 93 | "properties": { |
| 94 | "name": {"type": "string"}, |
| 95 | "count": {"type": "integer"}, |
| 96 | }, |
| 97 | } |
| 98 | result = provider._json_schema_to_simple_schema(schema) |
| 99 | assert result == schema |
| 100 | |
| 101 | def test_empty_schema(self, provider): |
| 102 | """Test handling of empty schema.""" |
| 103 | result = provider._json_schema_to_simple_schema({}) |
| 104 | assert result == {} |
| 105 | |
| 106 | |
| 107 | class TestWrapTool: |
| 108 | """Tests for wrap_tool method.""" |
| 109 | |
| 110 | def test_wrap_tool_returns_sdk_mcp_tool( |
| 111 | self, provider, mock_tool, mock_execute_tool |
| 112 | ): |
| 113 | """Test that wrap_tool returns an SdkMcpTool.""" |
| 114 | with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool: |
| 115 | mock_sdk_tool.return_value = lambda fn: fn |
| 116 | provider.wrap_tool(mock_tool, mock_execute_tool) |
| 117 | |
| 118 | # Verify sdk_tool was called with correct arguments |
| 119 | mock_sdk_tool.assert_called_once_with( |
| 120 | mock_tool.slug, |
| 121 | mock_tool.description, |
| 122 | mock_tool.input_parameters, |
| 123 | ) |
| 124 | |
| 125 | def test_wrap_tool_without_description(self, provider, mock_execute_tool): |
| 126 | """Test wrapping a tool without description.""" |
| 127 | tool_without_desc = MagicMock( |
| 128 | slug="TEST_TOOL", |
| 129 | description=None, |
| 130 | input_parameters={"type": "object", "properties": {}}, |
| 131 | ) |
| 132 | |
| 133 | with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool: |
| 134 | mock_sdk_tool.return_value = lambda fn: fn |
| 135 | provider.wrap_tool(tool_without_desc, mock_execute_tool) |
| 136 | |
| 137 | # Should use default description |
| 138 | mock_sdk_tool.assert_called_once() |
| 139 | call_args = mock_sdk_tool.call_args[0] |
| 140 | assert call_args[1] == "Execute TEST_TOOL" |
| 141 | |
| 142 | def test_wrap_tool_without_input_parameters(self, provider, mock_execute_tool): |
| 143 | """Test wrapping a tool without input parameters.""" |
| 144 | tool_without_params = MagicMock( |
| 145 | slug="TEST_TOOL", |
| 146 | description="Test tool", |
| 147 | input_parameters=None, |
| 148 | ) |
| 149 | |
| 150 | with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool: |
| 151 | mock_sdk_tool.return_value = lambda fn: fn |
| 152 | provider.wrap_tool(tool_without_params, mock_execute_tool) |
| 153 | |
| 154 | # Should use empty schema |
| 155 | mock_sdk_tool.assert_called_once() |
| 156 | call_args = mock_sdk_tool.call_args[0] |
| 157 | assert call_args[2] == {} |
| 158 | |
| 159 | |
| 160 | class TestWrapTools: |
| 161 | """Tests for wrap_tools method.""" |
| 162 | |
| 163 | def test_wrap_multiple_tools(self, provider, mock_tool, mock_execute_tool): |
| 164 | """Test wrapping multiple tools.""" |
| 165 | another_tool = MagicMock( |
| 166 | slug="SLACK_POST_MESSAGE", |
| 167 | description="Post a message to Slack", |
| 168 | input_parameters={"type": "object", "properties": {}}, |
| 169 | ) |
| 170 | tools = [mock_tool, another_tool] |
| 171 | |
| 172 | with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool: |
| 173 | mock_sdk_tool.return_value = lambda fn: fn |
| 174 | wrapped = provider.wrap_tools(tools, mock_execute_tool) |
| 175 | |
| 176 | assert len(wrapped) == 2 |
| 177 | assert mock_sdk_tool.call_count == 2 |
| 178 | |
| 179 | def test_wrap_empty_tools_list(self, provider, mock_execute_tool): |
| 180 | """Test wrapping an empty tools list.""" |
| 181 | wrapped = provider.wrap_tools([], mock_execute_tool) |
| 182 | assert wrapped == [] |
| 183 | |
| 184 | |
| 185 | class TestCreateMcpServer: |
| 186 | """Tests for create_mcp_server method.""" |
| 187 | |
| 188 | def test_create_mcp_server_with_default_options(self, provider): |
| 189 | """Test creating MCP server with default options.""" |
| 190 | mock_tools = [MagicMock(), MagicMock()] |
| 191 | |
| 192 | with patch( |
| 193 | "composio_claude_agent_sdk.provider.create_sdk_mcp_server" |
| 194 | ) as mock_create: |
| 195 | mock_create.return_value = {"type": "sdk", "name": "composio"} |
| 196 | provider.create_mcp_server(mock_tools) |
| 197 | |
| 198 | mock_create.assert_called_once_with( |
| 199 | name="composio", |
| 200 | version="1.0.0", |
| 201 | tools=mock_tools, |
| 202 | ) |
| 203 | |
| 204 | def test_create_mcp_server_with_custom_options(self, custom_provider): |
| 205 | """Test creating MCP server with custom options.""" |
| 206 | mock_tools = [MagicMock()] |
| 207 | |
| 208 | with patch( |
| 209 | "composio_claude_agent_sdk.provider.create_sdk_mcp_server" |
| 210 | ) as mock_create: |
| 211 | mock_create.return_value = {"type": "sdk", "name": "custom-server"} |
| 212 | custom_provider.create_mcp_server(mock_tools) |
| 213 | |
| 214 | mock_create.assert_called_once_with( |
| 215 | name="custom-server", |
| 216 | version="2.0.0", |
| 217 | tools=mock_tools, |
| 218 | ) |
| 219 | |
| 220 | def test_create_mcp_server_with_empty_tools(self, provider): |
| 221 | """Test creating MCP server with empty tools list.""" |
| 222 | with patch( |
| 223 | "composio_claude_agent_sdk.provider.create_sdk_mcp_server" |
| 224 | ) as mock_create: |
| 225 | mock_create.return_value = {"type": "sdk", "name": "composio"} |
| 226 | provider.create_mcp_server([]) |
| 227 | |
| 228 | mock_create.assert_called_once_with( |
| 229 | name="composio", |
| 230 | version="1.0.0", |
| 231 | tools=[], |
| 232 | ) |
| 233 | |
| 234 | |
| 235 | class TestToolHandlerExecution: |
| 236 | """Tests for tool handler execution.""" |
| 237 | |
| 238 | def test_tool_handler_success(self, provider, mock_tool): |
| 239 | """Test successful tool execution.""" |
| 240 | mock_execute = MagicMock(return_value={"data": "success", "successful": True}) |
| 241 | |
| 242 | # Create a real wrapped tool to test the handler |
| 243 | with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool: |
| 244 | # Capture the decorated function |
| 245 | captured_handler = None |
| 246 | |
| 247 | def capture_decorator(name, desc, schema): |
| 248 | def decorator(fn): |
| 249 | nonlocal captured_handler |
| 250 | captured_handler = fn |
| 251 | return fn |
| 252 | |
| 253 | return decorator |
| 254 | |
| 255 | mock_sdk_tool.side_effect = capture_decorator |
| 256 | provider.wrap_tool(mock_tool, mock_execute) |
| 257 | |
| 258 | # Execute the captured handler |
| 259 | result = asyncio.run(captured_handler({"to": "test@example.com"})) |
| 260 | |
| 261 | assert result["content"][0]["type"] == "text" |
| 262 | assert "success" in result["content"][0]["text"] |
| 263 | |
| 264 | def test_tool_handler_error(self, provider, mock_tool): |
| 265 | """Test tool execution with error.""" |
| 266 | mock_execute = MagicMock(side_effect=Exception("Test error")) |
| 267 | |
| 268 | with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool: |
| 269 | captured_handler = None |
| 270 | |
| 271 | def capture_decorator(name, desc, schema): |
| 272 | def decorator(fn): |
| 273 | nonlocal captured_handler |
| 274 | captured_handler = fn |
| 275 | return fn |
| 276 | |
| 277 | return decorator |
| 278 | |
| 279 | mock_sdk_tool.side_effect = capture_decorator |
| 280 | provider.wrap_tool(mock_tool, mock_execute) |
| 281 | |
| 282 | result = asyncio.run(captured_handler({"to": "test@example.com"})) |
| 283 | |
| 284 | assert result["content"][0]["type"] == "text" |
| 285 | response = json.loads(result["content"][0]["text"]) |
| 286 | assert response["successful"] is False |
| 287 | assert "Test error" in response["error"] |
| 288 | |
| 289 | def test_tool_handler_string_result(self, provider, mock_tool): |
| 290 | """Test tool execution returning string result.""" |
| 291 | mock_execute = MagicMock(return_value="Simple string result") |
| 292 | |
| 293 | with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool: |
| 294 | captured_handler = None |
| 295 | |
| 296 | def capture_decorator(name, desc, schema): |
| 297 | def decorator(fn): |
| 298 | nonlocal captured_handler |
| 299 | captured_handler = fn |
| 300 | return fn |
| 301 | |
| 302 | return decorator |
| 303 | |
| 304 | mock_sdk_tool.side_effect = capture_decorator |
| 305 | provider.wrap_tool(mock_tool, mock_execute) |
| 306 | |
| 307 | result = asyncio.run(captured_handler({})) |
| 308 | |
| 309 | assert result["content"][0]["type"] == "text" |
| 310 | assert result["content"][0]["text"] == "Simple string result" |