/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 bzrlib/tests/intertree_implementations/test_compare.py

1st cut merge of bzr.dev r3907

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/intertree_implementations/test_compare.py
21
21
 
22
22
from bzrlib import errors, tests, workingtree_4
23
23
from bzrlib.osutils import file_kind, has_symlinks
 
24
from bzrlib.tests import TestNotApplicable
24
25
from bzrlib.tests.intertree_implementations import TestCaseWithTwoTrees
25
26
 
26
27
# TODO: test the include_root option.
49
50
        tree2.set_root_id(tree1.get_root_id())
50
51
        tree1 = self.get_tree_no_parents_no_content(tree1)
51
52
        tree2 = self.get_tree_no_parents_no_content(tree2)
52
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
53
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
53
54
        d = self.intertree_class(tree1, tree2).compare()
54
55
        self.assertEqual([], d.added)
55
56
        self.assertEqual([], d.modified)
63
64
        tree2.set_root_id(tree1.get_root_id())
64
65
        tree1 = self.get_tree_no_parents_no_content(tree1)
65
66
        tree2 = self.get_tree_no_parents_abc_content(tree2)
66
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
67
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
67
68
        d = self.intertree_class(tree1, tree2).compare()
68
69
        self.assertEqual([('a', 'a-id', 'file'),
69
70
                          ('b', 'b-id', 'directory'),
93
94
        # default intertree, but may perform a commit for other tree types,
94
95
        # which may reduce the validity of the test. XXX: Think about how to
95
96
        # address this.
96
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
97
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
97
98
        d = self.intertree_class(tree1, tree2).compare()
98
99
        self.assertEqual([], d.added)
99
100
        self.assertEqual([], d.modified)
107
108
        tree2.set_root_id(tree1.get_root_id())
108
109
        tree1 = self.get_tree_no_parents_abc_content(tree1)
109
110
        tree2 = self.get_tree_no_parents_no_content(tree2)
110
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
111
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
111
112
        d = self.intertree_class(tree1, tree2).compare()
112
113
        self.assertEqual([], d.added)
113
114
        self.assertEqual([], d.modified)
124
125
        tree2.set_root_id(tree1.get_root_id())
125
126
        tree1 = self.get_tree_no_parents_abc_content(tree1)
126
127
        tree2 = self.get_tree_no_parents_abc_content_2(tree2)
127
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
128
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
128
129
        d = self.intertree_class(tree1, tree2).compare()
129
130
        self.assertEqual([], d.added)
130
131
        self.assertEqual([('a', 'a-id', 'file', True, False)], d.modified)
138
139
        tree2.set_root_id(tree1.get_root_id())
139
140
        tree1 = self.get_tree_no_parents_abc_content(tree1)
140
141
        tree2 = self.get_tree_no_parents_abc_content_3(tree2)
141
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
142
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
142
143
        d = self.intertree_class(tree1, tree2).compare()
143
144
        self.assertEqual([], d.added)
144
145
        self.assertEqual([('b/c', 'c-id', 'file', False, True)], d.modified)
152
153
        tree2.set_root_id(tree1.get_root_id())
153
154
        tree1 = self.get_tree_no_parents_abc_content(tree1)
154
155
        tree2 = self.get_tree_no_parents_abc_content_4(tree2)
155
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
156
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
156
157
        d = self.intertree_class(tree1, tree2).compare()
157
158
        self.assertEqual([], d.added)
158
159
        self.assertEqual([], d.modified)
166
167
        tree2.set_root_id(tree1.get_root_id())
167
168
        tree1 = self.get_tree_no_parents_abc_content(tree1)
168
169
        tree2 = self.get_tree_no_parents_abc_content_5(tree2)
169
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
170
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
170
171
        d = self.intertree_class(tree1, tree2).compare()
171
172
        self.assertEqual([], d.added)
172
173
        self.assertEqual([], d.modified)
180
181
        tree2.set_root_id(tree1.get_root_id())
181
182
        tree1 = self.get_tree_no_parents_abc_content(tree1)
182
183
        tree2 = self.get_tree_no_parents_abc_content_6(tree2)
183
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
184
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
184
185
        d = self.intertree_class(tree1, tree2).compare()
185
186
        self.assertEqual([], d.added)
186
187
        self.assertEqual([], d.modified)
194
195
        tree2.set_root_id(tree1.get_root_id())
195
196
        tree1 = self.get_tree_no_parents_no_content(tree1)
196
197
        tree2 = self.get_tree_no_parents_abc_content(tree2)
197
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
198
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
198
199
        d = self.intertree_class(tree1, tree2).compare(specific_files=['a'])
199
200
        self.assertEqual([('a', 'a-id', 'file')], d.added)
200
201
        self.assertEqual([], d.modified)
207
208
        tree2 = self.make_to_branch_and_tree('2')
208
209
        tree1 = self.get_tree_no_parents_no_content(tree1)
209
210
        tree2 = self.get_tree_no_parents_abc_content(tree2)
210
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
211
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
211
212
        d = self.intertree_class(tree1, tree2).compare(
212
213
            specific_files=['a', 'b/c'])
213
214
        self.assertEqual(
224
225
        tree2 = self.make_to_branch_and_tree('2')
225
226
        tree1 = self.get_tree_no_parents_no_content(tree1)
226
227
        tree2 = self.get_tree_no_parents_abc_content(tree2)
227
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
228
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
228
229
        d = self.intertree_class(tree1, tree2).compare(specific_files=['b'])
229
230
        self.assertEqual(
230
231
            [('b', 'b-id', 'directory'),('b/c', 'c-id', 'file')],
240
241
        tree2 = self.make_to_branch_and_tree('2')
241
242
        tree1 = self.get_tree_no_parents_abc_content(tree1)
242
243
        tree2 = self.get_tree_no_parents_abc_content_5(tree2)
243
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
244
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
244
245
        d = self.intertree_class(tree1, tree2).compare(want_unchanged=True)
245
246
        self.assertEqual([], d.added)
246
247
        self.assertEqual([], d.modified)
256
257
        tree2 = self.make_to_branch_and_tree('2')
257
258
        tree1 = self.get_tree_no_parents_abc_content(tree1)
258
259
        tree2 = self.get_tree_no_parents_abc_content_3(tree2)
259
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
260
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
260
261
        d = self.intertree_class(tree1, tree2).compare(specific_files=['b'])
261
262
        # the type of tree-3 does not matter - it is used as a lookup, not
262
263
        # a dispatch. XXX: For dirstate it does speak to the optimisability of
291
292
        tree2 = self.make_to_branch_and_tree('2')
292
293
        tree1 = self.get_tree_no_parents_no_content(tree1)
293
294
        tree2 = self.get_tree_no_parents_abc_content(tree2)
294
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
295
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
295
296
        self.assertRaises(errors.PathsNotVersionedError, 
296
297
            self.intertree_class(tree1, tree2).compare,
297
298
            specific_files=['d'],
306
307
        tree1.add(['a', 'c'], ['a-id', 'c-id'])
307
308
        tree2.add(['a', 'c'], ['a-id', 'c-id'])
308
309
 
309
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
310
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
310
311
        d = self.intertree_class(tree1, tree2).compare()
311
312
        self.assertEqual([], d.added)
312
313
        self.assertEqual([(u'a', 'a-id', 'file', True, False),
326
327
            links_supported = True
327
328
        else:
328
329
            links_supported = False
329
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
330
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
330
331
        d = self.intertree_class(tree1, tree2).compare(want_unversioned=True)
331
332
        self.assertEqual([], d.added)
332
333
        self.assertEqual([], d.modified)
366
367
 
367
368
        Read lock them, and add the unlock to the cleanup.
368
369
        """
369
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
370
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
370
371
        tree1.lock_read()
371
372
        self.addCleanup(tree1.unlock)
372
373
        tree2.lock_read()
428
429
        tree2 = self.make_to_branch_and_tree('2')
429
430
        tree1 = self.get_tree_no_parents_no_content(tree1)
430
431
        tree2 = self.get_tree_no_parents_no_content(tree2)
431
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
432
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
432
433
        self.assertEqual([], self.do_iter_changes(tree1, tree2))
433
434
 
434
435
    def added(self, tree, file_id):
435
 
        entry = tree.inventory[file_id]
436
 
        path = tree.id2path(file_id)
 
436
        path, entry = self.get_path_entry(tree, file_id)
437
437
        return (file_id, (None, path), True, (False, True), (None, entry.parent_id),
438
438
                (None, entry.name), (None, entry.kind),
439
439
                (None, entry.executable))
440
440
 
 
441
    @staticmethod
 
442
    def get_path_entry(tree, file_id):
 
443
        iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
 
444
        return iterator.next()
 
445
 
441
446
    def content_changed(self, tree, file_id):
442
 
        entry = tree.inventory[file_id]
443
 
        path = tree.id2path(file_id)
444
 
        return (file_id, (path, path), True, (True, True), (entry.parent_id, entry.parent_id),
 
447
        path, entry = self.get_path_entry(tree, file_id)
 
448
        return (file_id, (path, path), True, (True, True),
 
449
                (entry.parent_id, entry.parent_id),
445
450
                (entry.name, entry.name), (entry.kind, entry.kind),
446
451
                (entry.executable, entry.executable))
447
452
 
448
453
    def kind_changed(self, from_tree, to_tree, file_id):
449
 
        old_entry = from_tree.inventory[file_id]
450
 
        new_entry = to_tree.inventory[file_id]
451
 
        path = to_tree.id2path(file_id)
452
 
        from_path = from_tree.id2path(file_id)
453
 
        return (file_id, (from_path, path), True, (True, True), (old_entry.parent_id, new_entry.parent_id),
454
 
                (old_entry.name, new_entry.name), (old_entry.kind, new_entry.kind),
 
454
        from_path, old_entry = self.get_path_entry(from_tree, file_id)
 
455
        path, new_entry = self.get_path_entry(to_tree, file_id)
 
456
        return (file_id, (from_path, path), True, (True, True),
 
457
                (old_entry.parent_id, new_entry.parent_id),
 
458
                (old_entry.name, new_entry.name),
 
459
                (old_entry.kind, new_entry.kind),
455
460
                (old_entry.executable, new_entry.executable))
456
461
 
457
462
    def missing(self, file_id, from_path, to_path, parent_id, kind):
470
475
                (entry.executable, None))
471
476
 
472
477
    def renamed(self, from_tree, to_tree, file_id, content_changed):
473
 
        from_entry = from_tree.inventory[file_id]
474
 
        to_entry = to_tree.inventory[file_id]
475
 
        from_path = from_tree.id2path(file_id)
476
 
        to_path = to_tree.id2path(file_id)
 
478
        from_path, from_entry = self.get_path_entry(from_tree, file_id)
 
479
        to_path, to_entry = self.get_path_entry(to_tree, file_id)
477
480
        return (file_id, (from_path, to_path), content_changed, (True, True),
478
481
            (from_entry.parent_id, to_entry.parent_id),
479
482
            (from_entry.name, to_entry.name),
481
484
            (from_entry.executable, to_entry.executable))
482
485
 
483
486
    def unchanged(self, tree, file_id):
484
 
        entry = tree.inventory[file_id]
 
487
        path, entry = self.get_path_entry(tree, file_id)
485
488
        parent = entry.parent_id
486
489
        name = entry.name
487
490
        kind = entry.kind
488
491
        executable = entry.executable
489
 
        path = tree.id2path(file_id)
490
492
        return (file_id, (path, path), False, (True, True),
491
493
               (parent, parent), (name, name), (kind, kind),
492
494
               (executable, executable))
494
496
    def unversioned(self, tree, path):
495
497
        """Create an unversioned result."""
496
498
        _, basename = os.path.split(path)
497
 
        kind = file_kind(tree.abspath(path))
 
499
        kind = tree._comparison_data(None, path)[0]
498
500
        return (None, (None, path), True, (False, False), (None, None),
499
501
                (None, basename), (None, kind),
500
502
                (None, False))
592
594
        tree2 = self.make_to_branch_and_tree('2')
593
595
        tree1 = self.get_tree_no_parents_abc_content(tree1)
594
596
        tree2 = self.get_tree_no_parents_abc_content_2(tree2)
595
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
597
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
596
598
        root_id = tree1.path2id('')
597
599
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
598
600
                           (root_id, root_id), ('a', 'a'),
604
606
        tree2 = self.make_to_branch_and_tree('2')
605
607
        tree1 = self.get_tree_no_parents_abc_content(tree1)
606
608
        tree2 = self.get_tree_no_parents_abc_content_3(tree2)
607
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
609
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
608
610
        self.assertEqual([('c-id', ('b/c', 'b/c'), False, (True, True),
609
611
                           ('b-id', 'b-id'), ('c', 'c'), ('file', 'file'),
610
612
                          (False, True))],
620
622
        self.build_tree(['1/a-empty/', '2/a-empty/'])
621
623
        tree1.add(['a-empty'], ['a-empty'])
622
624
        tree2.add(['a-empty'], ['a-empty'])
623
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
625
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
624
626
        expected = []
625
627
        self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
626
628
 
629
631
        tree2 = self.make_to_branch_and_tree('2')
630
632
        tree1 = self.get_tree_no_parents_abc_content(tree1)
631
633
        tree2 = self.get_tree_no_parents_abc_content_4(tree2)
632
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
634
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
633
635
        root_id = tree1.path2id('')
634
636
        self.assertEqual([('a-id', ('a', 'd'), False, (True, True),
635
637
                           (root_id, root_id), ('a', 'd'), ('file', 'file'),
641
643
        tree2 = self.make_to_branch_and_tree('2')
642
644
        tree1 = self.get_tree_no_parents_abc_content(tree1)
643
645
        tree2 = self.get_tree_no_parents_abc_content_5(tree2)
644
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
646
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
645
647
        root_id = tree1.path2id('')
646
648
        self.assertEqual([('a-id', ('a', 'd'), True, (True, True),
647
649
                           (root_id, root_id), ('a', 'd'), ('file', 'file'),
653
655
        tree2 = self.make_to_branch_and_tree('2')
654
656
        tree1 = self.get_tree_no_parents_abc_content(tree1)
655
657
        tree2 = self.get_tree_no_parents_abc_content_6(tree2)
656
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
658
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
657
659
        root_id = tree1.path2id('')
658
660
        self.assertEqual([('c-id', ('b/c', 'e'), False, (True, True),
659
661
                           ('b-id', root_id), ('c', 'e'), ('file', 'file'),
669
671
        os.unlink('2/a')
670
672
        shutil.rmtree('2/b')
671
673
        # TODO ? have a symlink here?
672
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
674
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
673
675
        root_id = tree1.path2id('')
674
676
        expected = sorted([
675
677
            self.missing('a-id', 'a', 'a', root_id, 'file'),
695
697
            ])
696
698
        self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
697
699
 
 
700
    def test_only_in_source_and_missing(self):
 
701
        tree1 = self.make_branch_and_tree('tree1')
 
702
        tree2 = self.make_to_branch_and_tree('tree2')
 
703
        tree2.set_root_id(tree1.get_root_id())
 
704
        self.build_tree(['tree1/file'])
 
705
        tree1.add(['file'], ['file-id'])
 
706
        os.unlink('tree1/file')
 
707
        tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
 
708
        root_id = tree1.path2id('')
 
709
        if not tree1.path2id('file'):
 
710
            # The locked test trees conversion could not preserve the missing
 
711
            # file status. This is normal (e.g. InterDirstateTree falls back
 
712
            # to InterTree if the basis is not a DirstateRevisionTree, and
 
713
            # revision trees cannot have missing files. 
 
714
            raise TestNotApplicable()
 
715
        expected = [('file-id', ('file', None), False, (True, False),
 
716
            (root_id, None), ('file', None), (None, None), (False, None))]
 
717
        self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
 
718
 
 
719
    def test_only_in_target_and_missing(self):
 
720
        tree1 = self.make_branch_and_tree('tree1')
 
721
        tree2 = self.make_to_branch_and_tree('tree2')
 
722
        tree2.set_root_id(tree1.get_root_id())
 
723
        self.build_tree(['tree2/file'])
 
724
        tree2.add(['file'], ['file-id'])
 
725
        os.unlink('tree2/file')
 
726
        tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2)
 
727
        root_id = tree1.path2id('')
 
728
        expected = [('file-id', (None, 'file'), False, (False, True),
 
729
            (None, root_id), (None, 'file'), (None, None), (None, False))]
 
730
        self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
 
731
 
698
732
    def test_unchanged_with_renames_and_modifications(self):
699
733
        """want_unchanged should generate a list of unchanged entries."""
700
734
        tree1 = self.make_branch_and_tree('1')
940
974
        tree2 = self.make_to_branch_and_tree('tree2')
941
975
        tree2.set_root_id(tree1.get_root_id())
942
976
        self.build_tree(['tree2/dir/', 'tree2/dir/file'])
943
 
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
977
        tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
944
978
        expected = [
945
979
            self.unversioned(tree2, 'dir'),
946
980
            ]