hud-python 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

hud/tools/tests/test_tools.py

@@ -1,157 +1,145 @@
-from __future__ import annotations
-
-import asyncio
-import inspect
-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
-from hud.tools.helper import register_instance_tool
-
-
-@pytest.mark.asyncio
-async def test_bash_tool_echo():
-    tool = BashTool()
-
-    # Monkey-patch the private _session methods so no subprocess is spawned
-    class _FakeSession:
-        async def run(self, cmd: str):
-            from hud.tools.base import ToolResult
-
-            return ToolResult(output=f"mocked: {cmd}")
-
-        async def start(self):
-            return None
-
-    tool._session = _FakeSession()  # type: ignore[attr-defined]
-
-    result = await tool(command="echo hello")
-    assert result.output == "mocked: echo hello"
-
-
-@pytest.mark.asyncio
-async def test_bash_tool_restart_and_no_command():
-    from hud.tools.base import ToolError, ToolResult
-
-    tool = BashTool()
-
-    class _FakeSession:
-        async def run(self, cmd: str):
-            return ToolResult(output="ran")
-
-        async def start(self):
-            return None
-
-        def stop(self):
-            return None
-
-    tool._session = _FakeSession()  # type: ignore[attr-defined]
-
-    # 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)
-    assert res.system == "tool has been restarted."
-
-    # 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")
-    assert "File created" in (res.output or "")
-
-    # view
-    res = await edit(command="view", path=str(file_path))
-    assert "hello" in (res.output or "")
-
-    # replace
-    res = await edit(command="str_replace", path=str(file_path), old_str="world", new_str="earth")
-    assert "has been edited" in (res.output or "")
-
-    # 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))
-    assert result.output is not None
-    assert "Sample content" in result.output
-
-
-@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)
-
-
-def test_register_instance_tool_signature():
-    """Helper should expose same user-facing parameters (no *args/**kwargs)."""
-
-    class Dummy:
-        async def __call__(self, *, x: int, y: str) -> str:
-            return f"{x}-{y}"
-
-    from mcp.server.fastmcp import FastMCP
-
-    mcp = FastMCP("test")
-    fn = register_instance_tool(mcp, "dummy", Dummy())
-    sig = inspect.signature(fn)
-    params = list(sig.parameters.values())
-
-    assert [p.name for p in params] == ["x", "y"], "*args/**kwargs should be stripped"
-
-
-def test_build_server_subset():
-    """Ensure build_server registers only requested tools."""
-    from hud.tools.helper.mcp_server import build_server
-
-    mcp = build_server(["bash"])
-    names = [t.name for t in asyncio.run(mcp.list_tools())]
-    assert names == ["bash"]
+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)

hud/tools/tests/test_utils.py

@@ -1,156 +1,156 @@
-"""Tests for tools utils."""
-
-from __future__ import annotations
-
-import asyncio
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from hud.tools.utils import maybe_truncate, run
-
-
-class TestRun:
-    """Tests for the run function."""
-
-    @pytest.mark.asyncio
-    async def test_run_string_command_success(self):
-        """Test running a string command successfully."""
-        mock_proc = AsyncMock()
-        mock_proc.returncode = 0
-        mock_proc.communicate = AsyncMock(return_value=(b"output", b""))
-
-        with patch("asyncio.create_subprocess_shell", return_value=mock_proc) as mock_shell:
-            return_code, stdout, stderr = await run("echo test")
-
-            assert return_code == 0
-            assert stdout == "output"
-            assert stderr == ""
-            mock_shell.assert_called_once()
-
-    @pytest.mark.asyncio
-    async def test_run_list_command_success(self):
-        """Test running a list command successfully."""
-        mock_proc = AsyncMock()
-        mock_proc.returncode = 0
-        mock_proc.communicate = AsyncMock(return_value=(b"hello world", b""))
-
-        with patch("asyncio.create_subprocess_exec", return_value=mock_proc) as mock_exec:
-            return_code, stdout, stderr = await run(["echo", "hello", "world"])
-
-            assert return_code == 0
-            assert stdout == "hello world"
-            assert stderr == ""
-            mock_exec.assert_called_once_with(
-                "echo",
-                "hello",
-                "world",
-                stdin=None,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-            )
-
-    @pytest.mark.asyncio
-    async def test_run_with_input(self):
-        """Test running a command with input."""
-        mock_proc = AsyncMock()
-        mock_proc.returncode = 0
-        mock_proc.communicate = AsyncMock(return_value=(b"processed", b""))
-
-        with patch("asyncio.create_subprocess_shell", return_value=mock_proc):
-            return_code, stdout, stderr = await run("cat", input="test input")
-
-            assert return_code == 0
-            assert stdout == "processed"
-            mock_proc.communicate.assert_called_once_with(input=b"test input")
-
-    @pytest.mark.asyncio
-    async def test_run_with_error(self):
-        """Test running a command that returns an error."""
-        mock_proc = AsyncMock()
-        mock_proc.returncode = 1
-        mock_proc.communicate = AsyncMock(return_value=(b"", b"error message"))
-
-        with patch("asyncio.create_subprocess_shell", return_value=mock_proc):
-            return_code, stdout, stderr = await run("false")
-
-            assert return_code == 1
-            assert stdout == ""
-            assert stderr == "error message"
-
-    @pytest.mark.asyncio
-    async def test_run_with_timeout(self):
-        """Test running a command with custom timeout."""
-        mock_proc = AsyncMock()
-        mock_proc.returncode = 0
-        mock_proc.communicate = AsyncMock(return_value=(b"done", b""))
-
-        with (
-            patch("asyncio.create_subprocess_shell", return_value=mock_proc),
-            patch("asyncio.wait_for") as mock_wait_for,
-        ):
-            mock_wait_for.return_value = (b"done", b"")
-
-            return_code, stdout, stderr = await run("sleep 1", timeout=5.0)
-
-            # Check that wait_for was called with the correct timeout
-            mock_wait_for.assert_called_once()
-            assert mock_wait_for.call_args[1]["timeout"] == 5.0
-
-    @pytest.mark.asyncio
-    async def test_run_timeout_exception(self):
-        """Test running a command that times out."""
-        mock_proc = AsyncMock()
-
-        with (
-            patch("asyncio.create_subprocess_shell", return_value=mock_proc),
-            patch("asyncio.wait_for", side_effect=TimeoutError()),
-            pytest.raises(asyncio.TimeoutError),
-        ):
-            await run("sleep infinity", timeout=0.1)
-
-
-class TestMaybeTruncate:
-    """Tests for the maybe_truncate function."""
-
-    def test_maybe_truncate_short_text(self):
-        """Test that short text is not truncated."""
-        text = "This is a short text"
-        result = maybe_truncate(text)
-        assert result == text
-
-    def test_maybe_truncate_long_text_default(self):
-        """Test that long text is truncated with default limit."""
-        text = "x" * 30000  # Much longer than default limit
-        result = maybe_truncate(text)
-
-        assert len(result) < len(text)
-        assert result.endswith("... (truncated)")
-        assert len(result) == 20480 + len("... (truncated)")
-
-    def test_maybe_truncate_custom_limit(self):
-        """Test truncation with custom limit."""
-        text = "abcdefghijklmnopqrstuvwxyz"
-        result = maybe_truncate(text, max_length=10)
-
-        assert result == "abcdefghij... (truncated)"
-
-    def test_maybe_truncate_exact_limit(self):
-        """Test text exactly at limit is not truncated."""
-        text = "x" * 100
-        result = maybe_truncate(text, max_length=100)
-
-        assert result == text
-
-    def test_maybe_truncate_empty_string(self):
-        """Test empty string handling."""
-        result = maybe_truncate("")
-        assert result == ""
-
-    def test_maybe_truncate_unicode(self):
-        """Test truncation with unicode characters."""
-        text = "🎉" * 5000
-        result = maybe_truncate(text, max_length=10)
-
-        assert len(result) > 10  # Because of "... (truncated)" suffix
-        assert result.endswith("... (truncated)")
+"""Tests for tools utils."""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from hud.tools.utils import maybe_truncate, run
+
+
+class TestRun:
+    """Tests for the run function."""
+
+    @pytest.mark.asyncio
+    async def test_run_string_command_success(self):
+        """Test running a string command successfully."""
+        mock_proc = AsyncMock()
+        mock_proc.returncode = 0
+        mock_proc.communicate = AsyncMock(return_value=(b"output", b""))
+
+        with patch("asyncio.create_subprocess_shell", return_value=mock_proc) as mock_shell:
+            return_code, stdout, stderr = await run("echo test")
+
+            assert return_code == 0
+            assert stdout == "output"
+            assert stderr == ""
+            mock_shell.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_run_list_command_success(self):
+        """Test running a list command successfully."""
+        mock_proc = AsyncMock()
+        mock_proc.returncode = 0
+        mock_proc.communicate = AsyncMock(return_value=(b"hello world", b""))
+
+        with patch("asyncio.create_subprocess_exec", return_value=mock_proc) as mock_exec:
+            return_code, stdout, stderr = await run(["echo", "hello", "world"])
+
+            assert return_code == 0
+            assert stdout == "hello world"
+            assert stderr == ""
+            mock_exec.assert_called_once_with(
+                "echo",
+                "hello",
+                "world",
+                stdin=None,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+    @pytest.mark.asyncio
+    async def test_run_with_input(self):
+        """Test running a command with input."""
+        mock_proc = AsyncMock()
+        mock_proc.returncode = 0
+        mock_proc.communicate = AsyncMock(return_value=(b"processed", b""))
+
+        with patch("asyncio.create_subprocess_shell", return_value=mock_proc):
+            return_code, stdout, stderr = await run("cat", input="test input")
+
+            assert return_code == 0
+            assert stdout == "processed"
+            mock_proc.communicate.assert_called_once_with(input=b"test input")
+
+    @pytest.mark.asyncio
+    async def test_run_with_error(self):
+        """Test running a command that returns an error."""
+        mock_proc = AsyncMock()
+        mock_proc.returncode = 1
+        mock_proc.communicate = AsyncMock(return_value=(b"", b"error message"))
+
+        with patch("asyncio.create_subprocess_shell", return_value=mock_proc):
+            return_code, stdout, stderr = await run("false")
+
+            assert return_code == 1
+            assert stdout == ""
+            assert stderr == "error message"
+
+    @pytest.mark.asyncio
+    async def test_run_with_timeout(self):
+        """Test running a command with custom timeout."""
+        mock_proc = AsyncMock()
+        mock_proc.returncode = 0
+        mock_proc.communicate = AsyncMock(return_value=(b"done", b""))
+
+        with (
+            patch("asyncio.create_subprocess_shell", return_value=mock_proc),
+            patch("asyncio.wait_for") as mock_wait_for,
+        ):
+            mock_wait_for.return_value = (b"done", b"")
+
+            return_code, stdout, stderr = await run("sleep 1", timeout=5.0)
+
+            # Check that wait_for was called with the correct timeout
+            mock_wait_for.assert_called_once()
+            assert mock_wait_for.call_args[1]["timeout"] == 5.0
+
+    @pytest.mark.asyncio
+    async def test_run_timeout_exception(self):
+        """Test running a command that times out."""
+        mock_proc = AsyncMock()
+
+        with (
+            patch("asyncio.create_subprocess_shell", return_value=mock_proc),
+            patch("asyncio.wait_for", side_effect=TimeoutError()),
+            pytest.raises(asyncio.TimeoutError),
+        ):
+            await run("sleep infinity", timeout=0.1)
+
+
+class TestMaybeTruncate:
+    """Tests for the maybe_truncate function."""
+
+    def test_maybe_truncate_short_text(self):
+        """Test that short text is not truncated."""
+        text = "This is a short text"
+        result = maybe_truncate(text)
+        assert result == text
+
+    def test_maybe_truncate_long_text_default(self):
+        """Test that long text is truncated with default limit."""
+        text = "x" * 30000  # Much longer than default limit
+        result = maybe_truncate(text)
+
+        assert len(result) < len(text)
+        assert result.endswith("... (truncated)")
+        assert len(result) == 20480 + len("... (truncated)")
+
+    def test_maybe_truncate_custom_limit(self):
+        """Test truncation with custom limit."""
+        text = "abcdefghijklmnopqrstuvwxyz"
+        result = maybe_truncate(text, max_length=10)
+
+        assert result == "abcdefghij... (truncated)"
+
+    def test_maybe_truncate_exact_limit(self):
+        """Test text exactly at limit is not truncated."""
+        text = "x" * 100
+        result = maybe_truncate(text, max_length=100)
+
+        assert result == text
+
+    def test_maybe_truncate_empty_string(self):
+        """Test empty string handling."""
+        result = maybe_truncate("")
+        assert result == ""
+
+    def test_maybe_truncate_unicode(self):
+        """Test truncation with unicode characters."""
+        text = "🎉" * 5000
+        result = maybe_truncate(text, max_length=10)
+
+        assert len(result) > 10  # Because of "... (truncated)" suffix
+        assert result.endswith("... (truncated)")