@iaforged/context-code 2.3.3 → 2.3.5

package/dist/src/utils/computerControlMcp/server/tests/test_computer_control.py

@@ -0,0 +1,161 @@
+"""
+Tests for the Computer Control MCP package.
+"""
+
+import pytest
+from unittest.mock import Mock, patch
+import json
+import sys
+import tkinter as tk
+from tkinter import ttk
+import asyncio
+import os
+import ast
+from computer_control_mcp.core import mcp
+
+# Helper function to print request/response JSON, skipping non-serializable properties
+def print_json_data(name, request_data=None, response_data=None):
+    def serialize(obj):
+        try:
+            json.dumps(obj)
+            return obj
+        except (TypeError, OverflowError):
+            return str(obj)
+
+    print(f"\n===== TEST: {name} =====", file=sys.stderr)
+    if isinstance(request_data, dict):
+        serializable_request = {k: serialize(v) for k, v in request_data.items()}
+        print(f"REQUEST: {json.dumps(serializable_request, indent=2)}", file=sys.stderr)
+    elif request_data is not None:
+        print(f"REQUEST: {serialize(request_data)}", file=sys.stderr)
+    if response_data is not None:
+        if isinstance(response_data, dict):
+            serializable_response = {k: serialize(v) for k, v in response_data.items()}
+            print(
+                f"RESPONSE: {json.dumps(serializable_response, indent=2)}",
+                file=sys.stderr,
+            )
+        else:
+            print(f"RESPONSE: {serialize(response_data)}", file=sys.stderr)
+    print("======================\n", file=sys.stderr)
+
+
+# Test drag_mouse tool
+@pytest.mark.asyncio
+async def test_drag_mouse():
+    # Test data
+    test_window = tk.Tk()
+    test_window.title("Test Drag Mouse")
+    test_window.geometry("400x400")
+
+    # Update the window to ensure coordinates are calculated
+    test_window.update_idletasks()
+    test_window.update()
+
+    # Window title coordinates
+    window_x = test_window.winfo_x()
+    window_y = test_window.winfo_y()
+
+    screen_width = test_window.winfo_screenwidth()
+    screen_height = test_window.winfo_screenheight()
+    center_x = screen_width // 2
+    center_y = screen_height // 2
+    request_data = {
+        "from_x": window_x + 55,
+        "from_y": window_y + 15,
+        "to_x": center_x,
+        "to_y": center_y,
+        "duration": 1.0,
+    }
+
+    print(f"starting coordinates: x={window_x}, y={window_y}", file=sys.stderr)
+
+    # Create an event to track completion
+    drag_complete = asyncio.Event()
+
+    async def perform_drag():
+        try:
+            result = await mcp.call_tool("drag_mouse", request_data)
+            print(f"Result: {result}", file=sys.stderr)
+        finally:
+            drag_complete.set()
+
+    # Start the drag operation
+    drag_task = asyncio.create_task(perform_drag())
+
+    # Keep updating the window while waiting for drag to complete
+    while not drag_complete.is_set():
+        test_window.update()
+        await asyncio.sleep(0.01)  # Small delay to prevent high CPU usage
+
+    # Wait for drag operation to complete
+    await drag_task
+
+    window_x_end = test_window.winfo_x()
+    window_y_end = test_window.winfo_y()
+    print(f'ending coordinates: x={window_x_end}, y={window_y_end}', file=sys.stderr)
+
+    assert window_y_end != window_y and window_x_end != window_x
+
+    test_window.destroy()
+
+
+# Test list_windows tool
+@pytest.mark.asyncio
+async def test_list_windows():
+    # open tkinter
+    test_window = tk.Tk()
+    test_window.title("Test Window")
+    test_window.geometry("400x400")
+
+    # Update the window to ensure coordinates are calculated
+    test_window.update_idletasks()
+    test_window.update()
+
+    # list all windows
+    result = await mcp.call_tool("list_windows", {})
+
+    # check if "Test Window" is in the list
+    # Parse the TextContent objects to extract the JSON data
+    window_data = []
+    for item in result:
+        if hasattr(item, 'text'):
+            try:
+                window_info = json.loads(item.text)
+                window_data.append(window_info)
+            except json.JSONDecodeError:
+                print(f"Failed to parse JSON: {item.text}", file=sys.stderr)
+
+    print(f"Result: {window_data}")
+
+    assert any(window.get("title") == "Test Window" for window in window_data)
+
+    test_window.destroy()
+
+# Test screenshot with downloads
+@pytest.mark.asyncio
+async def test_take_screenshot():
+    # Take a screenshot of the whole screen and save to downloads
+    results = await mcp.call_tool("take_screenshot", {'save_to_downloads': True, 'mode': 'whole_screen'})
+
+    for result in results:
+        # Check if file_path is in the result
+        if hasattr(result, 'text'):
+            try:
+                result_dict = json.loads(result.text)
+                print(f"Screenshot result: {result_dict['title']}", file=sys.stderr)
+                assert 'file_path' in result_dict, "file_path should be in the result"
+                file_path = result_dict['file_path']
+
+                # Check if the file exists
+                assert os.path.exists(file_path), f"File {file_path} should exist"
+                print(f"Screenshot saved to: {file_path}", file=sys.stderr)
+
+                # Clean up - remove the file
+                os.remove(file_path)
+                print(f"Removed test file: {file_path}", file=sys.stderr)
+            except (ValueError, SyntaxError, AttributeError) as e:
+                print(f"Error processing result: {e}", file=sys.stderr)
+                assert False, f"Error processing result: {e}"
+
+    assert True, "Successfully tested screenshot with downloads"

package/dist/src/utils/computerControlMcp/server/tests/test_screenshot.py

@@ -0,0 +1,14 @@
+import sys
+sys.path.append('src')
+from computer_control_mcp.core import take_screenshot
+
+# Test with save_to_downloads=False
+result = take_screenshot(mode='whole_screen', save_to_downloads=False)
+print('Base64 image included:', 'base64_image' in result)
+print('MCP Image included:', 'image' in result)
+
+# Test with save_to_downloads=True
+result = take_screenshot(mode='whole_screen', save_to_downloads=True)
+print('Base64 image included:', 'base64_image' in result)
+print('MCP Image included:', 'image' in result)
+print('File path included:', 'file_path' in result)

package/dist/src/utils/computerControlMcp/server/tests/test_wgc_env_var.py

@@ -0,0 +1,42 @@
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from computer_control_mcp.core import _should_use_wgc_by_default
+import os
+
+def test_wgc_env_var():
+    """Test the WGC environment variable pattern matching"""
+    print("Testing WGC environment variable pattern matching...")
+    
+    # Test with no environment variable set
+    if 'COMPUTER_CONTROL_MCP_WGC_PATTERNS' in os.environ:
+        del os.environ['COMPUTER_CONTROL_MCP_WGC_PATTERNS']
+    
+    result = _should_use_wgc_by_default("OBS Studio")
+    print(f"Without env var - 'OBS Studio': {result} (expected: False)")
+    
+    # Test with environment variable set
+    os.environ['COMPUTER_CONTROL_MCP_WGC_PATTERNS'] = "obs, discord, game"
+    
+    test_cases = [
+        ("OBS Studio", True),
+        ("Discord", True),
+        ("My Game", True),
+        ("Notepad", False),
+        ("Google Chrome", False),
+        ("obs studio", True),  # Test case insensitivity
+        ("DISCORD APP", True),  # Test case insensitivity
+    ]
+    
+    for window_title, expected in test_cases:
+        result = _should_use_wgc_by_default(window_title)
+        status = "✓" if result == expected else "✗"
+        print(f"{status} '{window_title}': {result} (expected: {expected})")
+    
+    # Clean up
+    if 'COMPUTER_CONTROL_MCP_WGC_PATTERNS' in os.environ:
+        del os.environ['COMPUTER_CONTROL_MCP_WGC_PATTERNS']
+
+if __name__ == "__main__":
+    test_wgc_env_var()

package/dist/src/utils/computerControlMcp/server/tests/test_wgc_screenshot.py

@@ -0,0 +1,67 @@
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from computer_control_mcp.core import take_screenshot, _wgc_screenshot
+import tempfile
+import os
+
+def test_wgc_screenshot():
+    """Test WGC screenshot functionality"""
+    print("Testing WGC screenshot functionality...")
+    
+    # Test if WGC is available
+    try:
+        from windows_capture import WindowsCapture
+        wgc_available = True
+        print("Windows Graphics Capture API is available")
+    except ImportError:
+        wgc_available = False
+        print("Windows Graphics Capture API is not available")
+    
+    if wgc_available:
+        # Try to capture the desktop window (usually available)
+        try:
+            # Get the first available window title
+            import pywinctl as gw
+            windows = gw.getAllWindows()
+            if windows:
+                window_title = windows[0].title
+                print(f"Attempting to capture window: {window_title}")
+                
+                # Test the internal WGC function
+                result = _wgc_screenshot(window_title)
+                if result:
+                    image_bytes, width, height = result
+                    print(f"Successfully captured window: {width}x{height}")
+                    
+                    # Save to a temporary file to verify
+                    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+                        tmp.write(image_bytes)
+                        print(f"Saved test screenshot to: {tmp.name}")
+                        # Clean up
+                        os.unlink(tmp.name)
+                else:
+                    print("Failed to capture window with WGC")
+            else:
+                print("No windows found to capture")
+        except Exception as e:
+            print(f"Error during WGC test: {e}")
+    else:
+        print("Skipping WGC tests as the API is not available")
+
+def test_take_screenshot_with_wgc():
+    """Test take_screenshot function with WGC enabled"""
+    print("\nTesting take_screenshot with WGC...")
+    
+    try:
+        # Test with WGC enabled (will fall back if not available)
+        result = take_screenshot(use_wgc=True)
+        print("take_screenshot with WGC completed")
+        print(f"Result type: {type(result)}")
+    except Exception as e:
+        print(f"Error in take_screenshot with WGC: {e}")
+
+if __name__ == "__main__":
+    test_wgc_screenshot()
+    test_take_screenshot_with_wgc()