test: use thread-aware fake to exercise executor path

Address CodeRabbit review: replace AsyncMock with _ThreadAffinityFakeClient
that raises unless async methods run in a worker thread.

Author: PiedPiper911

lib/crewai/tests/mcp/test_tool_resolver_native.py

@@ -1,5 +1,6 @@
 """Tests for MCPToolResolver native (non-AMP) resolution paths."""
 
+import threading
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
@@ -99,26 +100,63 @@ def test_unmatched_runtime_error_is_wrapped_not_swallowed(
             resolver._resolve_native(http_config)
 
 
+class _ThreadAffinityFakeClient:
+    """Fake MCP client that raises when awaited from the main thread.
+
+    Simulates the thread-affinity constraint of real asyncio objects:
+    async methods must run in a worker thread, not on the main thread
+    where an event loop is already running.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self._main_tid = threading.current_thread().ident
+        self.connected = False
+        self._executor_tid = None
+
+    def _check_affinity(self):
+        if (
+            threading.current_thread().ident == self._main_tid
+            and _loop_is_running()
+        ):
+            raise RuntimeError(
+                "Event loop affinity: async operations must run in a worker thread"
+            )
+
+    async def connect(self):
+        self._check_affinity()
+        self._executor_tid = threading.current_thread().ident
+        self.connected = True
+
+    async def disconnect(self):
+        self._check_affinity()
+        self.connected = False
+
+    async def list_tools(self):
+        self._check_affinity()
+        return [{"name": "test_tool", "description": "A test tool", "inputSchema": {}}]
+
+
+def _loop_is_running():
+    try:
+        import asyncio
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
+
 class TestResolveNativeAsyncioThreadAffinity:
-    @patch("crewai.mcp.tool_resolver.MCPClient")
+    @patch("crewai.mcp.tool_resolver.MCPClient", _ThreadAffinityFakeClient)
     def test_resolve_native_from_running_loop_uses_executor_path(
-        self, mock_client_class, resolver, http_config
+        self, resolver, http_config
     ):
         """Test that _resolve_native works when called from a running event loop.
 
-        When an event loop is already running, _resolve_native uses
-        executor.submit() with a lambda to create the coroutine inside
-        the worker thread, avoiding the thread affinity error.
+        Uses a thread-aware fake that raises a thread-affinity error unless
+        async methods execute in a worker thread (i.e. via the executor path).
         """
         import asyncio
 
-        mock_client = AsyncMock()
-        mock_client.list_tools = AsyncMock(return_value=[])
-        mock_client.connected = False
-        mock_client.connect = AsyncMock()
-        mock_client.disconnect = AsyncMock()
-        mock_client_class.return_value = mock_client
-
         mock_log = MagicMock()
         resolver._logger = MagicMock(log=mock_log)
 
@@ -127,5 +165,6 @@ async def _call_resolve_native():
 
         tools, clients = asyncio.run(_call_resolve_native())
 
-        assert tools == []
+        assert len(tools) == 1
+        assert tools[0].name == "test_tool"
         assert clients == []