Merge lp:~vrruiz/gallery-app/autopilot-app-class into lp:gallery-app

[Víctor R. Ruiz]

Create a class to drive the UI, and refactor test cases to use it.

Create a class to drive the UI, and refactor test cases to use it.

[Víctor R. Ruiz (vrruiz)]

One thing to think about: the UI-driver methods were moved from the case classes to GalleryApp. The problem is that some of them use asserts, that make sense as part of tests, but not so much a pure UI test. Right now, it's not a big deal, because the test_case is a required argument to instantiate GalleryApp, but in the medium term, we won't have it.

[Víctor R. Ruiz (vrruiz)]

Another comment. The code is a not as elegant as it could be: lots of direct calls to the UI in the test cases. They probably can be refactored, but that wasn't the target of the present changes.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:998
http://jenkins.qa.ubuntu.com/job/gallery-app-ci/861/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-amd64-ci/36
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-armhf-ci/36
        deb: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-armhf-ci/36/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-i386-ci/36
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-utopic-touch/75
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/725
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-mako/227
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-utopic-armhf/109
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/8289
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-utopic/647
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/864
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/864/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/gallery-app-ci/861/rebuild

review: Needs Fixing (continuous-integration)

[Leo Arias (elopio)]

> One thing to think about: the UI-driver methods were moved from the case
> classes to GalleryApp. The problem is that some of them use asserts, that make
> sense as part of tests, but not so much a pure UI test. Right now, it's not a
> big deal, because the test_case is a required argument to instantiate
> GalleryApp, but in the medium term, we won't have it.

I think that's just what we want, move the assertions out of the helpers and into the tests.
Many assertions can be replaced by wait_for.

[Leo Arias (elopio)]

Victor, I'm sorry it took so long to make this review. You will likely have to merge with trunk now.
I'll try harder to make the reviews the same day. But next time I won't make soon a review you request please keep pinging me. I'll owe you a beer for every day you wait :)

For the gallery and apps developers: this change seeks to make it easier for us to test multiple applications at the same time. On its own, it just seems like a huge branch not really useful, and now you will have to call something like self.app.main_view instead of just self.main_view. But it makes a lot of sense when you see a test like this:

address_book = AddressBook.launch()
add_contact_page = address_book.main_view.go_to_add_contact()
add_contact_page.click_contact_image()
gallery_app = GalleryApp()
gallery_app.main_view.pick_image(...)
add_contact_page.main_view.fill_form(...)
add_contact_page.save()

For that we need to move the app helpers out of the test cases because there's no nice way to make a test case that inherits from both the base test cases in address book and gallery.

review: Needs Fixing

[Leo Arias (elopio)]

Sorry, about the comment:
This empty line is not needed.

I mean, the line between

from pkg_resources import resource_filename

and

from ubuntuuitoolkit import emulators as toolkit_emulators.

[lp:~vrruiz/gallery-app/autopilot-app-class]

999. By Víctor R. Ruiz on 2014-07-02

Merge with trunk

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:999
http://jenkins.qa.ubuntu.com/job/gallery-app-ci/884/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-amd64-ci/59
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-armhf-ci/59
        deb: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-armhf-ci/59/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/gallery-app-utopic-i386-ci/59
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-utopic-touch/136
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-utopic/1269
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/generic-click-autopilot-runner-mako/285
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-click-builder-utopic-armhf/194
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/9166
    UNSTABLE: http://jenkins.qa.ubuntu.com/job/autopilot-testrunner-otto-utopic/1045
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/1417
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-amd64/1417/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/gallery-app-ci/884/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

999. By Víctor R. Ruiz on 2014-07-02

Merge with trunk

998. By Víctor R. Ruiz on 2014-06-10

Autopilot: Refactor for app class pattern (test_picker_mode)

997. By Víctor R. Ruiz on 2014-06-10

Autopilot: Refactor for app class pattern (test_photos_view)

996. By Víctor R. Ruiz on 2014-06-10

Autopilot: Refactor for app class pattern (test_photo_viewer)

995. By Víctor R. Ruiz on 2014-06-06

Autopilot: Refactor for app class pattern (test_events_view)

994. By Víctor R. Ruiz on 2014-06-06

Autopilot: Refactor for app class pattern (test_album_view)

993. By Víctor R. Ruiz on 2014-06-06

Autopilot: Refactor for app class pattern (test_albums_view)

992. By Víctor R. Ruiz on 2014-06-06

Autopilot: Refactor for app class pattern (test_albums_view)

991. By Víctor R. Ruiz on 2014-06-06

Autopilot: Refactor for app class pattern (test_album_editor)

990. By Víctor R. Ruiz on 2014-06-05

Autopilot: Refactoring for app class pattern

=== modified file 'tests/autopilot/gallery_app/__init__.py'
--- tests/autopilot/gallery_app/__init__.py	2013-03-19 13:04:59 +0000
+++ tests/autopilot/gallery_app/__init__.py	2014-07-02 14:17:44 +0000
@@ -6,3 +6,418 @@
 # by the Free Software Foundation.
 
 """Autopilot tests and emulators for gallery - top level package."""
+
+import os
+import logging
+import shutil
+import signal
+
+from time import sleep
+
+from testtools.matchers import Equals, NotEquals, GreaterThan, Is
+from autopilot.matchers import Eventually
+from autopilot.platform import model
+from autopilot.introspection import get_proxy_object_for_existing_process
+from pkg_resources import resource_filename
+
+from ubuntuuitoolkit import emulators as toolkit_emulators
+
+from gallery_app.emulators import main_screen
+from gallery_app.emulators.album_editor import AlbumEditor
+from gallery_app.emulators.album_view import AlbumView
+from gallery_app.emulators.albums_view import AlbumsView
+from gallery_app.emulators.events_view import EventsView
+from gallery_app.emulators.gallery_utils import GalleryUtils
+from gallery_app.emulators.media_selector import MediaSelector
+from gallery_app.emulators.media_viewer import MediaViewer
+from gallery_app.emulators.photo_viewer import PhotoViewer
+from gallery_app.emulators.photos_view import PhotosView
+from gallery_app.emulators.picker_screen import PickerScreen
+
+logger = logging.getLogger(__name__)
+
+
+class EnvironmentTypes:
+    installed = "installed"
+    local = "local"
+    click = "click"
+
+
+class GalleryApp():
+    """A class to drive the UI of the gallery-app."""
+
+    sample_file_source = "/sample01.jpg"
+    local_location = "../src/gallery-app"
+    tap_press_time = 1
+
+    _db = '~/.local/share/com.ubuntu.gallery/gallery-app/' \
+          'database/gallery.sqlite'
+    _thumbs = '~/.cache/com.ubuntu.gallery/gallery-app/thumbnails'
+
+    _default_sample_destination_dir = "/tmp/gallery-ap_sd"
+    sample_destination_dir = ""
+
+    args = []
+    app = None
+
+    def __init__(self, test_case, args=[]):
+        """Constructor
+
+        :param test_case: An AutopilotTestCase object. This is required
+        to be able to launch the application.
+        
+        """
+        # Start app
+        self.args = args
+        self.test_case = test_case
+        env_type = self._get_environment_launch_type()
+        self.configure_sample_files(env_type)
+        self.launch_gallery_app(env_type)
+
+    def __del__(self):
+        """Destructor"""
+        shutil.rmtree(self.sample_destination_dir)
+
+    @property
+    def gallery_utils(self):
+        return GalleryUtils(self.app)
+
+    @property
+    def main_view(self):
+        return self.app.select_single(main_screen.MainScreen)
+
+    @property
+    def album_editor(self):
+        return self.app.select_single(AlbumEditor)
+
+    @property
+    def album_view(self):
+        return AlbumView(self.app)
+
+    @property
+    def albums_view(self):
+        return AlbumsView(self.app)
+
+    @property
+    def events_view(self):
+        return EventsView(self.app)
+
+    @property
+    def media_selector(self):
+        return MediaSelector(self.app)
+
+    @property
+    def media_view(self):
+        return self.app.select_single(MediaViewer)
+
+    @property
+    def photo_viewer(self):
+        return PhotoViewer(self.app)
+
+    @property
+    def photos_view(self):
+        return PhotosView(self.app)
+
+    @property
+    def picker_view(self):
+        return self.app.select_single(PickerScreen)
+
+    def _get_environment_launch_type(self):
+        """Returns the type of the environment in which to setup and launch
+        gallery-app.
+
+        """
+        # Lets assume we are installed system wide if this file is somewhere
+        # in /usr
+        if os.path.realpath(__file__).startswith("/usr/"):
+            return EnvironmentTypes.installed
+        if model() == 'Desktop':
+            return EnvironmentTypes.installed
+        else:
+            if os.path.exists(self.local_location):
+                return EnvironmentTypes.local
+            else:
+                return EnvironmentTypes.click
+
+    def _get_sample_destination_dir(self, env_type):
+        if env_type == EnvironmentTypes.click:
+            pic_dir = os.path.expanduser("~/Pictures")
+            pic_bak_dir = pic_dir + '.apbak'
+            # Only save and restore if it previously existed
+            if os.path.exists(pic_dir):
+                shutil.move(pic_dir, pic_bak_dir)
+                self.addCleanup(
+                    logger.debug, "Restoring backed up pics to %s" % pic_dir)
+                self.addCleanup(shutil.move, pic_bak_dir, pic_dir)
+            return pic_dir
+        else:
+            return self._default_sample_destination_dir
+
+    def configure_db(self):
+        db = os.path.expanduser(self._db)
+        db_bak = db + '.apbak'
+        # Only save and restore if it previously existed
+        if os.path.exists(db):
+            shutil.move(db, db_bak)
+            self.addCleanup(shutil.move, db_bak, db)
+        if not os.path.exists(os.path.dirname(db)):
+            os.makedirs(os.path.dirname(db))
+        mock_db = os.path.join(self.sample_destination_dir, '.database',
+                               'gallery_confined.sqlite')
+        shutil.move(mock_db, db)
+
+    def configure_thumbnails(self):
+        thumbs = os.path.expanduser(self._thumbs)
+        thumbs_bak = thumbs + '.apbak'
+        # Only save and restore if it previously existed
+        if os.path.exists(thumbs):
+            shutil.move(thumbs, thumbs_bak)
+            self.addCleanup(shutil.move, thumbs_bak, thumbs)
+        if not os.path.exists(os.path.dirname(thumbs)):
+            os.makedirs(os.path.dirname(thumbs))
+        mock_thumbs = os.path.join(self.sample_destination_dir, '.thumbnails')
+        shutil.move(mock_thumbs, thumbs)
+
+    def configure_sample_files(self, env_type):
+        self.sample_dir = resource_filename('gallery_app', 'data')
+        self.sample_destination_dir = \
+            self._get_sample_destination_dir(env_type)
+        if (os.path.exists(self.sample_destination_dir)):
+            shutil.rmtree(self.sample_destination_dir)
+        ## FIXME self.assertFalse(os.path.exists(self.sample_destination_dir))
+
+        self.sample_file = os.path.join(
+            self.sample_destination_dir,
+            "sample04.jpg"
+        )
+
+        default_data_dir = os.path.join(
+            self.sample_dir,
+            "default")
+        shutil.copytree(default_data_dir, self.sample_destination_dir)
+        ## FIXME self.assertTrue(os.path.isfile(self.sample_file))
+
+        self.sample_file_source = \
+            default_data_dir + self.sample_file_source
+
+        if env_type == EnvironmentTypes.click:
+            self.configure_db()
+            self.configure_thumbnails()
+
+    def do_reset_config(self):
+        config = os.path.expanduser(
+            os.path.join("~", ".config", "gallery-app.conf"))
+        if os.path.exists(config):
+            os.remove(config)
+
+    @property
+    def pointing_device(self):
+        """Return pointing device"""
+        return toolkit_emulators.get_pointing_device()
+
+    def launch_gallery_app(self, env_type):
+        """Launch"""
+        if env_type == EnvironmentTypes.installed:
+            self.launch_test_installed()
+        elif env_type == EnvironmentTypes.local:
+            self.launch_test_local()
+        elif env_type == EnvironmentTypes.click:
+            self.launch_test_click()
+        else:
+            raise ValueError("Unknown environment type: %s", env_type)
+
+    def launch_test_local(self):
+        logger.debug("Launching local gallery-app binary.")
+        self.args.append(self.sample_destination_dir)
+        self.app = self.test_case.launch_test_application(
+            self.local_location,
+            *self.args,
+            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
+
+    def launch_test_installed(self):
+        if model() == 'Desktop':
+            logger.debug(
+                "Launching installed gallery-app binary for desktop."
+            )
+            self.args.append(self.sample_destination_dir)
+            self.app = self.test_case.launch_test_application(
+                "gallery-app",
+                *self.args,
+                emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
+        else:
+            logger.debug(
+                "Launching installed gallery-app binary for device."
+            )
+            self.args.append("--desktop_file_hint="
+                             "/usr/share/applications/gallery-app.desktop")
+            self.args.append(self.sample_destination_dir)
+            self.app = self.test_case.launch_test_application(
+                "gallery-app",
+                *self.args,
+                app_type='qt',
+                emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
+
+    def launch_test_click(self):
+        """
+        Since this test runs under confinement, the only location photos
+        are searchable in is ~/Pictures.
+        """
+        logger.debug("Launching gallery-app via click package.")
+        self.app = self.test_case.launch_click_package(
+            package_id="com.ubuntu.gallery",
+            app_uris=' '.join(self.args),
+            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
+
+    def ui_update(self):
+        """ Gives the program the time to update the UI"""
+        sleep(0.1)
+
+    def click_item(self, item, delay=0.1):
+        """Does a mouse click on the passed item, and moved the mouse there
+           before"""
+        # In jenkins test may fail because we don't wait before clicking the
+        # target so we add a little delay before click.
+        if model() == 'Desktop' and delay <= 0.25:
+            delay = 0.25
+
+        self.pointing_device.move_to_object(item)
+        sleep(delay)
+        self.pointing_device.click()
+
+    def tap_item(self, item):
+        """Does a long mouse press on the passed item, and moved the mouse
+           there before"""
+        self.pointing_device.move_to_object(item)
+        self.pointing_device.press()
+        sleep(1)
+        self.pointing_device.release()
+
+    def switch_to_albums_tab(self):
+        self.main_view.switch_to_tab("albumsTab")
+
+        albums_loader = self.gallery_utils.get_albums_viewer_loader()
+        self.test_case.assertThat(albums_loader.progress, Eventually(Equals(1)))
+
+        # The next check assumes that at least one album is available
+        # Check if the albums are availabe - they need some time to load.
+        self.test_case.assertThat(lambda: len(self.gallery_utils.get_all_albums()),
+                        Eventually(GreaterThan(0)))
+        self.ensure_tabs_dont_move()
+
+    def ensure_tabs_dont_move(self):
+        # FIXME find a (functional) way to test if the tabs still move
+        sleep(1)
+
+    def open_album_at(self, position):
+        album = self.album_view.get_album_at(position)
+        # workaround lp:1247698
+        self.main_view.close_toolbar()
+        self.click_item(album)
+        self.ensure_view_is_fully_open()
+
+    def open_first_album(self):
+        self.open_album_at(-1)
+
+    def get_delete_dialog(self):
+        """Raises StateNotFoundError if get_delete_dialog fails."""
+        delete_dialog = self.gallery_utils.get_delete_dialog()
+        return delete_dialog
+
+    def edit_first_album(self):
+        """Edit first album."""
+        first_album = self.gallery_utils.get_first_album()
+        # workaround lp:1247698
+        self.main_view.close_toolbar()
+        self.tap_item(first_album)
+        edit_button = self.gallery_utils.get_edit_album_button()
+        self.click_item(edit_button)
+
+    def ensure_view_is_fully_open(self):
+        view = self.album_view.get_album_view()
+        self.test_case.assertThat(view.visible, Eventually(Equals(True)))
+
+    def ensure_app_has_quit(self):
+        """Terminate as gracefully as possible the application and ensure
+        that it has fully quit before returning"""
+
+        if model() == "Desktop":
+            # On desktop to cleanly quit an app we just do the
+            # equivalent of clicking on the close button in the window.
+            self.keyboard.press_and_release("Alt+F4")
+        else:
+            # On unity8 at the moment we have no clean way to close the app.
+            # So we ask the shell first to show the home, unfocusing our app,
+            # which will save its state. Then we simply send it a SIGTERM to
+            # force it to quit.
+            # See bug https://bugs.launchpad.net/unity8/+bug/1261720 for more
+            # details.
+            from unity8 import process_helpers
+            pid = process_helpers._get_unity_pid()
+            unity8 = get_proxy_object_for_existing_process(pid)
+            shell = unity8.select_single("Shell")
+            shell.slots.showHome()
+            self.test_case.assertThat(shell.currentFocusedAppId,
+                            Eventually(NotEquals("gallery-app"))) # FIXME
+            self.app.process.send_signal(signal.SIGTERM)
+
+        # Either way, we wait for the underlying process to be fully finished.
+        self.app.process.wait()
+        self.test_case.assertIsNotNone(self.app.process.returncode) # FIXME
+
+    def get_events_view(self):
+        return self.app.wait_select_single("EventsOverview",
+                                           objectName="organicEventView")
+
+    def enable_select_mode(self):
+        self.main_view.open_toolbar().click_button("selectButton")
+
+    def delete_one_picture(self):
+        self.main_view.open_toolbar().click_button("deleteButton")
+        self.get_delete_dialog()
+        delete_item = self.photo_viewer.get_delete_popover_delete_item()
+        self.click_item(delete_item)
+        self.ensure_closed_delete_dialog()
+
+    def open_first_photo(self):
+        self.test_case.assertThat(
+            lambda: self.events_view.number_of_photos_in_events(),
+            Eventually(GreaterThan(0))
+        )
+
+        # workaround lp:1247698
+        # toolbar needs to be gone to click on an image.
+        self.main_view.close_toolbar()
+
+        self.events_view.click_photo(self.sample_file)
+
+        photo_viewer_loader = self.photo_viewer.get_main_photo_viewer_loader()
+        self.test_case.assertThat(photo_viewer_loader.loaded, Eventually(Equals(True)))
+        sleep(1)
+        photo_viewer = self.photo_viewer.get_main_photo_viewer()
+        self.test_case.assertThat(photo_viewer.visible, Eventually(Equals(True)))
+
+    def ensure_closed_delete_dialog(self):
+        self.test_case.assertThat(self.photo_viewer.delete_dialog_shown,
+                        Eventually(Is(False)))
+
+    def click_edit_button(self):
+        self.main_view.open_toolbar().click_button("editButton")
+        edit_dialog = self.photo_viewer.get_photo_edit_dialog()
+        self.test_case.assertThat(edit_dialog.visible, (Eventually(Equals(True))))
+        self.test_case.assertThat(edit_dialog.opacity, (Eventually(Equals(1))))
+
+    def switch_to_photos_tab(self):
+        self.main_view.switch_to_tab("photosTab")
+        self.ensure_tabs_dont_move()
+
+    def click_first_photo(self):
+        photo = self.photos_view.get_first_photo_in_photos_view()
+        self.click_item(photo)
+
+    def select_first_event_media(self):
+        first_media = self.picker_view.first_media_in_events_view()
+        self.click_item(first_media)
+
+    def select_first_grid_media(self):
+        first_media = self.picker_view.first_media_in_events_view()
+        self.click_item(first_media)
 
=== modified file 'tests/autopilot/gallery_app/tests/__init__.py'
--- tests/autopilot/gallery_app/tests/__init__.py	2014-06-10 18:54:21 +0000
+++ tests/autopilot/gallery_app/tests/__init__.py	2014-07-02 14:17:44 +0000
@@ -7,304 +7,30 @@
 
 """gallery autopilot tests."""
 
-import os
-import logging
-import shutil
-import signal
+from time import sleep
 
-from testtools.matchers import Equals, NotEquals, GreaterThan
+from testtools.matchers import Equals
 from autopilot.matchers import Eventually
-from autopilot.platform import model
 from autopilot.testcase import AutopilotTestCase
-from autopilot.introspection import get_proxy_object_for_existing_process
-from pkg_resources import resource_filename
-
-from ubuntuuitoolkit import emulators as toolkit_emulators
-from gallery_app.emulators import main_screen
-from gallery_app.emulators.gallery_utils import GalleryUtils
-
-from time import sleep
-
-logger = logging.getLogger(__name__)
-
-
-class EnvironmentTypes:
-    installed = "installed"
-    local = "local"
-    click = "click"
+
+from gallery_app import GalleryApp
 
 
 class GalleryTestCase(AutopilotTestCase):
-
     """A common test case class that provides several useful methods for
        gallery tests."""
 
-    sample_file_source = "/sample01.jpg"
-    tap_press_time = 1
-    local_location = "../../src/gallery-app"
-
-    _db = '~/.local/share/com.ubuntu.gallery/gallery-app/' \
-          'database/gallery.sqlite'
-    _thumbs = '~/.cache/com.ubuntu.gallery/gallery-app/thumbnails'
-
-    _default_sample_destination_dir = "/tmp/gallery-ap_sd"
-
     ARGS = []
 
-    @property
-    def gallery_utils(self):
-        return GalleryUtils(self.app)
-
-    @property
-    def main_view(self):
-        return self.app.select_single(main_screen.MainScreen)
-
-    def _get_environment_launch_type(self):
-        """Returns the type of the environment in which to setup and launch
-        gallery-app.
-
-        """
-        # Lets assume we are installed system wide if this file is somewhere
-        # in /usr
-        if os.path.realpath(__file__).startswith("/usr/"):
-            return EnvironmentTypes.installed
-        if model() == 'Desktop':
-            return EnvironmentTypes.installed
-        else:
-            if os.path.exists(self.local_location):
-                return EnvironmentTypes.local
-            else:
-                return EnvironmentTypes.click
-
-    def _get_sample_destination_dir(self, env_type):
-        if env_type == EnvironmentTypes.click:
-            pic_dir = os.path.expanduser("~/Pictures")
-            pic_bak_dir = pic_dir + '.apbak'
-            # Only save and restore if it previously existed
-            if os.path.exists(pic_dir):
-                shutil.move(pic_dir, pic_bak_dir)
-                self.addCleanup(
-                    logger.debug, "Restoring backed up pics to %s" % pic_dir)
-                self.addCleanup(shutil.move, pic_bak_dir, pic_dir)
-            return pic_dir
-        else:
-            return self._default_sample_destination_dir
-
-    def configure_db(self):
-        db = os.path.expanduser(self._db)
-        db_bak = db + '.apbak'
-        # Only save and restore if it previously existed
-        if os.path.exists(db):
-            shutil.move(db, db_bak)
-            self.addCleanup(shutil.move, db_bak, db)
-        if not os.path.exists(os.path.dirname(db)):
-            os.makedirs(os.path.dirname(db))
-        mock_db = os.path.join(self.sample_destination_dir, '.database',
-                               'gallery_confined.sqlite')
-        shutil.move(mock_db, db)
-
-    def configure_thumbnails(self):
-        thumbs = os.path.expanduser(self._thumbs)
-        thumbs_bak = thumbs + '.apbak'
-        # Only save and restore if it previously existed
-        if os.path.exists(thumbs):
-            shutil.move(thumbs, thumbs_bak)
-            self.addCleanup(shutil.move, thumbs_bak, thumbs)
-        if not os.path.exists(os.path.dirname(thumbs)):
-            os.makedirs(os.path.dirname(thumbs))
-        mock_thumbs = os.path.join(self.sample_destination_dir, '.thumbnails')
-        shutil.move(mock_thumbs, thumbs)
-
-    def configure_sample_files(self, env_type):
-        self.sample_dir = resource_filename('gallery_app', 'data')
-        self.sample_destination_dir = \
-            self._get_sample_destination_dir(env_type)
-        if (os.path.exists(self.sample_destination_dir)):
-            shutil.rmtree(self.sample_destination_dir)
-        self.assertFalse(os.path.exists(self.sample_destination_dir))
-
-        self.sample_file = os.path.join(
-            self.sample_destination_dir,
-            "sample04.jpg"
-        )
-
-        default_data_dir = os.path.join(
-            self.sample_dir,
-            "default")
-        shutil.copytree(default_data_dir, self.sample_destination_dir)
-        self.assertTrue(os.path.isfile(self.sample_file))
-
-        self.sample_file_source = \
-            default_data_dir + self.sample_file_source
-
-        if env_type == EnvironmentTypes.click:
-            self.configure_db()
-            self.configure_thumbnails()
-
-    def do_reset_config(self):
-        config = os.path.expanduser(
-            os.path.join("~", ".config", "gallery-app.conf"))
-        if os.path.exists(config):
-            os.remove(config)
-
     def setUp(self):
-        self.pointing_device = toolkit_emulators.get_pointing_device()
         super(GalleryTestCase, self).setUp()
 
-        env_type = self._get_environment_launch_type()
-        self.configure_sample_files(env_type)
-
-        self.launch_gallery_app(env_type)
-
-        self.addCleanup(shutil.rmtree, self.sample_destination_dir)
-        self.addCleanup(logger.debug,
-                        "Deleting %s" % self.sample_destination_dir)
+        self.gallery_app = GalleryApp(self, self.ARGS)
 
         """ This is needed to wait for the application to start.
         In the testfarm, the application may take some time to show up."""
-        self.assertThat(self.gallery_utils.get_qml_view().visible,
+        self.assertThat(self.gallery_app.gallery_utils.get_qml_view().visible,
                         Eventually(Equals(True)))
         """FIXME somehow on the server gallery sometimes is not fully started
         for switching to the albums view. Therefore this hack of sleeping"""
         sleep(2)
-
-    def launch_gallery_app(self, env_type):
-        if env_type == EnvironmentTypes.installed:
-            self.launch_test_installed()
-        elif env_type == EnvironmentTypes.local:
-            self.launch_test_local()
-        elif env_type == EnvironmentTypes.click:
-            self.launch_test_click()
-        else:
-            raise ValueError("Unknown environment type: %s", env_type)
-
-    def launch_test_local(self):
-        logger.debug("Launching local gallery-app binary.")
-        self.ARGS.append(self.sample_destination_dir)
-        self.app = self.launch_test_application(
-            self.local_location,
-            *self.ARGS,
-            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
-
-    def launch_test_installed(self):
-        if model() == 'Desktop':
-            logger.debug(
-                "Launching installed gallery-app binary for desktop."
-            )
-            self.ARGS.append(self.sample_destination_dir)
-            self.app = self.launch_test_application(
-                "gallery-app",
-                *self.ARGS,
-                emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
-        else:
-            logger.debug(
-                "Launching installed gallery-app binary for device."
-            )
-            self.ARGS.append("--desktop_file_hint="
-                             "/usr/share/applications/gallery-app.desktop")
-            self.ARGS.append(self.sample_destination_dir)
-            self.app = self.launch_test_application(
-                "gallery-app",
-                *self.ARGS,
-                app_type='qt',
-                emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
-
-    def launch_test_click(self):
-        '''
-        Since this test runs under confinement, the only location photos
-        are searchable in is ~/Pictures.
-        '''
-        logger.debug("Launching gallery-app via click package.")
-        self.app = self.launch_click_package(
-            package_id="com.ubuntu.gallery",
-            app_uris=' '.join(self.ARGS),
-            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
-
-    def ui_update(self):
-        """ Gives the program the time to update the UI"""
-        sleep(0.1)
-
-    def click_item(self, item, delay=0.1):
-        """Does a mouse click on the passed item, and moved the mouse there
-           before"""
-        # In jenkins test may fail because we don't wait before clicking the
-        # target so we add a little delay before click.
-        if model() == 'Desktop' and delay <= 0.25:
-            delay = 0.25
-
-        self.pointing_device.move_to_object(item)
-        sleep(delay)
-        self.pointing_device.click()
-
-    def tap_item(self, item):
-        """Does a long mouse press on the passed item, and moved the mouse
-           there before"""
-        self.pointing_device.move_to_object(item)
-        self.pointing_device.press()
-        sleep(1)
-        self.pointing_device.release()
-
-    def switch_to_albums_tab(self):
-        self.main_view.switch_to_tab("albumsTab")
-
-        albums_loader = self.gallery_utils.get_albums_viewer_loader()
-        self.assertThat(albums_loader.progress, Eventually(Equals(1)))
-
-        # The next check assumes that at least one album is available
-        # Check if the albums are availabe - they need some time to load.
-        self.assertThat(lambda: len(self.gallery_utils.get_all_albums()),
-                        Eventually(GreaterThan(0)))
-        self.ensure_tabs_dont_move()
-
-    def ensure_tabs_dont_move(self):
-        # FIXME find a (functional) way to test if the tabs still move
-        sleep(1)
-
-    def open_album_at(self, position):
-        album = self.album_view.get_album_at(position)
-        # workaround lp:1247698
-        self.main_view.close_toolbar()
-        self.click_item(album)
-        self.ensure_view_is_fully_open()
-
-    def open_first_album(self):
-        self.open_album_at(-1)
-
-    def ensure_view_is_fully_open(self):
-        view = self.album_view.get_album_view()
-        self.assertThat(view.visible, Eventually(Equals(True)))
-
-    def ensure_app_has_quit(self):
-        """Terminate as gracefully as possible the application and ensure
-        that it has fully quit before returning"""
-
-        if model() == "Desktop":
-            # On desktop to cleanly quit an app we just do the
-            # equivalent of clicking on the close button in the window.
-            self.keyboard.press_and_release("Alt+F4")
-        else:
-            # On unity8 at the moment we have no clean way to close the app.
-            # So we ask the shell first to show the home, unfocusing our app,
-            # which will save its state. Then we simply send it a SIGTERM to
-            # force it to quit.
-            # See bug https://bugs.launchpad.net/unity8/+bug/1261720 for more
-            # details.
-            from unity8 import process_helpers
-            pid = process_helpers._get_unity_pid()
-            unity8 = get_proxy_object_for_existing_process(pid)
-            shell = unity8.select_single("Shell")
-            shell.slots.showHome()
-            self.assertThat(shell.currentFocusedAppId,
-                            Eventually(NotEquals("gallery-app")))
-            self.app.process.send_signal(signal.SIGTERM)
-
-        # Either way, we wait for the underlying process to be fully finished.
-        self.app.process.wait()
-        self.assertIsNotNone(self.app.process.returncode)
-
-    def get_delete_dialog(self):
-        """Raises StateNotFoundError if get_delete_dialog fails."""
-        delete_dialog = self.gallery_utils.get_delete_dialog()
-        self.assertThat(delete_dialog.visible, Eventually(Equals(True)))
-        self.assertThat(delete_dialog.opacity, Eventually(Equals(1)))
-        return delete_dialog
 
=== modified file 'tests/autopilot/gallery_app/tests/test_album_editor.py'
--- tests/autopilot/gallery_app/tests/test_album_editor.py	2014-06-10 19:00:23 +0000
+++ tests/autopilot/gallery_app/tests/test_album_editor.py	2014-07-02 14:17:44 +0000
@@ -11,9 +11,7 @@
 from testtools.matchers import Equals
 from autopilot.matchers import Eventually
 
-from gallery_app.emulators.album_view import AlbumView
-from gallery_app.emulators.media_selector import MediaSelector
-from gallery_app.emulators import album_editor
+from gallery_app import GalleryApp
 from gallery_app.tests import GalleryTestCase
 
 from time import sleep
@@ -21,34 +19,17 @@
 class TestAlbumEditor(GalleryTestCase):
     """Tests the album editor of the gallery app"""
 
-    @property
-    def album_view(self):
-        return AlbumView(self.app)
-
-    @property
-    def media_selector(self):
-        return MediaSelector(self.app)
-
     def setUp(self):
-        self.ARGS = []
         super(TestAlbumEditor, self).setUp()
-        self.switch_to_albums_tab()
-        self.main_view.close_toolbar()
-        self.edit_first_album()
-
-    def edit_first_album(self):
-        first_album = self.gallery_utils.get_first_album()
-        # workaround lp:1247698
-        self.main_view.close_toolbar()
-        self.tap_item(first_album)
-        edit_button = self.gallery_utils.get_edit_album_button()
-        self.click_item(edit_button)
-        editor = self.app.select_single(album_editor.AlbumEditor)
+        self.gallery_app.switch_to_albums_tab()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.edit_first_album()
+        editor = self.gallery_app.album_editor
         editor.ensure_fully_open()
 
     def test_album_title_fields(self):
         """tests the title and sub title"""
-        editor = self.app.select_single(album_editor.AlbumEditor)
+        editor = self.gallery_app.album_editor
         title_field = editor.album_title_entry_field()
         subtitle_field = editor.album_subtitle_entry_field()
 
@@ -59,7 +40,7 @@
         self.assertThat(subtitle_field.text, Eventually(Equals(text)))
 
         # workaround lp:1247698
-        self.main_view.close_toolbar()
+        self.gallery_app.main_view.close_toolbar()
         editor.click_title_field()
         self.assertThat(title_field.activeFocus, Eventually(Equals(True)))
         self.keyboard.press_and_release("Ctrl+a")
@@ -80,61 +61,60 @@
     def test_add_photo(self):
         """Tests adding a photo using the media selector"""
         # first open, but cancel before adding a photo
-        editor = self.app.select_single(album_editor.AlbumEditor)
+        editor = self.gallery_app.album_editor
         # workaround lp:1247698
-        self.main_view.close_toolbar()
+        self.gallery_app.main_view.close_toolbar()
         editor.add_photos()
-        self.media_selector.ensure_fully_open()
+        self.gallery_app.media_selector.ensure_fully_open()
 
         sleep(5)
-        self.main_view.get_toolbar().click_custom_button("cancelButton")
+        self.gallery_app.main_view.get_toolbar().click_custom_button("cancelButton")
         editor.ensure_fully_closed()
 
-        self.main_view.close_toolbar()
-        self.open_first_album()
-        num_photos_start = self.album_view.number_of_photos()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.open_first_album()
+        num_photos_start = self.gallery_app.album_view.number_of_photos()
         self.assertThat(num_photos_start, Equals(1))
-        self.main_view.open_toolbar().click_button("backButton")
-        self.album_view.ensure_album_view_fully_closed()
+        self.gallery_app.main_view.open_toolbar().click_button("backButton")
+        self.gallery_app.album_view.ensure_album_view_fully_closed()
 
         # now open to add a photo
-        self.main_view.close_toolbar()
-        self.edit_first_album()
-        editor = self.app.select_single(album_editor.AlbumEditor)
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.edit_first_album()
+        editor = self.gallery_app.album_editor
         # workaround lp:1247698
-        self.main_view.close_toolbar()
-        editor.add_photos()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.album_editor.add_photos()
         self.media_selector.ensure_fully_open()
 
         photo = self.media_selector.get_second_photo()
-        self.click_item(photo)
-        self.main_view.get_toolbar().click_custom_button("addButton")
-        editor = self.app.select_single(album_editor.AlbumEditor)
-        editor.ensure_fully_closed()
+        self.gallery_app.click_item(photo)
+        self.gallery_app.main_view.get_toolbar().click_custom_button("addButton")
+        self.gallery_app.album_editor.ensure_fully_closed()
 
-        self.main_view.close_toolbar()
-        self.open_first_album()
-        num_photos = self.album_view.number_of_photos()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.open_first_album()
+        num_photos = self.gallery_app.album_view.number_of_photos()
         self.assertThat(num_photos, Equals(num_photos_start + 1))
 
     def test_cover_image(self):
         """Test to change the album cover image"""
-        editor = self.app.select_single(album_editor.AlbumEditor)
+        editor = self.gallery_app.album_editor
         cover_image = editor.album_cover_image()
         self.assertThat(
             cover_image.source.endswith("album-cover-default-large.png"),
             Equals(True))
-        self.main_view.close_toolbar()
+        self.gallery_app.main_view.close_toolbar()
 
         # click somewhere rather at the bottom of the cover
         # workaround lp:1247698
-        self.main_view.close_toolbar()
+        self.gallery_app.main_view.close_toolbar()
         x, y, w, h = cover_image.globalRect
-        self.pointing_device.move(x + int(w / 2), y + h - int(h / 10))
-        self.pointing_device.click()
+        self.gallery_app.pointing_device.move(x + int(w / 2), y + h - int(h / 10))
+        self.gallery_app.pointing_device.click()
 
-        green_item = self.gallery_utils.get_cover_menu_item("Green")
-        self.click_item(green_item)
+        green_item = self.gallery_app.gallery_utils.get_cover_menu_item("Green")
+        self.gallery_app.click_item(green_item)
 
         self.assertThat(lambda: cover_image.source.endswith(
             "album-cover-green-large.png"), Eventually(Equals(True)))
 
=== modified file 'tests/autopilot/gallery_app/tests/test_album_view.py'
--- tests/autopilot/gallery_app/tests/test_album_view.py	2014-06-12 16:42:04 +0000
+++ tests/autopilot/gallery_app/tests/test_album_view.py	2014-07-02 14:17:44 +0000
@@ -15,7 +15,6 @@
 from gallery_app.emulators.albums_view import AlbumsView
 from gallery_app.emulators.media_selector import MediaSelector
 from gallery_app.emulators.photo_viewer import PhotoViewer
-from gallery_app.emulators import album_editor
 from gallery_app.tests import GalleryTestCase
 
 import os
@@ -43,72 +42,72 @@
         return PhotoViewer(self.app)
 
     def setUp(self):
-        self.ARGS = []
+        self.args = []
         super(TestAlbumView, self).setUp()
-        self.switch_to_albums_tab()
+        self.gallery_app.switch_to_albums_tab()
 
     def test_album_view_open_photo(self):
-        self.main_view.close_toolbar()
-        self.open_first_album()
-        self.main_view.close_toolbar()
-        photo = self.album_view.get_first_photo()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.open_first_album()
+        self.gallery_app.main_view.close_toolbar()
+        photo = self.gallery_app.album_view.get_first_photo()
         # workaround lp:1247698
-        self.main_view.close_toolbar()
-        self.click_item(photo)
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.click_item(photo)
         sleep(5)
-        photo_view = self.main_view.wait_select_single("PopupPhotoViewer")
+        photo_view = self.gallery_app.main_view.wait_select_single("PopupPhotoViewer")
         self.assertThat(photo_view.visible, Eventually(Equals(True)))
 
     def test_album_view_flipping(self):
-        self.main_view.close_toolbar()
+        self.gallery_app.main_view.close_toolbar()
 
         # For some reason here the album at position 0 in the autopilot list is
         # actually the second album, they seem to be returned in reverse order.
-        self.open_album_at(0)
-        self.main_view.close_toolbar()
+        self.gallery_app.open_album_at(0)
+        self.gallery_app.main_view.close_toolbar()
 
-        spread = self.album_view.get_spread_view()
+        spread = self.gallery_app.album_view.get_spread_view()
 
         # check that we can page to the cover and back (we check for lesser
         # than 1 because it can either be 0 if we are on a one page spread
         # or -1 if we are on a two page spread, for example on desktop)
-        self.album_view.swipe_page_left(1)
+        self.gallery_app.album_view.swipe_page_left(1)
         self.assertThat(spread.viewingPage, Eventually(LessThan(1)))
-        self.album_view.swipe_page_right(0)
+        self.gallery_app.album_view.swipe_page_right(0)
         self.assertThat(spread.viewingPage, Eventually(Equals(1)))
 
         # drag to next page and check we have flipped away from page 1
         # can't check precisely for page 2 because depending on form factor
         # and orientation we might be displaying two pages at the same time
-        self.album_view.swipe_page_right(1)
+        self.gallery_app.album_view.swipe_page_right(1)
         self.assertThat(spread.viewingPage, Eventually(GreaterThan(1)))
 
     def test_add_photo(self):
-        self.main_view.close_toolbar()
-        self.open_first_album()
-        num_photos_start = self.album_view.number_of_photos()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.open_first_album()
+        num_photos_start = self.gallery_app.album_view.number_of_photos()
         self.assertThat(num_photos_start, Equals(1))
 
         # open media selector but cancel
-        self.main_view.open_toolbar().click_button("addButton")
-        self.media_selector.ensure_fully_open()
+        self.gallery_app.main_view.open_toolbar().click_button("addButton")
+        self.gallery_app.media_selector.ensure_fully_open()
 
-        self.main_view.get_toolbar().click_custom_button("cancelButton")
+        self.gallery_app.main_view.get_toolbar().click_custom_button("cancelButton")
         sleep(1)
 
-        num_photos = self.album_view.number_of_photos()
+        num_photos = self.gallery_app.album_view.number_of_photos()
         self.assertThat(num_photos, Equals(num_photos_start))
 
         # open media selector and add a photo
-        self.main_view.open_toolbar().click_button("addButton")
-        self.media_selector.ensure_fully_open()
+        self.gallery_app.main_view.open_toolbar().click_button("addButton")
+        self.gallery_app.media_selector.ensure_fully_open()
 
-        photo = self.media_selector.get_second_photo()
-        self.click_item(photo)
-        self.main_view.get_toolbar().click_custom_button("addButton")
+        photo = self.gallery_app.media_selector.get_second_photo()
+        self.gallery_app.click_item(photo)
+        self.gallery_app.main_view.get_toolbar().click_custom_button("addButton")
 
         self.assertThat(
-            lambda: self.album_view.number_of_photos(),
+            lambda: self.gallery_app.album_view.number_of_photos(),
             Eventually(Equals(num_photos_start + 1)))
 
     def test_remove_photo_from_album(self):
@@ -183,57 +182,57 @@
                         Eventually(Equals(True)))
 
     def test_add_photo_to_new_album(self):
-        self.main_view.open_toolbar().click_button("addButton")
-        self.ui_update()
+        self.gallery_app.main_view.open_toolbar().click_button("addButton")
+        self.gallery_app.ui_update()
 
-        editor = self.app.select_single(album_editor.AlbumEditor)
+        editor = self.gallery_app.album_editor
         editor.ensure_fully_open()
-        self.main_view.close_toolbar()
+        self.gallery_app.main_view.close_toolbar()
         editor.close()
 
-        self.open_first_album()
-        self.main_view.close_toolbar()
-        num_photos_start = self.album_view.number_of_photos()
+        self.gallery_app.open_first_album()
+        self.gallery_app.main_view.close_toolbar()
+        num_photos_start = self.gallery_app.album_view.number_of_photos()
         self.assertThat(num_photos_start, Equals(0))
 
-        plus = self.album_view.get_plus_icon_empty_album()
+        plus = self.gallery_app.album_view.get_plus_icon_empty_album()
         # workaround lp:1247698
-        self.main_view.close_toolbar()
-        self.click_item(plus)
-        self.media_selector.ensure_fully_open()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.click_item(plus)
+        self.gallery_app.media_selector.ensure_fully_open()
 
-        photo = self.media_selector.get_second_photo()
-        self.click_item(photo)
-        self.main_view.get_toolbar().click_custom_button("addButton")
+        photo = self.gallery_app.media_selector.get_second_photo()
+        self.gallery_app.click_item(photo)
+        self.gallery_app.main_view.get_toolbar().click_custom_button("addButton")
 
         self.assertThat(
-            lambda: self.album_view.number_of_photos(),
+            lambda: self.gallery_app.album_view.number_of_photos(),
             Eventually(Equals(num_photos_start + 1)))
 
     @skip("Temporarily disable as it fails in some cases, supposedly due to "
           "problems with the infrastructure")
     def test_save_state(self):
-        self.main_view.close_toolbar()
-        self.open_first_album()
-
-        id = self.album_view.get_album_view().albumId
-
-        self.ensure_app_has_quit()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.open_first_album()
+
+        id = self.gallery_app.album_view.get_album_view().albumId
+
+        self.gallery_app.ensure_app_has_quit()
         self.start_app()
 
-        view = self.album_view.get_album_view()
+        view = self.gallery_app.album_view.get_album_view()
         self.assertThat(view.visible, Eventually(Equals(True)))
         self.assertThat(view.albumId, Eventually(Equals(id)))
 
     @skip("Temporarily disable as it fails in some cases, supposedly due to "
           "problems with the infrastructure")
     def test_no_save_state_on_back(self):
-        self.main_view.close_toolbar()
-        self.open_first_album()
-        self.main_view.open_toolbar().click_button("backButton")
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.open_first_album()
+        self.gallery_app.main_view.open_toolbar().click_button("backButton")
 
         self.ensure_app_has_quit()
         self.start_app()
 
-        view = self.album_view.get_animated_album_view()
+        view = self.gallery_app.album_view.get_animated_album_view()
         self.assertThat(view.isOpen, Equals(False))
 
=== modified file 'tests/autopilot/gallery_app/tests/test_albums_view.py'
--- tests/autopilot/gallery_app/tests/test_albums_view.py	2014-05-20 15:19:35 +0000
+++ tests/autopilot/gallery_app/tests/test_albums_view.py	2014-07-02 14:17:44 +0000
@@ -13,8 +13,6 @@
 from autopilot.platform import model
 
 from gallery_app.tests import GalleryTestCase
-from gallery_app.emulators.albums_view import AlbumsView
-from gallery_app.emulators import album_editor
 
 from os import environ as env
 
@@ -22,13 +20,7 @@
 class TestAlbumsView(GalleryTestCase):
     envDesktopMode = None
 
-    @property
-    def albums_view(self):
-        return AlbumsView(self.app)
-
     def setUp(self):
-        self.ARGS = []
-
         self.envDesktopMode = env.get("DESKTOP_MODE")
 
         if model() == "Desktop":
@@ -37,7 +29,7 @@
             env["DESKTOP_MODE"] = "0"
 
         super(TestAlbumsView, self).setUp()
-        self.switch_to_albums_tab()
+        self.gallery_app.switch_to_albums_tab()
 
     def tearDown(self):
         if self.envDesktopMode:
@@ -49,10 +41,10 @@
 
     def test_add_album(self):
         """Add one album, and checks if the number of albums went up by one"""
-        albums = self.albums_view.number_of_albums_in_albums_view()
-        self.main_view.open_toolbar().click_button("addButton")
+        albums = self.gallery_app.albums_view.number_of_albums_in_albums_view()
+        self.gallery_app.main_view.open_toolbar().click_button("addButton")
         self.assertThat(
-            lambda: self.albums_view.number_of_albums_in_albums_view(),
+            lambda: self.gallery_app.albums_view.number_of_albums_in_albums_view(),
             Eventually(Equals(albums+1))
         )
 
@@ -60,20 +52,20 @@
         """Add one album, cancel it and checks if the number of albums does
         not change
         """
-        albums = self.albums_view.number_of_albums_in_albums_view()
-        self.main_view.open_toolbar().click_button("addButton")
-        editor = self.app.select_single(album_editor.AlbumEditor)
+        albums = self.gallery_app.albums_view.number_of_albums_in_albums_view()
+        self.gallery_app.main_view.open_toolbar().click_button("addButton")
+        editor = self.gallery_app.album_editor
         editor.ensure_fully_open()
-        self.main_view.get_toolbar().click_custom_button("cancelButton")
+        self.gallery_app.main_view.get_toolbar().click_custom_button("cancelButton")
         self.assertThat(
-            lambda: self.albums_view.number_of_albums_in_albums_view(),
+            lambda: self.gallery_app.albums_view.number_of_albums_in_albums_view(),
             Eventually(Equals(albums))
         )
 
     # Check if Camera Button is not visible at Desktop mode
     def test_camera_button_visible(self):
-        self.main_view.open_toolbar()
-        toolbar = self.main_view.get_toolbar()
+        self.gallery_app.main_view.open_toolbar()
+        toolbar = self.gallery_app.main_view.get_toolbar()
         cameraButton = toolbar.select_single(
             "ActionItem",
             objectName="cameraButton"
 
=== modified file 'tests/autopilot/gallery_app/tests/test_events_view.py'
--- tests/autopilot/gallery_app/tests/test_events_view.py	2014-06-16 13:46:21 +0000
+++ tests/autopilot/gallery_app/tests/test_events_view.py	2014-07-02 14:17:44 +0000
@@ -13,7 +13,6 @@
 from autopilot.platform import model
 
 from gallery_app.tests import GalleryTestCase
-from gallery_app.emulators.events_view import EventsView
 
 from os import environ as env
 from os.path import exists
@@ -24,12 +23,8 @@
     """Tests the main gallery features"""
     envDesktopMode = None
 
-    @property
-    def events_view(self):
-        return EventsView(self.app)
-
     def setUp(self):
-        self.ARGS = []
+        self.args = []
 
         self.envDesktopMode = env.get("DESKTOP_MODE")
 
@@ -41,9 +36,9 @@
         # This is needed to wait for the application to start.
         # In the testfarm, the application may take some time to show up.
         super(TestEventsView, self).setUp()
-        self.main_view.switch_to_tab("eventsTab")
+        self.gallery_app.main_view.switch_to_tab("eventsTab")
         """Wait for the data to be loaded and displayed"""
-        self.assertThat(lambda: self.events_view.number_of_events(),
+        self.assertThat(lambda: self.gallery_app.events_view.number_of_events(),
                         Eventually(GreaterThan(0)))
 
     def tearDown(self):
@@ -54,77 +49,70 @@
 
         super(TestEventsView, self).tearDown()
 
-    def get_events_view(self):
-        return self.app.wait_select_single("EventsOverview",
-                                           objectName="organicEventView")
-
-    def enable_select_mode(self):
-        self.main_view.open_toolbar().click_button("selectButton")
-
     def test_select_button_cancel(self):
         """Clicking the cancel button after clicking the select button must
            hide the toolbar automatically."""
-        events_view = self.get_events_view()
+        events_view = self.gallery_app.get_events_view()
         self.assertFalse(events_view.inSelectionMode)
 
-        self.enable_select_mode()
+        self.gallery_app.enable_select_mode()
         self.assertTrue(events_view.inSelectionMode)
 
-        self.main_view.get_toolbar().click_custom_button("cancelButton")
+        self.gallery_app.main_view.get_toolbar().click_custom_button("cancelButton")
 
-        toolbar = self.main_view.get_toolbar()
+        toolbar = self.gallery_app.main_view.get_toolbar()
         self.assertThat(toolbar.opened, Eventually(Equals(False)))
         self.assertFalse(events_view.inSelectionMode)
 
     def test_delete_a_photo(self):
         """Selecting a photo must make the delete button clickable."""
-        self.assertThat(lambda: exists(self.sample_file),
-                        Eventually(Equals(True)))
-
-        self.enable_select_mode()
-        self.events_view.click_photo(self.sample_file)
-        self.main_view.open_toolbar().click_button("deleteButton")
-        self.assertThat(self.gallery_utils.delete_dialog_shown,
-                        Eventually(Is(True)))
-
-        self.gallery_utils.click_delete_dialog_cancel_button()
-        self.assertThat(self.gallery_utils.delete_dialog_shown,
-                        Eventually(Is(False)))
-
-        self.assertThat(lambda: exists(self.sample_file),
-                        Eventually(Equals(True)))
-
-        self.main_view.open_toolbar().click_button("deleteButton")
-        self.assertThat(self.gallery_utils.delete_dialog_shown,
-                        Eventually(Is(True)))
-
-        self.gallery_utils.click_delete_dialog_delete_button()
-        self.assertThat(self.gallery_utils.delete_dialog_shown,
-                        Eventually(Is(False)))
-
-        self.assertThat(lambda: exists(self.sample_file),
+        self.assertThat(lambda: exists(self.gallery_app.sample_file),
+                        Eventually(Equals(True)))
+
+        self.gallery_app.enable_select_mode()
+        self.gallery_app.events_view.click_photo(self.gallery_app.sample_file)
+        self.gallery_app.main_view.open_toolbar().click_button("deleteButton")
+        self.assertThat(self.gallery_app.gallery_utils.delete_dialog_shown,
+                        Eventually(Is(True)))
+
+        self.gallery_app.gallery_utils.click_delete_dialog_cancel_button()
+        self.assertThat(self.gallery_app.gallery_utils.delete_dialog_shown,
+                        Eventually(Is(False)))
+
+        self.assertThat(lambda: exists(self.gallery_app.sample_file),
+                        Eventually(Equals(True)))
+
+        self.gallery_app.main_view.open_toolbar().click_button("deleteButton")
+        self.assertThat(self.gallery_app.gallery_utils.delete_dialog_shown,
+                        Eventually(Is(True)))
+
+        self.gallery_app.gallery_utils.click_delete_dialog_delete_button()
+        self.assertThat(self.gallery_app.gallery_utils.delete_dialog_shown,
+                        Eventually(Is(False)))
+
+        self.assertThat(lambda: exists(self.gallery_app.sample_file),
                         Eventually(Equals(False)))
 
     def test_adding_a_video(self):
         if model() == "Desktop":
-            before = self.events_view.get_event(0)
+            before = self.gallery_app.events_view.get_event(0)
             video_file = "video.mp4"
-            shutil.copyfile(self.sample_dir+"/option01/"+video_file,
-                            self.sample_destination_dir+"/"+video_file)
+            shutil.copyfile(self.gallery_app.sample_dir+"/option01/"+video_file,
+                            self.gallery_app.sample_destination_dir+"/"+video_file)
             video_file = "video.mkv"
-            shutil.copyfile(self.sample_dir+"/option01/"+video_file,
-                            self.sample_destination_dir+"/"+video_file)
-            after = self.events_view.get_event(0)
+            shutil.copyfile(self.gallery_app.sample_dir+"/option01/"+video_file,
+                            self.gallery_app.sample_destination_dir+"/"+video_file)
+            after = self.gallery_app.events_view.get_event(0)
             self.assertThat(lambda: str(after),
                             Eventually(NotEquals(str(before))))
             self.assertThat(
-                lambda: self.events_view.number_of_photos_in_events(),
+                lambda: self.gallery_app.events_view.number_of_photos_in_events(),
                 Eventually(Equals(4)))
 
     # Check if Camera Button is not visible at Desktop mode
     def test_camera_button_visible(self):
-        self.main_view.open_toolbar()
-        toolbar = self.main_view.get_toolbar()
+        self.gallery_app.main_view.open_toolbar()
+        toolbar = self.gallery_app.main_view.get_toolbar()
         cameraButton = toolbar.select_single(
             "ActionItem",
             objectName="cameraButton"
 
=== modified file 'tests/autopilot/gallery_app/tests/test_photo_viewer.py'
--- tests/autopilot/gallery_app/tests/test_photo_viewer.py	2014-05-20 15:19:35 +0000
+++ tests/autopilot/gallery_app/tests/test_photo_viewer.py	2014-07-02 14:17:44 +0000
@@ -8,12 +8,9 @@
 
 """Tests the Photo editor of the gallery app."""
 
-from testtools.matchers import Equals, NotEquals, GreaterThan, Is
+from testtools.matchers import Equals, NotEquals
 from autopilot.matchers import Eventually
 
-from gallery_app.emulators.photo_viewer import PhotoViewer
-from gallery_app.emulators.media_viewer import MediaViewer
-from gallery_app.emulators.events_view import EventsView
 from gallery_app.tests import GalleryTestCase
 
 import os
@@ -26,38 +23,11 @@
 
 
 class TestPhotoViewerBase(GalleryTestCase):
-    @property
-    def photo_viewer(self):
-        return PhotoViewer(self.app)
-
-    @property
-    def events_view(self):
-        return EventsView(self.app)
-
     def setUp(self):
-        self.ARGS = []
         super(TestPhotoViewerBase, self).setUp()
-        self.main_view.switch_to_tab("eventsTab")
-        self.open_first_photo()
-        self.main_view.open_toolbar()
-
-    def open_first_photo(self):
-        self.assertThat(
-            lambda: self.events_view.number_of_photos_in_events(),
-            Eventually(GreaterThan(0))
-        )
-
-        # workaround lp:1247698
-        # toolbar needs to be gone to click on an image.
-        self.main_view.close_toolbar()
-
-        self.events_view.click_photo(self.sample_file)
-
-        photo_viewer_loader = self.photo_viewer.get_main_photo_viewer_loader()
-        self.assertThat(photo_viewer_loader.loaded, Eventually(Equals(True)))
-        sleep(1)
-        photo_viewer = self.photo_viewer.get_main_photo_viewer()
-        self.assertThat(photo_viewer.visible, Eventually(Equals(True)))
+        self.gallery_app.main_view.switch_to_tab("eventsTab")
+        self.gallery_app.open_first_photo()
+        self.gallery_app.main_view.open_toolbar()
 
 
 class TestPhotoViewer(TestPhotoViewerBase):
@@ -67,15 +37,15 @@
     def test_save_state(self):
         """Quitting the app once a photo has been opened will return
         to that same photo on restart"""
-        path = self.photo_viewer.get_photo_component().select_single(
+        path = self.gallery_app.photo_viewer.get_photo_component().select_single(
             "QQuickImage").source
 
         self.ensure_app_has_quit()
         self.start_app()
 
-        photo_viewer = self.photo_viewer.get_main_photo_viewer()
+        photo_viewer = self.gallery_app.photo_viewer.get_main_photo_viewer()
         self.assertThat(photo_viewer.visible, Eventually(Equals(True)))
-        new_path = self.photo_viewer.get_photo_component().select_single(
+        new_path = self.gallery_app.photo_viewer.get_photo_component().select_single(
             "QQuickImage").source
 
         self.assertThat(path, Equals(new_path))
@@ -85,76 +55,59 @@
     def test_no_save_state_on_back(self):
         """Quitting the app once a photo has been opened and then closed
         will not reopen a photo on restart"""
-        self.main_view.open_toolbar().click_button("backButton")
+        self.gallery_app.main_view.open_toolbar().click_button("backButton")
 
         self.ensure_app_has_quit()
         self.start_app()
 
-        photo_viewer_loader = self.photo_viewer.get_main_photo_viewer_loader()
+        photo_viewer_loader = self.gallery_app.photo_viewer.get_main_photo_viewer_loader()
         self.assertThat(photo_viewer_loader.source, Equals(""))
 
-    def get_delete_dialog(self):
-        delete_dialog = self.photo_viewer.get_delete_dialog()
-        self.assertThat(delete_dialog.visible, Eventually(Equals(True)))
-        self.assertThat(delete_dialog.opacity, Eventually(Equals(1)))
-        return delete_dialog
-
-    def ensure_closed_delete_dialog(self):
-        self.assertThat(self.photo_viewer.delete_dialog_shown,
-                        Eventually(Is(False)))
-
     def test_nav_bar_back_button(self):
         """Clicking the back button must close the photo."""
-        self.main_view.open_toolbar().click_button("backButton")
-        photo_viewer = self.photo_viewer.get_main_photo_viewer()
+        self.gallery_app.main_view.open_toolbar().click_button("backButton")
+        photo_viewer = self.gallery_app.photo_viewer.get_main_photo_viewer()
         self.assertThat(photo_viewer.visible, Eventually(Equals(False)))
 
-    def delete_one_picture(self):
-        self.main_view.open_toolbar().click_button("deleteButton")
-        self.get_delete_dialog()
-        delete_item = self.photo_viewer.get_delete_popover_delete_item()
-        self.click_item(delete_item)
-        self.ensure_closed_delete_dialog()
-
     def test_photo_delete_works(self):
         """Clicking the trash button must show the delete dialog."""
-        self.main_view.open_toolbar().click_button("deleteButton")
-        self.get_delete_dialog()
-
-        photo_viewer = self.photo_viewer.get_main_photo_viewer()
-
-        cancel_item = self.photo_viewer.get_delete_popover_cancel_item()
-        self.click_item(cancel_item)
-        self.ensure_closed_delete_dialog()
-
-        self.assertThat(lambda: os.path.exists(self.sample_file),
+        self.gallery_app.main_view.open_toolbar().click_button("deleteButton")
+        self.gallery_app.get_delete_dialog()
+
+        photo_viewer = self.gallery_app.photo_viewer.get_main_photo_viewer()
+
+        cancel_item = self.gallery_app.photo_viewer.get_delete_popover_cancel_item()
+        self.gallery_app.click_item(cancel_item)
+        self.gallery_app.ensure_closed_delete_dialog()
+
+        self.assertThat(lambda: os.path.exists(self.gallery_app.sample_file),
                         Eventually(Equals(True)))
 
-        self.delete_one_picture()
-        self.assertThat(lambda: os.path.exists(self.sample_file),
+        self.gallery_app.delete_one_picture()
+        self.assertThat(lambda: os.path.exists(self.gallery_app.sample_file),
                         Eventually(Equals(False)))
 
         # Delete all other pictures and make sure the photo viewer closes
-        self.delete_one_picture()
-        self.delete_one_picture()
-        self.delete_one_picture()
-        self.delete_one_picture()
+        self.gallery_app.delete_one_picture()
+        self.gallery_app.delete_one_picture()
+        self.gallery_app.delete_one_picture()
+        self.gallery_app.delete_one_picture()
 
         self.assertThat(photo_viewer.visible, Eventually(Equals(False)))
 
     def test_nav_bar_album_picker_button(self):
         """Clicking the album picker must show the picker dialog."""
-        self.main_view.open_toolbar().click_button("addButton")
-        album_picker = self.photo_viewer.get_popup_album_picker()
+        self.gallery_app.main_view.open_toolbar().click_button("addButton")
+        album_picker = self.gallery_app.photo_viewer.get_popup_album_picker()
         self.assertThat(album_picker.visible, Eventually(Equals(True)))
 
     def test_double_click_zoom(self):
         """Double clicking an opened photo must zoom it."""
-        opened_photo = self.photo_viewer.get_photo_component()
+        opened_photo = self.gallery_app.photo_viewer.get_photo_component()
 
-        self.pointing_device.move_to_object(opened_photo)
-        self.pointing_device.click()
-        self.pointing_device.click()
+        self.gallery_app.pointing_device.move_to_object(opened_photo)
+        self.gallery_app.pointing_device.click()
+        self.gallery_app.pointing_device.click()
 
         self.assertThat(
             opened_photo.isZoomAnimationInProgress,
@@ -162,8 +115,8 @@
         )
         self.assertThat(opened_photo.fullyZoomed, Eventually(Equals(True)))
 
-        self.pointing_device.click()
-        self.pointing_device.click()
+        self.gallery_app.pointing_device.click()
+        self.gallery_app.pointing_device.click()
 
         self.assertThat(
             opened_photo.isZoomAnimationInProgress,
@@ -173,26 +126,26 @@
 
     def test_swipe_change_image(self):
         """Swiping left and right on a photo should move to another photo"""
-        list = self.photo_viewer.get_photos_list()
+        list = self.gallery_app.photo_viewer.get_photos_list()
         self.assertThat(list.currentIndex, Eventually(Equals(0)))
 
         # Slide left should move to the next image
         x, y, w, h = list.globalRect
         mid_y = y + h // 2
         mid_x = x + w // 2
-        self.pointing_device.drag(mid_x, mid_y, x + 10, mid_y)
+        self.gallery_app.pointing_device.drag(mid_x, mid_y, x + 10, mid_y)
 
         self.assertThat(list.moving, Eventually(Equals(False)))
         self.assertThat(list.currentIndex, Eventually(Equals(1)))
 
         # Slide right should get us back to the start
-        self.pointing_device.drag(mid_x, mid_y, x + w - 10, mid_y)
+        self.gallery_app.pointing_device.drag(mid_x, mid_y, x + w - 10, mid_y)
 
         self.assertThat(list.moving, Eventually(Equals(False)))
         self.assertThat(list.currentIndex, Eventually(Equals(0)))
 
         # Slide right again shouldn't go anywhere
-        self.pointing_device.drag(mid_x, mid_y, x + w - 10, mid_y)
+        self.gallery_app.pointing_device.drag(mid_x, mid_y, x + w - 10, mid_y)
 
         self.assertThat(list.moving, Eventually(Equals(False)))
         self.assertThat(list.currentIndex, Eventually(Equals(0)))
@@ -202,98 +155,91 @@
 
     def setUp(self):
         super(TestPhotoEditor, self).setUp()
-        self.click_edit_button()
-        self.media_view = self.app.select_single(MediaViewer)
-
-    def click_edit_button(self):
-        self.main_view.open_toolbar().click_button("editButton")
-        edit_dialog = self.photo_viewer.get_photo_edit_dialog()
-        self.assertThat(edit_dialog.visible, (Eventually(Equals(True))))
-        self.assertThat(edit_dialog.opacity, (Eventually(Equals(1))))
+        self.gallery_app.click_edit_button()
 
     def test_photo_editor_crop(self):
         """Cropping a photo must crop it."""
-        old_file_size = os.path.getsize(self.sample_file)
+        old_file_size = os.path.getsize(self.gallery_app.sample_file)
 
-        crop_box = self.photo_viewer.get_crop_interactor()
+        crop_box = self.gallery_app.photo_viewer.get_crop_interactor()
         item_width = crop_box.width
         item_height = crop_box.height
 
-        self.photo_viewer.click_crop_item()
+        self.gallery_app.photo_viewer.click_crop_item()
 
         self.assertThat(crop_box.state, Eventually(Equals("shown")))
         self.assertThat(crop_box.opacity, Eventually(Equals(1)))
 
-        crop_corner = self.photo_viewer.get_top_left_crop_corner()
+        crop_corner = self.gallery_app.photo_viewer.get_top_left_crop_corner()
         x, y, h, w = crop_corner.globalRect
         x = x + w // 2
         y = y + h // 2
-        self.pointing_device.drag(x, y,
+        self.gallery_app.pointing_device.drag(x, y,
                                   x + item_width // 2, y + item_height // 2)
 
         # wait for animation being finished
-        crop_overlay = self.photo_viewer.get_crop_overlay()
+        crop_overlay = self.gallery_app.photo_viewer.get_crop_overlay()
         self.assertThat(crop_overlay.interpolationFactor,
                         Eventually(Equals(1.0)))
 
-        crop_button = self.photo_viewer.get_crop_overlays_crop_icon()
-        self.click_item(crop_button)
-        self.media_view.ensure_spinner_not_running()
+        crop_button = self.gallery_app.photo_viewer.get_crop_overlays_crop_icon()
+        self.gallery_app.click_item(crop_button)
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
         # wait for new photo being set/reloaded, so saving thumbnailing etc.
         # is done
-        edit_preview = self.photo_viewer.get_edit_preview()
-        new_source = "image://thumbnailer/" + self.sample_file
+        edit_preview = self.gallery_app.photo_viewer.get_edit_preview()
+        new_source = "image://thumbnailer/" + self.gallery_app.sample_file
 
         self.assertThat(edit_preview.source, Eventually(Equals(new_source)))
 
-        new_file_size = os.path.getsize(self.sample_file)
+        new_file_size = os.path.getsize(self.gallery_app.sample_file)
         self.assertThat(old_file_size > new_file_size, Equals(True))
 
     def test_photo_editor_rotate(self):
         """Makes sure that the photo editor inside the photo viewer works using
            the rotate function"""
-        opened_photo = self.photo_viewer.get_opened_photo()
+        opened_photo = self.gallery_app.photo_viewer.get_opened_photo()
         item_height = opened_photo.height
 
         def is_landscape():
             return opened_photo.paintedWidth > opened_photo.paintedHeight
         self.assertThat(is_landscape(), Equals(True))
 
-        self.photo_viewer.click_rotate_item()
-        self.media_view.ensure_spinner_not_running()
+        self.gallery_app.photo_viewer.click_rotate_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
         self.assertThat(opened_photo.paintedHeight,
                         Eventually(Equals(item_height)))
         self.assertThat(lambda: is_landscape(),
                         Eventually(Equals(False)))
 
-        self.main_view.open_toolbar()
-        self.click_edit_button()
-        self.photo_viewer.click_undo_item()
-        self.media_view.ensure_spinner_not_running()
+        self.gallery_app.main_view.open_toolbar()
+        self.gallery_app.click_edit_button()
+        self.gallery_app.photo_viewer.click_undo_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
         self.assertThat(opened_photo.paintedHeight,
                         Eventually(NotEquals(item_height)))
         self.assertThat(lambda: is_landscape(),
                         Eventually(Equals(True)))
 
-        self.main_view.open_toolbar()
-        self.click_edit_button()
-        self.photo_viewer.click_redo_item()
-        self.media_view.ensure_spinner_not_running()
+        self.gallery_app.main_view.open_toolbar()
+        self.gallery_app.click_edit_button()
+        self.gallery_app.photo_viewer.click_redo_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
         self.assertThat(opened_photo.paintedHeight,
                         Eventually(Equals(item_height)))
         is_landscape = opened_photo.paintedWidth > opened_photo.paintedHeight
         self.assertThat(is_landscape, Equals(False))
 
-        self.main_view.open_toolbar()
-        self.click_edit_button()
-        self.photo_viewer.click_rotate_item()
-        self.main_view.open_toolbar()
-        self.click_edit_button()
-        self.photo_viewer.click_revert_item()
+        self.gallery_app.main_view.open_toolbar()
+        self.gallery_app.click_edit_button()
+        self.gallery_app.photo_viewer.click_rotate_item()
+        self.gallery_app.main_view.open_toolbar()
+        self.gallery_app.click_edit_button()
+        self.gallery_app.photo_viewer.click_revert_item()
 
         self.assertThat(opened_photo.paintedHeight,
                         Eventually(NotEquals(item_height)))
@@ -307,66 +253,66 @@
         sleep(1)
 
     def test_photo_editor_redo_undo_revert_enhance_states(self):
-        undo_item = self.photo_viewer.get_undo_menu_item()
-        redo_item = self.photo_viewer.get_redo_menu_item()
-        revert_item = self.photo_viewer.get_revert_menu_item()
+        undo_item = self.gallery_app.photo_viewer.get_undo_menu_item()
+        redo_item = self.gallery_app.photo_viewer.get_redo_menu_item()
+        revert_item = self.gallery_app.photo_viewer.get_revert_menu_item()
 
         self.assertThat(undo_item.enabled, Eventually(Equals(False)))
         self.assertThat(redo_item.enabled, Eventually(Equals(False)))
         self.assertThat(revert_item.enabled, Eventually(Equals(False)))
 
-        self.photo_viewer.click_rotate_item()
-        self.media_view.ensure_spinner_not_running()
+        self.gallery_app.photo_viewer.click_rotate_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
-        self.click_edit_button()
-        undo_item = self.photo_viewer.get_undo_menu_item()
-        redo_item = self.photo_viewer.get_redo_menu_item()
-        revert_item = self.photo_viewer.get_revert_menu_item()
+        self.gallery_app.click_edit_button()
+        undo_item = self.gallery_app.photo_viewer.get_undo_menu_item()
+        redo_item = self.gallery_app.photo_viewer.get_redo_menu_item()
+        revert_item = self.gallery_app.photo_viewer.get_revert_menu_item()
 
         self.assertThat(undo_item.enabled, Eventually(Equals(True)))
         self.assertThat(redo_item.enabled, Eventually(Equals(False)))
         self.assertThat(revert_item.enabled, Eventually(Equals(True)))
 
-        self.photo_viewer.click_undo_item()
-        self.media_view.ensure_spinner_not_running()
+        self.gallery_app.photo_viewer.click_undo_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
-        self.click_edit_button()
-        undo_item = self.photo_viewer.get_undo_menu_item()
-        redo_item = self.photo_viewer.get_redo_menu_item()
-        revert_item = self.photo_viewer.get_revert_menu_item()
+        self.gallery_app.click_edit_button()
+        undo_item = self.gallery_app.photo_viewer.get_undo_menu_item()
+        redo_item = self.gallery_app.photo_viewer.get_redo_menu_item()
+        revert_item = self.gallery_app.photo_viewer.get_revert_menu_item()
 
         self.assertThat(undo_item.enabled, Eventually(Equals(False)))
         self.assertThat(redo_item.enabled, Eventually(Equals(True)))
         self.assertThat(revert_item.enabled, Eventually(Equals(False)))
 
-        self.photo_viewer.click_redo_item()
-        self.media_view.ensure_spinner_not_running()
+        self.gallery_app.photo_viewer.click_redo_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
-        self.click_edit_button()
-        undo_item = self.photo_viewer.get_undo_menu_item()
-        redo_item = self.photo_viewer.get_redo_menu_item()
-        revert_item = self.photo_viewer.get_revert_menu_item()
+        self.gallery_app.click_edit_button()
+        undo_item = self.gallery_app.photo_viewer.get_undo_menu_item()
+        redo_item = self.gallery_app.photo_viewer.get_redo_menu_item()
+        revert_item = self.gallery_app.photo_viewer.get_revert_menu_item()
 
         self.assertThat(undo_item.enabled, Eventually(Equals(True)))
         self.assertThat(redo_item.enabled, Eventually(Equals(False)))
         self.assertThat(revert_item.enabled, Eventually(Equals(True)))
 
-        self.photo_viewer.click_revert_item()
-        self.media_view.ensure_spinner_not_running()
+        self.gallery_app.photo_viewer.click_revert_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
 
-        self.click_edit_button()
-        undo_item = self.photo_viewer.get_undo_menu_item()
-        redo_item = self.photo_viewer.get_redo_menu_item()
-        revert_item = self.photo_viewer.get_revert_menu_item()
+        self.gallery_app.click_edit_button()
+        undo_item = self.gallery_app.photo_viewer.get_undo_menu_item()
+        redo_item = self.gallery_app.photo_viewer.get_redo_menu_item()
+        revert_item = self.gallery_app.photo_viewer.get_revert_menu_item()
 
         self.assertThat(undo_item.enabled, Eventually(Equals(True)))
         self.assertThat(redo_item.enabled, Eventually(Equals(False)))
         self.assertThat(revert_item.enabled, Eventually(Equals(False)))
 
-        self.photo_viewer.click_enhance_item()
-        self.media_view.ensure_spinner_not_running()
-
-        self.click_edit_button()
-
-        revert_item = self.photo_viewer.get_revert_menu_item()
+        self.gallery_app.photo_viewer.click_enhance_item()
+        self.gallery_app.media_view.ensure_spinner_not_running()
+
+        self.gallery_app.click_edit_button()
+
+        revert_item = self.gallery_app.photo_viewer.get_revert_menu_item()
         self.assertThat(lambda: revert_item.enabled, Eventually(Equals(True)))
 
=== modified file 'tests/autopilot/gallery_app/tests/test_photos_view.py'
--- tests/autopilot/gallery_app/tests/test_photos_view.py	2014-05-20 20:59:52 +0000
+++ tests/autopilot/gallery_app/tests/test_photos_view.py	2014-07-02 14:17:44 +0000
@@ -14,7 +14,6 @@
 from autopilot.platform import model
 
 from gallery_app.tests import GalleryTestCase
-from gallery_app.emulators.photos_view import PhotosView
 
 from time import sleep
 from os import environ as env
@@ -24,12 +23,8 @@
 class TestPhotosView(GalleryTestCase):
     envDesktopMode = None
 
-    @property
-    def photos_view(self):
-        return PhotosView(self.app)
-
     def setUp(self):
-        self.ARGS = []
+        self.args = []
         self.envDesktopMode = env.get("DESKTOP_MODE")
 
         if model() == "Desktop":
@@ -38,7 +33,7 @@
             env["DESKTOP_MODE"] = "0"
 
         super(TestPhotosView, self).setUp()
-        self.switch_to_photos_tab()
+        self.gallery_app.switch_to_photos_tab()
 
     def tearDown(self):
         if self.envDesktopMode:
@@ -48,82 +43,74 @@
 
         super(TestPhotosView, self).tearDown()
 
-    def switch_to_photos_tab(self):
-        self.main_view.switch_to_tab("photosTab")
-        self.ensure_tabs_dont_move()
-
-    def click_first_photo(self):
-        photo = self.photos_view.get_first_photo_in_photos_view()
-        self.click_item(photo)
-
     def test_open_photo(self):
-        self.main_view.close_toolbar()
-        self.click_first_photo()
+        self.gallery_app.main_view.close_toolbar()
+        self.gallery_app.click_first_photo()
         sleep(5)
-        photo_viewer = self.photos_view.get_main_photo_viewer()
+        photo_viewer = self.gallery_app.photos_view.get_main_photo_viewer()
         self.assertThat(photo_viewer.visible, Eventually(Equals(True)))
 
     def test_select_button_cancel(self):
         """Clicking the cancel button after clicking the select button must
         hide the toolbar automatically."""
-        photos_overview = self.app.select_single("PhotosOverview")
+        photos_overview = self.gallery_app.app.select_single("PhotosOverview")
         self.assertFalse(photos_overview.inSelectionMode)
 
-        self.main_view.open_toolbar().click_button("selectButton")
+        self.gallery_app.main_view.open_toolbar().click_button("selectButton")
         self.assertTrue(photos_overview.inSelectionMode)
 
-        self.main_view.open_toolbar().click_custom_button("cancelButton")
+        self.gallery_app.main_view.open_toolbar().click_custom_button("cancelButton")
 
-        toolbar = self.main_view.get_toolbar()
+        toolbar = self.gallery_app.main_view.get_toolbar()
         self.assertThat(toolbar.opened, Eventually(Equals(False)))
         self.assertFalse(photos_overview.inSelectionMode)
 
-        first_photo = self.photos_view.get_first_photo_in_photos_view()
-        self.tap_item(first_photo)
+        first_photo = self.gallery_app.photos_view.get_first_photo_in_photos_view()
+        self.gallery_app.tap_item(first_photo)
         self.assertTrue(photos_overview.inSelectionMode)
 
     def test_delete_photo_dialog_appears(self):
         """Selecting a photo must make the delete button clickable."""
-        self.main_view.open_toolbar().click_button("selectButton")
-        self.click_first_photo()
-        self.main_view.open_toolbar().click_button("deleteButton")
+        self.gallery_app.main_view.open_toolbar().click_button("selectButton")
+        self.gallery_app.click_first_photo()
+        self.gallery_app.main_view.open_toolbar().click_button("deleteButton")
 
-        self.assertThat(self.gallery_utils.delete_dialog_shown,
+        self.assertThat(self.gallery_app.gallery_utils.delete_dialog_shown,
                         Eventually(Is(True)))
 
-        cancel_item = self.photos_view.get_delete_dialog_cancel_button()
-        self.click_item(cancel_item)
-        self.assertThat(self.gallery_utils.delete_dialog_shown,
+        cancel_item = self.gallery_app.photos_view.get_delete_dialog_cancel_button()
+        self.gallery_app.click_item(cancel_item)
+        self.assertThat(self.gallery_app.gallery_utils.delete_dialog_shown,
                         Eventually(Is(False)))
 
     def test_delete_a_photo(self):
         """Must be able to select a photo and use the dialog to delete it."""
-        number_of_photos = self.photos_view.number_of_photos()
-        self.main_view.open_toolbar().click_button("selectButton")
-        self.click_first_photo()
-        self.main_view.open_toolbar().click_button("deleteButton")
+        number_of_photos = self.gallery_app.photos_view.number_of_photos()
+        self.gallery_app.main_view.open_toolbar().click_button("selectButton")
+        self.gallery_app.click_first_photo()
+        self.gallery_app.main_view.open_toolbar().click_button("deleteButton")
 
-        self.assertThat(self.gallery_utils.delete_dialog_shown,
+        self.assertThat(self.gallery_app.gallery_utils.delete_dialog_shown,
                         Eventually(Is(True)))
 
-        self.main_view.open_toolbar().click_button("deleteButton")
+        self.gallery_app.main_view.open_toolbar().click_button("deleteButton")
 
-        delete_item = self.photos_view.get_delete_dialog_delete_button()
-        self.click_item(delete_item)
+        delete_item = self.gallery_app.photos_view.get_delete_dialog_delete_button()
+        self.gallery_app.click_item(delete_item)
         self.assertThat(
-            self.gallery_utils.delete_dialog_shown,
+            self.gallery_app.gallery_utils.delete_dialog_shown,
             Eventually(Is(False))
         )
 
-        self.assertThat(lambda: self.photos_view.number_of_photos(),
+        self.assertThat(lambda: self.gallery_app.photos_view.number_of_photos(),
                         Eventually(Equals(number_of_photos - 1)))
 
     @unittest.skip("Temporarily disable as it fails in some cases, "
                    "supposedly due to problems with the infrastructure")
     def test_save_state(self):
-        self.switch_to_photos_tab()
+        self.gallery_app.switch_to_photos_tab()
 
-        tabs = self.main_view.select_single("Tabs")
+        tabs = self.gallery_app.main_view.select_single("Tabs")
         tab = tabs.get_current_tab()
         self.assertThat(tab.objectName, Equals("photosTab"))
         index = tab.index
@@ -131,7 +118,7 @@
         self.ensure_app_has_quit()
         self.start_app()
 
-        tabs = self.main_view.select_single("Tabs")
+        tabs = self.gallery_app.main_view.select_single("Tabs")
         tab = tabs.get_current_tab()
         self.assertThat(tabs.selectedTabIndex, Eventually(Equals(index)))
         self.assertThat(tab.objectName, Equals("photosTab"))
@@ -141,8 +128,8 @@
         'Key based tests only make sense on Desktop'
     )
     def test_toggle_fullscreen(self):
-        self.switch_to_photos_tab()
-        view = self.main_view
+        self.gallery_app.switch_to_photos_tab()
+        view = self.gallery_app.main_view
         self.assertThat(view.fullScreen, Eventually(Equals(False)))
         self.keyboard.press_and_release('F11')
         self.assertThat(view.fullScreen, Eventually(Equals(True)))
@@ -157,8 +144,8 @@
 
     # Check if Camera Button is not visible at Desktop mode
     def test_camera_button_visible(self):
-        self.main_view.open_toolbar()
-        toolbar = self.main_view.get_toolbar()
+        self.gallery_app.main_view.open_toolbar()
+        toolbar = self.gallery_app.main_view.get_toolbar()
         cameraButton = toolbar.select_single(
             "ActionItem",
             objectName="cameraButton"
 
=== modified file 'tests/autopilot/gallery_app/tests/test_picker_mode.py'
--- tests/autopilot/gallery_app/tests/test_picker_mode.py	2014-05-21 16:02:19 +0000
+++ tests/autopilot/gallery_app/tests/test_picker_mode.py	2014-07-02 14:17:44 +0000
@@ -11,54 +11,43 @@
 from testtools.matchers import Equals
 from autopilot.matchers import Eventually
 
-from gallery_app.emulators.picker_screen import PickerScreen
+from gallery_app import GalleryApp
 from gallery_app.tests import GalleryTestCase
+
 import unittest
 
 from unittest import skip
 
 class TestPickerMode(GalleryTestCase):
 
-    @property
-    def picker_view(self):
-        return self.app.select_single(PickerScreen)
-
     def setUp(self):
-        self.ARGS.append("--pick-mode")
+        self.args.append("--pick-mode")
         super(TestPickerMode, self).setUp()
 
-    def select_first_event_media(self):
-        first_media = self.picker_view.first_media_in_events_view()
-        self.click_item(first_media)
-
-    def select_first_grid_media(self):
-        first_media = self.picker_view.first_media_in_events_view()
-        self.click_item(first_media)
-
     @unittest.skip("Temporarily disable as it fails in some cases, "
                    "supposedly due to problems with the infrastructure")
     def test_pick_first_photo(self):
         """Check if the button enabled state follows the selection"""
-        pick_button = self.picker_view.pick_button()
+        pick_button = self.gallery_app.picker_view.pick_button()
         self.assertThat(pick_button.enabled, Eventually(Equals(False)))
-        first_events_media = self.picker_view.first_media_in_events_view()
+        first_events_media = self.gallery_app.picker_view.first_media_in_events_view()
         self.assertThat(
             first_events_media.isSelected,
             Eventually(Equals(False))
         )
 
-        self.select_first_event_media()
+        self.gallery_app.select_first_event_media()
 
-        pick_button = self.picker_view.pick_button()
+        pick_button = self.gallery_app.picker_view.pick_button()
         self.assertThat(pick_button.enabled, Eventually(Equals(True)))
         self.assertThat(
             first_events_media.isSelected,
             Eventually(Equals(True))
         )
 
-        self.select_first_event_media()
+        self.gallery_app.select_first_event_media()
 
-        pick_button = self.picker_view.pick_button()
+        pick_button = self.gallery_app.picker_view.pick_button()
         self.assertThat(pick_button.enabled, Eventually(Equals(False)))
         self.assertThat(
             first_events_media.isSelected,
@@ -68,14 +57,14 @@
     @skip("Temporarily disable as it fails in some cases")
     def test_pick_named_photo(self):
         """Select a named photo and press Pick button."""
-        self.picker_view.switch_to_tab('photosTab')
-        pick_button = self.picker_view.pick_button()
+        self.gallery_app.picker_view.switch_to_tab('photosTab')
+        pick_button = self.gallery_app.picker_view.pick_button()
         self.assertFalse(pick_button.enabled)
 
         # create the image location path based on sample location
         image_path = 'image://thumbnailer/{}/sample02.jpg'.format(
             self.sample_destination_dir)
-        self.picker_view.select_named_photo(image_path)
+        self.gallery_app.picker_view.select_named_photo(image_path)
 
         self.assertTrue(pick_button.enabled)
         self.click_item(pick_button)
@@ -84,38 +73,38 @@
                    "supposedly due to problems with the infrastructure")
     def test_selection_synchronisation(self):
         """Checks if the selection is the same for both views"""
-        first_events_media = self.picker_view.first_media_in_events_view()
+        first_events_media = self.gallery_app.picker_view.first_media_in_events_view()
         self.assertThat(
             first_events_media.isSelected,
             Eventually(Equals(False))
         )
 
-        self.select_first_event_media()
+        self.gallery_app.select_first_event_media()
         self.assertThat(
             first_events_media.isSelected,
             Eventually(Equals(True))
         )
 
-        self.picker_view.switch_to_next_tab()
+        self.gallery_app.picker_view.switch_to_next_tab()
 
-        first_grid_media = self.picker_view.first_media_in_grid_view()
+        first_grid_media = self.gallery_app.picker_view.first_media_in_grid_view()
         self.assertThat(first_grid_media.isSelected, Eventually(Equals(True)))
 
     @unittest.skip("Temporarily disable as it fails in some cases, "
                    "supposedly due to problems with the infrastructure")
     def test_save_picker_state(self):
-        self.picker_view.switch_to_tab("photosTab")
-        self.ensure_tabs_dont_move()
+        self.gallery_app.picker_view.switch_to_tab("photosTab")
+        self.gallery_app.ensure_tabs_dont_move()
 
-        tabs = self.picker_view.select_single("Tabs")
+        tabs = self.gallery_app.picker_view.select_single("Tabs")
         tab = tabs.get_current_tab()
         self.assertThat(tab.objectName, Equals("photosTab"))
         index = tab.index
 
-        self.ensure_app_has_quit()
+        self.gallery_app.ensure_app_has_quit()
         self.start_app()
 
-        tabs = self.picker_view.select_single("Tabs")
+        tabs = self.gallery_app.picker_view.select_single("Tabs")
         tab = tabs.get_current_tab()
         self.assertThat(tabs.selectedTabIndex, Eventually(Equals(index)))
         self.assertThat(tab.objectName, Equals("photosTab"))