/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/test_transform.py

Merge with stacked-fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
51
51
    )
52
52
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths, 
53
53
                              resolve_conflicts, cook_conflicts, 
54
 
                              find_interesting, build_tree, get_backup_name,
55
 
                              change_entry, _FileMover, resolve_checkout,
 
54
                              build_tree, get_backup_name,
 
55
                              _FileMover, resolve_checkout,
56
56
                              TransformPreview)
57
57
 
58
58
class TestTreeTransform(tests.TestCaseWithTransport):
64
64
 
65
65
    def get_transform(self):
66
66
        transform = TreeTransform(self.wt)
67
 
        #self.addCleanup(transform.finalize)
 
67
        self.addCleanup(transform.finalize)
68
68
        return transform, transform.root
69
69
 
70
70
    def test_existing_limbo(self):
85
85
    def test_existing_pending_deletion(self):
86
86
        transform, root = self.get_transform()
87
87
        deletion_path = self._limbodir = urlutils.local_path_from_url(
88
 
            transform._tree._control_files.controlfilename('pending-deletion'))
 
88
            transform._tree._transport.abspath('pending-deletion'))
89
89
        os.mkdir(pathjoin(deletion_path, 'blocking-directory'))
90
90
        self.assertRaises(ImmortalPendingDeletion, transform.apply)
91
91
        self.assertRaises(LockError, self.wt.unlock)
747
747
        rename.set_executability(True, myfile)
748
748
        rename.apply()
749
749
 
750
 
    def test_find_interesting(self):
751
 
        create, root = self.get_transform()
752
 
        wt = create._tree
753
 
        create.new_file('vfile', root, 'myfile-text', 'myfile-id')
754
 
        create.new_file('uvfile', root, 'othertext')
755
 
        create.apply()
756
 
        result = self.applyDeprecated(symbol_versioning.zero_fifteen,
757
 
            find_interesting, wt, wt, ['vfile'])
758
 
        self.assertEqual(result, set(['myfile-id']))
759
 
 
760
750
    def test_set_executability_order(self):
761
751
        """Ensure that executability behaves the same, no matter what order.
762
752
        
836
826
        transform.apply()
837
827
        transform, root = self.get_transform()
838
828
        try:
839
 
            self.assertEqual([], list(transform._iter_changes()))
 
829
            self.assertEqual([], list(transform.iter_changes()))
840
830
            old = transform.trans_id_tree_file_id('id-1')
841
831
            transform.unversion_file(old)
842
832
            self.assertEqual([('id-1', ('old', None), False, (True, False),
843
833
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
844
 
                (True, True))], list(transform._iter_changes()))
 
834
                (True, True))], list(transform.iter_changes()))
845
835
            transform.new_directory('new', root, 'id-1')
846
836
            self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
847
837
                ('eert_toor', 'eert_toor'), ('old', 'new'),
848
838
                ('file', 'directory'),
849
 
                (True, False))], list(transform._iter_changes()))
 
839
                (True, False))], list(transform.iter_changes()))
850
840
        finally:
851
841
            transform.finalize()
852
842
 
861
851
            transform.version_file('id-1', old)
862
852
            self.assertEqual([('id-1', (None, 'old'), False, (False, True),
863
853
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
864
 
                (False, False))], list(transform._iter_changes()))
 
854
                (False, False))], list(transform.iter_changes()))
865
855
        finally:
866
856
            transform.finalize()
867
857
 
877
867
            old = transform.trans_id_tree_path('old')
878
868
            subdir = transform.trans_id_tree_file_id('subdir-id')
879
869
            new = transform.trans_id_tree_path('new')
880
 
            self.assertEqual([], list(transform._iter_changes()))
 
870
            self.assertEqual([], list(transform.iter_changes()))
881
871
 
882
872
            #content deletion
883
873
            transform.delete_contents(old)
884
874
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
885
875
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', None),
886
 
                (False, False))], list(transform._iter_changes()))
 
876
                (False, False))], list(transform.iter_changes()))
887
877
 
888
878
            #content change
889
879
            transform.create_file('blah', old)
890
880
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
891
881
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
892
 
                (False, False))], list(transform._iter_changes()))
 
882
                (False, False))], list(transform.iter_changes()))
893
883
            transform.cancel_deletion(old)
894
884
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
895
885
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
896
 
                (False, False))], list(transform._iter_changes()))
 
886
                (False, False))], list(transform.iter_changes()))
897
887
            transform.cancel_creation(old)
898
888
 
899
889
            # move file_id to a different file
900
 
            self.assertEqual([], list(transform._iter_changes()))
 
890
            self.assertEqual([], list(transform.iter_changes()))
901
891
            transform.unversion_file(old)
902
892
            transform.version_file('id-1', new)
903
893
            transform.adjust_path('old', root, new)
904
894
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
905
895
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
906
 
                (False, False))], list(transform._iter_changes()))
 
896
                (False, False))], list(transform.iter_changes()))
907
897
            transform.cancel_versioning(new)
908
898
            transform._removed_id = set()
909
899
 
910
900
            #execute bit
911
 
            self.assertEqual([], list(transform._iter_changes()))
 
901
            self.assertEqual([], list(transform.iter_changes()))
912
902
            transform.set_executability(True, old)
913
903
            self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
914
904
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
915
 
                (False, True))], list(transform._iter_changes()))
 
905
                (False, True))], list(transform.iter_changes()))
916
906
            transform.set_executability(None, old)
917
907
 
918
908
            # filename
919
 
            self.assertEqual([], list(transform._iter_changes()))
 
909
            self.assertEqual([], list(transform.iter_changes()))
920
910
            transform.adjust_path('new', root, old)
921
911
            transform._new_parent = {}
922
912
            self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
923
913
                ('eert_toor', 'eert_toor'), ('old', 'new'), ('file', 'file'),
924
 
                (False, False))], list(transform._iter_changes()))
 
914
                (False, False))], list(transform.iter_changes()))
925
915
            transform._new_name = {}
926
916
 
927
917
            # parent directory
928
 
            self.assertEqual([], list(transform._iter_changes()))
 
918
            self.assertEqual([], list(transform.iter_changes()))
929
919
            transform.adjust_path('new', subdir, old)
930
920
            transform._new_name = {}
931
921
            self.assertEqual([('id-1', ('old', 'subdir/old'), False,
932
922
                (True, True), ('eert_toor', 'subdir-id'), ('old', 'old'),
933
923
                ('file', 'file'), (False, False))],
934
 
                list(transform._iter_changes()))
 
924
                list(transform.iter_changes()))
935
925
            transform._new_path = {}
936
926
 
937
927
        finally:
959
949
                ('id-2', (u'file2', u'file2'), False, (True, True),
960
950
                ('eert_toor', 'eert_toor'), ('file2', u'file2'),
961
951
                ('file', 'file'), (False, True))],
962
 
                list(transform._iter_changes()))
 
952
                list(transform.iter_changes()))
963
953
        finally:
964
954
            transform.finalize()
965
955
 
979
969
            transform.adjust_path('flitter', root, floater)
980
970
            self.assertEqual([('floater-id', ('floater', 'flitter'), False,
981
971
            (True, True), ('toor_eert', 'toor_eert'), ('floater', 'flitter'),
982
 
            (None, None), (False, False))], list(transform._iter_changes()))
 
972
            (None, None), (False, False))], list(transform.iter_changes()))
983
973
        finally:
984
974
            transform.finalize()
985
975
 
994
984
        try:
995
985
            old = transform.trans_id_tree_path('old')
996
986
            subdir = transform.trans_id_tree_file_id('subdir-id')
997
 
            self.assertEqual([], list(transform._iter_changes()))
 
987
            self.assertEqual([], list(transform.iter_changes()))
998
988
            transform.delete_contents(subdir)
999
989
            transform.create_directory(subdir)
1000
990
            transform.set_executability(False, old)
1001
991
            transform.unversion_file(old)
1002
992
            transform.version_file('id-1', old)
1003
993
            transform.adjust_path('old', root, old)
1004
 
            self.assertEqual([], list(transform._iter_changes()))
 
994
            self.assertEqual([], list(transform.iter_changes()))
1005
995
        finally:
1006
996
            transform.finalize()
1007
997
 
1172
1162
        transform.cancel_creation(parent)
1173
1163
        transform.finalize()
1174
1164
 
1175
 
    def test_change_entry(self):
1176
 
        txt = 'bzrlib.transform.change_entry was deprecated in version 0.90.'
1177
 
        self.callDeprecated([txt], change_entry, None, None, None, None, None,
1178
 
            None, None, None)
1179
 
 
1180
1165
    def test_case_insensitive_clash(self):
1181
1166
        self.requireFeature(CaseInsensitiveFilesystemFeature)
1182
1167
        def tt_helper():
1617
1602
        self.assertEqual(['file1-id'], calls)
1618
1603
        target.lock_read()
1619
1604
        self.addCleanup(target.unlock)
1620
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1605
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1621
1606
 
1622
1607
    def test_build_tree_accelerator_tree_missing_file(self):
1623
1608
        source = self.create_ab_tree()
1630
1615
        build_tree(revision_tree, target, source)
1631
1616
        target.lock_read()
1632
1617
        self.addCleanup(target.unlock)
1633
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1618
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1634
1619
 
1635
1620
    def test_build_tree_accelerator_wrong_kind(self):
1636
1621
        self.requireFeature(SymlinkFeature)
1657
1642
        self.assertEqual([], calls)
1658
1643
        target.lock_read()
1659
1644
        self.addCleanup(target.unlock)
1660
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1645
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1661
1646
 
1662
1647
    def test_build_tree_hardlink(self):
1663
1648
        self.requireFeature(HardlinkFeature)
1669
1654
        build_tree(revision_tree, target, source, hardlink=True)
1670
1655
        target.lock_read()
1671
1656
        self.addCleanup(target.unlock)
1672
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1657
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1673
1658
        source_stat = os.stat('source/file1')
1674
1659
        target_stat = os.stat('target/file1')
1675
1660
        self.assertEqual(source_stat, target_stat)
1679
1664
        build_tree(revision_tree, target2, source, hardlink=False)
1680
1665
        target2.lock_read()
1681
1666
        self.addCleanup(target2.unlock)
1682
 
        self.assertEqual([], list(target2._iter_changes(revision_tree)))
 
1667
        self.assertEqual([], list(target2.iter_changes(revision_tree)))
1683
1668
        source_stat = os.stat('source/file1')
1684
1669
        target2_stat = os.stat('target2/file1')
1685
1670
        self.assertNotEqual(source_stat, target2_stat)
1699
1684
        build_tree(revision_tree, target, source)
1700
1685
        target.lock_read()
1701
1686
        self.addCleanup(target.unlock)
1702
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1687
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1703
1688
 
1704
1689
    def test_build_tree_hardlinks_preserve_execute(self):
1705
1690
        self.requireFeature(HardlinkFeature)
1716
1701
        build_tree(revision_tree, target, source, hardlink=True)
1717
1702
        target.lock_read()
1718
1703
        self.addCleanup(target.unlock)
1719
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1704
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1720
1705
        self.assertTrue(source.is_executable('file1-id'))
1721
1706
 
 
1707
    def test_case_insensitive_build_tree_inventory(self):
 
1708
        source = self.make_branch_and_tree('source')
 
1709
        self.build_tree(['source/file', 'source/FILE'])
 
1710
        source.add(['file', 'FILE'], ['lower-id', 'upper-id'])
 
1711
        source.commit('added files')
 
1712
        # Don't try this at home, kids!
 
1713
        # Force the tree to report that it is case insensitive
 
1714
        target = self.make_branch_and_tree('target')
 
1715
        target.case_sensitive = False
 
1716
        build_tree(source.basis_tree(), target, source, delta_from_tree=True)
 
1717
        self.assertEqual('file.moved', target.id2path('lower-id'))
 
1718
        self.assertEqual('FILE', target.id2path('upper-id'))
 
1719
 
1722
1720
 
1723
1721
class MockTransform(object):
1724
1722
 
1955
1953
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
1956
1954
                          (root, root), ('a', 'a'), ('file', 'file'),
1957
1955
                          (False, False))],
1958
 
                          list(preview_tree._iter_changes(revision_tree)))
 
1956
                          list(preview_tree.iter_changes(revision_tree)))
1959
1957
 
1960
1958
    def test_wrong_tree_value_error(self):
1961
1959
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1962
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1960
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1963
1961
                              preview_tree)
1964
1962
        self.assertEqual('from_tree must be transform source tree.', str(e))
1965
1963
 
1966
1964
    def test_include_unchanged_value_error(self):
1967
1965
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1968
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1966
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1969
1967
                              revision_tree, include_unchanged=True)
1970
1968
        self.assertEqual('include_unchanged is not supported', str(e))
1971
1969
 
1972
1970
    def test_specific_files(self):
1973
1971
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1974
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1972
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1975
1973
                              revision_tree, specific_files=['pete'])
1976
1974
        self.assertEqual('specific_files is not supported', str(e))
1977
1975
 
1978
1976
    def test_want_unversioned_value_error(self):
1979
1977
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1980
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1978
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1981
1979
                              revision_tree, want_unversioned=True)
1982
1980
        self.assertEqual('want_unversioned is not supported', str(e))
1983
1981
 
1985
1983
        # extra_trees is harmless without specific_files, so we'll silently
1986
1984
        # accept it, even though we won't use it.
1987
1985
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1988
 
        preview_tree._iter_changes(revision_tree, extra_trees=[preview_tree])
 
1986
        preview_tree.iter_changes(revision_tree, extra_trees=[preview_tree])
1989
1987
 
1990
1988
    def test_ignore_require_versioned_no_specific_files(self):
1991
1989
        # require_versioned is meaningless without specific_files.
1992
1990
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1993
 
        preview_tree._iter_changes(revision_tree, require_versioned=False)
 
1991
        preview_tree.iter_changes(revision_tree, require_versioned=False)
1994
1992
 
1995
1993
    def test_ignore_pb(self):
1996
1994
        # pb could be supported, but TT.iter_changes doesn't support it.
1997
1995
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1998
 
        preview_tree._iter_changes(revision_tree, pb=progress.DummyProgress())
 
1996
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
1999
1997
 
2000
1998
    def test_kind(self):
2001
1999
        revision_tree = self.create_tree()