Merge lp:~heber013/ubuntu-system-tests/fix-gnome-software-tests into lp:ubuntu-system-tests

[Heber Parrucci]

Fixing some gnome-software tests and adding new ones.

Fixing some gnome-software tests and adding new ones.

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

PASSED: Continuous integration, rev:582
https://platform-qa-jenkins.ubuntu.com/job/ubuntu-system-tests-ci/1331/
Executed test runs:
    None: https://platform-qa-jenkins.ubuntu.com/job/generic-update-mp/2464/console

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

review: Approve (continuous-integration)

Unmerged revisions

582. By Heber Parrucci on 2018-01-30

Fixing some gnome-software tests and adding new ones.

=== modified file 'ubuntu_system_tests/helpers/application.py'
--- ubuntu_system_tests/helpers/application.py	2018-01-17 16:37:00 +0000
+++ ubuntu_system_tests/helpers/application.py	2018-01-30 13:22:26 +0000
@@ -220,3 +220,8 @@
     def remove(self):
         cmd = ['apt', 'remove', self.app_name, '-y']
         run_command_with_sudo(cmd)
+
+    def ensure_uninstalled(self):
+        if self._is_installed():
+            cmd = ['apt', 'remove', self.app_name, '-y']
+            run_command_with_sudo(cmd)

=== modified file 'ubuntu_system_tests/helpers/gnome_sofware/cpo.py'
--- ubuntu_system_tests/helpers/gnome_sofware/cpo.py	2018-01-18 20:52:36 +0000
+++ ubuntu_system_tests/helpers/gnome_sofware/cpo.py	2018-01-30 13:22:26 +0000
@@ -168,30 +168,45 @@
         """Open the featured app's description
         :return The page with the featured app's description
         """
+        time.sleep(10)
         item = self.proxy.wait_select_single(BuilderName='GsFeatureTile', visible=True)
-        box = item.wait_select_single(BuilderName='box')
-        # This line throws an exception:
+        box = item.wait_select_single(BuilderName='box',
+                                      visible=True,
+                                      sensitive=True,
+                                      focus_on_click=True)
         input_manager.pointer.click_object(box)
         self.proxy.wait_select_single(
             BuilderName='box_details',
             visible=True)
         return ItemDetailsPage(self.proxy.select_single(BuilderName='details_page'))
 
+    @retry(stop_max_attempt_number=5,
+           wait_fixed=3000,
+           retry_on_exception=lambda exception: isinstance(
+               exception, ValueError))
+    def click_installed_tab(self):
+        """Click on installed tab"""
+        installed_button = self.proxy.select_single(BuilderName='button_installed_box',
+                                                    visible=True)
+        input_manager.pointer.click_object(installed_button)
+        return InstalledPage(self.proxy)
+
 
 class ResultsPage(GnomeSoftwareCPO):
     def __init__(self, proxy):
         super().__init__(proxy)
+        self.results = []
 
     def get_results(self, *args, **kwargs):
         """Get the current results
         :return the list with the current results or empty
         """
+        search = self.proxy.wait_select_single(BuilderName='list_box_search',
+                                               *args,
+                                               **kwargs)
         attempts = 1
         retries = kwargs.pop('retries', 10)
         wait = kwargs.pop('wait', 5)
-        search = self.proxy.wait_select_single(BuilderName='list_box_search',
-                                               *args,
-                                               **kwargs)
         # Wait until search finishes and return results
         while attempts < retries:
             try:
@@ -201,10 +216,12 @@
             except (DBusException, StateNotFoundError):
                 time.sleep(wait)
                 if search.get_children():
-                    return search.get_children()
+                    self.results = search.get_children()
+                    return self.results
                 attempts += 1
                 continue
-        return []
+        self.results = []
+        return self.results
 
     @staticmethod
     def check_item(item, *args):
@@ -252,9 +269,49 @@
             visible=True)
         return ItemDetailsPage(self.proxy.select_single(BuilderName='details_page'))
 
+    def no_app_found(self):
+        """Check if no apps were found in the search results
+        :return True if no apps were found, False otherwise
+        """
+        try:
+            self.proxy.select_single(BuilderName='noresults_grid_search',
+                                     visible=True)
+            return True
+        except (DBusException, StateNotFoundError):
+            return False
+
+    def get_item_details(self, app_name, **kwargs):
+        """Get an item details from the results page
+        :param app_name: the app name to look in the results
+        :param kwargs: the filters to apply for the app details
+        :return: the item details page if found or none
+        """
+        if not self.results:
+            self.get_results()
+        for item in self.results:
+            if item.select_single(BuilderName='name_label').label == app_name:
+                item_details = self.open_item(item)
+                if item_details.check_details(**kwargs):
+                    return item_details
+                super().click_back_button()
+        return None
+
+    def get_item(self, app_name):
+        """Get an item from the results page
+        :param app_name: the app name to look in the results
+        :return: the item object if found or none
+        """
+        for item in self.results:
+            if item.select_single(BuilderName='name_label').label == app_name:
+                return item
+        return None
+
 
 class ItemDetailsPage(GnomeSoftwareCPO):
     """Represent an item details"""
+
+    mapping = {'developer': 'label_details_developer_value'}
+
     def __init__(self, item_details_proxy):
         super().__init__(item_details_proxy)
 
@@ -268,3 +325,74 @@
             return description_box.wait_select_many('GtkLabel')
         except (DBusException, StateNotFoundError):
             return []
+
+    def check_details(self, **kwargs):
+        """
+        Check if the item contains all attributes passed as parameter
+        :param kwargs: the list of attributes to check
+        :return: True if all attributes were found in the item, False otherwise
+        """
+        for _k, _v in kwargs.items():
+            if not self.proxy.select_single(BuilderName=self.mapping.get(_k)).label == _v:
+                return False
+        return True
+
+    @retry(stop_max_attempt_number=10,
+           wait_fixed=3000,
+           retry_on_exception=lambda exception: isinstance(
+               exception, ValueError))
+    def click_install(self):
+        """Click install button"""
+        install_btn = self.proxy.wait_select_single(BuilderName='button_install',
+                                                    visible=True,
+                                                    can_focus=True)
+        input_manager.pointer.click_object(install_btn)
+        return self
+
+    @retry(stop_max_attempt_number=15,
+           wait_fixed=3000,
+           retry_on_exception=lambda exception: isinstance(
+               exception, ValueError))
+    def click_launch(self):
+        """Click launch button"""
+        launch_btn = self.proxy.wait_select_single(BuilderName='button_details_launch',
+                                                   visible=True,
+                                                   can_focus=True)
+        input_manager.pointer.click_object(launch_btn)
+
+
+class InstalledPage(GnomeSoftwareCPO):
+    """Represent installed tab section"""
+    def __init__(self, proxy):
+        super().__init__(proxy)
+
+    def get_header(self):
+        """Get the header object"""
+        header = self.proxy.wait_select_single(BuilderName='header', visible=True)
+        return header
+
+    @retry(stop_max_attempt_number=5,
+           wait_fixed=3000,
+           retry_on_exception=lambda exception: isinstance(
+               exception, ValueError) or isinstance(exception, StateNotFoundError))
+    def click_check_mark(self):
+        """Click on check mark button"""
+        check_mark = self.get_header().select_single(
+            'GtkButton',
+            visible=True).select_single(
+            'GtkBox',
+            visible=True)
+        input_manager.pointer.click_object(check_mark)
+        return self
+
+    def get_check_boxes(self):
+        """Get installed apps checkboxes"""
+        return self.proxy.wait_select_many(BuilderName='checkbox', visible=True)
+
+    def get_header_selection_menu(self):
+        """Get the header selection menu object"""
+        try:
+            return self.proxy.wait_select_single(BuilderName='header_selection_menu_button',
+                                                 visible=True)
+        except (DBusException, StateNotFoundError):
+            return None

=== added directory 'ubuntu_system_tests/helpers/krita'
=== added file 'ubuntu_system_tests/helpers/krita/__init__.py'
--- ubuntu_system_tests/helpers/krita/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/krita/__init__.py	2018-01-30 13:22:26 +0000
@@ -0,0 +1,19 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2018 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/>.
+#

=== added file 'ubuntu_system_tests/helpers/krita/app.py'
--- ubuntu_system_tests/helpers/krita/app.py	1970-01-01 00:00:00 +0000
+++ ubuntu_system_tests/helpers/krita/app.py	2018-01-30 13:22:26 +0000
@@ -0,0 +1,30 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+
+#
+# Ubuntu System Tests
+# Copyright (C) 2018 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.application import Deb
+
+APP_NAME = 'krita'
+APP_ID = 'org.gnome.Krita'
+
+
+class Krita(Deb):
+
+    def __init__(self):
+        super().__init__(APP_NAME, APP_ID)

=== modified file 'ubuntu_system_tests/host/target_setup.py'
--- ubuntu_system_tests/host/target_setup.py	2018-01-16 17:19:00 +0000
+++ ubuntu_system_tests/host/target_setup.py	2018-01-30 13:22:26 +0000
@@ -605,7 +605,7 @@
             ['systemctl', 'enable', service_name])
 
 
-def main(config_path, snapd_https_proxy, snapd_http_proxy, username):
+def main(config_path, snapd_https_proxy=None, snapd_http_proxy=None, username=None):
     with open(config_path, 'r') as f:
         config_json = json.loads(f.read())
     runner = SetupRunner(config_json, snapd_https_proxy, snapd_http_proxy)

=== modified file 'ubuntu_system_tests/tests/test_gnome_software.py'
--- ubuntu_system_tests/tests/test_gnome_software.py	2018-01-18 21:17:21 +0000
+++ ubuntu_system_tests/tests/test_gnome_software.py	2018-01-30 13:22:26 +0000
@@ -15,18 +15,23 @@
 #
 # 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.introspection import get_proxy_object_for_existing_process
 from testtools import skipIf, skip
 
+from ubuntu_system_tests.helpers.entangle.app import Entangle
+from ubuntu_system_tests.helpers.gnome_core_apps.gnome_calculator.app import GnomeCalculator
+from ubuntu_system_tests.helpers.gnome_sofware.app import GnomeSoftware
+from ubuntu_system_tests.helpers.gnome_sofware.cpo import GnomeSoftwareCPO
+from ubuntu_system_tests.helpers.krita.app import Krita
+from ubuntu_system_tests.helpers.processes import (
+    is_process_running,
+    stop_process,
+    get_process_id
+)
 from ubuntu_system_tests.helpers.session.release import get_release, XENIAL
-
-from ubuntu_system_tests.helpers.gnome_sofware.cpo import GnomeSoftwareCPO
-from ubuntu_system_tests.helpers.testbed import run_command
-from ubuntu_system_tests.helpers.gnome_sofware.app import GnomeSoftware
+from ubuntu_system_tests.helpers.snapd.snapd import Snapd
+from ubuntu_system_tests.helpers.testbed import run_command, run_command_with_sudo
 from ubuntu_system_tests.tests.base import BaseUbuntuSystemTestCase
-from ubuntu_system_tests.helpers.snapd.snapd import Snapd
-from ubuntu_system_tests.helpers.chromium.app import Chromium
-from ubuntu_system_tests.helpers.entangle.app import Entangle
 
 
 class TestGnomeSoftware(BaseUbuntuSystemTestCase):
@@ -169,13 +174,84 @@
         for item in items:
             self.assertTrue(self.app.check_item(item, 'image'))
 
-    @skip('This test never passes, open_featured_app function needs to be fixed')
     def test_featured_application_description(self):
         """Check there is a description after clicking the featured
         application image"""
         featured_details = self.app.open_featured_app()
         self.assertTrue(featured_details.check_description())
 
+    def test_check_installed_tab(self):
+        """Check installed tab"""
+        installed_page = self.app.click_installed_tab()
+        installed_page.click_check_mark()
+        self.assertIsNotNone(installed_page.get_header_selection_menu())
+        self.assertGreater(installed_page.get_check_boxes(), 1)
+
+    def test_search_not_found(self):
+        """Search for a non-existent app and verify no results are found"""
+        self.app.click_search_button()
+        results_page = self.app.write_search('nonexistent-app123')
+        self.assertTrue(results_page.no_app_found())
+
+    def test_launch_app(self):
+        # Perform the search
+        self.app.click_search_button()
+        results_page = self.app.write_search('cheese')
+        results = results_page.get_results()
+        item = results[0]
+        # Open item and check details
+        item_details = results_page.open_item(item)
+        item_details.click_launch()
+        self.assertTrue(is_process_running('cheese'))
+
+
+class TestLaunchDebApp(BaseUbuntuSystemTestCase):
+
+    def setUp(self):
+        super(BaseUbuntuSystemTestCase, self).setUp()
+        run_command('killall gnome-software')
+        self.root = GnomeSoftware().launch(app_type='gtk')
+        self.app = GnomeSoftwareCPO(self.root)
+
+    def test_launch_app(self):
+        # Perform the search
+        self.app.click_search_button()
+        results_page = self.app.write_search('cheese')
+        # Open item and check details
+        item_details = results_page.get_item_details('Cheese', developer='GNOME')
+        item_details.click_launch()
+        self.assertTrue(is_process_running('cheese'))
+
+    def tearDown(self):
+        super(TestLaunchDebApp, self).tearDown()
+        stop_process('cheese')
+
+
+class TestLaunchSnapApp(BaseUbuntuSystemTestCase):
+
+    def setUp(self):
+        super(TestLaunchSnapApp, self).setUp()
+        self.snapd = Snapd()
+        self.snap_app = 'gnome-sudoku'
+        run_command('killall gnome-software')
+        if not self.snapd.is_installed(self.snap_app):
+            self.snapd.install(self.snap_app)
+            self.addCleanup(self.snapd.remove, self.snap_app)
+        self.root = GnomeSoftware().launch(app_type='gtk')
+        self.cpo = GnomeSoftwareCPO(self.root)
+
+    def test_launch_app(self):
+        # Perform the search
+        self.cpo.click_search_button()
+        results_page = self.cpo.write_search(self.snap_app)
+        item_details = results_page.get_item_details(self.snap_app, developer='canonical')
+        item_details.click_launch()
+        self.assertTrue(is_process_running(self.snap_app))
+
+    def tearDown(self):
+        super(TestLaunchSnapApp, self).tearDown()
+        stop_process(self.snap_app)
+
 
 class TestGnomeSoftwareMixedResults(BaseUbuntuSystemTestCase):
 
@@ -183,55 +259,40 @@
         super(TestGnomeSoftwareMixedResults, self).setUp()
         self.snapd = Snapd()
         run_command('killall gnome-software')
-        self.is_snap_installed = self.snapd.is_installed('chromium')
-        if not self.is_snap_installed:
-            self.snapd.install('chromium')
-        self.chromium = Chromium()
-        self.is_deb_installed = self.chromium._is_installed()
-        if self.is_deb_installed:
-            self.chromium.remove()
+        if self.snapd.is_installed('gnome-calculator'):
+            self.snapd.remove('gnome-calculator')
+            self.addCleanup(self.snapd.install, 'gnome-calculator')
+        self.calculator_deb = GnomeCalculator()
+        if not self.calculator_deb.is_installed():
+            self.calculator_deb.install()
+            self.addCleanup(self.calculator_deb.remove)
         self.root = GnomeSoftware().launch(app_type='gtk')
         self.app = GnomeSoftwareCPO(self.root)
 
-    @skip('This tests randomly fails, so it needs to be fixed')
     def test_mixed_results(self):
         """Check there are deb and snap versions"""
         # Perform the search
         self.app.click_search_button()
-        results_page = self.app.write_search('chromium')
+        results_page = self.app.write_search('gnome calculator')
         # Verify that there is more than one result
         results = results_page.get_results()
         self.assertTrue(len(results) > 1)
-        # Check item attributes in results
-        self.assertTrue(results_page.check_item(results[0],
-                                                'image',
-                                                'description_label'))
-        self.assertTrue(results_page.check_item(results[1],
-                                                'image',
-                                                'description_label'))
-        # Determine which result is a snap and which is a deb
-        if (results_page.get_app_name(results[0]) == 'Chromium'):
-            i = 0
-            j = 1
-        else:
-            i = 1
-            j = 0
-        # Check if the snap is visible as installed
-        self.assertTrue(results_page.check_item(results[i],
+        # Check snap attributes in results
+        snap_calculator = results_page.get_item('gnome-calculator')
+        self.assertTrue(results_page.check_item(snap_calculator,
+                                                'image',
+                                                'description_label'))
+        self.assertFalse(results_page.check_item(snap_calculator,
+                                                 'label_installed'))
+        # Check deb attributes in results
+        self.assertTrue(results_page.check_item(results_page.get_item('GNOME Calculator'),
+                                                'image',
+                                                'description_label',
+                                                'star',
                                                 'label_installed'))
-        # Check if there is rating of the deb
-        self.assertTrue(results_page.check_item(results[j],
-                                                'star'))
-        # Check if the deb is visible as not installed
-        self.assertFalse(results_page.check_item(results[j],
-                                                 'label_installed'))
 
     def tearDown(self):
         super(TestGnomeSoftwareMixedResults, self).tearDown()
-        if not self.is_snap_installed:
-            self.snapd.remove('chromium')
-        if self.is_deb_installed:
-            self.chromium.install()
 
 
 class TestGnomeSoftwareInstalledSnap(BaseUbuntuSystemTestCase):
@@ -243,10 +304,10 @@
         self.is_installed = self.snapd.is_installed('hello-unity')
         if not self.is_installed:
             self.snapd.install('hello-unity')
+            self.addCleanup(self.snapd.remove, 'hello-unity')
         self.root = GnomeSoftware().launch(app_type='gtk')
         self.app = GnomeSoftwareCPO(self.root)
 
-    @skip('In some cases this test freezes at setup, so it needs to be fixed')
     def test_check_installed_snap(self):
         """Check already installed snap"""
         # Perform the search
@@ -266,11 +327,6 @@
         item_details = results_page.open_item(item)
         self.assertTrue(item_details.check_description())
 
-    def tearDown(self):
-        super(TestGnomeSoftwareInstalledSnap, self).tearDown()
-        if not self.is_installed:
-            self.snapd.remove('hello-unity')
-
 
 class TestGnomeSoftwareNotInstalledSnap(BaseUbuntuSystemTestCase):
 
@@ -281,6 +337,7 @@
         self.is_installed = self.snapd.is_installed('hugo')
         if self.is_installed:
             self.snapd.remove('hugo')
+            self.addCleanup(self.snapd.install, 'hugo')
         self.root = GnomeSoftware().launch(app_type='gtk')
         self.app = GnomeSoftwareCPO(self.root)
 
@@ -306,11 +363,6 @@
         item_details = results_page.open_item(item)
         self.assertTrue(item_details.check_description())
 
-    def tearDown(self):
-        super(TestGnomeSoftwareNotInstalledSnap, self).tearDown()
-        if self.is_installed:
-            self.snapd.install('hugo')
-
 
 class TestGnomeSoftwareNotInstalledDeb(BaseUbuntuSystemTestCase):
 
@@ -321,6 +373,7 @@
         self.is_installed = self.entangle._is_installed()
         if self.is_installed:
             self.entangle.remove()
+            self.addCleanup(self.entangle.install)
         self.root = GnomeSoftware().launch(app_type='gtk')
         self.app = GnomeSoftwareCPO(self.root)
 
@@ -345,7 +398,27 @@
         item_details = results_page.open_item(item)
         self.assertTrue(item_details.check_description())
 
-    def tearDown(self):
-        super(TestGnomeSoftwareNotInstalledDeb, self).tearDown()
-        if self.is_installed:
-            self.entangle.install()
+
+class TestGnomeSoftwareInstallDeb(BaseUbuntuSystemTestCase):
+
+    def setUp(self):
+        super(TestGnomeSoftwareInstallDeb, self).setUp()
+        run_command('killall gnome-software')
+        run_command_with_sudo('gnome-software')
+        self.cpo = get_proxy_object_for_existing_process(pid=get_process_id('gnome-software'))
+        self.app = Krita()
+        self.app.ensure_uninstalled()
+
+    @skip('WIP')
+    def test_install_deb_app(self):
+        """Install a deb package"""
+        # Perform the search
+        self.cpo.click_search_button()
+        results_page = self.cpo.write_search('krita')
+        results_page.get_results()
+        # Get the item we want to install
+        item_details_page = results_page.get_item_details('Krita', developer='KDE')
+        self.assertIsNotNone(item_details_page)
+        item_details_page.click_install()
+        self.addCleanup(self.app.ensure_uninstalled)
+        self.assertTrue(self.app.is_installed())