Merge lp:~elopio/autopilot/fix1257055-slow_drag into lp:~elopio/autopilot/fix1266601-Pointer-pressed-move

[Leo Arias]

Added the drags with rate.

[lp:~elopio/autopilot/fix1257055-slow_drag]

421. By Leo Arias on 2014-01-19

Updated the copyright years.

422. By Leo Arias on 2014-01-19

Added the rate to the Pointer drag.

423. By Leo Arias on 2014-01-19

Renamed MockTouch to MockUinputTouch.

424. By Leo Arias on 2014-01-20

Merged with trunk.

425. By Leo Arias on 2014-01-20

Added python-evdev as a build-dep.

426. By Leo Arias on 2014-02-11

Merged with prerequisite branch.

427. By Leo Arias on 2014-02-11

Fixed the imports.

428. By Leo Arias on 2014-02-11

Added comments for the rate parameter.

429. By Leo Arias on 2014-02-11

Updated the tests.

430. By Leo Arias on 2014-02-11

Removed unused import.

431. By Leo Arias on 2014-02-11

Removed extra line.

432. By Leo Arias on 2014-02-11

s/should/must

433. By Leo Arias on 2014-02-11

Added a test with time_between_events.

434. By Leo Arias on 2014-02-11

We can't use the real Mouse, so switch to touch backend for now.

435. By Leo Arias on 2014-02-11

Updated the fake.

Unmerged revisions

=== modified file 'autopilot/input/_X11.py'
--- autopilot/input/_X11.py	2013-11-07 05:53:36 +0000
+++ autopilot/input/_X11.py	2014-01-19 00:39:05 +0000
@@ -455,7 +455,7 @@
         x, y = coord["root_x"], coord["root_y"]
         return x, y
 
-    def drag(self, x1, y1, x2, y2):
+    def drag(self, x1, y1, x2, y2, rate=10):
         """Performs a press, move and release.
 
         This is to keep a common API between Mouse and Finger as long as
@@ -464,7 +464,7 @@
         """
         self.move(x1, y1)
         self.press()
-        self.move(x2, y2)
+        self.move(x2, y2, rate=rate)
         self.release()
 
     @classmethod
 
=== modified file 'autopilot/input/_uinput.py'
--- autopilot/input/_uinput.py	2013-11-07 05:53:36 +0000
+++ autopilot/input/_uinput.py	2014-01-19 00:39:05 +0000
@@ -361,23 +361,33 @@
             raise RuntimeError("Attempting to move without finger being down.")
         self._finger_move(x, y)
 
-    def drag(self, x1, y1, x2, y2):
+    def drag(self, x1, y1, x2, y2, rate=10):
         """Perform a drag gesture from (x1,y1) to (x2,y2)"""
         logger.debug("Dragging from %d,%d to %d,%d", x1, y1, x2, y2)
         self._finger_down(x1, y1)
 
-        # Let's drag in 100 steps for now...
-        dx = 1.0 * (x2 - x1) / 100
-        dy = 1.0 * (y2 - y1) / 100
-        cur_x = x1 + dx
-        cur_y = y1 + dy
-        for i in range(0, 100):
-            self._finger_move(int(cur_x), int(cur_y))
+        current_x, current_y = x1, y1
+        while current_x != x2 or current_y != y2:
+            dx = abs(x2 - current_x)
+            dy = abs(y2 - current_y)
+
+            intx = float(dx) / max(dx, dy)
+            inty = float(dy) / max(dx, dy)
+
+            step_x = min(rate * intx, dx)
+            step_y = min(rate * inty, dy)
+
+            if x2 < current_x:
+                step_x *= -1
+            if y2 < current_y:
+                step_y *= -1
+
+            current_x += step_x
+            current_y += step_y
+            self._finger_move(current_x, current_y)
+
             sleep(0.002)
-            cur_x += dx
-            cur_y += dy
-        # Make sure we actually end up at target
-        self._finger_move(x2, y2)
+
         self._finger_up()
 
     def _finger_down(self, x, y):
 
=== modified file 'autopilot/tests/unit/test_input.py'
--- autopilot/tests/unit/test_input.py	2014-01-07 00:21:08 +0000
+++ autopilot/tests/unit/test_input.py	2014-01-19 00:39:05 +0000
@@ -1,7 +1,7 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 #
 # Autopilot Functional Test Tool
-# Copyright (C) 2013 Canonical
+# Copyright (C) 2013, 2014 Canonical
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -17,12 +17,18 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from mock import patch
+import testscenarios
+
+from mock import call, Mock, patch
 from testtools import TestCase
 from testtools.matchers import raises
 
+<<<<<<< TREE
 from autopilot import input
 from autopilot.input import _uinput
+=======
+from autopilot.input import _uinput, _X11
+>>>>>>> MERGE-SOURCE
 from autopilot.input._common import get_center_point
 
 
@@ -153,6 +159,7 @@
 
         self.assertEqual(123, x)
         self.assertEqual(345, y)
+<<<<<<< TREE
 
 
 class PointerWithTouchBackendTestCase(TestCase):
@@ -182,3 +189,182 @@
             self.pointer.move(1, 1)
 
         self.assertFalse(mock_move.called)
+=======
+
+
+class PartialMock(object):
+    """Mock some of the methods of an object, and record their calls."""
+
+    def __init__(self, real_object, *args):
+        super(PartialMock, self).__init__()
+        self._mock_manager = Mock()
+        self._real_object = real_object
+        self.patched_attributes = args
+
+    def __getattr__(self, name):
+        """Forward all the calls to the real object."""
+        return self._real_object.__getattribute__(name)
+
+    @property
+    def mock_calls(self):
+        """Return the calls recorded for the mocked attributes."""
+        return self._mock_manager.mock_calls
+
+    def __enter__(self):
+        self._start_patchers()
+        return self
+
+    def _start_patchers(self):
+        self._patchers = []
+        for attribute in self.patched_attributes:
+            patcher = patch.object(self._real_object, attribute)
+            self._patchers.append(patcher)
+
+            self._mock_manager.attach_mock(patcher.start(), attribute)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._stop_patchers()
+
+    def _stop_patchers(self):
+        for patcher in self._patchers:
+            patcher.stop()
+
+
+class MockX11Mouse(PartialMock):
+    """Mock for the X11 Mouse Touch.
+
+    It records the calls to press, release and move, but doesn't perform them.
+
+    """
+
+    def __init__(self):
+        super(MockX11Mouse, self).__init__(
+            _X11.Mouse(), 'press', 'release', 'move')
+
+    def get_move_call_args_list(self):
+        return self._mock_manager.move.call_args_list
+
+
+class X11MouseTestCase(TestCase):
+
+    def test_drag_should_call_move_with_rate(self):
+        expected_first_move_call = call(0, 0)
+        expected_second_move_call = call(100, 100, rate=1)
+        with MockX11Mouse() as mock_mouse:
+            mock_mouse.drag(0, 0, 100, 100, rate=1)
+
+        self.assertEqual(
+            [expected_first_move_call, expected_second_move_call],
+            mock_mouse.get_move_call_args_list())
+
+    def test_drag_with_default_rate(self):
+        expected_first_move_call = call(0, 0)
+        expected_second_move_call = call(100, 100, rate=10)
+        with MockX11Mouse() as mock_mouse:
+            mock_mouse.drag(0, 0, 100, 100)
+
+        self.assertEqual(
+            [expected_first_move_call, expected_second_move_call],
+            mock_mouse.get_move_call_args_list())
+
+
+class MockTouch(PartialMock):
+    """Mock for the uinput Touch.
+
+    It records the calls to _finger_down, _finger_up and _finger_move, but
+    doesn't perform them.
+
+    """
+
+    def __init__(self):
+        super(MockTouch, self).__init__(
+            _uinput.Touch(), '_finger_down', '_finger_up', '_finger_move')
+
+    def get_finger_move_call_args_list(self):
+        return self._mock_manager._finger_move.call_args_list
+
+
+class UinputTouchTestCase(TestCase):
+
+    def test_drag_finger_actions(self):
+        expected_finger_calls = [
+            call._finger_down(0, 0),
+            call._finger_move(10, 10),
+            call._finger_up()
+        ]
+        with MockTouch() as mock_touch:
+            mock_touch.drag(0, 0, 10, 10)
+        self.assertEqual(mock_touch.mock_calls, expected_finger_calls)
+
+    def test_drag_should_call_move_with_rate(self):
+        expected_move_calls = [call(5, 5), call(10, 10), call(15, 15)]
+        with MockTouch() as mock_touch:
+            mock_touch.drag(0, 0, 15, 15, rate=5)
+
+        self.assertEqual(
+            expected_move_calls, mock_touch.get_finger_move_call_args_list())
+
+    def test_drag_with_default_rate(self):
+        expected_move_calls = [call(10, 10), call(20, 20)]
+        with MockTouch() as mock_touch:
+            mock_touch.drag(0, 0, 20, 20)
+
+        self.assertEqual(
+            expected_move_calls, mock_touch.get_finger_move_call_args_list())
+
+    def test_drag_to_same_place_should_not_move(self):
+        expected_finger_calls = [
+            call._finger_down(0, 0),
+            call._finger_up()
+        ]
+        with MockTouch() as mock_touch:
+            mock_touch.drag(0, 0, 0, 0)
+        self.assertEqual(mock_touch.mock_calls, expected_finger_calls)
+
+
+class DragUinputTouchTestCase(testscenarios.TestWithScenarios, TestCase):
+
+    scenarios = [
+        ('drag to top', dict(
+            start_x=50, start_y=50, stop_x=50, stop_y=30,
+            expected_moves=[call(50, 40), call(50, 30)])),
+        ('drag to bottom', dict(
+            start_x=50, start_y=50, stop_x=50, stop_y=70,
+            expected_moves=[call(50, 60), call(50, 70)])),
+        ('drag to left', dict(
+            start_x=50, start_y=50, stop_x=30, stop_y=50,
+            expected_moves=[call(40, 50), call(30, 50)])),
+        ('drag to right', dict(
+            start_x=50, start_y=50, stop_x=70, stop_y=50,
+            expected_moves=[call(60, 50), call(70, 50)])),
+
+        ('drag to top-left', dict(
+            start_x=50, start_y=50, stop_x=30, stop_y=30,
+            expected_moves=[call(40, 40), call(30, 30)])),
+        ('drag to top-right', dict(
+            start_x=50, start_y=50, stop_x=70, stop_y=30,
+            expected_moves=[call(60, 40), call(70, 30)])),
+        ('drag to bottom-left', dict(
+            start_x=50, start_y=50, stop_x=30, stop_y=70,
+            expected_moves=[call(40, 60), call(30, 70)])),
+        ('drag to bottom-right', dict(
+            start_x=50, start_y=50, stop_x=70, stop_y=70,
+            expected_moves=[call(60, 60), call(70, 70)])),
+
+        ('drag less than rate', dict(
+            start_x=50, start_y=50, stop_x=55, stop_y=55,
+            expected_moves=[call(55, 55)])),
+
+        ('drag with last move less than rate', dict(
+            start_x=50, start_y=50, stop_x=65, stop_y=65,
+            expected_moves=[call(60, 60), call(65, 65)])),
+    ]
+
+    def test_drag_moves(self):
+        with MockTouch() as mock_touch:
+            mock_touch.drag(
+                self.start_x, self.start_y, self.stop_x, self.stop_y)
+
+        self.assertEqual(
+            self.expected_moves, mock_touch.get_finger_move_call_args_list())
+>>>>>>> MERGE-SOURCE