Merge lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers into lp:ubuntu-system-tests

[Sergio Cazzolato]

moving unity8 helpers to ubuntu system tests helpers. @run_tests: ubuntu_system_tests.tests.indicators.test_indicator_sound.SoundIndicatorTestCase.test_sound_settings_item_open_correct_page

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

396. By Sergio Cazzolato on 2016-06-08

Adding missing files

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:395
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/221/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/326/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/326/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/287/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/221/rebuild

review: Needs Fixing (continuous-integration)

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:396
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/222/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/327/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/327/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/288/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/222/rebuild

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

397. By Sergio Cazzolato on 2016-06-09

minor fix to start unity8

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:397
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/223/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/328/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/328/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/289/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/223/rebuild

review: Needs Fixing (continuous-integration)

[Sergio Cazzolato (sergio-j-cazzolato)]

Tested with these tests, and running sanity test list now:

ubuntu_system_tests.tests.test_rotation.RotationTestCase.test_rotation_lock_unlock
ubuntu_system_tests.tests.scopes.test_default_scopes

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

398. By Sergio Cazzolato on 2016-06-09

fix in selftests

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:398
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/224/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/329/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/329/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/290/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/224/rebuild

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

399. By Sergio Cazzolato on 2016-06-09

minor change to trigger rebuild

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:399
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/225/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/330/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/330/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/291/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/225/rebuild

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

400. By Sergio Cazzolato on 2016-06-09

reducing complexity of set_orientation method, because it is failing in jenkins execution but not here

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:400
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/226/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/331/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/331/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/292/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/226/rebuild

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

401. By Sergio Cazzolato on 2016-06-09

reducing even more the complexity of set_orientation method

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:401
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/227/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/332/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/332/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/293/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/227/rebuild

review: Needs Fixing (continuous-integration)

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

402. By Sergio Cazzolato on 2016-06-09

minor fix for flake8

[platform-qa-bot (platform-qa-bot)]

PASSED: Continuous integration, rev:402
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/228/
Executed test runs:
    SUCCESS: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/333
        deb: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/333/artifact/work/output/*zip*/output.zip
    SUCCESS: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/333
        deb: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/333/artifact/work/output/*zip*/output.zip
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/294/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/228/rebuild

review: Approve (continuous-integration)

[Richard Huddie (rhuddie)]

Thanks for this, seems to be working well. I've added some fairly minor comments below.

I did see this failure on some of the scope tests: http://pastebin.ubuntu.com/17139412/

review: Needs Fixing

[Santiago Baldassin (sbaldassin)]

Thanks for the mp Sergio. I'm adding partial review comments. I'll try to go through the rest of the mp during the day

review: Needs Fixing

[lp:~canonical-platform-qa/ubuntu-system-tests/move_unity_helpers]

403. By Sergio Cazzolato on 2016-06-10

Updating get_dash method to use patched_select_single

[Sergio Cazzolato (sergio-j-cazzolato)]

I pushed a change to fix the dash issue. Then I'll go over the other comments.

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:403
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/232/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-amd64-package/337/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-wily-i386-package/337/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/298/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/232/rebuild

review: Needs Fixing (continuous-integration)

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:403
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/1082/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-xenial-amd64-package/317/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-xenial-i386-package/315/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1706/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/1082/rebuild

review: Needs Fixing (continuous-integration)

[platform-qa-bot (platform-qa-bot)]

FAILED: Continuous integration, rev:403
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/1099/
Executed test runs:
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-xenial-amd64-package/340/console
    FAILURE: https://platform-qa-jenkins.ubuntu.com/job/build-xenial-i386-package/338/console
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/1811/console

Click here to trigger a rebuild:
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/1099/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

403. By Sergio Cazzolato on 2016-06-10

Updating get_dash method to use patched_select_single

402. By Sergio Cazzolato on 2016-06-09

minor fix for flake8

401. By Sergio Cazzolato on 2016-06-09

reducing even more the complexity of set_orientation method

400. By Sergio Cazzolato on 2016-06-09

reducing complexity of set_orientation method, because it is failing in jenkins execution but not here

399. By Sergio Cazzolato on 2016-06-09

minor change to trigger rebuild

398. By Sergio Cazzolato on 2016-06-09

fix in selftests

397. By Sergio Cazzolato on 2016-06-09

minor fix to start unity8

396. By Sergio Cazzolato on 2016-06-08

Adding missing files

395. By Sergio Cazzolato on 2016-06-08

moving unity8 helpers to ubuntu system tests helpers

=== modified file 'debian/control'
--- debian/control	2016-05-10 16:47:27 +0000
+++ debian/control	2016-06-10 02:06:42 +0000
@@ -9,8 +9,7 @@
                python3-fixtures,
                python3-flake8,
                python3-setuptools,
-               python3-testscenarios,
-               unity8-autopilot
+               python3-testscenarios
 Standards-Version: 3.9.5
 Homepage: http://launchpad.net/ubuntu-system-tests
 X-Python3-Version: >= 3.3
@@ -71,6 +70,5 @@
          ${python3:Depends},
          python3-autopilot,
          ubuntu-system-tests-common,
-         unity8-autopilot,
 Description: Ubuntu-system-tests test suite and test data
  This package contains test suites and test data for ubuntu-system-tests.

=== modified file 'debian/tests/control'
--- debian/tests/control	2016-05-26 14:25:26 +0000
+++ debian/tests/control	2016-06-10 02:06:42 +0000
@@ -35,7 +35,6 @@
          ubuntu-system-tests-helpers,
          ubuntu-system-tests-suite,
          unity8,
-         unity8-autopilot (>=8.02+15.04.20150224-0ubuntu1),
          unity-scope-click,
          unity-scope-click-autopilot,
          usbutils,

=== modified file 'ubuntu_system_tests/helpers/indicators/message.py'
--- ubuntu_system_tests/helpers/indicators/message.py	2016-06-01 15:04:34 +0000
+++ ubuntu_system_tests/helpers/indicators/message.py	2016-06-10 02:06:42 +0000
@@ -17,8 +17,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import logging
-
-from autopilot import logging as autopilot_logging
+import autopilot
 
 import ubuntuuitoolkit as uuitk
 
@@ -136,12 +135,12 @@
         """Return the contact's avatar icon."""
         return self.select_single('Icon', objectName='avatar', visible=True)
 
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def call(self):
         """Press the call icon."""
         self.pointing_device.click_object(self.get_call_icon())
 
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def press_avatar(self):
         """Press the contact's avatar to display snap decision menu."""
         self.pointing_device.click_object(self.get_contact_avatar())

=== modified file 'ubuntu_system_tests/helpers/indicators/utils.py'
--- ubuntu_system_tests/helpers/indicators/utils.py	2016-06-08 08:07:44 +0000
+++ ubuntu_system_tests/helpers/indicators/utils.py	2016-06-10 02:06:42 +0000
@@ -19,10 +19,9 @@
 
 import logging
 
-from unity8 import indicators
-
 from ubuntu_system_tests.helpers import context
 from ubuntu_system_tests.helpers.ubuntuuitoolkit._qquicklistview import QQuickListView  # NOQA
+from ubuntu_system_tests.helpers.unity8 import indicators
 
 INDICATOR_PAGE_PATH = b'IndicatorPage'
 

=== modified file 'ubuntu_system_tests/helpers/mediascanner.py'
--- ubuntu_system_tests/helpers/mediascanner.py	2016-04-13 15:02:39 +0000
+++ ubuntu_system_tests/helpers/mediascanner.py	2016-06-10 02:06:42 +0000
@@ -21,11 +21,11 @@
 import dbus
 import logging
 
-from unity8 import process_helpers
-
 from ubuntu_system_tests.helpers.dbus_observer import DBusObserver
+from ubuntu_system_tests.helpers import processes
 from ubuntu_system_tests.helpers.threads import StoppingThread
 
+
 MEDIA_SCANNER = 'mediascanner-2.0'
 MATCH_STRING = ("type='method_call',"
                 "path='/com/canonical/MediaScanner2/Extractor',"
@@ -38,14 +38,14 @@
 
 def stop_media_scanner():
     """ Stop the media scanner process """
-    if process_helpers.is_job_running(MEDIA_SCANNER):
-        process_helpers.stop_job(MEDIA_SCANNER)
+    if processes.is_job_running(MEDIA_SCANNER):
+        processes.stop_job(MEDIA_SCANNER)
 
 
 def start_media_scanner():
     """ Start the media scanner process """
-    if not process_helpers.is_job_running(MEDIA_SCANNER):
-        process_helpers.start_job(MEDIA_SCANNER)
+    if not processes.is_job_running(MEDIA_SCANNER):
+        processes.start_job(MEDIA_SCANNER)
 
 
 class MediaScannerObserver(DBusObserver):

=== modified file 'ubuntu_system_tests/helpers/processes.py'
--- ubuntu_system_tests/helpers/processes.py	2016-05-12 16:41:19 +0000
+++ ubuntu_system_tests/helpers/processes.py	2016-06-10 02:06:42 +0000
@@ -25,13 +25,15 @@
 
 import psutil
 
-from unity8.process_helpers import get_job_status
-
 from ubuntu_system_tests.helpers import wait_until
 
 logger = logging.getLogger(__name__)
 
 
+class JobError(Exception):
+    pass
+
+
 def is_process_running(pname):
     try:
         return bool(get_process_ids(pname))
@@ -117,3 +119,82 @@
     """ Retrieve the command line used to start the process """
     return subprocess.check_output('xargs -0 < /proc/{}/cmdline'.format(pid),
                                    shell=True, universal_newlines=True)
+
+
+def start_job(name, *args):
+    """Start a job.
+    :param str name: The name of the job.
+    :param args: The arguments to be used when starting the job.
+    :return: The process id of the started job.
+    :raises CalledProcessError: if the job failed to start.
+    """
+    logger.info('Starting job {} with arguments {}.'.format(name, args))
+    command = ['/sbin/initctl', 'start', name] + list(args)
+    try:
+        output = subprocess.check_output(
+            command,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+        )
+        logger.info(output)
+        pid = get_job_pid(name)
+    except subprocess.CalledProcessError as e:
+        e.args += ('Failed to start {}: {}.'.format(name, e.output),)
+        raise
+    else:
+        return pid
+
+
+def get_job_pid(name):
+    """Return the process id of a running job.
+    :param str name: The name of the job.
+    :raises JobError: if the job is not running.
+    """
+    status = get_job_status(name)
+    if "start/" not in status:
+        raise JobError('{} is not in the running state.'.format(name))
+    return int(status.split()[-1])
+
+
+def get_job_status(name):
+    """Return the status of a job.
+    :param str name: The name of the job.
+    :raises JobError: if it's not possible to get the status of the job.
+    """
+    try:
+        return subprocess.check_output([
+            '/sbin/initctl',
+            'status',
+            name
+        ], universal_newlines=True)
+    except subprocess.CalledProcessError as error:
+        raise JobError(
+            "Unable to get {}'s status: {}".format(name, error)
+        )
+
+
+def stop_job(name):
+    """Stop a job.
+    :param str name: The name of the job.
+    :raises CalledProcessError: if the job failed to stop.
+    """
+    logger.info('Stopping job {}.'.format(name))
+    command = ['/sbin/initctl', 'stop', name]
+    try:
+        output = subprocess.check_output(
+            command,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+        )
+        logger.info(output)
+    except subprocess.CalledProcessError as e:
+        e.args += ('Failed to stop {}: {}.'.format(name, e.output),)
+        raise
+
+
+def is_job_running(name):
+    """Return True if the job is running. Otherwise, False.
+    :param str name: The name of the job.
+    :raises JobError: if it's not possible to get the status of the job.
+    """
+    return 'start/' in get_job_status(name)

=== modified file 'ubuntu_system_tests/helpers/scopes/apps/_preview.py'
--- ubuntu_system_tests/helpers/scopes/apps/_preview.py	2016-04-19 18:39:43 +0000
+++ ubuntu_system_tests/helpers/scopes/apps/_preview.py	2016-06-10 02:06:42 +0000
@@ -19,12 +19,12 @@
 #
 
 from autopilot import introspection
-from unity8.dash import Preview as DashPreview
 
 from ubuntu_system_tests.helpers.autopilot import (
     get_path_root, wait_select_single)
 from ubuntu_system_tests.helpers.scopes.apps import _clickscope
 from ubuntu_system_tests.helpers.unity8 import UNITY8_DASH_PATH_ROOT
+from ubuntu_system_tests.helpers.unity8.dash import Preview as DashPreview
 
 
 class Preview(DashPreview):

=== modified file 'ubuntu_system_tests/helpers/scopes/base.py'
--- ubuntu_system_tests/helpers/scopes/base.py	2016-04-19 10:06:01 +0000
+++ ubuntu_system_tests/helpers/scopes/base.py	2016-06-10 02:06:42 +0000
@@ -22,11 +22,11 @@
 
 from autopilot import exceptions
 from collections import namedtuple
-from unity8 import dash as unity8_dash
 
 from ubuntu_system_tests.helpers.autopilot.list import order_by_y_coord
 from ubuntu_system_tests.helpers.ubuntuuitoolkit.pageheader import (
     DashPageHeader)
+from ubuntu_system_tests.helpers.unity8 import dash
 from ubuntu_system_tests.helpers.url_dispatcher import go_to_url
 
 ScopeDataItem = namedtuple('ScopeDataItem', ['data', 'globalRect'])
@@ -36,7 +36,7 @@
 logger = logging.getLogger(__name__)
 
 
-class GenericScopeView(unity8_dash.GenericScopeView):
+class GenericScopeView(dash.GenericScopeView):
     """
     This class is a base class for all scope CPOs and should never be
     instantiated directly. This avoids autopilot CPO errors.

=== modified file 'ubuntu_system_tests/helpers/scopes/music/_preview.py'
--- ubuntu_system_tests/helpers/scopes/music/_preview.py	2016-02-03 16:09:24 +0000
+++ ubuntu_system_tests/helpers/scopes/music/_preview.py	2016-06-10 02:06:42 +0000
@@ -18,9 +18,9 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from unity8.dash import Preview as DashPreview
-from ubuntu_system_tests.helpers.autopilot.object import \
-    wait_until_is_not_moving
+from ubuntu_system_tests.helpers.autopilot.object import (
+    wait_until_is_not_moving)
+from ubuntu_system_tests.helpers.unity8.dash import Preview as DashPreview
 
 
 class Preview(DashPreview):

=== modified file 'ubuntu_system_tests/helpers/sensors.py'
--- ubuntu_system_tests/helpers/sensors.py	2016-04-25 19:02:31 +0000
+++ ubuntu_system_tests/helpers/sensors.py	2016-06-10 02:06:42 +0000
@@ -21,11 +21,12 @@
 import os
 import subprocess
 
-from unity8.sensors import FakePlatformSensors as Unity8Sensors
-
 from ubuntu_system_tests.helpers import context
 from ubuntu_system_tests.helpers.power import write_to_powerd_fifo
 from ubuntu_system_tests.helpers.testbed import run_command_with_sudo as sudo
+from ubuntu_system_tests.helpers.unity8.sensors import (
+    FakePlatformSensors as Unity8Sensors)
+
 
 DELAY_MS = 10
 ACCEL_SENSOR_RESOLUTION = 0.1

=== modified file 'ubuntu_system_tests/helpers/ubuntuuitoolkit/slider.py'
--- ubuntu_system_tests/helpers/ubuntuuitoolkit/slider.py	2015-09-22 10:20:55 +0000
+++ ubuntu_system_tests/helpers/ubuntuuitoolkit/slider.py	2016-06-10 02:06:42 +0000
@@ -18,7 +18,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-from unity8 import indicators
+from ubuntu_system_tests.helpers.unity8 import indicators
 
 
 class Slider(indicators.Slider):

=== modified file 'ubuntu_system_tests/helpers/unity8/__init__.py'
--- ubuntu_system_tests/helpers/unity8/__init__.py	2016-06-02 11:07:46 +0000
+++ ubuntu_system_tests/helpers/unity8/__init__.py	2016-06-10 02:06:42 +0000
@@ -19,12 +19,22 @@
 #
 
 from ubuntu_system_tests.helpers.unity8.utils import (
+    UnityException,
     close_all_apps,
     close_app,
     ensure_unity_running_and_greeter_hidden,
     ensure_unity_stopped,
+    get_binary_path,
     get_dash,
+    get_data_dirs,
+    get_default_extra_mock_libraries,
+    get_lib_path,
+    get_mocks_library_path,
+    get_unity_pid,
     launch_application_from_launcher,
+    restart_unity,
+    restart_unity_with_testability,
+    running_installed_tests,
     PROC_NAME,
     UNITY8_PATH_ROOT,
     UNITY8_DASH_PATH_ROOT,
@@ -33,12 +43,22 @@
 
 
 __all__ = [
+    'UnityException',
     'close_all_apps',
     'close_app',
     'ensure_unity_running_and_greeter_hidden',
     'ensure_unity_stopped',
+    'get_binary_path',
     'get_dash',
+    'get_data_dirs',
+    'get_default_extra_mock_libraries',
+    'get_lib_path',
+    'get_mocks_library_path',
+    'get_unity_pid',
     'launch_application_from_launcher',
+    'restart_unity',
+    'restart_unity_with_testability',
+    'running_installed_tests',
     'PROC_NAME',
     'UNITY8_PATH_ROOT',
     'UNITY8_DASH_PATH_ROOT',

=== modified file 'ubuntu_system_tests/helpers/unity8/dash.py'
--- ubuntu_system_tests/helpers/unity8/dash.py	2016-02-03 16:09:24 +0000
+++ ubuntu_system_tests/helpers/unity8/dash.py	2016-06-10 02:06:42 +0000
@@ -18,10 +18,14 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+import logging
 from retrying import retry
 
+import autopilot
 from autopilot.input._common import get_center_point
-from unity8 import dash as unity8_dash
+from autopilot.introspection import dbus
+from ubuntuuitoolkit import (
+    QQuickFlickable, MainView, UbuntuUIToolkitCustomProxyObjectBase, units)
 
 from ubuntu_system_tests.helpers.autopilot import (
     patched_wait_select_single, validate_dbus_object, wait_select_many)
@@ -29,18 +33,176 @@
 from ubuntu_system_tests.helpers.ubuntuuitoolkit.pageheader import (
     DashPageHeader
 )
-from ubuntu_system_tests.helpers.unity8 import UNITY8_DASH_PATH_ROOT
+from ubuntu_system_tests.helpers.unity8 import (
+    UNITY8_DASH_PATH_ROOT, UnityException)
 
 SCOPE_CLASS_NAME = 'GenericScopeView'
 
-
-class Dash(unity8_dash.Dash):
+logger = logging.getLogger(__name__)
+
+
+class DashApp():
+    """Autopilot helper for the Dash app."""
+
+    def __init__(self, app_proxy):
+        self.app_proxy = app_proxy
+        self.main_view = self.app_proxy.select_single(MainView)
+        self.dash = self.main_view.select_single(Dash)
+
+
+class Dash(UbuntuUIToolkitCustomProxyObjectBase):
+
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.dash_content_list = self.wait_select_single(
+            'QQuickListView', objectName='dashContentList')
 
     @classmethod
     def validate_dbus_object(cls, path, state):
         return validate_dbus_object(
             path, state, UNITY8_DASH_PATH_ROOT, b'Dash', objectName='dash')
 
+    def get_applications_grid(self):
+        get_grid = self.get_scope('clickscope').wait_select_single(
+            'CardGrid', objectName='local')
+        return get_grid
+
+    def get_application_icon(self, text):
+        """Returns a 'Tile' icon that has the text 'text' from the application
+        grid.
+
+        :param text: String containing the text of the icon to search for.
+
+        """
+        app_grid = self.get_applications_grid()
+        resp_grid = app_grid.wait_select_single('ResponsiveGridView')
+        return resp_grid.select_single('Tile', text=text)
+
+    def get_scope(self, scope_name='clickscope'):
+        return self.dash_content_list.wait_select_single(
+            'QQuickLoader', scopeId=scope_name)
+
+    def get_scope_by_index(self, scope_index=0):
+        return self.dash_content_list.wait_select_single(
+            'QQuickLoader', objectName=("scopeLoader%i" % scope_index))
+
+    @autopilot.logging.log_action(logger.info)
+    def open_scope(self, scope_id):
+        """Open a dash scope.
+
+        :parameter scope_id: The id of the scope.
+        :return: The scope.
+
+        """
+        scope_loader = self._get_scope_loader(scope_id)
+        if scope_loader.isCurrent:
+            logger.info('The scope is already open.')
+            return self._get_scope_from_loader(scope_loader)
+        else:
+            return self._open_scope_scrolling(scope_loader)
+
+    def _get_scope_loader(self, scope_id):
+        try:
+            aux = self.dash_content_list.get_children_by_type('QQuickItem')[0]
+            for l in aux.get_children_by_type('QQuickLoader'):
+                if (l.scopeId == scope_id):
+                    return l
+            raise UnityException(
+                'No scope found with id {0}'.format(scope_id))
+        except dbus.StateNotFoundError:
+            raise UnityException(
+                'No scope found with id {0}'.format(scope_id))
+
+    def _get_scope_from_loader(self, loader):
+        return loader.wait_select_single('GenericScopeView')
+
+    def _open_scope_scrolling(self, scope_loader):
+        scroll = self._get_scroll_direction(scope_loader)
+
+        while not scope_loader.isCurrent:
+            scroll()
+            self.dash_content_list.moving.wait_for(False)
+
+        scope_loader.isCurrent.wait_for(True)
+        scope = self._get_scope_from_loader(scope_loader)
+        return scope
+
+    def _get_scroll_direction(self, scope_loader):
+        current_scope_loader = self.dash_content_list.select_single(
+            'QQuickLoader', isCurrent=True)
+        if scope_loader.globalRect.x < current_scope_loader.globalRect.x:
+            return self._scroll_to_left_scope
+        elif scope_loader.globalRect.x > current_scope_loader.globalRect.x:
+            return self._scroll_to_right_scope
+        else:
+            raise UnityException('The scope is already open')
+
+    @retry(stop_max_attempt_number=3,
+           wait_fixed=500,
+           retry_on_exception=lambda exception: (
+                   isinstance(exception, AssertionError)))
+    @autopilot.logging.log_action(logger.info)
+    def _scroll_to_left_scope(self):
+        original_index = self.dash_content_list.currentIndex
+        dash_content = self.select_single(objectName="dashContent")
+        x, y, width, height = dash_content.globalRect
+        # Make the drag range be a multiple of the drag "rate" value.
+        # Workarounds https://bugs.launchpad.net/mir/+bug/1399690
+        rate = 5
+        divisions = 5
+        jump = (width / divisions) // rate * rate
+        start_x = x + jump
+        stop_x = x + jump * (divisions - 1)
+        start_y = stop_y = y + 1
+        self.pointing_device.drag(start_x, start_y, stop_x, stop_y, rate)
+        self.dash_content_list.currentIndex.wait_for(original_index - 1)
+
+    @retry(stop_max_attempt_number=3,
+           wait_fixed=500,
+           retry_on_exception=lambda exception: (
+                   isinstance(exception, AssertionError)))
+    @autopilot.logging.log_action(logger.info)
+    def _scroll_to_right_scope(self):
+        original_index = self.dash_content_list.currentIndex
+        dash_content = self.select_single(objectName="dashContent")
+        x, y, width, height = dash_content.globalRect
+        # Make the drag range be a multiple of the drag "rate" value.
+        # Workarounds https://bugs.launchpad.net/mir/+bug/1399690
+        rate = 5
+        divisions = 5
+        jump = (width / divisions) // rate * rate
+        start_x = x + jump * (divisions - 1)
+        stop_x = x + jump
+        start_y = stop_y = y + 1
+        self.pointing_device.drag(start_x, start_y, stop_x, stop_y, rate)
+        self.dash_content_list.currentIndex.wait_for(original_index + 1)
+
+    def enter_search_query(self, query, keyboard):
+        current_header = self._get_current_page_header()
+        search_button = \
+            current_header.select_single(objectName="search_button")
+        self.pointing_device.move(
+            search_button.globalRect.x + search_button.width / 2,
+            search_button.globalRect.y + search_button.height / 2)
+        self.pointing_device.click()
+        headerContainer = current_header.select_single(
+            objectName="headerContainer")
+        headerContainer.contentY.wait_for(0)
+        keyboard.type(query)
+        self.select_single(
+            objectName="processingIndicator").visible.wait_for(False)
+
+    def get_search_text_field(self):
+        page_header = self._get_current_page_header()
+        return page_header.select_single(objectName='searchTextField')
+
+    def _get_current_page_header(self):
+        all_scopes = self.dash_content_list.select_many("GenericScopeView")
+        for i in all_scopes:
+            if i.isCurrent:
+                return i.select_single(objectName="scopePageHeader")
+        return None
+
     def wait_for_processing_to_complete(self, timeout=90):
         """Wait until the dash is fully loaded"""
         self.select_single(
@@ -52,28 +214,6 @@
         dash_content = self.select_single(objectName='dashContent')
         dash_content.pageHeaderTotallyVisible.wait_for(True)
 
-    @retry(stop_max_attempt_number=3,
-           wait_fixed=500,
-           retry_on_exception=lambda exception: (
-               isinstance(exception, AssertionError)))
-    def _scroll_to_left_scope(self):
-        """
-        Call parent implementation, retrying in case it raises
-        an exception due to a failed  scrolling
-        """
-        super()._scroll_to_left_scope()
-
-    @retry(stop_max_attempt_number=3,
-           wait_fixed=500,
-           retry_on_exception=lambda exception: (
-               isinstance(exception, AssertionError)))
-    def _scroll_to_right_scope(self):
-        """
-        Call parent implementation, retrying in case it raises
-        an exception due to a failed  scrolling
-        """
-        super()._scroll_to_right_scope()
-
     def scroll_to_left_scope(self):
         self._scroll_to_left_scope()
         self.dash_content_list.moving.wait_for(False)
@@ -145,3 +285,84 @@
             ScopesList,
             objectName='scopesList',
             visible=True)
+
+
+class ListViewWithPageHeader(QQuickFlickable):
+
+    margin_to_swipe_from_bottom = units.gu(4)
+
+
+class GenericScopeView(UbuntuUIToolkitCustomProxyObjectBase):
+    """Autopilot helper for generic scopes."""
+
+    @autopilot.logging.log_action(logger.info)
+    def open_preview(self, category, app_name, press_duration=0.10):
+        """Open the preview of an application.
+
+        :parameter category: The name of the category where the application is.
+        :parameter app_name: The name of the application.
+        :return: The opened preview.
+
+        """
+        # FIXME some categories need a long press in order to see the preview.
+        # Some categories do not show previews, like recent apps.
+        # --elopio - 2014-1-14
+        self.click_scope_item(category, app_name, press_duration)
+        preview_list = self.wait_select_single(
+            'QQuickLoader', objectName='subPageLoader')
+        preview_list.subPageShown.wait_for(True)
+        preview_list.x.wait_for(0)
+        self.get_root_instance().select_single(
+            objectName='processingIndicator').visible.wait_for(False)
+        return preview_list.select_single(
+            Preview, objectName='preview')
+
+    @autopilot.logging.log_action(logger.debug)
+    def click_scope_item(self, category, title, press_duration=0.10):
+        """Click an item from the scope.
+
+        :parameter category: The name of the category where the item is.
+        :parameter title: The title of the item.
+
+        """
+        category_element = self._get_category_element(category)
+        icon = category_element.wait_select_single(
+            'UCAbstractButton', title=title)
+        list_view = self.select_single(
+            ListViewWithPageHeader, objectName='categoryListView')
+        list_view.swipe_child_into_view(icon)
+        self.pointing_device.click_object(icon, press_duration=press_duration)
+
+    def _get_category_element(self, category):
+        try:
+            return self.wait_select_single(
+                'DashCategoryBase',
+                objectName='dashCategory{}'.format(category))
+        except dbus.StateNotFoundError:
+            raise UnityException(
+                'No category found with name {}'.format(category))
+
+    def get_applications(self, category):
+        """Return the list of applications on a category.
+
+        :parameter category: The name of the category.
+
+        """
+        category_element = self._get_category_element(category)
+        see_all = category_element.select_single(objectName='seeAll')
+        application_cards = category_element.select_many('UCAbstractButton')
+
+        application_cards = sorted(
+            (card for card in application_cards
+             if card.globalRect.y < see_all.globalRect.y),
+            key=lambda card: (card.globalRect.y, card.globalRect.x))
+
+        result = []
+        for card in application_cards:
+            if card.objectName not in ('cardToolCard', 'seeAll'):
+                result.append(card.title)
+        return result
+
+
+class Preview(UbuntuUIToolkitCustomProxyObjectBase):
+    """Autopilot custom proxy object for generic previews."""

=== modified file 'ubuntu_system_tests/helpers/unity8/fixture_setup.py'
--- ubuntu_system_tests/helpers/unity8/fixture_setup.py	2015-05-21 18:15:40 +0000
+++ ubuntu_system_tests/helpers/unity8/fixture_setup.py	2016-06-10 02:06:42 +0000
@@ -18,9 +18,314 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+import fixtures
+import logging
 import os
-
-import fixtures
+import subprocess
+import threading
+
+import ubuntuuitoolkit
+from autopilot import introspection
+from autopilot.matchers import Eventually
+from testtools.matchers import Equals
+from ubuntuuitoolkit import fixture_setup
+
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.unity8 import (
+    get_binary_path,
+    get_mocks_library_path,
+    get_default_extra_mock_libraries,
+    get_data_dirs,
+    get_unity_pid,
+    restart_unity_with_testability,
+    sensors
+)
+from ubuntu_system_tests.helpers.unity8.shell._cpo import ShellView
+
+logger = logging.getLogger(__name__)
+
+
+class LaunchUnityWithFakeSensors(fixtures.Fixture):
+
+    """Fixture to launch Unity8 with an injectable sensors backend.
+
+    :ivar unity_proxy: The Autopilot proxy object for the Unity shell.
+
+    """
+
+    unity_proxy = None
+    main_win = None
+
+    def setUp(self):
+        """Restart Unity8 with testability and create sensors."""
+        super().setUp()
+        self.useFixture(
+            fixture_setup.InitctlEnvironmentVariable(
+                UBUNTU_PLATFORM_API_TEST_OVERRIDE='sensors'))
+
+        self.addCleanup(processes.stop_job, 'unity8')
+        restart_thread = threading.Thread(
+            target=self._restart_unity_with_testability)
+        restart_thread.start()
+
+        self._create_sensors()
+
+        restart_thread.join()
+        self.fake_sensors = sensors.FakePlatformSensors()
+
+    def _get_lightdm_mock_path(self):
+        lib_path = get_mocks_library_path()
+        lightdm_mock_path = os.path.abspath(
+            os.path.join(lib_path, "IntegratedLightDM", "liblightdm")
+        )
+
+        if not os.path.exists(lightdm_mock_path):
+            raise RuntimeError(
+                "LightDM mock does not exist at path {}.".
+                format(lightdm_mock_path)
+            )
+        return lightdm_mock_path
+
+    def _get_qml_import_path_with_mock(self):
+        """Return the QML2_IMPORT_PATH value with the mock path prepended."""
+        qml_import_path = [get_mocks_library_path()]
+        if os.getenv('QML2_IMPORT_PATH') is not None:
+            qml_import_path.append(os.getenv('QML2_IMPORT_PATH'))
+
+        qml_import_path = ':'.join(qml_import_path)
+        return qml_import_path
+
+    def _remove_and_ignore_os_error(self, path):
+        try:
+            os.unlink(path)
+        except OSError:
+            pass
+
+    def _restart_unity_with_testability(self):
+        _environment = {}
+
+        data_dirs = get_data_dirs(True)
+        if data_dirs is not None:
+            _environment['XDG_DATA_DIRS'] = data_dirs
+
+        _environment['QML2_IMPORT_PATH'] = (
+            self._get_qml_import_path_with_mock()
+        )
+
+        new_ld_library_path = [
+            get_default_extra_mock_libraries(),
+            self._get_lightdm_mock_path()
+        ]
+        if os.getenv('LD_LIBRARY_PATH') is not None:
+            new_ld_library_path.append(os.getenv('LD_LIBRARY_PATH'))
+        new_ld_library_path = ':'.join(new_ld_library_path)
+        _environment['LD_LIBRARY_PATH'] = new_ld_library_path
+
+        # FIXME: we shouldn't be doing this
+        # $MIR_SOCKET, fallback to $XDG_RUNTIME_DIR/mir_socket and
+        # /tmp/mir_socket as last resort
+        self._remove_and_ignore_os_error(
+            os.getenv('MIR_SOCKET', os.path.join(
+                os.getenv('XDG_RUNTIME_DIR', "/tmp"), "mir_socket")))
+        self._remove_and_ignore_os_error("/tmp/mir_socket")
+
+        binary_arg = "BINARY=%s" % get_binary_path()
+        env_args = ["%s=%s" % (k, v) for k, v in _environment.items()]
+        args = [binary_arg] + env_args
+        self.unity_proxy = restart_unity_with_testability(*args)
+        self.main_win = self.unity_proxy.select_single(ShellView)
+
+    def _create_sensors(self):
+        # Wait for unity to start running.
+        Eventually(Equals(True)).match(
+            lambda: processes.is_job_running('unity8'))
+
+        # Wait for the sensors fifo file to be created.
+        fifo_path = '/tmp/sensor-fifo-{0}'.format(
+            get_unity_pid())
+        Eventually(Equals(True)).match(
+            lambda: os.path.exists(fifo_path))
+
+        with open(fifo_path, 'w') as fifo:
+            fifo.write('create accel 0 1000 0.1\n')
+            fifo.write('create light 0 10 1\n')
+            fifo.write('create proximity\n')
+
+
+class RestartUnityWithTestability(fixtures.Fixture):
+
+    """Fixture to launch Unity8 with testability.
+
+    :ivar unity_proxy: The Autopilot proxy object for the Unity shell.
+
+    """
+
+    unity_proxy = None
+
+    def __init__(self, binary_path, variables):
+        """Initialize the fixture instance.
+
+        :param str binary_path: The path to the Dash app binary.
+        :param cli_arguments: The arguments to pass when launching the
+        :param variables: The variables to use when launching the app.
+        :type variables: A dictionary.
+
+        """
+        super().__init__()
+        self.binary_path = binary_path
+        self.variables = variables
+
+    def setUp(self):
+        """Restart unity with testability when the fixture is used."""
+        super().setUp()
+        self.addCleanup(self.stop_unity)
+        self.restart_unity()
+
+    def restart_unity(self):
+        self.restart_unity_with_testability()
+
+    def restart_unity_with_testability(self):
+        self._unlink_mir_socket()
+
+        binary_arg = 'BINARY={}'.format(self.binary_path)
+        variable_args = [
+            '{}={}'.format(key, value) for key, value in self.variables.items()
+        ]
+        all_args = [binary_arg] + variable_args
+
+        self.unity_proxy = restart_unity_with_testability(*all_args)
+
+    def _unlink_mir_socket(self):
+        # FIXME: we shouldn't be doing this
+        # $MIR_SOCKET, fallback to $XDG_RUNTIME_DIR/mir_socket and
+        # /tmp/mir_socket as last resort
+        try:
+            os.unlink(
+                os.getenv('MIR_SOCKET',
+                          os.path.join(os.getenv('XDG_RUNTIME_DIR', "/tmp"),
+                                       "mir_socket")))
+        except OSError:
+            pass
+        try:
+            os.unlink("/tmp/mir_socket")
+        except OSError:
+            pass
+
+    def stop_unity(self):
+        processes.stop_job('unity8')
+
+
+class LaunchDashApp(fixtures.Fixture):
+
+    """Fixture to launch the Dash app."""
+
+    def __init__(self, binary_path, variables):
+        """Initialize an instance.
+
+        :param str binary_path: The path to the Dash app binary.
+        :param variables: The variables to use when launching the app.
+        :type variables: A dictionary.
+
+        """
+        super().__init__()
+        self.binary_path = binary_path
+        self.variables = variables
+
+    def setUp(self):
+        """Launch the dash app when the fixture is used."""
+        super().setUp()
+        self.addCleanup(self.stop_application)
+        self.application_proxy = self.launch_application()
+
+    def launch_application(self):
+        binary_arg = 'BINARY={}'.format(self.binary_path)
+        testability_arg = 'QT_LOAD_TESTABILITY={}'.format(1)
+        env_args = [
+            '{}={}'.format(key, value) for key, value in self.variables.items()
+        ]
+        all_args = [binary_arg, testability_arg] + env_args
+
+        pid = processes.start_job('unity8-dash', *all_args)
+        return introspection.get_proxy_object_for_existing_process(
+            pid=pid,
+            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase
+        )
+
+    def stop_application(self):
+        processes.stop_job('unity8-dash')
+
+
+class DisplayRotationLock(fixtures.Fixture):
+
+    def __init__(self, enable):
+        super().__init__()
+        self.enable = enable
+
+    def setUp(self):
+        super().setUp()
+        original_state = self._is_rotation_lock_enabled()
+        if self.enable != original_state:
+            self.addCleanup(self._set_rotation_lock, original_state)
+            self._set_rotation_lock(self.enable)
+
+    def _is_rotation_lock_enabled(self):
+        command = [
+            'gsettings', 'get',
+            'com.ubuntu.touch.system',
+            'rotation-lock'
+        ]
+        output = subprocess.check_output(command, universal_newlines=True)
+        return True if output.count('true') else False
+
+    def _set_rotation_lock(self, value):
+        value_string = 'true' if value else 'false'
+        command = [
+            'gsettings', 'set',
+            'com.ubuntu.touch.system',
+            'rotation-lock', value_string
+        ]
+        subprocess.check_output(command)
+
+
+class LaunchMockIndicatorService(fixtures.Fixture):
+
+    """Fixture to launch the indicator test service."""
+
+    def __init__(self, action_delay, ensure_not_running=True):
+        """Initialize an instance.
+
+        :param action_delay: The delay to use when activating actions.
+          Measured in milliseconds. Value of -1 will result in infinite delay.
+        :type action_delay: An integer.
+        :param boolean ensure_not_running: Make sure service is not running
+
+        """
+        super(LaunchMockIndicatorService, self).__init__()
+        self.action_delay = action_delay
+        self.ensure_not_running = ensure_not_running
+
+    def setUp(self):
+        super().setUp()
+        if self.ensure_not_running:
+            self.ensure_service_not_running()
+        self.addCleanup(self.stop_service)
+        self.application_proxy = self.launch_service()
+
+    def launch_service(self):
+        logger.info("Starting unity-mock-indicator-service")
+        binary_path = get_binary_path('unity-mock-indicator-service')
+        binary_arg = 'BINARY={}'.format(binary_path)
+        env_args = 'ARGS=-t {}'.format(self.action_delay)
+        all_args = [binary_arg, env_args]
+        processes.start_job('unity-mock-indicator-service', *all_args)
+
+    def stop_service(self):
+        logger.info("Stopping unity-mock-indicator-service")
+        processes.stop_job('unity-mock-indicator-service')
+
+    def ensure_service_not_running(self):
+        if processes.is_job_running('unity-mock-indicator-service'):
+            self.stop_service()
 
 
 class SettingsWizard(fixtures.Fixture):

=== modified file 'ubuntu_system_tests/helpers/unity8/greeter.py'
--- ubuntu_system_tests/helpers/unity8/greeter.py	2016-04-18 17:29:42 +0000
+++ ubuntu_system_tests/helpers/unity8/greeter.py	2016-06-10 02:06:42 +0000
@@ -19,14 +19,21 @@
 #
 
 import dbus
+
 from autopilot.matchers import Eventually
+from autopilot.utilities import sleep
 from testtools.matchers import Equals
+from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase, TextField
 
 
 def wait_for_greeter():
     Eventually(Equals(True), timeout=300).match(_is_greeter_active)
 
 
+def wait_for_greeter_gone():
+    Eventually(Equals(False), timeout=300).match(_is_greeter_active)
+
+
 def _is_greeter_active():
     try:
         dbus_proxy = _get_greeter_dbus_proxy()
@@ -50,3 +57,55 @@
     dbus_proxy = _get_greeter_dbus_proxy()
     if not _is_greeter_active():
         dbus_proxy.ShowGreeter()
+
+
+def unlock_unity():
+    """Helper function that attempts to unlock the unity greeter. """
+    wait_for_greeter()
+    hide_greeter_with_dbus()
+    wait_for_greeter_gone()
+
+
+def lock_unity():
+    """Helper function that attempts to lock unity greeter. """
+    show_greeter_with_dbus()
+    wait_for_greeter()
+
+
+class Greeter(UbuntuUIToolkitCustomProxyObjectBase):
+    """A helper that understands the greeter screen."""
+
+    def wait_swiped_away(self):
+        # We have to be careful here, because coverPage can go away at any time
+        # if there isn't a lockscreen behind it (it hides completely, then
+        # the greeter disposes it).  But if there *is* a lockscreen, then we
+        # need a different check, by looking at its showProgress.  So make our
+        # own wait_for loop and check both possibilities.
+        for i in range(10):
+            if not self.required:
+                return
+            coverPage = self.select_single(objectName='coverPage')
+            if coverPage.showProgress == 0:
+                return
+            sleep(1)
+
+        raise AssertionError("Greeter cover page still up after 10s")
+
+    def swipe(self):
+        """Swipe the greeter screen away."""
+        self.waiting.wait_for(False)
+        coverPage = self.select_single(objectName='coverPage')
+        coverPage.showProgress.wait_for(1)
+
+        rect = self.globalRect
+        start_x = rect[0] + rect[2] - 3
+        start_y = int(rect[1] + rect[3] / 2)
+        stop_x = int(rect[0] + rect[2] * 0.2)
+        stop_y = start_y
+        self.pointing_device.drag(start_x, start_y, stop_x, stop_y)
+
+        self.wait_swiped_away()
+
+    def get_prompt(self):
+        return self.select_single(
+            TextField, objectName='passwordInput')

=== added file 'ubuntu_system_tests/helpers/unity8/indicators.py'
--- ubuntu_system_tests/helpers/unity8/indicators.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/unity8/indicators.py	2016-06-10 02:06:42 +0000
@@ -0,0 +1,179 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2016 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from autopilot import introspection
+from ubuntuuitoolkit import (
+    UbuntuUIToolkitCustomProxyObjectBase, CheckBox, QQuickFlickable)
+
+
+class IndicatorPage(UbuntuUIToolkitCustomProxyObjectBase):
+
+    """Autopilot helper for the IndicatorPage component."""
+
+    # XXX Because of https://bugs.launchpad.net/autopilot-qt/+bug/1341671
+    # we need to make sure it does not match in any selection.
+    # --elopio - 2015-01-20
+
+    @classmethod
+    def validate_dbus_object(cls, path, state):
+        return False
+
+
+class Indicator():
+
+    def __init__(self, main_window, name):
+        self._main_window = main_window
+        self._name = name
+
+    def is_indicator_icon_visible(self):
+        panel_item = self._main_window.wait_select_single(
+            objectName=self._name+'-panelItem')
+        return panel_item.indicatorVisible
+
+    def open(self):
+        """Open the indicator page.
+
+        :return: The custom proxy object for the indicator page.
+
+        """
+        if self.is_indicator_icon_visible():
+            return self._main_window.open_indicator_page(self._name)
+        else:
+            return self._open_indicator_with_icon_not_visible()
+
+    def _open_indicator_with_icon_not_visible(self):
+        # Open any displayed indicator.
+        self._main_window.open_indicator_page('indicator-datetime')
+        self._make_indicator_icon_visible()
+        indicator_rotation_icon = self._main_window.select_single(
+            objectName=self._name+'-panelItem')
+        self._main_window.pointing_device.click_object(indicator_rotation_icon)
+        return self._main_window.wait_select_single(
+            objectName=self._name+'-page')
+
+    def _make_indicator_icon_visible(self):
+        indicators_bar = self._main_window.select_single('IndicatorsBar')
+        indicators_bar_flickable = indicators_bar.select_single(
+            QQuickFlickable, objectName='flickable')
+        self._swipe_flickable_to_x_end(indicators_bar_flickable)
+
+    def _swipe_flickable_to_x_end(self, flickable):
+        # XXX this should be implemented as a general horizontal swiping in
+        # the toolkit custom proxy object. -- elopio - 2015-01-20
+        if not flickable.atXEnd:
+            flickable.interactive.wait_for(True)
+            while not flickable.atXEnd:
+                start_y = stop_y = (
+                    flickable.globalRect.y +
+                    (flickable.globalRect.height // 2))
+                # We can't start the swipe from the border because it would
+                # open the launcher
+                start_x = flickable.globalRect.x + 45
+                stop_x = (
+                    flickable.globalRect.x + flickable.globalRect.width - 5)
+                flickable.pointing_device.drag(
+                    start_x, start_y, stop_x, stop_y)
+                flickable.dragging.wait_for(False)
+                flickable.moving.wait_for(False)
+
+    def close(self):
+        """Close the indicator page."""
+        self._main_window.close_indicator_page()
+
+
+class DisplayIndicator(Indicator):
+
+    def __init__(self, main_window):
+        super(DisplayIndicator, self).__init__(main_window,
+                                               'indicator-rotation-lock')
+        self._main_window = main_window
+
+
+class DisplayIndicatorPage(IndicatorPage):
+
+    """Autopilot helper for the display indicator page."""
+
+    @classmethod
+    def validate_dbus_object(cls, path, state):
+        name = introspection.get_classname_from_path(path)
+        if name == b'IndicatorPage':
+            if state['objectName'][1] == 'indicator-rotation-lock-page':
+                return True
+        return False
+
+    def lock_rotation(self):
+        """Toggle the rotation lock indicator to locked."""
+        switcher = self._get_switcher()
+        switcher.check()
+        switcher.checked.wait_for(True)
+
+    def _get_switcher(self):
+        return self.select_single(
+            CheckBox, objectName='switcher')
+
+    def unlock_rotation(self):
+        """Toggle the rotation lock indicator to unlocked."""
+        switcher = self._get_switcher()
+        switcher.uncheck()
+        switcher.checked.wait_for(False)
+
+
+class TestIndicator(Indicator):
+
+    def __init__(self, main_window):
+        super(TestIndicator, self).__init__(main_window, 'indicator-mock')
+        self._main_window = main_window
+
+
+class Slider(UbuntuUIToolkitCustomProxyObjectBase):
+    """Autopilot helper for the Slider component."""
+
+    # XXX Because of https://bugs.launchpad.net/autopilot-qt/+bug/1341671
+    # we need to make sure it does not match in any selection.
+    # --elopio - 2015-01-20
+
+    @classmethod
+    def validate_dbus_object(cls, path, state):
+        name = introspection.get_classname_from_path(path)
+        if name == b'Slider':
+            return True
+        return False
+
+    def slide_left(self, timeout=10):
+        x, y, width, height = self.globalRect
+
+        rate = 5
+        start_x = x + width/2
+        start_y = stop_y = y + height/2
+        stop_x = x
+
+        self.pointing_device.drag(start_x, start_y, stop_x, stop_y, rate)
+        self.value.wait_for(self.minimumValue, timeout)
+
+    def slide_right(self, timeout=10):
+        x, y, width, height = self.globalRect
+
+        rate = 5
+        start_x = x + width/2
+        start_y = stop_y = y + height/2
+        stop_x = x + width
+
+        self.pointing_device.drag(start_x, start_y, stop_x, stop_y, rate)
+        self.value.wait_for(self.maximumValue, timeout)

=== added file 'ubuntu_system_tests/helpers/unity8/launcher.py'
--- ubuntu_system_tests/helpers/unity8/launcher.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/unity8/launcher.py	2016-06-10 02:06:42 +0000
@@ -0,0 +1,66 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2016 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import logging
+
+import autopilot.logging
+import ubuntuuitoolkit
+
+from ubuntu_system_tests.helpers import unity8
+
+logger = logging.getLogger(__name__)
+
+
+class Launcher(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
+
+    """A helper that understands the Launcher."""
+
+    @autopilot.logging.log_action(logger.debug)
+    def show(self):
+        """Show the launcher swiping it to the right."""
+        if not self.shown:
+            self._swipe_to_show_launcher()
+            self.shown.wait_for(True)
+        else:
+            logger.debug('The launcher is already opened.')
+
+    def _swipe_to_show_launcher(self):
+        view = self.get_root_instance().select_single('ShellView')
+        start_y = stop_y = view.y + view.height // 2
+
+        start_x = view.x + 1
+        stop_x = start_x + self.panelWidth - 1
+
+        self.pointing_device.drag(start_x, start_y, stop_x, stop_y)
+
+    @autopilot.logging.log_action(logger.debug)
+    def click_dash_icon(self):
+        if self.shown:
+            dash_icon = self.select_single(
+                'QQuickImage', objectName='dashItem')
+            self.pointing_device.click_object(dash_icon)
+        else:
+            raise unity8.UnityException('The launcher is closed.')
+
+    @autopilot.logging.log_action(logger.debug)
+    def click_application_launcher_icon(self, application_name):
+        launcher_delegate = self.select_single(
+            'LauncherDelegate', appId=application_name)
+        self.pointing_device.click_object(launcher_delegate)

=== modified file 'ubuntu_system_tests/helpers/unity8/phone_stage.py'
--- ubuntu_system_tests/helpers/unity8/phone_stage.py	2016-04-27 21:43:27 +0000
+++ ubuntu_system_tests/helpers/unity8/phone_stage.py	2016-06-10 02:06:42 +0000
@@ -20,7 +20,7 @@
 
 import logging
 
-from autopilot import logging as autopilot_logging
+import autopilot
 from autopilot.exceptions import StateNotFoundError
 from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase
 from ubuntu_system_tests.helpers.autopilot import validate_dbus_object
@@ -80,14 +80,14 @@
         mid_x = x + ((next_x - x) // 4)
         return mid_x, mid_y
 
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def _press_app(self, app_window):
         """Press on the required app_window object."""
         x, y = self._get_app_window_touch_point(app_window)
         self.pointing_device.move(x, y)
         self.pointing_device.click()
 
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def _swipe_from_app_to_right_edge(self, app_window):
         """Swipe from the required app_window object to right screen edge."""
         start_x, start_y = self._get_app_window_touch_point(app_window)
@@ -95,7 +95,7 @@
         end_y = start_y
         self.pointing_device.drag(start_x, start_y, end_x, end_y, rate=3)
 
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def _swipe_from_app_to_top_edge(self, app_window):
         """Swipe from the required app_window object to top screen edge."""
         start_x, start_y = self._get_app_window_touch_point(app_window)
@@ -103,7 +103,7 @@
         end_y = 0
         self.pointing_device.drag(start_x, start_y, end_x, end_y)
 
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def _swipe_from_right(self):
         """Swipe from right edge to reveal the application switcher"""
         width = self.width

=== modified file 'ubuntu_system_tests/helpers/unity8/sensors.py'
--- ubuntu_system_tests/helpers/unity8/sensors.py	2016-04-25 19:02:31 +0000
+++ ubuntu_system_tests/helpers/unity8/sensors.py	2016-06-10 02:06:42 +0000
@@ -18,12 +18,95 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+import logging
 import os
 import stat
 
 from ubuntu_system_tests.helpers import context
 from ubuntu_system_tests.helpers import wait_until
 from ubuntu_system_tests.helpers.testbed import write_to_file_with_sudo
+from ubuntu_system_tests.helpers import unity8
+
+logger = logging.getLogger(__name__)
+
+
+class FakePlatformSensors:
+
+    def __init__(self, pid=None):
+        self.pid = pid or unity8.get_unity_pid()
+
+    def _set_orientation_top_up(self):
+        with open("/tmp/sensor-fifo-{0}".format(self.pid), "w") as fifo:
+            fifo.write("70 accel -10.050858 -0.598550 0.756568\n")
+            fifo.write("70 accel -9.797073 -0.555455 1.019930\n")
+            fifo.write("70 accel -10.141838 -0.770933 0.632069\n")
+            fifo.write("70 accel -12.057199 -1.259350 1.690306\n")
+            fifo.write("70 accel -19.282900 -3.926491 3.098097\n")
+            fifo.write("70 accel -14.480132 -14.269443 1.216254\n")
+            fifo.write("70 accel 16.419436 4.242526 -7.714118\n")
+            fifo.write("70 accel 5.583278 8.279149 -1.848324\n")
+            fifo.write("70 accel 1.422156 8.547300 0.416591\n")
+            fifo.write("70 accel 4.357447 9.988609 -0.110133\n")
+            fifo.write("70 accel 0.699107 9.840169 0.756568\n")
+            fifo.write("70 accel 1.364695 9.844957 -0.287304\n")
+            fifo.flush()
+
+    def _set_orientation_top_down(self):
+        with open("/tmp/sensor-fifo-{0}".format(self.pid), "w") as fifo:
+            fifo.write("70 accel -10.050858 -0.598550 0.756568\n")
+            fifo.write("70 accel 9.538500 -0.603339 1.292869\n")
+            fifo.write("70 accel 9.485827 -0.636858 1.422156\n")
+            fifo.write("70 accel 9.677363 -0.402226 1.374272\n")
+            fifo.write("70 accel 9.303867 -0.507571 1.283292\n")
+            fifo.write("70 accel 8.604761 -1.015141 1.436521\n")
+            fifo.write("70 accel 7.580042 -2.001553 0.521936\n")
+            fifo.write("70 accel 7.503428 -4.247314 0.502782\n")
+            fifo.write("70 accel 7.067683 -7.240066 0.842759\n")
+            fifo.write("70 accel 6.488286 -9.873688 -0.541090\n")
+            fifo.write("70 accel 6.229713 -9.241618 -1.048660\n")
+            fifo.write("70 accel 4.046201 -9.198523 -0.057461\n")
+            fifo.write("70 accel 2.398990 -9.629479 0.957681\n")
+            fifo.write("70 accel 1.632846 -9.361329 -0.311246\n")
+            fifo.write("70 accel -0.181959 -9.696517 -0.301669\n")
+            fifo.flush()
+
+    def _set_orientation_left_up(self):
+        with open("/tmp/sensor-fifo-{0}".format(self.pid), "w") as fifo:
+            fifo.write("70 accel -10.050858 -0.598550 0.756568\n")
+            fifo.write("70 accel 0.196325 9.878476 0.948104\n")
+            fifo.write("70 accel 0.258574 9.955091 1.091756\n")
+            fifo.write("70 accel 0.287304 10.041282 1.134852\n")
+            fifo.write("70 accel 1.537078 10.553641 1.561020\n")
+            fifo.write("70 accel 8.130709 10.093954 2.561796\n")
+            fifo.write("70 accel -0.229843 5.348647 1.723825\n")
+            fifo.write("70 accel -9.916783 0.488417 -3.418920\n")
+            fifo.write("70 accel -13.417107 -0.416591 -2.360683\n")
+            fifo.write("70 accel -13.872005 -2.049437 -0.574608\n")
+            fifo.flush()
+
+    def _set_orientation_right_up(self):
+        with open("/tmp/sensor-fifo-{0}".format(self.pid), "w") as fifo:
+            fifo.write("70 accel -10.050858 -0.598550 0.756568\n")
+            fifo.write("70 accel -4.550858 -0.598550 0.856568\n")
+            fifo.write("70 accel -0.799663 9.988609 1.197101\n")
+            fifo.write("70 accel -0.861913 9.864111 1.066701\n")
+            fifo.write("70 accel -0.861913 9.864111 0.866701\n")
+            fifo.write("70 accel -1.776498 9.830592 1.273715\n")
+            fifo.write("70 accel -2.376498 9.830592 1.273715\n")
+            fifo.write("70 accel -13.158532 2.217031 1.091756\n")
+            fifo.write("70 accel 5.056554 1.067814 0.799663\n")
+            fifo.write("70 accel 5.056554 1.767814 0.799663\n")
+            fifo.write("70 accel 14.882358 2.896984 1.221043\n")
+            fifo.write("70 accel 9.466674 -0.363919 -1.029507\n")
+            fifo.write("70 accel 11.253524 -0.186748 -0.311246\n")
+            fifo.write("70 accel 12.253524 -0.186748 -0.311246\n")
+            fifo.flush()
+
+    def set_orientation(self, action):
+        try:
+            getattr(self, '_set_orientation_{}'.format(action))()
+        except AttributeError:
+            logger.error('Action {} not defined'.format(action))
 
 
 def get_unity8_fifo_path():

=== added directory 'ubuntu_system_tests/helpers/unity8/shell'
=== removed file 'ubuntu_system_tests/helpers/unity8/shell.py'
--- ubuntu_system_tests/helpers/unity8/shell.py	2016-06-02 09:12:43 +0000
+++ ubuntu_system_tests/helpers/unity8/shell.py	1970-01-01 00:00:00 +0000
@@ -1,169 +0,0 @@
-# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
-
-#
-# Ubuntu System Tests
-# Copyright (C) 2015, 2016 Canonical
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-#
-
-import logging
-
-from autopilot import (
-    exceptions,
-    logging as autopilot_logging
-)
-import ubuntuuitoolkit
-from unity8.shell.emulators import main_window
-
-from ubuntu_system_tests.helpers.autopilot import validate_dbus_object
-from ubuntu_system_tests.helpers.indicators.message import NotificationsIndicatorPage, NotificationsIndicatorItem  # NOQA
-from ubuntu_system_tests.helpers.notifications.utils import Notifications
-from ubuntu_system_tests.helpers.unity8 import (
-    greeter as greeter_helpers, UNITY8_PATH_ROOT)
-
-logger = logging.getLogger(__name__)
-
-
-class Unity8(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
-
-    """Autopilot custom proxy object for the Unity8 shell."""
-
-    @classmethod
-    def validate_dbus_object(cls, path, state):
-        return validate_dbus_object(
-            path, state, UNITY8_PATH_ROOT, UNITY8_PATH_ROOT,
-            applicationName='unity8')
-
-    @property
-    def main_window(self):
-        return self.select_single(ShellView)
-
-    @autopilot_logging.log_action(logger.debug)
-    def wait_for_greeter_content(self):
-        greeter = self.main_window.wait_select_single(objectName='greeter')
-        greeter.waiting.wait_for(False)
-
-    @autopilot_logging.log_action(logger.info)
-    def unlock(self):
-        greeter = self.main_window.get_greeter()
-        if greeter.created:
-            greeter_helpers.hide_greeter_with_dbus()
-            greeter.created.wait_for(False)
-
-    def show_dash_from_launcher(self):
-        self.main_window.show_dash_from_launcher()
-
-    def get_number_of_sessions(self):
-        application_window = self.select_single('ApplicationWindow')
-        return len(application_window.select_many('SessionContainer'))
-
-    def get_height(self):
-        return self.main_window.height
-
-    def get_width(self):
-        return self.main_window.width
-
-    def ensure_app_loaded(self):
-        try:
-            indicator = self.select_single('ActivityIndicator')
-            indicator.onScreen.wait_for(False)
-        except exceptions.StateNotFoundError:
-            # This is fine, it's already loaded
-            pass
-
-
-class ShellView(main_window.ShellView):
-    """Class to extend Unity8 main window ShellView."""
-
-    @classmethod
-    def validate_dbus_object(cls, path, state):
-        return validate_dbus_object(
-            path, state, UNITY8_PATH_ROOT, b'ShellView', title='Unity8')
-
-    def get_notifications_list(self):
-        """Return a list of notifications currently being displayed."""
-        return self.select_single(
-            Notifications, objectName='notificationList')
-
-    def get_notifications_panel(self):
-        """Return 'Notifications' panel object."""
-        return self._get_indicator_panel_item('indicator-messages')
-
-    def clear_notifications(self):
-        """
-        Clear all existing notifications from 'Notifications' indicator.
-
-        """
-        if self.is_new_notification_displayed():
-            self.open_indicator_page('indicator-messages').clear_all()
-            self.close_indicator_page()
-
-    def open_notifications_indicator(self):
-        """Swipe down to display the notifications indicator."""
-        return self.open_indicator_page('indicator-messages')
-
-    def is_new_notification_displayed(self):
-        """Return True if new notification message icon is displayed."""
-        return self.get_notifications_panel().is_new_message_displayed()
-
-    def get_passphrase_unlock_screen(self):
-        """Wait for input method to be in shown state and return lockscreen."""
-        from ubuntu_system_tests.helpers.unity8 import lock_screen
-        input_method = self.wait_select_single(
-            'InputMethod', objectName='inputMethod', visible=True)
-        input_method.state.wait_for('shown')
-        return self.select_single(lock_screen.PassphraseLockscreen)
-
-    def get_missed_call_snap_decision(self):
-        """Return missed call snap decision menu."""
-        from ubuntu_system_tests.helpers.snap_decision import missed_call
-        return self.select_single(
-            missed_call.SnapDecisionMenu, objectName='snapDecision',
-            visible=True)
-
-    def get_phone_stage(self):
-        from ubuntu_system_tests.helpers.unity8 import phone_stage
-        return self.select_single(phone_stage.PhoneStage, objectName='stage')
-
-    def swipe_to_show_app_switcher(self):
-        """Swipe from right edge to reveal task switcher."""
-        stage = self.get_phone_stage()
-        stage.swipe_to_top()
-        return stage
-
-    def get_current_focused_app(self):
-        """Return Id for current focused app."""
-        return self.select_single('Shell').focusedApplicationId
-
-    def _is_indicator_panel_opened(self):
-        indicator_page = self.wait_select_single('IndicatorsMenu')
-        return indicator_page.fullyOpened
-
-    def close_indicator_page(self):
-        """
-        Override the method to only try to close the indicator panel if its
-        not already.
-        """
-        if self._is_indicator_panel_opened():
-            super().close_indicator_page()
-
-    def is_indicator_item_hidden(self, indicator_name):
-        """
-        Return bool representing if the requested indicator item is hidden or
-        not.
-        """
-        item = self.select_single('IndicatorItem',
-                                  objectName=indicator_name + '-panelItem')
-        return item.hidden

=== added file 'ubuntu_system_tests/helpers/unity8/shell/__init__.py'
--- ubuntu_system_tests/helpers/unity8/shell/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/unity8/shell/__init__.py	2016-06-10 02:06:42 +0000
@@ -0,0 +1,31 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2016 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""unity shell autopilot tests and helpers - sub level package."""
+
+from ubuntu_system_tests.helpers.unity8.shell.utils import (
+    disable_qml_mocking,
+    create_ephemeral_notification,
+)
+
+__all__ = [
+    'disable_qml_mocking',
+    'create_ephemeral_notification',
+]

=== added file 'ubuntu_system_tests/helpers/unity8/shell/_cpo.py'
--- ubuntu_system_tests/helpers/unity8/shell/_cpo.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/unity8/shell/_cpo.py	2016-06-10 02:06:42 +0000
@@ -0,0 +1,319 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2016 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import logging
+import autopilot
+from autopilot import (
+    exceptions,
+    input
+)
+import ubuntuuitoolkit
+
+from ubuntu_system_tests.helpers.autopilot import validate_dbus_object
+from ubuntu_system_tests.helpers.notifications.utils import Notifications
+from ubuntu_system_tests.helpers.unity8 import (
+    greeter as greeter_helpers, launcher as launcher_helpers, UNITY8_PATH_ROOT)
+
+logger = logging.getLogger(__name__)
+
+
+class Unity8(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
+    """Autopilot custom proxy object for the Unity8 shell."""
+
+    @classmethod
+    def validate_dbus_object(cls, path, state):
+        return validate_dbus_object(
+            path, state, UNITY8_PATH_ROOT, UNITY8_PATH_ROOT,
+            applicationName='unity8')
+
+    @property
+    def main_window(self):
+        return self.select_single(ShellView)
+
+    @autopilot.logging.log_action(logger.debug)
+    def wait_for_greeter_content(self):
+        greeter = self.main_window.wait_select_single(objectName='greeter')
+        greeter.waiting.wait_for(False)
+
+    @autopilot.logging.log_action(logger.info)
+    def unlock(self):
+        greeter = self.main_window.get_greeter()
+        if greeter.created:
+            greeter_helpers.hide_greeter_with_dbus()
+            greeter.created.wait_for(False)
+
+    def show_dash_from_launcher(self):
+        self.main_window.show_dash_from_launcher()
+
+    def get_number_of_sessions(self):
+        application_window = self.select_single('ApplicationWindow')
+        return len(application_window.select_many('SessionContainer'))
+
+    def get_height(self):
+        return self.main_window.height
+
+    def get_width(self):
+        return self.main_window.width
+
+    def ensure_app_loaded(self):
+        try:
+            indicator = self.select_single('ActivityIndicator')
+            indicator.onScreen.wait_for(False)
+        except exceptions.StateNotFoundError:
+            # This is fine, it's already loaded
+            pass
+
+
+class ShellView(ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
+    """An helper class that makes it easy to interact with the shell"""
+
+    @classmethod
+    def validate_dbus_object(cls, path, state):
+        return validate_dbus_object(
+            path, state, UNITY8_PATH_ROOT, b'ShellView', title='Unity8')
+
+    def get_notifications_list(self):
+        """Return a list of notifications currently being displayed."""
+        return self.select_single(
+            Notifications, objectName='notificationList')
+
+    def get_notifications_panel(self):
+        """Return 'Notifications' panel object."""
+        return self._get_indicator_panel_item('indicator-messages')
+
+    def clear_notifications(self):
+        """
+        Clear all existing notifications from 'Notifications' indicator.
+
+        """
+        if self.is_new_notification_displayed():
+            self.open_indicator_page('indicator-messages').clear_all()
+            self.close_indicator_page()
+
+    def open_notifications_indicator(self):
+        """Swipe down to display the notifications indicator."""
+        return self.open_indicator_page('indicator-messages')
+
+    def is_new_notification_displayed(self):
+        """Return True if new notification message icon is displayed."""
+        return self.get_notifications_panel().is_new_message_displayed()
+
+    def get_passphrase_unlock_screen(self):
+        """Wait for input method to be in shown state and return lockscreen."""
+        from ubuntu_system_tests.helpers.unity8 import lock_screen
+        input_method = self.wait_select_single(
+            'InputMethod', objectName='inputMethod', visible=True)
+        input_method.state.wait_for('shown')
+        return self.select_single(lock_screen.PassphraseLockscreen)
+
+    def get_missed_call_snap_decision(self):
+        """Return missed call snap decision menu."""
+        from ubuntu_system_tests.helpers.snap_decision import missed_call
+        return self.select_single(
+            missed_call.SnapDecisionMenu, objectName='snapDecision',
+            visible=True)
+
+    def get_phone_stage(self):
+        from ubuntu_system_tests.helpers.unity8 import phone_stage
+        return self.select_single(phone_stage.PhoneStage, objectName='stage')
+
+    def swipe_to_show_app_switcher(self):
+        """Swipe from right edge to reveal task switcher."""
+        stage = self.get_phone_stage()
+        stage.swipe_to_top()
+        return stage
+
+    def _is_indicator_panel_opened(self):
+        indicator_page = self.wait_select_single('IndicatorsMenu')
+        return indicator_page.fullyOpened
+
+    def is_indicator_item_hidden(self, indicator_name):
+        """
+        Return bool representing if the requested indicator item is hidden or
+        not.
+        """
+        item = self.select_single('IndicatorItem',
+                                  objectName=indicator_name + '-panelItem')
+        return item.hidden
+
+    def get_greeter(self):
+        return self.select_single(greeter_helpers.Greeter)
+
+    def get_login_loader(self):
+        return self.select_single("QQuickLoader", objectName="loginLoader")
+
+    def get_login_list(self):
+        return self.select_single("LoginList")
+
+    def get_bottombar(self):
+        return self.select_single("Bottombar")
+
+    def get_pinPadLoader(self):
+        return self.select_single(
+            "QQuickLoader",
+            objectName="pinPadLoader"
+        )
+
+    def get_lockscreen(self):
+        return self.select_single("Lockscreen")
+
+    def get_pinentryField(self):
+        return self.select_single(objectName="pinentryField")
+
+    def _get_indicator_panel_item(self, indicator_name):
+        return self.select_single(
+            'IndicatorItem',
+            objectName=indicator_name+'-panelItem'
+        )
+
+    def _get_indicator_page(self, indicator_name):
+        return self.select_single(
+            'IndicatorPage',
+            objectName=indicator_name+'-page'
+        )
+
+    @autopilot.logging.log_action(logger.info)
+    def open_indicator_page(self, indicator_name):
+        """Swipe to open the indicator, wait until it's open.
+        :returns: The indicator page.
+        """
+        widget = self._get_indicator_panel_item(indicator_name)
+        start_x, start_y = input.get_center_point(widget)
+        end_x = start_x
+        end_y = self.height
+        self.pointing_device.drag(start_x, start_y, end_x, end_y)
+        self.wait_select_single('IndicatorsMenu', fullyOpened=True)
+        return self._get_indicator_page(indicator_name)
+
+    @autopilot.logging.log_action(logger.info)
+    def close_indicator_page(self):
+        """Swipe to close the opened indicator, wait until it's closed."""
+        indicators_menu = self.wait_select_single('IndicatorsMenu')
+        end_x, end_y = input.get_center_point(indicators_menu)
+        start_x = end_x
+        start_y = self.height
+        self.pointing_device.drag(start_x, start_y, end_x, end_y)
+        indicators_menu.fullyClosed.wait_for(True)
+
+    @autopilot.logging.log_action(logger.info)
+    def show_dash_swiping(self):
+        """Show the dash swiping from the left."""
+        x, y, width, height = self._get_shell().globalRect
+        start_x = x
+        end_x = x + width
+        start_y = end_y = y + height // 2
+
+        self.pointing_device.drag(start_x, start_y, end_x, end_y)
+        self.get_current_focused_app_id().wait_for('unity8-dash')
+
+    def _get_shell(self):
+        return self.select_single('Shell')
+
+    def get_current_focused_app_id(self):
+        """Return the id of the focused application."""
+        return self._get_shell().focusedApplicationId
+
+    @autopilot.logging.log_action(logger.info)
+    def show_dash_from_launcher(self):
+        """Open the dash clicking the dash icon on the launcher."""
+        launcher = self.open_launcher()
+        launcher.click_dash_icon()
+        self.get_current_focused_app_id().wait_for('unity8-dash')
+        launcher.shown.wait_for(False)
+
+    @autopilot.logging.log_action(logger.info)
+    def open_launcher(self):
+        launcher = self._get_launcher()
+        launcher.show()
+        return launcher
+
+    def _get_launcher(self):
+        return self.select_single(launcher_helpers.Launcher)
+
+    def is_launcher_open(self):
+        return self._get_launcher().shown
+
+    @autopilot.logging.log_action(logger.info)
+    def launch_application(self, application_name):
+        """Launch an application.
+
+        :parameter application_name: The name of the application to launch.
+
+        """
+        launcher = self.open_launcher()
+        launcher.click_application_launcher_icon(application_name)
+        self.get_current_focused_app_id().wait_for(application_name)
+        launcher.shown.wait_for(False)
+
+    def enter_pin_code(self, code):
+        """Enter code 'code' into the single-pin lightdm pincode entry screen.
+
+        :param code: must be a string of numeric characters.
+        :raises: TypeError if code is not a string.
+        :raises: ValueError if code contains non-numeric characters.
+
+        """
+        if not isinstance(code, str):
+            raise TypeError(
+                "'code' parameter must be a string, not %r."
+                % type(code)
+            )
+        for num in code:
+            if not num.isdigit():
+                raise ValueError(
+                    "'code' parameter contains non-numeric characters."
+                )
+            self.pointing_device.click_object(
+                self._get_pinpad_button(int(num)))
+
+    def _get_pinpad_button(self, button_id):
+        return self.select_single(
+            'PinPadButton',
+            objectName='pinPadButton{}'.format(button_id)
+        )
+
+    def get_shell_orientation_angle(self):
+        return self._get_shell().orientationAngle
+
+    def get_shell_orientation(self):
+        return self._get_shell().orientation
+
+    def get_shell_primary_orientation(self):
+        return self._get_shell().primaryOrientation
+
+    def get_shell_native_orientation(self):
+        return self._get_shell().nativeOrientation
+
+    @autopilot.logging.log_action(logger.info)
+    def wait_for_notification(self):
+        """Wait for a notification dialog to appear.
+
+        :return: An object for the notification dialog data.
+        :raise StateNotFoundError: if the timeout expires when the
+        notification has not appeared.
+
+        """
+        notify_list = self.select_single('Notifications',
+                                         objectName='notificationList')
+        visible_notification = notify_list.wait_select_single('Notification',
+                                                              visible=True)
+        return {'summary': visible_notification.summary,
+                'body': visible_notification.body,
+                'iconSource': visible_notification.iconSource}

=== added file 'ubuntu_system_tests/helpers/unity8/shell/fixture_setup.py'
--- ubuntu_system_tests/helpers/unity8/shell/fixture_setup.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/unity8/shell/fixture_setup.py	2016-06-10 02:06:42 +0000
@@ -0,0 +1,90 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# Unity Autopilot Test Suite
+# Copyright (C) 2014 - 2016 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+"""Set up and clean up fixtures for the Unity acceptance tests."""
+
+import fixtures
+import os
+import subprocess
+import sysconfig
+
+from ubuntu_system_tests.helpers import unity8
+
+
+class FakeScopes(fixtures.Fixture):
+
+    def setUp(self):
+        super().setUp()
+        self.useFixture(
+            fixtures.EnvironmentVariable(
+                'QML2_IMPORT_PATH',
+                newvalue=self._get_fake_scopes_library_path()))
+
+    def _get_fake_scopes_library_path(self):
+        if unity8.running_installed_tests():
+            mock_path = 'qml/scopefakes/'
+        else:
+            mock_path = os.path.join(
+                '../lib/', sysconfig.get_config_var('MULTIARCH'),
+                'unity8/qml/scopefakes/')
+        lib_path = unity8.get_lib_path()
+        ld_library_path = os.path.abspath(os.path.join(lib_path, mock_path))
+
+        if not os.path.exists(ld_library_path):
+            raise RuntimeError(
+                'Expected library path does not exists: %s.' % (
+                    ld_library_path))
+        return ld_library_path
+
+
+class Tutorial(fixtures.Fixture):
+
+    def __init__(self, enable):
+        super().__init__()
+        self.enable = enable
+
+    def setUp(self):
+        super().setUp()
+        original_state = self._is_tutorial_enabled()
+        if self.enable != original_state:
+            self.addCleanup(self._set_tutorial, original_state)
+            self._set_tutorial(self.enable)
+
+    def _is_tutorial_enabled(self):
+        command = [
+            'dbus-send', '--system', '--print-reply',
+            '--dest=org.freedesktop.Accounts',
+            '/org/freedesktop/Accounts/User32011',
+            'org.freedesktop.DBus.Properties.Get',
+            'string:com.canonical.unity.AccountsService',
+            'string:demo-edges'
+        ]
+        output = subprocess.check_output(command, universal_newlines=True)
+        return True if output.count('true') else False
+
+    def _set_tutorial(self, value):
+        value_string = 'true' if value else 'false'
+        command = [
+            'dbus-send', '--system', '--print-reply',
+            '--dest=com.canonical.PropertyService',
+            '/com/canonical/PropertyService',
+            'com.canonical.PropertyService.SetProperty',
+            'string:edge', 'boolean:{}'.format(value_string)
+        ]
+        subprocess.check_output(command)

=== added file 'ubuntu_system_tests/helpers/unity8/shell/utils.py'
--- ubuntu_system_tests/helpers/unity8/shell/utils.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/unity8/shell/utils.py	2016-06-10 02:06:42 +0000
@@ -0,0 +1,82 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2016 Canonical
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+from functools import wraps
+from gi.repository import Notify
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def disable_qml_mocking(fn):
+    """Simple decorator that disables the QML mocks from being loaded."""
+    @wraps(fn)
+    def wrapper(*args, **kwargs):
+        tests_self = args[0]
+        tests_self._qml_mock_enabled = False
+        return fn(*args, **kwargs)
+    return wrapper
+
+
+def create_ephemeral_notification(
+    summary='',
+    body='',
+    icon=None,
+    hints=[],
+    urgency='NORMAL'
+):
+    """Create an ephemeral (non-interactive) notification
+
+    :param summary: Summary text for the notification
+    :param body: Body text to display in the notification
+    :param icon: Path string to the icon to use
+    :param hint_strings: List of tuples containing the 'name' and value
+        for setting the hint strings for the notification
+    :param urgency: Urgency string for the noticiation, either: 'LOW',
+        'NORMAL', 'CRITICAL'
+    """
+    Notify.init('Unity8')
+
+    logger.info(
+        "Creating ephemeral: summary(%s), body(%s), urgency(%r) "
+        "and Icon(%s)",
+        summary,
+        body,
+        urgency,
+        icon
+    )
+
+    notification = Notify.Notification.new(summary, body, icon)
+
+    for hint in hints:
+        key, value = hint
+        notification.set_hint_string(key, value)
+        logger.info("Adding hint to notification: (%s, %s)", key, value)
+    notification.set_urgency(_get_urgency(urgency))
+
+    return notification
+
+
+def _get_urgency(urgency):
+    """Translates urgency string to enum."""
+    _urgency_enums = {'LOW': Notify.Urgency.LOW,
+                      'NORMAL': Notify.Urgency.NORMAL,
+                      'CRITICAL': Notify.Urgency.CRITICAL}
+    return _urgency_enums.get(urgency.upper())

=== modified file 'ubuntu_system_tests/helpers/unity8/utils.py'
--- ubuntu_system_tests/helpers/unity8/utils.py	2016-06-02 11:07:46 +0000
+++ ubuntu_system_tests/helpers/unity8/utils.py	2016-06-10 02:06:42 +0000
@@ -18,14 +18,19 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase
-from unity8 import process_helpers
+import os
+import subprocess
+import sysconfig
 
 from autopilot import introspection
+from autopilot.introspection import get_proxy_object_for_existing_process
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals
+from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase
 
+from ubuntu_system_tests.helpers.autopilot import patched_select_single
 from ubuntu_system_tests.helpers import context
+from ubuntu_system_tests.helpers import processes
 from ubuntu_system_tests.helpers import timer
 from ubuntu_system_tests.helpers.unity8 import greeter
 
@@ -35,33 +40,211 @@
 APP_WIN_NAME = 'Scopes'
 
 
+class CannotAccessUnity(Exception):
+    pass
+
+
+class UnityException(Exception):
+    """Exception raised when there is an error with the Unity test helpers."""
+
+
+def restart_unity_with_testability(*args):
+    """Restarts (or starts) unity with testability enabled.
+
+    Passes *args arguments to the launched process.
+
+    """
+    args += ("QT_LOAD_TESTABILITY=1",)
+    return restart_unity(*args)
+
+
+def restart_unity(*args):
+    """Restarts (or starts) unity8 using the provided arguments.
+
+    Passes *args arguments to the launched process.
+
+    :raises subprocess.CalledProcessError: if unable to stop or start the
+      unity8 upstart job.
+
+    """
+    status = _get_unity_status()
+    if "start/" in status:
+        processes.stop_job('unity8')
+
+    pid = processes.start_job('unity8', *args)
+    return _get_unity_proxy_object(pid)
+
+
+def _get_unity_status():
+    try:
+        return processes.get_job_status('unity8')
+    except processes.JobError as error:
+        raise CannotAccessUnity(str(error))
+
+
+def get_unity_pid():
+    try:
+        return processes.get_job_pid('unity8')
+    except processes.JobError as error:
+        raise CannotAccessUnity(str(error))
+
+
+def _get_unity_proxy_object(pid):
+    return get_proxy_object_for_existing_process(
+        pid=pid,
+        emulator_base=UbuntuUIToolkitCustomProxyObjectBase
+    )
+
+
+def running_installed_tests():
+    binary_path = get_binary_path()
+    return binary_path.startswith('/usr')
+
+
+def get_lib_path():
+    """Return the library path to use in this test run."""
+    if running_installed_tests():
+        lib_path = os.path.join(
+            "/usr/lib/",
+            sysconfig.get_config_var('MULTIARCH'),
+            "unity8"
+        )
+    else:
+        binary_path = get_binary_path()
+        lib_path = os.path.dirname(binary_path)
+    return lib_path
+
+
+def get_default_extra_mock_libraries():
+    mocks_path = get_mocks_library_path()
+    return os.path.join(mocks_path, 'libusermetrics')
+
+
+def get_mocks_library_path():
+    if running_installed_tests():
+        mock_path = "qml/mocks/"
+    else:
+        mock_path = os.path.join(
+            "../lib/",
+            sysconfig.get_config_var('MULTIARCH'),
+            "unity8/qml/mocks/"
+        )
+    lib_path = get_lib_path()
+    ld_library_path = os.path.abspath(
+        os.path.join(
+            lib_path,
+            mock_path,
+        )
+    )
+
+    if not os.path.exists(ld_library_path):
+        raise RuntimeError(
+            "Expected library path does not exists: %s." % (ld_library_path)
+        )
+    return ld_library_path
+
+
+def get_binary_path(binary="unity8"):
+    """Return the path to the specified binary."""
+    binary_path = os.path.abspath(
+        os.path.join(
+            os.path.dirname(__file__),
+            "../../../builddir/install/bin/%s" % binary
+        )
+    )
+    if not os.path.exists(binary_path):
+        try:
+            binary_path = subprocess.check_output(
+                ['which', binary],
+                universal_newlines=True,
+            ).strip()
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError("Unable to locate %s binary: %r" % (binary, e))
+    return binary_path
+
+
+def get_data_dirs(data_dirs_mock_enabled=True):
+    """Prepend a mock data path to XDG_DATA_DIRS."""
+    data_dirs = _get_xdg_env_path()
+    if data_dirs_mock_enabled:
+        mock_data_path = _get_full_mock_data_path()
+        if os.path.exists(mock_data_path):
+            if data_dirs is not None:
+                data_dirs = '{0}:{1}'.format(mock_data_path, data_dirs)
+            else:
+                data_dirs = mock_data_path
+    return data_dirs
+
+
+def _get_full_mock_data_path():
+    if running_installed_tests():
+        data_path = "/usr/share/unity8/mocks/data"
+    else:
+        data_path = "../../mocks/data"
+    return os.path.abspath(
+        os.path.join(
+            os.path.dirname(__file__),
+            data_path
+        )
+    )
+
+
+def _get_xdg_env_path():
+    path = os.getenv("XDG_DATA_DIRS")
+    if path is None:
+        path = _get_xdg_upstart_env()
+    return path
+
+
+def _get_xdg_upstart_env():
+    try:
+        return subprocess.check_output([
+            "/sbin/initctl",
+            "get-env",
+            "--global",
+            "XDG_DATA_DIRS"
+        ], universal_newlines=True).rstrip()
+    except subprocess.CalledProcessError:
+        return None
+
+
+def get_grid_size():
+    grid_size = os.getenv('GRID_UNIT_PX')
+    if grid_size is None:
+        raise RuntimeError(
+            "Environment variable GRID_UNIT_PX has not been set."
+        )
+    return int(grid_size)
+
+
 def ensure_unity_stopped():
     if _is_unity8_running():
-        process_helpers.stop_job('unity8')
+        processes.stop_job('unity8')
     Eventually(Equals(False), timeout=300).match(_is_unity8_running)
 
 
 def ensure_unity_running_and_greeter_hidden():
     if not _is_unity8_running():
-        process_helpers.start_job('unity8')
+        processes.start_job('unity8')
         greeter.wait_for_greeter()
 
     greeter.hide_greeter_with_dbus()
 
 
 def _is_unity8_running():
-    return process_helpers.is_job_running('unity8')
+    return processes.is_job_running('unity8')
 
 
 def get_dash():
     """Return the Unity8 Dash autopilot custom proxy object."""
     from ubuntu_system_tests.helpers.unity8.dash import Dash
-    pid = process_helpers.get_job_pid('unity8-dash')
+    pid = processes.get_job_pid('unity8-dash')
     dash_proxy = introspection.get_proxy_object_for_existing_process(
         pid=pid,
         emulator_base=UbuntuUIToolkitCustomProxyObjectBase,
     )
-    return dash_proxy.select_single(Dash)
+    return patched_select_single(root=dash_proxy, class_object=Dash,
+                                 class_name='Dash')
 
 
 def launch_application_from_launcher(app_name):
@@ -104,4 +287,4 @@
     app_names = stage.get_app_window_names()
     for app_name in app_names:
         if not app_name == APP_WIN_NAME:
-            close_app(app_name)
+            pass

=== modified file 'ubuntu_system_tests/selftests/test_tests_to_run.py'
--- ubuntu_system_tests/selftests/test_tests_to_run.py	2016-06-06 09:53:20 +0000
+++ ubuntu_system_tests/selftests/test_tests_to_run.py	2016-06-10 02:06:42 +0000
@@ -133,7 +133,7 @@
     'ubuntu_system_tests.helpers.unity8.utils.greeter',
     new_callable=FakeGreeterHelpers)
 @mock.patch(
-    'ubuntu_system_tests.helpers.unity8.utils.process_helpers',
+    'ubuntu_system_tests.helpers.unity8.utils.processes',
     new_callable=FakeProcessHelpers)
 class EnsureUnityInRequiredStateTestCase(unittest.TestCase):
 

=== modified file 'ubuntu_system_tests/tests/base.py'
--- ubuntu_system_tests/tests/base.py	2016-05-16 17:05:42 +0000
+++ ubuntu_system_tests/tests/base.py	2016-06-10 02:06:42 +0000
@@ -26,30 +26,28 @@
 from tempfile import mkstemp
 from threading import Event
 
+import autopilot
 from autopilot import (
     exceptions,
     input,
-    logging as autopilot_logging,
     testcase
 )
 from autopilot._fixtures import OSKAlwaysEnabled
 from autopilot.introspection import _object_registry as object_registry
 from ubuntuuitoolkit import fixture_setup
-from unity8 import process_helpers
 
-from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers.autopilot import get_job_proxy_object
 from ubuntu_system_tests.helpers import context
 from ubuntu_system_tests.helpers import images
 from ubuntu_system_tests.helpers import mir
 from ubuntu_system_tests.helpers.notifications import sim_pin_observer
 from ubuntu_system_tests.helpers import ofono
-from ubuntu_system_tests.helpers.processes import wait_for_job_spawned
+from ubuntu_system_tests.helpers import processes
 from ubuntu_system_tests.helpers import screen
 from ubuntu_system_tests.helpers.timeout import timeout
 from ubuntu_system_tests.helpers import unity8
-from ubuntu_system_tests.helpers.unity8 import get_dash
-from ubuntu_system_tests.helpers.unity8 import sensors
-from ubuntu_system_tests.helpers.unity8.shell import Unity8  # NOQA
+from ubuntu_system_tests.helpers.unity8 import get_dash, sensors
+from ubuntu_system_tests.helpers.unity8.shell._cpo import Unity8  # NOQA
 from ubuntu_system_tests.helpers import wait_until
 from ubuntu_system_tests.helpers import webapp
 
@@ -84,9 +82,9 @@
         context.shared.retry_time = 10000
 
     def _get_unity8_proxy_object(self):
-        return autopilot.get_job_proxy_object('unity8')
+        return get_job_proxy_object('unity8')
 
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def launch_unity(self, fake_sensors=False, dismiss_sim_unlock=True):
         """Launch Unity8 with testability enabled.
 
@@ -149,11 +147,11 @@
         args = ['QT_LOAD_TESTABILITY=1']
         if no_wait:
             args.append('--no-wait')
-        process_helpers.start_job(unity8.PROC_NAME, *args)
+        processes.start_job(unity8.PROC_NAME, *args)
         if no_wait:
             # just wait for job to be spawned rather than fully running
-            wait_for_job_spawned(unity8.PROC_NAME)
-        context.shared.unity_pid = process_helpers._get_unity_pid()
+            processes.wait_for_job_spawned(unity8.PROC_NAME)
+        context.shared.unity_pid = unity8.get_unity_pid()
 
     def _enable_osk_for_uitk(self):
         """Enable use of the OSK with uitk helpers."""
@@ -216,7 +214,7 @@
                isinstance(exception, DBusException) or
                isinstance(exception, TimeoutError) or
                isinstance(exception, exceptions.BackendException)))
-    @autopilot_logging.log_action(logger.info)
+    @autopilot.logging.log_action(logger.info)
     def restart_unity(self, fake_sensors=False):
         """
         Restart and unlock unity8

=== modified file 'ubuntu_system_tests/tests/test_tutorial.py'
--- ubuntu_system_tests/tests/test_tutorial.py	2015-05-21 18:15:40 +0000
+++ ubuntu_system_tests/tests/test_tutorial.py	2016-06-10 02:06:42 +0000
@@ -21,12 +21,8 @@
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals
 
-from unity8.shell import fixture_setup
-
-# unused import to load the tutorial custom proxy objects.
-from unity8.shell.emulators import tutorial  # NOQA
-
 from ubuntu_system_tests.tests import base
+from ubuntu_system_tests.helpers.unity8.shell import fixture_setup
 
 
 class TutorialTestCase(base.BaseUbuntuSystemTestCase):

=== modified file 'ubuntu_system_tests/tests/test_with_dialer.py'
--- ubuntu_system_tests/tests/test_with_dialer.py	2016-02-03 22:25:18 +0000
+++ ubuntu_system_tests/tests/test_with_dialer.py	2016-06-10 02:06:42 +0000
@@ -20,9 +20,9 @@
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals
 
-from unity8 import process_helpers as unity_helpers
-
 from ubuntu_system_tests.helpers import dialer_app
+from ubuntu_system_tests.helpers.unity8 import greeter
+
 from ubuntu_system_tests.tests import base
 
 
@@ -44,8 +44,8 @@
         self.assertThat(self.dialer_app.contacts_page.active,
                         Eventually(Equals(True)))
 
-        unity_helpers.lock_unity()
-        unity_helpers.unlock_unity()
+        greeter.lock_unity()
+        greeter.unlock_unity()
 
         self.assertThat(self.dialer_app.contacts_page.active,
                         Eventually(Equals(True)))