1
=== modified file 'plugins/about/License.qml'
2
--- plugins/about/License.qml	2014-03-04 12:45:06 +0000
3
+++ plugins/about/License.qml	2014-04-08 12:01:45 +0000
4
@@ -8,7 +8,6 @@
5
8
    property string binary;
8
    property string binary;
6
9
9
7
10
    id: licensesPage
10
    id: licensesPage
8
11
    objectName: "licensesPage"
9
12
    title: binary
11
    title: binary
10
13
    flickable: scrollWidget
12
    flickable: scrollWidget
11
14
13
12
15
14
13
=== modified file 'plugins/about/Software.qml'
14
--- plugins/about/Software.qml	2013-07-29 14:08:10 +0000
15
+++ plugins/about/Software.qml	2014-04-08 12:01:45 +0000
16
@@ -7,6 +7,7 @@
17
7
7
18
8
ItemPage {
8
ItemPage {
19
9
    id: licensesPage
9
    id: licensesPage
20
10
    objectName: "licensesPage"
21
10
    title: i18n.tr("Software licenses")
11
    title: i18n.tr("Software licenses")
22
11
    flickable: softwareList
12
    flickable: softwareList
23
12
13
24
13
14
25
=== modified file 'tests/autopilot/ubuntu_system_settings/tests/__init__.py'
26
--- tests/autopilot/ubuntu_system_settings/tests/__init__.py	2014-03-31 15:42:50 +0000
27
+++ tests/autopilot/ubuntu_system_settings/tests/__init__.py	2014-04-08 12:01:45 +0000
28
@@ -9,7 +9,6 @@
29
9
9
30
10
from __future__ import absolute_import
10
from __future__ import absolute_import
31
11
11
32
12
from ubuntu_system_settings.utils.i18n import ugettext as _
33
13
from ubuntu_system_settings import helpers
12
from ubuntu_system_settings import helpers
34
14
13
35
15
from autopilot.input import Mouse, Touch, Pointer
14
from autopilot.input import Mouse, Touch, Pointer
36
@@ -163,6 +162,7 @@
37
163
    def setUp(self):
162
    def setUp(self):
38
164
        """ Go to About page """
163
        """ Go to About page """
39
165
        super(AboutBaseTestCase, self).setUp('about')
164
        super(AboutBaseTestCase, self).setUp('about')
40
165
        self.assertThat(self.about_page.active, Eventually(Equals(True)))
41
166
166
42
167
    @property
167
    @property
43
168
    def about_page(self):
168
    def about_page(self):
44
@@ -177,10 +177,13 @@
45
177
        """ Go to Storage Page """
177
        """ Go to Storage Page """
46
178
        super(StorageBaseTestCase, self).setUp()
178
        super(StorageBaseTestCase, self).setUp()
47
179
        # Click on 'Storage' option
179
        # Click on 'Storage' option
50
180
        button = self.about_page.select_single(objectName='storageItem')
180
        button = self.about_page.select_single(
51
181
        self.assertThat(button, NotEquals(None))
181
            'Standard', objectName='storageItem'
52
182
        )
53
182
        self.scroll_to_and_click(button)
183
        self.scroll_to_and_click(button)
54
183
184
55
185
        self.assertThat(self.storage_page.active, Eventually(Equals(True)))
56
186
57
184
    def assert_space_item(self, object_name, text):
187
    def assert_space_item(self, object_name, text):
58
185
        """ Checks whether an space item exists and returns a value """
188
        """ Checks whether an space item exists and returns a value """
59
186
        item = self.storage_page.select_single(objectName=object_name)
189
        item = self.storage_page.select_single(objectName=object_name)
60
@@ -193,10 +196,17 @@
61
193
        values = size_label.text.split(' ')  # Format: "00.0 (bytes|MB|GB)"
196
        values = size_label.text.split(' ')  # Format: "00.0 (bytes|MB|GB)"
62
194
        self.assertThat(len(values), GreaterThan(1))
197
        self.assertThat(len(values), GreaterThan(1))
63
195
198
64
199
    def get_storage_space_used_by_category(self, objectName):
65
200
        return self.main_view.wait_select_single(
66
201
            'StorageItem', objectName=objectName
67
202
            ).value
68
203
69
196
    @property
204
    @property
70
197
    def storage_page(self):
205
    def storage_page(self):
71
198
        """ Return 'Storage' page """
206
        """ Return 'Storage' page """
73
199
        return self.main_view.select_single(objectName='storagePage')
207
        return self.main_view.select_single(
74
208
            'Storage', objectName='storagePage'
75
209
        )
76
200
210
77
201
211
78
202
class LicenseBaseTestCase(AboutBaseTestCase):
212
class LicenseBaseTestCase(AboutBaseTestCase):
79
@@ -206,15 +216,17 @@
80
206
        """ Go to License Page """
216
        """ Go to License Page """
81
207
        super(LicenseBaseTestCase, self).setUp()
217
        super(LicenseBaseTestCase, self).setUp()
82
208
        # Click on 'Software licenses' option
218
        # Click on 'Software licenses' option
86
209
        button = self.main_view.select_single(objectName='licenseItem')
219
        button = self.main_view.select_single(
87
210
        self.assertThat(button, NotEquals(None))
220
            'Standard', objectName='licenseItem'
88
211
        self.assertThat(button.text, Equals(_('Software licenses')))
221
        )
89
212
        self.scroll_to_and_click(button)
222
        self.scroll_to_and_click(button)
90
213
223
91
214
    @property
224
    @property
92
215
    def licenses_page(self):
225
    def licenses_page(self):
93
216
        """ Return 'License' page """
226
        """ Return 'License' page """
95
217
        return self.main_view.select_single(objectName='licensesPage')
227
        return self.main_view.wait_select_single(
96
228
            'ItemPage', objectName='licensesPage'
97
229
        )
98
218
230
99
219
231
100
220
class SystemUpdatesBaseTestCase(UbuntuSystemSettingsTestCase):
232
class SystemUpdatesBaseTestCase(UbuntuSystemSettingsTestCase):
101
221
233
102
=== modified file 'tests/autopilot/ubuntu_system_settings/tests/test_about.py'
103
--- tests/autopilot/ubuntu_system_settings/tests/test_about.py	2014-04-02 09:06:34 +0000
104
+++ tests/autopilot/ubuntu_system_settings/tests/test_about.py	2014-04-08 12:01:45 +0000
105
@@ -5,11 +5,15 @@
106
5
# under the terms of the GNU General Public License version 3, as published
5
# under the terms of the GNU General Public License version 3, as published
107
6
# by the Free Software Foundation.
6
# by the Free Software Foundation.
108
7
7
114
8
from time import sleep
8
import os
115
9
9
import subprocess
116
10
from autopilot.platform import model
10
import unittest
117
11
from testtools.matchers import Equals, NotEquals, GreaterThan
11
118
12
from unittest import expectedFailure
12
from gi.repository import GLib
119
13
120
14
from autopilot.matchers import Eventually
121
15
from testtools import skipIf
122
16
from testtools.matchers import Equals, NotEquals
123
13
17
124
14
from ubuntu_system_settings.tests import (
18
from ubuntu_system_settings.tests import (
125
15
    AboutBaseTestCase,
19
    AboutBaseTestCase,
126
@@ -18,97 +22,148 @@
127
18
)
22
)
128
19
from ubuntu_system_settings.utils.i18n import ugettext as _
23
from ubuntu_system_settings.utils.i18n import ugettext as _
129
20
24
130
25
import dbus
131
26
132
21
27
133
22
class AboutTestCase(AboutBaseTestCase):
28
class AboutTestCase(AboutBaseTestCase):
134
23
    """ Tests for About this phone Page """
29
    """ Tests for About this phone Page """
135
24
30
146
25
    def test_about_page(self):
31
    def _get_imei_from_dbus(self):
147
26
        """ Checks whether About page is available """
32
        bus = dbus.SystemBus()
148
27
        self.assertThat(self.about_page, NotEquals(None))
33
        try:
149
28
        self.assertThat(self.about_page.title, Equals(_('About this phone')))
34
            manager = dbus.Interface(
150
29
35
                bus.get_object('org.ofono', '/'), 'org.ofono.Manager'
151
30
    def test_device(self):
36
            )
152
31
        """ Checks whether Device info is shown """
37
        except dbus.exceptions.DBusException:
153
32
        device_label = self.about_page.select_single(objectName='deviceLabel')
38
            # oFono interface not found, probably its a desktop.
154
33
        self.assertThat(device_label, NotEquals(None))
39
            return None
155
34
        self.assertThat(device_label.text, NotEquals(''))
40
156
41
        modems = manager.GetModems()
157
42
        for path, properties in modems:
158
43
            return properties['Serial']
159
44
160
45
    def _get_os_name(self):
161
46
        os_id = subprocess.check_output(['lsb_release', '-is'])
162
47
        os_release = subprocess.check_output(['lsb_release', '-rs'])
163
48
164
49
        return '{} {}'.format(os_id.strip(), os_release.strip())
165
50
166
51
    def _get_device_serial_number(self):
167
52
        try:
168
53
            return subprocess.check_output(['getprop', 'ro.serialno']).strip()
169
54
        except OSError:
170
55
            # getprop is only available on android hardware.
171
56
            return None
172
57
173
58
    def _get_device_manufacturer_and_model(self):
174
59
        manufacturer = subprocess.check_output(
175
60
            ['getprop', 'ro.product.manufacturer']
176
61
            ).strip()
177
62
        hw_model = subprocess.check_output(
178
63
            ['getprop', 'ro.product.model']
179
64
            ).strip()
180
65
181
66
        return '{} {}'.format(manufacturer, hw_model)
182
67
183
68
    def _get_system_image_iface(self):
184
69
        bus = dbus.SystemBus()
185
70
        service = bus.get_object('com.canonical.SystemImage', '/Service')
186
71
        iface = dbus.Interface(service, 'com.canonical.SystemImage')
187
72
        return iface.Info()
188
73
189
74
    def _get_last_updated_date(self):
190
75
        info = self._get_system_image_iface()[3]
191
76
192
77
        if info == 'Unknown':
193
78
            return _('Never')
194
79
        else:
195
80
            return str(info.split()[0])
196
35
81
197
36
    def test_serial(self):
82
    def test_serial(self):
199
37
        """ Checks whether Serial info is available """
83
        """Checks whether the UI is showing the correct serial number."""
200
38
        item = self.about_page.select_single(objectName='serialItem')
84
        item = self.about_page.select_single(objectName='serialItem')
226
39
        if (model() == 'Desktop'):
85
        serial = self._get_device_serial_number()
227
40
            self.assertThat(item.visible, Equals(False))
86
228
41
        else:
87
        if not serial:
229
42
            self.assertThat(item.visible, Equals(True))
88
            self.assertThat(item.visible, Equals(False))
230
43
            self.assertThat(item.text, Equals(_('Serial')))
89
        else:
231
44
            self.assertThat(item.value, NotEquals(_('N/A')))
90
            self.assertThat(
232
45
91
                item.value, Equals(self._get_device_serial_number())
233
46
    def test_imei(self):
92
            )
234
47
        """ Checks whether IMEI info is available """
93
235
48
        item = self.about_page.select_single(objectName='imeiItem')
94
    def test_imei_information_is_correct(self):
236
49
        if (model() == 'Desktop'):
95
        """Checks whether the UI is exposing the right IMEI."""
237
50
            self.assertThat(item.visible, Equals(False))
96
        imei_item = self.about_page.wait_select_single(
238
51
        else:
97
            objectName='imeiItem')
239
52
            self.assertThat(item.visible, Equals(True))
98
        imei_ofono = self._get_imei_from_dbus()
240
53
            self.assertThat(item.text, Equals(_('IMEI')))
99
241
54
            self.assertThat(item.value, NotEquals(_('N/A')))
100
        if not imei_ofono:
242
55
101
            self.assertThat(imei_item.visible, Equals(False))
243
56
    def test_software(self):
102
        else:
244
57
        """ Checks whether Software info is available """
103
            self.assertEquals(imei_item.value, imei_ofono)
245
58
        item = self.about_page.select_single(objectName='softwareItem')
104
246
59
        self.assertThat(item, NotEquals(None))
105
    def test_settings_show_correct_version_of_the_os(self):
247
60
        self.assertThat(item.text, Equals(_('Software:')))
106
        """Ensure the UI is showing the correct version of the OS."""
223
61
224
62
    def test_os(self):
225
63
        """ Checks whether OS info is available """
248
64
        item = self.about_page.select_single(objectName='osItem')
107
        item = self.about_page.select_single(objectName='osItem')
257
65
        self.assertThat(item, NotEquals(None))
108
        # TODO: find a way to check the image build number as well
258
66
        self.assertThat(item.text, Equals(_('OS')))
109
        # -- om26er 10-03-2014
259
67
        info = item.value.split()
110
        self.assertTrue(self._get_os_name() in item.value)
260
68
        self.assertThat(len(info), GreaterThan(1))
111
261
69
        self.assertThat(info[0], Equals(_('Ubuntu')))
112
    @skipIf(subprocess.call(
262
70
        self.assertThat(info[1], NotEquals(''))
113
        ['which', 'getprop'], stdout=subprocess.PIPE) != 0,
263
71
        if (len(info) > 2):
114
        'program "getprop" not found'
264
72
            self.assertThat(info[2], NotEquals(''))
115
    )
265
116
    def test_hardware_name(self):
266
117
        """Ensure the UI is showing the correct device name."""
267
118
        device_label = self.about_page.select_single(
268
119
            objectName='deviceLabel'
269
120
            ).text
270
121
        device_name_from_getprop = self._get_device_manufacturer_and_model()
271
122
272
123
        self.assertEquals(device_label, device_name_from_getprop)
273
73
124
274
74
    def test_last_updated(self):
125
    def test_last_updated(self):
297
75
        """ Checks whether Last Updated info is available """
126
        """Checks whether Last Updated info is correct."""
298
76
        item = self.about_page.select_single(objectName='lastUpdatedItem')
127
        last_updated = self.about_page.select_single(
299
77
        self.assertThat(item, NotEquals(None))
128
            objectName='lastUpdatedItem'
300
78
        self.assertThat(item.text, Equals(_('Last updated')))
129
            ).value
301
79
        date = item.value.split('-')
130
302
80
        if (len(date) == 1):
131
        self.assertEquals(last_updated, self._get_last_updated_date())
281
81
            self.assertThat(item.value, Equals(_('Never')))
282
82
        else:
283
83
            # 2013-10-19
284
84
            self.assertThat(len(item.value), Equals(10))
285
85
286
86
    def test_legal(self):
287
87
        """ Checks whether Legal info is available """
288
88
        item = self.about_page.select_single(objectName='legalItem')
289
89
        self.assertThat(item, NotEquals(None))
290
90
        self.assertThat(item.text, Equals(_('Legal:')))
291
91
292
92
    def test_update(self):
293
93
        """ Checks whether Update button is available """
294
94
        button = self.about_page.select_single(objectName='updateButton')
295
95
        self.assertThat(button, NotEquals(None))
296
96
        self.assertThat(button.text, Equals(_('Check for updates')))
303
97
132
304
98
133
305
99
class StorageTestCase(StorageBaseTestCase):
134
class StorageTestCase(StorageBaseTestCase):
306
100
    """ Tests for Storage """
135
    """ Tests for Storage """
307
101
136
311
102
    def test_storage_page(self):
137
    def _get_space_by_directory(self, dir_name):
312
103
        """ Check whether Storage page is available """
138
        if dir_name == 'Music':
313
104
        self.assertThat(self.storage_page, NotEquals(None))
139
            location = GLib.get_user_special_dir(
314
140
                GLib.UserDirectory.DIRECTORY_MUSIC
315
141
            )
316
142
        elif dir_name == 'Videos':
317
143
            location = GLib.get_user_special_dir(
318
144
                GLib.UserDirectory.DIRECTORY_VIDEOS
319
145
            )
320
146
        elif dir_name == 'Pictures':
321
147
            location = GLib.get_user_special_dir(
322
148
                GLib.UserDirectory.DIRECTORY_PICTURES
323
149
            )
324
150
        else:
325
151
            raise ValueError(
326
152
                '{} directory not handled by this fuction, you need to enhance'
327
153
                ' this function to handle that directory.'.format(dir_name)
328
154
            )
329
155
330
156
        if not os.path.exists(location):
331
157
            self.skipTest('glib directory {} does not exist'.format(dir_name))
332
158
333
159
        output = subprocess.check_output(['du', '--block-size=1', location])
334
160
        disk_space = output.split()[len(output.split()) - 2]
335
161
        return disk_space
336
105
162
337
106
    def test_disk(self):
163
    def test_disk(self):
338
107
        """ Checks whether disk item is available """
164
        """ Checks whether disk item is available """
343
108
        sleep(5)
165
        disk_item = self.storage_page.wait_select_single(objectName='diskItem')
344
109
        disk_item = self.storage_page.select_single(objectName='diskItem')
166
        self.assertThat(disk_item.text, Equals('Total storage'))
341
110
        self.assertThat(disk_item, NotEquals(None))
342
111
        self.assertThat(disk_item.text, Equals(_('Total storage')))
345
112
167
346
113
    def test_space(self):
168
    def test_space(self):
347
114
        """ Checks whether storage item is available """
169
        """ Checks whether storage item is available """
348
@@ -118,17 +173,49 @@
349
118
        """ Checks storage item """
173
        """ Checks storage item """
350
119
        self.assert_space_item('usedByUbuntuItem', _('Used by Ubuntu'))
174
        self.assert_space_item('usedByUbuntuItem', _('Used by Ubuntu'))
351
120
175
363
121
    def test_space_movies(self):
176
    @unittest.skip(
364
122
        """ Checks whether space item is available """
177
        'Disk calculation can take a while depending on different factors '
365
123
        self.assert_space_item('moviesItem', _('Videos'))
178
        'we dont want to wait for it to calculate.'
366
124
179
    )
367
125
    def test_space_audio(self):
180
    def test_space_used_by_movies(self):
368
126
        """ Checks whether space item is available """
181
        """ Checks whether space shown to be used by movies is
369
127
        self.assert_space_item('audioItem', _('Audio'))
182
        correct. """
370
128
183
        movie_space = self._get_space_by_directory('Videos')
371
129
    def test_space_pictures(self):
184
        movie_space_in_ui = self.get_storage_space_used_by_category(
372
130
        """ Checks whether space item is available """
185
            'moviesItem'
373
131
        self.assert_space_item('picturesItem', _('Pictures'))
186
        )
374
187
375
188
        self.assertThat(movie_space_in_ui, Eventually(Equals(movie_space)))
376
189
377
190
    @unittest.skip(
378
191
        'Disk calculation can take a while depending on different factors '
379
192
        'we dont want to wait for it to calculate.'
380
193
    )
381
194
    def test_space_used_by_music(self):
382
195
        """ Checks whether space shown to be used by music is
383
196
        correct. """
384
197
        music_space = self._get_space_by_directory('Music')
385
198
        music_space_in_ui = self.get_storage_space_used_by_category(
386
199
            'audioItem'
387
200
        )
388
201
389
202
        self.assertThat(music_space_in_ui, Eventually(Equals(music_space)))
390
203
391
204
    @unittest.skip(
392
205
        'Disk calculation can take a while depending on different factors '
393
206
        'we dont want to wait for it to calculate.'
394
207
    )
395
208
    def test_space_used_by_pictures(self):
396
209
        """ Checks whether space shown to be used by pictures is
397
210
        correct. """
398
211
        pictures_space = self._get_space_by_directory('Pictures')
399
212
        pictures_space_in_ui = self.get_storage_space_used_by_category(
400
213
            'picturesItem'
401
214
        )
402
215
403
216
        self.assertThat(
404
217
            pictures_space_in_ui, Eventually(Equals(pictures_space))
405
218
        )
406
132
219
407
133
    def test_space_other_files(self):
220
    def test_space_other_files(self):
408
134
        """ Checks whether space item is available """
221
        """ Checks whether space item is available """
409
@@ -149,7 +236,6 @@
410
149
class LicenseTestCase(LicenseBaseTestCase):
236
class LicenseTestCase(LicenseBaseTestCase):
411
150
    """ Tests for Licenses """
237
    """ Tests for Licenses """
412
151
238
413
152
    @expectedFailure
414
153
    def test_licenses_page(self):
239
    def test_licenses_page(self):
415
154
        """ Check whether Storage page is available """
240
        """ Check whether Storage page is available """
417
155
        self.assertThat(self.licenses_page, NotEquals(None))
241
        self.assertThat(self.licenses_page.active, Eventually(Equals(True)))
418
156
242
419
=== modified file 'tests/autopilot/ubuntu_system_settings/tests/test_search.py'
420
--- tests/autopilot/ubuntu_system_settings/tests/test_search.py	2014-03-10 11:24:08 +0000
421
+++ tests/autopilot/ubuntu_system_settings/tests/test_search.py	2014-04-08 12:01:45 +0000
422
@@ -6,7 +6,8 @@
423
6
# by the Free Software Foundation.
6
# by the Free Software Foundation.
424
7
7
425
8
from autopilot.introspection.dbus import StateNotFoundError
8
from autopilot.introspection.dbus import StateNotFoundError
427
9
from testtools.matchers import Equals, NotEquals
9
from testtools.matchers import Equals
428
10
from autopilot.matchers import Eventually
429
10
11
430
11
from ubuntu_system_settings.tests import UbuntuSystemSettingsTestCase
12
from ubuntu_system_settings.tests import UbuntuSystemSettingsTestCase
431
12
from ubuntu_system_settings.utils.i18n import ugettext as _
13
from ubuntu_system_settings.utils.i18n import ugettext as _
432
@@ -21,22 +22,25 @@
433
21
    def setUp(self):
22
    def setUp(self):
434
22
        super(SearchTestCases, self).setUp()
23
        super(SearchTestCases, self).setUp()
435
23
24
437
24
    def test_search(self):
25
    def _get_entry_component(self, name):
438
26
        return self.main_view.wait_select_single(
439
27
            objectName='entryComponent-' + name
440
28
        )
441
29
442
30
    def _type_into_search_box(self, text):
443
31
        search_box = self.main_view.select_single(
444
32
            objectName='searchTextField'
445
33
        )
446
34
        self.scroll_to_and_click(search_box)
447
35
        self.keyboard.type(_(text))
448
36
        self.assertThat(search_box.text, Eventually(Equals(text)))
449
37
450
38
    def test_search_filter_results(self):
451
25
        """ Checks whether Search box actually filters the results """
39
        """ Checks whether Search box actually filters the results """
469
26
        # Select search text field
40
        self._type_into_search_box('Sound')
470
27
        search = self.main_view.select_single(objectName='searchTextField')
41
        sound_icon = self._get_entry_component('sound')
471
28
        self.assertThat(search, NotEquals(None))
42
472
29
        # Move to text field
43
        self.assertThat(sound_icon.visible, Eventually(Equals(True)))
473
30
        self.scroll_to_and_click(search)
44
        self.assertRaises(
474
31
        # Filter by string
45
            StateNotFoundError, self._get_entry_component, 'background'
475
32
        self.keyboard.type(_('Sound'))
46
        )
459
33
        # Search component
460
34
        sound = self.main_view.select_single(objectName='entryComponent-sound')
461
35
        self.assertThat(sound, NotEquals(None))
462
36
        try:
463
37
            background = self.main_view.select_single(
464
38
                objectName='entryComponent-background'
465
39
            )
466
40
        except StateNotFoundError:
467
41
            background = None
468
42
        self.assertThat(background, Equals(None))
Reviewer	Review Type	Date Requested	Status
Sebastien Bacher (community)		2014-04-01	Approve on 2014-04-11
PS Jenkins bot	continuous-integration	2014-04-01	Approve on 2014-04-08
Review via email: mp+213691@code.launchpad.net