tests: add more tests

Author: dbschmigelski

src/strands/tools/mcp/mcp_client.py

@@ -16,7 +16,7 @@
 from concurrent import futures
 from datetime import timedelta
 from types import TracebackType
-from typing import Any, Callable, Coroutine, Dict, Optional, TypeVar, Union
+from typing import Any, Callable, Coroutine, Dict, Optional, TypeVar, Union, cast
 
 from mcp import ClientSession, ListToolsResult
 from mcp.types import CallToolResult as MCPCallToolResult
@@ -157,7 +157,7 @@ def stop(
                 async def _set_close_event() -> None:
                     self._close_event.set()
 
-                asyncio.run_coroutine_threadsafe(_set_close_event(), self._background_thread_event_loop)
+                self._invoke_on_background_thread(_set_close_event()).result()
 
             self._log_debug_with_thread("waiting for background thread to join")
             self._background_thread.join()
@@ -183,8 +183,7 @@ def list_tools_sync(self, pagination_token: Optional[str] = None) -> PaginatedLi
             raise MCPClientInitializationError(CLIENT_SESSION_NOT_RUNNING_ERROR_MESSAGE)
 
         async def _list_tools_async() -> ListToolsResult:
-            assert self._background_thread_session is not None
-            return await self._background_thread_session.list_tools(cursor=pagination_token)
+            return await cast(ClientSession, self._background_thread_session).list_tools(cursor=pagination_token)
 
         list_tools_response: ListToolsResult = self._invoke_on_background_thread(_list_tools_async()).result()
         self._log_debug_with_thread("received %d tools from MCP server", len(list_tools_response.tools))
@@ -210,8 +209,7 @@ def list_prompts_sync(self, pagination_token: Optional[str] = None) -> ListPromp
             raise MCPClientInitializationError(CLIENT_SESSION_NOT_RUNNING_ERROR_MESSAGE)
 
         async def _list_prompts_async() -> ListPromptsResult:
-            assert self._background_thread_session is not None
-            return await self._background_thread_session.list_prompts(cursor=pagination_token)
+            return await cast(ClientSession, self._background_thread_session).list_prompts(cursor=pagination_token)
 
         list_prompts_result: ListPromptsResult = self._invoke_on_background_thread(_list_prompts_async()).result()
         self._log_debug_with_thread("received %d prompts from MCP server", len(list_prompts_result.prompts))
@@ -235,8 +233,7 @@ def get_prompt_sync(self, prompt_id: str, args: dict[str, Any]) -> GetPromptResu
             raise MCPClientInitializationError(CLIENT_SESSION_NOT_RUNNING_ERROR_MESSAGE)
 
         async def _get_prompt_async() -> GetPromptResult:
-            assert self._background_thread_session is not None
-            return await self._background_thread_session.get_prompt(prompt_id, arguments=args)
+            return await cast(ClientSession, self._background_thread_session).get_prompt(prompt_id, arguments=args)
 
         get_prompt_result: GetPromptResult = self._invoke_on_background_thread(_get_prompt_async()).result()
         self._log_debug_with_thread("received prompt from MCP server")
@@ -271,8 +268,9 @@ def call_tool_sync(
             raise MCPClientInitializationError(CLIENT_SESSION_NOT_RUNNING_ERROR_MESSAGE)
 
         async def _call_tool_async() -> MCPCallToolResult:
-            assert self._background_thread_session is not None
-            return await self._background_thread_session.call_tool(name, arguments, read_timeout_seconds)
+            return await cast(ClientSession, self._background_thread_session).call_tool(
+                name, arguments, read_timeout_seconds
+            )
 
         try:
             call_tool_result: MCPCallToolResult = self._invoke_on_background_thread(_call_tool_async()).result()
@@ -307,8 +305,9 @@ async def call_tool_async(
             raise MCPClientInitializationError(CLIENT_SESSION_NOT_RUNNING_ERROR_MESSAGE)
 
         async def _call_tool_async() -> MCPCallToolResult:
-            assert self._background_thread_session is not None
-            return await self._background_thread_session.call_tool(name, arguments, read_timeout_seconds)
+            return await cast(ClientSession, self._background_thread_session).call_tool(
+                name, arguments, read_timeout_seconds
+            )
 
         try:
             future = self._invoke_on_background_thread(_call_tool_async())

tests/strands/tools/mcp/test_mcp_client.py

@@ -485,3 +485,39 @@ def slow_transport():
         with pytest.raises(MCPClientInitializationError, match="background thread did not start in 1 seconds"):
             client.start()
         mock_stop.assert_called_once_with(None, None, None)
+
+
+def test_stop_with_no_background_thread():
+    """Test that stop() handles the case when no background thread exists."""
+    client = MCPClient(MagicMock())
+
+    # Ensure no background thread exists
+    assert client._background_thread is None
+
+    # Mock join to verify it's not called
+    with patch("threading.Thread.join") as mock_join:
+        client.stop(None, None, None)
+        mock_join.assert_not_called()
+
+    # Verify cleanup occurred
+    assert client._background_thread is None
+
+
+def test_stop_with_background_thread_but_no_event_loop():
+    """Test that stop() handles the case when background thread exists but event loop is None."""
+    client = MCPClient(MagicMock())
+
+    # Mock a background thread without event loop
+    mock_thread = MagicMock()
+    mock_thread.join = MagicMock()
+    client._background_thread = mock_thread
+    client._background_thread_event_loop = None
+
+    # Should not raise any exceptions and should join the thread
+    client.stop(None, None, None)
+
+    # Verify thread was joined
+    mock_thread.join.assert_called_once()
+
+    # Verify cleanup occurred
+    assert client._background_thread is None