[BugFix] Fix step distance scaling issue in walk_pointer_to_proportional() (#47)

Signed-off-by: Douglas Chiang <[email protected]>

Author: douglasdotc

yarf/rf_libraries/libraries/hid_base.py

@@ -4,6 +4,7 @@
 
 import asyncio
 from abc import ABC, abstractmethod
+from math import sqrt
 from typing import NamedTuple, Sequence
 
 from robot.api.deco import keyword
@@ -202,15 +203,22 @@ async def walk_pointer_to_absolute(
         assert 0 <= y <= display_size.height, "Y coordinate outside of screen"
 
         proportional = (x / display_size.width, y / display_size.height)
+        proportional_step_distance = step_distance / sqrt(
+            display_size.width * display_size.height
+        )
         await self.walk_pointer_to_proportional(
             *proportional,
-            step_distance,
+            proportional_step_distance,
             delay,
         )
 
     @keyword
     async def walk_pointer_to_proportional(
-        self, x: float, y: float, step_distance: float, delay: float
+        self,
+        x: float,
+        y: float,
+        step_distance: float,
+        delay: float,
     ) -> None:
         """
         Walk the virtual pointer to a position proportional to the size of the
@@ -220,14 +228,15 @@ async def walk_pointer_to_proportional(
         Args:
             x: horizontal coordinate, 0 <= x <= 1
             y: vertical coordinate, 0 <= y <= 1
-            step_distance: maximum distance to move per step
+            step_distance: maximum distance to move per step horizontally, 0 < step_distance <= 1
             delay: delay between steps in seconds
 
         Raises:
             AssertionError: if coordinates are out of range
         """
         assert 0 <= x <= 1, "x not in range 0..1"
         assert 0 <= y <= 1, "y not in range 0..1"
+        assert 0 < step_distance <= 1, "step_distance_x not in range 0..1"
 
         while self._pointer_position != (x, y):
             dist_x = x - self._pointer_position.x

yarf/rf_libraries/libraries/tests/test_hid_base.py

@@ -1,4 +1,4 @@
-from unittest.mock import AsyncMock, call, patch
+from unittest.mock import AsyncMock, MagicMock, call, patch
 
 import pytest
 
@@ -112,24 +112,48 @@ async def test_walk_pointer_to_proportional(self, stub_hid, mock_sleep):
 
         mock_sleep.assert_has_calls(7 * [call(0.2)])
 
+    @pytest.mark.asyncio
+    @pytest.mark.parametrize(
+        "x,y,step_distance",
+        [
+            (1.1, 0, 0),
+            (0, 1.1, 0),
+            (0, 0, 1.1),
+        ],
+    )
+    async def test_walk_pointer_to_proportional_raises(
+        self,
+        stub_hid: MagicMock,
+        x: float,
+        y: float,
+        step_distance: float,
+    ):
+        """
+        Test the function raises an exception if the target position or step
+        distance are out of range.
+        """
+        with pytest.raises(AssertionError):
+            await stub_hid.walk_pointer_to_proportional(
+                x, y, step_distance, 0.2
+            )
+
     @pytest.mark.asyncio
     async def test_walk_pointer_to_absolute(self, stub_hid, mock_sleep):
         """
         Test the function moves the pointer by the requested step to the target
         position given in absolute coordinates.
         """
         await stub_hid.move_pointer_to_proportional(0.15, 0.35)
-        await stub_hid.walk_pointer_to_absolute(100, 200, 0.05, 0.2)
+        await stub_hid.walk_pointer_to_absolute(100, 200, 100, 0.2)
 
         stub_hid._move_pointer.assert_has_calls(
             (
-                call(pytest.approx(0.1), pytest.approx(0.3)),
                 call(pytest.approx(0.1), pytest.approx(0.25)),
                 call(pytest.approx(0.1), pytest.approx(0.2)),
             )
         )
 
-        mock_sleep.assert_has_calls(3 * [call(0.2)])
+        mock_sleep.assert_has_calls(2 * [call(0.2)])
 
     @pytest.mark.asyncio
     @pytest.mark.parametrize(