1
=== modified file 'alarm/AlarmPage.qml'
2
--- alarm/AlarmPage.qml	2013-10-26 13:55:35 +0000
3
+++ alarm/AlarmPage.qml	2013-11-07 16:34:52 +0000
4
@@ -217,14 +217,7 @@
5
217
217
6
218
                    selected: listSavedAlarm.currentIndex == index
218
                    selected: listSavedAlarm.currentIndex == index
7
219
                    removable: true
219
                    removable: true
16
220
220
                    confirmRemoval: true
9
221
                    // TODO: Replace SwipeDelete custom component with SDK default component. Ensure that bugs
10
222
                    // https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1241506, https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1242089
11
223
                    // and https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1236464 are fixed beforehand.
12
224
                    backgroundIndicator: SwipeDelete {
13
225
                        id: swipeDelete
14
226
                        state: swipingState
15
227
                    }
17
228
221
18
229
                    onItemRemoved: {
222
                    onItemRemoved: {
19
230
                        var alarm = alarmModel.get(index)
223
                        var alarm = alarmModel.get(index)
20
231
224
21
=== modified file 'clock/ClockPage.qml'
22
--- clock/ClockPage.qml	2013-11-01 16:10:28 +0000
23
+++ clock/ClockPage.qml	2013-11-07 16:34:52 +0000
24
@@ -214,6 +214,7 @@
25
214
                currentIndex: -1
214
                currentIndex: -1
26
215
215
27
216
                delegate: ListItem.Standard {
216
                delegate: ListItem.Standard {
28
217
                    objectName: "savedworldcity" + index
29
217
                    Label {
218
                    Label {
30
218
                        text: cityName
219
                        text: cityName
31
219
                        objectName: "city_name"
220
                        objectName: "city_name"
32
@@ -231,18 +232,9 @@
33
231
232
34
232
                    selected: listWorldClocks.currentIndex == index
233
                    selected: listWorldClocks.currentIndex == index
35
233
                    removable: true
234
                    removable: true
48
234
235
                    confirmRemoval: true
49
235
                    // TODO: Replace SwipeDelete custom component with SDK default component. Ensure that bugs
236
50
236
                    // https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1241506, https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1242089
237
                    onItemRemoved: worldModel.removePreset(index);
39
237
                    // and https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1236464 are fixed beforehand.
40
238
                    backgroundIndicator: SwipeDelete {
41
239
                        id: swipeDelete
42
240
                        state: swipingState
43
241
                    }
44
242
45
243
                    onItemRemoved: {
46
244
                        worldModel.removePreset(index);
47
245
                    }
51
246
                }
238
                }
52
247
            }
239
            }
53
248
        }
240
        }
54
249
241
55
=== modified file 'clock/WorldClock.qml'
56
--- clock/WorldClock.qml	2013-10-25 04:33:48 +0000
57
+++ clock/WorldClock.qml	2013-11-07 16:34:52 +0000
58
@@ -126,6 +126,7 @@
59
126
            section.labelPositioning: ViewSection.InlineLabels
126
            section.labelPositioning: ViewSection.InlineLabels
60
127
127
61
128
            delegate: ListItem.Base {
128
            delegate: ListItem.Base {
62
129
                objectName: "worldcity" + index
63
129
                visible: !errorMessage.visible
130
                visible: !errorMessage.visible
64
130
                height: adminName || adminName2 ? units.gu(8) : units.gu(6)
131
                height: adminName || adminName2 ? units.gu(8) : units.gu(6)
65
131
                Column {
132
                Column {
66
132
133
67
=== removed file 'common/SwipeDelete.qml'
68
--- common/SwipeDelete.qml	2013-07-20 07:54:03 +0000
69
+++ common/SwipeDelete.qml	1970-01-01 00:00:00 +0000
70
@@ -1,67 +0,0 @@
71
1
/*
72
2
 * Copyright (C) 2013 Canonical Ltd
73
3
 *
74
4
 * This program is free software: you can redistribute it and/or modify
75
5
 * it under the terms of the GNU General Public License version 3 as
76
6
 * published by the Free Software Foundation.
77
7
 *
78
8
 * This program is distributed in the hope that it will be useful,
79
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
80
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
81
11
 * GNU General Public License for more details.
82
12
 *
83
13
 * You should have received a copy of the GNU General Public License
84
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
85
15
 *
86
16
 * Authored by: Nekhelesh Ramananthan <krnekhelesh@gmail.com>
87
17
 */
88
18
89
19
import QtQuick 2.0
90
20
import Ubuntu.Components 0.1
91
21
92
22
// Qml element to customize list item swipe behavior.
93
23
Rectangle {
94
24
    id: swipeBackgroundItem
95
25
96
26
    anchors.fill: parent
97
27
    color: Theme.palette.normal.base;
98
28
99
29
    Image {
100
30
        id: swipeDeleteIcon
101
31
102
32
        property int slidingMargin: units.gu(12)
103
33
104
34
        anchors { verticalCenter: parent.verticalCenter; left: parent.left; right: parent.right }
105
35
        verticalAlignment: Image.AlignVCenter        
106
36
        fillMode: Image.Pad
107
37
    }
108
38
109
39
    Label {
110
40
        id: swipeBackgroundText
111
41
112
42
        property int slidingMargin: units.gu(3)
113
43
114
44
        anchors.fill: parent
115
45
        verticalAlignment: Text.AlignVCenter
116
46
        color: Theme.palette.normal.baseText
117
47
        fontSize: "large"
118
48
    }
119
49
120
50
    states: [
121
51
        State {
122
52
            name: "SwipingRight"
123
53
            PropertyChanges { target: swipeBackgroundText; anchors.rightMargin: swipeBackgroundText.slidingMargin
124
54
                anchors.leftMargin: 0; horizontalAlignment: Text.AlignRight; text: i18n.tr("Delete") }
125
55
            PropertyChanges { target: swipeDeleteIcon; anchors.rightMargin: swipeDeleteIcon.slidingMargin
126
56
                anchors.leftMargin: 0; horizontalAlignment: Image.AlignRight; source: Qt.resolvedUrl("../images/trash_icon.png")}
127
57
        },
128
58
129
59
        State {
130
60
            name: "SwipingLeft"
131
61
            PropertyChanges { target: swipeBackgroundText; anchors.rightMargin: 0; anchors.leftMargin: swipeBackgroundText.slidingMargin
132
62
                horizontalAlignment: Text.AlignLeft; text: i18n.tr("Delete") }
133
63
            PropertyChanges { target: swipeDeleteIcon; anchors.rightMargin: 0; source: Qt.resolvedUrl("../images/trash_icon.png")
134
64
                anchors.leftMargin: swipeDeleteIcon.slidingMargin; horizontalAlignment: Image.AlignLeft }
135
65
        }
136
66
    ]
137
67
}
138
68
0
139
=== modified file 'stopwatch/LapList.qml'
140
--- stopwatch/LapList.qml	2013-10-26 13:55:35 +0000
141
+++ stopwatch/LapList.qml	2013-11-07 16:34:52 +0000
142
@@ -91,15 +91,10 @@
143
91
            }
91
            }
144
92
            
92
            
145
93
            removable: true
93
            removable: true
155
94
            
94
            // FIXME: Confirm removal for stopwatch is not required. However if set to false, then the SDK does not display
156
95
            // TODO: Replace SwipeDelete custom component with SDK default component. Ensure that bugs
95
            // the delete text and icon leading to the user not being aware which action is performed on swiping left/right.
157
96
            // https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1241506, https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1242089
96
            // Reported bug at https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1242089
158
97
            // and https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1236464 are fixed beforehand.
97
            confirmRemoval: true
150
98
            backgroundIndicator: SwipeDelete {
151
99
                id: swipeDelete
152
100
                state: swipingState
153
101
            }
154
102
            
159
103
            onItemRemoved: lapModel.remove(index)
98
            onItemRemoved: lapModel.remove(index)
160
104
            
99
            
161
105
            Label {
100
            Label {
162
106
101
163
=== modified file 'tests/autopilot/ubuntu_clock_app/emulators.py'
164
--- tests/autopilot/ubuntu_clock_app/emulators.py	2013-10-26 13:02:16 +0000
165
+++ tests/autopilot/ubuntu_clock_app/emulators.py	2013-11-07 16:34:52 +0000
166
@@ -13,16 +13,20 @@
167
13
#
13
#
168
14
# You should have received a copy of the GNU Lesser General Public License
14
# You should have received a copy of the GNU Lesser General Public License
169
15
# along with this program. If not, see <http://www.gnu.org/licenses/>.
15
# along with this program. If not, see <http://www.gnu.org/licenses/>.
170
16
#
171
17
# Authored by: Nekhelesh Ramananthan <krnekhelesh@gmail.com>
172
18
#              Nicholas Skaggs <nicholas.skaggs@canonical.com>
173
16
19
174
17
from ubuntuuitoolkit import emulators as toolkit_emulators
20
from ubuntuuitoolkit import emulators as toolkit_emulators
175
18
from autopilot.matchers import Eventually
21
from autopilot.matchers import Eventually
176
19
from testtools.matchers import Not, Is, Equals
22
from testtools.matchers import Not, Is, Equals
177
20
from time import sleep
23
from time import sleep
178
21
24
179
22
180
23
class MainView(toolkit_emulators.MainView):
25
class MainView(toolkit_emulators.MainView):
181
24
26
182
27
    # Common Emulator Functions    
183
25
    def _drag_page(self, page, test_case, direction):
28
    def _drag_page(self, page, test_case, direction):
184
29
        """Function to drag the page up/down"""
185
26
        page_func = lambda: self.select_single(page)
30
        page_func = lambda: self.select_single(page)
186
27
        test_case.assertThat(page_func, Eventually(Not(Is(None))))
31
        test_case.assertThat(page_func, Eventually(Not(Is(None))))
187
28
        page = self.select_single(page)
32
        page = self.select_single(page)
188
@@ -49,59 +53,58 @@
189
49
        self._drag_page(page, test_case, "down")
53
        self._drag_page(page, test_case, "down")
190
50
54
191
51
    def longpress_object(self, obj):
55
    def longpress_object(self, obj):
192
56
        """Function to longpress an object"""
193
52
        self.pointing_device.move_to_object(obj)
57
        self.pointing_device.move_to_object(obj)
194
53
        self.pointing_device.press()
58
        self.pointing_device.press()
195
54
        sleep(2)
59
        sleep(2)
196
55
        self.pointing_device.release()
60
        self.pointing_device.release()
197
56
61
239
57
    #stopwatch page
62
    # CLOCK Page Emulator Functions
240
58
    def get_stopwatch_label(self):
63
    def get_clock_page(self):
241
59
        """Returns the select for the stopwatch label"""
64
        """Return the page containing the main clock."""
242
60
        return self.select_single("Label", objectName="labelStopwatch")
65
        return self.select_single("ClockPage")
243
61
66
244
62
    def get_stopwatch_button(self):
67
    def get_time_label(self):
245
63
        """Returns the select for the stopwatch button"""
68
        """Return the label with the timer countdown"""
246
64
        return self.select_single("AnalogStopwatch",
69
        return self.wait_select_single("Label", objectName="currentTimeLabel")
247
65
                                  objectName="buttonStopwatch")
70
248
66
71
    # WORLD CLOCK Page Emulator Functions
249
67
    def get_lap_button(self):
72
    def get_world_cities_page(self):
250
68
        """Returns the select for the lap button"""
73
        """Return the page containing the world cities."""
251
69
        return self.select_single("Button", objectName="lapButton")
74
        return self.wait_select_single("WorldClock")    
252
70
75
253
71
    def get_reset_button(self):
76
    def get_world_cities_list(self):
254
72
        """Returns the select for the reset button"""
77
        """Return the component containing the list of available world cities."""
255
73
        return self.select_single("ImageButton", objectName="resetButton")
78
        return self.wait_select_single(objectName="worldList")
256
74
79
257
75
    def get_laps(self):
80
    def get_city_name(self, city):
258
76
        """Returns the select for the lap count"""
81
        """Return the name of the city passed as argument"""
259
77
        return self.select_single("ListModel", objectName="laps")
82
        return city.select_single('Label', objectName='city_name').text
260
78
83
261
79
    #timer page
84
    def get_saved_cities_list(self):
262
80
    def get_toolbar_timer(self):
85
        """Return the component containing list of user saved world city locations."""
263
81
        """Returns the toolbar of timer tab"""
86
        return self.wait_select_single(objectName="listWorldClocks")
264
82
        return self.select_single("ToolbarItems")
87
265
83
88
    def grab_first_listed_city(self):
266
84
    def get_toolbar_timer_button(self, button_idx):
89
        """Return the first city from the available world cities list (both local and online)"""
267
85
        """Returns a button of toolbar of timer tab"""
90
        return self.wait_select_single("Base", objectName="worldcity0")
268
86
        toolbar = self.select_single("ToolbarItems")
91
269
87
        button = toolbar.get_children()
92
    def select_city(self, city):
270
88
        return button[button_idx]
93
        """Click the selected city passed as argument"""
271
89
94
        self.pointing_device.click_object(city)
272
90
    def get_toolbar_timer_add_preset_button(self):
95
273
91
        """Returns the button for add preset of toolbar of timer tab"""
96
    def grab_first_saved_city(self):
274
92
        return self.select_single('ActionItem', objectName="addPresetButton")
97
        """Return the first city from the user saved world cities list"""        
275
93
98
        return self.wait_select_single("Standard", objectName="savedworldcity0")
276
94
    def get_toolbar_timer_save_preset_button(self):
99
277
95
        """Returns the button for add preset of toolbar of timer tab"""
100
    # TIMER Page Emulator Functions
237
96
        return self.select_single("ActionItem", objectName="savePresetButton")
238
97
278
98
    def get_timer_name_preset(self):
101
    def get_timer_name_preset(self):
279
99
        """Returns the TextField where insert the name of the preset"""
102
        """Returns the TextField where insert the name of the preset"""
281
100
        return self.select_single("LabelDots", objectName="namePreset")
103
        return self.wait_select_single("LabelDots", objectName="namePreset")
282
101
104
283
102
    def get_timer_minute_hand(self):
105
    def get_timer_minute_hand(self):
284
103
        """Returns the hour hand of clock in timer tab"""
106
        """Returns the hour hand of clock in timer tab"""
286
104
        return self.select_single("AnalogTouchHand", objectName="minuteHand")
107
        return self.wait_select_single("AnalogTouchHand", objectName="minuteHand")
287
105
108
288
106
    def get_preset_label_text(self):
109
    def get_preset_label_text(self):
289
107
        """Returns the label with the preset text"""
110
        """Returns the label with the preset text"""
290
@@ -115,22 +118,40 @@
291
115
118
292
116
    def get_label_timer(self):
119
    def get_label_timer(self):
293
117
        """Return the label with the timer countdown"""
120
        """Return the label with the timer countdown"""
295
118
        return self.select_single("Label", objectName="labelTimer")
121
        return self.wait_select_single("Label", objectName="labelTimer")
296
119
122
297
120
    def get_first_preset_list_item(self):
123
    def get_first_preset_list_item(self):
298
121
        """Returns the first preset list item in the timer page."""
124
        """Returns the first preset list item in the timer page."""
304
122
        return self.select_single("Standard", objectName="preset0")
125
        return self.wait_select_single("Standard", objectName="preset0")    
300
123
301
124
    def get_time_label(self):
302
125
        """Return the label with the timer countdown"""
303
126
        return self.select_single("Label", objectName="currentTimeLabel")
305
127
126
306
128
    def get_num_of_presets(self):
127
    def get_num_of_presets(self):
307
129
        """Returns the number of presets in the timer page."""
128
        """Returns the number of presets in the timer page."""
308
130
        timer_page = self.select_single("TimerPage")
129
        timer_page = self.select_single("TimerPage")
312
131
        return int(timer_page.select_single("QQuickListView").count)
130
        return int(timer_page.wait_select_single("QQuickListView").count)
313
132
131
314
133
    #alarm page
132
    # STOPWATCH Page Emulator Functions
315
133
    def get_stopwatch_label(self):
316
134
        """Returns the select for the stopwatch label"""
317
135
        return self.wait_select_single("Label", objectName="labelStopwatch")
318
136
319
137
    def get_stopwatch_button(self):
320
138
        """Returns the select for the stopwatch button"""
321
139
        return self.wait_select_single("AnalogStopwatch",
322
140
                                  objectName="buttonStopwatch")
323
141
324
142
    def get_lap_button(self):
325
143
        """Returns the select for the lap button"""
326
144
        return self.wait_select_single("Button", objectName="lapButton")
327
145
328
146
    def get_reset_button(self):
329
147
        """Returns the select for the reset button"""
330
148
        return self.wait_select_single("ImageButton", objectName="resetButton")
331
149
332
150
    def get_laps(self):
333
151
        """Returns the select for the lap count"""
334
152
        return self.wait_select_single("ListModel", objectName="laps")
335
153
    
336
154
    # ALARM Page Emulator Functions
337
134
    def get_addalarm_page(self):
155
    def get_addalarm_page(self):
338
135
        """Returns the add alarm page object"""
156
        """Returns the add alarm page object"""
339
136
        return self.select_single("Page", objectName="addAlarmPage")
157
        return self.select_single("Page", objectName="addAlarmPage")
340
@@ -285,25 +306,4 @@
341
285
        test_case.assertThat(lambda: self.select_single(
306
        test_case.assertThat(lambda: self.select_single(
342
286
            "OptionSelector", objectName="RepeatSelector").selectedIndex+1,
307
            "OptionSelector", objectName="RepeatSelector").selectedIndex+1,
343
287
            Eventually(Equals(occurence)))
308
            Eventually(Equals(occurence)))
366
288
309
    
345
289
    #world clock page
346
290
    def get_add_city_button(self):
347
291
        """Return the button for adding a new clock location."""
348
292
        return self.select_single(
349
293
            "ActionItem", objectName="addCityAction")
350
294
351
295
    def get_world_cities_page(self):
352
296
        """Return the page containing the world cities."""
353
297
        return self.select_single("WorldClock")
354
298
355
299
    def get_clock_page(self):
356
300
        """Return the page containing the main clock."""
357
301
        return self.select_single("ClockPage")
358
302
359
303
    def get_world_cities_list(self):
360
304
        """Return the component containing the list of world cities."""
361
305
        return self.select_single(objectName="worldList")
362
306
363
307
    def get_selected_cities_list(self):
364
308
        """Return the component containing list of selected clock locations."""
365
309
        return self.select_single(objectName="listWorldClocks")
367
310
310
368
=== modified file 'tests/autopilot/ubuntu_clock_app/tests/test_alarm.py'
369
--- tests/autopilot/ubuntu_clock_app/tests/test_alarm.py	2013-10-22 15:20:06 +0000
370
+++ tests/autopilot/ubuntu_clock_app/tests/test_alarm.py	2013-11-07 16:34:52 +0000
371
@@ -13,6 +13,8 @@
372
13
#
13
#
373
14
# You should have received a copy of the GNU General Public License
14
# You should have received a copy of the GNU General Public License
374
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
375
16
#
376
17
# Authored by: Nicholas Skaggs <nicholas.skaggs@canonical.com>
377
16
18
378
17
"""Tests for the Clock App - Alarm"""
19
"""Tests for the Clock App - Alarm"""
379
18
20
380
19
21
381
=== modified file 'tests/autopilot/ubuntu_clock_app/tests/test_clock.py'
382
--- tests/autopilot/ubuntu_clock_app/tests/test_clock.py	2013-10-25 04:33:48 +0000
383
+++ tests/autopilot/ubuntu_clock_app/tests/test_clock.py	2013-11-07 16:34:52 +0000
384
@@ -15,6 +15,7 @@
385
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
386
16
#
16
#
387
17
# Authored by: Renato Araujo Oliveira Filho <renato@canonical.com>
17
# Authored by: Renato Araujo Oliveira Filho <renato@canonical.com>
388
18
#              Nekhelesh Ramananthan <krnekhelesh@gmail.com>
389
18
19
390
19
"""
20
"""
391
20
Tests for the Clock App, main window.
21
Tests for the Clock App, main window.
392
@@ -54,64 +55,40 @@
393
54
        # and compare the values
55
        # and compare the values
394
55
        self.assertThat(label.text, Eventually(NotEquals('')))
56
        self.assertThat(label.text, Eventually(NotEquals('')))
395
56
57
398
57
    def test_add_remove_world_location(self):
58
    def test_add_local_world_city(self):
399
58
        """It must be possible to add and remove world locations."""
59
        """Test to check if adding a local listed world city works"""
400
59
60
402
60
        self.assert_no_cities_selected()
61
        # Open clock toolbar        
403
61
        self.main_view.open_toolbar()
62
        self.main_view.open_toolbar()
457
62
        self.switch_to_world_cities_page()
63
458
63
        city = self.grab_first_city()
64
        # Click add city toolbar button
459
64
        city_name = self.city_name_from(city)
65
        self.main_view.get_toolbar().click_button('addCityAction')
460
65
66
461
66
        self.select_city(city)
67
        # Click on first city in the list shown and ensure that it was saved
462
67
68
        city = self.main_view.grab_first_listed_city()
463
68
        selected_city_name = self.city_name_from(self.selected_city())
69
        city_name = self.main_view.get_city_name(city)
464
69
        self.assertThat(selected_city_name, Eventually(Equals(city_name)))
70
        self.main_view.select_city(city)
465
70
71
        saved_city_name = self.main_view.get_city_name(self.main_view.grab_first_saved_city())
466
71
        delete_button = self.enable_delete_button()
72
        self.assertThat(saved_city_name, Eventually(Equals(city_name)))
467
72
        self.pointing_device.click_object(delete_button)
73
468
73
        self.assert_no_cities_selected()
74
    def test_delete_local_world_city(self):
469
74
75
        """Test to check if deleting a saved local world city works"""
470
75
    def city_name_from(self, city):
76
471
76
        return city.select_single('Label', objectName='city_name').text
77
        # Add a local world city        
472
77
78
        self.test_add_local_world_city()
473
78
    def enable_delete_button(self):
79
474
79
        selected_city = self.selected_city()
80
        # Close toolbar and drag page up to see the saved world city list        
475
80
        x, y, w, h = selected_city.globalRect
81
        self.main_view.close_toolbar()
423
81
424
82
        tx = x + (w / 8)
425
83
        ty = y + (h / 2)
426
84
427
85
        self.pointing_device.drag(tx, ty, w - w / 8, ty)
428
86
        delete_button = selected_city.select_many("QQuickItem")[2]
429
87
        self.assertThat(lambda: delete_button, Eventually(NotEquals(None)))
430
88
431
89
        return delete_button
432
90
433
91
    def switch_to_world_cities_page(self):
434
92
        add_city_button = self.main_view.get_add_city_button()
435
93
        self.pointing_device.click_object(add_city_button)
436
94
        self.assertThat(self.main_view.get_world_cities_page, Eventually(NotEquals(None)))
437
95
438
96
    def grab_first_city(self):
439
97
        self.assertThat(self.main_view.get_world_cities_list, Eventually(NotEquals(None)))
440
98
        cities_list = self.main_view.get_world_cities_list()
441
99
        self.assertThat(lambda: not cities_list.select_many("Base"), Eventually(Equals(False)))
442
100
443
101
        return cities_list.select_many("Base")[0]
444
102
445
103
    def select_city(self, city):
446
104
        self.pointing_device.click_object(city)
447
105
        self.assertThat(self.main_view.get_clock_page, Eventually(NotEquals(None)))
448
106
449
107
    def selected_city(self):
450
108
        self.assertThat(self.main_view.get_selected_cities_list, Eventually(NotEquals(None)))
451
109
        selected_cities = self.main_view.get_selected_cities_list()
452
110
        self.assertThat(lambda: not selected_cities.select_many("Standard"), Eventually(Equals(False)))
453
111
454
112
        return selected_cities.select_many("Standard")[0]
455
113
456
114
    def assert_no_cities_selected(self):
476
115
        self.main_view.drag_page_up("ClockPage", self)
82
        self.main_view.drag_page_up("ClockPage", self)
479
116
        cities = self.main_view.get_selected_cities_list()
83
480
117
        self.assertThat(cities.count, Eventually(Equals(0)))
84
        # Get the saved world city and swipe to delete
481
85
        old_saved_city_count = self.main_view.get_saved_cities_list().count
482
86
        saved_city = self.main_view.grab_first_saved_city()
483
87
        saved_city.swipe_to_delete()
484
88
        saved_city.confirm_removal()
485
89
486
90
        # Assert deletion of saved city
487
91
        cities = self.main_view.get_saved_cities_list()
488
92
        self.assertThat(
489
93
            cities.count,
490
94
            Eventually(Equals(old_saved_city_count - 1)))
491
118
95
492
=== modified file 'tests/autopilot/ubuntu_clock_app/tests/test_stopwatch.py'
493
--- tests/autopilot/ubuntu_clock_app/tests/test_stopwatch.py	2013-08-14 02:07:36 +0000
494
+++ tests/autopilot/ubuntu_clock_app/tests/test_stopwatch.py	2013-11-07 16:34:52 +0000
495
@@ -35,8 +35,7 @@
496
35
        self.assertThat(
35
        self.assertThat(
497
36
            self.main_view.visible, Eventually(Equals(True)))
36
            self.main_view.visible, Eventually(Equals(True)))
498
37
37
501
38
        #move to stopwatch tab
38
        # Move to stopwatch tab
500
39
        #ignoring the emulator tab functions until fixed
502
40
        self.main_view.switch_to_tab("StopwatchTab")
39
        self.main_view.switch_to_tab("StopwatchTab")
503
41
40
504
42
    def tearDown(self):
41
    def tearDown(self):
505
@@ -45,15 +44,11 @@
506
45
    def test_start_stop_reset_stopwatch(self):
44
    def test_start_stop_reset_stopwatch(self):
507
46
        """Test to check the proper functioning of the start/stop/reset of stopwatch"""
45
        """Test to check the proper functioning of the start/stop/reset of stopwatch"""
508
47
46
509
48
        self.assertThat(self.main_view.get_stopwatch_button, Eventually(Not(Is(None))))
510
49
        start_stop_button = self.main_view.get_stopwatch_button()
47
        start_stop_button = self.main_view.get_stopwatch_button()
511
50
        self.assertThat(self.main_view.get_stopwatch_label, Eventually(Not(Is(None))))
512
51
        stopwatch_label = self.main_view.get_stopwatch_label()
48
        stopwatch_label = self.main_view.get_stopwatch_label()
513
52
        self.assertThat(self.main_view.get_reset_button, Eventually(Not(Is(None))))
514
53
        reset_button = self.main_view.get_reset_button()
49
        reset_button = self.main_view.get_reset_button()
515
54
50
518
55
        # Press the start button to start the stopwatch
51
        # Press the start button to start the stopwatch and check if the stopwatch starts ticking
517
56
        self.assertThat(self.main_view.get_stopwatch_label, Eventually(Not(Is(None))))
519
57
        stopwatch_label_before = self.main_view.get_stopwatch_label().text
52
        stopwatch_label_before = self.main_view.get_stopwatch_label().text
520
58
        self.pointing_device.click_object(start_stop_button)
53
        self.pointing_device.click_object(start_stop_button)
521
59
        self.assertThat(stopwatch_label.text, Eventually(NotEquals("00:00.0")))
54
        self.assertThat(stopwatch_label.text, Eventually(NotEquals("00:00.0")))
522
60
55
523
=== modified file 'tests/autopilot/ubuntu_clock_app/tests/test_timer.py'
524
--- tests/autopilot/ubuntu_clock_app/tests/test_timer.py	2013-10-16 18:54:28 +0000
525
+++ tests/autopilot/ubuntu_clock_app/tests/test_timer.py	2013-11-07 16:34:52 +0000
526
@@ -15,6 +15,7 @@
527
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
528
16
#
16
#
529
17
# Authored by: Riccardo Padovani <rpadovani@ubuntu-it.org>
17
# Authored by: Riccardo Padovani <rpadovani@ubuntu-it.org>
530
18
#              Nekhelesh Ramananthan <krnekhelesh@gmail.com>
531
18
19
532
19
"""Tests for the Clock App - Timer"""
20
"""Tests for the Clock App - Timer"""
533
20
21
534
@@ -36,7 +37,7 @@
535
36
        self.assertThat(
37
        self.assertThat(
536
37
            self.main_view.visible, Eventually(Equals(True)))
38
            self.main_view.visible, Eventually(Equals(True)))
537
38
39
539
39
        #move to timer tab
40
        # Move to Timer tab
540
40
        self.main_view.switch_to_tab("TimerTab")
41
        self.main_view.switch_to_tab("TimerTab")
541
41
42
542
42
    def select_name_preset_label(self):
43
    def select_name_preset_label(self):
543
@@ -55,13 +56,10 @@
544
55
        self.main_view.open_toolbar()
56
        self.main_view.open_toolbar()
545
56
57
546
57
        # Click the add preset button
58
        # Click the add preset button
550
58
        self.assertThat(self.main_view.get_toolbar_timer_add_preset_button, Eventually(Not(Is(None))))
59
        self.main_view.get_toolbar().click_button('addPresetButton')
548
59
        add_preset_button = self.main_view.get_toolbar_timer_add_preset_button()
549
60
        self.pointing_device.click_object(add_preset_button)
551
61
60
553
62
        # Write in the label
61
        # Set Timer label as "test"
554
63
        self.main_view.drag_page_up("TimerPage", self)
62
        self.main_view.drag_page_up("TimerPage", self)
555
64
        self.assertThat(self.main_view.get_timer_name_preset, Eventually(Not(Is(None))))
556
65
        label = self.select_name_preset_label()
63
        label = self.select_name_preset_label()
557
66
        self.assertThat(label.focus, Eventually(Equals(True)))
64
        self.assertThat(label.focus, Eventually(Equals(True)))
558
67
        self.keyboard.type("test")
65
        self.keyboard.type("test")
559
@@ -69,10 +67,8 @@
560
69
67
561
70
        self.main_view.drag_page_down("TimerPage", self)
68
        self.main_view.drag_page_down("TimerPage", self)
562
71
69
565
72
        # Set minute
70
        # Set timer minute
564
73
        self.assertThat(self.main_view.get_timer_minute_hand, Eventually(Not(Is(None))))
566
74
        minute = self.main_view.get_timer_minute_hand()
71
        minute = self.main_view.get_timer_minute_hand()
567
75
568
76
        timeout = 0
72
        timeout = 0
569
77
        while label.focus == True and timeout < 10:
73
        while label.focus == True and timeout < 10:
570
78
            TimerLabel = self.main_view.get_label_timer()
74
            TimerLabel = self.main_view.get_label_timer()
571
@@ -83,49 +79,15 @@
572
83
        x, y, w, h = minute.globalRect
79
        x, y, w, h = minute.globalRect
573
84
        tx = x + (w / 2)
80
        tx = x + (w / 2)
574
85
        ty = y + (h / 2.5)
81
        ty = y + (h / 2.5)
615
86
        self.pointing_device.drag(tx, ty - (h / 4), tx + (w / 2), ty + (h / 2))
82
        self.pointing_device.drag(tx, ty - (h / 4), tx + (w / 2), ty + (h / 2))        
616
87
83
617
88
        self.assertThat(self.main_view.get_num_of_presets, Eventually(Not(Is(None))))
84
        # Press "Save" toolbar button and ensure that preset is saved and check that
618
89
        num_of_presets_old = self.main_view.get_num_of_presets()
85
        # the timer preset has been added.
619
90
86
        num_of_presets_old = self.main_view.get_num_of_presets()
620
91
        # Press "Save" toolbar button
87
        self.main_view.get_toolbar().click_button('savePresetButton')
581
92
        self.assertThat(self.main_view.get_toolbar_timer_save_preset_button, Eventually(Not(Is(None))))
582
93
583
94
        #make sure preset is saved, and shows up properly
584
95
        timeout = 0
585
96
        while self.main_view.get_num_of_presets() != num_of_presets_old + 1 and timeout < 10:
586
97
            save_preset_button = self.main_view.get_toolbar_timer_save_preset_button()
587
98
            self.pointing_device.click_object(save_preset_button)
588
99
            sleep(1)
589
100
            timeout += 1
590
101
591
102
    def test_delete_preset(self):
592
103
        """Test if the swipe of a preset deletes it"""
593
104
594
105
        # Create a new preset
595
106
        self.test_add_preset()
596
107
597
108
        self.assertThat(self.main_view.get_num_of_presets, Eventually(Not(Is(None))))
598
109
        num_of_presets_old = self.main_view.get_num_of_presets()
599
110
        self.assertThat(self.main_view.get_first_preset_list_item, Eventually(Not(Is(None))))
600
111
601
112
        self.main_view.drag_page_up("TimerPage", self)
602
113
603
114
        # Delete the preset
604
115
        timeout = 0
605
116
        while self.main_view.get_num_of_presets() != num_of_presets_old - 1 and timeout < 10:
606
117
            first_preset = self.main_view.get_first_preset_list_item()
607
118
            x, y, w, h = first_preset.globalRect
608
119
            tx = x + (w / 8)
609
120
            ty = y + (h / 2)
610
121
            self.pointing_device.drag(tx, ty, w - w / 8, ty)
611
122
            sleep(1)
612
123
            timeout += 1
613
124
614
125
        # Check has been deleted
621
126
        self.assertThat(
88
        self.assertThat(
622
127
            self.main_view.get_num_of_presets,
89
            self.main_view.get_num_of_presets,
624
128
            Eventually(Equals(num_of_presets_old - 1)))
90
            Eventually(Equals(num_of_presets_old + 1)))
625
129
91
626
130
    def test_run_preset(self):
92
    def test_run_preset(self):
627
131
        """Tests if a preset can runs"""
93
        """Tests if a preset can runs"""
628
@@ -133,26 +95,39 @@
629
133
        # Create a new preset
95
        # Create a new preset
630
134
        self.test_add_preset()
96
        self.test_add_preset()
631
135
97
632
98
        self.main_view.drag_page_up("TimerPage", self)
633
99
634
136
        # Click to select the preset
100
        # Click to select the preset
639
137
        self.assertThat(self.main_view.get_first_preset_list_item, Eventually(Not(Is(None))))
101
        # FIXME: Instead of always running the first preset, run the preset which was created
640
138
        first_preset = self.main_view.get_first_preset_list_item()
102
        first_preset = self.main_view.get_first_preset_list_item()        
637
139
638
140
        self.main_view.drag_page_up("TimerPage", self)
641
141
        self.pointing_device.click_object(first_preset)
103
        self.pointing_device.click_object(first_preset)
642
142
104
643
143
        self.main_view.drag_page_down("TimerPage", self)
105
        self.main_view.drag_page_down("TimerPage", self)
644
144
106
645
145
        # Click to start the preset
107
        # Click to start the preset
653
146
        self.assertThat(self.main_view.get_label_timer, Eventually(Not(Is(None))))
108
        label = self.main_view.get_label_timer()
654
147
        timeout = 0
109
        self.pointing_device.click_object(label)
648
148
        while self.main_view.get_label_timer() is None and timeout < 10:
649
149
            label = self.main_view.get_label_timer()
650
150
            self.pointing_device.click_object(label)
651
151
            sleep(1)
652
152
            timeout += 1
655
153
110
656
154
        # Check if timer is started
111
        # Check if timer is started
661
155
        self.assertThat(self.main_view.get_label_timer, Eventually(Not(Is(None))))
112
        self.assertThat(label.text, Eventually(NotEquals("03:00")))
662
156
        label_timer = self.main_view.get_label_timer()
113
663
157
        self.pointing_device.click_object(label_timer)
114
    def test_delete_preset(self):
664
158
        self.assertThat(label_timer.text, Eventually(NotEquals("21:00")))
115
        """Test if the swipe of a preset deletes it"""
665
116
666
117
        # Create a new preset
667
118
        self.test_add_preset()
668
119
669
120
        num_of_presets_old = self.main_view.get_num_of_presets()
670
121
        self.main_view.drag_page_up("TimerPage", self)
671
122
672
123
        # Delete the preset
673
124
        # FIXME: Delete the preset that was added instead of always deleting the first preset
674
125
        first_preset = self.main_view.get_first_preset_list_item()
675
126
        first_preset.swipe_to_delete()
676
127
        first_preset.confirm_removal()
677
128
678
129
        # Check that the timer preset has been deleted
679
130
        self.assertThat(
680
131
            self.main_view.get_num_of_presets,
681
132
            Eventually(Equals(num_of_presets_old - 1)))
682
133
    
683
159
134
684
=== modified file 'timer/PresetList.qml'
685
--- timer/PresetList.qml	2013-10-26 13:48:27 +0000
686
+++ timer/PresetList.qml	2013-11-07 16:34:52 +0000
687
@@ -87,14 +87,7 @@
688
87
            
87
            
689
88
            selected: listTimerPreset.currentIndex == index
88
            selected: listTimerPreset.currentIndex == index
690
89
            removable: true
89
            removable: true
699
90
            
90
            confirmRemoval: true
692
91
            // TODO: Replace SwipeDelete custom component with SDK default component. Ensure that bugs
693
92
            // https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1241506, https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1242089
694
93
            // and https://bugs.launchpad.net/ubuntu-ui-toolkit/+bug/1236464 are fixed beforehand.
695
94
            backgroundIndicator: SwipeDelete {
696
95
                id: swipeDelete
697
96
                state: swipingState
698
97
            }
700
98
            
91
            
701
99
            onItemRemoved: {
92
            onItemRemoved: {
702
100
                presetModel.removePreset(index);
93
                presetModel.removePreset(index);
Reviewer	Review Type	Date Requested	Status
Nicholas Skaggs (community)		2013-10-28	Approve on 2013-11-20
Ubuntu Phone Apps Jenkins Bot	continuous-integration		Approve on 2013-11-20
Ubuntu Clock Developers		2013-10-19	Pending
Review via email: mp+191905@code.launchpad.net