← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-03-10 23:39:45 UTC
  • mfrom: (3254.1.4 public-iter-changes)
  • Revision ID: pqm@pqm.ubuntu.com-20080310233945-ed3k1rc4g1p9qcpj
Make Tree.iter_changes a public method (abentley)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
836
836
        transform.apply()
837
837
        transform, root = self.get_transform()
838
838
        try:
839
 
            self.assertEqual([], list(transform._iter_changes()))
 
839
            self.assertEqual([], list(transform.iter_changes()))
840
840
            old = transform.trans_id_tree_file_id('id-1')
841
841
            transform.unversion_file(old)
842
842
            self.assertEqual([('id-1', ('old', None), False, (True, False),
843
843
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
844
 
                (True, True))], list(transform._iter_changes()))
 
844
                (True, True))], list(transform.iter_changes()))
845
845
            transform.new_directory('new', root, 'id-1')
846
846
            self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
847
847
                ('eert_toor', 'eert_toor'), ('old', 'new'),
848
848
                ('file', 'directory'),
849
 
                (True, False))], list(transform._iter_changes()))
 
849
                (True, False))], list(transform.iter_changes()))
850
850
        finally:
851
851
            transform.finalize()
852
852
 
861
861
            transform.version_file('id-1', old)
862
862
            self.assertEqual([('id-1', (None, 'old'), False, (False, True),
863
863
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
864
 
                (False, False))], list(transform._iter_changes()))
 
864
                (False, False))], list(transform.iter_changes()))
865
865
        finally:
866
866
            transform.finalize()
867
867
 
877
877
            old = transform.trans_id_tree_path('old')
878
878
            subdir = transform.trans_id_tree_file_id('subdir-id')
879
879
            new = transform.trans_id_tree_path('new')
880
 
            self.assertEqual([], list(transform._iter_changes()))
 
880
            self.assertEqual([], list(transform.iter_changes()))
881
881
 
882
882
            #content deletion
883
883
            transform.delete_contents(old)
884
884
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
885
885
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', None),
886
 
                (False, False))], list(transform._iter_changes()))
 
886
                (False, False))], list(transform.iter_changes()))
887
887
 
888
888
            #content change
889
889
            transform.create_file('blah', old)
890
890
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
891
891
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
892
 
                (False, False))], list(transform._iter_changes()))
 
892
                (False, False))], list(transform.iter_changes()))
893
893
            transform.cancel_deletion(old)
894
894
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
895
895
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
896
 
                (False, False))], list(transform._iter_changes()))
 
896
                (False, False))], list(transform.iter_changes()))
897
897
            transform.cancel_creation(old)
898
898
 
899
899
            # move file_id to a different file
900
 
            self.assertEqual([], list(transform._iter_changes()))
 
900
            self.assertEqual([], list(transform.iter_changes()))
901
901
            transform.unversion_file(old)
902
902
            transform.version_file('id-1', new)
903
903
            transform.adjust_path('old', root, new)
904
904
            self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
905
905
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
906
 
                (False, False))], list(transform._iter_changes()))
 
906
                (False, False))], list(transform.iter_changes()))
907
907
            transform.cancel_versioning(new)
908
908
            transform._removed_id = set()
909
909
 
910
910
            #execute bit
911
 
            self.assertEqual([], list(transform._iter_changes()))
 
911
            self.assertEqual([], list(transform.iter_changes()))
912
912
            transform.set_executability(True, old)
913
913
            self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
914
914
                ('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
915
 
                (False, True))], list(transform._iter_changes()))
 
915
                (False, True))], list(transform.iter_changes()))
916
916
            transform.set_executability(None, old)
917
917
 
918
918
            # filename
919
 
            self.assertEqual([], list(transform._iter_changes()))
 
919
            self.assertEqual([], list(transform.iter_changes()))
920
920
            transform.adjust_path('new', root, old)
921
921
            transform._new_parent = {}
922
922
            self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
923
923
                ('eert_toor', 'eert_toor'), ('old', 'new'), ('file', 'file'),
924
 
                (False, False))], list(transform._iter_changes()))
 
924
                (False, False))], list(transform.iter_changes()))
925
925
            transform._new_name = {}
926
926
 
927
927
            # parent directory
928
 
            self.assertEqual([], list(transform._iter_changes()))
 
928
            self.assertEqual([], list(transform.iter_changes()))
929
929
            transform.adjust_path('new', subdir, old)
930
930
            transform._new_name = {}
931
931
            self.assertEqual([('id-1', ('old', 'subdir/old'), False,
932
932
                (True, True), ('eert_toor', 'subdir-id'), ('old', 'old'),
933
933
                ('file', 'file'), (False, False))],
934
 
                list(transform._iter_changes()))
 
934
                list(transform.iter_changes()))
935
935
            transform._new_path = {}
936
936
 
937
937
        finally:
959
959
                ('id-2', (u'file2', u'file2'), False, (True, True),
960
960
                ('eert_toor', 'eert_toor'), ('file2', u'file2'),
961
961
                ('file', 'file'), (False, True))],
962
 
                list(transform._iter_changes()))
 
962
                list(transform.iter_changes()))
963
963
        finally:
964
964
            transform.finalize()
965
965
 
979
979
            transform.adjust_path('flitter', root, floater)
980
980
            self.assertEqual([('floater-id', ('floater', 'flitter'), False,
981
981
            (True, True), ('toor_eert', 'toor_eert'), ('floater', 'flitter'),
982
 
            (None, None), (False, False))], list(transform._iter_changes()))
 
982
            (None, None), (False, False))], list(transform.iter_changes()))
983
983
        finally:
984
984
            transform.finalize()
985
985
 
994
994
        try:
995
995
            old = transform.trans_id_tree_path('old')
996
996
            subdir = transform.trans_id_tree_file_id('subdir-id')
997
 
            self.assertEqual([], list(transform._iter_changes()))
 
997
            self.assertEqual([], list(transform.iter_changes()))
998
998
            transform.delete_contents(subdir)
999
999
            transform.create_directory(subdir)
1000
1000
            transform.set_executability(False, old)
1001
1001
            transform.unversion_file(old)
1002
1002
            transform.version_file('id-1', old)
1003
1003
            transform.adjust_path('old', root, old)
1004
 
            self.assertEqual([], list(transform._iter_changes()))
 
1004
            self.assertEqual([], list(transform.iter_changes()))
1005
1005
        finally:
1006
1006
            transform.finalize()
1007
1007
 
1617
1617
        self.assertEqual(['file1-id'], calls)
1618
1618
        target.lock_read()
1619
1619
        self.addCleanup(target.unlock)
1620
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1620
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1621
1621
 
1622
1622
    def test_build_tree_accelerator_tree_missing_file(self):
1623
1623
        source = self.create_ab_tree()
1630
1630
        build_tree(revision_tree, target, source)
1631
1631
        target.lock_read()
1632
1632
        self.addCleanup(target.unlock)
1633
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1633
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1634
1634
 
1635
1635
    def test_build_tree_accelerator_wrong_kind(self):
1636
1636
        self.requireFeature(SymlinkFeature)
1657
1657
        self.assertEqual([], calls)
1658
1658
        target.lock_read()
1659
1659
        self.addCleanup(target.unlock)
1660
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1660
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1661
1661
 
1662
1662
    def test_build_tree_hardlink(self):
1663
1663
        self.requireFeature(HardlinkFeature)
1669
1669
        build_tree(revision_tree, target, source, hardlink=True)
1670
1670
        target.lock_read()
1671
1671
        self.addCleanup(target.unlock)
1672
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1672
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1673
1673
        source_stat = os.stat('source/file1')
1674
1674
        target_stat = os.stat('target/file1')
1675
1675
        self.assertEqual(source_stat, target_stat)
1679
1679
        build_tree(revision_tree, target2, source, hardlink=False)
1680
1680
        target2.lock_read()
1681
1681
        self.addCleanup(target2.unlock)
1682
 
        self.assertEqual([], list(target2._iter_changes(revision_tree)))
 
1682
        self.assertEqual([], list(target2.iter_changes(revision_tree)))
1683
1683
        source_stat = os.stat('source/file1')
1684
1684
        target2_stat = os.stat('target2/file1')
1685
1685
        self.assertNotEqual(source_stat, target2_stat)
1699
1699
        build_tree(revision_tree, target, source)
1700
1700
        target.lock_read()
1701
1701
        self.addCleanup(target.unlock)
1702
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1702
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1703
1703
 
1704
1704
    def test_build_tree_hardlinks_preserve_execute(self):
1705
1705
        self.requireFeature(HardlinkFeature)
1716
1716
        build_tree(revision_tree, target, source, hardlink=True)
1717
1717
        target.lock_read()
1718
1718
        self.addCleanup(target.unlock)
1719
 
        self.assertEqual([], list(target._iter_changes(revision_tree)))
 
1719
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1720
1720
        self.assertTrue(source.is_executable('file1-id'))
1721
1721
 
1722
1722
 
1955
1955
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
1956
1956
                          (root, root), ('a', 'a'), ('file', 'file'),
1957
1957
                          (False, False))],
1958
 
                          list(preview_tree._iter_changes(revision_tree)))
 
1958
                          list(preview_tree.iter_changes(revision_tree)))
1959
1959
 
1960
1960
    def test_wrong_tree_value_error(self):
1961
1961
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1962
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1962
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1963
1963
                              preview_tree)
1964
1964
        self.assertEqual('from_tree must be transform source tree.', str(e))
1965
1965
 
1966
1966
    def test_include_unchanged_value_error(self):
1967
1967
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1968
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1968
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1969
1969
                              revision_tree, include_unchanged=True)
1970
1970
        self.assertEqual('include_unchanged is not supported', str(e))
1971
1971
 
1972
1972
    def test_specific_files(self):
1973
1973
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1974
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1974
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1975
1975
                              revision_tree, specific_files=['pete'])
1976
1976
        self.assertEqual('specific_files is not supported', str(e))
1977
1977
 
1978
1978
    def test_want_unversioned_value_error(self):
1979
1979
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1980
 
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1980
        e = self.assertRaises(ValueError, preview_tree.iter_changes,
1981
1981
                              revision_tree, want_unversioned=True)
1982
1982
        self.assertEqual('want_unversioned is not supported', str(e))
1983
1983
 
1985
1985
        # extra_trees is harmless without specific_files, so we'll silently
1986
1986
        # accept it, even though we won't use it.
1987
1987
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1988
 
        preview_tree._iter_changes(revision_tree, extra_trees=[preview_tree])
 
1988
        preview_tree.iter_changes(revision_tree, extra_trees=[preview_tree])
1989
1989
 
1990
1990
    def test_ignore_require_versioned_no_specific_files(self):
1991
1991
        # require_versioned is meaningless without specific_files.
1992
1992
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1993
 
        preview_tree._iter_changes(revision_tree, require_versioned=False)
 
1993
        preview_tree.iter_changes(revision_tree, require_versioned=False)
1994
1994
 
1995
1995
    def test_ignore_pb(self):
1996
1996
        # pb could be supported, but TT.iter_changes doesn't support it.
1997
1997
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
1998
 
        preview_tree._iter_changes(revision_tree, pb=progress.DummyProgress())
 
1998
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
1999
1999
 
2000
2000
    def test_kind(self):
2001
2001
        revision_tree = self.create_tree()