/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

merge dirstate

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/intertree_implementations/test_compare.py
416
416
    def added(self, tree, file_id):
417
417
        entry = tree.inventory[file_id]
418
418
        path = tree.id2path(file_id)
419
 
        return (file_id, path, True, (False, True), (None, entry.parent_id),
 
419
        return (file_id, (None, path), True, (False, True), (None, entry.parent_id),
420
420
                (None, entry.name), (None, entry.kind),
421
421
                (None, entry.executable))
422
422
 
423
423
    def content_changed(self, tree, file_id):
424
424
        entry = tree.inventory[file_id]
425
425
        path = tree.id2path(file_id)
426
 
        return (file_id, path, True, (True, True), (entry.parent_id, entry.parent_id),
 
426
        return (file_id, (path, path), True, (True, True), (entry.parent_id, entry.parent_id),
427
427
                (entry.name, entry.name), (entry.kind, entry.kind),
428
428
                (entry.executable, entry.executable))
429
429
 
431
431
        old_entry = from_tree.inventory[file_id]
432
432
        new_entry = to_tree.inventory[file_id]
433
433
        path = to_tree.id2path(file_id)
434
 
        return (file_id, path, True, (True, True), (old_entry.parent_id, new_entry.parent_id),
 
434
        from_path = from_tree.id2path(file_id)
 
435
        return (file_id, (from_path, path), True, (True, True), (old_entry.parent_id, new_entry.parent_id),
435
436
                (old_entry.name, new_entry.name), (old_entry.kind, new_entry.kind),
436
437
                (old_entry.executable, new_entry.executable))
437
438
 
438
 
    def missing(self, file_id, path, parent_id, kind):
439
 
        _, basename = os.path.split(path)
440
 
        return (file_id, path, True, (True, True), (parent_id, parent_id),
441
 
            (basename, basename), (kind, None), (False, False))
 
439
    def missing(self, file_id, from_path, to_path, parent_id, kind):
 
440
        _, from_basename = os.path.split(from_path)
 
441
        _, to_basename = os.path.split(to_path)
 
442
        # missing files have both paths, but no kind.
 
443
        return (file_id, (from_path, to_path), True, (True, True),
 
444
            (parent_id, parent_id),
 
445
            (from_basename, to_basename), (kind, None), (False, False))
442
446
 
443
447
    def deleted(self, tree, file_id):
444
448
        entry = tree.inventory[file_id]
445
449
        path = tree.id2path(file_id)
446
 
        return (file_id, path, True, (True, False), (entry.parent_id, None),
 
450
        return (file_id, (path, None), True, (True, False), (entry.parent_id, None),
447
451
                (entry.name, None), (entry.kind, None),
448
452
                (entry.executable, None))
449
453
 
452
456
        to_entry = to_tree.inventory[file_id]
453
457
        from_path = from_tree.id2path(file_id)
454
458
        to_path = to_tree.id2path(file_id)
455
 
        return (file_id, to_path, content_changed, (True, True),
 
459
        return (file_id, (from_path, to_path), content_changed, (True, True),
456
460
            (from_entry.parent_id, to_entry.parent_id),
457
461
            (from_entry.name, to_entry.name),
458
462
            (from_entry.kind, to_entry.kind),
464
468
        name = entry.name
465
469
        kind = entry.kind
466
470
        executable = entry.executable
467
 
        return (file_id, tree.id2path(file_id), False, (True, True),
 
471
        path = tree.id2path(file_id)
 
472
        return (file_id, (path, path), False, (True, True),
468
473
               (parent, parent), (name, name), (kind, kind),
469
474
               (executable, executable))
470
475
 
472
477
        """Create an unversioned result."""
473
478
        _, basename = os.path.split(path)
474
479
        kind = file_kind(tree.abspath(path))
475
 
        return (None, path, True, (False, False), (None, None),
 
480
        return (None, (None, path), True, (False, False), (None, None),
476
481
                (None, basename), (None, kind),
477
482
                (None, False))
478
483
 
547
552
        def deleted(file_id):
548
553
            entry = tree1.inventory[file_id]
549
554
            path = tree1.id2path(file_id)
550
 
            return (file_id, path, True, (True, False),
 
555
            return (file_id, (path, None), True, (True, False),
551
556
                    (entry.parent_id, None),
552
557
                    (entry.name, None), (entry.kind, None),
553
558
                    (entry.executable, None))
554
 
        expected_results = sorted([self.added(tree2, 'empty-root-id'),
555
 
                          deleted('root-id'), deleted('a-id'),
556
 
                          deleted('b-id'), deleted('c-id')])
 
559
        expected_results = sorted([
 
560
            self.added(tree2, 'empty-root-id'),
 
561
            deleted('root-id'), deleted('a-id'),
 
562
            deleted('b-id'), deleted('c-id')])
557
563
        tree1.unlock()
558
564
        tree2.unlock()
559
565
        self.assertEqual(
567
573
        tree2 = self.get_tree_no_parents_abc_content_2(tree2)
568
574
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
569
575
        root_id = tree1.path2id('')
570
 
        self.assertEqual([('a-id', 'a', True, (True, True),
571
 
                          (root_id, root_id), ('a', 'a'),
572
 
                          ('file', 'file'), (False, False))],
 
576
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
 
577
                           (root_id, root_id), ('a', 'a'),
 
578
                           ('file', 'file'), (False, False))],
573
579
                         self.do_iter_changes(tree1, tree2))
574
580
 
575
581
    def test_meta_modification(self):
578
584
        tree1 = self.get_tree_no_parents_abc_content(tree1)
579
585
        tree2 = self.get_tree_no_parents_abc_content_3(tree2)
580
586
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
581
 
        self.assertEqual([('c-id', 'b/c', False, (True, True),
582
 
                          ('b-id', 'b-id'), ('c', 'c'), ('file', 'file'),
 
587
        self.assertEqual([('c-id', ('b/c', 'b/c'), False, (True, True),
 
588
                           ('b-id', 'b-id'), ('c', 'c'), ('file', 'file'),
583
589
                          (False, True))],
584
590
                         self.do_iter_changes(tree1, tree2))
585
591
 
604
610
        tree2 = self.get_tree_no_parents_abc_content_4(tree2)
605
611
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
606
612
        root_id = tree1.path2id('')
607
 
        self.assertEqual([('a-id', 'd', False, (True, True),
608
 
                          (root_id, root_id), ('a', 'd'), ('file', 'file'),
609
 
                          (False, False))],
 
613
        self.assertEqual([('a-id', ('a', 'd'), False, (True, True),
 
614
                           (root_id, root_id), ('a', 'd'), ('file', 'file'),
 
615
                           (False, False))],
610
616
                         self.do_iter_changes(tree1, tree2))
611
617
 
612
618
    def test_file_rename_and_modification(self):
616
622
        tree2 = self.get_tree_no_parents_abc_content_5(tree2)
617
623
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
618
624
        root_id = tree1.path2id('')
619
 
        self.assertEqual([('a-id', 'd', True, (True, True),
620
 
                          (root_id, root_id), ('a', 'd'), ('file', 'file'),
 
625
        self.assertEqual([('a-id', ('a', 'd'), True, (True, True),
 
626
                           (root_id, root_id), ('a', 'd'), ('file', 'file'),
621
627
                           (False, False))],
622
628
                         self.do_iter_changes(tree1, tree2))
623
629
 
628
634
        tree2 = self.get_tree_no_parents_abc_content_6(tree2)
629
635
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
630
636
        root_id = tree1.path2id('')
631
 
        self.assertEqual([('c-id', 'e', False, (True, True),
632
 
                          ('b-id', root_id), ('c', 'e'), ('file', 'file'),
633
 
                          (False, True))],
 
637
        self.assertEqual([('c-id', ('b/c', 'e'), False, (True, True),
 
638
                           ('b-id', root_id), ('c', 'e'), ('file', 'file'),
 
639
                           (False, True))],
634
640
                         self.do_iter_changes(tree1, tree2))
635
641
 
636
642
    def test_missing_in_target(self):
645
651
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
646
652
        root_id = tree1.path2id('')
647
653
        expected = sorted([
648
 
            self.missing('a-id', 'a', root_id, 'file'),
649
 
            self.missing('b-id', 'b', root_id, 'directory'),
650
 
            self.missing('c-id', 'b/c', 'b-id', 'file'),
 
654
            self.missing('a-id', 'a', 'a', root_id, 'file'),
 
655
            self.missing('b-id', 'b', 'b', root_id, 'directory'),
 
656
            self.missing('c-id', 'b/c', 'b/c', 'b-id', 'file'),
 
657
            ])
 
658
        self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
 
659
 
 
660
    def test_missing_and_renamed(self):
 
661
        tree1 = self.make_branch_and_tree('tree1')
 
662
        tree2 = self.make_to_branch_and_tree('tree2')
 
663
        self.build_tree(['tree1/file'])
 
664
        tree1.add(['file'], ['file-id'])
 
665
        self.build_tree(['tree2/directory/'])
 
666
        tree2.add(['directory'], ['file-id'])
 
667
        os.rmdir('tree2/directory')
 
668
        tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
 
669
        tree1.lock_read()
 
670
        self.addCleanup(tree1.unlock)
 
671
        tree2.lock_read()
 
672
        self.addCleanup(tree2.unlock)
 
673
        root_id = tree1.path2id('')
 
674
        expected = sorted([
 
675
            self.missing('file-id', 'file', 'directory', root_id, 'file'),
651
676
            ])
652
677
        self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
653
678
 
664
689
        tree2.lock_read()
665
690
        self.addCleanup(tree2.unlock)
666
691
        self.assertEqual(sorted([self.unchanged(tree1, root_id),
667
 
            self.unchanged(tree1, 'b-id'), ('a-id', 'd', True, (True, True),
668
 
            (root_id, root_id), ('a', 'd'), ('file', 'file'),
 
692
            self.unchanged(tree1, 'b-id'),
 
693
            ('a-id', ('a', 'd'), True, (True, True),
 
694
             (root_id, root_id), ('a', 'd'), ('file', 'file'),
669
695
            (False, False)), self.unchanged(tree1, 'c-id')]),
670
696
            self.do_iter_changes(tree1, tree2, include_unchanged=True))
671
697
 
945
971
                          if f_id.endswith('_f-id'))
946
972
        self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
947
973
 
948
 
    def test_trees_with_missing_dir(self):
 
974
    def test_trees_with_deleted_dir(self):
949
975
        tree1 = self.make_branch_and_tree('tree1')
950
976
        tree2 = self.make_to_branch_and_tree('tree2')
951
977
        tree2.set_root_id(tree1.get_root_id())
961
987
        self.addCleanup(tree1.unlock)
962
988
        tree2.lock_read()
963
989
        self.addCleanup(tree2.unlock)
964
 
        # We should notice that 'b' and all its children are missing
 
990
        # We should notice that 'b' and all its children are deleted
965
991
        expected = sorted([
966
992
            self.content_changed(tree2, 'a-id'),
967
993
            self.content_changed(tree2, 'g-id'),