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

[Sergio Cazzolato]

Refactoring base test class and autopilot helpers. The idea is to reduce the tests/base and autopilot.py files length.

First step is implemented. For that different methods were move mainly to autopilot helper and this helper was split in different files.

The second part which is pushed and within it all the methods to launch and close apps are moved to the helpers.

To validate this: run 1 test of each test suite and ubuntu_system_tests.tests.app_startup.test_application_startup

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:303
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1314/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1040/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1043/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1040/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1314/rebuild

review: Needs Fixing (continuous-integration)

[Richard Huddie (rhuddie)]

Changes seem reasonable, I've made some minor comments below.

There will be a lot of conflicts with the app-name-cpo-dbus-validation branch, so would make sense to get that branch landed first.

I'll do some further testing with this branch to make sure its working fine.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:305
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1317/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1043/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1046/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1043/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1317/rebuild

review: Needs Fixing (continuous-integration)

[Sergio Cazzolato (sergio-j-cazzolato)]

Answers

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:306
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1318/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1044/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1047/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1044/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1318/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:314
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1320/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1046/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1049/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1046/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1320/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:315
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1321/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1047/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1050/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1047/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1321/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:316
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1322/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1048/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1051/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1048/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1322/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:317
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1323/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1049/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1052/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1049/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1323/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:318
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1324/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1050/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1053/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1050/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1324/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:319
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1325/
Executed test runs:
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1051
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1054
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1051

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1325/rebuild

review: Approve (continuous-integration)

[Richard Huddie (rhuddie)]

This diff seems to be showing the app-startup changes too? I see that branch is marked as pre-requisite, so it shouldn't be including those changes. Is this branch up to date with that one?

review: Needs Information

[Sergio Cazzolato (sergio-j-cazzolato)]

Yes, this branch is up to date with the other one, I created the dependency to avoid rework and because I am using the startup tests to validate the changes done as part of the refactor.

[Richard Huddie (rhuddie)]

There are currently conflicts with trunk. Also, given that the app-startup branch has now landed we can remove that as pre-requisite. Hopefully that will sort out the diff.

[Sergio Cazzolato (sergio-j-cazzolato)]

Pre-requisite removed, now gonna see why there are conflicts. I'll try to push the update today

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

320. By Sergio Cazzolato on 2016-02-08

Changes based on MP comments

321. By Sergio Cazzolato on 2016-02-08

Merge with trunk

[Sergio Cazzolato (sergio-j-cazzolato)]

Conflicts resolved. I forgot to push the last merge that I did. Try now.

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

322. By Sergio Cazzolato on 2016-02-08

Fixing import error

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:321
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1334/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1060/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1063/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1060/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1334/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:322
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1335/
Executed test runs:
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1061/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1064/console
    FAILURE: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1061/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1335/rebuild

review: Needs Fixing (continuous-integration)

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

323. By Sergio Cazzolato on 2016-02-08

Fixing flake errors

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:323
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1336/
Executed test runs:
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1062
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1065
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1062

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1336/rebuild

review: Approve (continuous-integration)

[Richard Huddie (rhuddie)]

This is looking good. I have not run through any of the tests yet, but will do so. With such a big change it will affect all tests.

I've just made some minor comments below. It would be good to get this landed as it gets difficult to maintain such a large MP!

review: Needs Fixing

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

324. By Sergio Cazzolato on 2016-02-10

Minor fixes based on MP comments

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:324
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1340/
Executed test runs:
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1066
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1069
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1066

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1340/rebuild

review: Approve (continuous-integration)

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

325. By Sergio Cazzolato on 2016-02-10

Adding removed tests and moving problematic dependency

[Sergio Cazzolato (sergio-j-cazzolato)]

Answers and changes done

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:325
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1341/
Executed test runs:
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1067
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1070
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1067

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1341/rebuild

review: Approve (continuous-integration)

[Richard Huddie (rhuddie)]

test failure:

Traceback (most recent call last):
  File "/tmp/adt-run.BxCKoY/build.zbE/real-tree/ubuntu_system_tests/tests/webapps/test_ebay.py", line 34, in setUp
    self.web_app = self.launch_ebay_webapp()
AttributeError: 'EbayTestCase' object has no attribute 'launch_ebay_webapp'

review: Needs Fixing

[Richard Huddie (rhuddie)]

2 more failures:

11:06:49.854 ERROR testresult:44 - traceback: {{{
Traceback (most recent call last):
  File "/tmp/adt-run.8bDTba/build.SDF/real-tree/ubuntu_system_tests/tests/indicators/test_indicator_network.py", line 182, in test_wifi_settings_item_open_correct_page
    settings_app = self.get_system_settings_proxy()
AttributeError: 'NetworkIndicatorTestCase' object has no attribute 'get_system_settings_proxy'
}}}

11:07:40.034 ERROR testresult:44 - traceback: {{{
Traceback (most recent call last):
  File "/tmp/adt-run.8bDTba/build.SDF/real-tree/ubuntu_system_tests/tests/indicators/test_indicator_network.py", line 171, in test_cellular_settings_item_open_correct_page
    settings_app = self.get_system_settings_proxy()
AttributeError: 'NetworkIndicatorTestCase' object has no attribute 'get_system_settings_proxy'
}}}

review: Needs Fixing

[Richard Huddie (rhuddie)]

Confirm that I've run a multitude of tests on this branch, with the above 3 failures being the only ones related to this change. So once these are fixed, it is ready for approval.

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

326. By Sergio Cazzolato on 2016-02-10

Fixing broken links

[Sergio Cazzolato (sergio-j-cazzolato)]

Fixes pushed

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:326
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1343/
Executed test runs:
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-amd64-ci/1069
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-armhf-ci/1072
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-wily-i386-ci/1069

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/ubuntu-sanity-tests-ci/1343/rebuild

review: Approve (continuous-integration)

[Richard Huddie (rhuddie)]

Confirm broken tests now working, so approving. Great job!

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'ubuntu_system_tests/helpers/__init__.py'
--- ubuntu_system_tests/helpers/__init__.py	2015-10-05 16:52:13 +0000
+++ ubuntu_system_tests/helpers/__init__.py	2016-02-10 11:57:12 +0000
@@ -68,3 +68,11 @@
         return validator(result)
     else:
         return bool(result)
+
+
+class AttrDict(dict):
+    """ Class used to access to the dict keys as parameters """
+
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self

=== modified file 'ubuntu_system_tests/helpers/addressbook/__init__.py'
--- ubuntu_system_tests/helpers/addressbook/__init__.py	2015-09-07 11:10:31 +0000
+++ ubuntu_system_tests/helpers/addressbook/__init__.py	2016-02-10 11:57:12 +0000
@@ -20,5 +20,59 @@
 
 from collections import namedtuple
 
+from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import (
+    close_app, launch_application_from_launcher
+)
+
+APP = 'address-book-app'
+APP_NAME = 'Contacts'
+APP_WIN_ID = 'address-book-app'
+
+
 Contact = namedtuple('Contact', ['name', 'number', 'expected_reply'])
 Contact.__new__.__defaults__ = (None, None, None)
+
+
+def launch_address_book():
+    """
+    Launch the address book app from apps scope and return proxy object.
+
+    :return: Proxy object for address book application.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    return get_address_book_app_proxy()
+
+
+def close_address_book():
+    """ Close the address book app using task switcher """
+    if is_address_book_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_address_book_app_running():
+    """ Indicate if the address book app is currently running """
+    return processes.is_process_running(APP)
+
+
+def launch_address_book_from_launcher():
+    """Drag out the launcher and tap the address book icon to start it."""
+    launch_application_from_launcher(APP_WIN_ID)
+    return get_address_book_app_proxy()
+
+
+def get_address_book_app_proxy():
+    """
+    Return address book app proxy object from existing process.
+
+    :return: Proxy object for address book application.
+
+    """
+    from ubuntu_system_tests.helpers.addressbook import _cpo  # NOQA
+    proxy = autopilot.get_proxy_object_for_existing_app(APP)
+    return proxy.main_window

=== added directory 'ubuntu_system_tests/helpers/autopilot'
=== renamed file 'ubuntu_system_tests/helpers/autopilot.py' => 'ubuntu_system_tests/helpers/autopilot/__init__.py'
--- ubuntu_system_tests/helpers/autopilot.py	2016-02-03 18:08:14 +0000
+++ ubuntu_system_tests/helpers/autopilot/__init__.py	2016-02-10 11:57:12 +0000
@@ -18,20 +18,16 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-import configparser
-import os
-import subprocess
-import systemimage.config as sys_info
 import sys
-import time
+from contextlib import contextmanager
 
+import ubuntuuitoolkit
 from autopilot import introspection
-from autopilot.display import is_point_on_any_screen
 from autopilot.exceptions import StateNotFoundError
-from autopilot.platform import model
-from contextlib import contextmanager
+
+from ubuntu_system_tests.helpers import context
+from ubuntu_system_tests.helpers import processes
 from ubuntu_system_tests.helpers import wait_until
-from ubuntu_system_tests.helpers import click
 
 CO_ORD_MAX = (sys.maxsize, sys.maxsize)
 
@@ -46,31 +42,14 @@
         proxy._poll_time = original_timeout
 
 
-def get_proxy_object_for_existing_process(
-        process_name, base_custom_proxy_object):
-    """Return the proxy object for a currently running process."""
-    return introspection.get_proxy_object_for_existing_process(
-        pid=_get_pid(process_name),
-        emulator_base=base_custom_proxy_object
-    )
-
-
-# Pulled from the UX tests
-def _get_pid(process_name):
-    """Returns pid for currently running browser process."""
-    for i in range(10):
-        try:
-            return int(
-                subprocess.check_output(
-                    ['pidof', process_name]).strip()
-            )
-        except subprocess.CalledProcessError:
-            time.sleep(1)
+def _get_pid(pname):
+    """ Wait until the process pname is running and retrieve its pid. Raise
+    Runtime exception when the process is not started after 10 seconds
+    """
+    if wait_until(processes.is_process_running, pname):
+        return processes.get_process_id(pname)
     else:
-        raise RuntimeError(
-            'Could not find autopilot interface for {} after 10 '
-            'seconds'.format(process_name)
-        )
+        raise RuntimeError('Could not find process: {} '.format(pname))
 
 
 def validate_dbus_object(path, state, root_name, class_name, **kwargs):
@@ -92,98 +71,6 @@
     return False
 
 
-def order_by_y_coord(object_list, include_off_screen=False):
-    """
-    Return an ordered list of objects ordered by y co-ordinate first
-    and then x co-ordinate second if y co-ordinates match.
-
-    :param object_list: List of objects containing globalRect property.
-    :param include_off_screen: Whether to include objects that are not within
-                               the bounds of any screen.
-    :return: List of sorted objects.
-
-    """
-    return _order_by_key(object_list, _get_y_and_x, include_off_screen)
-
-
-def order_by_x_coord(object_list, include_off_screen=False):
-    """
-    Return an ordered list of objects ordered by x co-ordinate first
-    and then y co-ordinate second if x co-ordinates match.
-
-    :param object_list: List of objects containing globalRect property.
-    :param include_off_screen: Whether to include objects that are not within
-                               the bounds of any screen.
-    :return: List of sorted objects.
-
-    """
-    return _order_by_key(object_list, _get_x_and_y, include_off_screen)
-
-
-def _order_by_key(object_list, sort_key, include_off_screen):
-    """
-    Return an ordered list of objects ordered by key.
-
-    :param object_list: List of objects containing globalRect property.
-    :param sort_key: Sorting key to use.
-    :param include_off_screen: Whether to include objects that are not within
-                               the bounds of any screen.
-    :return: List of sorted objects.
-
-    """
-    objects = []
-    for obj in object_list:
-        try:
-            # If obj is no longer valid this can cause excpetion
-            point = obj.globalRect.x, obj.globalRect.y
-            if include_off_screen:
-                objects.append(obj)
-            elif is_point_on_any_screen(point):
-                objects.append(obj)
-        except StateNotFoundError:
-            pass
-    return sorted(objects, key=sort_key)
-
-
-def _get_y_and_x(item):
-    """
-    Return y and x co-ordinates for specified object.
-
-    :param item: Item to check
-    :return: (y, x) co-ordinates
-    """
-    try:
-        # If item is no longer valid this can cause excpetion
-        co_ords = item.globalRect.y, item.globalRect.x
-    except StateNotFoundError:
-        # Trying to sort an object that no longer exists
-        # return a dummy key value so this item is sorted last
-        co_ords = CO_ORD_MAX
-    return co_ords
-
-
-def _get_x_and_y(item):
-    """
-    Return x and y co-ordinates for specified object.
-
-    :param item: Item to check
-    :return: (x, y) co-ordinates
-    """
-    try:
-        # If item is no longer valid this can cause excpetion
-        co_ords = item.globalRect.x, item.globalRect.y
-    except StateNotFoundError:
-        # Trying to sort an object that no longer exists
-        # return a dummy key value so this item is sorted last
-        co_ords = CO_ORD_MAX
-    return co_ords
-
-
-def get_object_path(item):
-    """Return the object path of a specified item."""
-    return item._path.decode('utf-8')
-
-
 def get_path_root(object_path):
     """Return the name of the root node of specified path."""
     is_string = isinstance(object_path, str)
@@ -195,128 +82,6 @@
     return root
 
 
-def _get_parent_by_type(item, required_type, **kwargs):
-    """Return a parent item of the required type.
-    :param item: The child item to start searching from.
-    :param required_type: String name of parent object type required.
-    :param kwargs: This is used for logging purposes only.
-    :return: Parent object matching required type.
-    :raises: StateNotFoundError if no matching object type can be found.
-    """
-    parent = item.get_parent()
-    path = get_object_path(parent).split('/')
-    try:
-        index = path.index(required_type)
-    except ValueError:
-        raise StateNotFoundError(
-            '{}, and properties: {}'.format(required_type, kwargs))
-    for count in range(1, len(path) - index):
-        parent = parent.get_parent()
-    return parent
-
-
-def validate_properties(item, **kwargs):
-    """Return True if item properties match specified keyword properties."""
-    props = item.get_properties()
-    for key in kwargs.keys():
-        if props[key] != kwargs[key]:
-            return False
-    return True
-
-
-def get_parent(item, required_type, **kwargs):
-    """Return a parent object of specified type and properties.
-    :param item: The child item to start searching from.
-    :param required_type: String name of parent object type required.
-    :param kwargs: Any properties to match on the parent object.
-    :return: Parent object matching required type and properties.
-    :raises: StateNotFoundError if no matching object can be found.
-    """
-    parent = item
-    while True:
-        parent = _get_parent_by_type(parent, required_type, **kwargs)
-        if validate_properties(parent, **kwargs):
-            return parent
-        parent = parent.get_parent()
-
-
-"""
-
-The following methods are for performing platform feature detection.
-
-These methods may in future be moved into the autopilot.platform module.
-Whilst the API will remain the same, the implementation of the methods may
-change depening on the specific requirements of the supported devices.
-
-"""
-
-
-def get_device_name():
-    """
-    Return the device's model name.
-
-    If this is run on desktop, it will return 'desktop'.
-
-    """
-    return sys_info.config.device or model().lower()
-
-
-def get_channel_name():
-    """ Return the build channel name. In case there is not channel defined, it
-    return the default value
-    """
-    default = 'ubuntu-touch/rc-proposed/bq-aquaris.en'
-    return _get_image_info('service', 'channel', default)
-
-
-def get_build_number():
-    """ Return the build number. In case there is not channel defined, it
-    return the default value
-    """
-    return _get_image_info('service', 'build_number', '0')
-
-
-def _get_image_info(category, item, default):
-    """ Return the image item requested. In case it is not defined, it return
-    the default value
-    """
-    file = '/etc/system-image/channel.ini'
-    if not os.path.isfile(file):
-        return default
-    parser = configparser.ConfigParser()
-    parser.read(file)
-    return parser[category][item]
-
-
-def is_agps_supported():
-    """Return True if a agps is supported, False if it is not."""
-    agps_supported = True
-    try:
-        subprocess.check_call(
-            ['dpkg-query --status ubuntu-location-provider-here'],
-            shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-    except subprocess.CalledProcessError:
-        agps_supported = False
-    return agps_supported
-
-
-def is_camera_supported():
-    """Return True if a camera is supported, False if it is not."""
-    return click.is_package_installed('com.ubuntu.camera')
-
-
-def is_wifi_supported():
-    """Return True if wifi is supported, False if it is not."""
-    wifi_supported = True
-    try:
-        subprocess.check_call(
-            ['nmcli -t -f type device | grep wifi'],
-            shell=True, stdout=subprocess.DEVNULL)
-    except subprocess.CalledProcessError:
-        wifi_supported = False
-    return wifi_supported
-
-
 def is_element(predicate, *args, **kwargs):
     """
     Evaluate the predicate with the args and indicate if it raises
@@ -435,28 +200,67 @@
     return _patched_select(True, root, class_object, class_name, **kwargs)
 
 
-def is_not_moving(elem, move_time=0.5):
-    """ Indicate if the element has not changed its position after a period
-    based on its globalRect coordinates
-    :param elem: autopilot element to check
-    :param move_time: time between the coordinates are retrieved
-    :return: True when the x and y coordinates are equal, False otherwise
-    """
-    x1, y1, h1, w1 = elem.globalRect
-    time.sleep(move_time)
-    x2, y2, h2, w2 = elem.globalRect
-
-    return x1 == x2 and y1 == y2
-
-
-def wait_until_is_not_moving(elem, move_time=0.5, timeout=10):
-    """ Wait until the autopilot element is not moving based on its globalRect
-    coordinates
-    :param elem: autopilot element to check
-    :param move_time: time in seconds between the coordinates are retrieved
-    :param timeout: total time to wait until the element is not moving
-    :return: True when the element is not moving before the timeout is reached,
-    otherwise return False
-    """
-    return wait_until(is_not_moving, elem, move_time, timeout=timeout,
-                      period=0)
+def get_proxy_object(pid):
+    return introspection.get_proxy_object_for_existing_process(
+        pid=pid,
+        emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase,
+    )
+
+
+def get_proxy_object_for_existing_process(
+        process_name, base_custom_proxy_object):
+    """Return the proxy object for a currently running process."""
+    return introspection.get_proxy_object_for_existing_process(
+        pid=_get_pid(process_name),
+        emulator_base=base_custom_proxy_object
+    )
+
+
+def get_proxy_object_for_existing_app(
+        process_name, cleanup_process=None,
+        base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
+    """
+    Return proxy object from existing application process.
+
+    Add cleanup action to close the application using cleanup_process
+    parameter. If cleanup_process is None then process_name is used as the
+    cleanup target using ensure_application_closed().
+
+    :param pname: Name of required application process.
+    :param cleanup_process: Name of process to clean up.
+    :param base: custom emulator base for proxy object
+    :return: Proxy object for the desired application.
+
+    """
+    if not cleanup_process:
+        cleanup_process = process_name
+    proxy = get_proxy_object_for_existing_process(process_name, base)
+    context.shared.add_cleanup(processes.ensure_application_closed,
+                               cleanup_process)
+    return proxy
+
+
+def get_job_proxy_object(pname):
+    pid = _get_pid(pname)
+    return get_proxy_object(pid)
+
+
+def get_proxy_object_for_existing_qmlscene_process(qmlfile):
+    """
+    Return proxy object from existing qmlscene process.
+
+    Add cleanup action to close the application using cleanup_process
+    parameter. If cleanup_process is None then process_id is used as the
+    cleanup target using processes.stop_qmlscene_process().
+
+    :param qmlfile: Thje name of the QML file for the required process
+    :return: Proxy object for the desired qmlscene process
+
+    """
+    process_id = processes.get_qmlscene_process_id(qmlfile)
+    proxy = introspection.get_proxy_object_for_existing_process(
+        pid=process_id,
+        emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase
+    )
+    context.shared.add_cleanup(processes.stop_qmlscene_process, qmlfile)
+    return proxy

=== added file 'ubuntu_system_tests/helpers/autopilot/list.py'
--- ubuntu_system_tests/helpers/autopilot/list.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/autopilot/list.py	2016-02-10 11:57:12 +0000
@@ -0,0 +1,78 @@
+# -*- 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.display import is_point_on_any_screen
+from autopilot.exceptions import StateNotFoundError
+
+from ubuntu_system_tests.helpers.autopilot.object import (
+    _get_y_and_x, _get_x_and_y)
+
+
+def order_by_x_coord(object_list, include_off_screen=False):
+    """
+    Return an ordered list of objects ordered by x co-ordinate first
+    and then y co-ordinate second if x co-ordinates match.
+
+    :param object_list: List of objects containing globalRect property.
+    :param include_off_screen: Whether to include objects that are not within
+                               the bounds of any screen.
+    :return: List of sorted objects.
+
+    """
+    return _order_by_key(object_list, _get_x_and_y, include_off_screen)
+
+
+def _order_by_key(object_list, sort_key, include_off_screen):
+    """
+    Return an ordered list of objects ordered by key.
+
+    :param object_list: List of objects containing globalRect property.
+    :param sort_key: Sorting key to use.
+    :param include_off_screen: Whether to include objects that are not within
+                               the bounds of any screen.
+    :return: List of sorted objects.
+
+    """
+    objects = []
+    for obj in object_list:
+        try:
+            # If obj is no longer valid this can cause excpetion
+            point = obj.globalRect.x, obj.globalRect.y
+            if include_off_screen:
+                objects.append(obj)
+            elif is_point_on_any_screen(point):
+                objects.append(obj)
+        except StateNotFoundError:
+            pass
+    return sorted(objects, key=sort_key)
+
+
+def order_by_y_coord(object_list, include_off_screen=False):
+    """
+    Return an ordered list of objects ordered by y co-ordinate first
+    and then x co-ordinate second if y co-ordinates match.
+
+    :param object_list: List of objects containing globalRect property.
+    :param include_off_screen: Whether to include objects that are not within
+                               the bounds of any screen.
+    :return: List of sorted objects.
+
+    """
+    return _order_by_key(object_list, _get_y_and_x, include_off_screen)

=== added file 'ubuntu_system_tests/helpers/autopilot/object.py'
--- ubuntu_system_tests/helpers/autopilot/object.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/autopilot/object.py	2016-02-10 11:57:12 +0000
@@ -0,0 +1,137 @@
+# -*- 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  received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import time
+
+from autopilot.exceptions import StateNotFoundError
+
+from ubuntu_system_tests.helpers import wait_until
+from ubuntu_system_tests.helpers.autopilot import CO_ORD_MAX
+
+
+def _get_y_and_x(item):
+    """
+    Return y and x co-ordinates for specified object.
+
+    :param item: Item to check
+    :return: (y, x) co-ordinates
+    """
+    try:
+        # If item is no longer valid this can cause excpetion
+        co_ords = item.globalRect.y, item.globalRect.x
+    except StateNotFoundError:
+        # Trying to sort an object that no longer exists
+        # return a dummy key value so this item is sorted last
+        co_ords = CO_ORD_MAX
+    return co_ords
+
+
+def _get_x_and_y(item):
+    """
+    Return x and y co-ordinates for specified object.
+
+    :param item: Item to check
+    :return: (x, y) co-ordinates
+    """
+    try:
+        # If item is no longer valid this can cause excpetion
+        co_ords = item.globalRect.x, item.globalRect.y
+    except StateNotFoundError:
+        # Trying to sort an object that no longer exists
+        # return a dummy key value so this item is sorted last
+        co_ords = CO_ORD_MAX
+    return co_ords
+
+
+def get_object_path(item):
+    """Return the object path of a specified item."""
+    return item._path.decode('utf-8')
+
+
+def wait_until_is_not_moving(elem, move_time=0.5, timeout=10):
+    """ Wait until the autopilot element is not moving based on its globalRect
+    coordinates
+    :param elem: autopilot element to check
+    :param move_time: time in seconds between the coordinates are retrieved
+    :param timeout: total time to wait until the element is not moving
+    :return: True when the element is not moving before the timeout is reached,
+    otherwise return False
+    """
+    return wait_until(is_not_moving, elem, move_time, timeout=timeout,
+                      period=0)
+
+
+def is_not_moving(elem, move_time=0.5):
+    """ Indicate if the element has not changed its position after a period
+    based on its globalRect coordinates
+    :param elem: autopilot element to check
+    :param move_time: time between the coordinates are retrieved
+    :return: True when the x and y coordinates are equal, False otherwise
+    """
+    x1, y1, h1, w1 = elem.globalRect
+    time.sleep(move_time)
+    x2, y2, h2, w2 = elem.globalRect
+
+    return x1 == x2 and y1 == y2
+
+
+def _get_parent_by_type(item, required_type, **kwargs):
+    """Return a parent item of the required type.
+    :param item: The child item to start searching from.
+    :param required_type: String name of parent object type required.
+    :param kwargs: This is used for logging purposes only.
+    :return: Parent object matching required type.
+    :raises: StateNotFoundError if no matching object type can be found.
+    """
+    parent = item.get_parent()
+    path = get_object_path(parent).split('/')
+    try:
+        index = path.index(required_type)
+    except ValueError:
+        raise StateNotFoundError(
+            '{}, and properties: {}'.format(required_type, kwargs))
+    for count in range(1, len(path) - index):
+        parent = parent.get_parent()
+    return parent
+
+
+def validate_properties(item, **kwargs):
+    """Return True if item properties match specified keyword properties."""
+    props = item.get_properties()
+    for key in kwargs.keys():
+        if props[key] != kwargs[key]:
+            return False
+    return True
+
+
+def get_parent(item, required_type, **kwargs):
+    """Return a parent object of specified type and properties.
+    :param item: The child item to start searching from.
+    :param required_type: String name of parent object type required.
+    :param kwargs: Any properties to match on the parent object.
+    :return: Parent object matching required type and properties.
+    :raises: StateNotFoundError if no matching object can be found.
+    """
+    parent = item
+    while True:
+        parent = _get_parent_by_type(parent, required_type, **kwargs)
+        if validate_properties(parent, **kwargs):
+            return parent
+        parent = parent.get_parent()

=== added file 'ubuntu_system_tests/helpers/autopilot/platform.py'
--- ubuntu_system_tests/helpers/autopilot/platform.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/autopilot/platform.py	2016-02-10 11:57:12 +0000
@@ -0,0 +1,94 @@
+# -*- 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 configparser
+import os
+import subprocess
+
+from autopilot.platform import model
+from systemimage import config as sys_info
+
+from ubuntu_system_tests.helpers import click
+
+
+def get_device_name():
+    """
+    Return the device's model name.
+
+    If this is run on desktop, it will return 'desktop'.
+
+    """
+    return sys_info.config.device or model().lower()
+
+
+def get_channel_name():
+    """ Return the build channel name. In case there is not channel defined, it
+    return the default value
+    """
+    default = 'ubuntu-touch/rc-proposed/bq-aquaris.en'
+    return _get_image_info('service', 'channel', default)
+
+
+def get_build_number():
+    """ Return the build number. In case there is not channel defined, it
+    return the default value
+    """
+    return _get_image_info('service', 'build_number', '0')
+
+
+def _get_image_info(category, item, default):
+    """ Return the image item requested. In case it is not defined, it return
+    the default value
+    """
+    file = '/etc/system-image/channel.ini'
+    if not os.path.isfile(file):
+        return default
+    parser = configparser.ConfigParser()
+    parser.read(file)
+    return parser[category][item]
+
+
+def is_agps_supported():
+    """Return True if a agps is supported, False if it is not."""
+    agps_supported = True
+    try:
+        subprocess.check_call(
+            ['dpkg-query --status ubuntu-location-provider-here'],
+            shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except subprocess.CalledProcessError:
+        agps_supported = False
+    return agps_supported
+
+
+def is_camera_supported():
+    """Return True if a camera is supported, False if it is not."""
+    return click.is_package_installed('com.ubuntu.camera')
+
+
+def is_wifi_supported():
+    """Return True if wifi is supported, False if it is not."""
+    wifi_supported = True
+    try:
+        subprocess.check_call(
+            ['nmcli -t -f type device | grep wifi'],
+            shell=True, stdout=subprocess.DEVNULL)
+    except subprocess.CalledProcessError:
+        wifi_supported = False
+    return wifi_supported

=== modified file 'ubuntu_system_tests/helpers/calculator/__init__.py'
--- ubuntu_system_tests/helpers/calculator/__init__.py	2015-10-30 11:52:23 +0000
+++ ubuntu_system_tests/helpers/calculator/__init__.py	2016-02-10 11:57:12 +0000
@@ -2,7 +2,7 @@
 
 #
 # Ubuntu System Tests
-# Copyright (C) 2015 Canonical
+# 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
@@ -17,3 +17,43 @@
 # 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 ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import close_app
+from ubuntu_system_tests.helpers import wait_until
+
+
+APP_NAME = 'Calculator'
+APP_WIN_ID = 'com.ubuntu.calculator_calculator'
+QML = 'ubuntu-calculator-app'
+
+
+def launch_calculator_app():
+    """
+    Launch calculator app from apps scope and return its proxy object.
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    wait_until(is_calculator_app_running, period=0.5)
+    return get_calculator_app_proxy()
+
+
+def close_calculator_app():
+    """ Close the calculator app using task switcher """
+    if is_calculator_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_calculator_app_running():
+    """ Indicate if the calculator app is currently running """
+    return processes.is_qmlscene_running_with_qmlfile(QML)
+
+
+def get_calculator_app_proxy():
+    """Return the proxy object of the calculator app."""
+    from ubuntu_system_tests.helpers.calculator import _cpo  # NOQA
+    proxy = autopilot.get_proxy_object_for_existing_qmlscene_process(QML)
+    return proxy.main_view

=== modified file 'ubuntu_system_tests/helpers/camera/__init__.py'
--- ubuntu_system_tests/helpers/camera/__init__.py	2015-10-26 18:39:02 +0000
+++ ubuntu_system_tests/helpers/camera/__init__.py	2016-02-10 11:57:12 +0000
@@ -21,9 +21,23 @@
 import os
 import warlock
 
+from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import click
 from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import (
+    close_app, launch_application_from_launcher
+)
 from ubuntu_system_tests.helpers import wait_until
 
+APP = 'camera-app'
+APP_NAME = 'Camera'
+APP_WIN_ID = 'com.ubuntu.camera_camera'
+APP_CLICK = 'com.ubuntu.camera'
+
 config_schema = {
     'name': 'CameraConfig',
     'properties': {
@@ -45,6 +59,50 @@
 }
 
 
+def launch_camera_app():
+    """
+    Launch the camera app from dash and return proxy object.
+
+    :return: Proxy object for camera application.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    return get_camera_app_proxy()
+
+
+def close_camera_app():
+    """ Close the camera app using task switcher """
+    if is_camera_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_camera_app_running():
+    """ Indicate if the camera app is currently running """
+    return processes.is_process_running(APP)
+
+
+def launch_camera_app_from_launcher():
+    """Drag out the launcher and tap the camera icon to start it."""
+    launch_application_from_launcher(APP_WIN_ID)
+    return get_camera_app_proxy()
+
+
+def get_camera_app_proxy():
+    """
+    Return camera app proxy object from existing process and add
+    cleanup actions to close the application.
+
+    :return: Proxy object for camera application.
+
+    """
+    from ubuntu_system_tests.helpers.camera._cpo import MainWindow
+    proxy = autopilot.get_proxy_object_for_existing_app(
+        APP,
+        cleanup_process=click.get_click_app_identifier(APP_CLICK)
+    )
+    return MainWindow(proxy)
+
+
 def get_config(**kwargs):
     return warlock.model_factory(config_schema)(kwargs)
 

=== modified file 'ubuntu_system_tests/helpers/camera/_cpo.py'
--- ubuntu_system_tests/helpers/camera/_cpo.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/camera/_cpo.py	2016-02-10 11:57:12 +0000
@@ -25,9 +25,8 @@
 
 from camera_app.emulators.main_window import MainWindow
 from camera_app.emulators.panel import Panel
-
-from ubuntu_system_tests.helpers.autopilot import (
-    order_by_x_coord, validate_dbus_object)
+from ubuntu_system_tests.helpers.autopilot.list import order_by_x_coord
+from ubuntu_system_tests.helpers.autopilot import validate_dbus_object
 from ubuntu_system_tests.helpers import wait_until
 
 logger = logging.getLogger(__name__)

=== modified file 'ubuntu_system_tests/helpers/clock/__init__.py'
--- ubuntu_system_tests/helpers/clock/__init__.py	2015-09-22 03:39:11 +0000
+++ ubuntu_system_tests/helpers/clock/__init__.py	2016-02-10 11:57:12 +0000
@@ -1,7 +1,7 @@
 # -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
 #
 # Ubuntu System Tests
-# Copyright (C) 2015 Canonical
+# 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
@@ -16,3 +16,50 @@
 # 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 ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import close_app
+from ubuntu_system_tests.helpers import wait_until
+
+APP_NAME = 'Clock'
+APP_WIN_ID = 'com.ubuntu.clock_clock'
+QML = 'ubuntu-clock-app'
+
+
+def launch_clock_app():
+    """
+    Launch the clock app from apps scope and return proxy object.
+
+    :return: Proxy object for clock application.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    wait_until(is_clock_app_running, period=0.5)
+    return get_clock_app_proxy()
+
+
+def close_clock_app():
+    """ Close the calendar app using task switcher """
+    if is_clock_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_clock_app_running():
+    """ Indicate if the clock app is currently running """
+    return processes.is_qmlscene_running_with_qmlfile(QML)
+
+
+def get_clock_app_proxy():
+    """
+    Return clock app proxy object from existing process.
+
+    :return: Proxy object for calendar application.
+
+    """
+    from ubuntu_system_tests.helpers.clock import _cpo  # NOQA
+    proxy = autopilot.get_proxy_object_for_existing_qmlscene_process(QML)
+    return proxy.main_view

=== added file 'ubuntu_system_tests/helpers/context.py'
--- ubuntu_system_tests/helpers/context.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/context.py	2016-02-10 11:57:12 +0000
@@ -0,0 +1,23 @@
+# -*- 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 ubuntu_system_tests.helpers import AttrDict
+
+shared = AttrDict()

=== modified file 'ubuntu_system_tests/helpers/data.py'
--- ubuntu_system_tests/helpers/data.py	2015-09-23 21:12:39 +0000
+++ ubuntu_system_tests/helpers/data.py	2016-02-10 11:57:12 +0000
@@ -21,9 +21,13 @@
 from json import (load, JSONDecoder)
 from os import path, walk
 
+from ubuntu_system_tests.helpers import AttrDict
 from ubuntu_system_tests.helpers import file_system as fs
 
 
+_full_dict = AttrDict()
+
+
 class AttrDictDecoder(JSONDecoder):
     """ Class used to decode a dict into a AttrDict object """
 
@@ -31,17 +35,6 @@
         JSONDecoder.__init__(self, object_hook=dict_to_attr_dict)
 
 
-class AttrDict(dict):
-    """ Class used to access to the dict keys as parameters """
-
-    def __init__(self, *args, **kwargs):
-        super(AttrDict, self).__init__(*args, **kwargs)
-        self.__dict__ = self
-
-
-_full_dict = AttrDict()
-
-
 def _get_metadata_file(dir):
     """ Retrieve the metadata file path from a dir, in case there is not one
     return None """

=== modified file 'ubuntu_system_tests/helpers/device.py'
--- ubuntu_system_tests/helpers/device.py	2016-01-15 11:19:35 +0000
+++ ubuntu_system_tests/helpers/device.py	2016-02-10 11:57:12 +0000
@@ -21,7 +21,7 @@
 import json
 import os
 
-from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers.autopilot.platform import get_device_name
 from ubuntu_system_tests.helpers import file_system as fs
 
 
@@ -79,7 +79,7 @@
     if device_metadata:
         return device_metadata
 
-    device_id = autopilot.get_device_name()
+    device_id = get_device_name()
     data_file = os.path.join(fs.DIR_TEST_DATA_DEVICES, device_id + '.json')
 
     if not os.path.isfile(data_file):

=== modified file 'ubuntu_system_tests/helpers/dialer_app/__init__.py'
--- ubuntu_system_tests/helpers/dialer_app/__init__.py	2015-11-13 16:54:39 +0000
+++ ubuntu_system_tests/helpers/dialer_app/__init__.py	2016-02-10 11:57:12 +0000
@@ -18,6 +18,59 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import (
+    close_app, launch_application_from_launcher
+)
+
+APP = 'dialer-app'
+APP_NAME = 'Phone'
+APP_WIN_ID = 'dialer-app'
+
+
+def launch_dialer_app():
+    """
+    Launch the dialer app from apps scope and return proxy object.
+
+    :return: Proxy object for dialer application.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    return get_dialer_app_proxy()
+
+
+def close_dialer_app():
+    """ Close the dialer app using task switcher """
+    if is_dialer_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_dialer_app_running():
+    """ Indicate if the dialer app is currently running """
+    return processes.is_process_running(APP)
+
+
+def get_dialer_app_proxy():
+    """
+    Return dialer app proxy object from existing process.
+
+    :return: Proxy object for dialer application.
+
+    """
+    from ubuntu_system_tests.helpers.dialer_app import _cpo  # NOQA
+    proxy = autopilot.get_proxy_object_for_existing_app(APP)
+    return proxy.main_view
+
+
+def launch_dialer_app_from_launcher():
+    """Drag out the launcher and tap the dialer app icon to start it."""
+    launch_application_from_launcher(APP_WIN_ID)
+    return get_dialer_app_proxy()
+
 
 def unformatted_phone_number(phone_number):
     """Remove any spaces or format characters from phone_number."""

=== modified file 'ubuntu_system_tests/helpers/gallery/__init__.py'
--- ubuntu_system_tests/helpers/gallery/__init__.py	2015-11-16 13:44:28 +0000
+++ ubuntu_system_tests/helpers/gallery/__init__.py	2016-02-10 11:57:12 +0000
@@ -2,7 +2,7 @@
 
 #
 # Ubuntu System Tests
-# Copyright (C) 2015 Canonical
+# 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
@@ -17,3 +17,71 @@
 # 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 ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import click
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import (
+    close_app, launch_application_from_launcher
+)
+
+APP = 'gallery-app'
+APP_NAME = 'Gallery'
+APP_WIN_ID = 'com.ubuntu.gallery_gallery'
+APP_CLICK = 'com.ubuntu.gallery'
+
+
+def launch_gallery_app():
+    """
+    Launch the gallery app from apps scope and return proxy object.
+
+    :return: Proxy object for gallery application.
+
+    """
+    from ubuntu_system_tests.helpers.gallery._cpo import EventsView
+    launch_application_from_apps_scope(APP_NAME)
+    return EventsView(get_gallery_app_proxy())
+
+
+def close_gallery_app():
+    """ Close the gallery app using task switcher """
+    if is_gallery_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_gallery_app_running():
+    """ Indicate if the gallery app is currently running """
+    return processes.is_process_running(APP)
+
+
+def get_gallery_app_proxy():
+    """
+    Return gallery app proxy object from existing process.
+
+    :return: Proxy object for gallery application.
+
+    """
+    proxy = autopilot.get_proxy_object_for_existing_app(
+        APP, cleanup_process=click.get_click_app_identifier(APP_CLICK))
+    return proxy
+
+
+def get_gallery_events_view():
+    """Return a gallery_app EventsView custom proxy object."""
+    from ubuntu_system_tests.helpers.gallery._cpo import EventsView
+    return EventsView(get_gallery_app_proxy())
+
+
+def get_gallery_photo_viewer():
+    """Return a gallery_app PhotoViewer custom proxy object."""
+    from ubuntu_system_tests.helpers.gallery._cpo import PhotoViewer
+    return PhotoViewer(get_gallery_app_proxy())
+
+
+def launch_gallery_app_from_launcher():
+    """Drag out the launcher and tap the gallery app icon to start it."""
+    launch_application_from_launcher(APP_WIN_ID)
+    return get_gallery_app_proxy()

=== modified file 'ubuntu_system_tests/helpers/mediaplayer/__init__.py'
--- ubuntu_system_tests/helpers/mediaplayer/__init__.py	2015-10-27 22:05:21 +0000
+++ ubuntu_system_tests/helpers/mediaplayer/__init__.py	2016-02-10 11:57:12 +0000
@@ -22,6 +22,7 @@
 
 from enum import IntEnum
 
+from ubuntu_system_tests.helpers import autopilot
 from ubuntu_system_tests.helpers.dbus_observer import DBusObserver
 from ubuntu_system_tests.helpers import processes
 from ubuntu_system_tests.helpers.threads import StoppingThread
@@ -29,6 +30,23 @@
 APP = 'mediaplayer-app'
 
 
+def get_media_player_proxy():
+    """
+    Return media player app proxy object from existing process.
+
+    :return: Proxy object for media player application.
+
+    """
+    from ubuntu_system_tests.helpers.mediaplayer._cpo import MainWindow
+    proxy = autopilot.get_proxy_object_for_existing_app(APP)
+    return MainWindow(proxy)
+
+
+def is_mediaplayer_running():
+    """ Indicate if the mediaplayer is running """
+    return processes.is_process_running(APP)
+
+
 class PlaybackStatus(IntEnum):
     """Media player playback states."""
     Null = 0
@@ -72,11 +90,6 @@
             self.result.set()
 
 
-def is_mediaplayer_running():
-    """ Indicate if the mediaplayer is running """
-    return processes.is_process_running(APP)
-
-
 def play_video(src_video):
     """ Play the src video in the media player """
     processes.start_application(APP, src_video)

=== modified file 'ubuntu_system_tests/helpers/messaging/__init__.py'
--- ubuntu_system_tests/helpers/messaging/__init__.py	2016-01-06 13:19:19 +0000
+++ ubuntu_system_tests/helpers/messaging/__init__.py	2016-02-10 11:57:12 +0000
@@ -19,6 +19,20 @@
 
 from collections import namedtuple
 from math import ceil
+import ubuntuuitoolkit
+
+from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import (
+    close_app, launch_application_from_launcher
+)
+
+APP = 'messaging-app'
+APP_NAME = 'Messaging'
+APP_WIN_ID = 'messaging-app'
 
 # Number of characters sent in a single SMS message
 SMS_MESSAGE_SIZE = 153
@@ -35,6 +49,51 @@
 Search.__new__.__defaults__ = (None, None, None)
 
 
+def launch_messaging_app():
+    """
+    Launch the messaging app from apps scope and return proxy object.
+
+    :return: Proxy object for messaging application.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    return get_messaging_app_proxy()
+
+
+def close_messaging_app():
+    """ Close the messaging app using task switcher """
+    if is_messaging_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_messaging_app_running():
+    """ Indicate if the messaging app is currently running """
+    return processes.is_process_running(APP)
+
+
+def get_messaging_app_proxy(
+        base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
+    """
+    Return messaging app proxy object from existing process.
+
+    :return: Proxy object for messaging application.
+
+    """
+    if not base:
+        return autopilot.get_proxy_object_for_existing_app(APP,
+                                                           base=base)
+
+    from ubuntu_system_tests.helpers.messaging._cpo import MainView
+    proxy = autopilot.get_proxy_object_for_existing_app(APP)
+    return proxy.wait_select_single(MainView)
+
+
+def launch_messaging_app_from_launcher():
+    """Drag out the launcher and tap the messaging app icon to start it."""
+    launch_application_from_launcher(APP)
+    return get_messaging_app_proxy()
+
+
 def calculate_sent_message_count(body, size=SMS_MESSAGE_SIZE):
     """
     Calculate the number of sms messages required to send the message.

=== modified file 'ubuntu_system_tests/helpers/messaging/_cpo.py'
--- ubuntu_system_tests/helpers/messaging/_cpo.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/messaging/_cpo.py	2016-02-10 11:57:12 +0000
@@ -28,8 +28,9 @@
 from messaging_app import emulators as messaging_emulators
 
 from ubuntu_system_tests.helpers.autopilot import (
-    order_by_y_coord, patched_select_single, validate_dbus_object,
-    wait_select_many)
+    patched_select_single, validate_dbus_object, wait_select_many
+)
+from ubuntu_system_tests.helpers.autopilot.list import order_by_y_coord
 from ubuntu_system_tests.helpers.system_settings import SIM_1, SIM_2
 
 logger = logging.getLogger(__name__)

=== modified file 'ubuntu_system_tests/helpers/music.py'
--- ubuntu_system_tests/helpers/music.py	2016-01-26 18:36:22 +0000
+++ ubuntu_system_tests/helpers/music.py	2016-02-10 11:57:12 +0000
@@ -16,15 +16,59 @@
 # 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 ubuntuuitoolkit
 
+from ubuntu_system_tests.helpers import autopilot
 from ubuntu_system_tests.helpers import file_system as fs
 from ubuntu_system_tests.helpers import processes
-
-
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import close_app
+from ubuntu_system_tests.helpers import wait_until
+
+APP = 'music-app'
+APP_NAME = 'Music'
+APP_WIN_ID = 'com.ubuntu.music_music'
 QML = 'music-app.qml'
 
 
+def launch_music_app():
+    """
+    Launch the music app from apps scope and return proxy object.
+
+    :return: Proxy object for music application.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    wait_until(is_music_app_running, period=0.5)
+    return get_music_app_proxy()
+
+
+def close_music_app():
+    """ Close the music app using task switcher """
+    if is_music_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_music_app_running():
+    """ Indicate if the music app is currently running """
+    return processes.is_qmlscene_running_with_qmlfile(APP)
+
+
+def get_music_app_proxy():
+    """
+    Return music app proxy object from existing process.
+
+    :return: Proxy object for music application.
+
+    """
+    proxy = autopilot.get_proxy_object_for_existing_qmlscene_process(APP)
+    return proxy.wait_select_single(ubuntuuitoolkit.MainView)
+
+
 def stop_music_app():
+    """ Stop the music app qml process """
     processes.stop_qmlscene_process(QML)
 
 

=== modified file 'ubuntu_system_tests/helpers/scopes/__init__.py'
--- ubuntu_system_tests/helpers/scopes/__init__.py	2016-01-05 15:28:08 +0000
+++ ubuntu_system_tests/helpers/scopes/__init__.py	2016-02-10 11:57:12 +0000
@@ -23,8 +23,9 @@
 
 from ubuntu_system_tests.helpers import file_system as fs
 from ubuntu_system_tests.helpers import url_dispatcher
-from ubuntu_system_tests.helpers.autopilot import (
-    get_channel_name, get_device_name)
+from ubuntu_system_tests.helpers.autopilot.platform import (
+    get_device_name, get_channel_name
+)
 from ubuntu_system_tests.helpers.scopes import data as scope_data
 from ubuntu_system_tests.helpers.unity8 import get_dash
 

=== modified file 'ubuntu_system_tests/helpers/scopes/apps/__init__.py'
--- ubuntu_system_tests/helpers/scopes/apps/__init__.py	2015-10-19 09:56:33 +0000
+++ ubuntu_system_tests/helpers/scopes/apps/__init__.py	2016-02-10 11:57:12 +0000
@@ -18,4 +18,23 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+from ubuntu_system_tests.helpers.scopes import go_to_apps_scope
+from ubuntu_system_tests.helpers import timer
+
+
 APP_STORE_TITLE = 'Ubuntu Store'
+
+
+def launch_application_from_apps_scope(app_name, category=None):
+    """
+    Launch an app from apps scope and return proxy object.
+
+    :param app_name: Name of the displayed application.
+    :param category: Category name app is displayed in. If None then the
+                     category name will be discovered automatically.
+    """
+    apps_scope = go_to_apps_scope()
+    if not category:
+        category = apps_scope.get_app_category(app_name)
+    apps_scope.click_scope_item(category, app_name)
+    timer.start(timer.LAUNCH_ID)

=== modified file 'ubuntu_system_tests/helpers/scopes/apps/_cpo.py'
--- ubuntu_system_tests/helpers/scopes/apps/_cpo.py	2016-02-03 10:31:33 +0000
+++ ubuntu_system_tests/helpers/scopes/apps/_cpo.py	2016-02-10 11:57:12 +0000
@@ -21,7 +21,10 @@
 from autopilot import exceptions, introspection
 
 from ubuntu_system_tests.helpers.autopilot import (
-    get_parent, get_patched_registry, order_by_y_coord, validate_dbus_object)
+    get_patched_registry, validate_dbus_object
+)
+from ubuntu_system_tests.helpers.autopilot.list import order_by_y_coord
+from ubuntu_system_tests.helpers.autopilot.object import get_parent
 from ubuntu_system_tests.helpers.scopes.apps import _clickscope
 from ubuntu_system_tests.helpers.scopes.base import GenericScopeView
 from ubuntu_system_tests.helpers.unity8 import UNITY8_DASH_PATH_ROOT

=== modified file 'ubuntu_system_tests/helpers/scopes/base.py'
--- ubuntu_system_tests/helpers/scopes/base.py	2016-01-22 18:18:38 +0000
+++ ubuntu_system_tests/helpers/scopes/base.py	2016-02-10 11:57:12 +0000
@@ -23,12 +23,9 @@
 from autopilot import exceptions
 from collections import namedtuple
 from unity8 import dash as unity8_dash
-
-from ubuntu_system_tests.helpers.autopilot import order_by_y_coord
+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 import timer
+    DashPageHeader)
 from ubuntu_system_tests.helpers.unity8 import get_dash
 from ubuntu_system_tests.helpers.url_dispatcher import go_to_url
 
@@ -75,7 +72,6 @@
         x, y, width, height = icon.globalRect
         self.pointing_device.move(x + 1, y + 1)
         self.pointing_device.click(press_duration=press_duration)
-        timer.start(timer.LAUNCH_ID)
 
     def _get_data_from_object(self, object):
         """

=== modified file 'ubuntu_system_tests/helpers/scopes/music/_cpo.py'
--- ubuntu_system_tests/helpers/scopes/music/_cpo.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/scopes/music/_cpo.py	2016-02-10 11:57:12 +0000
@@ -21,8 +21,9 @@
 from autopilot import exceptions
 
 from ubuntu_system_tests.helpers.autopilot import (
-    is_element, order_by_y_coord, patched_wait_select_single, wait_select_many,
+    is_element, patched_wait_select_single, wait_select_many,
     validate_dbus_object)
+from ubuntu_system_tests.helpers.autopilot.list import order_by_y_coord
 from ubuntu_system_tests.helpers.scopes.base import (
     GenericScopeView as GenericScopeViewBase)
 from ubuntu_system_tests.helpers.ubuntuuitoolkit import pageheader

=== modified file 'ubuntu_system_tests/helpers/scopes/music/_preview.py'
--- ubuntu_system_tests/helpers/scopes/music/_preview.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/scopes/music/_preview.py	2016-02-10 11:57:12 +0000
@@ -19,8 +19,8 @@
 #
 
 from unity8.dash import Preview as DashPreview
-
-from ubuntu_system_tests.helpers.autopilot import wait_until_is_not_moving
+from ubuntu_system_tests.helpers.autopilot.object import \
+    wait_until_is_not_moving
 
 
 class Preview(DashPreview):

=== modified file 'ubuntu_system_tests/helpers/scopes/photos/_category.py'
--- ubuntu_system_tests/helpers/scopes/photos/_category.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/scopes/photos/_category.py	2016-02-10 11:57:12 +0000
@@ -21,7 +21,8 @@
 from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase
 
 from ubuntu_system_tests.helpers.autopilot import (
-    is_element, order_by_x_coord, validate_dbus_object)
+    is_element, validate_dbus_object)
+from ubuntu_system_tests.helpers.autopilot.list import order_by_x_coord
 from ubuntu_system_tests.helpers.unity8 import UNITY8_DASH_PATH_ROOT
 
 

=== modified file 'ubuntu_system_tests/helpers/system_settings/__init__.py'
--- ubuntu_system_tests/helpers/system_settings/__init__.py	2016-01-18 09:29:20 +0000
+++ ubuntu_system_tests/helpers/system_settings/__init__.py	2016-02-10 11:57:12 +0000
@@ -25,13 +25,57 @@
     check_output,
 )
 
-SETTINGS_PROCESS = 'ubuntu-system-settings'
+from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import close_app
+
+APP = 'system-settings'
+APP_NAME = 'System Settings'
+APP_WIN_ID = 'ubuntu-system-settings'
 
 SIM_1 = '1'
 SIM_2 = '2'
 SIM_ASK = 'ask'
 
 
+def launch_system_settings():
+    """
+    Launch system settings from apps scope and return proxy object.
+
+    :return: Proxy object for system settings.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    return get_system_settings_proxy()
+
+
+def close_system_settings():
+    """ Close the system settings app using task switcher """
+    if is_system_settings_running():
+        close_app(APP_WIN_ID)
+
+
+def is_system_settings_running():
+    """ Indicate if the system settings is currently running """
+    return processes.is_process_running(APP)
+
+
+def get_system_settings_proxy():
+    """
+    Return system settings proxy object from existing process.
+
+    :return: Proxy object for system settings.
+
+    """
+    from ubuntu_system_tests.helpers.system_settings import _cpo  # NOQA
+    proxy = autopilot.get_proxy_object_for_existing_app(
+        APP, cleanup_process=APP_WIN_ID)
+    return proxy.main_view
+
+
 def get_ril_modem_for_sim(sim):
     """
     Convert the sim slot number to ril modem id, /ril_0 or /ril_1.

=== modified file 'ubuntu_system_tests/helpers/timer.py'
--- ubuntu_system_tests/helpers/timer.py	2016-01-21 18:25:17 +0000
+++ ubuntu_system_tests/helpers/timer.py	2016-02-10 11:57:12 +0000
@@ -19,15 +19,18 @@
 
 from datetime import datetime
 
+from ubuntu_system_tests.helpers import context
+
 start_times = {}
 
 LAUNCH_ID = 'launch'
 
 
 def start(id):
-    """ Start the timer identified with the id """
-    global start_times
-    start_times[id] = datetime.now()
+    """ Start the timer identified with the id when it has being enabled """
+    if id in context.shared.timers:
+        global start_times
+        start_times[id] = datetime.now()
 
 
 def _get_elapsed_time(id):

=== modified file 'ubuntu_system_tests/helpers/ubuntu_keyboard/__init__.py'
--- ubuntu_system_tests/helpers/ubuntu_keyboard/__init__.py	2015-12-15 19:31:52 +0000
+++ ubuntu_system_tests/helpers/ubuntu_keyboard/__init__.py	2016-02-10 11:57:12 +0000
@@ -20,6 +20,15 @@
 
 from ubuntu_keyboard.emulators.keyboard import Keyboard
 
+from ubuntu_system_tests.helpers import autopilot
+
+APP = 'maliit-server'
+
+
+def get_ubuntu_keyboard_proxy():
+    from ubuntu_system_tests.helpers.ubuntu_keyboard import _cpo  # NOQA
+    return autopilot.get_proxy_object_for_existing_app(APP)
+
 
 def is_keyboard_shifted():
     keyboard = Keyboard()

=== modified file 'ubuntu_system_tests/helpers/ubuntuuitoolkit/optiontoggle.py'
--- ubuntu_system_tests/helpers/ubuntuuitoolkit/optiontoggle.py	2016-01-08 17:39:01 +0000
+++ ubuntu_system_tests/helpers/ubuntuuitoolkit/optiontoggle.py	2016-02-10 11:57:12 +0000
@@ -18,8 +18,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase
-
-from ubuntu_system_tests.helpers.autopilot import order_by_y_coord
+from ubuntu_system_tests.helpers.autopilot.list import order_by_y_coord
 
 
 class OptionToggle(UbuntuUIToolkitCustomProxyObjectBase):

=== modified file 'ubuntu_system_tests/helpers/ubuntuuitoolkit/pageheader.py'
--- ubuntu_system_tests/helpers/ubuntuuitoolkit/pageheader.py	2015-11-06 22:41:22 +0000
+++ ubuntu_system_tests/helpers/ubuntuuitoolkit/pageheader.py	2016-02-10 11:57:12 +0000
@@ -18,8 +18,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase
-
-from ubuntu_system_tests.helpers.autopilot import order_by_y_coord
+from ubuntu_system_tests.helpers.autopilot.list import order_by_y_coord
 
 
 class DashPageHeader(UbuntuUIToolkitCustomProxyObjectBase):

=== modified file 'ubuntu_system_tests/helpers/unity8/__init__.py'
--- ubuntu_system_tests/helpers/unity8/__init__.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/unity8/__init__.py	2016-02-10 11:57:12 +0000
@@ -24,6 +24,9 @@
 from autopilot import introspection
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals
+
+from ubuntu_system_tests.helpers import context
+from ubuntu_system_tests.helpers import timer
 from ubuntu_system_tests.helpers.unity8 import greeter
 
 UNITY8_PATH_ROOT = b'unity8'
@@ -57,3 +60,37 @@
         emulator_base=UbuntuUIToolkitCustomProxyObjectBase,
     )
     return dash_proxy.select_single(Dash)
+
+
+def launch_application_from_launcher(app_name):
+    """
+    Launch an app from the launcher.
+
+    :param app_name: Name of the displayed application.
+
+    """
+    unity = context.shared.unity
+    timer.start(timer.LAUNCH_ID)
+    unity.main_window.launch_application(app_name)
+
+
+def close_app(app_name):
+    """Close an app using task switcher and check process is stopped."""
+    unity = context.shared.unity
+
+    # Get the windows name
+    stage = unity.main_window.swipe_to_show_app_switcher()
+    app_window_name = 'appWindow_' + app_name
+    app_windows = stage.get_app_window_names()
+    if app_window_name not in app_windows:
+        raise RuntimeError(
+            'Window {} no included in windows list {}'.format(
+                app_window_name, app_windows
+            ))
+
+    # Close the windows and assert that it is closed
+    stage.close_app(app_name)
+    app_windows = stage.get_app_window_names()
+    if app_window_name in app_windows:
+        raise RuntimeError(
+            'Window {} not closed correctly'.format(app_window_name))

=== modified file 'ubuntu_system_tests/helpers/unity8/dash.py'
--- ubuntu_system_tests/helpers/unity8/dash.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/unity8/dash.py	2016-02-10 11:57:12 +0000
@@ -24,8 +24,8 @@
 from unity8 import dash as unity8_dash
 
 from ubuntu_system_tests.helpers.autopilot import (
-    order_by_x_coord, patched_wait_select_single, validate_dbus_object,
-    wait_select_many)
+    patched_wait_select_single, validate_dbus_object, wait_select_many)
+from ubuntu_system_tests.helpers.autopilot.list import order_by_x_coord
 from ubuntu_system_tests.helpers.ubuntuuitoolkit.pageheader import (
     DashPageHeader
 )

=== modified file 'ubuntu_system_tests/helpers/unity8/phone_stage.py'
--- ubuntu_system_tests/helpers/unity8/phone_stage.py	2016-02-03 10:40:06 +0000
+++ ubuntu_system_tests/helpers/unity8/phone_stage.py	2016-02-10 11:57:12 +0000
@@ -23,9 +23,8 @@
 from autopilot import logging as autopilot_logging
 from autopilot.exceptions import StateNotFoundError
 from ubuntuuitoolkit import UbuntuUIToolkitCustomProxyObjectBase
-
-from ubuntu_system_tests.helpers.autopilot import (
-    order_by_x_coord, validate_dbus_object)
+from ubuntu_system_tests.helpers.autopilot import validate_dbus_object
+from ubuntu_system_tests.helpers.autopilot.list import order_by_x_coord
 from ubuntu_system_tests.helpers.unity8 import UNITY8_PATH_ROOT
 
 logger = logging.getLogger(__name__)

=== modified file 'ubuntu_system_tests/helpers/webapp/__init__.py'
--- ubuntu_system_tests/helpers/webapp/__init__.py	2015-10-30 14:05:06 +0000
+++ ubuntu_system_tests/helpers/webapp/__init__.py	2016-02-10 11:57:12 +0000
@@ -28,7 +28,13 @@
 from selenium.webdriver.chrome.options import Options
 from selenium.webdriver.common.touch_actions import TouchActions
 
+from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import context
 from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers import wait_until
 
 DEFAULT_WEBVIEW_INSPECTOR_IP = '127.0.0.1'
 DEFAULT_WEBVIEW_INSPECTOR_PORT = 9221
@@ -36,13 +42,16 @@
 logger = logging.getLogger(__name__)
 
 
-def get_webdriver(cleanup_method):
-    """ Retrieve the webdriver for the current webapp container """
-    driver = setup_webdriver()
-    cleanup_method(driver.quit)
-
-    driver.implicitly_wait(30)
-    return driver
+def launch_webapp(app_name, web_app_package):
+    """ Launch the webapp and return the webapp proxy object
+    :param app_name: The name in the apps scope
+    :param web_app_package: The package name
+    :return: Proxy object for webapp
+    """
+    launch_application_from_apps_scope(app_name)
+    context.shared.add_cleanup(ensure_webapp_closed, web_app_package)
+    wait_until(is_webapp_runing, web_app_package)
+    return get_webapp_proxy(web_app_package)
 
 
 def is_webapp_runing(web_app):
@@ -73,6 +82,18 @@
         raise RuntimeError('No such webapp {} running'.format(webapp_id))
 
 
+def get_webapp_proxy(web_app_package):
+    """ Return webapp proxy object from existing process.
+    :param web_app_package: The package name
+    :return: Proxy object for webapp.
+    """
+    from ubuntu_system_tests.helpers.webapp import _cpo  # NOQA
+
+    pid = get_webapp_pid(web_app_package)
+    proxy = autopilot.get_proxy_object(pid)
+    return proxy.wait_select_single('BrowserWindow')
+
+
 def ensure_webapp_closed(web_app):
     try:
         webapp_id = _get_webapp_id(web_app)
@@ -81,6 +102,15 @@
         pass
 
 
+def get_webdriver(cleanup_method):
+    """ Retrieve the webdriver for the current webapp container """
+    driver = setup_webdriver()
+    cleanup_method(driver.quit)
+
+    driver.implicitly_wait(30)
+    return driver
+
+
 def setup_webdriver():
     options = _get_webdriver_options()
     chromedriver_exec_path = get_chromedriver_exec_path()

=== modified file 'ubuntu_system_tests/helpers/webapp/ebay.py'
--- ubuntu_system_tests/helpers/webapp/ebay.py	2015-10-15 03:11:59 +0000
+++ ubuntu_system_tests/helpers/webapp/ebay.py	2016-02-10 11:57:12 +0000
@@ -20,8 +20,31 @@
 
 from selenium.webdriver.support.ui import WebDriverWait
 
+from ubuntu_system_tests.helpers.unity8 import close_app
+from ubuntu_system_tests.helpers import webapp
 from ubuntu_system_tests.helpers.webapp import BasePage
 
+WEBAPP_NAME = 'eBay'
+WEBAPP_PACKAGE = 'com.ubuntu.developer.webapps.webapp-ebay'
+WEBAPP_WIN_ID = 'com.ubuntu.developer.webapps.webapp-ebay_webapp-ebay'
+
+
+def launch_ebay_webapp():
+    """ Launch the Ebay webapp from apps scope and return its proxy object
+    """
+    return webapp.launch_webapp(WEBAPP_NAME, WEBAPP_PACKAGE)
+
+
+def close_ebay_webapp():
+    """ Close the ebay webapp using task switcher """
+    if is_ebay_webapp_running():
+        close_app(WEBAPP_WIN_ID)
+
+
+def is_ebay_webapp_running():
+    """ Indicate if the ebay webapp is currently running """
+    return webapp.is_webapp_runing(WEBAPP_PACKAGE)
+
 
 class Homepage(BasePage):
     _search_box_id = 'kw'

=== modified file 'ubuntu_system_tests/helpers/webapp/here.py'
--- ubuntu_system_tests/helpers/webapp/here.py	2015-10-21 05:52:09 +0000
+++ ubuntu_system_tests/helpers/webapp/here.py	2016-02-10 11:57:12 +0000
@@ -25,8 +25,32 @@
 from selenium.webdriver.support import expected_conditions as EC
 from selenium.webdriver.support.ui import WebDriverWait
 
+from ubuntu_system_tests.helpers.unity8 import close_app
+from ubuntu_system_tests.helpers import webapp
 from ubuntu_system_tests.helpers.webapp import BasePage
 
+WEBAPP_NAME = 'HERE Maps'
+WEBAPP_PACKAGE = 'com.nokia.heremaps'
+WEBAPP_WIN_ID = 'com.nokia.heremaps_here'
+
+
+def launch_here_webapp():
+    """ Launch the Here webapp from apps scope and return its proxy object
+    """
+    return webapp.launch_webapp(WEBAPP_NAME, WEBAPP_PACKAGE)
+
+
+def close_here_webapp():
+    """ Close the here webapp using task switcher """
+    if is_here_webapp_running():
+        close_app(WEBAPP_WIN_ID)
+
+
+def is_here_webapp_running():
+    """ Indicate if the here webapp is currently running """
+    webapp_package = WEBAPP_PACKAGE
+    return webapp.is_webapp_runing(webapp_package)
+
 
 class Homepage(BasePage):
     _my_location = "//a[@class='mh5_Button position available']"

=== modified file 'ubuntu_system_tests/helpers/webbrowser/__init__.py'
--- ubuntu_system_tests/helpers/webbrowser/__init__.py	2016-01-26 18:36:22 +0000
+++ ubuntu_system_tests/helpers/webbrowser/__init__.py	2016-02-10 11:57:12 +0000
@@ -2,7 +2,7 @@
 
 #
 # Ubuntu System Tests
-# Copyright (C) 2015 Canonical
+# 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
@@ -18,9 +18,58 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+from ubuntu_system_tests.helpers import autopilot
 from ubuntu_system_tests.helpers import processes
+from ubuntu_system_tests.helpers.scopes.apps import (
+    launch_application_from_apps_scope
+)
+from ubuntu_system_tests.helpers.unity8 import (
+    close_app, launch_application_from_launcher
+)
 
 APP = 'webbrowser-app'
+APP_NAME = 'Browser'
+APP_WIN_ID = 'webbrowser-app'
+
+
+def launch_webbrowser_app():
+    """
+    Launch the webbrowser app from apps scope and return proxy object.
+
+    :return: Proxy object for webbrowser application.
+
+    """
+    launch_application_from_apps_scope(APP_NAME)
+    return get_webbrowser_app_proxy()
+
+
+def close_webbrowser_app():
+    """ Close the webbrowser app using task switcher """
+    if is_webbrowser_app_running():
+        close_app(APP_WIN_ID)
+
+
+def is_webbrowser_app_running():
+    """ Indicate if the webbrowser app is currently running """
+    return processes.is_process_running(APP)
+
+
+def get_webbrowser_app_proxy():
+    """
+    Return webbrowser app proxy object from existing process.
+
+    :return: Proxy object for webbrowser application.
+
+    """
+    from ubuntu_system_tests.helpers.webbrowser import _cpo  # NOQA
+    proxy = autopilot.get_proxy_object_for_existing_app(APP)
+    return proxy.main_window
+
+
+def launch_webbrowser_from_launcher():
+    """Start webbrowser from the launcher."""
+    launch_application_from_launcher(APP_WIN_ID)
+    return get_webbrowser_app_proxy()
 
 
 def get_webbrowser_process_id():

=== modified file 'ubuntu_system_tests/tests/app_startup/test_application_startup.py'
--- ubuntu_system_tests/tests/app_startup/test_application_startup.py	2016-01-28 22:33:33 +0000
+++ ubuntu_system_tests/tests/app_startup/test_application_startup.py	2016-02-10 11:57:12 +0000
@@ -23,17 +23,31 @@
 import traceback
 
 from ubuntu_system_tests import config
-from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers import addressbook
+from ubuntu_system_tests.helpers.autopilot.platform import (
+    get_channel_name, get_device_name, get_build_number
+)
+from ubuntu_system_tests.helpers import calculator
+from ubuntu_system_tests.helpers import camera
 from ubuntu_system_tests.helpers.camera.fixture_setup import (
     SetCameraAccessRequests
 )
+from ubuntu_system_tests.helpers import clock
 from ubuntu_system_tests.helpers.clock.fixture_setup import (
     SetClockAccessRequests)
+from ubuntu_system_tests.helpers import context
+from ubuntu_system_tests.helpers import dialer_app
 from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers import gallery
 from ubuntu_system_tests.helpers.location.fixture_setup import (
     SetLocationAccessRequests)
+from ubuntu_system_tests.helpers import music
+from ubuntu_system_tests.helpers import messaging
+from ubuntu_system_tests.helpers import system_settings
 from ubuntu_system_tests.helpers.testbed import run_command_with_sudo
 from ubuntu_system_tests.helpers import timer
+from ubuntu_system_tests.helpers.webapp import ebay, here
+from ubuntu_system_tests.helpers import webbrowser
 from ubuntu_system_tests.helpers.webbrowser.fixture_setup import (
     WebbrowserTestEnvironment
 )
@@ -52,10 +66,14 @@
 
     def setUp(self):
         super().setUp()
+        self._setup_timers()
         self.shell = self.restart_unity()
         self.addCleanup(self._clear_qml_cache)
         self._log_global_info()
 
+    def _setup_timers(self):
+        context.shared.timers.append(timer.LAUNCH_ID)
+
     def _clear_qml_cache(self):
         fs.clean_dir(os.path.join(fs.DIR_HOME_CACHE, 'QML'))
         run_command_with_sudo('sysctl -w vm.drop_caches=3')
@@ -74,9 +92,9 @@
 
     def _log_global_info(self):
         global_info = {"run_id": RUN_ID,
-                       "device": autopilot.get_device_name(),
-                       "channel": autopilot.get_channel_name(),
-                       "build_number": autopilot.get_build_number()}
+                       "device": get_device_name(),
+                       "channel": get_channel_name(),
+                       "build_number": get_build_number()}
 
         logger.info("Global Info <= {}".format(global_info))
 
@@ -121,43 +139,44 @@
 class AppStartupTestCase(BaseAppStartupTestCase):
 
     def test_dialer_startup(self):
-        self._run_test('dialer', self.launch_dialer_app,
-                       self.close_dialer_app,
+        self._run_test('dialer', dialer_app.launch_dialer_app,
+                       dialer_app.close_dialer_app,
                        loaded_method=self.shell.ensure_app_loaded)
 
     def test_calculator_startup(self):
-        self._run_test('calculator', self.launch_calculator_app,
-                       self.close_calculator_app,
+        self._run_test('calculator', calculator.launch_calculator_app,
+                       calculator.close_calculator_app,
                        loaded_method=self.shell.ensure_app_loaded)
 
     def test_address_book_startup(self):
-        self._run_test('address_book', self.launch_address_book,
-                       self.close_address_book,
+        self._run_test('address_book', addressbook.launch_address_book,
+                       addressbook.close_address_book,
                        loaded_method=self.shell.ensure_app_loaded)
 
     def test_messaging_startup(self):
-        self._run_test('messaging', self.launch_messaging_app,
-                       self.close_messaging_app,
+        self._run_test('messaging', messaging.launch_messaging_app,
+                       messaging.close_messaging_app,
                        loaded_method=self.shell.ensure_app_loaded)
 
     def test_ebay_startup(self):
-        self._run_test('ebay', self.launch_ebay_webapp,
-                       self.close_ebay_webapp,
+        self._run_test('ebay', ebay.launch_ebay_webapp,
+                       ebay.close_ebay_webapp,
                        loaded_method=self.shell.ensure_app_loaded)
 
     def test_system_settings_startup(self):
-        self._run_test('system_settings', self.launch_system_settings,
-                       self.close_system_settings,
+        self._run_test('system_settings',
+                       system_settings.launch_system_settings,
+                       system_settings.close_system_settings,
                        loaded_method=self.shell.ensure_app_loaded)
 
     def test_gallery_startup(self):
-        self._run_test('gallery', self.launch_gallery_app_from_launcher,
-                       self.close_gallery_app,
+        self._run_test('gallery', gallery.launch_gallery_app_from_launcher,
+                       gallery.close_gallery_app,
                        loaded_method=self.shell.ensure_app_loaded)
 
     def test_music_startup(self):
-        self._run_test('music', self.launch_music_app,
-                       self.close_music_app,
+        self._run_test('music', music.launch_music_app,
+                       music.close_music_app,
                        loaded_method=self.shell.ensure_app_loaded)
 
 
@@ -168,12 +187,12 @@
         super().setUp()
 
     def _launch_camera_app(self):
-        camera = self.launch_camera_app()
-        camera.ensure_camera_ready()
+        camera_app = camera.launch_camera_app()
+        camera_app.ensure_camera_ready()
 
     def test_camera_startup(self):
         self._run_test('camera', self._launch_camera_app,
-                       self.close_camera_app)
+                       camera.close_camera_app)
 
 
 class WebBrowserAppStartupTestCase(BaseAppStartupTestCase):
@@ -183,8 +202,8 @@
         super().setUp()
 
     def test_webbrowser_startup(self):
-        self._run_test('webbrowser', self.launch_webbrowser_app,
-                       self.close_webbrowser_app,
+        self._run_test('webbrowser', webbrowser.launch_webbrowser_app,
+                       webbrowser.close_webbrowser_app,
                        loaded_method=self.shell.ensure_app_loaded)
 
 
@@ -195,8 +214,8 @@
         super().setUp()
 
     def test_clock_startup(self):
-        self._run_test('clock', self.launch_clock_app,
-                       self.close_clock_app,
+        self._run_test('clock', clock.launch_clock_app,
+                       clock.close_clock_app,
                        loaded_method=self.shell.ensure_app_loaded)
 
 
@@ -207,6 +226,6 @@
         super().setUp()
 
     def test_here_startup(self):
-        self._run_test('here', self.launch_here_webapp,
-                       self.close_here_webapp,
+        self._run_test('here', here.launch_here_webapp,
+                       here.close_here_webapp,
                        loaded_method=self.shell.ensure_app_loaded)

=== modified file 'ubuntu_system_tests/tests/base.py'
--- ubuntu_system_tests/tests/base.py	2016-02-05 19:18:50 +0000
+++ ubuntu_system_tests/tests/base.py	2016-02-10 11:57:12 +0000
@@ -2,7 +2,7 @@
 
 #
 # Ubuntu System Tests
-# Copyright (C) 2014, 2015 Canonical
+# 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
@@ -23,7 +23,6 @@
 import psutil
 from retrying import retry
 import stat
-import subprocess
 from tempfile import mkstemp
 import threading
 
@@ -31,12 +30,10 @@
     exceptions,
     get_test_configuration,
     input,
-    introspection,
     logging as autopilot_logging,
     testcase
 )
 from autopilot.matchers import Eventually
-import ubuntuuitoolkit
 from autopilot._fixtures import OSKAlwaysEnabled
 from autopilot.introspection import _object_registry as object_registry
 from testtools.matchers import Equals
@@ -44,30 +41,20 @@
 from unity8 import process_helpers
 from unity8.sensors import FakePlatformSensors
 
-from ubuntu_system_tests.helpers import autopilot as autopilot_helpers
-from ubuntu_system_tests.helpers import click
+from ubuntu_system_tests.helpers import autopilot
+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 import processes
 from ubuntu_system_tests.helpers import screen
-from ubuntu_system_tests.helpers import timer
 from ubuntu_system_tests.helpers import unity8
+from ubuntu_system_tests.helpers.unity8 import get_dash
+from ubuntu_system_tests.helpers.unity8.shell import Unity8  # NOQA
 from ubuntu_system_tests.helpers import wait_until
 from ubuntu_system_tests.helpers import webapp
-from ubuntu_system_tests.helpers.processes import ensure_application_closed
-from ubuntu_system_tests.helpers.scopes import go_to_apps_scope
-from ubuntu_system_tests.helpers.unity8 import get_dash
-from ubuntu_system_tests.helpers.unity8.shell import Unity8  # NOQA
 
 # Any test name ending with this will leave device locked
 TEST_ID_DEVICE_LOCKED = 'device_locked'
 
-# Apps and cleanup names
-CALCULATOR_APP = 'ubuntu-calculator-app'
-
-CATEGORY_LOCAL = 'local'
-CATEGORY_PREDEFINED = 'predefined'
-
 logger = logging.getLogger(__name__)
 
 
@@ -86,6 +73,21 @@
     def setUp(self):
         super().setUp()
         self._reset_autopilot_registry()
+        self._init_shared_context()
+
+    def _init_shared_context(self):
+        # The shared context is reset for each test
+        context.shared.clear()
+        context.shared.add_cleanup = self.addCleanup
+        context.shared.timers = []
+
+    # Retry added until fix for bug 1427946 in QtMir is landed
+    @retry(stop_max_delay=30000,
+           retry_on_exception=lambda exception: (
+                isinstance(exception, psutil.NoSuchProcess) or
+                isinstance(exception, ValueError)))
+    def _get_unity8_proxy_object(self):
+        return autopilot.get_job_proxy_object('unity8')
 
     @autopilot_logging.log_action(logger.info)
     def launch_unity(self, fake_sensors=False):
@@ -111,7 +113,8 @@
         else:
             self._start_unity_with_testability()
 
-        unity = self.get_job_proxy_object('unity8')
+        unity = self._get_unity8_proxy_object()
+        context.shared.unity = unity
         unity.wait_for_greeter_content()
         # Workaround to remove the UInput keyboard created by autopilot.
         # This stops the OSK from being displayed, so must remove it.
@@ -125,21 +128,6 @@
     def _start_unity_with_testability(self):
         process_helpers.start_job('unity8', 'QT_LOAD_TESTABILITY=1')
 
-    # Retry added until fix for bug 1427946 in QtMir is landed
-    @retry(stop_max_delay=30000,
-           retry_on_exception=lambda exception: (
-               isinstance(exception, psutil.NoSuchProcess) or
-               isinstance(exception, ValueError)))
-    def get_job_proxy_object(self, pname):
-        pid = process_helpers.get_job_pid(pname)
-        return self.get_proxy_object(pid)
-
-    def get_proxy_object(self, pid):
-        return introspection.get_proxy_object_for_existing_process(
-            pid=pid,
-            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase,
-        )
-
     def _remove_autopilot_keyboard(self):
         """Remove the UInput simulated keyboard automatically created by
         autopilot which stops the OSK from appearing."""
@@ -225,13 +213,9 @@
         test_id = self.id().split('.')[-1]
         return not test_id.endswith(TEST_ID_DEVICE_LOCKED)
 
-    def ensure_application_closed(self, app_name):
-        """Stop the app before unity8 is restarted so it's not orphaned."""
-        subprocess.call(['ubuntu-app-stop', app_name])
-
     def _get_screenshot_size(self, x, y, width, height):
         """ Calculate the screenshot size """
-        unity = self.get_job_proxy_object('unity8')
+        unity = context.shared.unity
         if width and height:
             return width, height
         else:
@@ -251,461 +235,6 @@
         return images.get_image_from_rgba(
             file_path, self._get_screenshot_size(x, y, width, height))
 
-    def _launch_application_from_apps_scope(self, app_name, category=None):
-        """
-        Launch an app from apps scope and return proxy object.
-
-        :param app_name: Name of the displayed application.
-        :param category: Category name app is displayed in. If None then the
-                         category name will be discovered automatically.
-        :return: Proxy object for application.
-
-        """
-        apps_scope = go_to_apps_scope()
-        if not category:
-            category = apps_scope.get_app_category(app_name)
-        apps_scope.click_scope_item(category, app_name)
-
-    def _launch_application_from_launcher(self, app_name):
-        """
-        Launch an app from the launcher.
-
-        :param app_name: Name of the displayed application.
-
-        """
-        unity = self.get_job_proxy_object('unity8')
-        timer.start(timer.LAUNCH_ID)
-        unity.main_window.launch_application(app_name)
-
-    def _get_proxy_object_for_existing_app(
-            self,
-            process_name,
-            cleanup_process=None,
-            base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
-        """
-        Return proxy object from existing application process.
-
-        Add cleanup action to close the application using cleanup_process
-        parameter. If cleanup_process is None then process_name is used as the
-        cleanup target using ensure_application_closed().
-
-        :param process_name: Name of required application process.
-        :param cleanup_process: Name of process to clean up.
-        :param base: custom emulator base for proxy object
-        :return: Proxy object for the desired application.
-
-        """
-        if not cleanup_process:
-            cleanup_process = process_name
-        proxy = autopilot_helpers.get_proxy_object_for_existing_process(
-            process_name,
-            base)
-        self.addCleanup(ensure_application_closed, cleanup_process)
-        return proxy
-
-    def _get_proxy_object_for_existing_qmlscene_process(self, qmlfile):
-        """
-        Return proxy object from existing qmlscene process.
-
-        Add cleanup action to close the application using cleanup_process
-        parameter. If cleanup_process is None then process_id is used as the
-        cleanup target using processes.stop_qmlscene_process().
-
-        :param qmlfile: Thje name of the QML file for the required process
-        :return: Proxy object for the desired qmlscene process
-
-        """
-        process_id = processes.get_qmlscene_process_id(qmlfile)
-        proxy = introspection.get_proxy_object_for_existing_process(
-            pid=process_id,
-            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase
-        )
-        self.addCleanup(processes.stop_qmlscene_process, qmlfile)
-        return proxy
-
-    def _get_proxy_object_for_existing_webapp(self, qmlfile):
-        """
-        Return proxy object from existing qmlscene process.
-
-        Add cleanup action to close the application using cleanup_process
-        parameter. If cleanup_process is None then process_id is used as the
-        cleanup target using processes.stop_qmlscene_process().
-
-        :param qmlfile: Thje name of the QML file for the required process
-        :return: Proxy object for the desired qmlscene process
-
-        """
-        process_id = processes.get_qmlscene_process_id(qmlfile)
-        proxy = introspection.get_proxy_object_for_existing_process(
-            pid=process_id,
-            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase
-        )
-        self.addCleanup(processes.stop_qmlscene_process, qmlfile)
-        return proxy
-
-    def launch_address_book(self):
-        """
-        Launch the address book app from apps scope and return proxy object.
-
-        :return: Proxy object for address book application.
-
-        """
-        self._launch_application_from_apps_scope(
-            'Contacts', CATEGORY_PREDEFINED)
-        return self.get_address_book_app_proxy()
-
-    def close_address_book(self):
-        """ Close the address book app using task switcher """
-        if self.is_address_book_app_running():
-            self._close_app('address-book-app')
-
-    def is_address_book_app_running(self):
-        """ Indicate if the address book app is currently running """
-        return processes.is_process_running('address-book-app')
-
-    def launch_address_book_from_launcher(self):
-        """Drag out the launcher and tap the address book icon to start it."""
-        self._launch_application_from_launcher('address-book-app')
-        return self.get_address_book_app_proxy()
-
-    def get_address_book_app_proxy(self):
-        """
-        Return address book app proxy object from existing process.
-
-        :return: Proxy object for address book application.
-
-        """
-        from ubuntu_system_tests.helpers.addressbook import _cpo  # NOQA
-        wait_until(self.is_address_book_app_running, period=0.5)
-        proxy = self._get_proxy_object_for_existing_app('address-book-app')
-        return proxy.main_window
-
-    def launch_camera_app(self):
-        """
-        Launch the camera app from dash and return proxy object.
-
-        :return: Proxy object for camera application.
-
-        """
-        self._launch_application_from_apps_scope('Camera', CATEGORY_PREDEFINED)
-        return self.get_camera_app_proxy()
-
-    def close_camera_app(self):
-        """ Close the camera app using task switcher """
-        if self.is_camera_app_running():
-            self._close_app('com.ubuntu.camera_camera')
-
-    def is_camera_app_running(self):
-        """ Indicate if the camera app is currently running """
-        return processes.is_process_running('camera-app')
-
-    def launch_camera_app_from_launcher(self):
-        """Drag out the launcher and tap the camera icon to start it."""
-        self._launch_application_from_launcher('com.ubuntu.camera_camera')
-        return self.get_camera_app_proxy()
-
-    def get_camera_app_proxy(self):
-        """
-        Return camera app proxy object from existing process and add
-        cleanup actions to close the application.
-
-        :return: Proxy object for camera application.
-
-        """
-        from ubuntu_system_tests.helpers.camera._cpo import MainWindow
-        wait_until(self.is_camera_app_running, period=0.5)
-        proxy = self._get_proxy_object_for_existing_app(
-            'camera-app',
-            cleanup_process=click.get_click_app_identifier('com.ubuntu.camera')
-        )
-        return MainWindow(proxy)
-
-    def launch_dialer_app(self):
-        """
-        Launch the dialer app from apps scope and return proxy object.
-
-        :return: Proxy object for dialer application.
-
-        """
-        self._launch_application_from_apps_scope('Phone', CATEGORY_PREDEFINED)
-        return self.get_dialer_app_proxy()
-
-    def close_dialer_app(self):
-        """ Close the dialer app using task switcher """
-        if self.is_dialer_app_running():
-            self._close_app('dialer-app')
-
-    def is_dialer_app_running(self):
-        """ Indicate if the dialer app is currently running """
-        return processes.is_process_running('dialer-app')
-
-    def get_dialer_app_proxy(self):
-        """
-        Return dialer app proxy object from existing process.
-
-        :return: Proxy object for dialer application.
-
-        """
-        from ubuntu_system_tests.helpers.dialer_app import _cpo  # NOQA
-        wait_until(self.is_dialer_app_running, period=0.5)
-        proxy = self._get_proxy_object_for_existing_app('dialer-app')
-        return proxy.main_view
-
-    def launch_gallery_app(self):
-        """
-        Launch the gallery app from apps scope and return proxy object.
-
-        :return: Proxy object for gallery application.
-
-        """
-        from ubuntu_system_tests.helpers.gallery._cpo import EventsView
-        self._launch_application_from_apps_scope('Gallery', CATEGORY_LOCAL)
-        return EventsView(self.get_gallery_app_proxy())
-
-    def close_gallery_app(self):
-        """ Close the gallery app using task switcher """
-        if self.is_gallery_app_running():
-            self._close_app('com.ubuntu.gallery_gallery')
-
-    def is_gallery_app_running(self):
-        """ Indicate if the gallery app is currently running """
-        return processes.is_process_running('gallery-app')
-
-    def get_gallery_app_proxy(self):
-        """
-        Return gallery app proxy object from existing process.
-
-        :return: Proxy object for gallery application.
-
-        """
-        wait_until(self.is_gallery_app_running, period=0.5)
-        proxy = self._get_proxy_object_for_existing_app(
-            'gallery-app',
-            cleanup_process=click.get_click_app_identifier(
-                'com.ubuntu.gallery'))
-        return proxy
-
-    def get_gallery_events_view(self):
-        """Return a gallery_app EventsView custom proxy object."""
-        from ubuntu_system_tests.helpers.gallery._cpo import EventsView
-        return EventsView(self.get_gallery_app_proxy())
-
-    def get_gallery_photo_viewer(self):
-        """Return a gallery_app PhotoViewer custom proxy object."""
-        from ubuntu_system_tests.helpers.gallery._cpo import PhotoViewer
-        return PhotoViewer(self.get_gallery_app_proxy())
-
-    def get_media_player_proxy(self):
-        """
-        Return media player app proxy object from existing process.
-
-        :return: Proxy object for media player application.
-
-        """
-        from ubuntu_system_tests.helpers.mediaplayer._cpo import MainWindow
-        proxy = self._get_proxy_object_for_existing_app('mediaplayer-app')
-        return MainWindow(proxy)
-
-    def launch_messaging_app(self):
-        """
-        Launch the messaging app from apps scope and return proxy object.
-
-        :return: Proxy object for messaging application.
-
-        """
-        self._launch_application_from_apps_scope(
-            'Messaging', CATEGORY_PREDEFINED)
-        return self.get_messaging_app_proxy()
-
-    def close_messaging_app(self):
-        """ Close the messaging app using task switcher """
-        if self.is_messaging_app_running():
-            self._close_app('messaging-app')
-
-    def is_messaging_app_running(self):
-        """ Indicate if the messaging app is currently running """
-        return processes.is_process_running('messaging-app')
-
-    def get_messaging_app_proxy(
-            self, base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase):
-        """
-        Return messaging app proxy object from existing process.
-
-        :return: Proxy object for messaging application.
-
-        """
-        wait_until(self.is_messaging_app_running, period=0.5)
-        if not base:
-            return self._get_proxy_object_for_existing_app('messaging-app',
-                                                           base=base)
-
-        from ubuntu_system_tests.helpers.messaging._cpo import MainView
-        proxy = self._get_proxy_object_for_existing_app('messaging-app')
-        return proxy.wait_select_single(MainView)
-
-    def launch_system_settings(self):
-        """
-        Launch system settings from apps scope and return proxy object.
-
-        :return: Proxy object for system settings.
-
-        """
-        self._launch_application_from_apps_scope(
-            'System Settings', CATEGORY_LOCAL)
-        return self.get_system_settings_proxy()
-
-    def close_system_settings(self):
-        """ Close the system settings app using task switcher """
-        if self.is_system_settings_running():
-            self._close_app('ubuntu-system-settings')
-
-    def is_system_settings_running(self):
-        """ Indicate if the system settings is currently running """
-        return processes.is_process_running('system-settings')
-
-    def get_system_settings_proxy(self):
-        """
-        Return system settings proxy object from existing process.
-
-        :return: Proxy object for system settings.
-
-        """
-        from ubuntu_system_tests.helpers.system_settings import _cpo  # NOQA
-        wait_until(self.is_system_settings_running, period=0.5)
-        proxy = self._get_proxy_object_for_existing_app(
-            'system-settings', cleanup_process='ubuntu-system-settings')
-        return proxy.main_view
-
-    def launch_webbrowser_app(self):
-        """
-        Launch the webbrowser app from apps scope and return proxy object.
-
-        :return: Proxy object for webbrowser application.
-
-        """
-        self._launch_application_from_apps_scope(
-            'Browser', CATEGORY_PREDEFINED)
-        return self.get_webbrowser_app_proxy()
-
-    def close_webbrowser_app(self):
-        """ Close the webbrowser app using task switcher """
-        if self.is_webbrowser_app_running():
-            self._close_app('webbrowser-app')
-
-    def is_webbrowser_app_running(self):
-        """ Indicate if the webbrowser app is currently running """
-        return processes.is_process_running('webbrowser-app')
-
-    def get_webbrowser_app_proxy(self):
-        """
-        Return webbrowser app proxy object from existing process.
-
-        :return: Proxy object for webbrowser application.
-
-        """
-        from ubuntu_system_tests.helpers.webbrowser import _cpo  # NOQA
-        wait_until(self.is_webbrowser_app_running, period=0.5)
-        proxy = self._get_proxy_object_for_existing_app('webbrowser-app')
-        return proxy.main_window
-
-    def launch_calendar_app(self):
-        """
-        Launch the calendar app from apps scope and return proxy object.
-
-        :return: Proxy object for calendar application.
-
-        """
-        self._launch_application_from_apps_scope('Calendar', CATEGORY_LOCAL)
-        wait_until(self.is_calendar_app_running, period=0.5)
-
-        return self.get_calendar_app_proxy()
-
-    def close_calendar_app(self):
-        """ Close the calendar app using task switcher """
-        if self.is_calendar_app_running():
-            self._close_app('calendar')
-
-    def is_calendar_app_running(self):
-        """ Indicate if the calendar app is currently running """
-        return processes.is_qmlscene_running_with_qmlfile('calendar')
-
-    def get_calendar_app_proxy(self):
-        """
-        Return calendar app proxy object from existing process.
-
-        :return: Proxy object for calendar application.
-
-        """
-        proxy = self._get_proxy_object_for_existing_qmlscene_process(
-            'calendar')
-        return proxy.main_window
-
-    def launch_clock_app(self):
-        """
-        Launch the clock app from apps scope and return proxy object.
-
-        :return: Proxy object for clock application.
-
-        """
-        self._launch_application_from_apps_scope('Clock', CATEGORY_PREDEFINED)
-        wait_until(self.is_clock_app_running, period=0.5)
-        return self.get_clock_app_proxy()
-
-    def close_clock_app(self):
-        """ Close the calendar app using task switcher """
-        if self.is_clock_app_running():
-            self._close_app('com.ubuntu.clock_clock')
-
-    def is_clock_app_running(self):
-        """ Indicate if the clock app is currently running """
-        return processes.is_qmlscene_running_with_qmlfile('ubuntu-clock-app')
-
-    def get_clock_app_proxy(self):
-        """
-        Return clock app proxy object from existing process.
-
-        :return: Proxy object for calendar application.
-
-        """
-        from ubuntu_system_tests.helpers.clock import _cpo  # NOQA
-        proxy = self._get_proxy_object_for_existing_qmlscene_process(
-            'ubuntu-clock-app')
-        return proxy.main_view
-
-    def launch_webbrowser_from_launcher(self):
-        """Start webbrowser from the launcher."""
-        self._launch_application_from_launcher('webbrowser-app')
-        return self.get_webbrowser_app_proxy()
-
-    def launch_messaging_app_from_launcher(self):
-        """Drag out the launcher and tap the messaging app icon to start it."""
-        self._launch_application_from_launcher('messaging-app')
-        return self.get_messaging_app_proxy()
-
-    def launch_dialer_app_from_launcher(self):
-        """Drag out the launcher and tap the dialer app icon to start it."""
-        self._launch_application_from_launcher('dialer-app')
-        return self.get_dialer_app_proxy()
-
-    def launch_gallery_app_from_launcher(self):
-        """Drag out the launcher and tap the gallery app icon to start it."""
-        self._launch_application_from_launcher('com.ubuntu.gallery_gallery')
-        return self.get_gallery_app_proxy()
-
-    def get_webapp_proxy(self, web_app_package):
-        """ Return webapp proxy object from existing process.
-        :param web_app_package: The package name
-        :return: Proxy object for webapp.
-        """
-        from ubuntu_system_tests.helpers.webapp import _cpo  # NOQA
-
-        pid = webapp.get_webapp_pid(web_app_package)
-        proxy = introspection.get_proxy_object_for_existing_process(
-            pid=pid,
-            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase
-        )
-        return proxy.wait_select_single('BrowserWindow')
-
     def setup_webapp_environment(self):
         """ Setup the environment for the webapps. This method has to be
         called before launch the first web app in the test.
@@ -715,128 +244,3 @@
             UBUNTU_WEBVIEW_DEVTOOLS_HOST=webapp.DEFAULT_WEBVIEW_INSPECTOR_IP,
             UBUNTU_WEBVIEW_DEVTOOLS_PORT=str(
                 webapp.DEFAULT_WEBVIEW_INSPECTOR_PORT)))
-
-    def launch_webapp(self, app_name, web_app_package):
-        """ Launch the webapp and return the webapp proxy object
-        :param app_name: The name in the apps scope
-        :param web_app_package: The package name
-        :return: Proxy object for webapp
-        """
-        apps_scope = go_to_apps_scope()
-        apps_scope.click_scope_item(CATEGORY_LOCAL, app_name)
-        self.addCleanup(webapp.ensure_webapp_closed, web_app_package)
-        wait_until(webapp.is_webapp_runing, web_app_package)
-        return self.get_webapp_proxy(web_app_package)
-
-    def launch_calculator_app(self):
-        """
-        Launch calculator app from apps scope and return its proxy object.
-        """
-        self._launch_application_from_apps_scope(
-            'Calculator', CATEGORY_LOCAL)
-        wait_until(self.is_calculator_app_running, period=0.5)
-        return self.get_calculator_app_proxy()
-
-    def close_calculator_app(self):
-        """ Close the calculator app using task switcher """
-        if self.is_calculator_app_running():
-            self._close_app('com.ubuntu.calculator_calculator')
-
-    def is_calculator_app_running(self):
-        """ Indicate if the calculator app is currently running """
-        return processes.is_qmlscene_running_with_qmlfile(
-            'ubuntu-calculator-app')
-
-    def get_calculator_app_proxy(self):
-        """Return the proxy object of the calculator app."""
-        from ubuntu_system_tests.helpers.calculator import _cpo  # NOQA
-        proxy = self._get_proxy_object_for_existing_qmlscene_process(
-            CALCULATOR_APP)
-        return proxy.main_view
-
-    def get_ubuntu_keyboard_proxy(self):
-        from ubuntu_system_tests.helpers.ubuntu_keyboard import _cpo  # NOQA
-        return self._get_proxy_object_for_existing_app('maliit-server')
-
-    def launch_ebay_webapp(self):
-        """ Launch the Ebay webapp from apps scope and return its proxy object
-        """
-        webapp_name = 'eBay'
-        webapp_package = 'com.ubuntu.developer.webapps.webapp-ebay'
-        return self.launch_webapp(webapp_name, webapp_package)
-
-    def close_ebay_webapp(self):
-        """ Close the ebay webapp using task switcher """
-        if self.is_ebay_webapp_running():
-            self._close_app(
-                'com.ubuntu.developer.webapps.webapp-ebay_webapp-ebay')
-
-    def is_ebay_webapp_running(self):
-        """ Indicate if the ebay webapp is currently running """
-        webapp_package = 'com.ubuntu.developer.webapps.webapp-ebay'
-        return webapp.is_webapp_runing(webapp_package)
-
-    def launch_here_webapp(self):
-        """ Launch the Here webapp from apps scope and return its proxy object
-        """
-        webapp_name = 'HERE Maps'
-        webapp_package = 'com.nokia.heremaps'
-        return self.launch_webapp(webapp_name, webapp_package)
-
-    def close_here_webapp(self):
-        """ Close the here webapp using task switcher """
-        if self.is_here_webapp_running():
-            self._close_app('com.nokia.heremaps_here')
-
-    def is_here_webapp_running(self):
-        """ Indicate if the here webapp is currently running """
-        webapp_package = 'com.nokia.heremaps'
-        return webapp.is_webapp_runing(webapp_package)
-
-    def launch_music_app(self):
-        """
-        Launch the music app from apps scope and return proxy object.
-
-        :return: Proxy object for music application.
-
-        """
-        self._launch_application_from_apps_scope('Music')
-        wait_until(self.is_music_app_running, period=0.5)
-        return self.get_music_app_proxy()
-
-    def close_music_app(self):
-        """ Close the music app using task switcher """
-        if self.is_music_app_running():
-            self._close_app('com.ubuntu.music_music')
-
-    def is_music_app_running(self):
-        """ Indicate if the music app is currently running """
-        return processes.is_qmlscene_running_with_qmlfile('music-app')
-
-    def get_music_app_proxy(self):
-        """
-        Return music app proxy object from existing process.
-
-        :return: Proxy object for music application.
-
-        """
-        proxy = self._get_proxy_object_for_existing_qmlscene_process(
-            'music-app')
-        return proxy.wait_select_single(ubuntuuitoolkit.MainView)
-
-    def _close_app(self, app_name):
-        """Close an app using task switcher and check process is stopped."""
-        unity_proxy = self.get_job_proxy_object('unity8')
-
-        # Get the windows name
-        stage = unity_proxy.main_window.swipe_to_show_app_switcher()
-        app_window_name = 'appWindow_' + app_name
-        app_windows = stage.get_app_window_names()
-        count = len(app_windows)
-        self.assertTrue(app_window_name in app_windows)
-
-        # Close the windows and assert that it is closed
-        stage.close_app(app_name)
-        app_windows = stage.get_app_window_names()
-        self.assertFalse(app_window_name in app_windows)
-        self.assertEqual(len(app_windows), count - 1)

=== modified file 'ubuntu_system_tests/tests/base_messaging.py'
--- ubuntu_system_tests/tests/base_messaging.py	2015-12-22 17:34:23 +0000
+++ ubuntu_system_tests/tests/base_messaging.py	2016-02-10 11:57:12 +0000
@@ -25,20 +25,17 @@
     Contact,
     fixture_setup as address_book_fixture
 )
+from ubuntu_system_tests.helpers import camera
 from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers import gallery
 from ubuntu_system_tests.helpers.messaging import fixture_setup
 from ubuntu_system_tests.helpers import messaging as messaging_helpers
+from ubuntu_system_tests.helpers import processes
 from ubuntu_system_tests.helpers import system_settings
-from ubuntu_system_tests.helpers.system_settings import SETTINGS_PROCESS
 from ubuntu_system_tests.helpers.unity8 import get_dash
 from ubuntu_system_tests.helpers import wait_until
 from ubuntu_system_tests.tests.base_telephony import BaseTelephonyTestCase
 
-CAMERA_APP = 'Camera'
-CAMERA_PROCESS = 'camera-app'
-GALLERY_APP = 'Gallery'
-GALLERY_PROCESS = 'gallery-app'
-
 CONTACT_NAME_1 = 'Fulano de Tal'
 REPLY_1 = 'ACK'
 
@@ -63,7 +60,7 @@
 
     def launch_messaging(self):
         """Launch the messaging app from apps scope."""
-        self.main_view = self.launch_messaging_app()
+        self.main_view = messaging_helpers.launch_messaging_app()
 
     def get_messaging_app(self):
         """
@@ -71,7 +68,7 @@
         Store proxy object in self.main_view.
 
         """
-        self.main_view = self.get_messaging_app_proxy()
+        self.main_view = messaging_helpers.get_messaging_app_proxy()
 
     def receive_message_and_get_notification(self, to, from_, message,
                                              media_url=None, timeout=60):
@@ -463,25 +460,25 @@
 
     def _add_attachment_from_gallery(self, attachment):
         """Add an attachment using the gallery app."""
-        self._open_app_to_attach_content(GALLERY_APP)
-        gallery_app = self.get_gallery_events_view()
-        self.addCleanup(self.ensure_application_closed, GALLERY_PROCESS)
+        self._open_app_to_attach_content(gallery.APP_NAME)
+        gallery_app = gallery.get_gallery_events_view()
+        self.addCleanup(processes.ensure_application_closed, gallery.APP)
         sample_photo_location = os.path.join(fs.DIR_HOME_CAMERA_PICTURES,
                                              attachment.identifier)
         gallery_app.pick_photo(sample_photo_location)
 
     def _add_attachment_from_camera(self, attachment):
         """Add an attachment using the camera app."""
-        self._open_app_to_attach_content(CAMERA_APP)
-        camera_app = self.get_camera_app_proxy()
-        self.addCleanup(self.ensure_application_closed, CAMERA_PROCESS)
+        self._open_app_to_attach_content(camera.APP_NAME)
+        camera_app = camera.get_camera_app_proxy()
+        self.addCleanup(processes.ensure_application_closed, camera.APP)
         camera_app.take_photo_and_select()
 
     def _add_attachment_from_camera_photoroll(self, attachment):
         """Add an attachment using the camera app photoroll."""
-        self._open_app_to_attach_content(CAMERA_APP)
-        camera_app = self.get_camera_app_proxy()
-        self.addCleanup(self.ensure_application_closed, CAMERA_PROCESS)
+        self._open_app_to_attach_content(camera.APP_NAME)
+        camera_app = camera.get_camera_app_proxy()
+        self.addCleanup(processes.ensure_application_closed, camera.APP)
         camera_app.swipe_to_gallery(self)
         camera_app.select_photo_from_roll()
 
@@ -495,7 +492,7 @@
         :param value: Value to set: 'ask', '1' or '2' (sim slot)
 
         """
-        settings = self.launch_system_settings()
+        settings = system_settings.launch_system_settings()
         cellular = settings.go_to_cellular_page()
 
         if value is '1' or value is '2':
@@ -505,7 +502,8 @@
         settings.scroll_to_and_click(selector)
         selector.selected.wait_for(True)
         self.dash.swipe_screen_from_left()
-        self.addCleanup(self.ensure_application_closed, SETTINGS_PROCESS)
+        self.addCleanup(processes.ensure_application_closed,
+                        system_settings.APP)
 
     def click_message_url(self, message_text):
         """Click the message text in a message bubble."""

=== modified file 'ubuntu_system_tests/tests/base_webbrowser.py'
--- ubuntu_system_tests/tests/base_webbrowser.py	2015-11-16 12:15:59 +0000
+++ ubuntu_system_tests/tests/base_webbrowser.py	2016-02-10 11:57:12 +0000
@@ -18,6 +18,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+from ubuntu_system_tests.helpers import webbrowser
 from ubuntu_system_tests.helpers.webbrowser.fixture_setup import (
     WebbrowserTestEnvironment)
 from ubuntu_system_tests.tests import base
@@ -29,7 +30,7 @@
         super().setUp()
         self.useFixture(WebbrowserTestEnvironment())
         self.unity_proxy = self.restart_unity()
-        self.browser = self.launch_webbrowser_app()
+        self.browser = webbrowser.launch_webbrowser_app()
 
     def _get_current_url(self):
         """Return currently opened url."""

=== modified file 'ubuntu_system_tests/tests/indicators/test_indicator_battery.py'
--- ubuntu_system_tests/tests/indicators/test_indicator_battery.py	2016-01-15 11:19:35 +0000
+++ ubuntu_system_tests/tests/indicators/test_indicator_battery.py	2016-02-10 11:57:12 +0000
@@ -55,7 +55,7 @@
         3. Ensure battery settings open.
         """
         self.indicator_page.open_battery_settings()
-        settings_app = self.get_system_settings_proxy()
+        settings_app = system_settings.get_system_settings_proxy()
         system_settings.ensure_power_settings_page_visible(settings_app)
 
     @skipUnless(platform.image_codename() in SUPPORTED_DEVICES,

=== modified file 'ubuntu_system_tests/tests/indicators/test_indicator_bluetooth.py'
--- ubuntu_system_tests/tests/indicators/test_indicator_bluetooth.py	2015-09-14 16:31:29 +0000
+++ ubuntu_system_tests/tests/indicators/test_indicator_bluetooth.py	2016-02-10 11:57:12 +0000
@@ -41,6 +41,6 @@
         3. Ensure bluetooth settings open
         """
         self.indicator_page.open_bluetooth_settings()
-        settings_app = self.get_system_settings_proxy()
+        settings_app = system_settings.get_system_settings_proxy()
         system_settings.ensure_settings_page_visible(settings_app,
                                                      BLUETOOTH_SETTINGS_PAGE)

=== modified file 'ubuntu_system_tests/tests/indicators/test_indicator_datetime.py'
--- ubuntu_system_tests/tests/indicators/test_indicator_datetime.py	2015-09-14 16:31:29 +0000
+++ ubuntu_system_tests/tests/indicators/test_indicator_datetime.py	2016-02-10 11:57:12 +0000
@@ -41,6 +41,6 @@
         3. Ensure date time settings open.
         """
         self.indicator_page.open_date_time_settings()
-        settings_app = self.get_system_settings_proxy()
+        settings_app = system_settings.get_system_settings_proxy()
         system_settings.ensure_settings_page_visible(settings_app,
                                                      DATETIME_SETTINGS_PAGE)

=== modified file 'ubuntu_system_tests/tests/indicators/test_indicator_network.py'
--- ubuntu_system_tests/tests/indicators/test_indicator_network.py	2015-10-22 14:58:41 +0000
+++ ubuntu_system_tests/tests/indicators/test_indicator_network.py	2016-02-10 11:57:12 +0000
@@ -21,8 +21,8 @@
 from testtools.matchers import Equals, NotEquals
 from testtools import skipUnless
 
+from ubuntu_system_tests.helpers.autopilot.platform import is_wifi_supported
 from ubuntu_system_tests.helpers import (
-    autopilot,
     ofono,
     radio_killswitch,
     network,
@@ -49,7 +49,7 @@
 
 class FlightModeTestCase(NetworkIndicatorBase):
 
-    @skipUnless(ofono.is_sim_inserted() and autopilot.is_wifi_supported(),
+    @skipUnless(ofono.is_sim_inserted() and is_wifi_supported(),
                 'SIM and Wi-Fi support required.')
     def setUp(self):
         self.radio_killswitch = self.useFixture(
@@ -168,7 +168,7 @@
         3. Ensure cellular settings open
         """
         self.indicator_page.open_cellular_settings()
-        settings_app = self.get_system_settings_proxy()
+        settings_app = system_settings.get_system_settings_proxy()
         system_settings.ensure_settings_page_visible(settings_app,
                                                      CELLULAR_SETTINGS_PAGE)
 
@@ -179,6 +179,6 @@
         3. Ensure Wifi settings open
         """
         self.indicator_page.open_wifi_settings()
-        settings_app = self.get_system_settings_proxy()
+        settings_app = system_settings.get_system_settings_proxy()
         system_settings.ensure_settings_page_visible(settings_app,
                                                      WIFI_SETTINGS_PAGE)

=== modified file 'ubuntu_system_tests/tests/indicators/test_indicator_sound.py'
--- ubuntu_system_tests/tests/indicators/test_indicator_sound.py	2015-09-14 16:31:29 +0000
+++ ubuntu_system_tests/tests/indicators/test_indicator_sound.py	2016-02-10 11:57:12 +0000
@@ -41,6 +41,6 @@
         3. Ensure sound settings open
         """
         self.indicator_page.open_sound_settings()
-        settings_app = self.get_system_settings_proxy()
+        settings_app = system_settings.get_system_settings_proxy()
         system_settings.ensure_settings_page_visible(settings_app,
                                                      SOUND_SETTINGS_PAGE)

=== modified file 'ubuntu_system_tests/tests/scopes/test_default_scopes.py'
--- ubuntu_system_tests/tests/scopes/test_default_scopes.py	2016-01-05 15:28:08 +0000
+++ ubuntu_system_tests/tests/scopes/test_default_scopes.py	2016-02-10 11:57:12 +0000
@@ -21,7 +21,10 @@
 import shutil
 
 from testtools import skipUnless
-from ubuntu_system_tests.helpers import autopilot
+
+from ubuntu_system_tests.helpers.autopilot.platform import (
+    get_device_name, get_channel_name
+)
 from ubuntu_system_tests.helpers import file_system as fs
 from ubuntu_system_tests.helpers import scopes
 from ubuntu_system_tests.helpers.location import (
@@ -59,7 +62,7 @@
     def setUp(self):
         super().setUp()
         logger.info('Running test using channel: {c} and device: {d}'.format(
-            c=autopilot.get_channel_name(), d=autopilot.get_device_name()))
+            c=get_channel_name(), d=get_device_name()))
 
 
 class ScopeHeadingTest(DefaultScopeTest):

=== modified file 'ubuntu_system_tests/tests/scopes/test_photos_scope.py'
--- ubuntu_system_tests/tests/scopes/test_photos_scope.py	2016-01-05 15:36:10 +0000
+++ ubuntu_system_tests/tests/scopes/test_photos_scope.py	2016-02-10 11:57:12 +0000
@@ -22,6 +22,7 @@
 
 from testtools import skipUnless
 from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers import gallery
 from ubuntu_system_tests.helpers import scopes
 from ubuntu_system_tests.helpers.scopes import go_to_photos_scope
 from ubuntu_system_tests.helpers import timedate
@@ -120,7 +121,7 @@
         preview.click_open_button()
 
         # The gallery opens
-        photo_viewer = self.get_gallery_photo_viewer()
+        photo_viewer = gallery.get_gallery_photo_viewer()
         self.assertIn(local_storage_pic_file_path,
                       photo_viewer.get_image_source())
 

=== modified file 'ubuntu_system_tests/tests/scopes/test_video_scope.py'
--- ubuntu_system_tests/tests/scopes/test_video_scope.py	2016-01-26 18:36:22 +0000
+++ ubuntu_system_tests/tests/scopes/test_video_scope.py	2016-02-10 11:57:12 +0000
@@ -131,10 +131,10 @@
 
         # Validate the webbrowser is launched by clicking in the play button
         preview.play_video()
-        self.assertTrue(wait_until(self.is_webbrowser_app_running))
+        self.assertTrue(wait_until(webbrowser.is_webbrowser_app_running))
 
         # Validate the url opened in the webbrowser is youtube
-        browser = self.get_webbrowser_app_proxy()
+        browser = webbrowser.get_webbrowser_app_proxy()
         self.assertIn('youtube', browser.get_current_url())
 
         # Validate the webbrowser was invoked with the correct video id
@@ -166,7 +166,7 @@
         preview.play_video()
 
         self.assertTrue(wait_until(mediaplayer.is_mediaplayer_running))
-        media_player = self.get_media_player_proxy()
+        media_player = mediaplayer.get_media_player_proxy()
         self.assertEqual(fs.get_file_path(test_data.LOCAL_VIDEO_FILE_2),
                          media_player.get_player().source)
 

=== modified file 'ubuntu_system_tests/tests/test_add_contact.py'
--- ubuntu_system_tests/tests/test_add_contact.py	2016-01-22 11:51:00 +0000
+++ ubuntu_system_tests/tests/test_add_contact.py	2016-02-10 11:57:12 +0000
@@ -24,8 +24,10 @@
 from address_book_app.address_book.data import Phone, Contact
 
 from ubuntu_system_tests.tests import base
+from ubuntu_system_tests.helpers import addressbook
 from ubuntu_system_tests.helpers.addressbook import (
     fixture_setup as addressbook_fixtures)
+from ubuntu_system_tests.helpers import dialer_app
 
 FIRST_NAME = 'Fulano'
 LAST_NAME = 'de Tal'
@@ -53,7 +55,7 @@
         test_contact_name = (
             test_contact.first_name + ' ' + test_contact.last_name)
 
-        address_book = self.launch_address_book()
+        address_book = addressbook.launch_address_book()
 
         # Add new contact.
         contact_editor = address_book.go_to_add_contact()
@@ -91,7 +93,7 @@
         3. Create a new contact with pre-filled number
         4. Ensure the newly saved contact is shown in the contacts list
         """
-        self.dialer_app = self.launch_dialer_app()
+        self.dialer_app = dialer_app.launch_dialer_app()
         contact_name = '{} {}'.format(FIRST_NAME, LAST_NAME)
         self.dialer_app.dialer_page.dial_number_add_new_contact(
             TYPED_MOBILE, FORMATTED_MOBILE)

=== modified file 'ubuntu_system_tests/tests/test_app_switcher.py'
--- ubuntu_system_tests/tests/test_app_switcher.py	2016-01-11 15:03:07 +0000
+++ ubuntu_system_tests/tests/test_app_switcher.py	2016-02-10 11:57:12 +0000
@@ -18,9 +18,13 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from ubuntu_system_tests.helpers import wait_until
+from ubuntu_system_tests.helpers import addressbook
+from ubuntu_system_tests.helpers import camera
 from ubuntu_system_tests.helpers.camera import fixture_setup as camera_fixture
+from ubuntu_system_tests.helpers import dialer_app
+from ubuntu_system_tests.helpers import messaging
 from ubuntu_system_tests.helpers.processes import is_process_running
+from ubuntu_system_tests.helpers import wait_until
 
 from ubuntu_system_tests.tests import base
 
@@ -69,10 +73,10 @@
         """Launch test applications and open the task switcher
         :return: PhoneStage task switcher object.
         """
-        self.launch_dialer_app_from_launcher()
-        self.launch_messaging_app_from_launcher()
-        self.launch_address_book_from_launcher()
-        self.launch_camera_app_from_launcher()
+        dialer_app.launch_dialer_app_from_launcher()
+        messaging.launch_messaging_app_from_launcher()
+        addressbook.launch_address_book_from_launcher()
+        camera.launch_camera_app_from_launcher()
         stage = self.shell.swipe_to_show_app_switcher()
         stage.swipe_to_top()
         apps = stage.get_app_window_names()

=== modified file 'ubuntu_system_tests/tests/test_bluetooth.py'
--- ubuntu_system_tests/tests/test_bluetooth.py	2015-09-07 11:10:31 +0000
+++ ubuntu_system_tests/tests/test_bluetooth.py	2016-02-10 11:57:12 +0000
@@ -22,6 +22,7 @@
 
 from ubuntu_system_tests.helpers import bluetooth
 from ubuntu_system_tests.helpers import indicators
+from ubuntu_system_tests.helpers import system_settings
 from ubuntu_system_tests.tests import base
 
 BLUETOOTH_INDICATOR = 'indicator-bluetooth'
@@ -36,7 +37,7 @@
         """ Go to Bluetooth page """
         super(BluetoothTestCase, self).setUp()
         self.unity_proxy = self.restart_unity()
-        self.app = self.launch_system_settings()
+        self.app = system_settings.launch_system_settings()
         self.bluetooth_page = self.app.go_to_bluetooth_page()
 
     def test_discover_bluetooth_devices(self):

=== modified file 'ubuntu_system_tests/tests/test_calculator.py'
--- ubuntu_system_tests/tests/test_calculator.py	2015-10-30 11:52:23 +0000
+++ ubuntu_system_tests/tests/test_calculator.py	2016-02-10 11:57:12 +0000
@@ -17,6 +17,7 @@
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals
 
+from ubuntu_system_tests.helpers import calculator
 from ubuntu_system_tests.tests import base
 
 
@@ -25,7 +26,7 @@
     def setUp(self):
         super().setUp()
         self.unity_proxy = self.restart_unity()
-        self.calculator = self.launch_calculator_app()
+        self.calculator = calculator.launch_calculator_app()
 
     def test_simple_multiplication(self):
         """Multiply two numbers."""

=== modified file 'ubuntu_system_tests/tests/test_calls.py'
--- ubuntu_system_tests/tests/test_calls.py	2016-02-01 15:50:00 +0000
+++ ubuntu_system_tests/tests/test_calls.py	2016-02-10 11:57:12 +0000
@@ -28,18 +28,21 @@
 from testtools.matchers import Equals
 from threading import Event
 
+from ubuntu_system_tests.helpers import addressbook
 from ubuntu_system_tests.helpers.addressbook import(
     Contact,
     fixture_setup as address_book_fixture
 )
+from ubuntu_system_tests.helpers import dialer_app as dialer
+from ubuntu_system_tests.helpers.dialer_app import fixture_setup as dialer_fixture_setup  # NOQA
 from ubuntu_system_tests.helpers import display
 from ubuntu_system_tests.helpers import indicators
-from ubuntu_system_tests.helpers import ofono
-from ubuntu_system_tests.helpers.dialer_app import fixture_setup
 from ubuntu_system_tests.helpers.mediaplayer import start_media_player_observer
 from ubuntu_system_tests.helpers.messaging.fixture_setup import (
     MessagingTestEnvironment)
 from ubuntu_system_tests.helpers import network
+from ubuntu_system_tests.helpers import ofono
+from ubuntu_system_tests.helpers.ofono import fixture_setup as ofono_fixture_setup  # NOQA
 from ubuntu_system_tests.helpers.power.fixture_setup import (
     EnablePowerdFakeSensors)
 from ubuntu_system_tests.helpers.indicators import(
@@ -49,6 +52,8 @@
 from ubuntu_system_tests.helpers.system_settings.fixture_setup import SilentMode  # NOQA
 from ubuntu_system_tests.helpers.timedate import get_current_utc_time
 from ubuntu_system_tests.helpers.vibration import start_vibration_observer
+from ubuntu_system_tests.helpers import webbrowser
+
 from ubuntu_system_tests.tests.base import wait_until
 from ubuntu_system_tests.tests.base_telephony import BaseTelephonyTestCase
 
@@ -93,7 +98,7 @@
         # enable fake proximity sensors prior to restarting unity8
         self.useFixture(EnablePowerdFakeSensors())
         super().setUp()
-        self.useFixture(fixture_setup.DialerTestEnvironment())
+        self.useFixture(dialer_fixture_setup.DialerTestEnvironment())
         self.useFixture(SilentMode(False))
         self.contact_1 = Contact(name=CONTACT_NAME_1,
                                  number=self.get_telephony_service_number1())
@@ -236,11 +241,11 @@
         """
         self.start_notification_observer()
         start_time = get_current_utc_time()
-        address_book = self.launch_address_book()
+        address_book = addressbook.launch_address_book()
         contacts_page = address_book.get_contact_list_page()
         contact = contacts_page.open_contact_by_name(required_contact.name)
         contact.call(required_contact.number)
-        dialer_app = self.get_dialer_app_proxy()
+        dialer_app = dialer.get_dialer_app_proxy()
         dialer_app.dialer_page.click_call_button()
         self.addCleanup(ofono.end_call)
         if not wait_until(self.telephony.is_call_active,
@@ -387,7 +392,7 @@
         time.sleep(1)
         call_notifier.start_call()
 
-        call_page = self.get_dialer_app_proxy().live_call_page
+        call_page = dialer.get_dialer_app_proxy().live_call_page
         self._validate_call_started(call_page, self.contact_1.name)
         self.assertTrue(display.is_display_on())
         self._assert_proximity_sensor()
@@ -422,7 +427,7 @@
         call_notifier.wait_until_destroyed()
 
         self._get_missed_call_notification(self.contact_1).call()
-        dialer_page = self.get_dialer_app_proxy().dialer_page
+        dialer_page = dialer.get_dialer_app_proxy().dialer_page
         self.assertThat(dialer_page.get_entered_phone_number(),
                         Eventually(Equals(caller_number)))
 
@@ -464,7 +469,7 @@
         self.shell.get_passphrase_unlock_screen().unlock(
             self.config_stack.get(KEY_DEVICE_PASSWORD))
 
-        dialer_page = self.get_dialer_app_proxy().dialer_page
+        dialer_page = dialer.get_dialer_app_proxy().dialer_page
         self.assertThat(dialer_page.get_entered_phone_number(),
                         Eventually(Equals(caller_number)))
 
@@ -618,13 +623,13 @@
         call_notifier.start_call()
         self.addCleanup(ofono.end_call)
 
-        call_page = self.get_dialer_app_proxy().live_call_page
+        call_page = dialer.get_dialer_app_proxy().live_call_page
         self._validate_call_started(call_page, self.contact_1.name)
 
         return call
 
     def _launch_browser_and_browse_page(self, page_url):
-        browser = self.launch_webbrowser_from_launcher()
+        browser = webbrowser.launch_webbrowser_from_launcher()
         browser.go_to_url(page_url)
         browser.wait_until_page_loaded(page_url)
 
@@ -637,8 +642,8 @@
             status=CALL_INPROGRESS)
 
         # End call from the UI once we check everything.
-        dialer = self.launch_dialer_app_from_launcher()
-        self._end_call_from_live_screen(dialer)
+        dialer_app = dialer.launch_dialer_app_from_launcher()
+        self._end_call_from_live_screen(dialer_app)
 
         self._validate_telephony_call(
             call['sid'],
@@ -701,7 +706,7 @@
         4. Open a website and ensure it opens
         5. Return to the dialer app and end the call
         """
-        self.useFixture(ofono.fixture_setup.ModemForData(0))
+        self.useFixture(ofono_fixture_setup.ModemForData(0))
         phone_number = self.get_device_phone_number()
         call = self._receive_call(phone_number)
         # Disable wifi and enable data connection to browse a website,

=== modified file 'ubuntu_system_tests/tests/test_camera.py'
--- ubuntu_system_tests/tests/test_camera.py	2015-10-27 17:30:04 +0000
+++ ubuntu_system_tests/tests/test_camera.py	2016-02-10 11:57:12 +0000
@@ -26,22 +26,24 @@
 from testtools import skipUnless
 from testtools.matchers import Equals
 
-from ubuntu_system_tests.helpers import autopilot as autopilot_helpers
-from ubuntu_system_tests.helpers import device
-from ubuntu_system_tests.helpers import file_system as fs
-from ubuntu_system_tests.helpers import images
-from ubuntu_system_tests.helpers import videos
+from ubuntu_system_tests.helpers.autopilot.platform import is_camera_supported
 from ubuntu_system_tests.helpers.backup_restore_fixture import (
     BackupRestoreFixture)
 from ubuntu_system_tests.helpers import camera
 from ubuntu_system_tests.helpers.camera.fixture_setup import (
     SetCameraAccessRequests)
+from ubuntu_system_tests.helpers import device
+from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers import images
+
 from ubuntu_system_tests.helpers.location import (
-    fixture_setup as location_fixture
-)
+    fixture_setup as location_fixture)
 from ubuntu_system_tests.helpers.location.coordinates import EIFFEL_TOWER
+from ubuntu_system_tests.helpers import mediaplayer
 from ubuntu_system_tests.helpers.unity8.greeter import show_greeter_with_dbus
+from ubuntu_system_tests.helpers import videos
 from ubuntu_system_tests.helpers import wait_until
+
 from ubuntu_system_tests.tests import base
 
 logger = logging.getLogger(__name__)
@@ -53,7 +55,7 @@
 
 class BaseCameraTestCase(base.BaseUbuntuSystemTestCase):
 
-    @skipUnless(autopilot_helpers.is_camera_supported(), 'Camera-app required')
+    @skipUnless(is_camera_supported(), 'Camera-app required')
     def setUp(self):
         """Backup existing images and settings and launch camera-app."""
         super().setUp()
@@ -64,7 +66,7 @@
         self.useFixture(BackupRestoreFixture(fs.DIR_HOME_CAMERA_PICTURES))
         self.useFixture(BackupRestoreFixture(fs.DIR_HOME_CAMERA_VIDEOS))
         self.useFixture(BackupRestoreFixture(fs.DIR_HOME_CAMERA_THUMBNAILS))
-        self.camera_app = self.launch_camera_app()
+        self.camera_app = camera.launch_camera_app()
 
     def _check_image_not_blank(self, image):
         """Check if the taken image is blank or very limited in colours."""
@@ -164,7 +166,7 @@
         self.camera_app.start_playback()
 
         # Verify the source file in the player is the one recently recorded
-        media_player = self.get_media_player_proxy()
+        media_player = mediaplayer.get_media_player_proxy()
         self.assertEqual(fs.FILE_PREFIX + camera.get_recorded_video(),
                          media_player.get_player().source)
 

=== modified file 'ubuntu_system_tests/tests/test_clock.py'
--- ubuntu_system_tests/tests/test_clock.py	2015-12-21 10:57:24 +0000
+++ ubuntu_system_tests/tests/test_clock.py	2016-02-10 11:57:12 +0000
@@ -25,6 +25,7 @@
 
 from ubuntu_system_tests.helpers.calendar.fixture_setup import (
     BackupRestoreCalendarFixture)
+from ubuntu_system_tests.helpers import clock
 from ubuntu_system_tests.helpers.clock.fixture_setup import (
     SetClockAccessRequests)
 from ubuntu_system_tests.helpers.location import (
@@ -42,7 +43,7 @@
         self.useFixture(SetClockAccessRequests(location=True))
         self.useFixture(BackupRestoreCalendarFixture())
         self.unity_proxy = self.restart_unity()
-        self.clock = self.launch_clock_app()
+        self.clock = clock.launch_clock_app()
 
     def _create_vibration_observer(self):
         """ Create observer used to watch for vibration event """

=== modified file 'ubuntu_system_tests/tests/test_messaging_sms.py'
--- ubuntu_system_tests/tests/test_messaging_sms.py	2016-01-18 10:08:57 +0000
+++ ubuntu_system_tests/tests/test_messaging_sms.py	2016-02-10 11:57:12 +0000
@@ -26,6 +26,7 @@
     Contact,
     fixture_setup as address_book_fixture
 )
+from ubuntu_system_tests.helpers import messaging
 from ubuntu_system_tests.helpers.messaging import(
     Message,
     Search,
@@ -39,6 +40,7 @@
 from ubuntu_system_tests.helpers.indicators import NotificationsIndicatorPage, NotificationsIndicatorItem  # NOQA
 from ubuntu_system_tests.helpers.system_settings import SIM_1, SIM_ASK
 from ubuntu_system_tests.helpers.uid import b64_uuid
+from ubuntu_system_tests.helpers import webbrowser
 
 CONTACT_1 = Contact(name='Imran Khan', number='08151')
 CONTACT_2 = Contact(name='John Connor', number='08153')
@@ -285,8 +287,8 @@
 
         self.get_messaging_app()
         self.click_message_url(domain)
-        web_browser = self.get_webbrowser_app_proxy()
-        web_browser.wait_until_page_loaded('{}/'.format(url))
+        webbrowser_app = webbrowser.get_webbrowser_app_proxy()
+        webbrowser_app.wait_until_page_loaded('{}/'.format(url))
 
     def verify_thread(self, messaging_app, phone_number, message):
         """Check that the thread with given number and message exists"""
@@ -311,7 +313,7 @@
         message_item.wait_until_destroyed()
         self.assertThat(lambda: self.shell.is_new_notification_displayed(),
                         Eventually(Equals(False)))
-        messaging_app = self.launch_messaging_app_from_launcher()
+        messaging_app = messaging.launch_messaging_app_from_launcher()
         self.verify_thread(messaging_app, self.contact_1.number, message.body)
 
     @skipUnless(ofono.number_of_sims() > 1, 'More than 1 SIM is required.')

=== modified file 'ubuntu_system_tests/tests/test_rotation.py'
--- ubuntu_system_tests/tests/test_rotation.py	2016-01-15 16:05:14 +0000
+++ ubuntu_system_tests/tests/test_rotation.py	2016-02-10 11:57:12 +0000
@@ -19,6 +19,7 @@
 #
 
 from ubuntu_system_tests.helpers.system_settings import (
+    launch_system_settings,
     get_rotation_lock,
     set_rotation_lock,
 )
@@ -41,7 +42,7 @@
         self.addCleanup(set_rotation_lock, get_rotation_lock())
         set_rotation_lock('false')
         self.sensors.set_orientation('top_up')
-        self.main_view = self.launch_system_settings()
+        self.main_view = launch_system_settings()
         unity_proxy.ensure_app_loaded()
 
     def _assert_orientation_and_angle(self, orientation, angle):

=== modified file 'ubuntu_system_tests/tests/test_sdcard.py'
--- ubuntu_system_tests/tests/test_sdcard.py	2016-02-03 18:08:14 +0000
+++ ubuntu_system_tests/tests/test_sdcard.py	2016-02-10 11:57:12 +0000
@@ -25,6 +25,7 @@
 
 from ubuntu_system_tests.helpers.data import load_test_metadata
 from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers import gallery
 from ubuntu_system_tests.helpers import images
 from ubuntu_system_tests.helpers import indicators
 from ubuntu_system_tests.helpers import media
@@ -171,7 +172,7 @@
 
         mediaplayer.play_video(dst_video)
         wait_until(mediaplayer.is_mediaplayer_running)
-        player = self.get_media_player_proxy()
+        player = mediaplayer.get_media_player_proxy()
 
         self.assertTrue(wait_until(player.is_playing))
 
@@ -203,7 +204,7 @@
         preview.play_video()
 
         wait_until(mediaplayer.is_mediaplayer_running)
-        player = self.get_media_player_proxy()
+        player = mediaplayer.get_media_player_proxy()
 
         self.assertTrue(wait_until(player.is_playing))
 
@@ -214,11 +215,11 @@
         # Prerequisite: Copy picture to the sd card
         dst_pic = sdcard.copy_picture(SRC_PICTURE_FILE_1)
 
-        gallery = self.launch_gallery_app()
-        self.assertTrue(gallery.is_image_displayed(dst_pic))
+        gallery_app = gallery.launch_gallery_app()
+        self.assertTrue(gallery_app.is_image_displayed(dst_pic))
 
-        gallery.click_photo(dst_pic)
-        self.assertTrue(gallery.is_image_in_view(dst_pic))
+        gallery_app.click_photo(dst_pic)
+        self.assertTrue(gallery_app.is_image_in_view(dst_pic))
 
     @skipUnless(scopes.is_scope_included(scopes.SCOPE_ID_MUSIC), SKIP_REASON)
     def test_play_music_from_sd_card_in_music_app(self):
@@ -240,7 +241,7 @@
         # Play the album in the music app and verify the desired album is
         # being reproduced
         preview.play_in_music_app()
-        self.assertTrue(wait_until(self.is_music_app_running, timeout=20))
+        self.assertTrue(wait_until(music.is_music_app_running, timeout=20))
         self.addCleanup(music.stop_music_app)
         song_path = os.path.join(
             fs.DIR_MEDIA_ROOT, sdcard.get_sd_card_dir_name(), 'Music',

=== modified file 'ubuntu_system_tests/tests/test_settings_wizard.py'
--- ubuntu_system_tests/tests/test_settings_wizard.py	2015-10-19 20:30:31 +0000
+++ ubuntu_system_tests/tests/test_settings_wizard.py	2016-02-10 11:57:12 +0000
@@ -17,8 +17,9 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>
 
 from ubuntu_system_tests.config import get_device_config_stack
-from ubuntu_system_tests.helpers.autopilot import is_wifi_supported
-from ubuntu_system_tests.helpers.autopilot import is_agps_supported
+from ubuntu_system_tests.helpers.autopilot.platform import (
+    is_agps_supported, is_wifi_supported
+)
 from ubuntu_system_tests.helpers.unity8 import settings_wizard
 from ubuntu_system_tests.helpers.unity8.settings_wizard import Wizard
 from ubuntu_system_tests.helpers import ofono

=== modified file 'ubuntu_system_tests/tests/test_sim_pin.py'
--- ubuntu_system_tests/tests/test_sim_pin.py	2015-10-08 12:13:55 +0000
+++ ubuntu_system_tests/tests/test_sim_pin.py	2016-02-10 11:57:12 +0000
@@ -25,6 +25,7 @@
 
 from ubuntu_system_tests.helpers import ofono
 from ubuntu_system_tests.helpers.ofono import fixture_setup as ofono_fixture
+from ubuntu_system_tests.helpers import system_settings
 from ubuntu_system_tests.tests import base
 
 
@@ -37,7 +38,7 @@
         self.useFixture(ofono_fixture.UnlockSims())
 
         self.unity_proxy = self.restart_unity()
-        self.app = self.launch_system_settings()
+        self.app = system_settings.launch_system_settings()
 
         # As per this bug where we're unable to launch the browser from the
         # scope after a unity8 reboot.

=== modified file 'ubuntu_system_tests/tests/test_system_settings.py'
--- ubuntu_system_tests/tests/test_system_settings.py	2016-01-18 13:14:03 +0000
+++ ubuntu_system_tests/tests/test_system_settings.py	2016-02-10 11:57:12 +0000
@@ -25,6 +25,7 @@
     network as network_indicator_helpers
 )
 from ubuntu_system_tests.helpers import network
+from ubuntu_system_tests.helpers import system_settings
 from ubuntu_system_tests.tests import base
 
 
@@ -33,7 +34,7 @@
     def setUp(self):
         super().setUp()
         self.shell = self.restart_unity().main_window
-        self.system_settings = self.launch_system_settings()
+        self.system_settings = system_settings.launch_system_settings()
         self.assertTrue(network.is_wifi_connected())
 
     def _disable_mobile_data_if_enabled(self):

=== modified file 'ubuntu_system_tests/tests/test_ubuntu_keyboard.py'
--- ubuntu_system_tests/tests/test_ubuntu_keyboard.py	2016-01-06 13:19:19 +0000
+++ ubuntu_system_tests/tests/test_ubuntu_keyboard.py	2016-02-10 11:57:12 +0000
@@ -47,14 +47,14 @@
         super().setUp()
         self.unity_proxy = self.restart_unity()
         self.useFixture(messaging_fixture.SetDefaultSIM())
-        self.messaging_app = self.launch_messaging_app()
+        self.messaging_app = messaging_helpers.launch_messaging_app()
 
     def _focus_message_input_field_to_invoke_keyboard(self):
         # Due to some reason, using the proxy object with uitk emulator base,
         # causes the Ubuntu Keyboard to misbehave i.e. its auto-capitalization
         # settings are reset during the test. Getting the proxy object without
         # custom emulator base, solves the issue. --om26er 16-12-2015
-        messaging_app_raw_proxy = self.get_messaging_app_proxy(
+        messaging_app_raw_proxy = messaging_helpers.get_messaging_app_proxy(
             base=None)
         return messaging_helpers.focus_message_input_field(
             messaging_app_raw_proxy, self.messaging_app.pointing_device)
@@ -119,7 +119,7 @@
         """
         osk = UbuntuKeyboard()
         osk.type(INITIAL_TEXT)
-        word_ribbon_list = self.get_ubuntu_keyboard_proxy().word_ribbon_list
+        word_ribbon_list = osk_helpers.get_ubuntu_keyboard_proxy().word_ribbon_list  # NOQA
 
         suggestions_list = word_ribbon_list.get_suggested_words()
         self._assert_words_in_ribbon(suggestions_list, EXPECTED_WORDS)

=== modified file 'ubuntu_system_tests/tests/test_with_dialer.py'
--- ubuntu_system_tests/tests/test_with_dialer.py	2016-01-12 08:06:11 +0000
+++ ubuntu_system_tests/tests/test_with_dialer.py	2016-02-10 11:57:12 +0000
@@ -22,6 +22,7 @@
 
 from unity8 import process_helpers as unity_helpers
 
+from ubuntu_system_tests.helpers import dialer_app
 from ubuntu_system_tests.tests import base
 
 
@@ -30,7 +31,7 @@
     def setUp(self):
         super().setUp()
         self.unity = self.restart_unity()
-        self.dialer_app = self.launch_dialer_app()
+        self.dialer_app = dialer_app.launch_dialer_app()
 
     def test_dialer_contacts_view_kept_on_screen_lock(self):
         """

=== modified file 'ubuntu_system_tests/tests/test_with_webbrowser.py'
--- ubuntu_system_tests/tests/test_with_webbrowser.py	2016-01-27 15:40:40 +0000
+++ ubuntu_system_tests/tests/test_with_webbrowser.py	2016-02-10 11:57:12 +0000
@@ -29,19 +29,21 @@
 from ubuntu_keyboard.emulators import keyboard
 
 from ubuntu_system_tests.helpers import autopilot
+from ubuntu_system_tests.helpers.data import load_test_metadata
 from ubuntu_system_tests.helpers import file_system as fs
+from ubuntu_system_tests.helpers import gallery
 from ubuntu_system_tests.helpers import images
-from ubuntu_system_tests.helpers import wait_until
-from ubuntu_system_tests.helpers.data import load_test_metadata
+from ubuntu_system_tests.helpers import messaging
 from ubuntu_system_tests.helpers.messaging import (
     fixture_setup as messaging_fixtures
 )
-
-from ubuntu_system_tests.tests import base_webbrowser
+from ubuntu_system_tests.helpers import wait_until
 from ubuntu_system_tests.helpers.webbrowser import (
     fixture_setup as webbrowser_fixtures
 )
 
+from ubuntu_system_tests.tests import base_webbrowser
+
 
 logger = logging.getLogger(__name__)
 PageUrls = namedtuple('PageUrls', ['entered_url',
@@ -281,7 +283,7 @@
         self.assertTrue(wait_until(os.path.isfile, downloaded_file))
 
         # Validate the gallery-app is displaying the downloaded image
-        events_view = self.get_gallery_events_view()
+        events_view = gallery.get_gallery_events_view()
         self.assertTrue(events_view.is_image_displayed(img.file_name))
 
         # check the displayed image matches the reference image
@@ -433,7 +435,7 @@
         self.browser.wait_until_page_loaded(test_data.get('ubuntu').actual_url)
         self.browser.copy_url_text()
 
-        messaging_app = self.launch_messaging_app_from_launcher()
+        messaging_app = messaging.launch_messaging_app_from_launcher()
         # Apparently the OSK stays visible if the app was switched while
         # the keyboard was on screen. Reported: LP: 1505630
         keyboard.Keyboard().dismiss()

=== modified file 'ubuntu_system_tests/tests/webapps/test_ebay.py'
--- ubuntu_system_tests/tests/webapps/test_ebay.py	2016-02-05 13:59:28 +0000
+++ ubuntu_system_tests/tests/webapps/test_ebay.py	2016-02-10 11:57:12 +0000
@@ -31,7 +31,7 @@
 
     def setUp(self):
         super().setUp()
-        self.web_app = self.launch_ebay_webapp()
+        self.web_app = ebay.launch_ebay_webapp()
         self.driver = webapp.get_webdriver(self.addCleanup)
 
     def test_open_and_view_content(self):

=== modified file 'ubuntu_system_tests/tests/webapps/test_here.py'
--- ubuntu_system_tests/tests/webapps/test_here.py	2016-01-14 17:35:52 +0000
+++ ubuntu_system_tests/tests/webapps/test_here.py	2016-02-10 11:57:12 +0000
@@ -41,7 +41,7 @@
         self.useFixture(DummyLocation(*EIFFEL_TOWER))
         super().setUp()
         self.useFixture(SetLocationAccessRequests(self.LOCATION_APP))
-        self.webapp = self.launch_here_webapp()
+        self.webapp = here.launch_here_webapp()
         self.driver = webapp.get_webdriver(self.addCleanup)
 
     def test_retrieve_location(self):