Merge lp:~nskaggs/ubuntu-rssreader-app/fix-ap-layout into lp:~ubuntu-shorts-dev/ubuntu-rssreader-app/trunk

[Nicholas Skaggs]

Update AP layout to best practices

Update AP layout to best practices (I did not switch off using the deprecated modules for the SDK helpers)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

review: Approve (continuous-integration)

=== modified file 'tests/autopilot/shorts_app/__init__.py'
--- tests/autopilot/shorts_app/__init__.py	2014-09-17 20:18:37 +0000
+++ tests/autopilot/shorts_app/__init__.py	2014-12-17 00:05:17 +0000
@@ -7,7 +7,6 @@
 
 """RSS reader app tests and emulators - top level package."""
 
-import os
 import logging
 from time import sleep
 
@@ -15,7 +14,6 @@
 from testtools.matchers import NotEquals
 
 from ubuntuuitoolkit import (
-    base,
     emulators as toolkit_emulators
 )
 
@@ -23,63 +21,18 @@
 logger = logging.getLogger(__name__)
 
 
-class ShortsApp():
-
-    """App class"""
-    local_location = "../../shorts-app.qml"
-    installed_location = "/usr/share/shorts-app/shorts-app.qml"
-
-    def __init__(self, test_obj):
-        """Constructor
-
-        :param test_obj: An AutopilotTestCase object
-        """
-        self.test_obj = test_obj
-        launch, self.test_type = self.setup_environment()
-        self.app = launch()
-
-    def setup_environment(self):
-        """Selects the way to launch the application"""
-        if os.path.exists(self.local_location):
-            logger.debug("Running via local installation")
-            launch = self.launch_test_local
-            test_type = 'local'
-        elif os.path.exists(self.installed_location):
-            logger.debug("Running via installed debian package")
-            launch = self.launch_test_installed
-            test_type = 'deb'
-        else:
-            logger.debug("Running via click package")
-            launch = self.launch_test_click
-            test_type = 'click'
-        return launch, test_type
-
-    def launch_test_local(self):
-        """Launch the application using a relative path"""
-        return self.test_obj.launch_test_application(
-            base.get_qmlscene_launch_command(),
-            self.local_location,
-            app_type='qt',
-            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
-
-    def launch_test_installed(self):
-        """Launch the application using the system path"""
-        return self.test_obj.launch_test_application(
-            base.get_qmlscene_launch_command(),
-            self.installed_location,
-            app_type='qt',
-            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
-
-    def launch_test_click(self):
-        """Launch the application using click package"""
-        return self.test_obj.launch_click_package(
-            "com.ubuntu.shorts",
-            emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
+class ShortsApp(object):
+
+    """Autopilot helper object for shorts."""
+
+    def __init__(self, app_proxy, test_type):
+        self.app = app_proxy
+        self.test_type = test_type
+        self.main_view = self.app.select_single(MainView)
 
     @property
-    def main_view(self):
-        """Return MainView object"""
-        return self.app.select_single(MainView)
+    def pointing_device(self):
+        return self.app.pointing_device
 
 
 class ShortsAppException(Exception):
@@ -227,7 +180,8 @@
         return self.select_single("ManageTopicsPage")
 
     def get_rss_feed_page(self):
-        return self.wait_select_single("RssFeedPage", objectName="rssfeedpage")
+        return self.wait_select_single("ArticleViewPage",
+                                       objectName="rssfeedpage")
 
     def get_shorts_tab(self):
         return self.wait_select_single("ShortsTab", objectName="Tab0")
 
=== modified file 'tests/autopilot/shorts_app/tests/__init__.py'
--- tests/autopilot/shorts_app/tests/__init__.py	2014-06-27 15:21:04 +0000
+++ tests/autopilot/shorts_app/tests/__init__.py	2014-12-17 00:05:17 +0000
@@ -20,72 +20,123 @@
 """shorts-app autopilot tests."""
 
 import os.path
-import os
 import shutil
 import logging
 
-from autopilot.input import Mouse, Touch, Pointer
 from autopilot.platform import model
+from autopilot import logging as autopilot_logging
 from autopilot.testcase import AutopilotTestCase
 
-from shorts_app import ShortsApp
+import shorts_app
+
+import ubuntuuitoolkit
+from ubuntuuitoolkit import base
+import fixtures
 
 logger = logging.getLogger(__name__)
 
 
-class ShortsAppTestCase(AutopilotTestCase):
+class BaseTestCaseWithPatchedHome(AutopilotTestCase):
 
     """A common test case class that provides several useful methods for
     rssreader-app tests.
 
     """
-    if model() == 'Desktop':
-        scenarios = [('with mouse', dict(input_device_class=Mouse))]
-    else:
-        scenarios = [('with touch', dict(input_device_class=Touch))]
-
-    sqlite_dir = os.path.expanduser(
-        "~/.local/share/com.ubuntu.shorts/Databases")
-    backup_dir = sqlite_dir + ".backup"
+
+    local_location = os.path.dirname(os.path.dirname(os.getcwd()))
+    local_location_qml = os.path.join(local_location, 'shorts-app.qml')
+    installed_location_qml = "/usr/share/shorts-app/shorts-app.qml"
+
+    def get_launcher_and_type(self):
+        if os.path.exists(self.local_location_qml):
+            launcher = self.launch_test_local
+            test_type = 'local'
+        elif os.path.exists(self.installed_location_qml):
+            launcher = self.launch_test_installed
+            test_type = 'deb'
+        else:
+            launcher = self.launch_test_click
+            test_type = 'click'
+        return launcher, test_type
 
     def setUp(self):
-        self.pointing_device = Pointer(self.input_device_class.create())
-        super(ShortsAppTestCase, self).setUp()
-        self.temp_move_sqlite_db()
-        self.addCleanup(self.restore_sqlite_db)
+        super(BaseTestCaseWithPatchedHome, self).setUp()
+        self.launcher, self.test_type = self.get_launcher_and_type()
+        self.home_dir = self.patch_home()
 
         # turn off the OSK so it doesn't block screen elements
         if model() != 'Desktop':
             os.system("stop maliit-server")
             self.addCleanup(os.system, "start maliit-server")
 
-        self.shorts_app = ShortsApp(self)
-
-    def temp_move_sqlite_db(self):
-        try:
-            shutil.rmtree(self.backup_dir)
-        except:
-            pass
-        else:
-            logger.warning("Prexisting backup database found and removed")
-
-        try:
-            shutil.move(self.sqlite_dir, self.backup_dir)
-        except:
-            logger.warning("No current database found")
-        else:
-            logger.debug("Backed up database")
-
-    def restore_sqlite_db(self):
-        if os.path.exists(self.backup_dir):
-            if os.path.exists(self.sqlite_dir):
-                try:
-                    shutil.rmtree(self.sqlite_dir)
-                except:
-                    logger.error("Failed to remove test database and restore" /
-                                 "database")
-                    return
-            try:
-                shutil.move(self.backup_dir, self.sqlite_dir)
-            except:
-                logger.error("Failed to restore database")
+    @autopilot_logging.log_action(logger.info)
+    def launch_test_local(self):
+        return self.launch_test_application(
+            base.get_qmlscene_launch_command(),
+            self.local_location_qml,
+            app_type='qt',
+            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase)
+
+    @autopilot_logging.log_action(logger.info)
+    def launch_test_installed(self):
+        return self.launch_test_application(
+            base.get_qmlscene_launch_command(),
+            self.installed_location_qml,
+            app_type='qt',
+            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase)
+
+    @autopilot_logging.log_action(logger.info)
+    def launch_test_click(self):
+        return self.launch_click_package(
+            "com.ubuntu.shorts",
+            emulator_base=ubuntuuitoolkit.UbuntuUIToolkitCustomProxyObjectBase)
+
+    def _copy_xauthority_file(self, directory):
+        """ Copy .Xauthority file to directory, if it exists in /home
+        """
+        # If running under xvfb, as jenkins does,
+        # xsession will fail to start without xauthority file
+        # Thus if the Xauthority file is in the home directory
+        # make sure we copy it to our temp home directory
+
+        xauth = os.path.expanduser(os.path.join(os.environ.get('HOME'),
+                                   '.Xauthority'))
+        if os.path.isfile(xauth):
+            logger.debug("Copying .Xauthority to %s" % directory)
+            shutil.copyfile(
+                os.path.expanduser(os.path.join(os.environ.get('HOME'),
+                                   '.Xauthority')),
+                os.path.join(directory, '.Xauthority'))
+
+    def patch_home(self):
+        """ mock /home for testing purposes to preserve user data
+        """
+
+        # if running on non-phablet device,
+        # run in temp folder to avoid mucking up home
+        # bug 1316746
+        # bug 1376423
+        if self.test_type is 'click':
+            # just use home for now on devices
+            temp_dir = os.environ.get('HOME')
+        else:
+            temp_dir_fixture = fixtures.TempDir()
+            self.useFixture(temp_dir_fixture)
+            temp_dir = temp_dir_fixture.path
+
+            # before we set fixture, copy xauthority if needed
+            self._copy_xauthority_file(temp_dir)
+            self.useFixture(fixtures.EnvironmentVariable('HOME',
+                                                         newvalue=temp_dir))
+
+            logger.debug("Patched home to fake home directory %s" % temp_dir)
+        return temp_dir
+
+
+class ShortsAppTestCase(BaseTestCaseWithPatchedHome):
+
+    """Base test case that launches shorts-app"""
+
+    def setUp(self):
+        super(ShortsAppTestCase, self).setUp()
+        self.app = shorts_app.ShortsApp(self.launcher(), self.test_type)
 
=== modified file 'tests/autopilot/shorts_app/tests/test_rssreader.py'
--- tests/autopilot/shorts_app/tests/test_rssreader.py	2014-09-17 20:18:37 +0000
+++ tests/autopilot/shorts_app/tests/test_rssreader.py	2014-12-17 00:05:17 +0000
@@ -16,8 +16,6 @@
 
 """shorts app autopilot tests."""
 
-from __future__ import absolute_import
-
 from autopilot.matchers import Eventually
 from testtools.matchers import Equals, NotEquals
 
@@ -36,7 +34,6 @@
 
     def setUp(self):
         super(BaseShortsAppTestCase, self).setUp()
-        self.shorts_app.main_view.visible.wait_for(True)
 
         # wait for any updates to finish before beginning tests
         self._wait_for_refresh()
@@ -44,18 +41,18 @@
     def _wait_for_refresh(self):
         try:
             self.assertThat(
-                self.shorts_app.main_view.get_network_activity,
+                self.app.main_view.get_network_activity,
                 Eventually(NotEquals(None), timeout=5))
             self.assertThat(
-                self.shorts_app.main_view.get_network_activity,
+                self.app.main_view.get_network_activity,
                 Eventually(Equals(None), timeout=60))
         except:
             self.assertThat(
-                self.shorts_app.main_view.get_network_activity,
+                self.app.main_view.get_network_activity,
                 Eventually(Equals(None), timeout=60))
 
     def add_feed_to_new_topic(self, feed_url, feed_title, topic):
-        add_feeds_page = self.shorts_app.main_view.go_to_add_feeds()
+        add_feeds_page = self.app.main_view.go_to_add_feeds()
         # XXX here we are using an external server because we are currently
         # using the Google Feed API, which doesn't let us access local
         # resources. --elopio - 2014-02-26
@@ -77,30 +74,30 @@
         test_topic = 'Test topic'
         self.add_feed_to_new_topic(test_feed_url, test_feed_title, test_topic)
 
-        selected_tab_title = self.shorts_app.main_view.get_selected_tab_title()
+        selected_tab_title = self.app.main_view.get_selected_tab_title()
         self.assertEqual('Test topic', selected_tab_title)
 
     def test_switch_to_list_view_mode(self):
         """ test switching to list view  mode"""
-        shorts_tab = self.shorts_app.main_view.get_shorts_tab()
+        shorts_tab = self.app.main_view.get_shorts_tab()
         self._ensure_grid_view_mode(shorts_tab)
-        self.shorts_app.main_view.change_view_mode("isNotListMode")
+        self.app.main_view.change_view_mode("isNotListMode")
         self.assertThat(shorts_tab.isListMode, Eventually(Equals(True)))
 
     def test_switch_to_grid_view_mode(self):
         """ test switching to grid view  mode"""
-        shorts_tab = self.shorts_app.main_view.get_shorts_tab()
+        shorts_tab = self.app.main_view.get_shorts_tab()
         self._ensure_list_view_mode(shorts_tab)
-        self.shorts_app.main_view.change_view_mode("isListMode")
+        self.app.main_view.change_view_mode("isListMode")
         self.assertThat(shorts_tab.isListMode, Eventually(Equals(False)))
 
     def _ensure_grid_view_mode(self, current_tab):
         if current_tab.isListMode:
-            self.shorts_app.main_view.change_view_mode("isListMode")
+            self.app.main_view.change_view_mode("isListMode")
 
     def _ensure_list_view_mode(self, current_tab):
         if not current_tab.isListMode:
-            self.shorts_app.main_view.change_view_mode("isNotListMode")
+            self.app.main_view.change_view_mode("isNotListMode")
 
     def test_open_listmode_feed_item(self):
         """"test to ensure list mode feed items can be opened"""
@@ -110,14 +107,14 @@
         test_topic = 'Test topic'
 
         self.add_feed_to_new_topic(test_feed_url, test_feed_title, test_topic)
-        new_topic_tab = self.shorts_app.main_view.get_topic_tab(test_topic)
+        new_topic_tab = self.app.main_view.get_topic_tab(test_topic)
         self._ensure_list_view_mode(new_topic_tab)
 
-        self.shorts_app.main_view.open_feed_item(test_topic, test_feed_title)
+        self.app.main_view.open_feed_item(test_topic, test_feed_title)
         self.assertEqual(
-            self.shorts_app.main_view.get_feed_in_feedlist_title(
+            self.app.main_view.get_feed_in_feedlist_title(
                 test_topic, test_feed_title),
-            self.shorts_app.main_view.get_articleviewitem_title())
+            self.app.main_view.get_articleviewitem_title())
 
     @unittest.skip("Can't see or get dynamic tabs")
     def test_edit_topic(self):
@@ -129,43 +126,43 @@
         self.add_feed_to_new_topic(test_feed_url, test_feed_title, test_topic)
 
         # verify we are on the topicName Tab
-        editTab = self.shorts_app.main_view.get_topic_tab(test_topic)
+        editTab = self.app.main_view.get_topic_tab(test_topic)
         self.assertThat(editTab.visible, Eventually(Equals(True)))
 
         # open toolbar
-        toolbar = self.shorts_app.main_view.open_toolbar()
+        toolbar = self.app.main_view.open_toolbar()
 
         # click on edit topics button
         toolbar.click_button("edittopicsbutton")
 
         # verify we are on topic management page
         topicmanagementpage = \
-            self.shorts_app.main_view.get_feed_management_page()
+            self.app.main_view.get_feed_management_page()
         self.assertThat(
             topicmanagementpage.objectName,
             Eventually(Equals("topicmanagement")))
 
         # verity Tab is expanded
-        editTopic = self.shorts_app.main_view.get_feedlist_topic(test_topic)
+        editTopic = self.app.main_view.get_feedlist_topic(test_topic)
         if editTopic.state != "expanded":
             self.pointing_device.click_object(editTopic)
 
         # select feed
-        editFeed = self.shorts_app.main_view.get_feedlist_feed(test_topic)
+        editFeed = self.app.main_view.get_feedlist_feed(test_topic)
         self.assertThat(editFeed, NotEquals(None))
         self.pointing_device.click_object(editFeed)
 
         # verify we are on edit feed page
-        editfeedpage = self.shorts_app.main_view.get_edit_feed_page()
+        editfeedpage = self.app.main_view.get_edit_feed_page()
         self.assertThat(editfeedpage.visible, Eventually(Equals(True)))
 
         # change topic from dropdown
         topicValueselector = \
-            self.shorts_app.main_view.get_editfeed_topic_valueselector()
+            self.app.main_view.get_editfeed_topic_valueselector()
         self.pointing_device.click_object(topicValueselector)
 
         # click on news topic
-        topicValueselectorValue = self.shorts_app.main_view. \
+        topicValueselectorValue = self.app.main_view. \
             get_editfeed_valueselector_value("Ubuntu")
         self.pointing_device.click_object(topicValueselectorValue)
 
@@ -186,7 +183,7 @@
 
     def test_remove_feed(self):
         """Test the removal of a feed from the Edit Feeds page."""
-        edit_feeds_page = self.shorts_app.main_view.go_to_edit_feeds()
+        edit_feeds_page = self.app.main_view.go_to_edit_feeds()
         edit_feeds_page.expand_topic(self.test_topic)
         feeds = edit_feeds_page.get_feeds_in_topic(self.test_topic)
         self.assertIn(self.test_feed_title, feeds)
@@ -196,7 +193,7 @@
 
     def test_remove_topic(self):
         """Test the removal of a topic from the Edit Topics page."""
-        edit_feeds_page = self.shorts_app.main_view.go_to_edit_feeds()
+        edit_feeds_page = self.app.main_view.go_to_edit_feeds()
         edit_feeds_page.delete_topic(self.test_topic)
         topics = edit_feeds_page.get_topics()
         self.assertNotIn(self.test_topic, topics)