Merge lp:~nik90/ubuntu-clock-app/add-world-qml-tests into lp:ubuntu-clock-app

[Nekhelesh Ramananthan]

Added world clock feature qml tests.

Added world clock feature qml tests.

The QML Test Suite now comprises of Feature, Unit and Integration tests and collectively has a far higher test coverage of the clock app than AP test have. A few more MPs later, I might propose removing AP tests.

[lp:~nik90/ubuntu-clock-app/add-world-qml-tests]

160. By Nekhelesh Ramananthan on 2014-10-14

merged trunk

161. By Nekhelesh Ramananthan on 2014-10-14

Migrated tst_worldClock over to ClockTestCase

162. By Nekhelesh Ramananthan on 2014-10-14

renamed confirmWorldCityAddition() to assertWorldCityAddition()

163. By Nekhelesh Ramananthan on 2014-10-14

Removed unnecessary confirm statement iat the start of a test

164. By Nekhelesh Ramananthan on 2014-10-14

Added TODO comment for mocking the searchOnline function

165. By Nekhelesh Ramananthan on 2014-10-14

Improved if logic in emulators.py

166. By Nekhelesh Ramananthan on 2014-10-14

Simplified code a bit

167. By Nekhelesh Ramananthan on 2014-10-14

Merged prerequisite branch

168. By Nekhelesh Ramananthan on 2014-10-14

Merged prerequisite branch

Unmerged revisions

=== modified file 'app/alarm/AlarmList.qml'
--- app/alarm/AlarmList.qml	2014-10-05 15:33:27 +0000
+++ app/alarm/AlarmList.qml	2014-10-13 20:56:20 +0000
@@ -129,7 +129,7 @@
 
             else {
                 pageStack.push(Qt.resolvedUrl("EditAlarmPage.qml"),
-                               {"isNewAlarm": false, "alarmIndex": index})
+                               {isNewAlarm: false, alarmIndex: index, alarmModel: alarmModel})
             }
         }
 

=== modified file 'app/alarm/EditAlarmPage.qml'
--- app/alarm/EditAlarmPage.qml	2014-10-10 19:58:49 +0000
+++ app/alarm/EditAlarmPage.qml	2014-10-13 20:56:20 +0000
@@ -37,6 +37,9 @@
     // Temporary alarm used to read saved alarm and modify them
     property var tempAlarm
 
+    // Property to store the alarm model
+    property var alarmModel
+
     title: isNewAlarm ? i18n.tr("New alarm") : i18n.tr("Edit alarm")
     visible: false
 

=== modified file 'app/worldclock/WorldCityList.qml'
--- app/worldclock/WorldCityList.qml	2014-10-10 10:55:27 +0000
+++ app/worldclock/WorldCityList.qml	2014-10-13 20:56:20 +0000
@@ -251,7 +251,7 @@
 
         delegate: ListItem.Base {
             showDivider: false
-            objectName: "worldCityItem" + index
+            objectName: "defaultWorldCityItem" + index
 
             Column {
                 id: worldCityDelegateColumn
@@ -265,7 +265,7 @@
 
                 Label {
                     text: city
-                    objectName: "cityNameText"
+                    objectName: "defaultCityNameText"
                     width: parent.width
                     elide: Text.ElideRight
                     color: UbuntuColors.midAubergine
@@ -273,7 +273,7 @@
 
                 Label {
                     text: country
-                    objectName: "countryNameText"
+                    objectName: "defaultCountryNameText"
                     fontSize: "xx-small"
                     width: parent.width
                     elide: Text.ElideRight

=== modified file 'debian/changelog'
--- debian/changelog	2014-10-11 11:46:39 +0000
+++ debian/changelog	2014-10-13 20:56:20 +0000
@@ -12,6 +12,9 @@
   * Synced ListItemWithActions with upstream
   * Delayed loading of AlarmModel to improve app startup time (LP: #1362140)
   * Fixed alarm page header width warning and corrected icon spacing.
+  * Added edit alarm qml tests and added a library helper which contains commonly
+    used test functions to avoid code duplication in future tests.
+  * Added world clock feature qml tests
 
   [Akiva Shammai Avraham]
   * Improved the analog clock performance by updating the clock hands every second

=== modified file 'tests/autopilot/ubuntu_clock_app/emulators.py'
--- tests/autopilot/ubuntu_clock_app/emulators.py	2014-10-10 22:12:50 +0000
+++ tests/autopilot/ubuntu_clock_app/emulators.py	2014-10-13 20:56:20 +0000
@@ -267,14 +267,18 @@
 
         for index in range(int(cityList.count)):
             if cityList.wait_select_single(
-                objectName="worldCityItem{}".format(index)).wait_select_single(
-                    "Label", objectName="cityNameText").text == city_Name:
+                objectName="defaultWorldCityItem{}".format(index)).\
+                wait_select_single(
+                    "Label",
+                    objectName="defaultCityNameText").text == city_Name:
                 if cityList.wait_select_single(
-                    objectName="worldCityItem{}".format(index)).\
-                    wait_select_single("Label", objectName="countryNameText").\
+                    objectName="defaultWorldCityItem{}".format(index)).\
+                    wait_select_single(
+                        "Label",
+                        objectName="defaultCountryNameText").\
                         text == country_Name:
                     cityList.click_element(
-                        "worldCityItem{}".format(index), direction=None)
+                        "defaultWorldCityItem{}".format(index), direction=None)
                     break
 
     @autopilot_logging.log_action(logger.info)

=== modified file 'tests/unit/CMakeLists.txt'
--- tests/unit/CMakeLists.txt	2014-10-05 21:22:25 +0000
+++ tests/unit/CMakeLists.txt	2014-10-13 20:56:20 +0000
@@ -26,6 +26,7 @@
     declare_qml_test("Alarm" tst_alarm.qml)
     declare_qml_test("AlarmSound" tst_alarmSound.qml)
     declare_qml_test("AlarmUtils" tst_alarmUtils.qml)
+    declare_qml_test("WorldClock" tst_worldClock.qml)
 else()
     if (NOT QMLTESTRUNNER_BIN)
         message(WARNING "Qml tests disabled: qmltestrunner not found")
@@ -40,5 +41,13 @@
     tst_alarm.qml
     tst_alarmSound.qml
     tst_alarmUtils.qml
+    tst_worldClock.qml
 )
 add_custom_target(tst_QmlFiles ALL SOURCES ${QML_TST_FILES})
+
+set(QML_TST_UTILS
+    Utils.qml
+    MockClockApp.qml
+)
+
+add_custom_target(tst_Utils ALL SOURCES ${QML_TST_UTILS})

=== added file 'tests/unit/MockClockApp.qml'
--- tests/unit/MockClockApp.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/MockClockApp.qml	2014-10-13 20:56:20 +0000
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This file is part of Ubuntu Clock App
+ *
+ * Ubuntu Clock App is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Ubuntu Clock App is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.3
+import DateTime 1.0
+import U1db 1.0 as U1db
+import Ubuntu.Components 1.1
+import "../../app/clock"
+
+/*
+ This file is meant to create a fake but fully fleshed clock app with its
+ own database and settings. This will avoid messing with the user data while
+ running the tests.
+*/
+
+MainView {
+    id: clockApp
+
+    // Property to store the state of an application (active or suspended)
+    property bool applicationState: Qt.application.active
+
+    width: units.gu(40)
+    height: units.gu(70)
+    useDeprecatedToolbar: false
+    applicationName: "com.ubuntu.fakeclock.test"
+
+    U1db.Database {
+        id: clockDB
+        path: "user-preferences"
+    }
+
+    U1db.Document {
+        id: clockModeDocument
+        create: true
+        database: clockDB
+        docId: "clockModeDocument"
+        defaults: { "digitalMode": false }
+    }
+
+    DateTime {
+        id: localTimeSource
+        updateInterval: 1000
+    }
+
+    PageStack {
+        id: mainStack
+        objectName: "pageStack"
+
+        Component.onCompleted: push(clockPage)
+
+        ClockPage {
+            id: clockPage
+
+            Loader {
+                id: alarmModelLoader
+                asynchronous: false
+            }
+
+            alarmModel: alarmModelLoader.item
+            bottomEdgeEnabled: alarmModelLoader.status === Loader.Ready
+            clockTime: new Date
+                       (
+                           localTimeSource.localDateString.split(":")[0],
+                           localTimeSource.localDateString.split(":")[1]-1,
+                           localTimeSource.localDateString.split(":")[2],
+                           localTimeSource.localTimeString.split(":")[0],
+                           localTimeSource.localTimeString.split(":")[1],
+                           localTimeSource.localTimeString.split(":")[2],
+                           localTimeSource.localTimeString.split(":")[3]
+                       )
+        }
+    }
+}

=== added file 'tests/unit/Utils.qml'
--- tests/unit/Utils.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/Utils.qml	2014-10-13 20:56:20 +0000
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This file is part of Ubuntu Clock App
+ *
+ * Ubuntu Clock App is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Ubuntu Clock App is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtTest 1.0
+import QtQuick 2.3
+import Ubuntu.Test 1.0
+
+/*
+ Utils.qml includes a set of commonly used test functions like pressing header
+ buttons and helps reduce code duplication.
+
+ Usage:
+        Utils {
+            id: testUtils
+        }
+
+        UbuntuTestCase {
+            id: sampleTest
+            name: "SampleTest"
+
+            when: windowShown
+
+            function initTestCase() {
+               header = findChild(mainView, "MainView_Header")
+               backButton = findChild(alarmTest.header, "customBackButton")
+            }
+
+            function test_something() {
+              testUtils._pressHeaderButton(header, "addAlarmAction")
+            }
+       }
+*/
+
+UbuntuTestCase {
+    id: testUtils
+
+    function pressHeaderButton(header, objectName) {
+        var headerButton = findChild(header, objectName + "_header_button")
+        mouseClick(headerButton, centerOf(headerButton).x, centerOf(headerButton).y)
+    }
+
+    function pressButton(objectName) {
+        mouseClick(objectName, centerOf(objectName).x, centerOf(objectName).y)
+    }
+
+    function getPage(pageStack, objectName) {
+        var page = findChild(pageStack, objectName)
+        waitForRendering(page)
+        return page
+    }
+
+    function swipeToDeleteItem(item)
+    {
+        var startX = item.threshold
+        var startY = item.height / 2
+        var endX = item.width
+        var endY = startY
+        mousePress(item, startX, startY)
+        mouseMoveSlowly(item,
+                        startX, startY,
+                        endX - startX, endY - startY,
+                        10, 100)
+        mouseRelease(item, endX, endY)
+        mouseClick(item, startX, startY)
+    }
+
+    function clearTextField(textfield) {
+        // Get textfield focus by clicking once
+        mouseClick(textfield, textfield.width - units.gu(2), centerOf(textfield).y)
+
+        // Click on the clear button shown on the right
+        mouseClick(textfield, textfield.width - units.gu(2), centerOf(textfield).y)
+    }
+}

=== modified file 'tests/unit/tst_alarm.qml'
--- tests/unit/tst_alarm.qml	2014-10-10 21:24:28 +0000
+++ tests/unit/tst_alarm.qml	2014-10-13 20:56:20 +0000
@@ -63,6 +63,10 @@
         id: alarmPage
     }
 
+    Utils {
+        id: utils
+    }
+
     UbuntuTestCase {
         id: alarmTest
         name: "AlarmTest"
@@ -79,31 +83,11 @@
 
         // *************  Helper Functions ************
 
-        function _pressAddAlarmHeaderButton() {
-            var addButton = findChild(header, "addAlarmAction" + "_header_button")
-            mouseClick(addButton, centerOf(addButton).x, centerOf(addButton).y)
-        }
-
-        function _pressSaveAlarmHeaderButton() {
-            var saveButton = findChild(alarmTest.header, "saveAlarmAction" + "_header_button")
-            mouseClick(saveButton, centerOf(saveButton).x, centerOf(saveButton).y)
-        }
-
-        function _pressBackButton() {
-            mouseClick(backButton, centerOf(backButton).x, centerOf(backButton).y)
-        }
-
         function _pressListItem(page, objectName) {
             var listitem = findChild(page, objectName)
             mouseClick(listitem, centerOf(listitem).x, centerOf(listitem).y)
         }
 
-        function _getPage(objectName) {
-            var page = findChild(pageStack, objectName)
-            waitForRendering(page)
-            return page
-        }
-
         function _waitForPickerToStopMoving(picker) {
             waitForRendering(picker);
             tryCompareFunction(function(){return picker.moving}, false);
@@ -112,7 +96,6 @@
         function _setAlarmTime(picker, time) {
             picker.date = time
             _waitForPickerToStopMoving(picker)
-            return picker.date
         }
 
         function _setAlarmRepeatDays(alarmRepeatPage, days) {
@@ -136,8 +119,7 @@
 
         function _setAlarmLabel(alarmLabelPage, label) {
             var alarmLabel = findChild(alarmLabelPage, "labelEntry")
-            mouseClick(alarmLabel, alarmLabel.width - units.gu(2), centerOf(alarmLabel).y)
-            mouseClick(alarmLabel, alarmLabel.width - units.gu(2), centerOf(alarmLabel).y)
+            utils.clearTextField(alarmLabel)
             typeString(label)
         }
 
@@ -173,19 +155,9 @@
             }
         }
 
-        function _swipeToDeleteItem(item)
-        {
-            var startX = item.threshold
-            var startY = item.height / 2
-            var endX = item.width
-            var endY = startY
-            mousePress(item, startX, startY)
-            mouseMoveSlowly(item,
-                            startX, startY,
-                            endX - startX, endY - startY,
-                            10, 100)
-            mouseRelease(item, endX, endY)
-            mouseClick(item, startX, startY)
+        function _confirmListItemValue(page, objectName, expectedValue, message) {
+            var listitem = findChild(page, objectName)
+            compare(listitem.subText, expectedValue, message)
         }
 
         function _deleteAlarm(label, repeat, time, status) {
@@ -196,50 +168,104 @@
             var alarmObject = findChild(alarmsList, "alarm"+index)
 
             if (index !== -1) {
-                _swipeToDeleteItem(alarmObject)
+                utils.swipeToDeleteItem(alarmObject)
             }
 
             tryCompare(alarmsList, "count", oldCount-1, 10000, "Alarm count did not decrease after deleting the alarm")
         }
 
         function _setAlarm(label, repeat, time) {
-            _pressAddAlarmHeaderButton()
+            utils.pressHeaderButton(header, "addAlarmAction")
 
             var addAlarmPage = findChild(pageStack, "AddAlarmPage")
             waitForRendering(addAlarmPage)
 
+            // Set the alarm time
             var alarmTimePicker = findChild(pageStack, "alarmTime")
-            var date = _setAlarmTime(alarmTimePicker, time)
+            _setAlarmTime(alarmTimePicker, time)
 
+            // Set the alarm repeat options
             _pressListItem(addAlarmPage, "alarmRepeat")
-            var alarmRepeatPage = _getPage("alarmRepeatPage")
+            var alarmRepeatPage = utils.getPage(pageStack, "alarmRepeatPage")
             _setAlarmRepeatDays(alarmRepeatPage, repeat)
-            _pressBackButton()
+            utils.pressButton(backButton)
 
             waitForRendering(addAlarmPage)
 
+            // Set the alarm label
             _pressListItem(addAlarmPage, "alarmLabel")
-            var alarmLabelPage = _getPage("alarmLabelPage")
+            var alarmLabelPage = utils.getPage(pageStack, "alarmLabelPage")
             _setAlarmLabel(alarmLabelPage, label)
-            _pressBackButton()
-
-            waitForRendering(addAlarmPage)
-
-            _pressListItem(addAlarmPage, "alarmSound")
-            var alarmSoundPage = _getPage("alarmSoundPage")
-            _setAlarmSound(alarmSoundPage)
-            _pressBackButton()
-
-            waitForRendering(addAlarmPage)
-
-            _pressSaveAlarmHeaderButton()
+            utils.pressButton(backButton)
+
+            waitForRendering(addAlarmPage)
+
+            // Set the alarm sound
+            _pressListItem(addAlarmPage, "alarmSound")
+            var alarmSoundPage = utils.getPage(pageStack, "alarmSoundPage")
+            _setAlarmSound(alarmSoundPage)
+            utils.pressButton(backButton)
+
+            waitForRendering(addAlarmPage)
+
+            utils.pressHeaderButton(header, "saveAlarmAction")
+
+            waitForRendering(alarmPage)
+        }
+
+        function _editAlarm(oldlabel, oldrepeat, oldtime, status, newlabel, newrepeat, newtime) {
+            // Find the index of the alarm which needs to be edited
+            var alarmIndex = findAlarm(oldlabel, oldrepeat, oldtime, status)
+
+            if (alarmIndex === -1) {
+                fail("Cannot find saved alarm to edit")
+            }
+
+            // Press the alarm to be edited
+            var alarmsList = findChild(alarmPage, "alarmListView")
+            var alarmObject = findChild(alarmsList, "alarm"+alarmIndex)
+            mouseClick(alarmObject, centerOf(alarmObject).x, centerOf(alarmObject).y)
+
+            // Proceed to verify the alarm read is correct and then set new values
+            var addAlarmPage = findChild(pageStack, "AddAlarmPage")
+            waitForRendering(addAlarmPage)
+
+            var alarmTimePicker = findChild(pageStack, "alarmTime")
+            compare(Qt.formatTime(alarmTimePicker.date), oldtime, "Time read from the saved alarm is incorrect")
+            _setAlarmTime(alarmTimePicker, newtime)
+
+            _confirmListItemValue(addAlarmPage, "alarmRepeat", oldrepeat, "Alarm repeat options read from the saved alarm is incorrect")
+            _pressListItem(addAlarmPage, "alarmRepeat")
+            var alarmRepeatPage = utils.getPage(pageStack, "alarmRepeatPage")
+            _setAlarmRepeatDays(alarmRepeatPage, newrepeat)
+            utils.pressButton(backButton)
+
+            waitForRendering(addAlarmPage)
+
+            _confirmListItemValue(addAlarmPage, "alarmLabel", oldlabel, "Alarm name read from the saved alarm is incorrect")
+            _pressListItem(addAlarmPage, "alarmLabel")
+            var alarmLabelPage = utils.getPage(pageStack, "alarmLabelPage")
+            _setAlarmLabel(alarmLabelPage, newlabel)
+            utils.pressButton(backButton)
+
+            waitForRendering(addAlarmPage)
+
+            _confirmListItemValue(addAlarmPage, "alarmSound", "Celestial", "Alarm sound read from the saved alarm is incorrect")
+            _pressListItem(addAlarmPage, "alarmSound")
+            var alarmSoundPage = utils.getPage(pageStack, "alarmSoundPage")
+            _setAlarmSound(alarmSoundPage)
+            utils.pressButton(backButton)
+
+            waitForRendering(addAlarmPage)
+
+            utils.pressHeaderButton(header, "saveAlarmAction")
 
             waitForRendering(alarmPage)
         }
 
         // *************  Test Functions ************
 
-        function test_createAlarm_data() {
+        function test_01_createAlarm_data() {
             return [
                         {tag: "Weekday Alarms",   name: "Weekday Alarm",    repeat: [0,1,2,3,4], repeatLabel: "Weekdays"},
                         {tag: "Weekend Alarms",   name: "Weekend Alarm",    repeat: [5,6],       repeatLabel: "Weekends"},
@@ -248,7 +274,7 @@
         }
 
         // Test to check if creating an alarm works as expected
-        function test_createAlarm(data) {
+        function test_01_createAlarm(data) {
             var date = new Date()
             date.setHours((date.getHours() + 10) % 24)
             date.setMinutes((date.getMinutes() + 40) % 60)
@@ -263,5 +289,37 @@
             */
             _deleteAlarm(data.name, data.repeatLabel, Qt.formatTime(date), true)
         }
+
+        // Test to check if editing an alarm and saving it works as expected
+        function test_02_editAlarm() {
+            var date = new Date()
+            date.setHours((date.getHours() + 10) % 24)
+            date.setMinutes((date.getMinutes() + 40) % 60)
+            date.setSeconds(0)
+
+            _setAlarm("Test Edit Alarm", [0,1,2,3,4], date)
+
+            var newDate = new Date()
+            newDate.setHours((newDate.getHours() + 5) % 24)
+            newDate.setMinutes((newDate.getMinutes() + 15) % 60)
+            newDate.setSeconds(0)
+
+            _editAlarm("Test Edit Alarm", "Weekdays", Qt.formatTime(date), true, "Alarm Edited", [5,6], newDate)
+
+            /*
+             #NOTE: This wait is required since as per the design after an alarm is edited and saved
+             it shows the remaining time to that alarm and then after 5 secs shows the alarm
+             frequency. Hence we need to wait for 5 seconds before confirming alarm creation.
+            */
+            wait(6000)
+
+            _confirmAlarmCreation("Alarm Edited", "Weekends", Qt.formatTime(newDate), true)
+
+            /*
+             #FIXME: This won't be required once we mock up alarm data. Until
+             then we need to delete alarms to cleanup after the tests.
+            */
+            _deleteAlarm("Alarm Edited", "Weekends", Qt.formatTime(newDate), true)
+        }
     }
 }

=== modified file 'tests/unit/tst_alarmLabel.qml'
--- tests/unit/tst_alarmLabel.qml	2014-09-25 11:14:24 +0000
+++ tests/unit/tst_alarmLabel.qml	2014-10-13 20:56:20 +0000
@@ -38,6 +38,10 @@
         alarm: _alarm
     }
 
+    Utils {
+        id: utils
+    }
+
     UbuntuTestCase {
         id: alarmLabelPageTest
         name: "AlarmLabelPage"
@@ -55,14 +59,6 @@
             backButton = findChild(header, "customBackButton")
         }
 
-        function clearTextField(textfield) {
-            // Get textfield focus by clicking once
-            mouseClick(textfield, textfield.width - units.gu(2), textfield.height/2)
-
-            // Click on the clear button shown on the right
-            mouseClick(textfield, textfield.width - units.gu(2), textfield.height/2)
-        }
-
         /*
          Test to check if the alarm label has focus true by default to ensure
          that the OSK is shown when the opens the alarm label page.
@@ -87,7 +83,7 @@
             compare(alarmLabel.text, "Alarm", "Default alarm label is not Alarm")
             compare(backButton.enabled, true, "Back header button is not enabled by default")
 
-            clearTextField(alarmLabel)
+            utils.clearTextField(alarmLabel)
             typeString(data.string)
 
             compare(alarmLabel.text, data.string, "Alarm label is not what was type in the textfield")

=== added file 'tests/unit/tst_worldClock.qml'
--- tests/unit/tst_worldClock.qml	1970-01-01 00:00:00 +0000
+++ tests/unit/tst_worldClock.qml	2014-10-13 20:56:20 +0000
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This file is part of Ubuntu Clock App
+ *
+ * Ubuntu Clock App is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * Ubuntu Clock App is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import QtTest 1.0
+import Ubuntu.Test 1.0
+import Ubuntu.Components 1.1
+
+MockClockApp {
+    id: clockApp
+
+    Utils {
+        id: utils
+    }
+
+    UbuntuTestCase {
+        id: worldClockFeatureTest
+        name: "WorldClockFeatureTest"
+
+        when: windowShown
+
+        property var header
+        property var backButton
+        property var clockPage
+        property var pageStack
+
+        function initTestCase() {
+            header = findChild(clockApp, "MainView_Header")
+            backButton = findChild(header, "customBackButton")
+            pageStack = findChild(clockApp, "pageStack")
+            clockPage = findChild(clockApp, "clockPage")
+        }
+
+        // *********** Helper Functions ************
+
+        function _pressAddWorldCityButton() {
+            var addWorldCityButton = findChild(clockApp, "addWorldCityButton")
+            utils.pressButton(addWorldCityButton)
+        }
+
+        function _findWorldCity(cityList, type, cityName, countryName) {
+            /*
+             The list view for the user world city list and the available world
+             city list have the same structure with some minor object name
+             changes. The 'objectPrefix' varible is used to handle that.
+            */
+            var objectPrefix = type === "user" ? "user" : "default"
+
+            for(var i=0; i<cityList.count; i++) {
+                var cityListItem = findChild(clockApp, objectPrefix+"WorldCityItem"+i)
+                var city = findChild(cityListItem, objectPrefix+"CityNameText")
+                var country = findChild(cityListItem, objectPrefix+"CountryNameText")
+
+                if (city.text === cityName && country.text === countryName) {
+                    return i
+                }
+            }
+
+            return -1;
+        }
+
+        function _confirmWorldCityAddition(cityName, countryName) {
+            var cityList = findChild(clockApp, "userWorldCityRepeater")
+
+            /*
+             Confirm that at least one world city is saved before proceeding
+             to check if that's the city added during the test.
+            */
+            tryCompareFunction(function() { return cityList.count > 0}, true)
+
+            var cityIndex = _findWorldCity(cityList, "user", cityName, countryName)
+
+            if (cityIndex === -1) {
+                // If city couldn't be found in the saved city list, fail the test
+                fail("City added during the test cannot be found in the user world city list!")
+            }
+        }
+
+        function _deleteWorldCity(cityName, countryName) {
+            var cityList = findChild(clockApp, "userWorldCityRepeater")
+
+            /*
+             Confirm that at least one world city is saved before proceeding
+             to delete the city added during the test.
+            */
+            tryCompareFunction(function() { return cityList.count > 0}, true)
+
+            var oldCount = cityList.count
+            var cityIndex = _findWorldCity(cityList, "user", cityName, countryName)
+
+            if (cityIndex === -1) {
+                fail("City added during the test cannot be found in the user world city list!")
+            }
+            else {
+                var cityListItem = findChild(clockApp, "userWorldCityItem"+cityIndex)
+                utils.swipeToDeleteItem(cityListItem)
+            }
+
+            /*
+             #FIXME: Commented out the following line as deleting a world city
+             when there is only one world city does not decrease the count to 0
+             but leaves it as 1 causing the test to fail. This has been reported
+             in bug #1368393. (Also fails in Autopilot)
+
+             tryCompare(cityList, "count", oldCount-1, 5000, "city list count did not decrease")
+
+             The wait() call below is to ensure that the world city is deleted properly
+             which wouldn't be required if could do the count decrease check mentioned above.
+            */
+
+            wait(1000)
+        }
+
+        function _addCityFromList(cityName, countryName) {
+            var worldCityPage = utils.getPage(pageStack, "worldCityList")
+            var cityList = findChild(worldCityPage, "cityList")
+
+            // Wait for the list to be populated with results
+            tryCompareFunction(function() { return cityList.count > 0}, true)
+
+            var cityIndex = _findWorldCity(cityList, "default", cityName, countryName)
+
+            if (cityIndex === -1) {
+                fail("City cannot be found in the local world city list")
+            }
+
+            var cityListItem = findChild(cityList, "defaultWorldCityItem"+cityIndex)
+            mouseClick(cityListItem, centerOf(cityListItem).x, centerOf(cityListItem).y)
+        }
+
+        function _addCityBySearchingOnline(cityName, countryName) {
+            utils.pressHeaderButton(header, "searchButton")
+            var searchField = findChild(clockApp, "searchField")
+            tryCompare(searchField, "visible", true, 5000, "Search field is not visible")
+            typeString(cityName)
+            _addCityFromList(cityName, countryName)
+        }
+
+        // *********** Test Functions *************
+
+        /*
+         Test to check if a city found in the world city list can be added
+         to the user world city list.
+        */
+        function test_addCityAlreadyPresentInWorldCityList() {
+            var clockPage = utils.getPage(pageStack, "clockPage")
+
+            _pressAddWorldCityButton()
+
+            var worldCityPage = utils.getPage(pageStack, "worldCityList")
+            waitForRendering(worldCityPage)
+
+            _addCityFromList("Amsterdam", "Netherlands")
+            _confirmWorldCityAddition("Amsterdam", "Netherlands")
+
+            // Clean up after the test by deleting the city which was added during the test
+            _deleteWorldCity("Amsterdam", "Netherlands")
+        }
+
+        /*
+         Test to check if a city now found in the world city list can be added
+         by searcing it online and then adding it from the results returned.
+        */
+        function test_addCityBySearchingOnline() {
+            var clockPage = utils.getPage(pageStack, "clockPage")
+
+            _pressAddWorldCityButton()
+
+            var worldCityPage = utils.getPage(pageStack, "worldCityList")
+            waitForRendering(worldCityPage)
+
+            _addCityBySearchingOnline("Venice", "Provincia di Venezia, Veneto, Italy")
+            _confirmWorldCityAddition("Venice", " Veneto, Italy")
+
+            // Clean up after the test by deleting the city which was added during the test
+            _deleteWorldCity("Venice", " Veneto, Italy")
+        }
+    }
+}