Merge lp:~nskaggs/ubuntu-weather-app/ap-tweaks into lp:ubuntu-weather-app/obsolete.trunk

[Nicholas Skaggs]

update tests to use more emulator standards

Work on some of the flakiness with tests, without total refactoring

[Nicholas Skaggs (nskaggs)]

I dislike the whitespaces changes being flagged...

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

FAILED: Continuous integration, rev:214
http://91.189.93.70:8080/job/ubuntu-weather-app-ci/155/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-trusty-weather-app/48
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-weather-app-raring-amd64-ci/153
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-weather-app-saucy-amd64-ci/153
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-weather-app-trusty-amd64-ci/67

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-weather-app-ci/155/rebuild

review: Needs Fixing (continuous-integration)

[lp:~nskaggs/ubuntu-weather-app/ap-tweaks]

215. By Nicholas Skaggs on 2014-03-05

remove get_qml_view

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

PASSED: Continuous integration, rev:215
http://91.189.93.70:8080/job/ubuntu-weather-app-ci/156/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty-weather-app/49
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-weather-app-raring-amd64-ci/154
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-weather-app-saucy-amd64-ci/154
    SUCCESS: http://91.189.93.70:8080/job/ubuntu-weather-app-trusty-amd64-ci/68

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/ubuntu-weather-app-ci/156/rebuild

review: Approve (continuous-integration)

[Leo Arias (elopio)]

A nice step forward. Thanks Nic.

review: Approve (code review)

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/__init__.py'
--- tests/autopilot/ubuntu_weather_app/tests/__init__.py	2014-02-26 17:08:11 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/__init__.py	2014-03-05 15:16:06 +0000
@@ -10,7 +10,6 @@
 """weather-app autopilot tests."""
 
 import os.path
-import glob
 import sqlite3
 import time
 import logging
@@ -19,19 +18,20 @@
 
 from autopilot.input import Mouse, Touch, Pointer
 from autopilot.platform import model
-from autopilot.testcase import AutopilotTestCase
 from testtools.matchers import Equals, Is, Not
 from autopilot.matchers import Eventually
 
+from ubuntuuitoolkit import (
+    base,
+    emulators as toolkit_emulators
+)
+from ubuntu_weather_app import emulators
 import ubuntu_weather_app
 
-from ubuntuuitoolkit import emulators as toolkit_emulators
-from ubuntu_weather_app.emulators import MainView
-
 logger = logging.getLogger(__name__)
 
 
-class WeatherTestCase(AutopilotTestCase):
+class WeatherTestCase(base.UbuntuUIToolkitAppTestCase):
 
     """A common test case class that provides several useful methods for
        weather app tests."""
@@ -45,16 +45,10 @@
     installed_location = "/usr/share/ubuntu-weather-app/ubuntu-weather-app.qml"
 
     def setUp(self):
+        super(WeatherTestCase, self).setUp()
         self.pointing_device = Pointer(self.input_device_class.create())
-        super(WeatherTestCase, self).setUp()
         self.launch_app()
 
-    """Workaround to find the qmlscene binary via shell globbing.
-       This is needed since we can't rely on qt5-default being installed on
-       devices to make qmlscene available in the path"""
-    def qmlscene(self):
-        return glob.glob("/usr/lib/*/qt5/bin/qmlscene")[0]
-
     def launch_app(self):
         if os.path.exists(self.local_location):
             logger.debug("Running via local installation")
@@ -68,14 +62,14 @@
 
     def launch_test_local(self):
         self.app = self.launch_test_application(
-            self.qmlscene(),
+            base.get_qmlscene_launch_command(),
             self.local_location,
             app_type='qt',
             emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
 
     def launch_test_installed(self):
         self.app = self.launch_test_application(
-            self.qmlscene(),
+            base.get_qmlscene_launch_command(),
             self.installed_location,
             app_type='qt',
             emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
@@ -85,30 +79,27 @@
             "com.ubuntu.weather",
             emulator_base=toolkit_emulators.UbuntuUIToolkitEmulatorBase)
 
-    def get_qml_view(self):
-        return self.app.select_single("QQuickView")
-
     """Test if tabs with data are present in tablet mode"""
     def _ensure_tablet_tabs_loaded(self):
-        self.assertThat(lambda: self.main_window.wait_select_single('QQuickRectangle', visible=True, objectName='SideLabel'), 
+        self.assertThat(lambda: self.main_view.wait_select_single('QQuickRectangle', visible=True, objectName='SideLabel'),
             Eventually(Not(Is(None)), timeout=60))
 
     @property
-    def main_window(self):
-        return self.app.select_single(MainView)
+    def main_view(self):
+        return self.app.wait_select_single(emulators.MainView)
 
 class SheetMixin(object):
     """A mixin to to give access to common sheet elements"""
 
     def _click_sheet_confirm(self):
         """Clicks the confirm button"""
-        button = self.main_window.select_single(
+        button = self.main_view.select_single(
             'Button', objectName='confirmButton')
         self.pointing_device.click_object(button)
 
     def _click_sheet_cancel(self):
         """Clicks the cancel button"""
-        button = self.main_window.select_single(
+        button = self.main_view.select_single(
             'Button', objectName='cancelButton')
         self.pointing_device.click_object(button)
 
@@ -118,12 +109,12 @@
     def _open_add_location_page(self):
         """Opens the AddLocationPage"""
         # click on listitem to open AddLocationPage
-        addCityItem = self.main_window.wait_select_single('Standard', objectName='AddCityListItem')
+        addCityItem = self.main_view.wait_select_single('Standard', objectName='AddCityListItem')
         self.assertThat(lambda: addCityItem.visible, Eventually(Equals(True)))
         self.pointing_device.move_to_object(addCityItem)
         self.pointing_device.click()
 
-        addLocPage = self.main_window.select_single("DefaultSheet", objectName="AddLocationSheet")
+        addLocPage = self.main_view.select_single("DefaultSheet", objectName="AddLocationSheet")
         self.assertThat(addLocPage.visible, Eventually(Equals(True)))
 
 class DatabaseMixin(object):
@@ -187,7 +178,7 @@
             with open(path) as fh:
                 json_str = fh.read()
                 result.append(json_str.strip())
-                fh.close()        
+                fh.close()
         return result
 
     def add_locations_to_database(self, limit=None):

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/test_locationmanager.py'
--- tests/autopilot/ubuntu_weather_app/tests/test_locationmanager.py	2014-02-15 14:31:10 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/test_locationmanager.py	2014-03-05 15:16:06 +0000
@@ -11,7 +11,7 @@
 
 from testtools.matchers import Equals, Not
 from autopilot.matchers import Eventually
-from autopilot.introspection.dbus import StateNotFoundError 
+from autopilot.introspection.dbus import StateNotFoundError
 from unittest import skip
 
 from ubuntu_weather_app.tests import WeatherTestCase, DatabaseMixin, SheetMixin, LocationManagerMixin
@@ -28,7 +28,7 @@
         self.clean_db()
         super(TestLocationManager, self).setUp()
         self.assertThat(
-            self.get_qml_view().visible, Eventually(Equals(True)))
+            self.main_view.visible, Eventually(Equals(True)))
 
     def _preload_database_and_launch(self):
         #we want to start with existing data
@@ -42,15 +42,15 @@
         logger.debug("Re-Launching app to introspect")
         super(TestLocationManager, self).setUp()
         self.assertThat(
-            self.get_qml_view().visible, Eventually(Equals(True)))
+            self.main_view.visible, Eventually(Equals(True)))
 
     def _open_location_manager(self, kb=False):
         """Opens the location manager"""
         if kb: self.keyboard.press_and_release('Ctrl+n')
-        else: self.main_window.open_toolbar().click_button("EditButton")
+        else: self.main_view.open_toolbar().click_button("EditButton")
 
         # test location manager becomes visible
-        managerSheet = self.main_window.select_single('ComposerSheet', objectName='LocationManagerSheet')
+        managerSheet = self.main_view.select_single('ComposerSheet', objectName='LocationManagerSheet')
         self.assertThat(managerSheet.visible, Eventually(Equals(True)))
 
     def _swipe_first_location_to_remove(self):
@@ -69,7 +69,7 @@
         return qqlw.count
 
     def _search_for_city(self, city):
-        searchField = self.main_window.wait_select_single("TextField", objectName="SearchField")
+        searchField = self.main_view.wait_select_single("TextField", objectName="SearchField")
         #poll clicking for focus for lack of better method, due to screen switching animation
         #is there a property we can use instead?
         timeout = 0
@@ -89,22 +89,22 @@
         self._search_for_city(location)
 
         # wait for results and click on the first item
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='SearchingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='SearchingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
-        resultsList = self.main_window.select_single('QQuickListView', objectName='SearchResultList')
+        resultsList = self.main_view.select_single('QQuickListView', objectName='SearchResultList')
         self.assertThat(resultsList.visible, Eventually(Equals(True)))
-        firstResult = self.main_window.wait_select_single('Label', objectName='searchResult0')
+        firstResult = self.main_view.wait_select_single('Label', objectName='searchResult0')
         self.pointing_device.move_to_object(firstResult)
         self.pointing_device.click()
         sleep(1)
 
         # LocationManagerPage should be visible and location added
-        addedItem = self.main_window.wait_select_single('Label', text=location)
+        addedItem = self.main_view.wait_select_single('Label', text=location)
         self.assertThat(addedItem.text, Eventually(Equals(location)))
         self._click_sheet_confirm()
 
         # back to locations, wait till data is loaded
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
 
     def _remove_location(self):
@@ -118,34 +118,34 @@
         self._add_location("Paris")
 
         # only location is there
-        loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
+        loadingPage = self.main_view.select_single("Tabs", objectName="rootTabs")
         self.assertThat(loadingPage.visible, Eventually(Equals(True)))
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         self.assertEqual(1, len(tabObjects))
 
     def test_add_predefined_location(self):
         """Adds a location"""
         self._open_add_location_page()
 
-        resultsList = self.main_window.select_single('QQuickListView', objectName='SearchResultList')
+        resultsList = self.main_view.select_single('QQuickListView', objectName='SearchResultList')
         self.assertThat(resultsList.visible, Eventually(Equals(True)))
-        testResult = self.main_window.wait_select_single('Label', objectName='searchResult4')
+        testResult = self.main_view.wait_select_single('Label', objectName='searchResult4')
         self.pointing_device.move_to_object(testResult)
         self.pointing_device.click()
 
         # LocationManagerPage should be visible and location added
-        addedItem = self.main_window.wait_select_single('Label', objectName="existingLocation0")
+        addedItem = self.main_view.wait_select_single('Label', objectName="existingLocation0")
         self.assertThat(addedItem.text, Eventually(Equals("Cairo")))
         self._click_sheet_confirm()
 
         # back to locations, wait till data is loaded
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
 
         # only location is there
-        loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
+        loadingPage = self.main_view.select_single("Tabs", objectName="rootTabs")
         self.assertThat(loadingPage.visible, Eventually(Equals(True)))
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         self.assertEqual(1, len(tabObjects))
 
     def test_search_city(self):
@@ -156,15 +156,15 @@
         searchField = self._search_for_city("London")
 
         # wait for results and click on the first item
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='SearchingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='SearchingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
-        resultsList = self.main_window.select_single('QQuickListView', objectName='SearchResultList')
+        resultsList = self.main_view.select_single('QQuickListView', objectName='SearchResultList')
         self.assertThat(resultsList.visible, Eventually(Equals(True)))
-        firstResult = self.main_window.wait_select_single("Label", objectName="searchResult0")
+        firstResult = self.main_view.wait_select_single("Label", objectName="searchResult0")
         self.assertThat(firstResult.text, Eventually(Equals("London")))
 
         # regain focus, clear search field and do another search
-        searchField = self.main_window.wait_select_single("TextField", objectName="SearchField")
+        searchField = self.main_view.wait_select_single("TextField", objectName="SearchField")
         self.pointing_device.click_object(searchField)
         clear_button = searchField.wait_select_single("AbstractButton")
         self.pointing_device.click_object(clear_button)
@@ -173,17 +173,17 @@
         self.pointing_device.click_object(searchField)
         self.keyboard.type("Hamburg")
         self.keyboard.press_and_release('Enter')
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='SearchingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='SearchingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
         self.assertThat(resultsList.visible, Eventually(Equals(True)))
-        firstResult = self.main_window.wait_select_single("Label", objectName="searchResult0")
+        firstResult = self.main_view.wait_select_single("Label", objectName="searchResult0")
         self.assertThat(firstResult.text, Eventually(Equals("Hamburg")))
 
     def test_cancel_adding_location(self):
         """Cancel the cities search"""
         self._open_add_location_page()
         self._click_sheet_cancel()
-        locationList = self.main_window.wait_select_single('QQuickListView', objectName='LocationList')
+        locationList = self.main_view.wait_select_single('QQuickListView', objectName='LocationList')
         self.assertThat(locationList.visible, Eventually(Equals(True)))
 
     def test_no_location_found(self):
@@ -194,43 +194,43 @@
         self._search_for_city("UbuntuCity")
 
         # wait for result and look if label is shown
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='SearchingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='SearchingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
-        errorLabel = self.main_window.select_single('Label', objectName='noCityError')
+        errorLabel = self.main_view.select_single('Label', objectName='noCityError')
         self.assertThat(errorLabel.visible, Eventually(Equals(True)))
 
     def test_location_lookup(self):
         """Tests the location lookup"""
         # start lookup
-        lookupItem = self.main_window.wait_select_single('Standard', objectName='LocationLookupItem')
+        lookupItem = self.main_view.wait_select_single('Standard', objectName='LocationLookupItem')
         self.pointing_device.click_object(lookupItem)
 
         # wait for result
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LookupIndicator')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LookupIndicator')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
 
         # check a location was found
-        location = self.main_window.wait_select_single('Label', objectName='CurrentLocationLabel')
+        location = self.main_view.wait_select_single('Label', objectName='CurrentLocationLabel')
         self.assertThat(location.text, Eventually(Not(Equals(""))))
         location_name = location.text
 
         # add location
-        add_button = self.main_window.wait_select_single('Button', objectName='LookupItemAddButton')
+        add_button = self.main_view.wait_select_single('Button', objectName='LookupItemAddButton')
         self.pointing_device.click_object(add_button)
 
         # LocationManagerPage should be visible and location added
-        addedItem = self.main_window.wait_select_single('Label', objectName="existingLocation0")
+        addedItem = self.main_view.wait_select_single('Label', objectName="existingLocation0")
         self.assertThat(addedItem.text, Eventually(Equals(location_name)))
         self._click_sheet_confirm()
 
         # back to locations, wait till data is loaded
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
 
         # only location is there
-        loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
+        loadingPage = self.main_view.select_single("Tabs", objectName="rootTabs")
         self.assertThat(loadingPage.visible, Eventually(Equals(True)))
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         self.assertEqual(1, len(tabObjects))
 
     def test_remove_location(self):
@@ -238,20 +238,20 @@
         self._preload_database_and_launch()
 
         # wait till data is loaded
-        loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
+        loadingPage = self.main_view.select_single("Tabs", objectName="rootTabs")
         self.assertThat(loadingPage.visible, Eventually(Equals(True)))
 
         # count locations at start
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         tabsSumStart = len(tabObjects)
 
         # go to the location manager and remove 1st location
         self._remove_location()
 
         # back to locations, only one is left
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         self.assertThat(lambda: tabsSumStart-1, Eventually(Equals(len(tabObjects))))
 
     def test_cancel_remove_location(self):
@@ -259,11 +259,11 @@
         self._preload_database_and_launch()
 
         # wait data is loaded
-        loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
+        loadingPage = self.main_view.select_single("Tabs", objectName="rootTabs")
         self.assertThat(loadingPage.visible, Eventually(Equals(True)))
 
         # count locations at start
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         tabsSumStart = len(tabObjects)
 
         # go to the location manager, remove location, but click cancel
@@ -272,9 +272,9 @@
         self._click_sheet_cancel()
 
         # back to locations, no loction is removed
-        loadingPage = self.main_window.select_single("Tabs", objectName="rootTabs")
+        loadingPage = self.main_view.select_single("Tabs", objectName="rootTabs")
         self.assertThat(loadingPage.visible, Eventually(Equals(True)))
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         self.assertEqual(tabsSumStart, len(tabObjects))
 
     def test_del_add_bug(self):
@@ -291,30 +291,30 @@
         self._add_location("Cairo")
 
         # back to locations, wait till data is loaded
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
 
         # count the tabs
-        tabObjects = self.main_window.select_many('LocationTab', objectName='LocationTab')
+        tabObjects = self.main_view.select_many('LocationTab', objectName='LocationTab')
         self.assertThat(lambda: len(tabObjects), Eventually(Equals(2)))
         self.assertThat(
-            self.main_window.select_single('LocationTab', index=1).title,
+            self.main_view.select_single('LocationTab', index=1).title,
             Eventually(Equals("Cairo")))
 
     @skip("skipped because of Bug #1279073")
     def test_open_location_manager_keyboard(self):
-        if self.platform_model != "Desktop": 
+        if self.platform_model != "Desktop":
             return
         self._preload_database_and_launch()
         self._open_location_manager(kb=True)
 
         # close sheet by keyboard and test
         self.keyboard.press_and_release('Escape')
-        self.assertRaises(StateNotFoundError, lambda: self.main_window.select_single('ComposerSheet'))
+        self.assertRaises(StateNotFoundError, lambda: self.main_view.select_single('ComposerSheet'))
 
     @skip("skipped because of Bug #1279073")
     def test_add_location_keyboard(self):
-        if self.platform_model != "Desktop": 
+        if self.platform_model != "Desktop":
             return
         self._preload_database_and_launch()
         self._open_location_manager(kb=True)
@@ -322,5 +322,5 @@
 
         # close sheet by keyboard and test all sheets are closed
         self.keyboard.press_and_release('Escape')
-        self.assertRaises(StateNotFoundError, lambda: self.main_window.select_single('DefaultSheet'))
-        self.assertRaises(StateNotFoundError, lambda: self.main_window.select_single('ComposerSheet'))
+        self.assertRaises(StateNotFoundError, lambda: self.main_view.select_single('DefaultSheet'))
+        self.assertRaises(StateNotFoundError, lambda: self.main_view.select_single('ComposerSheet'))

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/test_mainview.py'
--- tests/autopilot/ubuntu_weather_app/tests/test_mainview.py	2014-02-26 17:08:11 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/test_mainview.py	2014-03-05 15:16:06 +0000
@@ -13,7 +13,7 @@
 
 from testtools.matchers import Equals, Is, Not
 from autopilot.matchers import Eventually
-from unittest import skip 
+from unittest import skip
 
 import logging
 
@@ -34,7 +34,7 @@
         logger.debug("Re-Launching app to introspect")
         super(TestMainView, self).setUp()
         self.assertThat(
-            self.get_qml_view().visible, Eventually(Equals(True)))
+            self.main_view.visible, Eventually(Equals(True)))
 
     def tearDown(self):
         super(TestMainView, self).tearDown()
@@ -44,10 +44,10 @@
         second tab"""
 
         # first tab should be visible after start
-        tabs =  self.main_window.get_tabs()
-        first_tab = self.main_window.select_single(
+        tabs =  self.main_view.get_tabs()
+        first_tab = self.main_view.select_single(
             'LocationTab', index=0)
-        second_tab = self.main_window.select_single(
+        second_tab = self.main_view.select_single(
             'LocationTab', index=1)
         self.assertThat(tabs.selectedTabIndex, Eventually(Equals(0)))
         self.assertThat(first_tab.visible, Eventually(Equals(True)))
@@ -57,7 +57,7 @@
         # switch to next tab
         if kb and not back: self.keyboard.press_and_release('Ctrl+Tab')
         elif kb and back: self.keyboard.press_and_release('Ctrl+Shift+Tab')
-        else: self.main_window.switch_to_tab_by_index(1)
+        else: self.main_view.switch_to_tab_by_index(1)
 
         self.assertThat(tabs.selectedTabIndex, Eventually(Equals(1)))
         self.assertThat(first_tab.visible, Eventually(Equals(False)))
@@ -71,35 +71,35 @@
     @skip("skipped because of Bug #1279073")
     def test_switch_tabs_keyboard(self):
         """Test start of app with two locations and switch from first to second tab"""
-        if self.platform_model != "Desktop": 
+        if self.platform_model != "Desktop":
             return
         self._switch_tabs(kb=True)
 
     @skip("skipped because of Bug #1279073")
     def test_switch_tabs_keyboard_back(self):
         """Test start of app with two locations and switch from first to second tab"""
-        if self.platform_model != "Desktop": 
+        if self.platform_model != "Desktop":
             return
         self._switch_tabs(kb=True, back=True)
 
     def _refresh(self, kb=False):
         # get the dates from the test data
-        if self.main_window.wideAspect:
+        if self.main_view.wideAspect:
             self._ensure_tablet_tabs_loaded()
-        self.assertThat(lambda: self.main_window.select_many('Label', objectName='DayDateLabel'), Eventually(Not(Is(None))))
-        curr_dates = self.main_window.select_many('Label', objectName='DayDateLabel')
+        self.assertThat(lambda: self.main_view.select_many('Label', objectName='DayDateLabel'), Eventually(Not(Is(None))))
+        curr_dates = self.main_view.select_many('Label', objectName='DayDateLabel')
         tab1_curr_date = curr_dates[0].text
         tab2_curr_date = curr_dates[2].text
 
         # refresh and wait till loading has finished
         if kb: self.keyboard.press_and_release('Ctrl+r')
-        else: self.main_window.open_toolbar().click_button("RefreshButton")
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        else: self.main_view.open_toolbar().click_button("RefreshButton")
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False), timeout=120))
 
         # get the data from the refreshed tabs, have to be new
-        self.assertThat(lambda: self.main_window.select_many('Label',objectName='DayDateLabel'), Eventually(Not(Is(None)), timeout=60))
-        refreshed_dates = self.main_window.select_many('Label',objectName='DayDateLabel')
+        self.assertThat(lambda: self.main_view.select_many('Label',objectName='DayDateLabel'), Eventually(Not(Is(None)), timeout=60))
+        refreshed_dates = self.main_view.select_many('Label',objectName='DayDateLabel')
         self.assertNotEqual(tab1_curr_date, refreshed_dates[0].text)
         self.assertNotEqual(tab2_curr_date, refreshed_dates[2].text)
 
@@ -108,55 +108,55 @@
 
     @skip("skipped because of Bug #1279073")
     def test_refresh_tabs_keyboard(self):
-        if self.platform_model != "Desktop": 
+        if self.platform_model != "Desktop":
             return
         self._refresh(kb=True)
-       
+
     @skip("skipped because of Bug #1279073")
     def test_day_navigation_keyboard(self):
         # get the dates from the test data
-        if self.platform_model != "Desktop": 
+        if self.platform_model != "Desktop":
             return
-        self.assertThat(lambda: self.main_window.select_many('QQuickListView', objectName='DailyForecastList'), Eventually(Not(Is(None))))
-        dayLists = self.main_window.select_many('QQuickListView', objectName='DailyForecastList')
+        self.assertThat(lambda: self.main_view.select_many('QQuickListView', objectName='DailyForecastList'), Eventually(Not(Is(None))))
+        dayLists = self.main_view.select_many('QQuickListView', objectName='DailyForecastList')
         self.assertThat(dayLists[1].visible, Eventually(Equals(True)))
         self.assertThat(dayLists[1].currentIndex, Eventually(Equals(0)))
 
         # navigate to to overmorrow
         self.keyboard.press_and_release('Down')
         self.keyboard.press_and_release('Down')
-        dayLists = self.main_window.select_many('QQuickListView', objectName='DailyForecastList')
+        dayLists = self.main_view.select_many('QQuickListView', objectName='DailyForecastList')
         self.assertThat(dayLists[1].visible, Eventually(Equals(True)))
         self.assertThat(dayLists[1].currentIndex, Eventually(Equals(2)))
 
         # navigate to tomorrow
         self.keyboard.press_and_release('Up')
-        dayLists = self.main_window.select_many('QQuickListView', objectName='DailyForecastList')
+        dayLists = self.main_view.select_many('QQuickListView', objectName='DailyForecastList')
         self.assertThat(dayLists[1].visible, Eventually(Equals(True)))
         self.assertThat(dayLists[1].currentIndex, Eventually(Equals(1)))
 
     @skip("skipped because of Bug #1279073")
     def test_show_details_keyboard(self):
-        if self.platform_model != "Desktop": 
+        if self.platform_model != "Desktop":
             return
-        self.assertThat(lambda: self.main_window.select_many('QQuickFlickable', state="back"), Eventually(Not(Is(True))))
-        back_flipped = self.main_window.select_many('QQuickFlipable', state="back")
+        self.assertThat(lambda: self.main_view.select_many('QQuickFlickable', state="back"), Eventually(Not(Is(True))))
+        back_flipped = self.main_view.select_many('QQuickFlipable', state="back")
         self.assertEqual(0, len(back_flipped))
 
         # press space
         self.keyboard.press_and_release('Space')
 
         # check the displayed info is flipped and only one is flipped
-        self.assertThat(lambda: self.main_window.select_many('QQuickFlickable', state="back"), Eventually(Not(Is(True))))
-        flipables = self.main_window.select_many('QQuickFlipable')
+        self.assertThat(lambda: self.main_view.select_many('QQuickFlickable', state="back"), Eventually(Not(Is(True))))
+        flipables = self.main_view.select_many('QQuickFlipable')
         self.assertThat(flipables[1].state, Eventually(Equals("back")))
-        back_flipped = self.main_window.select_many('QQuickFlipable', state="back")
+        back_flipped = self.main_view.select_many('QQuickFlipable', state="back")
         self.assertEqual(1, len(back_flipped))
 
         # press space again, hide details
         self.keyboard.press_and_release('Space')
 
-        # check nothing is flipped 
-        self.assertThat(lambda: self.main_window.select_many('QQuickFlickable', state="back"), Eventually(Not(Is(True))))
-        back_flipped = self.main_window.select_many('QQuickFlipable', state="back")
+        # check nothing is flipped
+        self.assertThat(lambda: self.main_view.select_many('QQuickFlickable', state="back"), Eventually(Not(Is(True))))
+        back_flipped = self.main_view.select_many('QQuickFlipable', state="back")
         self.assertEqual(0, len(back_flipped))

=== modified file 'tests/autopilot/ubuntu_weather_app/tests/test_settings.py'
--- tests/autopilot/ubuntu_weather_app/tests/test_settings.py	2014-02-26 17:08:11 +0000
+++ tests/autopilot/ubuntu_weather_app/tests/test_settings.py	2014-03-05 15:16:06 +0000
@@ -27,26 +27,26 @@
         self.add_units_to_database()
         super(TestSettings, self).setUp()
         self.assertThat(
-            self.get_qml_view().visible, Eventually(Equals(True)))
+            self.main_view.visible, Eventually(Equals(True)))
 
     def _open_settings_sheet(self):
         """Opens the settings sheet"""
-        self.main_window.open_toolbar().click_button("SettingsButton")
+        self.main_view.open_toolbar().click_button("SettingsButton")
 
     def _move_pointer_around(self):
         """Helper method to move the pointer around, to assure selector is opened"""
-        self.assertThat(lambda: self.main_window.select_single('ComposerSheet', objectName='SettingsSheet'), 
+        self.assertThat(lambda: self.main_view.select_single('ComposerSheet', objectName='SettingsSheet'),
             Eventually(Not(Is(None))))
-        sheet = self.main_window.select_single('ComposerSheet', objectName='SettingsSheet')
+        sheet = self.main_view.select_single('ComposerSheet', objectName='SettingsSheet')
         self.pointing_device.move_to_object(sheet)
 
     def _check_units(self, units):
-        """Checks selected units by values from the first location tab"""        
-        if self.main_window.wideAspect:
+        """Checks selected units by values from the first location tab"""
+        if self.main_view.wideAspect:
             self._ensure_tablet_tabs_loaded()
-        self.assertThat(lambda: self.main_window.select_many('QQuickText', objectName='CurrentTempText'),
+        self.assertThat(lambda: self.main_view.select_many('QQuickText', objectName='CurrentTempText'),
             Eventually(Not(Is(None))))
-        current_location_tab = self.main_window.wait_select_single(
+        current_location_tab = self.main_view.wait_select_single(
             'LocationTab', visible=True)
         today_item = current_location_tab.wait_select_single(
             'QQuickItem', focus=True)
@@ -69,20 +69,20 @@
 
     def _check_wind_units(self, wind_units):
         """Checks selected units by values from the first location tab"""
-        if self.main_window.wideAspect:
+        if self.main_view.wideAspect:
             self._ensure_tablet_tabs_loaded()
-        self.assertThat(lambda: self.main_window.select_many('WeatherDetailComponent', objectName='WindSpeedValue')[0],
+        self.assertThat(lambda: self.main_view.select_many('WeatherDetailComponent', objectName='WindSpeedValue')[0],
              Eventually(Not(Is(None))))
-        current_location_tab = self.main_window.select_single(
+        current_location_tab = self.main_view.select_single(
             'LocationTab', visible=True)
         focused_item = current_location_tab.select_single(
             'QQuickItem', focus=True)
         wind_component = focused_item.select_single(
             'WeatherDetailComponent', objectName='WindSpeedValue')
-        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailUnit'), 
+        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailUnit'),
             Eventually(Not(Is(None))))
         wind_unit = wind_component.select_single('QQuickText', objectName='WeatherDetailUnit')
-        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailValue'), 
+        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailValue'),
             Eventually(Not(Is(None))))
         wind_value = wind_component.select_single('QQuickText', objectName='WeatherDetailValue')
         if wind_units == "mph":
@@ -94,20 +94,20 @@
 
     def _check_precipitation_units(self, pre_units):
         """Checks selected units by values from the first location tab"""
-        if self.main_window.wideAspect:
+        if self.main_view.wideAspect:
             self._ensure_tablet_tabs_loaded()
-        self.assertThat(lambda: self.main_window.select_many('WeatherDetailComponent', objectName='PrecipitationValue')[0],
+        self.assertThat(lambda: self.main_view.select_many('WeatherDetailComponent', objectName='PrecipitationValue')[0],
             Eventually(Not(Is(None))))
-        current_location_tab = self.main_window.select_single(
+        current_location_tab = self.main_view.select_single(
             'LocationTab', visible=True)
         focused_item = current_location_tab.select_single(
             'QQuickItem', focus=True)
         component = focused_item.select_single(
             'WeatherDetailComponent', objectName='PrecipitationValue')
-        self.assertThat(lambda: component.select_many('QQuickText', objectName='WeatherDetailUnit'), 
+        self.assertThat(lambda: component.select_many('QQuickText', objectName='WeatherDetailUnit'),
             Eventually(Not(Is(None))))
         unit = component.select_single('QQuickText', objectName='WeatherDetailUnit')
-        self.assertThat(lambda: component.select_single('QQuickText', objectName='WeatherDetailValue'), 
+        self.assertThat(lambda: component.select_single('QQuickText', objectName='WeatherDetailValue'),
             Eventually(Not(Is(None))))
         value = component.select_single('QQuickText', objectName='WeatherDetailValue')
         if pre_units == "in":
@@ -119,16 +119,16 @@
 
     def _check_service(self, service):
         """Checks selected units weather data service from the first location tab"""
-        if self.main_window.wideAspect:
+        if self.main_view.wideAspect:
             self._ensure_tablet_tabs_loaded()
-        self.assertThat(lambda: self.main_window.select_many('TabFooter', objectName='TabFooter')[0],
-            Eventually(Not(Is(None))))
-        current_location_tab = self.main_window.select_single('LocationTab', visible=True)
-        self.assertThat(lambda: current_location_tab.select_single('TabFooter', objectName='TabFooter'), 
-            Eventually(Not(Is(None))))
-        self.assertThat(lambda: current_location_tab.select_single('QQuickImage', objectName='DataProviderLogo'), 
-            Eventually(Not(Is(None))))
-            
+        self.assertThat(lambda: self.main_view.select_many('TabFooter', objectName='TabFooter')[0],
+            Eventually(Not(Is(None))))
+        current_location_tab = self.main_view.select_single('LocationTab', visible=True)
+        self.assertThat(lambda: current_location_tab.select_single('TabFooter', objectName='TabFooter'),
+            Eventually(Not(Is(None))))
+        self.assertThat(lambda: current_location_tab.select_single('QQuickImage', objectName='DataProviderLogo'),
+            Eventually(Not(Is(None))))
+
         focused_item = current_location_tab.select_single('QQuickItem', focus=True)
         tab_footer = current_location_tab.select_single('TabFooter', objectName='TabFooter')
         provider_logo = current_location_tab.select_single('QQuickImage', objectName='DataProviderLogo')
@@ -146,9 +146,9 @@
         self._open_settings_sheet()
 
         # open the value selector
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='TemperatureUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[1]
@@ -163,15 +163,15 @@
         self._click_sheet_confirm()
 
         # wait for reload and check the imperial values
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_units('imperial')
 
         # switch back to metric values again
         self._open_settings_sheet()
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='TemperatureUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[2]
@@ -191,7 +191,7 @@
         self._click_sheet_confirm()
 
         # wait for reload and check the metric values again
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_units('metric')
 
@@ -203,9 +203,9 @@
         self._open_settings_sheet()
 
         # open the temp value selector
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='TemperatureUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[1]
@@ -219,9 +219,9 @@
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
 
         # open the wind value selector
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='WindUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="WindUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="WindUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
         self.pointing_device.click_object(units_selector)
 
@@ -244,9 +244,9 @@
         self._open_settings_sheet()
 
         # open the wind value selector
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='WindUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="WindUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="WindUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[1]
@@ -261,15 +261,15 @@
         self._click_sheet_confirm()
 
         # wait for reload and check the mph values
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_wind_units('mph')
 
         # switch back to kmh values again
         self._open_settings_sheet()
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='WindUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="WindUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="WindUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[2]
@@ -289,7 +289,7 @@
         self._click_sheet_confirm()
 
         # wait for reload and check the metric values again
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_wind_units('kmh')
 
@@ -301,9 +301,9 @@
         self._open_settings_sheet()
 
         # open the precipitation value selector
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="PrecipitationUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="PrecipitationUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[1]
@@ -318,15 +318,15 @@
         self._click_sheet_confirm()
 
         # wait for reload and check the inch values
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_wind_units('in')
 
         # switch back to mm values again
         self._open_settings_sheet()
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'), 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'),
             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="PrecipitationUnitsSelector")
+        units_selector = self.main_view.select_single('OptionSelector', objectName="PrecipitationUnitsSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[2]
@@ -348,7 +348,7 @@
         self._click_sheet_confirm()
 
         # wait for reload and check the metric values again
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_precipitation_units('mm')
 
@@ -359,8 +359,8 @@
         self._open_settings_sheet()
 
         # open the value selector
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='ServiceSelector'),             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="ServiceSelector")
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='ServiceSelector'),             Eventually(Not(Is(None))))
+        units_selector = self.main_view.select_single('OptionSelector', objectName="ServiceSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[1]
@@ -374,22 +374,22 @@
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
 
         # check if precipitation units selector appears
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector',
             objectName='PrecipitationUnitsSelector'), Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', 
+        units_selector = self.main_view.select_single('OptionSelector',
             objectName="PrecipitationUnitsSelector")
         self.assertThat(units_selector.visible, Eventually(Equals(1)))
         self._click_sheet_confirm()
 
-        # wait for reload and check the used service 
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        # wait for reload and check the used service
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_service('openweathermap')
 
         # switch back to metric values again
         self._open_settings_sheet()
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='ServiceSelector'),             Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', objectName="ServiceSelector")
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector', objectName='ServiceSelector'),             Eventually(Not(Is(None))))
+        units_selector = self.main_view.select_single('OptionSelector', objectName="ServiceSelector")
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
         self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
         current_option = units_selector.select_many('ShapeItem')[2]
@@ -406,14 +406,14 @@
         self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
 
         # check if precipitation units selector disappears and confirm
-        self.assertThat(lambda: self.main_window.select_single('OptionSelector', 
+        self.assertThat(lambda: self.main_view.select_single('OptionSelector',
             objectName='PrecipitationUnitsSelector'), Eventually(Not(Is(None))))
-        units_selector = self.main_window.select_single('OptionSelector', 
+        units_selector = self.main_view.select_single('OptionSelector',
             objectName="PrecipitationUnitsSelector")
         self.assertThat(units_selector.visible, Eventually(Equals(0)))
         self._click_sheet_confirm()
 
         # wait for reload and check the metric values again
-        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
+        load_indicator = self.main_view.select_single('ActivityIndicator', objectName='LoadingSpinner')
         self.assertThat(load_indicator.running, Eventually(Equals(False)))
         self._check_service('weatherchannel')