@devries-cameron20 / composio Mirror · read-only
Fork 0

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

next
py 310 lines 10.4 KB
Raw
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"