@desklink/host 0.1.0

package/engine/vendor/inputtino/bindings/python/tests/test_joypad.py

@@ -0,0 +1,332 @@
+"""Tests for joypad.py."""
+
+import os
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from inputtino import _core
+from inputtino.joypad import (
+    ControllerButton,
+    DeviceDefinition,
+    PS5BatteryState,
+    PS5Joypad,
+    PS5MotionType,
+    SwitchJoypad,
+    XBoxOneJoypad,
+)
+from tests.helpers import mark_practical
+
+
+@pytest.fixture
+def mock_joypad():
+    """Create a mock for base Joypad."""
+    with patch("inputtino._core.Joypad") as mock_joypad_cls:
+        mock_instance = MagicMock(spec=_core.Joypad)
+        mock_joypad_cls.create.return_value = mock_instance
+        yield mock_instance
+
+
+@pytest.fixture
+def mock_xbox_joypad():
+    """Create a mock for XBoxOneJoypad."""
+    with patch("inputtino._core.XboxOneJoypad") as mock_joypad_cls:
+        mock_instance = MagicMock()
+        mock_joypad_cls.create = MagicMock(return_value=mock_instance)
+        yield mock_joypad_cls
+
+
+@pytest.fixture
+def mock_switch_joypad():
+    """Create a mock for SwitchJoypad."""
+    with patch("inputtino._core.SwitchJoypad") as mock_joypad_cls:
+        mock_instance = MagicMock()
+        mock_joypad_cls.create = MagicMock(return_value=mock_instance)
+        yield mock_joypad_cls
+
+
+@pytest.fixture
+def mock_ps5_joypad():
+    """Create a mock for PS5Joypad."""
+    with patch("inputtino._core.PS5Joypad") as mock_joypad_cls:
+        mock_instance = MagicMock()
+        mock_joypad_cls.create = MagicMock(return_value=mock_instance)
+        yield mock_joypad_cls
+
+
+def test_xbox_joypad_creation_with_default_device(mock_xbox_joypad):
+    """Test creating an Xbox joypad with default device definition."""
+    XBoxOneJoypad()
+    created_def = mock_xbox_joypad.create.call_args[0][0]
+
+    assert created_def.name == "Wolf X-Box One (virtual) pad"
+    assert created_def.vendor_id == 0x045E
+    assert created_def.product_id == 0x02EA
+    assert created_def.version == 0x0408
+
+
+def test_xbox_joypad_with_custom_device(mock_xbox_joypad):
+    """Test creating an Xbox joypad with custom device definition."""
+    custom_def = DeviceDefinition(
+        name="Custom Xbox",
+        vendor_id=0x1234,
+        product_id=0x5678,
+        version=0x0001,
+    )
+
+    XBoxOneJoypad(custom_def)
+    created_def = mock_xbox_joypad.create.call_args[0][0]
+
+    assert created_def.name == custom_def.name
+    assert created_def.vendor_id == custom_def.vendor_id
+    assert created_def.product_id == custom_def.product_id
+    assert created_def.version == custom_def.version
+
+
+def test_joypad_button_press(mock_xbox_joypad):
+    """Test joypad button pressing."""
+    joypad = XBoxOneJoypad()
+    instance = mock_xbox_joypad.create.return_value
+
+    buttons = ControllerButton.A | ControllerButton.B | ControllerButton.DPAD_UP
+    joypad.set_pressed_buttons(buttons)
+    instance.set_pressed_buttons.assert_called_once_with(int(buttons))
+
+
+def test_joypad_triggers(mock_xbox_joypad):
+    """Test setting trigger values."""
+    joypad = XBoxOneJoypad()
+    instance = mock_xbox_joypad.create.return_value
+
+    joypad.set_triggers(1000, 2000)
+    instance.set_triggers.assert_called_once_with(1000, 2000)
+
+
+def test_joypad_stick(mock_xbox_joypad):
+    """Test setting stick position."""
+    joypad = XBoxOneJoypad()
+    instance = mock_xbox_joypad.create.return_value
+
+    joypad.set_stick(_core.StickPosition.LS, 100, 200)
+    instance.set_stick.assert_called_once_with(_core.StickPosition.LS, 100, 200)
+
+
+def test_ps5_joypad_specific_features(mock_ps5_joypad):
+    """Test PS5-specific features."""
+    joypad = PS5Joypad()
+    instance = mock_ps5_joypad.create.return_value
+    instance.get_mac_address.return_value = "00:11:22:33:44:55"
+
+    assert joypad.mac_address == "00:11:22:33:44:55"
+
+    joypad.place_finger(1, 960, 540)
+    instance.place_finger.assert_called_once_with(1, 960, 540)
+
+    joypad.set_motion(PS5MotionType.ACCELERATION, 1.0, 2.0, 3.0)
+    instance.set_motion.assert_called_once_with(
+        PS5MotionType.ACCELERATION, 1.0, 2.0, 3.0
+    )
+
+    joypad.set_battery(PS5BatteryState.BATTERY_FULL, 100)
+    instance.set_battery.assert_called_once_with(PS5BatteryState.BATTERY_FULL, 100)
+
+
+def test_rumble_callback():
+    """Test rumble callback functionality."""
+    with patch("inputtino._core.XboxOneJoypad") as mock_joypad_cls:
+        joypad = XBoxOneJoypad()
+
+        callback_called = False
+
+        def rumble_callback(low, high):
+            nonlocal callback_called
+            callback_called = True
+            assert low == 1000
+            assert high == 2000
+
+        joypad.set_on_rumble(rumble_callback)
+
+        # Simulate rumble event
+        mock_joypad_cls.create.return_value.set_on_rumble.call_args[0][0](1000, 2000)
+        assert callback_called
+
+
+def test_ps5_led_callback():
+    """Test PS5 LED callback functionality."""
+    with patch("inputtino._core.PS5Joypad") as mock_joypad_cls:
+        joypad = PS5Joypad()
+
+        callback_called = False
+
+        def led_callback(r, g, b):
+            nonlocal callback_called
+            callback_called = True
+            assert r == 255
+            assert g == 0
+            assert b == 0
+
+        joypad.set_on_led(led_callback)
+
+        # Simulate LED event
+        mock_joypad_cls.create.return_value.set_on_led.call_args[0][0](255, 0, 0)
+        assert callback_called
+
+
+def test_joypad_creation_failure():
+    """Test handling of joypad creation failure."""
+    with patch("inputtino._core.XboxOneJoypad") as mock_joypad_cls:
+        mock_joypad_cls.create.side_effect = RuntimeError(
+            "Failed to create joypad device"
+        )
+
+        with pytest.raises(RuntimeError, match="Failed to create joypad device"):
+            XBoxOneJoypad()
+
+
+def test_switch_joypad_creation_with_default_device(mock_switch_joypad):
+    """Test creating a Switch joypad with default device definition."""
+    SwitchJoypad()
+    created_def = mock_switch_joypad.create.call_args[0][0]
+
+    assert created_def.name == "Wolf Nintendo (virtual) pad"
+    assert created_def.vendor_id == 0x057E
+    assert created_def.product_id == 0x2009
+    assert created_def.version == 0x8111
+
+
+def test_switch_joypad_with_custom_device(mock_switch_joypad):
+    """Test creating a Switch joypad with custom device definition."""
+    custom_def = DeviceDefinition(
+        name="Custom Switch",
+        vendor_id=0x1234,
+        product_id=0x5678,
+        version=0x0001,
+    )
+
+    SwitchJoypad(custom_def)
+    created_def = mock_switch_joypad.create.call_args[0][0]
+
+    assert created_def.name == custom_def.name
+    assert created_def.vendor_id == custom_def.vendor_id
+    assert created_def.product_id == custom_def.product_id
+    assert created_def.version == custom_def.version
+
+
+def test_switch_rumble_callback():
+    """Test Switch rumble callback functionality."""
+    with patch("inputtino._core.SwitchJoypad") as mock_joypad_cls:
+        joypad = SwitchJoypad()
+
+        callback_called = False
+
+        def rumble_callback(low, high):
+            nonlocal callback_called
+            callback_called = True
+            assert low == 1000
+            assert high == 2000
+
+        joypad.set_on_rumble(rumble_callback)
+
+        mock_joypad_cls.create.return_value.set_on_rumble.call_args[0][0](1000, 2000)
+        assert callback_called
+
+
+@mark_practical
+def test_practical_joypad_gameplay():
+    """Test gamepad controls in a simulated gameplay scenario.
+
+    This practical test demonstrates:
+    1. Basic directional movement
+    2. Button combinations
+    3. Trigger and stick input
+    4. Rumble feedback
+
+    Note:
+        This test requires actual device access (/dev/uinput)
+        and may fail if run without proper permissions.
+    """
+    joypad = XBoxOneJoypad()
+    assert len(joypad.nodes) > 0, "No joypad nodes created"
+
+    time.sleep(0.1)  # Allow device registration
+
+    rumble_received = False
+
+    def on_rumble(low, high):
+        nonlocal rumble_received
+        rumble_received = True
+
+    joypad.set_on_rumble(on_rumble)
+
+    try:
+        # Test movement sequence
+        movements = [
+            (ControllerButton.DPAD_RIGHT, _core.StickPosition.LS, 32767, 0),
+            (ControllerButton.DPAD_DOWN, _core.StickPosition.LS, 0, 32767),
+            (ControllerButton.DPAD_LEFT, _core.StickPosition.LS, -32767, 0),
+            (ControllerButton.DPAD_UP, _core.StickPosition.LS, 0, -32767),
+        ]
+
+        for button, stick, x, y in movements:
+            joypad.set_pressed_buttons(button)
+            joypad.set_stick(stick, x, y)
+            joypad.set_triggers(32767, 32767)
+            time.sleep(0.1)
+            joypad.set_pressed_buttons(ControllerButton(0))
+            time.sleep(0.1)
+
+        # Test button combinations
+        joypad.set_pressed_buttons(
+            ControllerButton.A | ControllerButton.B | ControllerButton.X
+        )
+        time.sleep(0.1)
+
+    finally:
+        joypad.set_pressed_buttons(ControllerButton(0))
+        joypad.set_triggers(0, 0)
+        joypad.set_stick(_core.StickPosition.LS, 0, 0)
+
+
+@mark_practical
+def test_practical_ps5_features():
+    """Test PS5-specific features in a practical scenario.
+
+    Tests touchpad, motion sensors, LED, and battery reporting.
+
+    Note:
+        Requires /dev/uinput access.
+    """
+    joypad = PS5Joypad()
+    # NOTE: 2025/02/05 Not working.
+    # assert len(joypad.nodes) > 0
+
+    time.sleep(0.1)
+
+    led_changed = False
+
+    def on_led(r, g, b):
+        nonlocal led_changed
+        led_changed = True
+
+    joypad.set_on_led(on_led)
+
+    try:
+        # Touchpad gesture
+        joypad.place_finger(0, 960, 540)
+        time.sleep(0.1)
+        joypad.place_finger(0, 1200, 540)
+        time.sleep(0.1)
+        joypad.release_finger(0)
+
+        # Motion controls
+        joypad.set_motion(PS5MotionType.ACCELERATION, 0.5, 0.1, 9.8)
+        time.sleep(0.1)
+        joypad.set_motion(PS5MotionType.GYROSCOPE, 45.0, 0.0, 0.0)
+        time.sleep(0.1)
+
+        # Battery update
+        joypad.set_battery(PS5BatteryState.BATTERY_FULL, 100)
+
+    finally:
+        joypad.release_finger(0)

package/engine/vendor/inputtino/bindings/python/tests/test_keyboard.py

@@ -0,0 +1,164 @@
+"""Tests for keyboard.py."""
+
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from inputtino._core import Keyboard as CoreKeyboard
+from inputtino.base import DeviceDefinition
+from inputtino.keyboard import DEFAULT_KEYBOARD, Keyboard, KeyCode
+from tests.helpers import mark_practical
+
+
+@pytest.fixture
+def mock_core_keyboard():
+    """Create a mock for CoreKeyboard with basic functionality."""
+    with patch("inputtino._core.Keyboard") as mock_keyboard_cls:
+        mock_instance = MagicMock(spec=CoreKeyboard)
+        mock_keyboard_cls.create.return_value = mock_instance
+        yield mock_instance
+
+
+def test_keyboard_creation_with_default_device():
+    """Test creating a keyboard with default device definition."""
+    with patch("inputtino._core.Keyboard") as mock_keyboard_cls:
+        Keyboard()
+
+        mock_keyboard_cls.create.assert_called_once()
+        created_def = mock_keyboard_cls.create.call_args[0][0]
+        assert created_def.name == DEFAULT_KEYBOARD.name
+        assert created_def.vendor_id == DEFAULT_KEYBOARD.vendor_id
+        assert created_def.product_id == DEFAULT_KEYBOARD.product_id
+        assert created_def.version == DEFAULT_KEYBOARD.version
+
+
+def test_keyboard_creation_with_custom_device():
+    """Test creating a keyboard with custom device definition."""
+    custom_def = DeviceDefinition(
+        name="Custom Keyboard",
+        vendor_id=0x1234,
+        product_id=0x5678,
+        version=0x0001,
+        device_phys="/dev/input/test",
+        device_uniq="unique_id",
+    )
+
+    with patch("inputtino._core.Keyboard") as mock_keyboard_cls:
+        Keyboard(custom_def)
+
+        mock_keyboard_cls.create.assert_called_once()
+        created_def = mock_keyboard_cls.create.call_args[0][0]
+        assert created_def.name == custom_def.name
+        assert created_def.vendor_id == custom_def.vendor_id
+        assert created_def.product_id == custom_def.product_id
+        assert created_def.version == custom_def.version
+        assert created_def.device_phys == custom_def.device_phys
+        assert created_def.device_uniq == custom_def.device_uniq
+
+
+def test_keyboard_custom_repress_time():
+    """Test creating a keyboard with custom key repress time."""
+    with patch("inputtino._core.Keyboard") as mock_keyboard_cls:
+        Keyboard(millis_repress_key=100)
+        mock_keyboard_cls.create.assert_called_once()
+        assert mock_keyboard_cls.create.call_args[0][1] == 100
+
+
+def test_keyboard_key_press_and_release(mock_core_keyboard):
+    """Test keyboard key press and release."""
+    keyboard = Keyboard()
+
+    # Test single key press/release
+    keyboard.press(KeyCode.A)
+    mock_core_keyboard.press.assert_called_with(KeyCode.A)
+
+    keyboard.release(KeyCode.A)
+    mock_core_keyboard.release.assert_called_with(KeyCode.A)
+
+    # Test modifier key press/release
+    keyboard.press(KeyCode.SHIFT)
+    mock_core_keyboard.press.assert_called_with(KeyCode.SHIFT)
+
+    keyboard.release(KeyCode.SHIFT)
+    mock_core_keyboard.release.assert_called_with(KeyCode.SHIFT)
+
+
+def test_keyboard_nodes(mock_core_keyboard):
+    """Test getting keyboard device nodes."""
+    expected_nodes = ["/dev/input/event1"]
+    mock_core_keyboard.get_nodes.return_value = expected_nodes
+
+    keyboard = Keyboard()
+    assert keyboard.nodes == expected_nodes
+    mock_core_keyboard.get_nodes.assert_called_once()
+
+
+def test_keyboard_type(mock_core_keyboard):
+    """Test keyboard type method."""
+    keyboard = Keyboard()
+
+    with patch("time.sleep") as mock_sleep:
+        # Test with default duration
+        keyboard.type(KeyCode.A)
+        mock_core_keyboard.press.assert_called_with(KeyCode.A)
+        mock_sleep.assert_called_with(0.1)
+        mock_core_keyboard.release.assert_called_with(KeyCode.A)
+
+        # Test with custom duration
+        keyboard.type(KeyCode.B, 0.5)
+        mock_core_keyboard.press.assert_called_with(KeyCode.B)
+        mock_sleep.assert_called_with(0.5)
+        mock_core_keyboard.release.assert_called_with(KeyCode.B)
+
+
+def test_keyboard_creation_failure():
+    """Test handling of keyboard creation failure."""
+    with patch("inputtino._core.Keyboard") as mock_keyboard_cls:
+        mock_keyboard_cls.create.side_effect = RuntimeError(
+            "Failed to create keyboard device"
+        )
+
+        with pytest.raises(RuntimeError, match="Failed to create keyboard device"):
+            Keyboard()
+
+
+def test_key_code_from_string():
+    assert KeyCode.from_str("a") is KeyCode.A
+    assert KeyCode.from_str("SHIFT") is KeyCode.SHIFT
+
+    with pytest.raises(KeyError):
+        KeyCode.from_str("")
+
+
+@mark_practical
+def test_practical_keyboard_input():
+    """Test simulating keyboard input with a practical example.
+
+    This practical test demonstrates:
+    1. Creating a keyboard device
+    2. Simulating Ctrl+A (select all) keyboard shortcut
+    3. Verifying device creation and basic functionality
+
+    Note:
+        This test requires actual device access (/dev/uinput)
+        and may fail if run without proper permissions.
+    """
+    keyboard = Keyboard()
+
+    # Ensure we have valid device nodes
+    assert len(keyboard.nodes) > 0, "No keyboard device nodes created"
+
+    # Give system time to register the device
+    time.sleep(0.1)
+
+    try:
+        # Simulate Ctrl+A (select all)
+        keyboard.press(KeyCode.CTRL)
+        keyboard.press(KeyCode.A)
+        time.sleep(0.1)
+        keyboard.release(KeyCode.A)
+        keyboard.release(KeyCode.CTRL)
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to simulate keyboard input: {e}") from e

package/engine/vendor/inputtino/bindings/python/tests/test_mouse.py

@@ -0,0 +1,185 @@
+"""Tests for mouse.py."""
+
+import time
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from inputtino._core import Mouse as CoreMouse
+from inputtino.mouse import DeviceDefinition, Mouse, MouseButton
+from tests.helpers import mark_practical
+
+
+@pytest.fixture
+def mock_core_mouse():
+    """Create a mock for CoreMouse with basic functionality."""
+    with patch("inputtino._core.Mouse") as mock_mouse_cls:
+        mock_instance = MagicMock(spec=CoreMouse)
+        mock_mouse_cls.create.return_value = mock_instance
+        yield mock_instance
+
+
+def test_mouse_creation_with_default_device():
+    """Test creating a mouse with default device definition."""
+    with patch("inputtino._core.Mouse") as mock_mouse_cls:
+        Mouse()
+
+        mock_mouse_cls.create.assert_called_once()
+        created_def = mock_mouse_cls.create.call_args[0][0]
+        assert created_def.name == "Wolf mouse virtual device"
+        assert created_def.vendor_id == 0xAB00
+        assert created_def.product_id == 0xAB01
+        assert created_def.version == 0xAB00
+
+
+def test_mouse_creation_with_custom_device():
+    """Test creating a mouse with custom device definition."""
+    custom_def = DeviceDefinition(
+        name="Custom Mouse",
+        vendor_id=0x1234,
+        product_id=0x5678,
+        version=0x0001,
+        device_phys="/dev/input/test",
+        device_uniq="unique_id",
+    )
+
+    with patch("inputtino._core.Mouse") as mock_mouse_cls:
+        Mouse(custom_def)
+
+        mock_mouse_cls.create.assert_called_once()
+        created_def = mock_mouse_cls.create.call_args[0][0]
+        assert created_def.name == custom_def.name
+        assert created_def.vendor_id == custom_def.vendor_id
+        assert created_def.product_id == custom_def.product_id
+        assert created_def.version == custom_def.version
+        assert created_def.device_phys == custom_def.device_phys
+        assert created_def.device_uniq == custom_def.device_uniq
+
+
+def test_mouse_movement(mock_core_mouse):
+    """Test relative mouse movement."""
+    mouse = Mouse()
+    mouse.move(100, -50)
+
+    mock_core_mouse.move.assert_called_once_with(100, -50)
+
+
+def test_mouse_absolute_movement(mock_core_mouse):
+    """Test absolute mouse movement."""
+    mouse = Mouse()
+    mouse.move_abs(1920, 1080, 3840, 2160)
+
+    mock_core_mouse.move_abs.assert_called_once_with(1920, 1080, 3840, 2160)
+
+
+def test_mouse_button_press_and_release(mock_core_mouse):
+    """Test mouse button press and release."""
+    mouse = Mouse()
+
+    # Test pressing each button
+    for button in [
+        MouseButton.EXTRA,
+        MouseButton.LEFT,
+        MouseButton.RIGHT,
+        MouseButton.MIDDLE,
+        MouseButton.SIDE,
+    ]:
+        mouse.press(button)
+        mock_core_mouse.press.assert_called_with(button)
+
+        mouse.release(button)
+        mock_core_mouse.release.assert_called_with(button)
+
+
+def test_mouse_scrolling(mock_core_mouse):
+    """Test mouse scrolling in both directions."""
+    mouse = Mouse()
+
+    # Test vertical scrolling
+    mouse.scroll_vertical(120)
+    mock_core_mouse.vertical_scroll.assert_called_once_with(120)
+
+    # Test horizontal scrolling
+    mouse.scroll_horizontal(-120)
+    mock_core_mouse.horizontal_scroll.assert_called_once_with(-120)
+
+
+def test_mouse_nodes(mock_core_mouse):
+    """Test getting mouse device nodes."""
+    expected_nodes = ["/dev/input/event0", "/dev/input/mouse0"]
+    mock_core_mouse.get_nodes.return_value = expected_nodes
+
+    mouse = Mouse()
+    assert mouse.nodes == expected_nodes
+    mock_core_mouse.get_nodes.assert_called_once()
+
+
+def test_click(mock_core_mouse):
+    """Test single click functionality."""
+    mouse = Mouse()
+    with patch("time.sleep") as mock_sleep:
+        mouse.click(MouseButton.LEFT, 0.5)
+
+        mock_core_mouse.press.assert_called_once_with(MouseButton.LEFT)
+        mock_sleep.assert_called_once_with(0.5)
+        mock_core_mouse.release.assert_called_once_with(MouseButton.LEFT)
+
+
+def test_mouse_creation_failure():
+    """Test handling of mouse creation failure."""
+    with patch("inputtino._core.Mouse") as mock_mouse_cls:
+        mock_mouse_cls.create.side_effect = RuntimeError(
+            "Failed to create mouse device"
+        )
+
+        with pytest.raises(RuntimeError, match="Failed to create mouse device"):
+            Mouse()
+
+
+@mark_practical
+def test_practical_mouse_draw_square():
+    """Test drawing a square pattern with the mouse.
+
+    This practical test demonstrates drawing a square pattern by:
+    1. Moving the mouse in a square pattern
+    2. Holding left button during the movement
+    3. Creating a visible mouse movement pattern
+
+    Note:
+        This test requires actual device access (/dev/uinput)
+        and may fail if run without proper permissions.
+    """
+    mouse = Mouse()
+
+    # Ensure we have valid device nodes
+    assert len(mouse.nodes) > 0, "No mouse device nodes created"
+
+    # Give system time to register the device
+    time.sleep(0.1)
+
+    # Start at center
+    center_x, center_y = 960, 540  # Assuming 1920x1080 screen
+    square_size = 200
+
+    mouse.move_abs(center_x - square_size // 2, center_y - square_size // 2, 1920, 1080)
+    mouse.press(MouseButton.LEFT)
+
+    try:
+        # Draw square pattern
+        movements = [
+            (square_size, 0),  # Right
+            (0, square_size),  # Down
+            (-square_size, 0),  # Left
+            (0, -square_size),  # Up
+        ]
+
+        for dx, dy in movements:
+            # Move slowly to create visible pattern
+            steps = 10
+            for _ in range(steps):
+                mouse.move(dx // steps, dy // steps)
+                time.sleep(0.01)  # Small delay for smooth movement
+
+    finally:
+        # Ensure we always release the button
+        mouse.release(MouseButton.LEFT)