Merge ~xnox/autopilot:master into autopilot:master

[Dimitri John Ledkov]

Drop ual support, blocking groovy transitions.

[Paride Legovini (paride)]

The proposed change looks reasonable to me, however I do not use autopilot so I'm probably not the best person to review this. I will approve but won't merge.

review: Approve

Unmerged commits

20f75d0... by Dimitri John Ledkov on 2020-06-04

Drop upstart, click, ubuntu-app-launch support. All of those things are removed from the Ubuntu Archive.

* Drop upstart, click, ubuntu-app-launch support. All of those things
  are removed from the Ubuntu Archive.
* No-change rebuild to drop python3.7.

diff --git a/autopilot/application/__init__.py b/autopilot/application/__init__.py
index 8ebda84..efaac1e 100644
--- a/autopilot/application/__init__.py
+++ b/autopilot/application/__init__.py
@@ -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',
     'NormalApplicationLauncher',
-    'UpstartApplicationLauncher',
     'get_application_launcher_wrapper',
 ]
diff --git a/autopilot/application/_launcher.py b/autopilot/application/_launcher.py
index 8ec391f..72fef39 100644
--- a/autopilot/application/_launcher.py
+++ b/autopilot/application/_launcher.py
@@ -20,12 +20,7 @@
 """Base module for application launchers."""
 
 import fixtures
-from gi import require_version
-try:
-    require_version('UbuntuAppLaunch', '3')
-except ValueError:
-    require_version('UbuntuAppLaunch', '2')
-from gi.repository import GLib, UbuntuAppLaunch
+from gi.repository import GLib
 
 import json
 import logging
@@ -81,233 +76,6 @@ class ApplicationLauncher(FixtureWithDirectAddDetail):
         raise NotImplementedError("Sub-classes must implement this method.")
 
 
-class UpstartApplicationLauncher(ApplicationLauncher):
-
-    """A launcher class that launches applications with UpstartAppLaunch."""
-    __doc__ += ApplicationLauncher.__doc__
-
-    Timeout = object()
-    Failed = object()
-    Started = object()
-    Stopped = object()
-
-    def launch(self, app_id, app_uris=[]):
-        """Launch an application with upstart.
-
-        This method launches an application via the ``upstart-app-launch``
-        library, on platforms that support it.
-
-        Usage is similar to NormalApplicationLauncher::
-
-            from autopilot.application import UpstartApplicationLauncher
-            launcher = UpstartApplicationLauncher()
-            launcher.setUp()
-            app_proxy = launcher.launch('gallery-app')
-
-        :param app_id: name of the application to launch
-        :param app_uris: list of separate application uris to launch
-        :raises RuntimeError: If the specified application cannot be launched.
-
-        :returns: proxy object for the launched package application
-
-        """
-        if isinstance(app_uris, str):
-            app_uris = [app_uris]
-        if isinstance(app_uris, bytes):
-            app_uris = [app_uris.decode()]
-        _logger.info(
-            "Attempting to launch application '%s' with URIs '%s' via "
-            "upstart-app-launch",
-            app_id,
-            ','.join(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', '')
-        )
-        pid = self._get_pid_for_launched_app(app_id)
-
-        return self._get_proxy_object(pid)
-
-    def _get_proxy_object(self, pid):
-        return get_proxy_object_for_existing_process(
-            dbus_bus=self.dbus_bus,
-            emulator_base=self.proxy_base,
-            pid=pid
-        )
-
-    @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)
-
-    @staticmethod
-    def _get_user_unit_match(app_id):
-        return 'ubuntu-app-launch-*-%s-*.service' % app_id
-
-    def _attach_application_log(self, app_id):
-        j = journal.Reader()
-        j.log_level(journal.LOG_INFO)
-        j.add_match(_SYSTEMD_USER_UNIT=self._get_user_unit_match(app_id))
-        log_data = ''
-        for i in j:
-            log_data += str(i) + '\n'
-        if len(log_data) > 0:
-            self.caseAddDetail('Application Log (%s)' % app_id,
-                               safe_text_content(log_data))
-
-    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 AlreadyLaunchedUpstartLauncher(UpstartApplicationLauncher):
-    """Launcher that doesn't wait for a proxy object.
-
-    This is useful when you are 're-launching' an already running application
-    and it's state has changed to suspended.
-
-    """
-
-    def _get_proxy_object(self, pid):
-        # Don't wait for a proxy object
-        return None
-
-
-class ClickApplicationLauncher(UpstartApplicationLauncher):
-
-    """Fixture to manage launching a Click application."""
-    __doc__ += ApplicationLauncher.__doc__
-
-    def launch(self, package_id, app_name=None, app_uris=[]):
-        """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 NormalApplicationLauncher.launch::
-
-            from autopilot.application import ClickApplicationLauncher
-            launcher = ClickApplicationLauncher()
-            launcher.setUp()
-            app_proxy = launcher.launch('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.
-
-        :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, str):
-            app_uris = [app_uris]
-        if isinstance(app_uris, bytes):
-            app_uris = [app_uris.decode()]
-        _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)
-        )
-        app_id = _get_click_app_id(package_id, app_name)
-        return super().launch(app_id, app_uris)
-
-
 class NormalApplicationLauncher(ApplicationLauncher):
 
     """Fixture to manage launching an application."""
@@ -470,35 +238,6 @@ def launch_process(application, args, capture_output=False, **kwargs):
     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.")
diff --git a/autopilot/testcase.py b/autopilot/testcase.py
index af8c2d4..8360eea 100644
--- a/autopilot/testcase.py
+++ b/autopilot/testcase.py
@@ -57,9 +57,7 @@ from testtools.testcase import _ExpectedFailure
 from unittest.case import SkipTest
 
 from autopilot.application import (
-    ClickApplicationLauncher,
     NormalApplicationLauncher,
-    UpstartApplicationLauncher,
 )
 from autopilot.display import Display, get_screenshot_data
 from autopilot.globals import get_debug_profile_fixture, get_test_timeout
@@ -285,78 +283,6 @@ class AutopilotTestCase(TestWithScenarios, TestCase, KeybindingsHelper):
         )
         return launcher.launch(application, arguments, **launch_args)
 
-    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
-
-        """
-        launcher = self.useFixture(
-            ClickApplicationLauncher(
-                case_addDetail=self.addDetailUniqueName,
-                **kwargs
-            )
-        )
-        return launcher.launch(package_id, app_name, app_uris)
-
-    def launch_upstart_application(self, application_name, uris=[],
-                                   launcher_class=UpstartApplicationLauncher,
-                                   **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.
-        :param launcher_class: The application launcher class to use. Useful if
-        you need to overwrite the default to do something custom (i.e. using
-          AlreadyLaunchedUpstartLauncher)
-        :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.
-        """
-        launcher = self.useFixture(
-            launcher_class(
-                case_addDetail=self.addDetailUniqueName,
-                **kwargs
-            )
-        )
-        return launcher.launch(application_name, uris)
-
     def _compare_system_with_app_snapshot(self):
         """Compare the currently running application with the last snapshot.
 
diff --git a/autopilot/tests/functional/test_ap_apps.py b/autopilot/tests/functional/test_ap_apps.py
index 71d5928..de66fa0 100644
--- a/autopilot/tests/functional/test_ap_apps.py
+++ b/autopilot/tests/functional/test_ap_apps.py
@@ -37,7 +37,6 @@ from fixtures import EnvironmentVariable
 
 from autopilot.application import (
     NormalApplicationLauncher,
-    UpstartApplicationLauncher,
 )
 from autopilot.exceptions import ProcessSearchError
 from autopilot.process import ProcessManager
@@ -296,12 +295,6 @@ class QtTests(ApplicationTests, QmlTestMixin):
         )
         self.assertTrue(app_proxy is not None)
 
-    def test_can_launch_upstart_app(self):
-        path = self.get_qml_viewer_app_path()
-        fixture = self.useFixture(TempDesktopFile(exec_=path,))
-        launcher = self.useFixture(UpstartApplicationLauncher())
-        launcher.launch(fixture.get_desktop_file_id())
-
     @skipIf(model() != "Desktop", "Only suitable on Desktop (Qt4)")
     def test_can_launch_normal_qt_script(self):
         path = self.write_script(dedent("""\
diff --git a/autopilot/tests/functional/test_application_launcher.py b/autopilot/tests/functional/test_application_launcher.py
index f9c1e48..7e16a0c 100644
--- a/autopilot/tests/functional/test_application_launcher.py
+++ b/autopilot/tests/functional/test_application_launcher.py
@@ -44,53 +44,3 @@ class AutopilotTestCaseClassTests(TestCase):
             uf.return_value.launch.assert_called_once_with('a', ('b', 'c'))
             self.assertEqual(result, uf.return_value.launch.return_value)
 
-    @patch('autopilot.testcase.ClickApplicationLauncher')
-    def test_launch_click_package(self, cal):
-        class LauncherTest(AutopilotTestCase):
-
-            """Test launchers."""
-
-            def test_anything(self):
-                pass
-
-        test_case = LauncherTest('test_anything')
-        with patch.object(test_case, 'useFixture') as uf:
-            result = test_case.launch_click_package('a', 'b', ['c', 'd'])
-            uf.assert_called_once_with(cal.return_value)
-            uf.return_value.launch.assert_called_once_with(
-                'a', 'b', ['c', 'd']
-            )
-            self.assertEqual(result, uf.return_value.launch.return_value)
-
-    @patch('autopilot.testcase.UpstartApplicationLauncher')
-    def test_launch_upstart_application_defaults(self, ual):
-        class LauncherTest(AutopilotTestCase):
-
-            """Test launchers."""
-
-            def test_anything(self):
-                pass
-
-        test_case = LauncherTest('test_anything')
-        with patch.object(test_case, 'useFixture') as uf:
-            result = test_case.launch_upstart_application(
-                'a', ['b'], launcher_class=ual
-            )
-            uf.assert_called_once_with(ual.return_value)
-            uf.return_value.launch.assert_called_once_with('a', ['b'])
-            self.assertEqual(result, uf.return_value.launch.return_value)
-
-    def test_launch_upstart_application_custom_launcher(self):
-        class LauncherTest(AutopilotTestCase):
-
-            """Test launchers."""
-
-            def test_anything(self):
-                pass
-
-        test_case = LauncherTest('test_anything')
-        self.assertRaises(
-            NotImplementedError,
-            test_case.launch_upstart_application,
-            'a', ['b'], launcher_class=_launcher.ApplicationLauncher
-        )
diff --git a/autopilot/tests/unit/test_application_launcher.py b/autopilot/tests/unit/test_application_launcher.py
index 3de7819..af92c42 100644
--- a/autopilot/tests/unit/test_application_launcher.py
+++ b/autopilot/tests/unit/test_application_launcher.py
@@ -36,9 +36,7 @@ from testtools.content import text_content
 from unittest.mock import MagicMock, Mock, patch
 
 from autopilot.application import (
-    ClickApplicationLauncher,
     NormalApplicationLauncher,
-    UpstartApplicationLauncher,
 )
 from autopilot.application._environment import (
     GtkApplicationEnvironment,
@@ -53,8 +51,6 @@ from autopilot.application._launcher import (
     _get_app_env_from_string_hint,
     _get_application_environment,
     _get_application_path,
-    _get_click_app_id,
-    _get_click_manifest,
     _is_process_running,
     _kill_process,
 )
@@ -261,635 +257,6 @@ class NormalApplicationLauncherTests(TestCase):
             )
 
 
-class ClickApplicationLauncherTests(TestCase):
-
-    def test_raises_exception_on_unknown_kwargs(self):
-        self.assertThat(
-            lambda: ClickApplicationLauncher(self.addDetail, unknown=True),
-            raises(TypeError("__init__() got an unexpected keyword argument "
-                             "'unknown'"))
-        )
-
-    @patch('autopilot.application._launcher._get_click_app_id')
-    def test_handle_string(self, gcai):
-        class FakeUpstartBase(_l.ApplicationLauncher):
-            launch_call_args = []
-
-            def launch(self, *args):
-                FakeUpstartBase.launch_call_args = list(args)
-
-        patcher = patch.object(
-            _l.ClickApplicationLauncher,
-            '__bases__',
-            (FakeUpstartBase,)
-        )
-        token = self.getUniqueString()
-        with patcher:
-            # Prevent mock from trying to delete __bases__
-            patcher.is_local = True
-            launcher = self.useFixture(
-                _l.ClickApplicationLauncher())
-            launcher.launch('', '', token)
-        self.assertEqual(
-            FakeUpstartBase.launch_call_args,
-            [gcai.return_value, [token]])
-
-    @patch('autopilot.application._launcher._get_click_app_id')
-    def test_handle_bytes(self, gcai):
-        class FakeUpstartBase(_l.ApplicationLauncher):
-            launch_call_args = []
-
-            def launch(self, *args):
-                FakeUpstartBase.launch_call_args = list(args)
-
-        patcher = patch.object(
-            _l.ClickApplicationLauncher,
-            '__bases__',
-            (FakeUpstartBase,)
-        )
-        token = self.getUniqueString()
-        with patcher:
-            # Prevent mock from trying to delete __bases__
-            patcher.is_local = True
-            launcher = self.useFixture(
-                _l.ClickApplicationLauncher())
-            launcher.launch('', '', token.encode())
-        self.assertEqual(
-            FakeUpstartBase.launch_call_args,
-            [gcai.return_value, [token]])
-
-    @patch('autopilot.application._launcher._get_click_app_id')
-    def test_handle_list(self, gcai):
-        class FakeUpstartBase(_l.ApplicationLauncher):
-            launch_call_args = []
-
-            def launch(self, *args):
-                FakeUpstartBase.launch_call_args = list(args)
-
-        patcher = patch.object(
-            _l.ClickApplicationLauncher,
-            '__bases__',
-            (FakeUpstartBase,)
-        )
-        token = self.getUniqueString()
-        with patcher:
-            # Prevent mock from trying to delete __bases__
-            patcher.is_local = True
-            launcher = self.useFixture(
-                _l.ClickApplicationLauncher())
-            launcher.launch('', '', [token])
-        self.assertEqual(
-            FakeUpstartBase.launch_call_args,
-            [gcai.return_value, [token]])
-
-    @patch('autopilot.application._launcher._get_click_app_id')
-    def test_call_get_click_app_id(self, gcai):
-        class FakeUpstartBase(_l.ApplicationLauncher):
-            launch_call_args = []
-
-            def launch(self, *args):
-                FakeUpstartBase.launch_call_args = list(args)
-
-        patcher = patch.object(
-            _l.ClickApplicationLauncher,
-            '__bases__',
-            (FakeUpstartBase,)
-        )
-        token_a = self.getUniqueString()
-        token_b = self.getUniqueString()
-        with patcher:
-            # Prevent mock from trying to delete __bases__
-            patcher.is_local = True
-            launcher = self.useFixture(
-                _l.ClickApplicationLauncher())
-            launcher.launch(token_a, token_b)
-        gcai.assert_called_once_with(token_a, token_b)
-
-    @patch('autopilot.application._launcher._get_click_app_id')
-    def test_call_upstart_launch(self, gcai):
-        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 = self.useFixture(
-                _l.ClickApplicationLauncher())
-            launcher.launch('', '')
-            self.assertEqual(launcher.launch_call_args,
-                             [gcai.return_value, []])
-
-
-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_raises_exception_on_unknown_kwargs(self):
-        self.assertThat(
-            lambda: UpstartApplicationLauncher(self.addDetail, unknown=True),
-            raises(TypeError("__init__() got an unexpected keyword argument "
-                             "'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))
-
-    @patch('autopilot.application._launcher.UbuntuAppLaunch')
-    @patch('autopilot.application._launcher.'
-           'get_proxy_object_for_existing_process')
-    def test_handle_string(self, gpofep, ual):
-        launcher = UpstartApplicationLauncher()
-        token_a = self.getUniqueString()
-        token_b = self.getUniqueString()
-        with patch.object(launcher, '_launch_app') as la:
-            with patch.object(launcher, '_get_pid_for_launched_app'):
-                with patch.object(launcher, '_get_glib_loop'):
-                    launcher.launch(token_a, token_b)
-                    la.assert_called_once_with(token_a, [token_b])
-
-    @patch('autopilot.application._launcher.UbuntuAppLaunch')
-    @patch('autopilot.application._launcher.'
-           'get_proxy_object_for_existing_process')
-    def test_handle_bytes(self, gpofep, ual):
-        launcher = UpstartApplicationLauncher()
-        token_a = self.getUniqueString()
-        token_b = self.getUniqueString()
-        with patch.object(launcher, '_launch_app') as la:
-            with patch.object(launcher, '_get_pid_for_launched_app'):
-                with patch.object(launcher, '_get_glib_loop'):
-                    launcher.launch(token_a, token_b.encode())
-                    la.assert_called_once_with(token_a, [token_b])
-
-    @patch('autopilot.application._launcher.UbuntuAppLaunch')
-    @patch('autopilot.application._launcher.'
-           'get_proxy_object_for_existing_process')
-    def test_handle_list(self, gpofep, ual):
-        launcher = UpstartApplicationLauncher()
-        token_a = self.getUniqueString()
-        token_b = self.getUniqueString()
-        with patch.object(launcher, '_launch_app') as la:
-            with patch.object(launcher, '_get_pid_for_launched_app'):
-                with patch.object(launcher, '_get_glib_loop'):
-                    launcher.launch(token_a, [token_b])
-                    la.assert_called_once_with(token_a, [token_b])
-
-    @patch('autopilot.application._launcher.UbuntuAppLaunch')
-    @patch('autopilot.application._launcher.'
-           'get_proxy_object_for_existing_process')
-    def test_calls_get_pid(self, gpofep, ual):
-        launcher = UpstartApplicationLauncher()
-        token = self.getUniqueString()
-        with patch.object(launcher, '_launch_app'):
-            with patch.object(launcher, '_get_pid_for_launched_app') as gp:
-                with patch.object(launcher, '_get_glib_loop'):
-                    launcher.launch(token)
-                    gp.assert_called_once_with(token)
-
-    @patch('autopilot.application._launcher.UbuntuAppLaunch')
-    @patch('autopilot.application._launcher.'
-           'get_proxy_object_for_existing_process')
-    def test_gets_correct_proxy_object(self, gpofep, ual):
-        launcher = UpstartApplicationLauncher()
-        with patch.object(launcher, '_launch_app'):
-            with patch.object(launcher, '_get_pid_for_launched_app') as gp:
-                with patch.object(launcher, '_get_glib_loop'):
-                    launcher.launch('')
-                    gpofep.assert_called_once_with(pid=gp.return_value,
-                                                   emulator_base=None,
-                                                   dbus_bus='session')
-
-    @patch('autopilot.application._launcher.UbuntuAppLaunch')
-    @patch('autopilot.application._launcher.'
-           'get_proxy_object_for_existing_process')
-    def test_returns_proxy_object(self, gpofep, ual):
-        launcher = UpstartApplicationLauncher()
-        with patch.object(launcher, '_launch_app'):
-            with patch.object(launcher, '_get_pid_for_launched_app'):
-                with patch.object(launcher, '_get_glib_loop'):
-                    result = launcher.launch('')
-                    self.assertEqual(result, gpofep.return_value)
-
-    @patch('autopilot.application._launcher.UbuntuAppLaunch')
-    @patch('autopilot.application._launcher.'
-           'get_proxy_object_for_existing_process')
-    def test_calls_get_glib_loop(self, gpofep, ual):
-        launcher = UpstartApplicationLauncher()
-        with patch.object(launcher, '_launch_app'):
-            with patch.object(launcher, '_get_pid_for_launched_app'):
-                with patch.object(launcher, '_get_glib_loop') as ggl:
-                    launcher.launch('')
-                    ggl.assert_called_once_with()
-
-    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)
-        j = MagicMock(spec=_l.journal.Reader)
-        with patch.object(_l.journal, 'Reader', return_value=j):
-            launcher._attach_application_log(app_id)
-            expected = launcher._get_user_unit_match(app_id)
-            j.add_match.assert_called_once_with(_SYSTEMD_USER_UNIT=expected)
-            self.assertEqual(0, case_addDetail.call_count)
-
-    def test_attach_application_log_attaches_log(self):
-        token = self.getUniqueString()
-        case_addDetail = Mock()
-        launcher = UpstartApplicationLauncher(case_addDetail)
-        app_id = self.getUniqueString()
-        j = MagicMock(spec=_l.journal.Reader)
-        j.__iter__ = lambda x: iter([token])
-        with patch.object(_l.journal, 'Reader', return_value=j):
-            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 (%s)" % app_id,
-                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):
@@ -1098,24 +465,6 @@ class ApplicationLauncherInternalTests(TestCase):
                 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
diff --git a/debian/changelog b/debian/changelog
index b1b6624..a951fae 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,16 @@
+autopilot (1.6.0+17.04.20170313-0ubuntu9) groovy; urgency=medium
+
+  * Drop upstart, click, ubuntu-app-launch support. All of those things
+    are removed from the Ubuntu Archive.
+
+ -- Dimitri John Ledkov <[e-mail]>  Thu, 04 Jun 2020 14:10:05 +0100
+
+autopilot (1.6.0+17.04.20170313-0ubuntu8) focal; urgency=medium
+
+  * No-change rebuild to drop python3.7.
+
+ -- Matthias Klose <[e-mail]>  Tue, 18 Feb 2020 09:16:48 +0100
+
 autopilot (1.6.0+17.04.20170313-0ubuntu7) focal; urgency=medium
 
   * autopilot-vis has been removed, so removed test_vis_main which depends on
diff --git a/debian/control b/debian/control
index 30f73e8..27699b6 100644
--- a/debian/control
+++ b/debian/control
@@ -7,7 +7,6 @@ Build-Depends: debhelper (>= 9.0.0),
                dh-python,
                gir1.2-gtk-3.0,
                gir1.2-ibus-1.0,
-               gir1.2-ubuntu-app-launch-3 | gir1.2-ubuntu-app-launch-2,
                graphviz,
                libjs-jquery,
                libjs-underscore,
@@ -39,8 +38,7 @@ X-Python3-Version: >= 3.3
 
 Package: python3-autopilot
 Architecture: all
-Depends: gir1.2-ubuntu-app-launch-3 | gir1.2-ubuntu-app-launch-2,
-         libjs-jquery,
+Depends: libjs-jquery,
          libjs-underscore,
          mir-utils,
          python3-dateutil,