Autopilot

autopilot/input/_X11.py (+19/-4)
autopilot/input/__init__.py (+63/-7)
autopilot/input/_uinput.py (+39/-14)
autopilot/tests/functional/test_input_stack.py (+2/-1)
autopilot/tests/unit/test_input.py (+157/-2)

To merge this branch:

bzr merge lp:~elopio/autopilot/fix1257055-slow_drag

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Thomi Richards (community)		2014-02-11	Approve on 2014-02-12
PS Jenkins bot	continuous-integration	2014-02-11	Approve on 2014-02-11
Leo Arias			Pending
Review via email: mp+205702@code.launchpad.net

This proposal supersedes a proposal from 2014-01-19.

Commit message

Added Mouse, Touch and Pointer drags with rate.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-01-19: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:421
http://jenkins.qa.ubuntu.com/job/autopilot-ci/406/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-amd64-ci/132/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-armhf-ci/132/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/2453/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/2455/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/406/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-01-19: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:423
http://jenkins.qa.ubuntu.com/job/autopilot-ci/407/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-amd64-ci/133/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-armhf-ci/133/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/2454/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/2456/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/407/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-01-20: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:425
http://jenkins.qa.ubuntu.com/job/autopilot-ci/413/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-amd64-ci/139/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-armhf-ci/139/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/2480/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/2482/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/413/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

Thomi Richards (thomir-deactivatedaccount) wrote on 2014-02-09: Posted in a previous version of this proposal

Hi,

I'm not sure if this MP is still relevant. If it's not, please delete the proposal to merge. If it is, then:

39 - def drag(self, x1, y1, x2, y2):
40 + def drag(self, x1, y1, x2, y2, rate=10):

If you're adding (or removing, or changing) a parameter to a public method, please document it in the docstrings. What exactly is 'rate' measured in anyway?

82 - def drag(self, x1, y1, x2, y2):
83 + def drag(self, x1, y1, x2, y2, rate=10):

You introduce a new parameter, and then don't use it at all in the method.

In general this MP makes me feel rather uneasy. You're introducing a new parameter, and some code changes, and I can't see any justification for it.

If this is really needed, I think it might be worth moving the algorithm to a common location, and making both the X11 and uinput backends be able to use it. That way, you can test it without needing to mock out anything.

Anyway, please talk to me on IRC about this. We need to either clean it up and merge it, or remove it from the review queue.

review: Needs Fixing

Revision history for this message

Thomi Richards (thomir-deactivatedaccount) wrote on 2014-02-09: Posted in a previous version of this proposal

Hi,

In order to make our review queue a little more sane, I'm setting this to WIP. If/when you need a new review, please set it back to 'Needs Review', and (optionally) ping someone on the AP team.

Thanks.

Revision history for this message

Leo Arias (elopio) wrote on 2014-02-11:

What exactly is 'rate' measured in anyway?

It's the number of pixels you advance per iteration. This is really confusing for me, I spent a couple of hours deciphering the algorithm; but unfortunately, that's what you chose for Mouse API. I would prefer something like the number of seconds that the drag will take, but at this point we can't change the Mouse API and the best we can do is to make the Touch API similar.

Revision history for this message

Leo Arias (elopio) wrote on 2014-02-11:

> If you're adding (or removing, or changing) a parameter to a public method, please document it in the docstrings.

I did my best. Please check it.

> In general this MP makes me feel rather uneasy. You're introducing a new parameter, and some code changes, and I can't see any justification for it.

The justification is on the linked bug. We need a way to slow down the drags. If we do them with the current hard-coded rate, when we try to make a new item visible on a list, we end up on the bottom of the list instead.

> If this is really needed, I think it might be worth moving the algorithm to a common location, and making both the X11 and uinput backends be able to use it. That way, you can test it without needing to mock out anything.

That's not actually possible at the moment, because the X11 relies on the move method, and so, it uses the current position of the pointer. On Touch, we don't have a current position, so there's no clean way to do a slow drag. Of course, I plan to keep cleaning things up, and that's something I will try in the following weeks.

But for now, I am losing my head with the number of workarounds I have to do on every place where the drag fails. This is an improvement from the current status, that has a hard-coded value of 100 steps per drag on the touch and 10 pixels per iteration on the mouse, which is inconsistent and comes without tests.

Lets talk tomorrow on IRC.

For now, I'll update the tests to use the new testability that comes from the branch I've added as a prerequisite.

Revision history for this message

Leo Arias (elopio) wrote on 2014-02-11:

Sorry, where it says: so there's no clean way to do a slow drag
It should say: so there's no clean way to do a slow move

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-02-11:

FAILED: Continuous integration, rev:433
http://jenkins.qa.ubuntu.com/job/autopilot-ci/483/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-amd64-ci/209/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-armhf-ci/209/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/autopilot-trusty-i386-ci/118/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-trusty/3100/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-trusty-amd64/3102/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/483/rebuild

review: Needs Fixing (continuous-integration)

lp:~elopio/autopilot/fix1257055-slow_drag updated on 2014-02-11

434. By Leo Arias on 2014-02-11: We can't use the real Mouse, so switch to touch backend for now.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-02-11:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/485/rebuild

review: Needs Fixing (continuous-integration)

lp:~elopio/autopilot/fix1257055-slow_drag updated on 2014-02-11

435. By Leo Arias on 2014-02-11: Updated the fake.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-02-11:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/487/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-02-11:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/488/rebuild

review: Approve (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2014-02-11:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/autopilot-ci/489/rebuild

review: Approve (continuous-integration)

Revision history for this message

Thomi Richards (thomir-deactivatedaccount) wrote on 2014-02-12:

Hi,

What's confusing me is that the new parameter 'rate' isn't used in this code:

193 + current_x, current_y = x1, y1
194 + while current_x != x2 or current_y != y2:
195 + dx = abs(x2 - current_x)
196 + dy = abs(y2 - current_y)
197 +
198 + intx = float(dx) / max(dx, dy)
199 + inty = float(dy) / max(dx, dy)
200 +
201 + step_x = min(rate * intx, dx)
202 + step_y = min(rate * inty, dy)
203 +
204 + if x2 < current_x:
205 + step_x *= -1
206 + if y2 < current_y:
207 + step_y *= -1
208 +
209 + current_x += step_x
210 + current_y += step_y
211 + self._device.finger_move(current_x, current_y)
212 +
213 + sleep(time_between_events)

So I don't see the point in adding the parameter if we're not going to use it.

review: Needs Information

Revision history for this message

Leo Arias (elopio) wrote on 2014-02-12:

201 + step_x = min(rate * intx, dx)
202 + step_y = min(rate * inty, dy)

I'm using it!

Actually, you are using it, as most of this code comes from X11 move. Here we are making sure that if the distance is smaller than the rate (which happens on the last iteration), we will make a move that will get us to the destination point and not farther. I added tests for this condition.

Revision history for this message

Thomi Richards (thomir-deactivatedaccount) wrote on 2014-02-12:

huh, sorry, I must be blind.

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Autopilot Hackers

Chris Gagnon

Leo Arias

 === modified file 'autopilot/input/_X11.py'
 --- autopilot/input/_X11.py	2013-11-07 05:53:36 +0000
 +++ autopilot/input/_X11.py	2014-02-11 12:23:36 +0000
@@ -1,7 +1,7 @@
  # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+ #
  # Autopilot Functional Test Tool
--# Copyright (C) 2012-2013 Canonical
++# Copyright (C) 2012, 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
@@ -455,16 +455,31 @@
          x, y = coord["root_x"], coord["root_y"]
          return x, y
--    def drag(self, x1, y1, x2, y2):
--        """Performs a press, move and release.
++    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
++        """Perform a press, move and release.
          This is to keep a common API between Mouse and Finger as long as
          possible.
++        The pointer will be dragged from the starting point to the ending point
++        with multiple moves. The number of moves, and thus the time that it
++        will take to complete the drag can be altered with the `rate`
++        parameter.
++
++        :param x1: The point on the x axis where the drag will start from.
++        :param y1: The point on the y axis where the drag will starts from.
++        :param x2: The point on the x axis where the drag will end at.
++        :param y2: The point on the y axis where the drag will end at.
++        :param rate: The number of pixels the mouse will be moved per
++            iteration. Default is 10 pixels. A higher rate will make the drag
++            faster, and lower rate will make it slower.
++        :param time_between_events: The number of seconds that the drag will
++            wait between iterations.
++
          """
          self.move(x1, y1)
          self.press()
--        self.move(x2, y2)
++        self.move(x2, y2, rate=rate, time_between_events=time_between_events)
          self.release()
      @classmethod
 === modified file 'autopilot/input/__init__.py'
 --- autopilot/input/__init__.py	2013-09-20 19:01:27 +0000
 +++ autopilot/input/__init__.py	2014-02-11 12:23:36 +0000
@@ -369,12 +369,27 @@
          """
          raise NotImplementedError("You cannot use this class directly.")
--    def drag(self, x1, y1, x2, y2):
--        """Performs a press, move and release.
++    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
++        """Perform a press, move and release.
          This is to keep a common API between Mouse and Finger as long as
          possible.
++        The pointer will be dragged from the starting point to the ending point
++        with multiple moves. The number of moves, and thus the time that it
++        will take to complete the drag can be altered with the `rate`
++        parameter.
++
++        :param x1: The point on the x axis where the drag will start from.
++        :param y1: The point on the y axis where the drag will starts from.
++        :param x2: The point on the x axis where the drag will end at.
++        :param y2: The point on the y axis where the drag will end at.
++        :param rate: The number of pixels the mouse will be moved per
++            iteration. Default is 10 pixels. A higher rate will make the drag
++            faster, and lower rate will make it slower.
++        :param time_between_events: The number of seconds that the drag will
++            wait between iterations.
++
          """
          raise NotImplementedError("You cannot use this class directly.")
@@ -466,8 +481,28 @@
          """Release a previously pressed finger"""
          raise NotImplementedError("You cannot use this class directly.")
--    def drag(self, x1, y1, x2, y2):
--        """Perform a drag gesture from (x1,y1) to (x2,y2)"""
++    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
++        """Perform a drag gesture.
++
++        The finger will be dragged from the starting point to the ending point
++        with multiple moves. The number of moves, and thus the time that it
++        will take to complete the drag can be altered with the `rate`
++        parameter.
++
++        :param x1: The point on the x axis where the drag will start from.
++        :param y1: The point on the y axis where the drag will starts from.
++        :param x2: The point on the x axis where the drag will end at.
++        :param y2: The point on the y axis where the drag will end at.
++        :param rate: The number of pixels the finger will be moved per
++            iteration. Default is 10 pixels. A higher rate will make the drag
++            faster, and lower rate will make it slower.
++        :param time_between_events: The number of seconds that the drag will
++            wait between iterations.
++
++        :raises RuntimeError: if the finger is already pressed.
++        :raises RuntimeError: if no more finger slots are available.
++
++        """
          raise NotImplementedError("You cannot use this class directly.")
@@ -641,9 +676,30 @@
          else:
              return (self._x, self._y)
--    def drag(self, x1, y1, x2, y2):
--        """Performs a press, move and release."""
--        self._device.drag(x1, y1, x2, y2)
++    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
++        """Perform a press, move and release.
++
++        This is to keep a common API between Mouse and Finger as long as
++        possible.
++
++        The pointer will be dragged from the starting point to the ending point
++        with multiple moves. The number of moves, and thus the time that it
++        will take to complete the drag can be altered with the `rate`
++        parameter.
++
++        :param x1: The point on the x axis where the drag will start from.
++        :param y1: The point on the y axis where the drag will starts from.
++        :param x2: The point on the x axis where the drag will end at.
++        :param y2: The point on the y axis where the drag will end at.
++        :param rate: The number of pixels the mouse will be moved per
++            iteration. Default is 10 pixels. A higher rate will make the drag
++            faster, and lower rate will make it slower.
++        :param time_between_events: The number of seconds that the drag will
++            wait between iterations.
++
++        """
++        self._device.drag(
++            x1, y1, x2, y2, rate=rate, time_between_events=time_between_events)
          if isinstance(self._device, Touch):
              self._x = x2
              self._y = y2
 === modified file 'autopilot/input/_uinput.py'
 --- autopilot/input/_uinput.py	2014-02-11 12:23:36 +0000
 +++ autopilot/input/_uinput.py	2014-02-11 12:23:36 +0000
@@ -521,8 +521,23 @@
          """
          self._device.finger_move(x, y)
--    def drag(self, x1, y1, x2, y2):
--        """Perform a drag gesture from (x1,y1) to (x2,y2).
++    def drag(self, x1, y1, x2, y2, rate=10, time_between_events=0.01):
++        """Perform a drag gesture.
++
++        The finger will be dragged from the starting point to the ending point
++        with multiple moves. The number of moves, and thus the time that it
++        will take to complete the drag can be altered with the `rate`
++        parameter.
++
++        :param x1: The point on the x axis where the drag will start from.
++        :param y1: The point on the y axis where the drag will starts from.
++        :param x2: The point on the x axis where the drag will end at.
++        :param y2: The point on the y axis where the drag will end at.
++        :param rate: The number of pixels the finger will be moved per
++            iteration. Default is 10 pixels. A higher rate will make the drag
++            faster, and lower rate will make it slower.
++        :param time_between_events: The number of seconds that the drag will
++            wait between iterations.
          :raises RuntimeError: if the finger is already pressed.
          :raises RuntimeError: if no more finger slots are available.
@@ -531,18 +546,28 @@
          logger.debug("Dragging from %d,%d to %d,%d", x1, y1, x2, y2)
          self._device.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._device.finger_move(int(cur_x), int(cur_y))
--            sleep(0.002)
--            cur_x += dx
--            cur_y += dy
--        # Make sure we actually end up at target
--        self._device.finger_move(x2, y2)
++        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._device.finger_move(current_x, current_y)
++
++            sleep(time_between_events)
++
          self._device.finger_up()
 === modified file 'autopilot/tests/functional/test_input_stack.py'
 --- autopilot/tests/functional/test_input_stack.py	2014-02-11 12:23:36 +0000
 +++ autopilot/tests/functional/test_input_stack.py	2014-02-11 12:23:36 +0000
@@ -487,7 +487,8 @@
              def __init__(self):
                  pass
--            def drag(self, x1, y1, x2, y2):
++            def drag(self, x1, y1, x2, y2, rate='dummy',
++                     time_between_events='dummy'):
                  pass
          p = Pointer(FakeTouch())
 === modified file 'autopilot/tests/unit/test_input.py'
 --- autopilot/tests/unit/test_input.py	2014-02-11 12:23:36 +0000
 +++ autopilot/tests/unit/test_input.py	2014-02-11 12:23:36 +0000
@@ -19,14 +19,15 @@
  import testscenarios
  from evdev import ecodes, uinput
--from mock import ANY, call, patch, Mock
++from mock import ANY, call, Mock, patch
  from six import StringIO
  from testtools import TestCase
  from testtools.matchers import Contains, raises
++import autopilot.input
++from autopilot import utilities
  from autopilot.input import _uinput
  from autopilot.input._common import get_center_point
--from autopilot import utilities
  class Empty(object):
@@ -698,6 +699,54 @@
          touch.move(10, 10)
          self.assertEqual(expected_calls, touch._device.mock_calls)
++    def test_drag_must_call_finger_down_move_and_up(self):
++        expected_calls = [
++            call.finger_down(0, 0),
++            call.finger_move(10, 10),
++            call.finger_up()
++        ]
++
++        touch = self.get_touch_with_mocked_backend()
++        touch.drag(0, 0, 10, 10)
++        self.assertEqual(expected_calls, touch._device.mock_calls)
++
++    def test_drag_must_move_with_specified_rate(self):
++        expected_calls = [
++            call.finger_down(0, 0),
++            call.finger_move(5, 5),
++            call.finger_move(10, 10),
++            call.finger_move(15, 15),
++            call.finger_up()]
++
++        touch = self.get_touch_with_mocked_backend()
++        touch.drag(0, 0, 15, 15, rate=5)
++
++        self.assertEqual(
++            expected_calls, touch._device.mock_calls)
++
++    def test_drag_without_rate_must_use_default(self):
++        expected_calls = [
++            call.finger_down(0, 0),
++            call.finger_move(10, 10),
++            call.finger_move(20, 20),
++            call.finger_up()]
++
++        touch = self.get_touch_with_mocked_backend()
++        touch.drag(0, 0, 20, 20)
++
++        self.assertEqual(
++            expected_calls, touch._device.mock_calls)
++
++    def test_drag_to_same_place_must_not_move(self):
++        expected_calls = [
++            call.finger_down(0, 0),
++            call.finger_up()
++        ]
++
++        touch = self.get_touch_with_mocked_backend()
++        touch.drag(0, 0, 0, 0)
++        self.assertEqual(expected_calls, touch._device.mock_calls)
++
  class MultipleUInputTouchBackend(_uinput._UInputTouchDevice):
@@ -731,3 +780,109 @@
          self.addCleanup(finger1.release)
          self.assertFalse(finger2.pressed)
++
++
++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.finger_move(50, 40),
++                            call.finger_move(50, 30)])),
++        ('drag to bottom', dict(
++            start_x=50, start_y=50, stop_x=50, stop_y=70,
++            expected_moves=[call.finger_move(50, 60),
++                            call.finger_move(50, 70)])),
++        ('drag to left', dict(
++            start_x=50, start_y=50, stop_x=30, stop_y=50,
++            expected_moves=[call.finger_move(40, 50),
++                            call.finger_move(30, 50)])),
++        ('drag to right', dict(
++            start_x=50, start_y=50, stop_x=70, stop_y=50,
++            expected_moves=[call.finger_move(60, 50),
++                            call.finger_move(70, 50)])),
++
++        ('drag to top-left', dict(
++            start_x=50, start_y=50, stop_x=30, stop_y=30,
++            expected_moves=[call.finger_move(40, 40),
++                            call.finger_move(30, 30)])),
++        ('drag to top-right', dict(
++            start_x=50, start_y=50, stop_x=70, stop_y=30,
++            expected_moves=[call.finger_move(60, 40),
++                            call.finger_move(70, 30)])),
++        ('drag to bottom-left', dict(
++            start_x=50, start_y=50, stop_x=30, stop_y=70,
++            expected_moves=[call.finger_move(40, 60),
++                            call.finger_move(30, 70)])),
++        ('drag to bottom-right', dict(
++            start_x=50, start_y=50, stop_x=70, stop_y=70,
++            expected_moves=[call.finger_move(60, 60),
++                            call.finger_move(70, 70)])),
++
++        ('drag less than rate', dict(
++            start_x=50, start_y=50, stop_x=55, stop_y=55,
++            expected_moves=[call.finger_move(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.finger_move(60, 60),
++                            call.finger_move(65, 65)])),
++    ]
++
++    def setUp(self):
++        super(DragUInputTouchTestCase, self).setUp()
++        # Mock the sleeps so we don't have to spend time actually sleeping.
++        self.addCleanup(utilities.sleep.disable_mock)
++        utilities.sleep.enable_mock()
++
++    def get_touch_with_mocked_backend(self):
++        touch = _uinput.Touch(device_class=Mock)
++        touch._device.mock_add_spec(
++            _uinput._UInputTouchDevice, spec_set=True)
++        return touch
++
++    def test_drag_moves(self):
++        touch = self.get_touch_with_mocked_backend()
++
++        touch.drag(
++            self.start_x, self.start_y, self.stop_x, self.stop_y)
++
++        # We don't check the finger down and finger up. They are already
++        # tested.
++        expected_calls = [ANY] + self.expected_moves + [ANY]
++        self.assertEqual(
++            expected_calls, touch._device.mock_calls)
++
++
++class PointerWithTouchBackendTestCase(TestCase):
++
++    def get_pointer_with_touch_backend_with_mock_device(self):
++        touch = _uinput.Touch(device_class=Mock)
++        touch._device.mock_add_spec(
++            _uinput._UInputTouchDevice, spec_set=True)
++        pointer = autopilot.input.Pointer(touch)
++        return pointer
++
++    def test_drag_with_rate(self):
++        pointer = self.get_pointer_with_touch_backend_with_mock_device()
++        with patch.object(pointer._device, 'drag') as mock_drag:
++            pointer.drag(0, 0, 20, 20, rate='test')
++
++        mock_drag.assert_called_once_with(
++            0, 0, 20, 20, rate='test', time_between_events=0.01)
++
++    def test_drag_with_time_between_events(self):
++        pointer = self.get_pointer_with_touch_backend_with_mock_device()
++        with patch.object(pointer._device, 'drag') as mock_drag:
++            pointer.drag(0, 0, 20, 20, time_between_events='test')
++
++        mock_drag.assert_called_once_with(
++            0, 0, 20, 20, rate=10, time_between_events='test')
++
++    def test_drag_with_default_parameters(self):
++        pointer = self.get_pointer_with_touch_backend_with_mock_device()
++        with patch.object(pointer._device, 'drag') as mock_drag:
++            pointer.drag(0, 0, 20, 20)
++
++        mock_drag.assert_called_once_with(
++            0, 0, 20, 20, rate=10, time_between_events=0.01)

Autopilot

Merge lp:~elopio/autopilot/fix1257055-slow_drag into lp:autopilot

Commit message

Description of the change

Preview Diff

Subscribers