/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_tree.py

  • Committer: Jelmer Vernooij
  • Date: 2019-03-04 00:16:27 UTC
  • mfrom: (7293 work)
  • mto: This revision was merged to the branch mainline in revision 7318.
  • Revision ID: jelmer@jelmer.uk-20190304001627-v6u7o6pf97tukhek
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_tree.py
29
29
    FileTimestampUnavailable,
30
30
    InterTree,
31
31
    find_previous_paths,
 
32
    get_canonical_path,
32
33
    )
33
34
 
34
35
 
82
83
    calls = []
83
84
 
84
85
    def compare(self, want_unchanged=False, specific_files=None,
85
 
        extra_trees=None, require_versioned=False, include_root=False,
86
 
        want_unversioned=False):
 
86
                extra_trees=None, require_versioned=False, include_root=False,
 
87
                want_unversioned=False):
87
88
        self.calls.append(
88
89
            ('compare', self.source, self.target, want_unchanged,
89
90
             specific_files, extra_trees, require_versioned,
114
115
                              'require', True)
115
116
            # pass in all optional arguments by keyword
116
117
            tree.changes_from(tree2,
117
 
                specific_files='specific',
118
 
                want_unchanged='unchanged',
119
 
                extra_trees='extra',
120
 
                require_versioned='require',
121
 
                include_root=True,
122
 
                want_unversioned=True,
123
 
                )
 
118
                              specific_files='specific',
 
119
                              want_unchanged='unchanged',
 
120
                              extra_trees='extra',
 
121
                              require_versioned='require',
 
122
                              include_root=True,
 
123
                              want_unversioned=True,
 
124
                              )
124
125
        finally:
125
126
            InterTree._optimisers = old_optimisers
126
127
        self.assertEqual(
127
128
            [
128
 
             ('compare', tree2, tree, False, None, None, False, False, False),
129
 
             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
130
 
              'require', True, False),
131
 
             ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
132
 
              'require', True, True),
 
129
                ('compare', tree2, tree, False, None, None, False, False,
 
130
                    False),
 
131
                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
 
132
                    'require', True, False),
 
133
                ('compare', tree2, tree, 'unchanged', 'specific', 'extra',
 
134
                    'require', True, True),
133
135
            ], RecordingOptimiser.calls)
134
136
 
135
137
    def test_changes_from_with_root(self):
147
149
        self.build_tree(['known_file', 'unknown_file'])
148
150
        wt.add('known_file')
149
151
 
150
 
        self.assertRaises(errors.PathsNotVersionedError,
151
 
            wt.changes_from, wt.basis_tree(), wt, specific_files=['known_file',
152
 
            'unknown_file'], require_versioned=True)
 
152
        self.assertRaises(
 
153
            errors.PathsNotVersionedError,
 
154
            wt.changes_from, wt.basis_tree(), wt,
 
155
            specific_files=['known_file', 'unknown_file'],
 
156
            require_versioned=True)
153
157
 
154
158
        # we need to pass a known file with an unknown file to get this to
155
159
        # fail when expected.
156
160
        delta = wt.changes_from(wt.basis_tree(),
157
 
            specific_files=['known_file', 'unknown_file'],
158
 
            require_versioned=False)
 
161
                                specific_files=['known_file', 'unknown_file'],
 
162
                                require_versioned=False)
159
163
        self.assertEqual(len(delta.added), 1)
160
164
 
161
165
 
215
219
        else:
216
220
            self.assertIs(None, master_ie, 'master should not have an entry')
217
221
        self.assertEqual(len(exp_other_paths), len(other_values),
218
 
                            'Wrong number of other entries')
 
222
                         'Wrong number of other entries')
219
223
        other_paths = []
220
224
        other_file_ids = []
221
225
        for path, ie in other_values:
366
370
                                              second_tree])
367
371
        iterator = walker.iter_all()
368
372
        self.assertWalkerNext(u'', root_id, True, [u'', u'', u''], iterator)
369
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a', u'a', u'a'], iterator)
370
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b', u'b', u'b'], iterator)
371
 
        self.assertWalkerNext(u'c', b'c-id', False, [u'c', u'c', u'c'], iterator)
372
 
        self.assertWalkerNext(u'd', b'd-id', False, [None, u'd', u'd'], iterator)
373
 
        self.assertWalkerNext(u'e', b'e-id', False, [None, u'e', None], iterator)
 
373
        self.assertWalkerNext(u'a', b'a-id', True,
 
374
                              [u'a', u'a', u'a'], iterator)
 
375
        self.assertWalkerNext(u'b', b'b-id', True,
 
376
                              [u'b', u'b', u'b'], iterator)
 
377
        self.assertWalkerNext(u'c', b'c-id', False,
 
378
                              [u'c', u'c', u'c'], iterator)
 
379
        self.assertWalkerNext(u'd', b'd-id', False,
 
380
                              [None, u'd', u'd'], iterator)
 
381
        self.assertWalkerNext(u'e', b'e-id', False,
 
382
                              [None, u'e', None], iterator)
374
383
        self.assertRaises(StopIteration, next, iterator)
375
384
 
376
385
    def test_different_file_id_in_others(self):
402
411
        self.assertRaises(StopIteration, next, iterator)
403
412
 
404
413
    def assertLtByDirblock(self, lt_val, path1, path2):
405
 
        self.assertEqual(lt_val,
406
 
            _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))
 
414
        self.assertEqual(
 
415
            lt_val, _mod_tree.MultiWalker._lt_path_by_dirblock(path1, path2))
407
416
 
408
417
    def test__lt_path_by_dirblock(self):
409
418
        # We only support Unicode strings at this point
410
 
        self.assertRaises(TypeError,
411
 
            _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')
 
419
        self.assertRaises(
 
420
            TypeError, _mod_tree.MultiWalker._lt_path_by_dirblock, b'', b'b')
412
421
        self.assertLtByDirblock(False, u'', u'')
413
422
        self.assertLtByDirblock(False, u'a', u'a')
414
423
        self.assertLtByDirblock(False, u'a/b', u'a/b')
461
470
 
462
471
        self.assertEqual({'c': 'b', 'b': None},
463
472
                         find_previous_paths(tree2, tree1, ['b', 'c']))
 
473
 
 
474
 
 
475
class GetCanonicalPath(TestCaseWithTransport):
 
476
 
 
477
    def test_existing_case(self):
 
478
        # Test that we can find a file from a path with different case
 
479
        tree = self.make_branch_and_tree('tree')
 
480
        self.build_tree(['tree/b'])
 
481
        tree.add(['b'])
 
482
        self.assertEqual(
 
483
            'b',
 
484
            get_canonical_path(tree, 'b', lambda x: x.lower()))
 
485
        self.assertEqual(
 
486
            'b',
 
487
            get_canonical_path(tree, 'B', lambda x: x.lower()))
 
488
 
 
489
    def test_nonexistant_preserves_case(self):
 
490
        tree = self.make_branch_and_tree('tree')
 
491
        self.assertEqual(
 
492
            'b',
 
493
            get_canonical_path(tree, 'b', lambda x: x.lower()))
 
494
        self.assertEqual(
 
495
            'B',
 
496
            get_canonical_path(tree, 'B', lambda x: x.lower()))
 
497
 
 
498
    def test_in_directory_with_case(self):
 
499
        tree = self.make_branch_and_tree('tree')
 
500
        self.build_tree(['tree/a/', 'tree/a/b'])
 
501
        tree.add(['a', 'a/b'])
 
502
        self.assertEqual(
 
503
            'a/b',
 
504
            get_canonical_path(tree, 'a/b', lambda x: x.lower()))
 
505
        self.assertEqual(
 
506
            'a/b',
 
507
            get_canonical_path(tree, 'A/B', lambda x: x.lower()))
 
508
        self.assertEqual(
 
509
            'a/b',
 
510
            get_canonical_path(tree, 'A/b', lambda x: x.lower()))
 
511
        self.assertEqual(
 
512
            'a/C',
 
513
            get_canonical_path(tree, 'A/C', lambda x: x.lower()))