hud-python 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

hud/tools/tests/test_playwright_tool.py

@@ -1,183 +1,183 @@
-"""Tests for Playwright tool."""
-
-from __future__ import annotations
-
-from unittest.mock import AsyncMock, patch
-
-import pytest
-from mcp.shared.exceptions import McpError
-from mcp.types import INVALID_PARAMS, ImageContent, TextContent
-
-from hud.tools.playwright import PlaywrightTool
-
-
-class TestPlaywrightTool:
-    """Tests for PlaywrightTool."""
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_init(self):
-        """Test tool initialization."""
-        tool = PlaywrightTool()
-        assert tool._browser is None
-        assert tool._browser_context is None
-        assert tool.page is None
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_invalid_action(self):
-        """Test that invalid action raises error."""
-        tool = PlaywrightTool()
-
-        with pytest.raises(McpError) as exc_info:
-            await tool(action="invalid_action")
-
-        assert exc_info.value.error.code == INVALID_PARAMS
-        assert "Unknown action" in exc_info.value.error.message
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_navigate_with_mocked_browser(self):
-        """Test navigate action with mocked browser."""
-        tool = PlaywrightTool()
-
-        # Mock the browser components
-        mock_page = AsyncMock()
-        mock_page.goto = AsyncMock()
-
-        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock) as mock_ensure:
-            # Set up the tool with mocked page
-            tool.page = mock_page
-
-            blocks = await tool(action="navigate", url="https://example.com")
-
-            assert blocks is not None
-            assert any(isinstance(b, TextContent) for b in blocks)
-            # The actual call includes wait_until parameter with a Field object
-            mock_page.goto.assert_called_once()
-            args, kwargs = mock_page.goto.call_args
-            assert args[0] == "https://example.com"
-            mock_ensure.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_click_with_mocked_browser(self):
-        """Test click action with mocked browser."""
-        tool = PlaywrightTool()
-
-        # Mock the browser components
-        mock_page = AsyncMock()
-        mock_page.click = AsyncMock()
-
-        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
-            # Set up the tool with mocked page
-            tool.page = mock_page
-
-            blocks = await tool(action="click", selector="button#submit")
-
-            assert blocks is not None
-            assert any(isinstance(b, TextContent) for b in blocks)
-            mock_page.click.assert_called_once_with("button#submit", button="left", click_count=1)
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_type_with_mocked_browser(self):
-        """Test type action with mocked browser."""
-        tool = PlaywrightTool()
-
-        # Mock the browser components
-        mock_page = AsyncMock()
-        mock_page.fill = AsyncMock()  # Playwright uses fill, not type
-
-        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
-            # Set up the tool with mocked page
-            tool.page = mock_page
-
-            blocks = await tool(action="type", selector="input#name", text="John Doe")
-
-            assert blocks is not None
-            assert any(isinstance(b, TextContent) for b in blocks)
-            mock_page.fill.assert_called_once_with("input#name", "John Doe")
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_screenshot_with_mocked_browser(self):
-        """Test screenshot action with mocked browser."""
-        tool = PlaywrightTool()
-
-        # Mock the browser components
-        mock_page = AsyncMock()
-        mock_page.screenshot = AsyncMock(return_value=b"fake_screenshot_data")
-
-        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
-            # Set up the tool with mocked page
-            tool.page = mock_page
-
-            blocks = await tool(action="screenshot")
-
-            assert blocks is not None
-            assert len(blocks) > 0
-            assert any(isinstance(b, ImageContent | TextContent) for b in blocks)
-            mock_page.screenshot.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_get_page_info_with_mocked_browser(self):
-        """Test get_page_info action with mocked browser."""
-        tool = PlaywrightTool()
-
-        # Mock the browser components
-        mock_page = AsyncMock()
-        mock_page.url = "https://example.com"
-        mock_page.title = AsyncMock(return_value="Example Page")
-        mock_page.evaluate = AsyncMock(return_value={"height": 1000})
-
-        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
-            # Set up the tool with mocked page
-            tool.page = mock_page
-
-            blocks = await tool(action="get_page_info")
-
-            assert blocks is not None
-            assert any(isinstance(b, TextContent) for b in blocks)
-            # Check that the text contains expected info
-            text_blocks = [b.text for b in blocks if isinstance(b, TextContent)]
-            combined_text = " ".join(text_blocks)
-            assert "https://example.com" in combined_text
-            assert "Example Page" in combined_text
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_wait_for_element_with_mocked_browser(self):
-        """Test wait_for_element action with mocked browser."""
-        tool = PlaywrightTool()
-
-        # Mock the browser components
-        mock_page = AsyncMock()
-        mock_page.wait_for_selector = AsyncMock()
-
-        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
-            # Set up the tool with mocked page
-            tool.page = mock_page
-
-            # wait_for_element doesn't accept timeout parameter directly
-            blocks = await tool(action="wait_for_element", selector="div#loaded")
-
-            assert blocks is not None
-            assert any(isinstance(b, TextContent) for b in blocks)
-            # Default timeout is used
-            mock_page.wait_for_selector.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_playwright_tool_cleanup(self):
-        """Test cleanup functionality."""
-        tool = PlaywrightTool()
-
-        # Mock browser and context
-        mock_browser = AsyncMock()
-        mock_context = AsyncMock()
-        mock_page = AsyncMock()
-
-        tool._browser = mock_browser
-        tool._browser_context = mock_context
-        tool.page = mock_page
-
-        # Call the cleanup method directly (tool is not a context manager)
-        await tool.close()
-
-        mock_browser.close.assert_called_once()
-        assert tool._browser is None
-        assert tool._browser_context is None
-        assert tool.page is None
+"""Tests for Playwright tool."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from mcp.shared.exceptions import McpError
+from mcp.types import INVALID_PARAMS, ImageContent, TextContent
+
+from hud.tools.playwright import PlaywrightTool
+
+
+class TestPlaywrightTool:
+    """Tests for PlaywrightTool."""
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_init(self):
+        """Test tool initialization."""
+        tool = PlaywrightTool()
+        assert tool._browser is None
+        assert tool._browser_context is None
+        assert tool.page is None
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_invalid_action(self):
+        """Test that invalid action raises error."""
+        tool = PlaywrightTool()
+
+        with pytest.raises(McpError) as exc_info:
+            await tool(action="invalid_action")
+
+        assert exc_info.value.error.code == INVALID_PARAMS
+        assert "Unknown action" in exc_info.value.error.message
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_navigate_with_mocked_browser(self):
+        """Test navigate action with mocked browser."""
+        tool = PlaywrightTool()
+
+        # Mock the browser components
+        mock_page = AsyncMock()
+        mock_page.goto = AsyncMock()
+
+        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock) as mock_ensure:
+            # Set up the tool with mocked page
+            tool.page = mock_page
+
+            blocks = await tool(action="navigate", url="https://example.com")
+
+            assert blocks is not None
+            assert any(isinstance(b, TextContent) for b in blocks)
+            # The actual call includes wait_until parameter with a Field object
+            mock_page.goto.assert_called_once()
+            args, kwargs = mock_page.goto.call_args
+            assert args[0] == "https://example.com"
+            mock_ensure.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_click_with_mocked_browser(self):
+        """Test click action with mocked browser."""
+        tool = PlaywrightTool()
+
+        # Mock the browser components
+        mock_page = AsyncMock()
+        mock_page.click = AsyncMock()
+
+        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
+            # Set up the tool with mocked page
+            tool.page = mock_page
+
+            blocks = await tool(action="click", selector="button#submit")
+
+            assert blocks is not None
+            assert any(isinstance(b, TextContent) for b in blocks)
+            mock_page.click.assert_called_once_with("button#submit", button="left", click_count=1)
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_type_with_mocked_browser(self):
+        """Test type action with mocked browser."""
+        tool = PlaywrightTool()
+
+        # Mock the browser components
+        mock_page = AsyncMock()
+        mock_page.fill = AsyncMock()  # Playwright uses fill, not type
+
+        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
+            # Set up the tool with mocked page
+            tool.page = mock_page
+
+            blocks = await tool(action="type", selector="input#name", text="John Doe")
+
+            assert blocks is not None
+            assert any(isinstance(b, TextContent) for b in blocks)
+            mock_page.fill.assert_called_once_with("input#name", "John Doe")
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_screenshot_with_mocked_browser(self):
+        """Test screenshot action with mocked browser."""
+        tool = PlaywrightTool()
+
+        # Mock the browser components
+        mock_page = AsyncMock()
+        mock_page.screenshot = AsyncMock(return_value=b"fake_screenshot_data")
+
+        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
+            # Set up the tool with mocked page
+            tool.page = mock_page
+
+            blocks = await tool(action="screenshot")
+
+            assert blocks is not None
+            assert len(blocks) > 0
+            assert any(isinstance(b, ImageContent | TextContent) for b in blocks)
+            mock_page.screenshot.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_get_page_info_with_mocked_browser(self):
+        """Test get_page_info action with mocked browser."""
+        tool = PlaywrightTool()
+
+        # Mock the browser components
+        mock_page = AsyncMock()
+        mock_page.url = "https://example.com"
+        mock_page.title = AsyncMock(return_value="Example Page")
+        mock_page.evaluate = AsyncMock(return_value={"height": 1000})
+
+        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
+            # Set up the tool with mocked page
+            tool.page = mock_page
+
+            blocks = await tool(action="get_page_info")
+
+            assert blocks is not None
+            assert any(isinstance(b, TextContent) for b in blocks)
+            # Check that the text contains expected info
+            text_blocks = [b.text for b in blocks if isinstance(b, TextContent)]
+            combined_text = " ".join(text_blocks)
+            assert "https://example.com" in combined_text
+            assert "Example Page" in combined_text
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_wait_for_element_with_mocked_browser(self):
+        """Test wait_for_element action with mocked browser."""
+        tool = PlaywrightTool()
+
+        # Mock the browser components
+        mock_page = AsyncMock()
+        mock_page.wait_for_selector = AsyncMock()
+
+        with patch.object(tool, "_ensure_browser", new_callable=AsyncMock):
+            # Set up the tool with mocked page
+            tool.page = mock_page
+
+            # wait_for_element doesn't accept timeout parameter directly
+            blocks = await tool(action="wait_for_element", selector="div#loaded")
+
+            assert blocks is not None
+            assert any(isinstance(b, TextContent) for b in blocks)
+            # Default timeout is used
+            mock_page.wait_for_selector.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_playwright_tool_cleanup(self):
+        """Test cleanup functionality."""
+        tool = PlaywrightTool()
+
+        # Mock browser and context
+        mock_browser = AsyncMock()
+        mock_context = AsyncMock()
+        mock_page = AsyncMock()
+
+        tool._browser = mock_browser
+        tool._browser_context = mock_context
+        tool.page = mock_page
+
+        # Call the cleanup method directly (tool is not a context manager)
+        await tool.close()
+
+        mock_browser.close.assert_called_once()
+        assert tool._browser is None
+        assert tool._browser_context is None
+        assert tool.page is None

hud/tools/tests/test_tools.py

@@ -1,145 +1,145 @@
-from __future__ import annotations
-
-import sys
-
-import pytest
-from mcp.types import ImageContent, TextContent
-
-from hud.tools.bash import BashTool
-from hud.tools.computer.hud import HudComputerTool
-from hud.tools.edit import EditTool
-
-
-@pytest.mark.asyncio
-async def test_bash_tool_echo():
-    tool = BashTool()
-
-    # Monkey-patch the private _session methods so no subprocess is spawned
-    from hud.tools.types import ContentResult
-
-    class _FakeSession:
-        async def run(self, cmd: str):
-            return ContentResult(output=f"mocked: {cmd}")
-
-        async def start(self):
-            return None
-
-    tool.session = _FakeSession()  # type: ignore[assignment]
-
-    result = await tool(command="echo hello")
-    assert len(result) > 0
-    assert isinstance(result[0], TextContent)
-    assert result[0].text == "mocked: echo hello"
-
-
-@pytest.mark.asyncio
-async def test_bash_tool_restart_and_no_command():
-    from hud.tools.types import ToolError
-
-    tool = BashTool()
-
-    from hud.tools.types import ContentResult
-
-    class _FakeSession:
-        async def run(self, cmd: str):
-            return ContentResult(output="ran")
-
-        async def start(self):
-            return None
-
-        def stop(self):
-            return None
-
-    tool.session = _FakeSession()  # type: ignore[assignment]
-
-    # Monkey-patch _BashSession.start to avoid launching a real shell
-    async def _dummy_start(self):
-        self._started = True
-        from types import SimpleNamespace
-
-        # minimal fake process attributes used later
-        self._process = SimpleNamespace(returncode=None)
-
-    import hud.tools.bash as bash_mod
-
-    bash_mod._BashSession.start = _dummy_start  # type: ignore[assignment]
-
-    # restart=True returns system message
-    res = await tool(command="ignored", restart=True)
-    # Check that we get content blocks with the restart message
-    assert len(res) > 0
-    text_blocks = [b for b in res if isinstance(b, TextContent)]
-    assert any("restarted" in b.text for b in text_blocks)
-
-    # Calling without command raises ToolError
-    with pytest.raises(ToolError):
-        await tool()
-
-
-@pytest.mark.asyncio
-@pytest.mark.skipif(sys.platform == "win32", reason="EditTool uses Unix commands")
-async def test_edit_tool_flow(tmp_path):
-    file_path = tmp_path / "demo.txt"
-
-    edit = EditTool()
-
-    # create
-    res = await edit(command="create", path=str(file_path), file_text="hello\nworld\n")
-    # Check for success message in content blocks
-    text_blocks = [b for b in res if isinstance(b, TextContent)]
-    assert any("created" in b.text for b in text_blocks)
-
-    # view
-    res = await edit(command="view", path=str(file_path))
-    # Check content blocks for file content
-    text_blocks = [b for b in res if isinstance(b, TextContent)]
-    combined_text = "".join(b.text for b in text_blocks)
-    assert "hello" in combined_text
-
-    # replace
-    res = await edit(command="str_replace", path=str(file_path), old_str="world", new_str="earth")
-    # Check for success message in content blocks
-    text_blocks = [b for b in res if isinstance(b, TextContent)]
-    combined_text = "".join(b.text for b in text_blocks)
-    assert "has been edited" in combined_text
-
-    # insert
-    res = await edit(command="insert", path=str(file_path), insert_line=1, new_str="first line\n")
-    assert res
-
-
-@pytest.mark.asyncio
-async def test_base_executor_simulation():
-    from hud.tools.executors.base import BaseExecutor
-
-    exec = BaseExecutor()
-    res = await exec.execute("echo test")
-    assert "SIMULATED" in (res.output or "")
-    shot = await exec.screenshot()
-    assert isinstance(shot, str) and len(shot) > 0
-
-
-@pytest.mark.asyncio
-@pytest.mark.skipif(sys.platform == "win32", reason="EditTool uses Unix commands")
-async def test_edit_tool_view(tmp_path):
-    # Create a temporary file
-    p = tmp_path / "sample.txt"
-    p.write_text("Sample content\n")
-
-    tool = EditTool()
-    result = await tool(command="view", path=str(p))
-    # Check content blocks for file content
-    text_blocks = [b for b in result if isinstance(b, TextContent)]
-    combined_text = "".join(b.text for b in text_blocks)
-    assert "Sample content" in combined_text
-
-
-@pytest.mark.asyncio
-async def test_computer_tool_screenshot():
-    comp = HudComputerTool()
-    blocks = await comp(action="screenshot")
-    # Check that we got content blocks back
-    assert blocks is not None
-    assert len(blocks) > 0
-    # Either ImageContent or TextContent is valid
-    assert all(isinstance(b, (ImageContent | TextContent)) for b in blocks)
+from __future__ import annotations
+
+import sys
+
+import pytest
+from mcp.types import ImageContent, TextContent
+
+from hud.tools.bash import BashTool
+from hud.tools.computer.hud import HudComputerTool
+from hud.tools.edit import EditTool
+
+
+@pytest.mark.asyncio
+async def test_bash_tool_echo():
+    tool = BashTool()
+
+    # Monkey-patch the private _session methods so no subprocess is spawned
+    from hud.tools.types import ContentResult
+
+    class _FakeSession:
+        async def run(self, cmd: str):
+            return ContentResult(output=f"mocked: {cmd}")
+
+        async def start(self):
+            return None
+
+    tool.session = _FakeSession()  # type: ignore[assignment]
+
+    result = await tool(command="echo hello")
+    assert len(result) > 0
+    assert isinstance(result[0], TextContent)
+    assert result[0].text == "mocked: echo hello"
+
+
+@pytest.mark.asyncio
+async def test_bash_tool_restart_and_no_command():
+    from hud.tools.types import ToolError
+
+    tool = BashTool()
+
+    from hud.tools.types import ContentResult
+
+    class _FakeSession:
+        async def run(self, cmd: str):
+            return ContentResult(output="ran")
+
+        async def start(self):
+            return None
+
+        def stop(self):
+            return None
+
+    tool.session = _FakeSession()  # type: ignore[assignment]
+
+    # Monkey-patch _BashSession.start to avoid launching a real shell
+    async def _dummy_start(self):
+        self._started = True
+        from types import SimpleNamespace
+
+        # minimal fake process attributes used later
+        self._process = SimpleNamespace(returncode=None)
+
+    import hud.tools.bash as bash_mod
+
+    bash_mod._BashSession.start = _dummy_start  # type: ignore[assignment]
+
+    # restart=True returns system message
+    res = await tool(command="ignored", restart=True)
+    # Check that we get content blocks with the restart message
+    assert len(res) > 0
+    text_blocks = [b for b in res if isinstance(b, TextContent)]
+    assert any("restarted" in b.text for b in text_blocks)
+
+    # Calling without command raises ToolError
+    with pytest.raises(ToolError):
+        await tool()
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(sys.platform == "win32", reason="EditTool uses Unix commands")
+async def test_edit_tool_flow(tmp_path):
+    file_path = tmp_path / "demo.txt"
+
+    edit = EditTool()
+
+    # create
+    res = await edit(command="create", path=str(file_path), file_text="hello\nworld\n")
+    # Check for success message in content blocks
+    text_blocks = [b for b in res if isinstance(b, TextContent)]
+    assert any("created" in b.text for b in text_blocks)
+
+    # view
+    res = await edit(command="view", path=str(file_path))
+    # Check content blocks for file content
+    text_blocks = [b for b in res if isinstance(b, TextContent)]
+    combined_text = "".join(b.text for b in text_blocks)
+    assert "hello" in combined_text
+
+    # replace
+    res = await edit(command="str_replace", path=str(file_path), old_str="world", new_str="earth")
+    # Check for success message in content blocks
+    text_blocks = [b for b in res if isinstance(b, TextContent)]
+    combined_text = "".join(b.text for b in text_blocks)
+    assert "has been edited" in combined_text
+
+    # insert
+    res = await edit(command="insert", path=str(file_path), insert_line=1, new_str="first line\n")
+    assert res
+
+
+@pytest.mark.asyncio
+async def test_base_executor_simulation():
+    from hud.tools.executors.base import BaseExecutor
+
+    exec = BaseExecutor()
+    res = await exec.execute("echo test")
+    assert "SIMULATED" in (res.output or "")
+    shot = await exec.screenshot()
+    assert isinstance(shot, str) and len(shot) > 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.skipif(sys.platform == "win32", reason="EditTool uses Unix commands")
+async def test_edit_tool_view(tmp_path):
+    # Create a temporary file
+    p = tmp_path / "sample.txt"
+    p.write_text("Sample content\n")
+
+    tool = EditTool()
+    result = await tool(command="view", path=str(p))
+    # Check content blocks for file content
+    text_blocks = [b for b in result if isinstance(b, TextContent)]
+    combined_text = "".join(b.text for b in text_blocks)
+    assert "Sample content" in combined_text
+
+
+@pytest.mark.asyncio
+async def test_computer_tool_screenshot():
+    comp = HudComputerTool()
+    blocks = await comp(action="screenshot")
+    # Check that we got content blocks back
+    assert blocks is not None
+    assert len(blocks) > 0
+    # Either ImageContent or TextContent is valid
+    assert all(isinstance(b, (ImageContent | TextContent)) for b in blocks)