← Back to branch summary

~martin-borho/ubuntu-weather-app/keyboard-shortcuts

« back to all changes in this revision

Viewing changes to tests/autopilot/ubuntu_weather_app/tests/test_settings.py

  • Committer: Martin Borho
  • Date: 2014-02-15 14:31:10 UTC
  • mfrom: (187.1.10 trunk)
  • Revision ID: martin@borho.net-20140215143110-gij32mdfm2mah342
merged from trunk, resolved conflict

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/autopilot/ubuntu_weather_app/tests/test_settings.py
9
9
 
10
10
from __future__ import absolute_import
11
11
 
 
12
from unittest import skip
12
13
from testtools.matchers import Equals, Is, Not
13
14
from autopilot.matchers import Eventually
14
15
import logging
15
16
 
16
17
from ubuntu_weather_app.tests import WeatherTestCase, DatabaseMixin, SheetMixin
17
 
from ubuntu_weather_app.tests.weatherdata import locations_data
18
18
 
19
19
logger = logging.getLogger(__name__)
20
20
 
23
23
        #we want to start with fake settings data
24
24
        self.create_blank_db()
25
25
        logger.debug("Adding fake data to new database")
26
 
        self.add_locations_to_database(locations_data)
 
26
        self.add_locations_to_database()
27
27
        self.add_units_to_database()
28
28
        super(TestSettings, self).setUp()
29
29
        self.assertThat(
35
35
 
36
36
    def _move_pointer_around(self):
37
37
        """Helper method to move the pointer around, to assure selector is opened"""
38
 
        self.assertThat(lambda: self.main_window.select_single('ComposerSheet', objectName='SettingsSheet'), Eventually(Not(Is(None))))
 
38
        self.assertThat(lambda: self.main_window.select_single('ComposerSheet', objectName='SettingsSheet'), 
 
39
            Eventually(Not(Is(None))))
39
40
        sheet = self.main_window.select_single('ComposerSheet', objectName='SettingsSheet')
40
41
        self.pointing_device.move_to_object(sheet)
41
42
 
42
43
    def _check_units(self, units):
43
44
        """Checks selected units by values from the first location tab"""
44
 
        self.assertThat(lambda: self.main_window.select_many('QQuickText', objectName='CurrentTempText'), Eventually(Not(Is(None))))
 
45
        self.assertThat(lambda: self.main_window.select_many('QQuickText', objectName='CurrentTempText'), 
 
46
            Eventually(Not(Is(None))))
45
47
        current_location_tab = self.main_window.select_single(
46
48
            'LocationTab', visible=True)
47
49
        today_item = current_location_tab.select_single(
48
50
            'QQuickItem', focus=True)
49
51
        today_temp = today_item.select_single(
50
52
            'QQuickText', objectName='CurrentTempText')
 
53
        today_temp_scale = today_item.select_single(
 
54
            'QQuickText', objectName='CurrentTempScale')
51
55
        tomorrow_item = today_item.get_parent().get_children_by_type(
52
56
            'QQuickItem', focus=False, z=1)
53
57
        tomorrow_temp = tomorrow_item[0].select_single(
54
58
            'QQuickText', objectName='CurrentTempText')
55
59
        if units == "imperial":
56
 
            self.assertThat(today_temp.text, Eventually(Equals(u'57')))
57
 
            self.assertThat(tomorrow_temp.text, Eventually(Equals(u'69')))
 
60
            self.assertThat(today_temp_scale.text, Eventually(Equals(u'°F')))
 
61
            self.assertThat(today_temp.text, Eventually(Equals(u'26')))
 
62
            self.assertThat(tomorrow_temp.text, Eventually(Equals(u'23')))
58
63
        else:
59
 
            self.assertThat(today_temp.text, Eventually(Equals(u'14')))
60
 
            self.assertThat(tomorrow_temp.text, Eventually(Equals(u'21')))
 
64
            self.assertThat(today_temp_scale.text, Eventually(Equals(u'°C')))
 
65
            self.assertThat(today_temp.text, Eventually(Equals(u'-3')))
 
66
            self.assertThat(tomorrow_temp.text, Eventually(Equals(u'-5')))
61
67
 
62
68
    def _check_wind_units(self, wind_units):
63
69
        """Checks selected units by values from the first location tab"""
64
 
        self.assertThat(lambda: self.main_window.select_many('WeatherDetailComponent', objectName='WindSpeedValue')[0], Eventually(Not(Is(None))))
 
70
        self.assertThat(lambda: self.main_window.select_many('WeatherDetailComponent', objectName='WindSpeedValue')[0], 
 
71
            Eventually(Not(Is(None))))
65
72
        current_location_tab = self.main_window.select_single(
66
73
            'LocationTab', visible=True)
67
74
        focused_item = current_location_tab.select_single(
68
75
            'QQuickItem', focus=True)
69
76
        wind_component = focused_item.select_single(
70
77
            'WeatherDetailComponent', objectName='WindSpeedValue')
71
 
        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailUnit'), Eventually(Not(Is(None))))
 
78
        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailUnit'), 
 
79
            Eventually(Not(Is(None))))
72
80
        wind_unit = wind_component.select_single('QQuickText', objectName='WeatherDetailUnit')
73
 
        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailValue'), Eventually(Not(Is(None))))
 
81
        self.assertThat(lambda: wind_component.select_single('QQuickText', objectName='WeatherDetailValue'), 
 
82
            Eventually(Not(Is(None))))
74
83
        wind_value = wind_component.select_single('QQuickText', objectName='WeatherDetailValue')
75
84
        if wind_units == "mph":
76
 
            self.assertThat(wind_unit.text, Eventually(Equals(u'mph SE')))
77
 
            self.assertThat(wind_value.text, Eventually(Equals(u'9')))
 
85
            self.assertThat(wind_unit.text, Eventually(Equals(u'mph ESE')))
 
86
            self.assertThat(wind_value.text, Eventually(Equals(u'49')))
78
87
        else:
79
 
            self.assertThat(wind_unit.text, Eventually(Equals(u'km/h SE')))
80
 
            self.assertThat(wind_value.text, Eventually(Equals(u'15')))
 
88
            self.assertThat(wind_unit.text, Eventually(Equals(u'km/h ESE')))
 
89
            self.assertThat(wind_value.text, Eventually(Equals(u'22')))
81
90
 
82
91
    def _check_precipitation_units(self, pre_units):
83
92
        """Checks selected units by values from the first location tab"""
84
 
        self.assertThat(lambda: self.main_window.select_many('WeatherDetailComponent', objectName='PrecipitationValue')[0], Eventually(Not(Is(None))))
 
93
        self.assertThat(lambda: self.main_window.select_many('WeatherDetailComponent', objectName='PrecipitationValue')[0], 
 
94
            Eventually(Not(Is(None))))
85
95
        current_location_tab = self.main_window.select_single(
86
96
            'LocationTab', visible=True)
87
97
        focused_item = current_location_tab.select_single(
88
98
            'QQuickItem', focus=True)
89
99
        component = focused_item.select_single(
90
100
            'WeatherDetailComponent', objectName='PrecipitationValue')
91
 
        self.assertThat(lambda: component.select_many('QQuickText', objectName='WeatherDetailUnit'), Eventually(Not(Is(None))))
 
101
        self.assertThat(lambda: component.select_many('QQuickText', objectName='WeatherDetailUnit'), 
 
102
            Eventually(Not(Is(None))))
92
103
        unit = component.select_single('QQuickText', objectName='WeatherDetailUnit')
93
 
        self.assertThat(lambda: component.select_single('QQuickText', objectName='WeatherDetailValue'), Eventually(Not(Is(None))))
 
104
        self.assertThat(lambda: component.select_single('QQuickText', objectName='WeatherDetailValue'), 
 
105
            Eventually(Not(Is(None))))
94
106
        value = component.select_single('QQuickText', objectName='WeatherDetailValue')
95
107
        if pre_units == "in":
96
108
            self.assertThat(unit.text, Eventually(Equals(u'in')))
97
109
            self.assertThat(value.text, Eventually(Equals(u'0.18')))
98
110
        else:
99
111
            self.assertThat(unit.text, Eventually(Equals(u'mm')))
100
 
            self.assertThat(value.text, Eventually(Equals(u'4.5')))
 
112
            self.assertThat(value.text, Eventually(Equals(u'0.5')))
 
113
 
 
114
    def _check_service(self, service):
 
115
        """Checks selected units weather data service from the first location tab"""
 
116
        self.assertThat(lambda: self.main_window.select_many('TabFooter', objectName='TabFooter')[0], 
 
117
            Eventually(Not(Is(None))))
 
118
        current_location_tab = self.main_window.select_single('LocationTab', visible=True)
 
119
        self.assertThat(lambda: current_location_tab.select_single('TabFooter', objectName='TabFooter'), 
 
120
            Eventually(Not(Is(None))))
 
121
        self.assertThat(lambda: current_location_tab.select_single('QQuickImage', objectName='DataProviderLogo'), 
 
122
            Eventually(Not(Is(None))))
 
123
            
 
124
        focused_item = current_location_tab.select_single('QQuickItem', focus=True)
 
125
        tab_footer = current_location_tab.select_single('TabFooter', objectName='TabFooter')
 
126
        provider_logo = current_location_tab.select_single('QQuickImage', objectName='DataProviderLogo')
 
127
        if service == "weatherchannel":
 
128
            self.assertThat(tab_footer.visible, Eventually(Equals(True)))
 
129
            self.assertThat(provider_logo.visible, Eventually(Equals(False)))
 
130
        elif service == "openweathermap":
 
131
            self.assertThat(tab_footer.visible, Eventually(Equals(False)))
 
132
            self.assertThat(provider_logo.visible, Eventually(Equals(True)))
101
133
 
102
134
    def test_switch_scale(self):
103
135
        """Tests switching the scale in the settings"""
106
138
        self._open_settings_sheet()
107
139
 
108
140
        # open the value selector
109
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), Eventually(Not(Is(None))))
 
141
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), 
 
142
            Eventually(Not(Is(None))))
110
143
        units_selector = self.main_window.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
111
144
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
112
145
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
128
161
 
129
162
        # switch back to metric values again
130
163
        self._open_settings_sheet()
131
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), Eventually(Not(Is(None))))
 
164
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), 
 
165
            Eventually(Not(Is(None))))
132
166
        units_selector = self.main_window.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
133
167
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
134
168
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
161
195
        self._open_settings_sheet()
162
196
 
163
197
        # open the temp value selector
164
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), Eventually(Not(Is(None))))
 
198
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='TemperatureUnitsSelector'), 
 
199
            Eventually(Not(Is(None))))
165
200
        units_selector = self.main_window.select_single('OptionSelector', objectName="TemperatureUnitsSelector")
166
201
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
167
202
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
176
211
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
177
212
 
178
213
        # open the wind value selector
179
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), Eventually(Not(Is(None))))
 
214
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), 
 
215
            Eventually(Not(Is(None))))
180
216
        units_selector = self.main_window.select_single('OptionSelector', objectName="WindUnitsSelector")
181
217
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
182
218
        self.pointing_device.click_object(units_selector)
200
236
        self._open_settings_sheet()
201
237
 
202
238
        # open the wind value selector
203
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), Eventually(Not(Is(None))))
 
239
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), 
 
240
            Eventually(Not(Is(None))))
204
241
        units_selector = self.main_window.select_single('OptionSelector', objectName="WindUnitsSelector")
205
242
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
206
243
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
222
259
 
223
260
        # switch back to kmh values again
224
261
        self._open_settings_sheet()
225
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), Eventually(Not(Is(None))))
 
262
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='WindUnitsSelector'), 
 
263
            Eventually(Not(Is(None))))
226
264
        units_selector = self.main_window.select_single('OptionSelector', objectName="WindUnitsSelector")
227
265
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
228
266
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
247
285
        self.assertThat(load_indicator.running, Eventually(Equals(False)))
248
286
        self._check_wind_units('kmh')
249
287
 
 
288
    @skip("data not available")
250
289
    def test_switch_precipitation_scale(self):
251
290
        """Tests switching the precipition scale in the settings"""
252
291
        # first check metric values and open the settings sheet
254
293
        self._open_settings_sheet()
255
294
 
256
295
        # open the precipitation value selector
257
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'), Eventually(Not(Is(None))))
 
296
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'), 
 
297
            Eventually(Not(Is(None))))
258
298
        units_selector = self.main_window.select_single('OptionSelector', objectName="PrecipitationUnitsSelector")
259
299
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
260
300
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
276
316
 
277
317
        # switch back to mm values again
278
318
        self._open_settings_sheet()
279
 
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'), Eventually(Not(Is(None))))
 
319
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='PrecipitationUnitsSelector'), 
 
320
            Eventually(Not(Is(None))))
280
321
        units_selector = self.main_window.select_single('OptionSelector', objectName="PrecipitationUnitsSelector")
281
322
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
282
323
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
303
344
        self.assertThat(load_indicator.running, Eventually(Equals(False)))
304
345
        self._check_precipitation_units('mm')
305
346
 
 
347
    def test_switch_service(self):
 
348
        """Tests switching the scale in the settings"""
 
349
        # first check metric values and open the settings sheet
 
350
        self._check_service('weatherchannel')
 
351
        self._open_settings_sheet()
 
352
 
 
353
        # open the value selector
 
354
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='ServiceSelector'),             Eventually(Not(Is(None))))
 
355
        units_selector = self.main_window.select_single('OptionSelector', objectName="ServiceSelector")
 
356
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
 
357
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
 
358
        current_option = units_selector.select_many('ShapeItem')[1]
 
359
        self.pointing_device.click_object(current_option)
 
360
 
 
361
        # choose second option, openweathermap
 
362
        self._move_pointer_around()
 
363
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
 
364
        second_option = units_selector.select_many('ShapeItem')[2]
 
365
        self.pointing_device.click_object(second_option)
 
366
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
 
367
 
 
368
        # check if precipitation units selector appears
 
369
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', 
 
370
            objectName='PrecipitationUnitsSelector'), Eventually(Not(Is(None))))
 
371
        units_selector = self.main_window.select_single('OptionSelector', 
 
372
            objectName="PrecipitationUnitsSelector")
 
373
        self.assertThat(units_selector.visible, Eventually(Equals(1)))
 
374
        self._click_sheet_confirm()
 
375
 
 
376
        # wait for reload and check the used service 
 
377
        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
 
378
        self.assertThat(load_indicator.running, Eventually(Equals(False)))
 
379
        self._check_service('openweathermap')
 
380
 
 
381
        # switch back to metric values again
 
382
        self._open_settings_sheet()
 
383
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', objectName='ServiceSelector'),             Eventually(Not(Is(None))))
 
384
        units_selector = self.main_window.select_single('OptionSelector', objectName="ServiceSelector")
 
385
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(1)))
 
386
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[2], Eventually(Not(Is(None))))
 
387
        current_option = units_selector.select_many('ShapeItem')[2]
 
388
        self.pointing_device.click_object(current_option)
 
389
        # while it's opened, units_selector returns false
 
390
        # self.assertThat(units_selector.expanded, Eventually(Equals(True)))
 
391
 
 
392
        # click twc option
 
393
        self._move_pointer_around()
 
394
        self.assertThat(lambda: units_selector.select_many('ShapeItem')[1], Eventually(Not(Is(None))))
 
395
        first_option = units_selector.select_single(
 
396
            'OptionSelectorDelegate', objectName='twcOption')
 
397
        self.pointing_device.click_object(first_option)
 
398
        self.assertThat(units_selector.selectedIndex, Eventually(Equals(0)))
 
399
 
 
400
        # check if precipitation units selector disappears and confirm
 
401
        self.assertThat(lambda: self.main_window.select_single('OptionSelector', 
 
402
            objectName='PrecipitationUnitsSelector'), Eventually(Not(Is(None))))
 
403
        units_selector = self.main_window.select_single('OptionSelector', 
 
404
            objectName="PrecipitationUnitsSelector")
 
405
        self.assertThat(units_selector.visible, Eventually(Equals(0)))
 
406
        self._click_sheet_confirm()
 
407
 
 
408
        # wait for reload and check the metric values again
 
409
        load_indicator = self.main_window.select_single('ActivityIndicator', objectName='LoadingSpinner')
 
410
        self.assertThat(load_indicator.running, Eventually(Equals(False)))
 
411
        self._check_service('weatherchannel')