@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/windows-computer-use-mcp/tests/test_automation_elements.py

@@ -1,138 +0,0 @@
-"""Tests for the automation_elements portmanteau tool."""
-
-from unittest.mock import MagicMock
-
-from windows_computer_use_mcp.tools.models import ElementOperationRequest
-from windows_computer_use_mcp.tools.portmanteau_elements import automation_elements
-
-
-class TestAutomationElements:
-    """Tests for automation_elements tool operations."""
-
-    def test_element_info(self, mock_desktop_uia, verify_result):
-        """Test getting detailed information about a UI element."""
-        mock_element = MagicMock()
-        mock_element.class_name.return_value = "Button"
-        mock_element.window_text.return_value = "OK"
-        mock_element.process_id.return_value = 1234
-        mock_element.handle = 12345
-        mock_element.is_visible.return_value = True
-        mock_element.is_enabled.return_value = True
-
-        mock_rect = MagicMock()
-        mock_rect.left = 100
-        mock_rect.top = 200
-        mock_rect.right = 150
-        mock_rect.bottom = 230
-        mock_rect.width.return_value = 50
-        mock_rect.height.return_value = 30
-        mock_element.rectangle.return_value = mock_rect
-
-        # Mocking the Desktop -> Window -> Child Element chain
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.child_window.return_value = mock_element
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = ElementOperationRequest(operation="info", window_handle=123, control_id="btnOK")
-        result = automation_elements(req)
-
-        verify_result(result, expected_keys=["class_name", "text", "rect"])
-        assert result.data["class_name"] == "Button"
-        assert result.data["text"] == "OK"
-
-    def test_element_click(self, mock_desktop_uia, verify_result):
-        """Test clicking a UI element by control_id."""
-        mock_element = MagicMock()
-        mock_element.exists.return_value = True
-
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.child_window.return_value = mock_element
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = ElementOperationRequest(operation="click", window_handle=123, control_id="btnOK")
-        result = automation_elements(req)
-
-        verify_result(result)
-        mock_element.click.assert_called_once()
-
-    def test_element_set_text(self, mock_desktop_uia, verify_result):
-        """Test setting text on a UI element."""
-        mock_element = MagicMock()
-        mock_element.exists.return_value = True
-
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.child_window.return_value = mock_element
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = ElementOperationRequest(operation="set_text", window_handle=123, control_id="Edit1", text="Hello World")
-        result = automation_elements(req)
-
-        verify_result(result)
-        mock_element.set_text.assert_called_once_with("Hello World")
-
-    def test_element_list(self, mock_desktop_uia, verify_result):
-        """Test listing child elements of a window."""
-        mock_child = MagicMock()
-        mock_child.class_name.return_value = "Button"
-        mock_child.window_text.return_value = "Child"
-        mock_child.process_id.return_value = 1234
-        mock_child.handle = 54321
-        mock_child.is_visible.return_value = True
-        mock_child.is_enabled.return_value = True
-        mock_child.children.return_value = []  # Terminate recursion
-
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.children.return_value = [mock_child]
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = ElementOperationRequest(operation="list", window_handle=123, max_depth=1)
-        result = automation_elements(req)
-
-        verify_result(result, expected_keys=["elements"])
-        assert len(result.data["elements"]) == 1
-        assert result.data["elements"][0]["text"] == "Child"
-
-    def test_element_exists_positive(self, mock_desktop_uia, verify_result):
-        """Test exists operation when element is found."""
-        mock_element = MagicMock()
-        mock_element.exists.return_value = True
-
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.child_window.return_value = mock_element
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = ElementOperationRequest(operation="exists", window_handle=123, control_id="btnOK", timeout=0.1)
-        result = automation_elements(req)
-
-        verify_result(result, expected_keys=["exists"])
-        assert result.data["exists"] is True
-
-    def test_element_wait_failure(self, mock_desktop_uia, verify_result):
-        """Test wait operation timeout."""
-        mock_element = MagicMock()
-        mock_element.exists.return_value = False
-
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.child_window.return_value = mock_element
-        mock_desktop_uia.window.return_value = mock_window
-
-        # Use a very short timeout for tests
-        req = ElementOperationRequest(operation="wait", window_handle=123, control_id="NonExistent", timeout=0.1)
-        result = automation_elements(req)
-
-        verify_result(result, expected_status="error")
-        assert "not found" in result.message.lower()
-
-    def test_coordinate_click_absolute(self, mock_desktop_uia, verify_result):
-        """Test clicking at absolute coordinates via automation_elements."""
-        # Note: automation_elements uses win32_mouse.click, not pyautogui.click
-        req = ElementOperationRequest(operation="click", window_handle=123, x=500, y=500, absolute=True)
-        result = automation_elements(req)
-
-        verify_result(result)

package/mcps/windows-computer-use-mcp/tests/test_automation_keyboard.py

@@ -1,57 +0,0 @@
-"""Tests for the automation_keyboard portmanteau tool."""
-
-# Imports moved into test methods to ensure mocks are applied correctly
-
-
-class TestAutomationKeyboard:
-    """Tests for automation_keyboard tool operations."""
-
-    def test_keyboard_type(self, mock_pyautogui, verify_result):
-        """Test typing text."""
-        from windows_computer_use_mcp.tools.models import KeyboardOperationRequest
-        from windows_computer_use_mcp.tools.portmanteau_keyboard import automation_keyboard
-
-        req = KeyboardOperationRequest(operation="type", text="Hello World", interval=0.1)
-        result = automation_keyboard(req)
-
-        verify_result(result)
-        mock_pyautogui.write.assert_called_once_with("Hello World", interval=0.1)
-
-    def test_keyboard_press(self, mock_pyautogui, verify_result):
-        """Test pressing a key."""
-        from windows_computer_use_mcp.tools.models import KeyboardOperationRequest
-        from windows_computer_use_mcp.tools.portmanteau_keyboard import automation_keyboard
-
-        req = KeyboardOperationRequest(operation="press", key="enter")
-        result = automation_keyboard(req)
-
-        verify_result(result)
-        mock_pyautogui.press.assert_called_once_with("enter")
-
-    def test_keyboard_hotkey(self, mock_pyautogui, verify_result):
-        """Test pressing a hotkey combination."""
-        from windows_computer_use_mcp.tools.models import KeyboardOperationRequest
-        from windows_computer_use_mcp.tools.portmanteau_keyboard import automation_keyboard
-
-        req = KeyboardOperationRequest(operation="hotkey", keys=["ctrl", "c"])
-        result = automation_keyboard(req)
-
-        verify_result(result)
-        mock_pyautogui.hotkey.assert_called_once_with("ctrl", "c")
-
-    def test_keyboard_write_pywinauto(self, mock_desktop_uia, verify_result):
-        """Test writing text via pywinauto (send_keys)."""
-        # Note: In portmanteau_keyboard, if handle is provided, it might try pywinauto
-        # But for now the implementation mostly uses pyautogui or similar.
-        # Let's verify the current implementation logic.
-        pass
-
-    def test_invalid_operation(self, verify_result):
-        """Test invalid operation error handling."""
-        import pytest
-        from pydantic import ValidationError
-
-        from windows_computer_use_mcp.tools.models import KeyboardOperationRequest
-
-        with pytest.raises(ValidationError):
-            KeyboardOperationRequest(operation="invalid_op", text="test")

package/mcps/windows-computer-use-mcp/tests/test_automation_mouse.py

@@ -1,57 +0,0 @@
-"""Tests for the automation_mouse portmanteau tool."""
-
-# Imports moved for mocking integrity
-
-
-import pytest
-
-
-class TestAutomationMouse:
-    """Tests for automation_mouse tool operations.
-
-    NOTE: Most mouse tests require mocking win32_mouse functions (click, move_to,
-    get_cursor_pos, scroll, drag). These were previously mocked via pyautogui
-    but the current implementation uses native win32_mouse. Rewrite when adding
-    new mouse tests.
-    """
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_position(self, verify_result):
-        ...
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_move_absolute(self, verify_result):
-        ...
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_move_relative(self, verify_result):
-        ...
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_click(self, verify_result):
-        ...
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_double_click(self, verify_result):
-        ...
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_right_click(self, verify_result):
-        ...
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_scroll(self, verify_result):
-        ...
-
-    @pytest.mark.skip(reason="needs win32_mouse mocking (previously used pyautogui)")
-    def test_mouse_drag(self, verify_result):
-        ...
-
-    def test_invalid_operation(self, verify_result):
-        """Test invalid operation error handling."""
-        from pydantic import ValidationError
-
-        from windows_computer_use_mcp.tools.models import MouseOperationRequest
-
-        with pytest.raises(ValidationError):
-            MouseOperationRequest(operation="invalid_op")

package/mcps/windows-computer-use-mcp/tests/test_automation_shortcut.py

@@ -1,41 +0,0 @@
-"""Tests for automation_shortcut and shortcut_engine."""
-
-from unittest.mock import patch
-
-from windows_computer_use_mcp import shortcut_engine
-from windows_computer_use_mcp.app_shortcuts.registry import get_shortcut, list_apps
-from windows_computer_use_mcp.tools.models import ShortcutOperationRequest, ToolResult
-from windows_computer_use_mcp.tools.portmanteau_shortcut import automation_shortcut
-
-
-def test_vroid_registry_export():
-    spec = get_shortcut("vroidstudio", "export_vrm")
-    assert spec.keys == "f8"
-
-
-def test_list_apps():
-    assert "vroidstudio" in list_apps()
-
-
-@patch("windows_computer_use_mcp.shortcut_engine._send_keys")
-@patch("windows_computer_use_mcp.shortcut_engine._wait_stable_after")
-def test_send_shortcut(mock_stable, mock_send):
-    mock_send.return_value = {"method": "pyautogui", "keys": ["f8"]}
-    mock_stable.return_value = {"stable": True}
-    result = shortcut_engine.send_shortcut("vroidstudio", "export_vrm", window_handle=12345, verify_stable=True)
-    assert result["action"] == "export_vrm"
-    mock_send.assert_called_once()
-
-
-def test_automation_shortcut_list():
-    req = ShortcutOperationRequest(operation="list", app="vroidstudio")
-    result = automation_shortcut(req)
-    assert isinstance(result, ToolResult)
-    assert result.status == "success"
-    assert len(result.data["shortcuts"]) > 10
-
-
-def test_automation_shortcut_unknown_action():
-    req = ShortcutOperationRequest(operation="send", app="vroidstudio", action="not_a_real_action")
-    result = automation_shortcut(req)
-    assert result.status == "error"

package/mcps/windows-computer-use-mcp/tests/test_automation_task.py

@@ -1,115 +0,0 @@
-"""Tests for automation_task and task_engine."""
-
-from pathlib import Path
-from unittest.mock import patch
-
-from windows_computer_use_mcp import task_engine
-from windows_computer_use_mcp.app_profiles import get_profile, list_profiles
-from windows_computer_use_mcp.tools.models import TaskOperationRequest, ToolResult
-from windows_computer_use_mcp.tools.portmanteau_task import automation_task
-
-
-def test_assert_outcome_file_exists(tmp_path: Path):
-    f = tmp_path / "out.vrm"
-    f.write_bytes(b"x" * 2000)
-    r = task_engine.assert_outcome("file_exists", path=str(f))
-    assert r["passed"] is True
-    r2 = task_engine.assert_outcome("file_min_kb", path=str(f), min_kb=1)
-    assert r2["passed"] is True
-
-
-def test_vroid_profile():
-    p = get_profile("vroidstudio")
-    assert p is not None
-    assert p.dispatch == "foreground"
-    assert p.stable_region is not None
-
-
-def test_list_profiles():
-    assert any(p["app_id"] == "vroidstudio" for p in list_profiles())
-
-
-@patch("windows_computer_use_mcp.task_engine._execute_step")
-def test_run_task_success(mock_exec, tmp_path: Path):
-    f = tmp_path / "model.vrm"
-    f.write_bytes(b"data")
-
-    def _fake(session, step, hwnd):
-        if step.get("kind") == "assert_file":
-            outcome = task_engine.assert_outcome("file_exists", path=step["path"])
-            if not outcome.get("passed"):
-                raise RuntimeError("assert_file failed")
-            return {"kind": "assert_file", "outcome": outcome}
-        return {"kind": "shortcut", "action": "new"}
-
-    mock_exec.side_effect = _fake
-    out = tmp_path / "evidence"
-    out.mkdir()
-    steps = [
-        {"kind": "shortcut", "action": "new", "app": "vroidstudio"},
-        {"kind": "assert_file", "path": str(f), "check": "file_exists", "on_fail": "abort"},
-    ]
-    session = task_engine.run_task(app="vroidstudio", steps=steps, output_dir=str(out))
-    assert session.status == "complete"
-    assert len(session.evidence) == 2
-
-
-@patch("windows_computer_use_mcp.task_engine._execute_step")
-def test_run_task_fails_with_evidence(mock_exec, tmp_path: Path):
-    mock_exec.side_effect = RuntimeError("shortcut missed")
-    session = task_engine.run_task(
-        app="vroidstudio",
-        steps=[{"kind": "shortcut", "action": "export_vrm", "on_fail": "abort"}],
-        output_dir=str(tmp_path),
-    )
-    assert session.status == "failed"
-    assert session.evidence[0]["status"] == "failed"
-
-
-@patch("windows_computer_use_mcp.task_engine._invalidate_snapshots_after_mutation")
-@patch("windows_computer_use_mcp.task_engine._execute_step")
-def test_run_task_invalidates_snapshots_on_mutation(mock_exec, mock_inv, tmp_path: Path):
-    mock_exec.return_value = {"kind": "shortcut", "action": "new"}
-    mock_inv.return_value = {"invalidated": 2, "ui_hash": "abc"}
-
-    session = task_engine.run_task(
-        app="vroidstudio",
-        steps=[{"kind": "shortcut", "action": "new", "app": "vroidstudio"}],
-        window_handle=12345,
-        output_dir=str(tmp_path),
-    )
-    assert session.status == "complete"
-    mock_inv.assert_called_once_with(12345)
-    assert session.evidence[0].get("snapshot_invalidation") == {"invalidated": 2, "ui_hash": "abc"}
-
-
-@patch("windows_computer_use_mcp.task_engine._execute_step")
-def test_run_task_optional_step_skipped(mock_exec, tmp_path: Path):
-    mock_exec.side_effect = RuntimeError("optional miss")
-    session = task_engine.run_task(
-        app="vroidstudio",
-        steps=[{"kind": "shortcut", "action": "rare", "optional": True, "on_fail": "abort"}],
-        output_dir=str(tmp_path),
-    )
-    assert session.status == "complete"
-    assert session.evidence[0]["status"] == "skipped_optional"
-
-
-def test_automation_task_list_profiles():
-    req = TaskOperationRequest(operation="list_profiles")
-    result = automation_task(req)
-    assert isinstance(result, ToolResult)
-    assert result.status == "success"
-    profiles = result.data["profiles"]
-    vroid = next(p for p in profiles if p["app_id"] == "vroidstudio")
-    assert "stable_region" in vroid
-
-
-def test_automation_task_list_templates():
-    from windows_computer_use_mcp.template_library import ensure_placeholder_templates
-
-    ensure_placeholder_templates("vroidstudio")
-    req = TaskOperationRequest(operation="list_templates", app="vroidstudio")
-    result = automation_task(req)
-    assert result.status == "success"
-    assert len(result.data["templates"]) >= 4

package/mcps/windows-computer-use-mcp/tests/test_automation_windows.py

@@ -1,105 +0,0 @@
-"""Tests for the automation_windows portmanteau tool."""
-
-from unittest.mock import MagicMock
-
-from windows_computer_use_mcp.tools.models import WindowOperationRequest
-from windows_computer_use_mcp.tools.portmanteau_windows import automation_windows
-
-
-class TestAutomationWindows:
-    """Tests for automation_windows tool operations."""
-
-    def test_window_list(self, mock_desktop_uia, verify_result):
-        """Test listing all visible windows."""
-        mock_window = MagicMock()
-        mock_window.window_text.return_value = "Test Window"
-        mock_window.handle = 12345
-        mock_window.class_name.return_value = "TestClass"
-        mock_window.process_id.return_value = 1000
-
-        mock_desktop_uia.windows.return_value = [mock_window]
-
-        req = WindowOperationRequest(operation="list")
-        result = automation_windows(req)
-
-        verify_result(result, expected_keys=["count", "windows"])
-        assert len(result.data["windows"]) == 1
-        assert result.data["windows"][0]["title"] == "Test Window"
-
-    def test_window_find(self, mock_desktop_uia, verify_result):
-        """Test finding a window by title + class (bypasses pygetwindow fast path)."""
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.handle = 12345
-        mock_window.window_text.return_value = "Notepad"
-        mock_window.class_name.return_value = "NotepadClass"
-
-        mock_desktop_uia.windows.return_value = [mock_window]
-
-        req = WindowOperationRequest(operation="find", title="Notepad", class_name="NotepadClass")
-        result = automation_windows(req)
-
-        verify_result(result, expected_keys=["count", "windows"])
-        assert result.data["count"] >= 1
-        assert result.data["windows"][0]["handle"] == 12345
-
-    def test_window_maximize(self, mock_desktop_uia, verify_result):
-        """Test maximizing a window."""
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = WindowOperationRequest(operation="maximize", handle=12345)
-        result = automation_windows(req)
-
-        verify_result(result)
-        mock_window.maximize.assert_called_once()
-
-    def test_window_minimize(self, mock_desktop_uia, verify_result):
-        """Test minimizing a window."""
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = WindowOperationRequest(operation="minimize", handle=12345)
-        result = automation_windows(req)
-
-        verify_result(result)
-        mock_window.minimize.assert_called_once()
-
-    def test_window_close(self, mock_desktop_uia, verify_result):
-        """Test closing a window."""
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = WindowOperationRequest(operation="close", handle=12345)
-        result = automation_windows(req)
-
-        verify_result(result)
-        mock_window.close.assert_called_once()
-
-    def test_window_position(self, mock_desktop_uia, verify_result):
-        """Test moving and resizing a window."""
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = WindowOperationRequest(operation="position", handle=12345, x=100, y=100, width=800, height=600)
-        result = automation_windows(req)
-
-        verify_result(result)
-        mock_window.move_window.assert_called_once_with(x=100, y=100, width=800, height=600)
-
-    def test_window_title(self, mock_desktop_uia, verify_result):
-        """Test getting window title."""
-        mock_window = MagicMock()
-        mock_window.exists.return_value = True
-        mock_window.window_text.return_value = "Test Window Title"
-        mock_desktop_uia.window.return_value = mock_window
-
-        req = WindowOperationRequest(operation="title", handle=12345)
-        result = automation_windows(req)
-
-        verify_result(result, expected_keys=["title"])
-        assert result.data["title"] == "Test Window Title"

package/mcps/windows-computer-use-mcp/tests/test_cameras_api.py

@@ -1,43 +0,0 @@
-"""Camera REST API — mocked in CI; optional real OpenCV probe locally."""
-
-from __future__ import annotations
-
-from unittest.mock import patch
-
-import pytest
-from fastapi.testclient import TestClient
-
-from windows_computer_use_mcp.api.v1.endpoints.cameras import CameraDevice
-from windows_computer_use_mcp.server import app
-
-
-@pytest.fixture
-def client() -> TestClient:
-    return TestClient(app)
-
-
-def test_cameras_get_returns_json(client: TestClient) -> None:
-    """Always runs — mocks enumeration so CI never opens devices."""
-    fake = [
-        CameraDevice(index=0, label="Camera 0 (640x480)", width=640, height=480),
-        CameraDevice(index=1, label="Camera 1 (320x240)", width=320, height=240),
-    ]
-    with patch("windows_computer_use_mcp.api.v1.endpoints.cameras.enumerate_cameras", return_value=fake):
-        r = client.get("/api/v1/cameras/")
-    assert r.status_code == 200
-    data = r.json()
-    assert len(data) == 2
-    assert data[0]["index"] == 0
-    assert "640" in data[0]["label"]
-
-
-@pytest.mark.requires_hardware
-def test_enumerate_cameras_runs_on_local_host() -> None:
-    """Outside CI: actually probes OpenCV indices (can be slow; may return [])."""
-    from windows_computer_use_mcp.api.v1.endpoints.cameras import enumerate_cameras
-
-    devices = enumerate_cameras()
-    assert isinstance(devices, list)
-    for d in devices:
-        assert d.index >= 0
-        assert d.label

package/mcps/windows-computer-use-mcp/tests/test_cua_parity.py

@@ -1,51 +0,0 @@
-"""Tests for Cua Driver parity helpers."""
-
-from windows_computer_use_mcp.desktop_state.capture import _legacy_capture_mode, normalize_elements_for_snapshot
-from windows_computer_use_mcp.dispatch import (
-    BACKGROUND_UNAVAILABLE,
-    background_unavailable_result,
-    default_dispatch_mode,
-    resolve_dispatch,
-)
-from windows_computer_use_mcp.snapshot_store import SnapshotStore
-
-
-def test_legacy_capture_mode():
-    assert _legacy_capture_mode(False, False) == "ax"
-    assert _legacy_capture_mode(True, False) == "som"
-    assert _legacy_capture_mode(False, True) == "som"
-
-
-def test_normalize_elements_for_snapshot():
-    raw = [{"type": "Button", "id": 0}, {"type": "Edit", "id": 1}]
-    out = normalize_elements_for_snapshot(raw)
-    assert out[0]["element_index"] == 0
-    assert out[1]["element_index"] == 1
-    assert "id" not in out[0]
-
-
-def test_snapshot_store_roundtrip():
-    store = SnapshotStore(max_snapshots=2)
-    sid = store.put(
-        window_handle=100,
-        capture_mode="ax",
-        elements=[{"element_index": 0, "type": "Button"}],
-    )
-    snap = store.get(sid)
-    assert snap is not None
-    assert snap.window_handle == 100
-    elem = store.resolve_element(sid, 0)
-    assert elem is not None
-    assert elem["type"] == "Button"
-
-
-def test_resolve_dispatch_explicit():
-    assert resolve_dispatch("background") == "background"
-    assert resolve_dispatch("foreground") == "foreground"
-    assert default_dispatch_mode() == "foreground"
-
-
-def test_background_unavailable_shape():
-    meta = background_unavailable_result("test reason", attempted=["invoke"])
-    assert meta["code"] == BACKGROUND_UNAVAILABLE
-    assert meta["background_unavailable"] is True

package/mcps/windows-computer-use-mcp/tests/test_dependency_failures.py

@@ -1,39 +0,0 @@
-"""Tests for dependency failure reporting and agentic recovery."""
-
-import pytest
-from unittest.mock import patch
-
-
-class TestDependencyFailures:
-    """Tests for tools with missing optional dependencies."""
-
-    @patch("windows_computer_use_mcp.tools.portmanteau_face.FACE_RECOGNITION_AVAILABLE", False)
-    def test_face_tool_missing_dependency(self, verify_result):
-        """Test that automation_face reports missing dependency correctly."""
-        # Note: We need to import inside to ensure the patch works if it was already imported
-        # Or better yet, just call the tool directly with the mock state
-        from windows_computer_use_mcp.tools.models import FaceOperationRequest
-        from windows_computer_use_mcp.tools.portmanteau_face import automation_face
-
-        req = FaceOperationRequest(operation="recognize", name="admin", image_path="test.jpg")
-        result = automation_face(req)
-
-        verify_result(result, expected_status="error", message_contains="face_recognition library is not installed")
-        assert "pip install face_recognition" in result.recovery_tip
-
-    @patch("windows_computer_use_mcp.tools.portmanteau_visual.OCR_AVAILABLE", False)
-    def test_visual_tool_missing_ocr(self, verify_result):
-        """Test that automation_visual reports missing OCR correctly."""
-        from windows_computer_use_mcp.tools.models import VisualOperationRequest
-        from windows_computer_use_mcp.tools.portmanteau_visual import automation_visual
-
-        req = VisualOperationRequest(operation="extract_text", handle=12345)
-        result = automation_visual(req)
-
-        # automation_visual should fail if OCR is requested but not available
-        verify_result(result, expected_status="error", message_contains="tesseract is not installed")
-        assert "README" in result.recovery_tip or "PATH" in result.recovery_tip or result.recovery_tip is not None
-
-    @pytest.mark.skip(reason="mission tool no longer guards on ctx=None")
-    def test_mission_tool_no_ctx(self, verify_result):
-        """Test mission fails gracefully when sampling context is missing."""