Merge lp:~dobey/autopilot/drop-ual into lp:autopilot/legacy

[dobey]

Remove support for UAL from legacy code, as it's not needed.

[lp:~dobey/autopilot/drop-ual]

501. By dobey on 2017-03-03

Also remove a couple more items from the testcase.

[dobey (dobey)]

Self-approving because this is necessary for migration.

review: Approve

=== modified file 'autopilot/application/__init__.py'
--- autopilot/application/__init__.py	2014-01-24 04:18:10 +0000
+++ autopilot/application/__init__.py	2017-03-03 23:28:24 +0000
@@ -20,15 +20,11 @@
 """Base package for application launching and environment management."""
 
 from autopilot.application._launcher import (
-    ClickApplicationLauncher,
     get_application_launcher_wrapper,
     NormalApplicationLauncher,
-    UpstartApplicationLauncher,
 )
 
 __all__ = [
-    'ClickApplicationLauncher',
     'get_application_launcher_wrapper',
     'NormalApplicationLauncher',
-    'UpstartApplicationLauncher',
 ]

=== modified file 'autopilot/application/_launcher.py'
--- autopilot/application/_launcher.py	2014-08-06 05:39:37 +0000
+++ autopilot/application/_launcher.py	2017-03-03 23:28:24 +0000
@@ -20,7 +20,7 @@
 """Base module for application launchers."""
 
 import fixtures
-from gi.repository import GLib, UbuntuAppLaunch
+from gi.repository import GLib
 import json
 import logging
 import os
@@ -55,143 +55,6 @@
         raise NotImplementedError("Sub-classes must implement this method.")
 
 
-class UpstartApplicationLauncher(ApplicationLauncher):
-
-    """A launcher class that launched applicaitons with UpstartAppLaunch."""
-
-    Timeout = object()
-    Failed = object()
-    Started = object()
-    Stopped = object()
-
-    def __init__(self, case_addDetail, **kwargs):
-        super(UpstartApplicationLauncher, self).__init__(case_addDetail)
-
-        self.emulator_base = kwargs.pop('emulator_base', None)
-        self.dbus_bus = kwargs.pop('dbus_bus', 'session')
-        self.dbus_application_name = kwargs.pop('application_name', None)
-
-        _raise_on_unknown_kwargs(kwargs)
-
-    def launch(self, app_id, app_uris=[]):
-        state = {}
-        state['loop'] = self._get_glib_loop()
-        state['expected_app_id'] = app_id
-        state['message'] = ''
-
-        UbuntuAppLaunch.observer_add_app_failed(self._on_failed, state)
-        UbuntuAppLaunch.observer_add_app_started(self._on_started, state)
-        UbuntuAppLaunch.observer_add_app_focus(self._on_started, state)
-        GLib.timeout_add_seconds(10.0, self._on_timeout, state)
-
-        self._launch_app(app_id, app_uris)
-        state['loop'].run()
-        UbuntuAppLaunch.observer_delete_app_failed(self._on_failed)
-        UbuntuAppLaunch.observer_delete_app_started(self._on_started)
-        UbuntuAppLaunch.observer_delete_app_focus(self._on_started)
-        self._maybe_add_application_cleanups(state)
-        self._check_status_error(
-            state.get('status', None),
-            state.get('message', '')
-        )
-        return self._get_pid_for_launched_app(app_id)
-
-    @staticmethod
-    def _on_failed(launched_app_id, failure_type, state):
-        if launched_app_id == state['expected_app_id']:
-            if failure_type == UbuntuAppLaunch.AppFailed.CRASH:
-                state['message'] = 'Application crashed.'
-            elif failure_type == UbuntuAppLaunch.AppFailed.START_FAILURE:
-                state['message'] = 'Application failed to start.'
-            state['status'] = UpstartApplicationLauncher.Failed
-            state['loop'].quit()
-
-    @staticmethod
-    def _on_started(launched_app_id, state):
-        if launched_app_id == state['expected_app_id']:
-            state['status'] = UpstartApplicationLauncher.Started
-            state['loop'].quit()
-
-    @staticmethod
-    def _on_stopped(stopped_app_id, state):
-        if stopped_app_id == state['expected_app_id']:
-            state['status'] = UpstartApplicationLauncher.Stopped
-            state['loop'].quit()
-
-    @staticmethod
-    def _on_timeout(state):
-        state['status'] = UpstartApplicationLauncher.Timeout
-        state['loop'].quit()
-
-    def _maybe_add_application_cleanups(self, state):
-        if state.get('status', None) == UpstartApplicationLauncher.Started:
-            app_id = state['expected_app_id']
-            self.addCleanup(self._stop_application, app_id)
-            self.addCleanup(self._attach_application_log, app_id)
-
-    def _attach_application_log(self, app_id):
-        log_path = UbuntuAppLaunch.application_log_path(app_id)
-        if log_path:
-            self.case_addDetail(
-                "Application Log",
-                content_from_file(log_path)
-            )
-
-    def _stop_application(self, app_id):
-        state = {}
-        state['loop'] = self._get_glib_loop()
-        state['expected_app_id'] = app_id
-
-        UbuntuAppLaunch.observer_add_app_stop(self._on_stopped, state)
-        GLib.timeout_add_seconds(10.0, self._on_timeout, state)
-
-        UbuntuAppLaunch.stop_application(app_id)
-        state['loop'].run()
-        UbuntuAppLaunch.observer_delete_app_stop(self._on_stopped)
-
-        if state.get('status', None) == UpstartApplicationLauncher.Timeout:
-            _logger.error(
-                "Timed out waiting for Application with app_id '%s' to stop.",
-                app_id
-            )
-
-    @staticmethod
-    def _get_glib_loop():
-        return GLib.MainLoop()
-
-    @staticmethod
-    def _get_pid_for_launched_app(app_id):
-        return UbuntuAppLaunch.get_primary_pid(app_id)
-
-    @staticmethod
-    def _launch_app(app_name, app_uris):
-        UbuntuAppLaunch.start_application_test(app_name, app_uris)
-
-    @staticmethod
-    def _check_status_error(status, extra_message=''):
-        message_parts = []
-        if status == UpstartApplicationLauncher.Timeout:
-            message_parts.append(
-                "Timed out while waiting for application to launch"
-            )
-        elif status == UpstartApplicationLauncher.Failed:
-            message_parts.append("Application Launch Failed")
-        if message_parts and extra_message:
-            message_parts.append(extra_message)
-        if message_parts:
-            raise RuntimeError(': '.join(message_parts))
-
-
-class ClickApplicationLauncher(UpstartApplicationLauncher):
-
-    def launch(self, package_id, app_name, app_uris):
-        app_id = _get_click_app_id(package_id, app_name)
-        return self._do_upstart_launch(app_id, app_uris)
-
-    def _do_upstart_launch(self, app_id, app_uris):
-        return super(ClickApplicationLauncher, self).launch(app_id, app_uris)
-
-
 class NormalApplicationLauncher(ApplicationLauncher):
     def __init__(self, case_addDetail, **kwargs):
         super(NormalApplicationLauncher, self).__init__(case_addDetail)
@@ -269,35 +132,6 @@
     return process
 
 
-def _get_click_app_id(package_id, app_name=None):
-    for pkg in _get_click_manifest():
-        if pkg['name'] == package_id:
-            if app_name is None:
-                # py3 dict.keys isn't indexable.
-                app_name = list(pkg['hooks'].keys())[0]
-            elif app_name not in pkg['hooks']:
-                raise RuntimeError(
-                    "Application '{}' is not present within the click "
-                    "package '{}'.".format(app_name, package_id))
-
-            return "{0}_{1}_{2}".format(package_id, app_name, pkg['version'])
-    raise RuntimeError(
-        "Unable to find package '{}' in the click manifest."
-        .format(package_id)
-    )
-
-
-def _get_click_manifest():
-    """Return the click package manifest as a python list."""
-    # get the whole click package manifest every time - it seems fast enough
-    # but this is a potential optimisation point for the future:
-    click_manifest_str = subprocess.check_output(
-        ["click", "list", "--manifest"],
-        universal_newlines=True
-    )
-    return json.loads(click_manifest_str)
-
-
 def _get_application_environment(app_type=None, app_path=None):
     if app_type is None and app_path is None:
         raise ValueError("Must specify either app_type or app_path.")

=== modified file 'autopilot/testcase.py'
--- autopilot/testcase.py	2014-08-06 05:39:37 +0000
+++ autopilot/testcase.py	2017-03-03 23:28:24 +0000
@@ -57,10 +57,8 @@
 from testtools.matchers import Equals
 
 from autopilot.application import (
-    ClickApplicationLauncher,
     get_application_launcher_wrapper,
     NormalApplicationLauncher,
-    UpstartApplicationLauncher,
 )
 from autopilot.display import Display
 from autopilot.globals import get_debug_profile_fixture
@@ -263,86 +261,6 @@
 
         return self._launch_test_application(launcher, application, *arguments)
 
-    def launch_click_package(self, package_id, app_name=None, app_uris=[],
-                             **kwargs):
-        """Launch a click package application with introspection enabled.
-
-        This method takes care of launching a click package with introspection
-        exabled. You probably want to use this method if your application is
-        packaged in a click application, or is started via upstart.
-
-        Usage is similar to the
-        :py:meth:`AutopilotTestCase.launch_test_application`::
-
-            app_proxy = self.launch_click_package(
-                "com.ubuntu.dropping-letters"
-            )
-
-        :param package_id: The Click package name you want to launch. For
-            example: ``com.ubuntu.dropping-letters``
-        :param app_name: Currently, only one application can be packaged in a
-            click package, and this parameter can be left at None. If
-            specified, it should be the application name you wish to launch.
-        :param app_uris: Parameters used to launch the click package. This
-            parameter will be left empty if not used.
-
-        :keyword emulator_base: If set, specifies the base class to be used for
-            all emulators for this loaded application.
-
-        :raises RuntimeError: If the specified package_id cannot be found in
-            the click package manifest.
-        :raises RuntimeError: If the specified app_name cannot be found within
-            the specified click package.
-
-        :returns: proxy object for the launched package application
-
-        """
-        if isinstance(app_uris, (six.text_type, six.binary_type)):
-            app_uris = [app_uris]
-        _logger.info(
-            "Attempting to launch click application '%s' from click package "
-            " '%s' and URIs '%s'",
-            app_name if app_name is not None else "(default)",
-            package_id,
-            ','.join(app_uris)
-        )
-        launcher = self.useFixture(
-            ClickApplicationLauncher(self.addDetail, **kwargs)
-        )
-        return self._launch_test_application(launcher, package_id, app_name,
-                                             app_uris)
-
-    def launch_upstart_application(self, application_name, uris=[], **kwargs):
-        """Launch an application with upstart.
-
-        This method launched an application via the ``ubuntu-app-launch``
-        library, on platforms that support it.
-
-        Usage is similar to the
-        :py:meth:`AutopilotTestCase.launch_test_application`::
-
-            app_proxy = self.launch_upstart_application("gallery-app")
-
-        :param application_name: The name of the application to launch.
-        :keyword emulator_base: If set, specifies the base class to be used for
-            all emulators for this loaded application.
-
-        :raises RuntimeError: If the specified application cannot be launched.
-        :raises ValueError: If unknown keyword arguments are specified.
-        """
-        if isinstance(uris, (six.text_type, six.binary_type)):
-            uris = [uris]
-        _logger.info(
-            "Attempting to launch application '%s' with URIs '%s' via "
-            "upstart-app-launch",
-            application_name,
-            ','.join(uris)
-        )
-        launcher = self.useFixture(
-            UpstartApplicationLauncher(self.addDetail, **kwargs)
-        )
-        return self._launch_test_application(launcher, application_name, uris)
-
     # Wrapper function tying the newer ApplicationLauncher behaviour with the
     # previous (to be depreciated) behaviour
     def _launch_test_application(self, launcher_instance, application, *args):

=== modified file 'autopilot/tests/unit/test_application_launcher.py'
--- autopilot/tests/unit/test_application_launcher.py	2014-08-06 05:39:37 +0000
+++ autopilot/tests/unit/test_application_launcher.py	2017-03-03 23:28:24 +0000
@@ -42,9 +42,7 @@
 from mock import Mock, patch
 
 from autopilot.application import (
-    ClickApplicationLauncher,
     NormalApplicationLauncher,
-    UpstartApplicationLauncher,
 )
 from autopilot.application._environment import (
     GtkApplicationEnvironment,
@@ -59,8 +57,6 @@
     _get_app_env_from_string_hint,
     _get_application_environment,
     _get_application_path,
-    _get_click_app_id,
-    _get_click_manifest,
     _is_process_running,
     _kill_process,
 )
@@ -171,500 +167,6 @@
             )
 
 
-class ClickApplicationLauncherTests(TestCase):
-
-    def test_raises_exception_on_unknown_kwargs(self):
-        self.assertThat(
-            lambda: ClickApplicationLauncher(self.addDetail, unknown=True),
-            raises(ValueError("Unknown keyword arguments: 'unknown'."))
-        )
-
-    def test_application_name_kwarg_stored(self):
-        app_name = self.getUniqueString()
-        launcher = ClickApplicationLauncher(
-            self.addDetail,
-            application_name=app_name
-        )
-
-        self.assertThat(
-            launcher.dbus_application_name, Equals(app_name)
-        )
-
-    def test_click_launch_calls_upstart_launch(self):
-        launcher = ClickApplicationLauncher(self.addDetail)
-        token = self.getUniqueString()
-        with patch.object(launcher, '_do_upstart_launch') as p_dul:
-            with patch.object(_l, '_get_click_app_id') as p_gcai:
-                p_gcai.return_value = token
-                launcher.launch('some_app_id', 'some_app_name', [])
-                p_dul.assert_called_once_with(token, [])
-
-    def test_upcalls_to_upstart(self):
-        class FakeUpstartBase(_l.ApplicationLauncher):
-            launch_call_args = []
-
-            def launch(self, *args):
-                FakeUpstartBase.launch_call_args = list(args)
-
-        patcher = patch.object(
-            _l.ClickApplicationLauncher,
-            '__bases__',
-            (FakeUpstartBase,)
-        )
-        with patcher:
-            # Prevent mock from trying to delete __bases__
-            patcher.is_local = True
-            launcher = ClickApplicationLauncher(self.addDetail)
-            launcher._do_upstart_launch('app_id', [])
-        self.assertEqual(
-            FakeUpstartBase.launch_call_args,
-            ['app_id', []])
-
-
-class ClickFunctionTests(TestCase):
-
-    def test_get_click_app_id_raises_runtimeerror_on_empty_manifest(self):
-        """_get_click_app_id must raise a RuntimeError if the requested
-        package id is not found in the click manifest.
-
-        """
-        with patch.object(_l, '_get_click_manifest', return_value=[]):
-            self.assertThat(
-                lambda: _get_click_app_id("com.autopilot.testing"),
-                raises(
-                    RuntimeError(
-                        "Unable to find package 'com.autopilot.testing' in "
-                        "the click manifest."
-                    )
-                )
-            )
-
-    def test_get_click_app_id_raises_runtimeerror_on_missing_package(self):
-        with patch.object(_l, '_get_click_manifest') as cm:
-            cm.return_value = [
-                {
-                    'name': 'com.not.expected.name',
-                    'hooks': {'bar': {}}, 'version': '1.0'
-                }
-            ]
-
-            self.assertThat(
-                lambda: _get_click_app_id("com.autopilot.testing"),
-                raises(
-                    RuntimeError(
-                        "Unable to find package 'com.autopilot.testing' in "
-                        "the click manifest."
-                    )
-                )
-            )
-
-    def test_get_click_app_id_raises_runtimeerror_on_wrong_app(self):
-        """get_click_app_id must raise a RuntimeError if the requested
-        application is not found within the click package.
-
-        """
-        with patch.object(_l, '_get_click_manifest') as cm:
-            cm.return_value = [{'name': 'com.autopilot.testing', 'hooks': {}}]
-
-            self.assertThat(
-                lambda: _get_click_app_id("com.autopilot.testing", "bar"),
-                raises(
-                    RuntimeError(
-                        "Application 'bar' is not present within the click "
-                        "package 'com.autopilot.testing'."
-                    )
-                )
-            )
-
-    def test_get_click_app_id_returns_id(self):
-        with patch.object(_l, '_get_click_manifest') as cm:
-            cm.return_value = [
-                {
-                    'name': 'com.autopilot.testing',
-                    'hooks': {'bar': {}}, 'version': '1.0'
-                }
-            ]
-
-            self.assertThat(
-                _get_click_app_id("com.autopilot.testing", "bar"),
-                Equals("com.autopilot.testing_bar_1.0")
-            )
-
-    def test_get_click_app_id_returns_id_without_appid_passed(self):
-        with patch.object(_l, '_get_click_manifest') as cm:
-            cm.return_value = [
-                {
-                    'name': 'com.autopilot.testing',
-                    'hooks': {'bar': {}}, 'version': '1.0'
-                }
-            ]
-
-            self.assertThat(
-                _get_click_app_id("com.autopilot.testing"),
-                Equals("com.autopilot.testing_bar_1.0")
-            )
-
-
-class UpstartApplicationLauncherTests(TestCase):
-
-    def test_can_construct_UpstartApplicationLauncher(self):
-        UpstartApplicationLauncher(self.addDetail)
-
-    def test_default_values_are_set(self):
-        launcher = UpstartApplicationLauncher(self.addDetail)
-        self.assertThat(launcher.emulator_base, Equals(None))
-        self.assertThat(launcher.dbus_bus, Equals('session'))
-
-    def test_can_set_emulator_base(self):
-        mock_emulator_base = Mock()
-        launcher = UpstartApplicationLauncher(
-            self.addDetail,
-            emulator_base=mock_emulator_base
-        )
-
-        self.assertThat(launcher.emulator_base, Equals(mock_emulator_base))
-
-    def test_can_set_dbus_bus(self):
-        launcher = UpstartApplicationLauncher(
-            self.addDetail,
-            dbus_bus='system'
-        )
-
-        self.assertThat(launcher.dbus_bus, Equals('system'))
-
-    def test_raises_exception_on_unknown_kwargs(self):
-        self.assertThat(
-            lambda: UpstartApplicationLauncher(self.addDetail, unknown=True),
-            raises(ValueError("Unknown keyword arguments: 'unknown'."))
-        )
-
-    def test_on_failed_only_sets_status_on_correct_app_id(self):
-        state = {
-            'expected_app_id': 'gedit',
-        }
-
-        UpstartApplicationLauncher._on_failed('some_game', None, state)
-
-        self.assertThat(state, Not(Contains('status')))
-
-    def assertFunctionSetsCorrectStateAndQuits(self, observer, expected_state):
-        """Assert that the observer observer sets the correct state id.
-
-        :param observer: The observer callable you want to test.
-        :param expected_state: The state id the observer callable must set.
-
-        """
-        expected_app_id = self.getUniqueString()
-        state = {
-            'expected_app_id': expected_app_id,
-            'loop': Mock()
-        }
-
-        if observer == UpstartApplicationLauncher._on_failed:
-            observer(expected_app_id, None, state)
-        elif observer == UpstartApplicationLauncher._on_started or \
-                observer == UpstartApplicationLauncher._on_stopped:
-            observer(expected_app_id, state)
-        else:
-            observer(state)
-
-        self.assertThat(
-            state['status'],
-            Equals(expected_state)
-        )
-        state['loop'].quit.assert_called_once_with()
-
-    def test_on_failed_sets_status_with_correct_app_id(self):
-        self.assertFunctionSetsCorrectStateAndQuits(
-            UpstartApplicationLauncher._on_failed,
-            UpstartApplicationLauncher.Failed
-        )
-
-    def test_on_started_sets_status_with_correct_app_id(self):
-        self.assertFunctionSetsCorrectStateAndQuits(
-            UpstartApplicationLauncher._on_started,
-            UpstartApplicationLauncher.Started
-        )
-
-    def test_on_timeout_sets_status_and_exits_loop(self):
-        self.assertFunctionSetsCorrectStateAndQuits(
-            UpstartApplicationLauncher._on_timeout,
-            UpstartApplicationLauncher.Timeout
-        )
-
-    def test_on_started_only_sets_status_on_correct_app_id(self):
-        state = {
-            'expected_app_id': 'gedit',
-        }
-
-        UpstartApplicationLauncher._on_started('some_game', state)
-
-        self.assertThat(state, Not(Contains('status')))
-
-    def test_on_stopped_only_sets_status_on_correct_app_id(self):
-        state = {
-            'expected_app_id': 'gedit',
-        }
-
-        UpstartApplicationLauncher._on_stopped('some_game', state)
-        self.assertThat(state, Not(Contains('status')))
-
-    def test_on_stopped_sets_status_and_exits_loop(self):
-        self.assertFunctionSetsCorrectStateAndQuits(
-            UpstartApplicationLauncher._on_stopped,
-            UpstartApplicationLauncher.Stopped
-        )
-
-    def test_get_pid_calls_upstart_module(self):
-        expected_return = self.getUniqueInteger()
-        with patch.object(_l, 'UbuntuAppLaunch') as mock_ual:
-            mock_ual.get_primary_pid.return_value = expected_return
-            observed = UpstartApplicationLauncher._get_pid_for_launched_app(
-                'gedit'
-            )
-
-            mock_ual.get_primary_pid.assert_called_once_with('gedit')
-            self.assertThat(expected_return, Equals(observed))
-
-    def test_launch_app_calls_upstart_module(self):
-        with patch.object(_l, 'UbuntuAppLaunch') as mock_ual:
-            UpstartApplicationLauncher._launch_app(
-                'gedit',
-                ['some', 'uris']
-            )
-
-            mock_ual.start_application_test.assert_called_once_with(
-                'gedit',
-                ['some', 'uris']
-            )
-
-    def test_check_error_raises_RuntimeError_on_timeout(self):
-        fn = lambda: UpstartApplicationLauncher._check_status_error(
-            UpstartApplicationLauncher.Timeout
-        )
-        self.assertThat(
-            fn,
-            raises(
-                RuntimeError(
-                    "Timed out while waiting for application to launch"
-                )
-            )
-        )
-
-    def test_check_error_raises_RuntimeError_on_failure(self):
-        fn = lambda: UpstartApplicationLauncher._check_status_error(
-            UpstartApplicationLauncher.Failed
-        )
-        self.assertThat(
-            fn,
-            raises(
-                RuntimeError(
-                    "Application Launch Failed"
-                )
-            )
-        )
-
-    def test_check_error_raises_RuntimeError_with_extra_message(self):
-        fn = lambda: UpstartApplicationLauncher._check_status_error(
-            UpstartApplicationLauncher.Failed,
-            "extra message"
-        )
-        self.assertThat(
-            fn,
-            raises(
-                RuntimeError(
-                    "Application Launch Failed: extra message"
-                )
-            )
-        )
-
-    def test_check_error_does_nothing_on_None(self):
-        UpstartApplicationLauncher._check_status_error(None)
-
-    def test_get_loop_returns_glib_mainloop_instance(self):
-        loop = UpstartApplicationLauncher._get_glib_loop()
-        self.assertThat(loop, IsInstance(GLib.MainLoop))
-
-    def test_launch(self):
-        launcher = UpstartApplicationLauncher(self.addDetail)
-        with patch.object(launcher, '_launch_app') as patched_launch:
-            with patch.object(launcher, '_get_glib_loop'):
-                launcher.launch('gedit')
-
-                patched_launch.assert_called_once_with('gedit', [])
-
-    def assertFailedObserverSetsExtraMessage(self, fail_type, expected_msg):
-        """Assert that the on_failed observer must set the expected message
-        for a particular failure_type."""
-        expected_app_id = self.getUniqueString()
-        state = {
-            'expected_app_id': expected_app_id,
-            'loop': Mock()
-        }
-        UpstartApplicationLauncher._on_failed(
-            expected_app_id,
-            fail_type,
-            state
-        )
-        self.assertEqual(expected_msg, state['message'])
-
-    def test_on_failed_sets_message_for_app_crash(self):
-        self.assertFailedObserverSetsExtraMessage(
-            _l.UbuntuAppLaunch.AppFailed.CRASH,
-            'Application crashed.'
-        )
-
-    def test_on_failed_sets_message_for_app_start_failure(self):
-        self.assertFailedObserverSetsExtraMessage(
-            _l.UbuntuAppLaunch.AppFailed.START_FAILURE,
-            'Application failed to start.'
-        )
-
-    def test_add_application_cleanups_adds_both_cleanup_actions(self):
-        token = self.getUniqueString()
-        state = {
-            'status': UpstartApplicationLauncher.Started,
-            'expected_app_id': token,
-        }
-        launcher = UpstartApplicationLauncher(Mock())
-        launcher.setUp()
-        launcher._maybe_add_application_cleanups(state)
-        self.assertThat(
-            launcher._cleanups._cleanups,
-            Contains(
-                (launcher._attach_application_log, (token,), {})
-            )
-        )
-        self.assertThat(
-            launcher._cleanups._cleanups,
-            Contains(
-                (launcher._stop_application, (token,), {})
-            )
-        )
-
-    def test_add_application_cleanups_does_nothing_when_app_timedout(self):
-        state = {
-            'status': UpstartApplicationLauncher.Timeout,
-        }
-        launcher = UpstartApplicationLauncher(Mock())
-        launcher.setUp()
-        launcher._maybe_add_application_cleanups(state)
-        self.assertThat(launcher._cleanups._cleanups, HasLength(0))
-
-    def test_add_application_cleanups_does_nothing_when_app_failed(self):
-        state = {
-            'status': UpstartApplicationLauncher.Failed,
-        }
-        launcher = UpstartApplicationLauncher(Mock())
-        launcher.setUp()
-        launcher._maybe_add_application_cleanups(state)
-        self.assertThat(launcher._cleanups._cleanups, HasLength(0))
-
-    def test_attach_application_log_does_nothing_wth_no_log_specified(self):
-        app_id = self.getUniqueString()
-        case_addDetail = Mock()
-        launcher = UpstartApplicationLauncher(case_addDetail)
-        with patch.object(_l.UbuntuAppLaunch, 'application_log_path') as p:
-            p.return_value = None
-            launcher._attach_application_log(app_id)
-
-            p.assert_called_once_with(app_id)
-            self.assertEqual(0, case_addDetail.call_count)
-
-    def test_attach_application_log_attaches_log_file(self):
-        token = self.getUniqueString()
-        case_addDetail = Mock()
-        launcher = UpstartApplicationLauncher(case_addDetail)
-        app_id = self.getUniqueString()
-        with tempfile.NamedTemporaryFile(mode='w') as f:
-            f.write(token)
-            f.flush()
-            with patch.object(_l.UbuntuAppLaunch, 'application_log_path',
-                              return_value=f.name):
-                launcher._attach_application_log(app_id)
-
-                self.assertEqual(1, case_addDetail.call_count)
-                content_name, content_obj = case_addDetail.call_args[0]
-                self.assertEqual("Application Log", content_name)
-                self.assertThat(content_obj.as_text(), Contains(token))
-
-    def test_stop_adds_app_stopped_observer(self):
-        mock_add_detail = Mock()
-        mock_glib_loop = Mock()
-        patch_get_loop = patch.object(
-            UpstartApplicationLauncher,
-            '_get_glib_loop',
-            new=mock_glib_loop,
-        )
-        mock_UAL = Mock()
-        patch_UAL = patch.object(_l, 'UbuntuAppLaunch', new=mock_UAL)
-        launcher = UpstartApplicationLauncher(mock_add_detail)
-        app_id = self.getUniqueString()
-        with ExitStack() as patches:
-            patches.enter_context(patch_get_loop)
-            patches.enter_context(patch_UAL)
-
-            launcher._stop_application(app_id)
-            call_args = mock_UAL.observer_add_app_stop.call_args[0]
-            self.assertThat(
-                call_args[0],
-                Equals(UpstartApplicationLauncher._on_stopped)
-            )
-            self.assertThat(call_args[1]['expected_app_id'], Equals(app_id))
-
-    def test_stop_calls_libUAL_stop_function(self):
-        mock_add_detail = Mock()
-        mock_glib_loop = Mock()
-        patch_get_loop = patch.object(
-            UpstartApplicationLauncher,
-            '_get_glib_loop',
-            new=mock_glib_loop,
-        )
-        mock_UAL = Mock()
-        patch_UAL = patch.object(_l, 'UbuntuAppLaunch', new=mock_UAL)
-        launcher = UpstartApplicationLauncher(mock_add_detail)
-        app_id = self.getUniqueString()
-        with ExitStack() as patches:
-            patches.enter_context(patch_get_loop)
-            patches.enter_context(patch_UAL)
-
-            launcher._stop_application(app_id)
-            mock_UAL.stop_application.assert_called_once_with(app_id)
-
-    def test_stop_logs_error_on_timeout(self):
-        mock_add_detail = Mock()
-        mock_glib_loop = Mock()
-        patch_get_loop = patch.object(
-            UpstartApplicationLauncher,
-            '_get_glib_loop',
-            new=mock_glib_loop,
-        )
-        mock_UAL = Mock()
-
-        # we replace the add_observer function with one that can set the
-        # tiemout state, so we can ibject the timeout condition within the
-        # glib loop. This is ugly, but necessary.
-        def fake_add_observer(fn, state):
-            state['status'] = UpstartApplicationLauncher.Timeout
-        mock_UAL.observer_add_app_stop = fake_add_observer
-        patch_UAL = patch.object(_l, 'UbuntuAppLaunch', new=mock_UAL)
-        launcher = UpstartApplicationLauncher(mock_add_detail)
-        app_id = self.getUniqueString()
-        mock_logger = Mock()
-        patch_logger = patch.object(_l, '_logger', new=mock_logger)
-        with ExitStack() as patches:
-            patches.enter_context(patch_get_loop)
-            patches.enter_context(patch_UAL)
-            patches.enter_context(patch_logger)
-
-            launcher._stop_application(app_id)
-
-            mock_logger.error.assert_called_once_with(
-                "Timed out waiting for Application with app_id '%s' to stop.",
-                app_id
-            )
-
-
 class ApplicationLauncherInternalTests(TestCase):
 
     def test_get_app_env_from_string_hint_returns_qt_env(self):
@@ -873,24 +375,6 @@
                 get_application_launcher_wrapper(""), Equals(None)
             )
 
-    def test_get_click_manifest_returns_python_object(self):
-        example_manifest = """
-            [{
-                "description": "Calculator application",
-                "framework": "ubuntu-sdk-13.10",
-                "hooks": {
-                    "calculator": {
-                        "apparmor": "apparmor/calculator.json",
-                        "desktop": "ubuntu-calculator-app.desktop"
-                    }
-                },
-                "icon": "calculator64.png"
-            }]
-        """
-        with patch.object(_l.subprocess, 'check_output') as check_output:
-            check_output.return_value = example_manifest
-            self.assertThat(_get_click_manifest(), IsInstance(list))
-
     @patch.object(_l.psutil, 'pid_exists')
     def test_is_process_running_checks_with_pid(self, pid_exists):
         pid_exists.return_value = True

=== modified file 'debian/control'
--- debian/control	2014-08-06 06:05:02 +0000
+++ debian/control	2017-03-03 23:28:24 +0000
@@ -10,7 +10,6 @@
                gir1.2-gconf-2.0,
                gir1.2-gtk-3.0,
                gir1.2-ibus-1.0,
-               gir1.2-ubuntu-app-launch-2,
                graphviz,
                liblttng-ust-dev,
                python-all-dev (>= 2.6),
@@ -44,7 +43,6 @@
 Depends: ${misc:Depends},
          ${python:Depends},
          python-gi,
-         gir1.2-ubuntu-app-launch-2,
          python-contextlib2,
          python-dbus,
          python-decorator,