~qbzr-dev/qbzr/0.22

« back to all changes in this revision

Viewing changes to lib/tests/test_treewidget.py

  • Committer: Gary van der Merwe
  • Author(s): Vincent Ladeuil
  • Date: 2011-01-27 22:27:15 UTC
  • mfrom: (1344.1.4 trunk)
  • Revision ID: garyvdm@gmail.com-20110127222715-sz1znm55dgzlc770
Allow tests to be run with --parallel=fork.

Show diffs side-by-side

added added

removed removed

Lines of Context:
27
27
from bzrlib import ignores
28
28
 
29
29
from PyQt4 import QtCore, QtGui
 
30
from bzrlib.plugins.qbzr.lib import tests as qtests
30
31
from bzrlib.plugins.qbzr.lib.treewidget import (
31
32
    TreeWidget,
32
33
    TreeModel,
37
38
    group_large_dirs,
38
39
    )
39
40
from bzrlib.plugins.qbzr.lib.tests.modeltest import ModelTest
40
 
from bzrlib.plugins.qbzr.lib.tests.excepthookwatcher import TestWatchExceptHook
41
41
 
42
42
def load_tests(standard_tests, module, loader):
43
43
    result = loader.suiteClass()
53
53
                TestTreeFilterProxyModel,
54
54
                )))
55
55
    tests.multiply_tests(filter_tests, filter_scenarios, result)
56
 
    
 
56
 
57
57
    # No parametrization for the remaining tests
58
58
    result.addTests(remaining_tests)
59
59
 
60
60
    return result
61
61
 
62
 
class TestTreeWidget(TestWatchExceptHook, TestCaseWithTransport):
63
 
    
 
62
 
 
63
class TestTreeWidget(qtests.QTestCase):
 
64
 
64
65
    # Set by load_tests
65
66
    make_tree = None
66
67
    modify_tree = None
67
68
    changes_mode = False
68
 
    
 
69
 
69
70
    def setUp(self):
70
71
        super(TestTreeWidget, self).setUp()
71
72
        self.tree, self.branch = self.make_tree(self)
72
 
    
 
73
 
73
74
    def make_working_tree(self):
74
75
        #tree = WorkingTree()
75
76
        tree = self.make_branch_and_tree('trunk')
224
225
         'modify_tree': lambda self, tree: None,}),
225
226
)
226
227
 
227
 
class TestTreeFilterProxyModel(TestWatchExceptHook, TestCaseWithTransport):
 
228
class TestTreeFilterProxyModel(qtests.QTestCase):
 
229
 
228
230
    # Set by load_tests
229
231
    filter = None
230
232
    expected_visible = None
231
 
    
 
233
 
232
234
    def test_filters(self):
233
235
        tree = self.make_branch_and_tree('tree')
234
 
        
 
236
 
235
237
        self.build_tree(['tree/dir-with-unversioned/',
236
238
                         'tree/ignored-dir-with-child/',])
237
239
        self.build_tree_contents([('tree/dir-with-unversioned/child', ''),
247
249
        ignores.tree_ignores_add_patterns(tree,
248
250
                                          ['ignored-dir-with-child',
249
251
                                           'ignored'])
250
 
        
 
252
 
251
253
        tree.commit('a', rev_id='rev-a',
252
254
                    committer="joe@foo.com",
253
255
                    timestamp=1166046000.00, timezone=0)
254
 
        
 
256
 
255
257
        self.build_tree_contents([('tree/changed', 'new')])
256
 
        
 
258
 
257
259
        self.model = TreeModel()
258
260
        load_dirs=[PersistantItemReference(None, 'dir-with-unversioned'),
259
 
                   PersistantItemReference(None, 'ignored-dir-with-child')]        
 
261
                   PersistantItemReference(None, 'ignored-dir-with-child')]
260
262
        self.model.set_tree(tree, branch=tree.branch, load_dirs=load_dirs)
261
263
        self.filter_model = TreeFilterProxyModel()
262
264
        self.filter_model.setSourceModel(self.model)
263
 
        
 
265
 
264
266
 
265
267
        self.filter_model.setFilters(self.filter)
266
268
        self.assertVisiblePaths(self.expected_visible)
267
269
 
268
 
    
269
270
    def assertVisiblePaths(self, paths):
270
271
        visible_paths = []
271
272
        parent_indexes_to_visit = [QtCore.QModelIndex()]
277
278
                    str(self.filter_model.data(index, self.model.PATH).toString()))
278
279
                if self.filter_model.hasChildren(index):
279
280
                    parent_indexes_to_visit.append(index)
280
 
        
 
281
 
281
282
        # we do not care for the order in this test.
282
283
        visible_paths.sort()
283
284
        paths.sort()
284
285
        self.assertEqual(visible_paths, paths)
285
286
 
286
 
class TestTreeWidgetSelectAll(TestWatchExceptHook, TestCaseWithTransport):
287
 
    
 
287
class TestTreeWidgetSelectAll(qtests.QTestCase):
 
288
 
288
289
    def setUp(self):
289
290
        super(TestTreeWidgetSelectAll, self).setUp()
290
291
        tree = self.make_branch_and_tree('tree')
291
 
        
 
292
 
292
293
        self.build_tree(['tree/dir-with-unversioned/',
293
294
                         'tree/ignored-dir-with-child/',
294
295
                         'tree/unversioned-with-ignored/',
308
309
        ignores.tree_ignores_add_patterns(tree,
309
310
                                          ['ignored-dir-with-child',
310
311
                                           'ignored'])
311
 
        
 
312
 
312
313
        tree.commit('a', rev_id='rev-a',
313
314
                    committer="joe@foo.com",
314
315
                    timestamp=1166046000.00, timezone=0)
315
 
        
 
316
 
316
317
        self.build_tree_contents([('tree/changed', 'new')])
317
318
        self.tree = tree
318
 
    
 
319
 
319
320
    def assertSelectedPaths(self, treewidget, paths):
320
321
        if 0: treewidget = TreeWidget()
321
322
        selected = [item.path for item in treewidget.tree_model.iter_checked()]
322
323
        # we do not care for the order in this test.
323
 
        selected.sort()
324
 
        paths.sort()
325
 
        self.assertEqual(selected, paths)
326
 
    
 
324
        self.assertEqual(set(selected), set(paths))
 
325
 
327
326
    def test_add_selectall(self):
328
327
        import bzrlib.plugins.qbzr.lib.add
329
328
        self.win = bzrlib.plugins.qbzr.lib.add.AddWindow(self.tree, None)
333
332
                                                     'unversioned',
334
333
                                                     'unversioned-with-ignored'])
335
334
 
336
 
    
 
335
 
337
336
    def test_commit_selectall(self):
338
337
        import bzrlib.plugins.qbzr.lib.commit
339
338
        self.win = bzrlib.plugins.qbzr.lib.commit.CommitWindow(self.tree, None)
357
356
        self.win.initial_load()
358
357
        self.win.selectall_checkbox.click()
359
358
        self.assertSelectedPaths(self.win.filelist, ['changed'])
360
 
    
 
359
 
361
360
    def cleanup_win(self):
362
361
        # Sometimes the model was getting deleted before the widget, and the
363
362
        # widget was trying to query the model. So we delete everything here.
366
365
        self.win.filelist.tree_model.deleteLater()
367
366
        QtCore.QCoreApplication.processEvents()
368
367
 
 
368
 
369
369
class TestModelItemData(TestCase):
370
370
 
371
371
    def _make_unversioned_model_list(self, iterable):
408
408
                              'dir-with-unversioned/child',
409
409
                              'ignored-dir-with-child',
410
410
                              'ignored-dir-with-child/child',
411
 
                              'unchanged', 
412
 
                              'changed', 
413
 
                              'unversioned', 
 
411
                              'unchanged',
 
412
                              'changed',
 
413
                              'unversioned',
414
414
                              'ignored',
415
415
                              '.bzrignore',
416
416
                              ],}),
417
417
    ('Unchanged',
418
418
        {'filter': (True, False, False, False) ,
419
419
         'expected_visible': ['dir-with-unversioned',
420
 
                              'unchanged', 
 
420
                              'unchanged',
421
421
                              '.bzrignore',
422
422
                              ],}),
423
423
    ('Changed',
427
427
        {'filter': (False, False, True, False),
428
428
         'expected_visible': ['dir-with-unversioned',
429
429
                              'dir-with-unversioned/child',
430
 
                              'unversioned', 
 
430
                              'unversioned',
431
431
                              ],}),
432
432
    ('Ignored',
433
433
        {'filter': (False, False, False, True),
441
441
                              'ignored',
442
442
                              'dir-with-unversioned',
443
443
                              'dir-with-unversioned/child',
444
 
                              'unversioned', 
 
444
                              'unversioned',
445
445
                              ],}),
446
446
    )
447
447
 
448
448
 
449
449
class TestGroupLargeDirs(TestCase):
450
 
    
 
450
 
451
451
    def test_no_group_small(self):
452
452
        paths = frozenset(("a/1", "a/2", "a/3", "b"))
453
453
        self.assertEqual(group_large_dirs(paths), {"":paths})
472
472
        paths = frozenset()
473
473
        self.assertEqual(group_large_dirs(paths),
474
474
                         {'': set([])})
475
 
    
 
475
 
476
476
    def test_group_deeper_dir(self):
477
477
        paths = frozenset(("a/b/1", "a/b/2", "a/b/3", "a/b/4", "c"))
478
478
        self.assertEqual(group_large_dirs(paths),
479
479
                         {'': set(['a/b', 'c']),
480
 
                          'a/b': set(['a/b/1', 'a/b/2', 'a/b/3', 'a/b/4'])}) 
481
 
    
 
480
                          'a/b': set(['a/b/1', 'a/b/2', 'a/b/3', 'a/b/4'])})
 
481
 
482
482
    def test_subdir_included(self):
483
483
        paths = frozenset([
484
484
            u'b',