Merge lp:~thomir-deactivatedaccount/camera-app/autopilot-tests-port into lp:camera-app

[Thomi Richards]

This brnch contains the minimum set of changes required to port the camera-app tests to autopilot 1.3.

DO NOT MERGE THIS BRANCH!

...until you're ready to start using the new autopilot.

[lp:~thomir-deactivatedaccount/camera-app/autopilot-tests-port]

127. By Thomi Richards on 2013-04-26

various test cleanups.

128. By Thomi Richards on 2013-04-30

Example of how to use scenarios.

[Leo Arias (elopio)]

This branch is no longer need.

review: Disapprove

Unmerged revisions

128. By Thomi Richards on 2013-04-30

Example of how to use scenarios.

127. By Thomi Richards on 2013-04-26

various test cleanups.

126. By Thomi Richards on 2013-04-25

port tests to new API.

125. By Thomi Richards on 2013-04-25

removed another unused import.

124. By Thomi Richards on 2013-04-25

removed unused imports.

=== modified file 'tests/autopilot/camera_app/tests/__init__.py'
--- tests/autopilot/camera_app/tests/__init__.py	2012-12-17 14:07:00 +0000
+++ tests/autopilot/camera_app/tests/__init__.py	2013-04-30 00:10:42 +0000
@@ -7,25 +7,31 @@
 
 """Camera-app autopilot tests."""
 
-from os import remove
 import os.path
 
-from autopilot.introspection.qt import QtIntrospectionTestMixin
 from autopilot.testcase import AutopilotTestCase
+from testtools.matchers import Equals
 
 from camera_app.emulators.main_window import MainWindow
 
-class CameraAppTestCase(AutopilotTestCase, QtIntrospectionTestMixin):
+class CameraAppTestCase(AutopilotTestCase):
 
     """A common test case class that provides several useful methods for camera-app tests."""
+    scenarios = [
+        ('with mouse', dict(input_device_class=Mouse)),
+        ('with touch', dict(input_device_class=Touch)),
+        ]
 
     def setUp(self):
+        self.input_device = self.input_device_class.create()
         super(CameraAppTestCase, self).setUp()
         # Lets assume we are installed system wide if this file is somewhere in /usr
         if os.path.realpath(__file__).startswith("/usr/"):
             self.launch_test_installed()
         else:
             self.launch_test_local()
+        # wait for the main window to be visible:
+        self.assertThat(self.main_window.get_qml_view().visible, Eventually(Equals(True)))
 
     def launch_test_local(self):
         self.app = self.launch_test_application(
@@ -40,10 +46,6 @@
             self.app = self.launch_test_application(
                "camera-app")
 
-    @staticmethod
-    def running_on_device():
-        return os.path.isfile('/system/usr/idc/autopilot-finger.idc')
-
     @property
     def main_window(self):
         return MainWindow(self.app)

=== modified file 'tests/autopilot/camera_app/tests/test_capture.py'
--- tests/autopilot/camera_app/tests/test_capture.py	2013-04-17 20:40:53 +0000
+++ tests/autopilot/camera_app/tests/test_capture.py	2013-04-30 00:10:42 +0000
@@ -9,63 +9,62 @@
 
 from __future__ import absolute_import
 
-from testtools.matchers import Equals, NotEquals, GreaterThan
 from autopilot.matchers import Eventually
+from autopilot.platform import model
+from testtools.matchers import Equals, NotEquals, HasLength
 
 from camera_app.tests import CameraAppTestCase
 
-import unittest
-import time
+import testtools
+import glob
 import os
 from os import path
 
 class TestCapture(CameraAppTestCase):
     """Tests the main camera features"""
 
-    """ This is needed to wait for the application to start.
-        In the testfarm, the application may take some time to show up."""
-    def setUp(self):
-        super(TestCapture, self).setUp()
-        self.assertThat(self.main_window.get_qml_view().visible, Eventually(Equals(True)))
-
-    def tearDown(self):
-        super(TestCapture, self).tearDown()
-
-    """Test taking a picture"""
-    def test_take_picture(self):
-        toolbar = self.main_window.get_toolbar()
-        exposure_button = self.main_window.get_exposure_button()
-        pictures_dir = path.expanduser("~/Pictures")
+    def cleanup_picture_files(self):
+        """Cleanup picture files from ~/Pictures that matches our file naming pattern."""
+        pictures_dir = self.get_picture_dir()
 
         # Remove all pictures from ~/Pictures that match our pattern
         files = [ f for f in os.listdir(pictures_dir) if f[0:5] == "image" and path.isfile(path.join(pictures_dir,f))]
         for f in files:
             os.remove(path.join(pictures_dir, f))
 
+    def get_picture_dir(self):
+        """Return the picture folder path."""
+        return path.expanduser("~/Pictures")
+
+    def get_pictures_on_disk(self):
+        """Return a list of pictures on the disk."""
+        return glob.glob(path.join(self.get_picture_dir(), "image*"))
+
+    def test_take_picture(self):
+        """Must be able to take a picture."""
+        # cleanup before the test starts, just to be safe:
+        self.cleanup_picture_files()
+
+        exposure_button = self.main_window.get_exposure_button()
+
         # Wait for the camera to have finished focusing (the exposure button gets enabled when ready)
         self.assertThat(exposure_button.enabled, Eventually(Equals(True)))
 
         # Now take the picture! (Give it a little time to animate)
         self.mouse.move_to_object(exposure_button)
         self.mouse.click()
+        self.addCleanup(self.cleanup_picture_files)
 
         # Check that only one picture with the right name pattern is actually there
-        one_picture_on_disk = False
-        for i in range(0, 10):
-            files = [ f for f in os.listdir(pictures_dir) if f[0:5] == "image" and path.isfile(path.join(pictures_dir,f))]
-            if len(files) == 1:
-                one_picture_on_disk = True
-                break
-            time.sleep(1)
-        self.assertEquals(one_picture_on_disk, True)
+        self.assertThat(self.get_pictures_on_disk, Eventually(HasLength(1)))
 
-    """Tests clicking on the record control and checks if the flash changes
-    to torch off mode and the recording time appears"""
-    @unittest.skipIf(CameraAppTestCase.running_on_device(), 'recording not available on device yet')
+    @testtools.skipUnless(model == 'Desktop', 'recording not available on device yet')
     def test_record_video(self):
+        """Clicking on the record control
+
+        Tests clicking on the record control and checks if the flash changes
+        to torch off mode and the recording time appears"""
         # Get all the elements
-        camera_window = self.main_window.get_camera()
-        toolbar = self.main_window.get_toolbar()
         record_control = self.main_window.get_record_control()
         flash_button = self.main_window.get_flash_button()
         stop_watch = self.main_window.get_stop_watch()
@@ -86,7 +85,7 @@
         # Before recording the stop watch should read zero recording time
         # and not be visible anyway.
         self.assertThat(stop_watch.opacity, Equals(0.0))
-        self.assertEquals(stop_watch.elapsed, "00:00")
+        self.assertThat(stop_watch.elapsed, Equals("00:00"))
 
         # Click the exposure button to start recording
         self.mouse.move_to_object(exposure_button)
@@ -111,7 +110,7 @@
         self.assertThat(flash_button.flashState, Eventually(Equals("off")))
         self.assertThat(flash_button.torchMode, Eventually(Equals(True)))
         self.assertThat(stop_watch.opacity, Eventually(Equals(1.0)))
-        self.assertEquals(stop_watch.elapsed, "00:00")
+        self.assertThat(stop_watch.elapsed, Equals("00:00"))
 
         # Record video for 2 seconds and check if the stop watch actually works
         self.assertThat(stop_watch.elapsed, Eventually(NotEquals("00:00")))
@@ -125,12 +124,12 @@
         self.assertThat(flash_button.flashState, Eventually(Equals(flashlight_old_state)))
         self.assertThat(flash_button.torchMode, Eventually(Equals(torchmode_old_state)))
 
-    """Test that the shoot button gets disabled for a while then re-enabled after shooting"""
     def test_shoot_button_disable(self):
+        """The shoot button must be disabled and then re-enabled after shooting."""
         exposure_button = self.main_window.get_exposure_button()
 
         # The focus ring should be invisible in the beginning
-        self.assertEquals(exposure_button.enabled, True)
+        self.assertThat(exposure_button.enabled, Equals(True))
 
         # Now take the picture! (Give it a little time to animate)
         self.mouse.move_to_object(exposure_button)

=== modified file 'tests/autopilot/camera_app/tests/test_flash.py'
--- tests/autopilot/camera_app/tests/test_flash.py	2013-04-17 20:40:53 +0000
+++ tests/autopilot/camera_app/tests/test_flash.py	2013-04-30 00:10:42 +0000
@@ -9,71 +9,45 @@
 
 from __future__ import absolute_import
 
-from testtools.matchers import Equals, NotEquals
+from testtools.matchers import Equals
 from autopilot.matchers import Eventually
 
 from camera_app.tests import CameraAppTestCase
 
-import time
 
 class TestCameraFlash(CameraAppTestCase):
     """Tests the flash"""
 
-    """ This is needed to wait for the application to start.
-        In the testfarm, the application may take some time to show up."""
-    def setUp(self):
-        super(TestCameraFlash, self).setUp()
-        self.assertThat(self.main_window.get_qml_view().visible, Eventually(Equals(True)))
-
-    def tearDown(self):
-        super(TestCameraFlash, self).tearDown()
-
-    """Test that flash modes cycle properly"""
     def test_cycle_flash(self):
+        """Test that flash modes cycle properly"""
         flash_button = self.main_window.get_flash_button()
+        self.mouse.move_to_object(flash_button)
 
         #ensure initial state
-        self.assertThat(flash_button.flashState, Equals("off"))
-        self.assertThat(flash_button.torchMode, Equals(False))
-
-        self.mouse.move_to_object(flash_button)
-
-        self.mouse.click()
-        self.assertThat(flash_button.flashState, Eventually(Equals("on")))
-        self.assertThat(flash_button.torchMode, Equals(False))
-
-        self.mouse.click()
-        self.assertThat(flash_button.flashState, Eventually(Equals("auto")))
-        self.assertThat(flash_button.torchMode, Equals(False))
-
-        self.mouse.click()
-        self.assertThat(flash_button.flashState, Eventually(Equals("off")))
-        self.assertThat(flash_button.torchMode, Equals(False))
-
-    """Test that torch modes cycles properly"""
+        for desired_mode in ("off", "on", "auto", "off"):
+            self.assertThat(flash_button.flashState, Eventually(Equals(desired_mode)))
+            self.assertThat(flash_button.torchMode, Equals(False))
+            self.mouse.click()
+
     def test_cycle_torch(self):
+        """Test that torch modes cycles properly"""
         flash_button = self.main_window.get_flash_button()
         record_button = self.main_window.get_record_control()
         self.mouse.move_to_object(record_button)
         self.mouse.click()
+        self.mouse.move_to_object(flash_button)
 
+        for desired_mode in ("off", "on", "off"):
         #ensure initial state
-        self.assertThat(flash_button.flashState, Equals("off"))
-        self.assertThat(flash_button.torchMode, Equals(True))
-
-        self.mouse.move_to_object(flash_button)
-
-        self.mouse.click()
-        self.assertThat(flash_button.flashState, Eventually(Equals("on")))
-        self.assertThat(flash_button.torchMode, Equals(True))
-
-        self.mouse.click()
-        self.assertThat(flash_button.flashState, Eventually(Equals("off")))
-        self.assertThat(flash_button.torchMode, Equals(True))
-
-    """When switching between video and picture the previous flash state
-       should be preserved"""
-    def test_remember_state(self):
+            self.assertThat(flash_button.flashState, Eventually(Equals(desired_mode)))
+            self.assertThat(flash_button.torchMode, Eventually(Equals(True)))
+            self.mouse.click()
+
+    def test_flash_state_is_rememberred(self):
+        """When switching between video and picture mode the previous flash state
+        must be preserved
+
+        """
         flash_button = self.main_window.get_flash_button()
         record_button = self.main_window.get_record_control()
 

=== modified file 'tests/autopilot/camera_app/tests/test_focus.py'
--- tests/autopilot/camera_app/tests/test_focus.py	2013-04-17 20:40:53 +0000
+++ tests/autopilot/camera_app/tests/test_focus.py	2013-04-30 00:10:42 +0000
@@ -9,28 +9,17 @@
 
 from __future__ import absolute_import
 
-from testtools.matchers import Equals, NotEquals, GreaterThan
 from autopilot.matchers import Eventually
+from testtools.matchers import Equals, GreaterThan
 
 from camera_app.tests import CameraAppTestCase
 
-import unittest
-import time
 
 class TestFocus(CameraAppTestCase):
     """Tests the focus"""
 
-    """ This is needed to wait for the application to start.
-        In the testfarm, the application may take some time to show up."""
-    def setUp(self):
-        super(TestFocus, self).setUp()
-        self.assertThat(self.main_window.get_qml_view().visible, Eventually(Equals(True)))
-
-    def tearDown(self):
-        super(TestFocus, self).tearDown()
-
-    """Test focusing in an area where we know the picture is"""
     def test_focus_valid_and_disappear(self):
+        """Test focusing in an area where we know the picture is"""
         camera_window = self.main_window.get_camera()
         focus_ring = self.main_window.get_focus_ring()
         toolbar = self.main_window.get_toolbar()
@@ -72,8 +61,8 @@
         # After some seconds the focus ring should fade out
         self.assertThat(focus_ring.opacity, Eventually(Equals(0.0)))
 
-    """Tests clicking outside of the viewfinder image area, where it should not focus"""
     def test_focus_invalid(self):
+        """Tests clicking outside of the viewfinder image area, where it should not focus"""
         camera_window = self.main_window.get_camera()
         toolbar = self.main_window.get_toolbar()
         zoom = self.main_window.get_zoom_control()
@@ -111,8 +100,8 @@
             self.mouse.click()
             self.assertEquals(focus_ring.opacity, 0.0)
 
-    """Tests dragging the focus ring"""
     def test_move_focus_ring(self):
+        """Tests dragging the focus ring"""
         camera_window = self.main_window.get_camera()
         focus_ring = self.main_window.get_focus_ring()
         feed = self.main_window.get_viewfinder_geometry()

=== modified file 'tests/autopilot/camera_app/tests/test_zoom.py'
--- tests/autopilot/camera_app/tests/test_zoom.py	2013-04-17 20:40:53 +0000
+++ tests/autopilot/camera_app/tests/test_zoom.py	2013-04-30 00:10:42 +0000
@@ -9,27 +9,17 @@
 
 from __future__ import absolute_import
 
+from autopilot.matchers import Eventually
 from testtools.matchers import Equals, NotEquals, GreaterThan, LessThan
-from autopilot.matchers import Eventually
 
 from camera_app.tests import CameraAppTestCase
 
-import time
 
 class TestCameraZoom(CameraAppTestCase):
     """Tests the main camera features"""
 
-    """ This is needed to wait for the application to start.
-        In the testfarm, the application may take some time to show up."""
-    def setUp(self):
-        super(TestCameraZoom, self).setUp()
-        self.assertThat(self.main_window.get_qml_view().visible, Eventually(Equals(True)))
-
-    def tearDown(self):
-        super(TestCameraZoom, self).tearDown()
-
-    """Tests the zoom slider"""
     def test_slider(self):
+        """Tests the zoom slider"""
         zoom_control = self.main_window.get_zoom_control()
 
         zoom_button = self.main_window.get_zoom_slider_button()
@@ -54,8 +44,8 @@
 
         self.assertThat(zoom_control.value, Eventually(Equals(1.0)))
 
-    """Tests the plus and minus buttons"""
     def test_plus_minus(self):
+        """Tests the plus and minus buttons"""
         zoom_control = self.main_window.get_zoom_control()
         plus = self.main_window.get_zoom_plus()
         minus = self.main_window.get_zoom_minus()