hud-python 0.4.45__py3-none-any.whl → 0.5.1__py3-none-any.whl

hud/environment/tests/test_connection.py

@@ -0,0 +1,317 @@
+"""Tests for hud.environment.connection module."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import mcp.types as mcp_types
+import pytest
+
+from hud.environment.connection import ConnectionConfig, ConnectionType, Connector
+
+
+class TestConnectionConfig:
+    """Tests for ConnectionConfig."""
+
+    def test_default_config(self) -> None:
+        """Config with no options set."""
+        config = ConnectionConfig()
+        assert config.prefix is None
+        assert config.include is None
+        assert config.exclude is None
+        assert config.transform is None
+
+    def test_config_with_options(self) -> None:
+        """Config with all options set."""
+        transform_fn = lambda t: t  # noqa: E731
+        config = ConnectionConfig(
+            prefix="test",
+            include=["tool1", "tool2"],
+            exclude=["tool3"],
+            transform=transform_fn,
+        )
+        assert config.prefix == "test"
+        assert config.include == ["tool1", "tool2"]
+        assert config.exclude == ["tool3"]
+        assert config.transform is transform_fn
+
+
+class TestConnectionType:
+    """Tests for ConnectionType enum."""
+
+    def test_local_type(self) -> None:
+        """LOCAL type for stdio/Docker connections."""
+        assert ConnectionType.LOCAL.value == "local"
+
+    def test_remote_type(self) -> None:
+        """REMOTE type for HTTP connections."""
+        assert ConnectionType.REMOTE.value == "remote"
+
+
+class TestConnector:
+    """Tests for Connector class."""
+
+    def test_init_stores_transport_config(self) -> None:
+        """__init__ stores transport config, doesn't create client."""
+        transport = {"server": {"url": "http://example.com"}}
+        config = ConnectionConfig()
+
+        connector = Connector(
+            transport=transport,
+            config=config,
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+            auth="test-token",
+        )
+
+        assert connector._transport == transport
+        assert connector._auth == "test-token"
+        assert connector.name == "test"
+        assert connector.connection_type == ConnectionType.REMOTE
+        assert connector.client is None  # Not created yet
+        assert connector._tools_cache is None
+
+    def test_is_local_property(self) -> None:
+        """is_local returns True for LOCAL connections."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="local-test",
+            connection_type=ConnectionType.LOCAL,
+        )
+        assert connector.is_local is True
+        assert connector.is_remote is False
+
+    def test_is_remote_property(self) -> None:
+        """is_remote returns True for REMOTE connections."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="remote-test",
+            connection_type=ConnectionType.REMOTE,
+        )
+        assert connector.is_remote is True
+        assert connector.is_local is False
+
+    def test_is_connected_false_when_no_client(self) -> None:
+        """is_connected returns False when client is None."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+        assert connector.is_connected is False
+
+    def test_cached_tools_empty_initially(self) -> None:
+        """cached_tools returns empty list initially."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+        assert connector.cached_tools == []
+
+    @pytest.mark.asyncio
+    async def test_connect_creates_client(self) -> None:
+        """connect() creates FastMCPClient and enters context."""
+        transport = {"server": {"url": "http://example.com"}}
+        connector = Connector(
+            transport=transport,
+            config=ConnectionConfig(),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+            auth="test-token",
+        )
+
+        mock_client = MagicMock()
+        mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_client.is_connected = MagicMock(return_value=True)
+
+        # Patch where it's imported from, not where it's used
+        with patch("fastmcp.client.Client", return_value=mock_client) as mock_cls:
+            await connector.connect()
+
+            # Client was created with correct args
+            mock_cls.assert_called_once_with(transport=transport, auth="test-token")
+            # Client context was entered
+            mock_client.__aenter__.assert_called_once()
+            # Client is now set
+            assert connector.client is mock_client
+
+    @pytest.mark.asyncio
+    async def test_disconnect_clears_client(self) -> None:
+        """disconnect() exits client context and clears state."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        mock_client = MagicMock()
+        mock_client.__aexit__ = AsyncMock(return_value=None)
+        mock_client.is_connected = MagicMock(return_value=True)
+        connector.client = mock_client
+        connector._tools_cache = [MagicMock()]
+
+        await connector.disconnect()
+
+        mock_client.__aexit__.assert_called_once_with(None, None, None)
+        assert connector.client is None
+        assert connector._tools_cache is None
+
+    @pytest.mark.asyncio
+    async def test_list_tools_raises_when_not_connected(self) -> None:
+        """list_tools() raises RuntimeError when not connected."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        with pytest.raises(RuntimeError, match="Not connected"):
+            await connector.list_tools()
+
+    @pytest.mark.asyncio
+    async def test_list_tools_applies_include_filter(self) -> None:
+        """list_tools() filters tools based on include list."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(include=["tool1"]),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        mock_client = MagicMock()
+        mock_client.list_tools = AsyncMock(
+            return_value=[
+                mcp_types.Tool(name="tool1", description="Tool 1", inputSchema={}),
+                mcp_types.Tool(name="tool2", description="Tool 2", inputSchema={}),
+            ]
+        )
+        connector.client = mock_client
+
+        tools = await connector.list_tools()
+
+        assert len(tools) == 1
+        assert tools[0].name == "tool1"
+
+    @pytest.mark.asyncio
+    async def test_list_tools_applies_exclude_filter(self) -> None:
+        """list_tools() filters out tools in exclude list."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(exclude=["tool2"]),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        mock_client = MagicMock()
+        mock_client.list_tools = AsyncMock(
+            return_value=[
+                mcp_types.Tool(name="tool1", description="Tool 1", inputSchema={}),
+                mcp_types.Tool(name="tool2", description="Tool 2", inputSchema={}),
+            ]
+        )
+        connector.client = mock_client
+
+        tools = await connector.list_tools()
+
+        assert len(tools) == 1
+        assert tools[0].name == "tool1"
+
+    @pytest.mark.asyncio
+    async def test_list_tools_applies_prefix(self) -> None:
+        """list_tools() adds prefix to tool names."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(prefix="myprefix"),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        mock_client = MagicMock()
+        mock_client.list_tools = AsyncMock(
+            return_value=[
+                mcp_types.Tool(name="tool1", description="Tool 1", inputSchema={}),
+            ]
+        )
+        connector.client = mock_client
+
+        tools = await connector.list_tools()
+
+        assert len(tools) == 1
+        assert tools[0].name == "myprefix_tool1"
+
+    @pytest.mark.asyncio
+    async def test_list_tools_caches_results(self) -> None:
+        """list_tools() caches results."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        mock_client = MagicMock()
+        mock_client.list_tools = AsyncMock(
+            return_value=[
+                mcp_types.Tool(name="tool1", description="Tool 1", inputSchema={}),
+            ]
+        )
+        connector.client = mock_client
+
+        tools = await connector.list_tools()
+
+        assert connector._tools_cache == tools
+        assert connector.cached_tools == tools
+
+    @pytest.mark.asyncio
+    async def test_call_tool_strips_prefix(self) -> None:
+        """call_tool() strips prefix before calling."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(prefix="myprefix"),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        mock_result = mcp_types.CallToolResult(content=[], isError=False)
+        mock_client = MagicMock()
+        mock_client.call_tool_mcp = AsyncMock(return_value=mock_result)
+        connector.client = mock_client
+
+        await connector.call_tool("myprefix_tool1", {"arg": "value"})
+
+        # Prefix should be stripped
+        mock_client.call_tool_mcp.assert_called_once_with("tool1", {"arg": "value"})
+
+    @pytest.mark.asyncio
+    async def test_call_tool_raises_when_not_connected(self) -> None:
+        """call_tool() raises RuntimeError when not connected."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="test",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        with pytest.raises(RuntimeError, match="Not connected"):
+            await connector.call_tool("tool1", {})
+
+    def test_repr(self) -> None:
+        """__repr__ shows useful info."""
+        connector = Connector(
+            transport={},
+            config=ConnectionConfig(),
+            name="my-server",
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        repr_str = repr(connector)
+        assert "my-server" in repr_str
+        assert "remote" in repr_str
+        assert "connected=False" in repr_str

hud/environment/tests/test_connectors.py

@@ -0,0 +1,218 @@
+"""Tests for hud.environment.connectors module."""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+from hud.environment.connection import ConnectionType, Connector
+
+
+class TestBaseConnectorMixin:
+    """Tests for BaseConnectorMixin._add_connection."""
+
+    def test_add_connection_stores_transport_config(self) -> None:
+        """_add_connection stores transport, doesn't create client."""
+        from hud.environment.connectors.base import BaseConnectorMixin
+
+        class TestEnv(BaseConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+        env = TestEnv()
+        transport = {"server": {"url": "http://example.com"}}
+
+        env._add_connection(
+            "test-server",
+            transport,
+            connection_type=ConnectionType.REMOTE,
+            auth="test-token",
+            prefix="myprefix",
+        )
+
+        assert "test-server" in env._connections
+        conn = env._connections["test-server"]
+        assert conn._transport == transport
+        assert conn._auth == "test-token"
+        assert conn.config.prefix == "myprefix"
+        assert conn.client is None  # Not created yet
+
+    def test_add_connection_returns_self(self) -> None:
+        """_add_connection returns self for chaining."""
+        from hud.environment.connectors.base import BaseConnectorMixin
+
+        class TestEnv(BaseConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+        env = TestEnv()
+        result = env._add_connection(
+            "test",
+            {},
+            connection_type=ConnectionType.REMOTE,
+        )
+
+        assert result is env
+
+
+class TestMCPConfigConnectorMixin:
+    """Tests for MCPConfigConnectorMixin."""
+
+    def test_connect_mcp_detects_local_connection(self) -> None:
+        """connect_mcp detects LOCAL type from command in config."""
+        from hud.environment.connectors.mcp_config import MCPConfigConnectorMixin
+
+        class TestEnv(MCPConfigConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+        env = TestEnv()
+        config = {
+            "filesystem": {
+                "command": "npx",
+                "args": ["-y", "@modelcontextprotocol/server-filesystem"],
+            }
+        }
+
+        env.connect_mcp(config)
+
+        conn = env._connections["filesystem"]
+        assert conn.connection_type == ConnectionType.LOCAL
+
+    def test_connect_mcp_detects_remote_connection(self) -> None:
+        """connect_mcp detects REMOTE type from URL in config."""
+        from hud.environment.connectors.mcp_config import MCPConfigConnectorMixin
+
+        class TestEnv(MCPConfigConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+        env = TestEnv()
+        config = {
+            "browser": {
+                "url": "https://mcp.hud.ai/browser",
+            }
+        }
+
+        env.connect_mcp(config)
+
+        conn = env._connections["browser"]
+        assert conn.connection_type == ConnectionType.REMOTE
+
+    def test_connect_mcp_uses_alias(self) -> None:
+        """connect_mcp uses alias if provided."""
+        from hud.environment.connectors.mcp_config import MCPConfigConnectorMixin
+
+        class TestEnv(MCPConfigConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+        env = TestEnv()
+        config = {"server": {"url": "http://example.com"}}
+
+        env.connect_mcp(config, alias="my-alias")
+
+        assert "my-alias" in env._connections
+        assert "server" not in env._connections
+
+    def test_connect_mcp_config_creates_multiple_connections(self) -> None:
+        """connect_mcp_config creates a connection for each server."""
+        from hud.environment.connectors.mcp_config import MCPConfigConnectorMixin
+
+        class TestEnv(MCPConfigConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+        env = TestEnv()
+        mcp_config = {
+            "server1": {"url": "http://example1.com"},
+            "server2": {"url": "http://example2.com"},
+            "server3": {"command": "npx", "args": ["server"]},
+        }
+
+        env.connect_mcp_config(mcp_config)
+
+        assert len(env._connections) == 3
+        assert "server1" in env._connections
+        assert "server2" in env._connections
+        assert "server3" in env._connections
+
+
+class TestRemoteConnectorMixin:
+    """Tests for RemoteConnectorMixin."""
+
+    def test_connect_url_creates_remote_connection(self) -> None:
+        """connect_url creates REMOTE connection."""
+        from hud.environment.connectors.remote import RemoteConnectorMixin
+
+        class TestEnv(RemoteConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+            def mount(self, server: Any, *, prefix: str | None = None) -> None:
+                pass
+
+        env = TestEnv()
+        env.connect_url("https://mcp.example.com", alias="example")
+
+        assert "example" in env._connections
+        conn = env._connections["example"]
+        assert conn.connection_type == ConnectionType.REMOTE
+
+    def test_connect_url_extracts_auth_from_headers(self) -> None:
+        """connect_url extracts Authorization from headers."""
+        from hud.environment.connectors.remote import RemoteConnectorMixin
+
+        class TestEnv(RemoteConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+            def mount(self, server: Any, *, prefix: str | None = None) -> None:
+                pass
+
+        env = TestEnv()
+        env.connect_url(
+            "https://mcp.example.com",
+            headers={"Authorization": "Bearer my-token"},
+            alias="example",
+        )
+
+        conn = env._connections["example"]
+        assert conn._auth == "Bearer my-token"
+
+    @patch("httpx.Client")
+    def test_connect_hub_fetches_config(self, mock_httpx_cls: MagicMock) -> None:
+        """connect_hub fetches mcp_config from API."""
+        from hud.environment.connectors.remote import RemoteConnectorMixin
+
+        class TestEnv(RemoteConnectorMixin):
+            def __init__(self) -> None:
+                self._connections: dict[str, Connector] = {}
+
+            def mount(self, server: Any, *, prefix: str | None = None) -> None:
+                pass
+
+        # Mock httpx response
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "mcp_config": {
+                "browser": {"url": "https://mcp.hud.ai/browser"},
+            }
+        }
+        mock_response.raise_for_status = MagicMock()
+
+        mock_client = MagicMock()
+        mock_client.get.return_value = mock_response
+        mock_client.__enter__ = MagicMock(return_value=mock_client)
+        mock_client.__exit__ = MagicMock(return_value=None)
+        mock_httpx_cls.return_value = mock_client
+
+        env = TestEnv()
+        with patch("hud.settings.settings") as mock_settings:
+            mock_settings.hud_api_url = "https://api.hud.so"
+            mock_settings.api_key = "test-key"
+
+            env.connect_hub("hud/browser")
+
+        # connect_hub creates a connection named "hud" (the server name)
+        assert "hud" in env._connections

hud/environment/tests/test_environment.py

@@ -0,0 +1,161 @@
+"""Tests for Environment class - context manager, resources, prompts, prompt feature."""
+
+from __future__ import annotations
+
+import pytest
+
+
+class TestEnvironmentPrompt:
+    """Tests for Environment.prompt feature."""
+
+    def test_prompt_defaults_to_none(self) -> None:
+        """Environment.prompt defaults to None."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+        assert env.prompt is None
+
+    def test_prompt_can_be_set(self) -> None:
+        """Environment.prompt can be set manually."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+        env.prompt = "Navigate to google.com"
+        assert env.prompt == "Navigate to google.com"
+
+
+class TestEnvironmentContextManager:
+    """Tests for Environment async context manager."""
+
+    @pytest.mark.asyncio
+    async def test_context_manager_sets_in_context_flag(self) -> None:
+        """Context manager sets _in_context flag."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+
+        assert env._in_context is False
+
+        async with env:
+            assert env._in_context is True
+
+        assert env._in_context is False
+
+    @pytest.mark.asyncio
+    async def test_context_manager_no_connections(self) -> None:
+        """Context manager works with no connections."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+
+        async with env:
+            # Should work without connections
+            pass
+
+
+class TestEnvironmentResources:
+    """Tests for Environment resource operations."""
+
+    @pytest.mark.asyncio
+    async def test_list_resources_empty(self) -> None:
+        """list_resources returns empty list when no resources."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+
+        async with env:
+            resources = await env.list_resources()
+
+        assert resources == []
+
+    @pytest.mark.asyncio
+    async def test_read_resource_not_found(self) -> None:
+        """read_resource raises when resource not found."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+
+        async with env:
+            with pytest.raises(ValueError, match="Resource not found"):
+                await env.read_resource("file://nonexistent.txt")
+
+
+class TestEnvironmentPrompts:
+    """Tests for Environment prompt operations (MCP prompts, not task prompt)."""
+
+    @pytest.mark.asyncio
+    async def test_list_prompts_empty(self) -> None:
+        """list_prompts returns empty list when no prompts."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+
+        async with env:
+            prompts = await env.list_prompts()
+
+        assert prompts == []
+
+    @pytest.mark.asyncio
+    async def test_get_prompt_not_found(self) -> None:
+        """get_prompt raises when prompt not found."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+
+        async with env:
+            with pytest.raises(ValueError, match="Prompt not found"):
+                await env.get_prompt("nonexistent")
+
+
+class TestEnvironmentSetupEvaluate:
+    """Tests for setup_tool and evaluate_tool methods."""
+
+    def test_setup_tool_with_name_and_kwargs(self) -> None:
+        """setup_tool accepts name and kwargs."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+        env.setup_tool("navigate", url="https://example.com")
+
+        assert len(env._setup_calls) == 1
+        assert env._setup_calls[0] == ("navigate", {"url": "https://example.com"})
+
+    def test_setup_tool_returns_self(self) -> None:
+        """setup_tool returns self for chaining."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+        result = env.setup_tool("navigate", url="https://example.com")
+
+        assert result is env
+
+    def test_evaluate_tool_with_name_and_kwargs(self) -> None:
+        """evaluate_tool accepts name and kwargs."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+        env.evaluate_tool("check_text", contains="success")
+
+        assert len(env._evaluate_calls) == 1
+        assert env._evaluate_calls[0] == ("check_text", {"contains": "success"})
+
+    def test_evaluate_tool_returns_self(self) -> None:
+        """evaluate_tool returns self for chaining."""
+        from hud.environment import Environment
+
+        env = Environment("test")
+        result = env.evaluate_tool("check_text", contains="success")
+
+        assert result is env
+
+    def test_chaining_multiple_setup_calls(self) -> None:
+        """Multiple setup_tool calls can be chained."""
+        from hud.environment import Environment
+
+        env = (
+            Environment("test")
+            .setup_tool("navigate", url="https://example.com")
+            .setup_tool("wait", seconds=2)
+        )
+
+        assert len(env._setup_calls) == 2