hud-python 0.2.10__py3-none-any.whl → 0.3.0__py3-none-any.whl

hud/tools/executors/tests/test_base_executor.py

@@ -0,0 +1,338 @@
+"""Tests for BaseExecutor."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+
+from hud.tools.base import ToolResult
+from hud.tools.executors.base import BaseExecutor
+
+
+class TestBaseExecutor:
+    """Tests for BaseExecutor simulated actions."""
+
+    def test_init(self):
+        """Test BaseExecutor initialization."""
+        # Without display num
+        executor = BaseExecutor()
+        assert executor.display_num is None
+        assert executor._screenshot_delay == 0.5
+
+        # With display num
+        executor = BaseExecutor(display_num=1)
+        assert executor.display_num == 1
+
+    @pytest.mark.asyncio
+    async def test_click_basic(self):
+        """Test basic click action."""
+        executor = BaseExecutor()
+        result = await executor.click(x=100, y=200, button="left", take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Click at (100, 200) with left button"
+        assert result.base64_image is None  # No screenshot requested
+
+    @pytest.mark.asyncio
+    async def test_click_with_screenshot(self):
+        """Test click with screenshot."""
+        executor = BaseExecutor()
+        result = await executor.click(x=100, y=200, take_screenshot=True)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Click at (100, 200) with left button"
+        assert result.base64_image is not None  # Screenshot included
+
+    @pytest.mark.asyncio
+    async def test_click_with_pattern(self):
+        """Test click with multi-click pattern."""
+        executor = BaseExecutor()
+        result = await executor.click(x=100, y=200, pattern=[100, 50], take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output is not None
+        assert (
+            "[SIMULATED] Click at (100, 200) with left button (multi-click pattern: [100, 50])"
+            in result.output
+        )
+
+    @pytest.mark.asyncio
+    async def test_click_with_hold_keys(self):
+        """Test click while holding keys."""
+        executor = BaseExecutor()
+        result = await executor.click(
+            x=100, y=200, hold_keys=["ctrl", "shift"], take_screenshot=False
+        )
+
+        assert isinstance(result, ToolResult)
+        assert result.output is not None
+        assert "while holding ['ctrl', 'shift']" in result.output
+
+    @pytest.mark.asyncio
+    async def test_type_basic(self):
+        """Test basic typing."""
+        executor = BaseExecutor()
+        result = await executor.type("Hello World", take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Type 'Hello World'"
+
+    @pytest.mark.asyncio
+    async def test_type_with_enter(self):
+        """Test typing with enter."""
+        executor = BaseExecutor()
+        result = await executor.type("Hello", enter_after=True, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Type 'Hello' followed by Enter"
+
+    @pytest.mark.asyncio
+    async def test_press_keys(self):
+        """Test pressing key combination."""
+        executor = BaseExecutor()
+        result = await executor.press(["ctrl", "c"], take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Press key combination: ctrl+c"
+
+    @pytest.mark.asyncio
+    async def test_key_single(self):
+        """Test pressing single key."""
+        executor = BaseExecutor()
+        result = await executor.key("Return", take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Press key: Return"
+
+    @pytest.mark.asyncio
+    async def test_keydown(self):
+        """Test key down action."""
+        executor = BaseExecutor()
+        result = await executor.keydown(["shift", "ctrl"], take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Key down: shift, ctrl"
+
+    @pytest.mark.asyncio
+    async def test_keyup(self):
+        """Test key up action."""
+        executor = BaseExecutor()
+        result = await executor.keyup(["shift", "ctrl"], take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Key up: shift, ctrl"
+
+    @pytest.mark.asyncio
+    async def test_scroll_basic(self):
+        """Test basic scroll."""
+        executor = BaseExecutor()
+        result = await executor.scroll(x=100, y=200, scroll_y=5, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output is not None
+        assert "[SIMULATED] Scroll at (100, 200)" in result.output
+        assert "vertically by 5" in result.output
+
+    @pytest.mark.asyncio
+    async def test_scroll_horizontal(self):
+        """Test horizontal scroll."""
+        executor = BaseExecutor()
+        result = await executor.scroll(scroll_x=10, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output is not None
+        assert "[SIMULATED] Scroll" in result.output
+        assert "horizontally by 10" in result.output
+
+    @pytest.mark.asyncio
+    async def test_scroll_with_hold_keys(self):
+        """Test scroll with held keys."""
+        executor = BaseExecutor()
+        result = await executor.scroll(
+            x=100, y=200, scroll_y=5, hold_keys=["shift"], take_screenshot=False
+        )
+
+        assert isinstance(result, ToolResult)
+        assert result.output is not None
+        assert "while holding ['shift']" in result.output
+
+    @pytest.mark.asyncio
+    async def test_move_absolute(self):
+        """Test absolute mouse movement."""
+        executor = BaseExecutor()
+        result = await executor.move(x=300, y=400, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Move mouse to (300, 400)"
+
+    @pytest.mark.asyncio
+    async def test_move_relative(self):
+        """Test relative mouse movement."""
+        executor = BaseExecutor()
+        result = await executor.move(offset_x=50, offset_y=-30, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Move mouse by offset (50, -30)"
+
+    @pytest.mark.asyncio
+    async def test_move_no_coords(self):
+        """Test move with no coordinates."""
+        executor = BaseExecutor()
+        result = await executor.move(take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Move mouse (no coordinates specified)"
+
+    @pytest.mark.asyncio
+    async def test_drag_basic(self):
+        """Test basic drag operation."""
+        executor = BaseExecutor()
+        path = [(100, 100), (200, 200)]
+        result = await executor.drag(path, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Drag from (100, 100) to (200, 200)"
+
+    @pytest.mark.asyncio
+    async def test_drag_with_intermediate_points(self):
+        """Test drag with intermediate points."""
+        executor = BaseExecutor()
+        path = [(100, 100), (150, 150), (200, 200)]
+        result = await executor.drag(path, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output is not None
+        assert (
+            "[SIMULATED] Drag from (100, 100) to (200, 200) via 1 intermediate points"
+            in result.output
+        )
+
+    @pytest.mark.asyncio
+    async def test_drag_invalid_path(self):
+        """Test drag with invalid path."""
+        executor = BaseExecutor()
+        result = await executor.drag([(100, 100)], take_screenshot=False)  # Only one point
+
+        assert isinstance(result, ToolResult)
+        assert result.error == "Drag path must have at least 2 points"
+        assert result.output is None
+
+    @pytest.mark.asyncio
+    async def test_drag_with_hold_keys(self):
+        """Test drag with held keys."""
+        executor = BaseExecutor()
+        path = [(100, 100), (200, 200)]
+        result = await executor.drag(path, hold_keys=["alt"], take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output is not None
+        assert "while holding ['alt']" in result.output
+
+    @pytest.mark.asyncio
+    async def test_mouse_down(self):
+        """Test mouse down action."""
+        executor = BaseExecutor()
+        result = await executor.mouse_down(button="right", take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Mouse down: right button"
+
+    @pytest.mark.asyncio
+    async def test_mouse_up(self):
+        """Test mouse up action."""
+        executor = BaseExecutor()
+        result = await executor.mouse_up(button="middle", take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Mouse up: middle button"
+
+    @pytest.mark.asyncio
+    async def test_hold_key(self):
+        """Test holding a key for duration."""
+        executor = BaseExecutor()
+
+        # Mock sleep to avoid actual wait
+        with patch("asyncio.sleep") as mock_sleep:
+            result = await executor.hold_key("shift", 0.5, take_screenshot=False)
+
+            assert isinstance(result, ToolResult)
+            assert result.output == "[SIMULATED] Hold key 'shift' for 0.5 seconds"
+            mock_sleep.assert_called_once_with(0.5)
+
+    @pytest.mark.asyncio
+    async def test_wait(self):
+        """Test wait action."""
+        executor = BaseExecutor()
+
+        # Mock sleep to avoid actual wait
+        with patch("asyncio.sleep") as mock_sleep:
+            result = await executor.wait(1000)  # 1000ms
+
+            assert isinstance(result, ToolResult)
+            assert result.output == "Waited 1000ms"
+            mock_sleep.assert_called_once_with(1.0)
+
+    @pytest.mark.asyncio
+    async def test_screenshot(self):
+        """Test screenshot action."""
+        executor = BaseExecutor()
+        result = await executor.screenshot()
+
+        assert isinstance(result, str)
+        # Check it's a valid base64 string (starts with PNG header)
+        assert result.startswith("iVBORw0KGgo")
+
+    @pytest.mark.asyncio
+    async def test_position(self):
+        """Test getting cursor position."""
+        executor = BaseExecutor()
+        result = await executor.position()
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Mouse position: (0, 0)"
+
+    @pytest.mark.asyncio
+    async def test_execute(self):
+        """Test execute command."""
+        executor = BaseExecutor()
+        result = await executor.execute("custom command", take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Execute: custom command"
+
+    @pytest.mark.asyncio
+    async def test_type_text_alias(self):
+        """Test type_text alias method."""
+        executor = BaseExecutor()
+        result = await executor.type_text("test", delay=20, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Type 'test'"
+
+    @pytest.mark.asyncio
+    async def test_mouse_move_alias(self):
+        """Test mouse_move alias method."""
+        executor = BaseExecutor()
+        result = await executor.mouse_move(100, 200, take_screenshot=False)
+
+        assert isinstance(result, ToolResult)
+        assert result.output == "[SIMULATED] Move mouse to (100, 200)"
+
+    @pytest.mark.asyncio
+    async def test_multiple_actions_with_screenshots(self):
+        """Test multiple actions with screenshots to ensure consistency."""
+        executor = BaseExecutor()
+
+        # Test that screenshots are consistent
+        screenshot1 = await executor.screenshot()
+        screenshot2 = await executor.screenshot()
+
+        assert screenshot1 == screenshot2  # Simulated screenshots should be identical
+
+        # Test actions with screenshots
+        result1 = await executor.click(10, 20, take_screenshot=True)
+        result2 = await executor.type("test", take_screenshot=True)
+
+        assert result1.base64_image == screenshot1
+        assert result2.base64_image == screenshot1

hud/tools/executors/tests/test_pyautogui_executor.py

@@ -0,0 +1,162 @@
+"""Tests for PyAutoGUI executor."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from hud.tools.base import ToolResult
+from hud.tools.executors.pyautogui import PYAUTOGUI_AVAILABLE, PyAutoGUIExecutor
+
+
+class TestPyAutoGUIExecutor:
+    """Tests for PyAutoGUIExecutor."""
+
+    def test_is_available(self):
+        """Test is_available method."""
+        # The availability is determined by the module-level PYAUTOGUI_AVAILABLE
+        assert PyAutoGUIExecutor.is_available() == PYAUTOGUI_AVAILABLE
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_screenshot_with_pyautogui(self):
+        """Test screenshot when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        # Mock pyautogui screenshot
+        with patch("pyautogui.screenshot") as mock_screenshot:
+            mock_img = MagicMock()
+            mock_img.save = MagicMock()
+            mock_screenshot.return_value = mock_img
+
+            result = await executor.screenshot()
+
+            # screenshot() returns a base64 string, not a ToolResult
+            assert isinstance(result, str)
+            mock_screenshot.assert_called_once()
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_click_with_pyautogui(self):
+        """Test click when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        with patch("pyautogui.click") as mock_click:
+            result = await executor.click(100, 200, "left")
+
+            assert isinstance(result, ToolResult)
+            assert result.output and "Clicked" in result.output
+            mock_click.assert_called_once_with(x=100, y=200, button="left")
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_type_text_with_pyautogui(self):
+        """Test type when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        with patch("pyautogui.typewrite") as mock_type:
+            result = await executor.type("Hello world")
+
+            assert isinstance(result, ToolResult)
+            assert result.output and "Typed" in result.output
+            # The implementation adds interval=0.012 (12ms converted to seconds)
+            mock_type.assert_called_once_with("Hello world", interval=0.012)
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_press_keys_with_pyautogui(self):
+        """Test press when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        # For key combinations, the implementation uses hotkey
+        with patch("pyautogui.hotkey") as mock_hotkey:
+            result = await executor.press(["ctrl", "a"])
+
+            assert isinstance(result, ToolResult)
+            assert result.output and "Pressed" in result.output
+            mock_hotkey.assert_called_once_with("ctrl", "a")
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_scroll_with_pyautogui(self):
+        """Test scroll when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        with patch("pyautogui.moveTo") as mock_move, patch("pyautogui.scroll") as mock_scroll:
+            result = await executor.scroll(100, 200, scroll_y=5)
+
+            assert isinstance(result, ToolResult)
+            assert result.output and "Scrolled" in result.output
+            # First moves to position
+            mock_move.assert_called_once_with(100, 200)
+            # Then scrolls (note: implementation negates scroll_y)
+            mock_scroll.assert_called_once_with(-5)
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_move_with_pyautogui(self):
+        """Test move when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        with patch("pyautogui.moveTo") as mock_move:
+            result = await executor.move(300, 400)
+
+            assert isinstance(result, ToolResult)
+            assert result.output and "Moved" in result.output
+            # The implementation adds duration=0.1
+            mock_move.assert_called_once_with(300, 400, duration=0.1)
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_drag_with_pyautogui(self):
+        """Test drag when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        with patch("pyautogui.dragTo") as mock_drag:
+            # drag expects a path (list of coordinate tuples)
+            path = [(100, 100), (300, 400)]
+            result = await executor.drag(path)
+
+            assert isinstance(result, ToolResult)
+            assert result.output and "Dragged" in result.output
+            # Implementation uses dragTo to move to each point
+            mock_drag.assert_called()
+
+    @pytest.mark.asyncio
+    async def test_wait(self):
+        """Test wait method."""
+        executor = PyAutoGUIExecutor()
+
+        # Mock asyncio.sleep
+        with patch("asyncio.sleep", new_callable=AsyncMock) as mock_sleep:
+            # wait expects time in milliseconds
+            result = await executor.wait(2500)  # 2500ms = 2.5s
+
+            assert isinstance(result, ToolResult)
+            assert result.output and "Waited" in result.output
+            # Implementation converts to seconds
+            mock_sleep.assert_called_once_with(2.5)
+
+    @pytest.mark.skipif(not PYAUTOGUI_AVAILABLE, reason="pyautogui not available")
+    @pytest.mark.asyncio
+    async def test_position_with_pyautogui(self):
+        """Test position when pyautogui is available."""
+        executor = PyAutoGUIExecutor()
+
+        with patch("pyautogui.position") as mock_position:
+            mock_position.return_value = (123, 456)
+            result = await executor.position()
+
+            assert isinstance(result, ToolResult)
+            assert result.output is not None
+            assert "Mouse position" in result.output
+            assert "123" in result.output
+            assert "456" in result.output
+            mock_position.assert_called_once()
+
+    def test_init_with_display_num(self):
+        """Test initialization with display number."""
+        # Should not raise
+        executor = PyAutoGUIExecutor(display_num=0)
+        assert executor.display_num == 0