Merge lp:~nskaggs/ubuntu-weather-app/swipe-delete-ap-tests into lp:ubuntu-weather-app/obsolete.trunk

[Nicholas Skaggs]

Further tweaks to enable mako and maguro to run the tests properly, transitioned to load db at startup, added logging

Further tweaks to enable mako and maguro to run the tests properly, transitioned to load db at startup, added logging

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

review: Approve (continuous-integration)

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/__init__.py'
--- tests/autopilot/ubuntu_weather_app/tests/__init__.py	2013-12-11 01:03:53 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/__init__.py	2013-12-11 20:25:12 +0000
@@ -13,16 +13,19 @@
 import glob
 import sqlite3
 import time
+import logging
 
 from autopilot.input import Mouse, Touch, Pointer
 from autopilot.platform import model
 from autopilot.testcase import AutopilotTestCase
-from testtools.matchers import Equals, NotEquals, Is, Not
+from testtools.matchers import Equals
 from autopilot.matchers import Eventually
 
 from ubuntuuitoolkit import emulators as toolkit_emulators
 from ubuntu_weather_app.emulators import MainView
 
+logger = logging.getLogger(__name__)
+
 
 class WeatherTestCase(AutopilotTestCase):
 
@@ -50,10 +53,13 @@
 
     def launch_app(self):
         if os.path.exists(self.local_location):
+            logger.debug("Running via local installation")
             self.launch_test_local()
         elif os.path.exists(self.installed_location):
+            logger.debug("Running via installed debian package")
             self.launch_test_installed()
         else:
+            logger.debug("Running via click package")
             self.launch_test_click()
 
     def launch_test_local(self):
@@ -77,18 +83,6 @@
             "com.ubuntu.weather",
             emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
 
-    def launch_and_quit_app(self):
-        self.launch_app()
-        self.get_qml_view().visible.wait_for(True)
-
-        # When calling launch_app an instance of the spawned process
-        # control object will be stored in self.app.process, and a cleanup
-        # handler will be registered that essentially kills the process.
-        # Therefore, by triggering the cleanup handler here we're killing the
-        # process and removing the handler, which allows a clean launch of
-        # the process during regular test setup.
-        self.doCleanups()
-
     def get_qml_view(self):
         return self.app.select_single("QQuickView")
 
@@ -132,44 +126,76 @@
     Helper functions for dealing with sqlite databases
     """
 
+    db_path = os.path.expanduser(
+        "~/.local/share/com.ubuntu.weather/Databases")
+
+    def _execute_sql(self, statement):
+        path = self.find_db()
+        conn = sqlite3.connect(path)
+        cursor = conn.cursor()
+        logger.debug("Executing sql")
+        logger.debug(statement)
+        cursor.execute(statement)
+        conn.commit()
+        conn.close()
+
     def find_db(self):
-        dbs_path = os.path.expanduser(
-            "~/.local/share/com.ubuntu.weather/Databases/")
-        if not os.path.exists(dbs_path):
+        if not os.path.exists(self.db_path):
+            logger.debug("Database not found in ~/.local/share/")
             return None
 
-        files = [f for f in os.listdir(dbs_path)
+        logger.debug("Database found in ~/.local/share/")
+        files = [f for f in os.listdir(self.db_path)
                  if os.path.splitext(f)[1] == ".ini"]
         for f in files:
-            ini_path = os.path.join(dbs_path, f)
+            ini_path = os.path.join(self.db_path, f)
             with open(ini_path) as ini:
                 for line in ini:
                     if "=" in line:
                         key, val = line.strip().split("=")
                         if key == "Name" and val == "com.ubuntu.weather":
                             try:
+                                logger.debug("Replaced ini com.ubuntu.weather key")
                                 return ini_path.replace(".ini", ".sqlite")
                             except OSError:
+                                logger.debug("No ini found to replace")
                                 pass
         return None
 
     def clean_db(self):
+        logger.debug("Removing existing database")
         path = self.find_db()
         if path is None:
+            logger.debug("Database not found to clean")
             self.launch_and_quit_app()
             path = self.find_db()
             if path is None:
+                logger.debug("Database still not found after app launch")
                 self.assertNotEquals(path, None)
 
         try:
+            logger.debug("Removing existing database")
             os.remove(path)
         except OSError:
+            logger.debug("Could not remove existing database")
             pass
 
-    def save_locations_to_storage(self, locations):
+    def create_blank_db(self):
+        self.clean_db()
+
+        #this needs to stay in sync with Storage.qml enties
+        logger.debug("Creating locations and settings tables")
+        self._execute_sql("CREATE TABLE IF NOT EXISTS Locations(id INTEGER "
+                       "PRIMARY KEY AUTOINCREMENT, data TEXT, date TEXT)")
+
+        self._execute_sql("CREATE TABLE IF NOT EXISTS settings(key TEXT "
+                       "UNIQUE, value TEXT)")
+
+    def add_locations_to_database(self, locations):
         path = self.find_db()
         conn = sqlite3.connect(path)
         cursor = conn.cursor()
+        logger.debug("Adding locations to database")
         for loc_data in locations:
             db_exec = "INSERT INTO Locations(date, data) VALUES('{}', '{}')"
             cursor.execute(db_exec.format(
@@ -177,13 +203,9 @@
             conn.commit()
         conn.close()
 
-    def save_units_to_storage(self):
-        path = self.find_db()
-        conn = sqlite3.connect(path)
-        cursor = conn.cursor()
-        cursor.execute("INSERT INTO settings(key, value) "
+    def add_units_to_database(self):
+        logger.debug("Adding units to database")
+        self._execute_sql("INSERT INTO settings(key, value) "
                        "VALUES('units', 'metric'), "
                        "('wind_units', 'kmh'), "
                        "('precip_units', 'mm')")
-        conn.commit()
-        conn.close()

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/test_locationmanager.py'
--- tests/autopilot/ubuntu_weather_app/tests/test_locationmanager.py	2013-12-11 01:09:53 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/test_locationmanager.py	2013-12-11 20:25:12 +0000
@@ -9,14 +9,16 @@
 
 from __future__ import absolute_import
 
-from testtools.matchers import Equals, NotEquals, Is, Not
+from testtools.matchers import Equals, Not
 from autopilot.matchers import Eventually
 
 from ubuntu_weather_app.tests import WeatherTestCase, DatabaseMixin, SheetMixin, LocationManagerMixin
 from ubuntu_weather_app.tests.weatherdata import locations_data
 
 from time import sleep
-import unittest
+import logging
+
+logger = logging.getLogger(__name__)
 
 class TestLocationManager(WeatherTestCase, DatabaseMixin, SheetMixin, LocationManagerMixin):
 
@@ -26,11 +28,16 @@
         self.assertThat(
             self.get_qml_view().visible, Eventually(Equals(True)))
 
-    def _preload_database_and_relaunch(self):
-        self.clean_db()
-        self.launch_and_quit_app()
-        # add one location to storage
-        self.save_locations_to_storage(locations_data)
+    def _preload_database_and_launch(self):
+        #close app
+        logger.debug("Closing app")
+        self.doCleanups()
+        #wipe the existing database and create a new blank one
+        self.create_blank_db()
+        # add locations to storage
+        logger.debug("Adding fake data to new database")
+        self.add_locations_to_database(locations_data)
+        logger.debug("Re-Launching app to introspect")
         super(TestLocationManager, self).setUp()
         self.assertThat(
             self.get_qml_view().visible, Eventually(Equals(True)))
@@ -51,7 +58,7 @@
         self.assertThat(self._get_number_of_locations, Eventually(Equals(number_of_locations-1)))
 
     def _get_number_of_locations(self):
-        qqlw = self.app.select_single("ComposerSheet").select_single("QQuickListView")
+        qqlw = self.app.wait_select_single("ComposerSheet").wait_select_single("QQuickListView")
         return qqlw.count
 
     def _search_for_city(self, city):
@@ -220,7 +227,7 @@
 
     def test_remove_location(self):
         """Removes location"""
-        self._preload_database_and_relaunch()
+        self._preload_database_and_launch()
 
         # wait till data is loaded
         loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
@@ -241,7 +248,7 @@
 
     def test_cancel_remove_location(self):
         """Cancels removing of location"""
-        self._preload_database_and_relaunch()
+        self._preload_database_and_launch()
 
         # wait data is loaded
         loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
@@ -266,13 +273,11 @@
         """Tests if removing and add a location in one action works
            https://bugs.launchpad.net/ubuntu-weather-app/+bug/1230297"""
 
-        self._preload_database_and_relaunch()
+        self._preload_database_and_launch()
 
         # remove a location
         self._remove_location()
 
-        number_of_locations = self._get_number_of_locations()
-
         # add a location
         self._open_location_manager()
         self._add_location("Cairo")
@@ -283,7 +288,7 @@
 
         # count the tabs
         tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
-        self.assertThat(lambda: number_of_locations + 1, Eventually(Equals(len(tabObjects))))
+        self.assertThat(lambda: len(tabObjects), Eventually(Equals(2)))
         self.assertThat(
             self.main_window.select_single('LocationTab', index=1).title,
             Eventually(Equals("Cairo")))

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/test_mainview.py'
--- tests/autopilot/ubuntu_weather_app/tests/test_mainview.py	2013-11-05 23:27:52 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/test_mainview.py	2013-12-11 20:25:12 +0000
@@ -11,23 +11,31 @@
 
 from __future__ import absolute_import
 
-from testtools.matchers import NotEquals, Equals, Is, Not
+from testtools.matchers import Equals, Is, Not
 from autopilot.matchers import Eventually
 
-import unittest
+import logging
 
 from ubuntu_weather_app.tests import WeatherTestCase, DatabaseMixin
 from ubuntu_weather_app.tests.weatherdata import locations_data
 
+logger = logging.getLogger(__name__)
+
 class TestMainView(WeatherTestCase, DatabaseMixin):
     """Tests creating weather"""
 
     """ This is needed to wait for the application to start.
         In the testfarm, the application may take some time to show up."""
     def setUp(self):
-        self.clean_db()
-        self.launch_and_quit_app()
-        self.save_locations_to_storage(locations_data)
+        #close app
+        #logger.debug("Closing app")
+        #self.doCleanups()
+        #wipe the existing database and create a new blank one
+        self.create_blank_db()
+        # add settings to storage
+        logger.debug("Adding fake data to new database")
+        self.add_locations_to_database(locations_data)
+        logger.debug("Re-Launching app to introspect")
         super(TestMainView, self).setUp()
         self.assertThat(
             self.get_qml_view().visible, Eventually(Equals(True)))

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/test_settings.py'
--- tests/autopilot/ubuntu_weather_app/tests/test_settings.py	2013-11-06 19:40:17 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/test_settings.py	2013-12-11 20:25:12 +0000
@@ -9,18 +9,27 @@
 
 from __future__ import absolute_import
 
-from testtools.matchers import Equals, NotEquals, Is, Not
+from testtools.matchers import Equals, Is, Not
 from autopilot.matchers import Eventually
+import logging
 
 from ubuntu_weather_app.tests import WeatherTestCase, DatabaseMixin, SheetMixin
 from ubuntu_weather_app.tests.weatherdata import locations_data
 
+logger = logging.getLogger(__name__)
+
 class TestSettings(WeatherTestCase, DatabaseMixin, SheetMixin):
     def setUp(self):
-        self.clean_db()
-        self.launch_and_quit_app()
-        self.save_locations_to_storage(locations_data)
-        self.save_units_to_storage()
+        #close app
+        #logger.debug("Closing app")
+        #self.doCleanups()
+        #wipe the existing database and create a new blank one
+        self.create_blank_db()
+        # add settings to storage
+        logger.debug("Adding fake data to new database")
+        self.add_locations_to_database(locations_data)
+        self.add_units_to_database()
+        logger.debug("Re-Launching app to introspect")
         super(TestSettings, self).setUp()
         self.assertThat(
             self.get_qml_view().visible, Eventually(Equals(True)))
@@ -257,7 +266,7 @@
         current_option = units_selector.select_many('ShapeItem')[1]
         self.pointing_device.click_object(current_option)
 
-        # choose second option, inch 
+        # choose second option, inch
         self._move_pointer_around()
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
         in_option = units_selector.select_many('ShapeItem')[2]