@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,99 +0,0 @@
-"""Tests for desktop state capture tools."""
-
-from unittest.mock import MagicMock, patch
-
-from windows_computer_use_mcp.tools.desktop_state import get_desktop_state
-from windows_computer_use_mcp.tools.models import DesktopStateRequest
-
-
-class TestGetDesktopState:
-    """Tests for get_desktop_state tool."""
-
-    @patch("windows_computer_use_mcp.tools.desktop_state.DesktopStateCapture")
-    def test_get_desktop_state_basic(self, mock_capture_class, verify_result):
-        """Test basic desktop state capture."""
-        mock_capturer = MagicMock()
-        mock_capturer.capture.return_value = {
-            "text": "Desktop state report",
-            "interactive_elements": [{"name": "Button1", "type": "Button"}],
-            "informative_elements": [{"name": "Label1", "type": "Text"}],
-            "element_count": 2,
-        }
-        mock_capture_class.return_value = mock_capturer
-
-        req = DesktopStateRequest()
-        result = get_desktop_state(req)
-
-        verify_result(result, expected_keys=["element_count", "interactive_elements", "informative_elements"])
-        assert result.data["element_count"] == 2
-        assert len(result.data["interactive_elements"]) == 1
-
-    @patch("windows_computer_use_mcp.tools.desktop_state.DesktopStateCapture")
-    def test_get_desktop_state_with_vision(self, mock_capture_class, verify_result):
-        """Test desktop state capture with vision enabled."""
-        mock_capturer = MagicMock()
-        mock_capturer.capture.return_value = {
-            "text": "Desktop state report",
-            "interactive_elements": [],
-            "informative_elements": [],
-            "element_count": 0,
-            "screenshot_base64": "base64encodedimage",
-        }
-        mock_capture_class.return_value = mock_capturer
-
-        req = DesktopStateRequest(use_vision=True)
-        result = get_desktop_state(req)
-
-        verify_result(result)
-        mock_capturer.capture.assert_called_once_with(use_vision=True, use_ocr=False, capture_mode=None)
-
-    @patch("windows_computer_use_mcp.tools.desktop_state.DesktopStateCapture")
-    def test_get_desktop_state_with_ocr(self, mock_capture_class, verify_result):
-        """Test desktop state capture with OCR enabled."""
-        mock_capturer = MagicMock()
-        mock_capturer.capture.return_value = {
-            "text": "Desktop state report",
-            "interactive_elements": [],
-            "informative_elements": [],
-            "element_count": 0,
-        }
-        mock_capture_class.return_value = mock_capturer
-
-        req = DesktopStateRequest(use_ocr=True)
-        result = get_desktop_state(req)
-
-        verify_result(result)
-        mock_capturer.capture.assert_called_once_with(use_vision=False, use_ocr=True, capture_mode=None)
-
-    @patch("windows_computer_use_mcp.tools.desktop_state.DesktopStateCapture")
-    def test_get_desktop_state_with_custom_depth(self, mock_capture_class, verify_result):
-        """Test desktop state capture with custom max_depth."""
-        mock_capturer = MagicMock()
-        mock_capturer.capture.return_value = {
-            "text": "Desktop state report",
-            "interactive_elements": [],
-            "informative_elements": [],
-            "element_count": 0,
-        }
-        mock_capture_class.return_value = mock_capturer
-
-        req = DesktopStateRequest(max_depth=15)
-        result = get_desktop_state(req)
-
-        verify_result(result)
-        mock_capture_class.assert_called_once_with(max_depth=15, element_timeout=0.5)
-
-    @patch("windows_computer_use_mcp.tools.desktop_state.DesktopStateCapture")
-    def test_get_desktop_state_error_handling(self, mock_capture_class, verify_result):
-        """Test desktop state capture error handling."""
-        mock_capturer = MagicMock()
-        mock_capturer.capture.side_effect = Exception("Capture failed")
-        mock_capture_class.return_value = mock_capturer
-
-        req = DesktopStateRequest()
-        result = get_desktop_state(req)
-
-        # In current industrialized version, it returns a ToolResult with status="error"
-        verify_result(result, expected_status="error")
-        # Ensure data is either None or handled safely on error
-        assert result.data is None or "handle" not in result.data

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

@@ -1,238 +0,0 @@
-"""Tests for face recognition functionality."""
-
-import os
-
-# Add the parent directory to the Python path
-import sys
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import numpy as np
-import pytest
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from windows_computer_use_mcp.face_recognition import FaceRecognition
-
-# Test data
-TEST_IMAGE_DIR = Path(__file__).parent / "test_images"
-KNOWN_FACE_IMAGE = TEST_IMAGE_DIR / "known_face.jpg"
-UNKNOWN_FACE_IMAGE = TEST_IMAGE_DIR / "unknown_face.jpg"
-
-# Use mocks for face recognition tests instead of requiring actual images
-# Tests will create mock image data when needed
-
-
-@pytest.fixture
-def face_rec():
-    """Fixture that provides a FaceRecognition instance for testing."""
-    import base64
-
-    from cryptography.fernet import Fernet
-
-    # Use a temporary directory for test data
-    with patch("windows_computer_use_mcp.face_recognition.KNOWN_FACES_DIR", Path("tests/test_data/known_faces")):
-        # Create the test directory if it doesn't exist
-        os.makedirs("tests/test_data/known_faces", exist_ok=True)
-
-        # Generate a valid Fernet key (32 bytes, base64-encoded)
-        valid_key = Fernet.generate_key()
-        # The key is already base64-encoded, but face_recognition.py expects raw bytes
-        # So we decode it to get the raw 32 bytes
-        raw_key = base64.urlsafe_b64decode(valid_key)
-
-        # Initialize with a valid encryption key (raw bytes)
-        with patch("windows_computer_use_mcp.face_recognition.ENCRYPTION_KEY", raw_key):
-            yield FaceRecognition(tolerance=0.6, model="hog")
-
-    # Cleanup: Remove test data after tests
-    import shutil
-
-    if os.path.exists("tests/test_data"):
-        shutil.rmtree("tests/test_data")
-
-
-@patch("face_recognition.face_encodings")
-@patch("face_recognition.face_locations")
-@patch("face_recognition.load_image_file")
-def test_add_known_face(mock_load_image, mock_face_locations, mock_face_encodings, face_rec):
-    """Test adding a known face."""
-    # Mock face recognition functions
-    mock_load_image.return_value = np.zeros((100, 100, 3), dtype=np.uint8)
-    mock_face_locations.return_value = [(10, 20, 30, 40)]
-    mock_face_encodings.return_value = [np.random.rand(128)]
-
-    # Test with image path (create temp file)
-    import tempfile
-
-    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
-        tmp_file.write(b"fake image data")
-        tmp_path = tmp_file.name
-
-    try:
-        success = face_rec.add_known_face("Test User", tmp_path)
-        assert success
-        assert "Test User" in face_rec.known_faces
-    finally:
-        os.unlink(tmp_path)
-
-    # Test with image data
-    mock_face_encodings.return_value = [np.random.rand(128)]
-    success = face_rec.add_known_face("Test User 2", image_data=b"fake image data")
-    assert success
-    assert "Test User 2" in face_rec.known_faces
-
-
-@patch("face_recognition.face_encodings")
-@patch("face_recognition.face_locations")
-@patch("face_recognition.load_image_file")
-def test_remove_known_face(mock_load_image, mock_face_locations, mock_face_encodings, face_rec):
-    """Test removing a known face."""
-    # Mock face recognition functions
-    mock_load_image.return_value = np.zeros((100, 100, 3), dtype=np.uint8)
-    mock_face_locations.return_value = [(10, 20, 30, 40)]
-    mock_face_encodings.return_value = [np.random.rand(128)]
-
-    # First add a face
-    import tempfile
-
-    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
-        tmp_file.write(b"fake image data")
-        tmp_path = tmp_file.name
-
-    try:
-        face_rec.add_known_face("Test User", tmp_path)
-        assert "Test User" in face_rec.known_faces
-
-        # Then remove it
-        success = face_rec.remove_known_face("Test User")
-        assert success
-        assert "Test User" not in face_rec.known_faces
-
-        # Try removing non-existent face
-        success = face_rec.remove_known_face("Non-existent User")
-        assert not success
-    finally:
-        os.unlink(tmp_path)
-
-
-@patch("face_recognition.face_encodings")
-@patch("face_recognition.face_locations")
-@patch("face_recognition.load_image_file")
-@patch("face_recognition.compare_faces")
-@patch("face_recognition.face_distance")
-def test_recognize_face(
-    mock_face_distance,
-    mock_compare_faces,
-    mock_load_image,
-    mock_face_locations,
-    mock_face_encodings,
-    face_rec,
-):
-    """Test recognizing a face."""
-    # Mock face recognition functions
-    known_encoding = np.random.rand(128)
-    unknown_encoding = np.random.rand(128)
-
-    mock_load_image.return_value = np.zeros((100, 100, 3), dtype=np.uint8)
-    mock_face_locations.return_value = [(10, 20, 30, 40)]
-
-    # Add a known face
-    mock_face_encodings.return_value = [known_encoding]
-    import tempfile
-
-    with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
-        tmp_file.write(b"fake image data")
-        tmp_path = tmp_file.name
-
-    try:
-        face_rec.add_known_face("Test User", tmp_path)
-
-        # Test with known face (matching encoding)
-        mock_face_encodings.return_value = [known_encoding]
-        mock_compare_faces.return_value = [True]
-        mock_face_distance.return_value = [0.3]
-
-        success, name, confidence = face_rec.recognize_face(b"fake image data")
-        assert success
-        assert name == "Test User"
-        assert 0.0 <= confidence <= 1.0
-
-        # Test with unknown face (non-matching encoding)
-        mock_face_encodings.return_value = [unknown_encoding]
-        mock_compare_faces.return_value = [False]
-        mock_face_distance.return_value = [0.9]
-
-        success, name, confidence = face_rec.recognize_face(b"fake unknown image data")
-        assert not success
-        assert name is None
-        assert confidence == 0.0
-    finally:
-        os.unlink(tmp_path)
-
-
-@patch("cv2.VideoCapture")
-def test_capture_and_verify_face(mock_video_capture, face_rec):
-    """Test face verification with webcam."""
-    # Mock the video capture
-    mock_camera = MagicMock()
-    mock_video_capture.return_value = mock_camera
-
-    # Mock frame data
-    test_frame = np.zeros((480, 640, 3), dtype=np.uint8)
-    mock_camera.read.return_value = (True, test_frame)
-
-    # Mock face detection
-    with (
-        patch("face_recognition.face_locations") as mock_face_locations,
-        patch("face_recognition.face_encodings") as mock_face_encodings,
-        patch("face_recognition.load_image_file") as mock_load_image,
-    ):
-        # Setup mock for no face detected
-        mock_face_locations.return_value = []
-
-        # Test with no face in frame (should return False)
-        success, name, confidence = face_rec.capture_and_verify_face(timeout=1)
-        assert not success
-        assert name is None
-        assert confidence == 0.0
-
-        # Setup mock for face detected but not recognized
-        mock_face_locations.return_value = [(100, 200, 300, 400)]
-        mock_face_encodings.return_value = [np.zeros(128)]
-
-        # Add a known face with a different encoding
-        mock_load_image.return_value = np.zeros((100, 100, 3), dtype=np.uint8)
-        mock_face_locations.return_value = [(10, 20, 30, 40)]
-        mock_face_encodings.return_value = [np.random.rand(128)]
-        import tempfile
-
-        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp_file:
-            tmp_file.write(b"fake image data")
-            tmp_path = tmp_file.name
-        try:
-            face_rec.add_known_face("Test User", tmp_path)
-
-            # Test with face detected but not recognized (different encoding)
-            success, name, confidence = face_rec.capture_and_verify_face(timeout=1)
-            assert not success
-            assert name is None
-            assert confidence == 0.0
-        finally:
-            os.unlink(tmp_path)
-
-
-def test_face_encryption(face_rec):
-    """Test that face encodings are properly encrypted/decrypted."""
-    # Create a test encoding
-    test_encoding = np.random.rand(128)
-
-    # Encrypt and decrypt
-    encrypted = face_rec.encrypt_encoding(test_encoding)
-    decrypted = face_rec.decrypt_encoding(encrypted)
-
-    # Check that decrypted data matches original
-    assert np.allclose(test_encoding, decrypted)
-
-    # Check that encrypted data is different from original
-    assert not np.array_equal(test_encoding.tobytes(), encrypted)

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

@@ -1,161 +0,0 @@
-"""Integration tests for face recognition API endpoints."""
-
-import base64
-
-# Add the parent directory to the Python path
-import sys
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-sys.path.append(str(Path(__file__).parent.parent))
-
-from windows_computer_use_mcp.face_recognition import FaceData
-
-# Test data - use mocks instead of requiring actual image files
-TEST_IMAGE_DIR = Path(__file__).parent / "test_images"
-KNOWN_FACE_IMAGE = TEST_IMAGE_DIR / "known_face.jpg"
-UNKNOWN_FACE_IMAGE = TEST_IMAGE_DIR / "unknown_face.jpg"
-
-
-@pytest.fixture(scope="module")
-def client():
-    """Test client for the FastAPI application."""
-    # Skip API tests - FastMCP app is not a FastAPI app
-    pytest.skip("Face recognition API tests require FastAPI, but FastMCP uses different architecture")
-
-
-@pytest.fixture
-def mock_face_recognizer():
-    """Mock the face recognizer for testing."""
-    with patch("windows_computer_use_mcp.face_recognition.face_recognizer") as mock:
-        # Setup mock return values
-        mock.recognize_face.return_value = (True, "Test User", 0.85)
-        mock.capture_and_verify_face.return_value = (True, "Test User", 0.88)
-        mock.known_faces = {
-            "Test User": FaceData(
-                name="Test User",
-                encoding=b"test_encoding",
-                created_at="2023-01-01T00:00:00",
-                last_used="2023-01-01T01:00:00",
-                usage_count=5,
-            )
-        }
-        yield mock
-
-
-# Helper function to encode image file to base64
-def image_to_base64(image_path):
-    with open(image_path, "rb") as image_file:
-        return base64.b64encode(image_file.read()).decode("utf-8")
-
-
-# Test cases
-def test_enroll_face(client, mock_face_recognizer):
-    """Test enrolling a new face."""
-    # Mock the add_known_face method
-    mock_face_recognizer.add_known_face.return_value = True
-
-    # Create a test file in memory
-    import io
-
-    fake_image = io.BytesIO(b"fake image data")
-    files = {"image_file": ("test_face.jpg", fake_image, "image/jpeg")}
-
-    # Make the request
-    response = client.post("/face-recognition/enroll", files=files, data={"name": "Test User"})
-
-    # Check the response
-    assert response.status_code == 201
-    assert response.json()["status"] == "success"
-    assert response.json()["name"] == "Test User"
-
-    # Verify the method was called
-    mock_face_recognizer.add_known_face.assert_called_once()
-    assert mock_face_recognizer.add_known_face.call_args[1]["name"] == "Test User"
-
-
-def test_verify_face(client, mock_face_recognizer):
-    """Test verifying a face from an image."""
-    # Encode fake image data to base64
-    import base64
-
-    fake_image_data = b"fake image data"
-    image_base64 = base64.b64encode(fake_image_data).decode("utf-8")
-
-    # Make the request
-    response = client.post("/face-recognition/verify", json={"image_data": image_base64, "confidence_threshold": 0.7})
-
-    # Check the response
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["name"] == "Test User"
-    assert 0.0 <= data["confidence"] <= 1.0
-
-    # Verify the method was called
-    mock_face_recognizer.recognize_face.assert_called_once()
-
-
-@patch("cv2.VideoCapture")
-def test_verify_face_webcam(mock_video_capture, client, mock_face_recognizer):
-    """Test verifying a face using webcam."""
-    # Mock the video capture
-    mock_camera = MagicMock()
-    mock_video_capture.return_value = mock_camera
-
-    # Make the request
-    response = client.post("/face-recognition/verify/webcam", params={"confidence_threshold": 0.7, "timeout": 1})
-
-    # Check the response
-    assert response.status_code == 200
-    data = response.json()
-    assert data["success"] is True
-    assert data["name"] == "Test User"
-    assert 0.0 <= data["confidence"] <= 1.0
-
-    # Verify the method was called
-    mock_face_recognizer.capture_and_verify_face.assert_called_once()
-
-
-def test_list_known_faces(client, mock_face_recognizer):
-    """Test listing known faces."""
-    # Make the request
-    response = client.get("/face-recognition/faces")
-
-    # Check the response
-    assert response.status_code == 200
-    data = response.json()
-    assert len(data) == 1
-    assert data[0]["name"] == "Test User"
-    assert data[0]["usage_count"] == 5
-
-
-def test_remove_known_face(client, mock_face_recognizer):
-    """Test removing a known face."""
-    # Mock the remove_known_face method
-    mock_face_recognizer.remove_known_face.return_value = True
-
-    # Make the request
-    response = client.delete("/face-recognition/faces/Test%20User")
-
-    # Check the response
-    assert response.status_code == 200
-    assert response.json()["status"] == "success"
-
-    # Verify the method was called
-    mock_face_recognizer.remove_known_face.assert_called_once_with("Test User")
-
-
-def test_remove_nonexistent_face(client, mock_face_recognizer):
-    """Test removing a face that doesn't exist."""
-    # Mock the remove_known_face method to return False
-    mock_face_recognizer.remove_known_face.return_value = False
-
-    # Make the request
-    response = client.delete("/face-recognition/faces/Nonexistent%20User")
-
-    # Check the response
-    assert response.status_code == 404
-    assert "not found" in response.json()["detail"].lower()

package/mcps/windows-computer-use-mcp/tests/test_images/README.md

@@ -1,28 +0,0 @@
-# Test Images for Face Recognition
-
-This directory contains test images for the face recognition system.
-
-## Required Test Images
-
-### 1. `known_face.jpg`
-
-- A clear, front-facing photo of a person's face
-- Well-lit with neutral expression
-- Minimum 200x200 pixels
-- JPG format
-
-### 2. `unknown_face.jpg`
-
-- A photo of a different person's face
-- Similar quality to `known_face.jpg`
-- Used to test non-matching face scenarios
-
-## How to Add Test Images
-
-1. Place your test images in this directory
-2. Ensure they match the expected filenames
-3. Add them to `.gitignore` if they contain sensitive data
-
-## Note
-
-These images are for testing purposes only and should not contain real user data in the repository.

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

@@ -1,42 +0,0 @@
-"""Tests for the automation_mission portmanteau tool and sampling integration."""
-
-from unittest.mock import AsyncMock, MagicMock
-
-import pytest
-
-from windows_computer_use_mcp.tools.models import MissionOperationRequest
-from windows_computer_use_mcp.tools.portmanteau_mission import automation_mission
-
-
-class TestAutomationMission:
-    """Tests for automation_mission tool."""
-
-    @pytest.mark.asyncio
-    async def test_automation_mission_success(self, app_instance, verify_result):
-        """Test successful mission planning via sampling."""
-        # Mock FastMCP Context
-        mock_ctx = AsyncMock()
-
-        # Mock Sample response
-        mock_sample_result = MagicMock()
-        mock_sample_result.content = "1. Open Notepad\n2. Type 'Hello'\n3. Save"
-        mock_ctx.sample.return_value = mock_sample_result
-
-        req = MissionOperationRequest(operation="plan", goal="Test goal")
-        result = await automation_mission(req, ctx=mock_ctx)
-
-        verify_result(result, expected_keys=["mission_id"])
-        assert "steps" in result.data or "plan" in result.data
-
-        # Verify context call
-        assert mock_ctx.sample.called
-
-        # Verify the prompt sent to sample
-        _args, kwargs = mock_ctx.sample.call_args
-        user_msgs = [m for m in kwargs.get("messages", []) if m.get("role") == "user"]
-        assert any("Test goal" in m.get("content", "") for m in user_msgs)
-
-    @pytest.mark.skip(reason="mission 'plan' no longer requires ctx")
-    @pytest.mark.asyncio
-    async def test_automation_mission_no_ctx(self, app_instance, verify_result):
-        """Test mission fails gracefully when sampling context is missing."""