← Back to branch summary

~dobey/ubuntuone-control-panel/update-4-0

« back to all changes in this revision

Viewing changes to ubuntuone/controlpanel/gui/qt/tests/test_folders.py

  • Committer: Tarmac
  • Author(s): Diego Sarmentero, mike.mccracken at canonical, Roberto Alsina, Rodney Dawes
  • Date: 2012-06-20 19:33:56 UTC
  • mfrom: (327.7.1 update-4-0)
  • Revision ID: tarmac-20120620193356-en3jx8bhrcl62yjo
[Mike McCracken]

    - Use qt4reactor on Darwin. (LP: #1013820)
    - Make run-tests script work on Darwin. (LP: #1010211)

[Roberto Alsina]

    - Enable folder list sorting (Fixes LP:1006385).

[Diego Sarmentero]

    - Using suggested_path to server path comparisons (LP: #1004603).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ubuntuone/controlpanel/gui/qt/tests/test_folders.py
24
24
import shutil
25
25
import sys
26
26
 
27
 
from PyQt4 import QtGui
 
27
from PyQt4 import QtCore, QtGui
28
28
from twisted.internet import defer
29
29
from ubuntuone.devtools.handlers import MementoHandler
30
30
from ubuntuone.devtools.testcases import skipIfOS
37
37
    FAKE_VOLUMES_ONLY_ROOT_INFO,
38
38
    MUSIC_FOLDER, MUSIC_PATH, ROOT, USER_HOME,
39
39
)
 
40
from ubuntuone.controlpanel.gui import MUSIC_REAL_PATH
40
41
from ubuntuone.controlpanel.gui.qt import folders as gui
41
42
from ubuntuone.controlpanel.gui.qt.tests import (
42
43
    BaseTestCase,
243
244
 
244
245
    def test_process_info(self):
245
246
        """The volumes info is processed when ready."""
 
247
        folders = self.ui.ui.folders
246
248
        self.ui.process_info(FAKE_VOLUMES_INFO)
247
 
        folders = self.ui.ui.folders
248
 
 
249
249
        root = folders.invisibleRootItem()
250
250
        self.assertEqual(len(FAKE_VOLUMES_INFO), root.childCount())
251
251
 
252
 
        treeiter = gui.QtGui.QTreeWidgetItemIterator(folders)
253
252
        for name, _, volumes in FAKE_VOLUMES_INFO:
254
253
            name = _build_name(name)
255
 
 
256
 
            # get first child, matching "My Folders"
257
 
            item = treeiter.value()
258
 
            self.assertFalse(item.is_empty)
259
 
 
 
254
            items = folders.findItems(name, QtCore.Qt.MatchFixedString
 
255
                | QtCore.Qt.MatchCaseSensitive | QtCore.Qt.MatchRecursive,
 
256
                gui.FOLDER_NAME_COL)
 
257
            self.assertEqual(1, len(items))
 
258
            item = items[0]
260
259
            self.assert_folder_group_header_correct(item, name)
261
 
 
262
260
            self.assertEqual(len(volumes), item.childCount())
263
 
            sorted_vols = sorted(volumes, key=operator.itemgetter('path'))
264
 
            for volume in sorted_vols:
265
 
                treeiter += 1
266
 
                item = treeiter.value()  # get child folder
267
 
                self.assertTrue(item is not None)
 
261
            for volume in volumes:
268
262
 
269
263
                name = volume['path'].replace(USER_HOME + os.path.sep, '')
270
264
                expected_path = volume['path']
277
271
                else:
278
272
                    icon_name = gui.SHARE_ICON_NAME
279
273
 
 
274
                items = folders.findItems(name, QtCore.Qt.MatchFixedString |
 
275
                    QtCore.Qt.MatchCaseSensitive | QtCore.Qt.MatchRecursive,
 
276
                    gui.FOLDER_NAME_COL)
 
277
                self.assertEqual(1, len(items))
 
278
                item = items[0]
280
279
                self.assert_folder_row_correct(item, name, icon_name, volume,
281
280
                                               tweaked_path=expected_path)
282
281
 
283
 
            treeiter += 1
284
 
            item = treeiter.value()
285
 
 
286
282
    def test_process_info_clears_the_list(self):
287
283
        """The old volumes info is cleared before updated."""
288
284
        self.ui.process_info(FAKE_VOLUMES_INFO)
304
300
 
305
301
        child_index = 0
306
302
        root = self.ui.ui.folders.invisibleRootItem()
307
 
        for name, _, _ in FAKE_VOLUMES_NO_FREE_SPACE_INFO:
308
 
            name = _build_name(name)
309
 
 
 
303
        names = [_build_name(name) for name, _, _ in
 
304
            FAKE_VOLUMES_NO_FREE_SPACE_INFO]
 
305
        names.sort(key=lambda x: x.lower())
 
306
        for name in names:
310
307
            item = root.child(child_index)
311
308
            self.assertFalse(item.is_empty)
312
309
            self.assert_folder_group_header_correct(item, name)
413
410
        """Ensure that the inner widgets are in the correct tab order."""
414
411
        self.ui.process_info(FAKE_VOLUMES_INFO)
415
412
        folders = self.ui.ui.folders
416
 
 
417
413
        widget = self.ui.ui.folders.nextInFocusChain()
418
414
        treeiter = gui.QtGui.QTreeWidgetItemIterator(folders)
419
 
        for name, _, volumes in FAKE_VOLUMES_INFO:
420
 
            item = treeiter.value()
421
 
            sorted_vols = sorted(volumes, key=operator.itemgetter('path'))
422
 
            for volume in sorted_vols:
 
415
        while treeiter.value():
 
416
            if treeiter.value().parent() is None:  # Top-levels
423
417
                treeiter += 1
424
 
                item = treeiter.value()  # get child folder
425
 
 
426
 
                name = volume['path'].replace(USER_HOME + os.path.sep, '')
427
 
                if volume['type'] == self.ui.backend.SHARE_TYPE:
428
 
                    name = volume['name']
429
 
                self.assertEqual(unicode(item.text(gui.FOLDER_NAME_COL)), name)
430
 
 
431
 
                actual_name = unicode(self.ui.widget_items[widget].text(0))
432
 
                if volume['type'] != self.ui.backend.ROOT_TYPE:
433
 
                    self.assertIsInstance(widget, QtGui.QCheckBox)
434
 
                    self.assertEqual(actual_name, name)
435
 
                    widget = widget.nextInFocusChain()
436
 
 
437
 
                if not self.ui.remote_folders:
438
 
                    self.assertIsInstance(widget, QtGui.QPushButton)
439
 
                    self.assertEqual(actual_name, name)
440
 
                    widget = widget.nextInFocusChain()
441
 
 
 
418
                continue
 
419
            if self.ui.remote_folders:
 
420
                self.assertIsInstance(widget, QtGui.QCheckBox)
 
421
            # ROOT volume has no checkbox
 
422
            elif treeiter.value().text(1) or self.ui.remote_folders:
 
423
                self.assertIsInstance(widget, QtGui.QPushButton)
 
424
            else:
 
425
                self.assertIsInstance(widget, QtGui.QCheckBox)
 
426
                widget = widget.nextInFocusChain()
 
427
                self.assertIsInstance(widget, QtGui.QPushButton)
 
428
            widget = widget.nextInFocusChain()
442
429
            treeiter += 1
443
 
            item = treeiter.value()
444
430
 
445
431
    def test_widget_dict(self):
446
432
        """Ensure the widget_items dictionary is full."""
994
980
    def assert_folder_added(self, path, volume_id=None, item=None):
995
981
        """A entry for 'path' was added to the folder list."""
996
982
        folders = self.ui.ui.folders
997
 
        if item is None:  # grab the last one added
998
 
            item = folders.topLevelItem(folders.topLevelItemCount() - 1)
999
983
 
1000
984
        if path == MUSIC_PATH:
1001
985
            display_name = gui.MUSIC_DISPLAY_NAME
1002
986
        else:
1003
987
            display_name = path.replace(USER_HOME + os.path.sep, '')
 
988
        if item is None:  # search for it
 
989
            items = folders.findItems(display_name,
 
990
                QtCore.Qt.MatchFixedString | QtCore.Qt.MatchCaseSensitive,
 
991
                gui.FOLDER_NAME_COL)
 
992
            self.assertEqual(len(items), 1)
 
993
            item = items[0]
1004
994
        self.assertEqual(display_name,
1005
995
                         unicode(item.text(gui.LOCAL_SUBSCRIPTION_COL)))
1006
996
 
1093
1083
        # the following will execute update_sizes once
1094
1084
        # will fill in all the path sizes for the already added folders
1095
1085
        self.timer.timeout.emit()
1096
 
 
1097
 
        folders = self.ui.ui.folders
1098
 
        treeiter = gui.QtGui.QTreeWidgetItemIterator(folders)
1099
 
 
1100
1086
        volumes = []
1101
1087
        for _, _, vols in volumes_info:
1102
1088
            volumes.extend(vols)
1107
1093
                not bool(volume['subscribed'])):
1108
1094
                # non-folders or unsubscribed should not appear in the tree
1109
1095
                continue
1110
 
 
1111
 
            item = treeiter.value()
1112
 
            self.assertTrue(item is not None)
1113
1096
            self.assert_folder_added(volume['path'],
1114
 
                                     volume_id=volume['volume_id'], item=item)
1115
 
 
1116
 
            treeiter += 1
1117
 
            item = treeiter.value()
1118
 
 
 
1097
                                     volume_id=volume['volume_id'])
1119
1098
        for folder in gui.default_folders(USER_HOME):
1120
1099
            valid = yield self.validate_path(folder)
1121
1100
            if not valid:
1122
1101
                continue  # invalid folders should not appear in the tree
1123
 
 
1124
 
            item = treeiter.value()
1125
 
            self.assertTrue(item is not None)
1126
 
            self.assert_folder_added(folder, volume_id=None, item=item)
1127
 
 
1128
 
            treeiter += 1
1129
 
            item = treeiter.value()
1130
 
 
1131
 
        self.assertTrue(item is None)
 
1102
            self.assert_folder_added(folder, volume_id=None, item=None)
 
1103
 
1132
1104
        self.assert_space_header_correct(ACCOUNT_INFO['quota_used'])
1133
1105
 
1134
1106
    @defer.inlineCallbacks
1219
1191
class LocalFoldersPanelAddFolderTestCase(BaseLocalFoldersPanelTestCase):
1220
1192
    """Test suite for the add_folder method from LocalFoldersPanel."""
1221
1193
 
1222
 
    def test_folder_is_added(self, folder_path=None):
 
1194
    def test_folder_is_added(self, folder_path=None, suggested=None):
1223
1195
        """Adding a folder adds it to the folder list."""
1224
1196
        former_count = self.ui.ui.folders.topLevelItemCount()
1225
1197
 
1226
1198
        if folder_path is None:
1227
1199
            folder_path = self.path
1228
 
        self.ui.add_folder(folder_path)
 
1200
        self.ui.add_folder(folder_path, suggested=suggested)
1229
1201
 
1230
1202
        new_count = self.ui.ui.folders.topLevelItemCount()
1231
1203
        self.assertEqual(new_count, former_count + 1)
1233
1205
 
1234
1206
    def test_add_music_folder_adds_the_folder(self):
1235
1207
        """Adding the purchased music folder adds it to the folder list."""
1236
 
        self.test_folder_is_added(folder_path=MUSIC_PATH)
 
1208
        self.test_folder_is_added(folder_path=MUSIC_PATH,
 
1209
            suggested=MUSIC_REAL_PATH)
 
1210
 
 
1211
    def test_add_music_folder_adds_the_folder_with_suggested_path(self):
 
1212
        """Adding the purchased music folder adds it to the folder list."""
 
1213
        suggested_path = '~/' + MUSIC_REAL_PATH
 
1214
        self.test_folder_is_added(folder_path=MUSIC_PATH,
 
1215
            suggested=suggested_path)
1237
1216
 
1238
1217
    def test_do_not_add_twice(self):
1239
1218
        """The same folder will not be added twice."""