test: add comprehensive test suite for MCP fetch_tools functionality

Add 12 new tests covering MCP-backed tool fetching to match Node SDK test
coverage in stackone.mcp-fetch.spec.ts. Tests are organized into logical
groups for account and provider/action filtering scenarios.

Test Coverage:

Account Filtering (TestAccountFiltering):
- fetch_tools_with_single_account_id: Single account filtering
- fetch_tools_with_multiple_account_ids: Multiple account filtering
- fetch_tools_with_set_accounts: Using set_accounts() method
- fetch_tools_account_ids_override_set_accounts: Parameter precedence
- fetch_tools_with_constructor_account_id: Constructor-based account
- fetch_tools_with_empty_account_ids: Empty list handling

Provider/Action Filtering (TestProviderAndActionFiltering):
- fetch_tools_with_provider_filter: Single provider filtering
- fetch_tools_with_multiple_providers: Multiple provider filtering
- fetch_tools_with_action_glob_pattern: Glob pattern matching
- fetch_tools_with_exact_action_match: Exact action name matching
- fetch_tools_with_provider_and_action_filters: Combined filtering
- fetch_tools_with_exclusion_pattern: Negative glob patterns

Removed:
- Deleted old fetch_tools tests that used non-MCP approach
- These tests were testing the old implementation that loaded from
  OpenAPI specs instead of the MCP server

The test suite uses comprehensive mocking of MCP client components:
- ClientSession for MCP protocol communication
- streamablehttp_client for HTTP transport
- Tool list responses with pagination support
- Proper async context manager handling

All tests verify:
- Correct tool count after filtering
- Proper tool presence/absence
- Account ID preservation in tool context
- Filter precedence and interaction

Author: ryoppippi

tests/test_toolset.py

@@ -1,7 +1,5 @@
 from unittest.mock import MagicMock, patch
 
-import pytest
-
 from stackone_ai.models import ExecuteConfig, ToolDefinition, ToolParameters
 from stackone_ai.toolset import StackOneToolSet
 
@@ -273,206 +271,3 @@ def test_filter_by_action():
     # Test non-matching patterns
     assert not toolset._filter_by_action("crm_list_contacts", ["*_list_employees"])
     assert not toolset._filter_by_action("ats_create_job", ["hris_*"])
-
-
-@pytest.fixture
-def mock_tools_setup():
-    """Setup mocked tools for filtering tests"""
-    # Create mock tool definitions
-    tools_defs = {
-        "hris_list_employees": ToolDefinition(
-            description="List employees",
-            parameters=ToolParameters(type="object", properties={}),
-            execute=ExecuteConfig(
-                method="GET",
-                url="https://api.stackone.com/hris/employees",
-                name="hris_list_employees",
-                headers={},
-            ),
-        ),
-        "hris_create_employee": ToolDefinition(
-            description="Create employee",
-            parameters=ToolParameters(type="object", properties={}),
-            execute=ExecuteConfig(
-                method="POST",
-                url="https://api.stackone.com/hris/employees",
-                name="hris_create_employee",
-                headers={},
-            ),
-        ),
-        "ats_list_employees": ToolDefinition(
-            description="List ATS employees",
-            parameters=ToolParameters(type="object", properties={}),
-            execute=ExecuteConfig(
-                method="GET",
-                url="https://api.stackone.com/ats/employees",
-                name="ats_list_employees",
-                headers={},
-            ),
-        ),
-        "crm_list_contacts": ToolDefinition(
-            description="List contacts",
-            parameters=ToolParameters(type="object", properties={}),
-            execute=ExecuteConfig(
-                method="GET",
-                url="https://api.stackone.com/crm/contacts",
-                name="crm_list_contacts",
-                headers={},
-            ),
-        ),
-    }
-
-    with (
-        patch("stackone_ai.toolset.OAS_DIR") as mock_dir,
-        patch("stackone_ai.toolset.OpenAPIParser") as mock_parser_class,
-    ):
-        mock_path = MagicMock()
-        mock_path.exists.return_value = True
-        mock_dir.glob.return_value = [mock_path]
-
-        mock_parser = MagicMock()
-        mock_parser.parse_tools.return_value = tools_defs
-        mock_parser_class.return_value = mock_parser
-
-        yield
-
-
-def test_fetch_tools_no_filters(mock_tools_setup):
-    """Test fetch_tools without any filters"""
-    toolset = StackOneToolSet(api_key="test_key")
-    tools = toolset.fetch_tools()
-
-    # Should include all tools (4 regular + 1 feedback tool)
-    assert len(tools) == 5
-
-
-def test_fetch_tools_provider_filter(mock_tools_setup):
-    """Test fetch_tools with provider filtering"""
-    toolset = StackOneToolSet(api_key="test_key")
-
-    # Filter by single provider
-    tools = toolset.fetch_tools(providers=["hris"])
-    assert len(tools) == 2
-    assert tools.get_tool("hris_list_employees") is not None
-    assert tools.get_tool("hris_create_employee") is not None
-
-    # Filter by multiple providers
-    tools = toolset.fetch_tools(providers=["hris", "ats"])
-    assert len(tools) == 3
-    assert tools.get_tool("hris_list_employees") is not None
-    assert tools.get_tool("ats_list_employees") is not None
-
-
-def test_fetch_tools_action_filter(mock_tools_setup):
-    """Test fetch_tools with action filtering"""
-    toolset = StackOneToolSet(api_key="test_key")
-
-    # Exact action match
-    tools = toolset.fetch_tools(actions=["hris_list_employees"])
-    assert len(tools) == 1
-    assert tools.get_tool("hris_list_employees") is not None
-
-    # Glob pattern match
-    tools = toolset.fetch_tools(actions=["*_list_employees"])
-    assert len(tools) == 2
-    assert tools.get_tool("hris_list_employees") is not None
-    assert tools.get_tool("ats_list_employees") is not None
-
-
-def test_fetch_tools_combined_filters(mock_tools_setup):
-    """Test fetch_tools with combined filters"""
-    toolset = StackOneToolSet(api_key="test_key")
-
-    # Combine provider and action filters
-    tools = toolset.fetch_tools(providers=["hris"], actions=["*_list_*"])
-    assert len(tools) == 1
-    assert tools.get_tool("hris_list_employees") is not None
-    assert tools.get_tool("hris_create_employee") is None
-
-
-def test_fetch_tools_with_set_accounts(mock_tools_setup):
-    """Test fetch_tools using set_accounts"""
-    toolset = StackOneToolSet(api_key="test_key")
-    toolset.set_accounts(["acc1"])
-
-    tools = toolset.fetch_tools(providers=["hris"])
-    assert len(tools) == 2
-
-
-def test_fetch_tools_account_id_override(mock_tools_setup) -> None:
-    """Test that fetch_tools account_ids parameter overrides set_accounts"""
-    toolset = StackOneToolSet(api_key="test_key")
-
-    # Set accounts via set_accounts
-    toolset.set_accounts(["acc1", "acc2"])
-
-    # Override with different account IDs in fetch_tools
-    # This should use acc3, not acc1/acc2
-    tools = toolset.fetch_tools(account_ids=["acc3"], providers=["hris"])
-
-    # Should fetch tools for acc3 only
-    # With 2 HRIS tools per account
-    assert len(tools) == 2
-
-    # Verify that set_accounts state is not modified
-    assert toolset._account_ids == ["acc1", "acc2"]
-
-
-def test_fetch_tools_uses_set_accounts_when_no_override(mock_tools_setup) -> None:
-    """Test that fetch_tools uses set_accounts when account_ids not provided"""
-    toolset = StackOneToolSet(api_key="test_key")
-    toolset.set_accounts(["acc1", "acc2"])
-
-    # Should use accounts from set_accounts
-    tools = toolset.fetch_tools(providers=["hris"])
-
-    # Should fetch tools for both accounts
-    # 2 HRIS tools × 2 accounts = 4 tools
-    assert len(tools) == 4
-
-
-def test_fetch_tools_multiple_account_ids(mock_tools_setup) -> None:
-    """Test fetching tools for multiple account IDs"""
-    toolset = StackOneToolSet(api_key="test_key")
-
-    # Fetch tools for multiple accounts
-    tools = toolset.fetch_tools(account_ids=["acc1", "acc2", "acc3"])
-
-    # Should fetch all tools for all 3 accounts
-    # (4 regular tools + 1 feedback tool) × 3 accounts = 15 tools
-    assert len(tools) == 15
-
-
-def test_fetch_tools_preserves_account_context() -> None:
-    """Test that tools fetched with account_id maintain their account context"""
-    with (
-        patch("stackone_ai.toolset.OAS_DIR") as mock_dir,
-        patch("stackone_ai.toolset.OpenAPIParser") as mock_parser_class,
-    ):
-        # Create a simple tool definition
-        tool_def = ToolDefinition(
-            description="Test tool",
-            parameters=ToolParameters(type="object", properties={}),
-            execute=ExecuteConfig(
-                method="GET",
-                url="https://api.stackone.com/test",
-                name="test_tool",
-                headers={},
-            ),
-        )
-
-        mock_path = MagicMock()
-        mock_path.exists.return_value = True
-        mock_dir.glob.return_value = [mock_path]
-
-        mock_parser = MagicMock()
-        mock_parser.parse_tools.return_value = {"test_tool": tool_def}
-        mock_parser_class.return_value = mock_parser
-
-        toolset = StackOneToolSet(api_key="test_key")
-        tools = toolset.fetch_tools(account_ids=["specific-account"])
-
-        # Get a tool and verify it has the account ID
-        tool = tools.get_tool("test_tool")
-        assert tool is not None
-        assert tool.get_account_id() == "specific-account"