/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

  • Committer: Aaron Bentley
  • Date: 2008-02-24 16:42:13 UTC
  • mfrom: (3234 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3235.
  • Revision ID: aaron@aaronbentley.com-20080224164213-eza1lzru5bwuwmmj
Merge with bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
16
16
 
17
17
import os
18
18
import stat
 
19
from StringIO import StringIO
19
20
import sys
20
21
 
21
22
from bzrlib import (
22
23
    errors,
23
24
    generate_ids,
 
25
    osutils,
 
26
    progress,
 
27
    revision as _mod_revision,
24
28
    symbol_versioning,
25
29
    tests,
26
30
    urlutils,
27
31
    )
28
32
from bzrlib.bzrdir import BzrDir
29
33
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
30
 
                              UnversionedParent, ParentLoop, DeletingParent,)
 
34
                              UnversionedParent, ParentLoop, DeletingParent,
 
35
                              NonDirectoryParent)
 
36
from bzrlib.diff import show_diff_trees
31
37
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
32
38
                           ReusingTransform, CantMoveRoot, 
33
39
                           PathsNotVersionedError, ExistingLimbo,
46
52
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths, 
47
53
                              resolve_conflicts, cook_conflicts, 
48
54
                              find_interesting, build_tree, get_backup_name,
49
 
                              change_entry, _FileMover, resolve_checkout)
50
 
 
 
55
                              change_entry, _FileMover, resolve_checkout,
 
56
                              TransformPreview)
51
57
 
52
58
class TestTreeTransform(tests.TestCaseWithTransport):
53
59
 
266
272
        transform.new_file('FiLe', transform.root, 'content')
267
273
        result = transform.find_conflicts()
268
274
        self.assertEqual([], result)
 
275
        transform.finalize()
269
276
        # Force the tree to report that it is case insensitive, for conflict
270
277
        # generation tests
271
278
        tree.case_sensitive = False
 
279
        transform = TreeTransform(tree)
 
280
        self.addCleanup(transform.finalize)
 
281
        transform.new_file('file', transform.root, 'content')
 
282
        transform.new_file('FiLe', transform.root, 'content')
272
283
        result = transform.find_conflicts()
273
284
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
274
285
 
284
295
        transform.new_file('file', transform.root, 'content')
285
296
        result = transform.find_conflicts()
286
297
        self.assertEqual([], result)
 
298
        transform.finalize()
287
299
        # Force the tree to report that it is case insensitive, for conflict
288
300
        # generation tests
289
301
        tree.case_sensitive = False
 
302
        transform = TreeTransform(tree)
 
303
        self.addCleanup(transform.finalize)
 
304
        transform.new_file('file', transform.root, 'content')
290
305
        result = transform.find_conflicts()
291
306
        self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
292
307
 
639
654
        self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
640
655
                                         ' oz/emeraldcity.  Cancelled move.')
641
656
 
 
657
    def prepare_wrong_parent_kind(self):
 
658
        tt, root = self.get_transform()
 
659
        tt.new_file('parent', root, 'contents', 'parent-id')
 
660
        tt.apply()
 
661
        tt, root = self.get_transform()
 
662
        parent_id = tt.trans_id_file_id('parent-id')
 
663
        tt.new_file('child,', parent_id, 'contents2', 'file-id')
 
664
        return tt
 
665
 
 
666
    def test_find_conflicts_wrong_parent_kind(self):
 
667
        tt = self.prepare_wrong_parent_kind()
 
668
        tt.find_conflicts()
 
669
 
 
670
    def test_resolve_conflicts_wrong_existing_parent_kind(self):
 
671
        tt = self.prepare_wrong_parent_kind()
 
672
        raw_conflicts = resolve_conflicts(tt)
 
673
        self.assertEqual(set([('non-directory parent', 'Created directory',
 
674
                         'new-3')]), raw_conflicts)
 
675
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
 
676
        self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
 
677
        'parent-id')], cooked_conflicts)
 
678
        tt.apply()
 
679
        self.assertEqual(None, self.wt.path2id('parent'))
 
680
        self.assertEqual('parent-id', self.wt.path2id('parent.new'))
 
681
 
 
682
    def test_resolve_conflicts_wrong_new_parent_kind(self):
 
683
        tt, root = self.get_transform()
 
684
        parent_id = tt.new_directory('parent', root, 'parent-id')
 
685
        tt.new_file('child,', parent_id, 'contents2', 'file-id')
 
686
        tt.apply()
 
687
        tt, root = self.get_transform()
 
688
        parent_id = tt.trans_id_file_id('parent-id')
 
689
        tt.delete_contents(parent_id)
 
690
        tt.create_file('contents', parent_id)
 
691
        raw_conflicts = resolve_conflicts(tt)
 
692
        self.assertEqual(set([('non-directory parent', 'Created directory',
 
693
                         'new-3')]), raw_conflicts)
 
694
        tt.apply()
 
695
        self.assertEqual(None, self.wt.path2id('parent'))
 
696
        self.assertEqual('parent-id', self.wt.path2id('parent.new'))
 
697
 
 
698
    def test_resolve_conflicts_wrong_parent_kind_unversioned(self):
 
699
        tt, root = self.get_transform()
 
700
        parent_id = tt.new_directory('parent', root)
 
701
        tt.new_file('child,', parent_id, 'contents2')
 
702
        tt.apply()
 
703
        tt, root = self.get_transform()
 
704
        parent_id = tt.trans_id_tree_path('parent')
 
705
        tt.delete_contents(parent_id)
 
706
        tt.create_file('contents', parent_id)
 
707
        resolve_conflicts(tt)
 
708
        tt.apply()
 
709
        self.assertIs(None, self.wt.path2id('parent'))
 
710
        self.assertIs(None, self.wt.path2id('parent.new'))
 
711
 
642
712
    def test_moving_versioned_directories(self):
643
713
        create, root = self.get_transform()
644
714
        kansas = create.new_directory('kansas', root, 'kansas-id')
719
789
        transform, root = self.get_transform()
720
790
        transform.new_file('file1', root, 'contents', 'file1-id', True)
721
791
        transform.apply()
 
792
        self.wt.lock_write()
 
793
        self.addCleanup(self.wt.unlock)
722
794
        self.assertTrue(self.wt.is_executable('file1-id'))
723
795
        transform, root = self.get_transform()
724
796
        file1_id = transform.trans_id_tree_file_id('file1-id')
1177
1249
 
1178
1250
 
1179
1251
class TestTransformMerge(TestCaseInTempDir):
 
1252
 
1180
1253
    def test_text_merge(self):
1181
1254
        root_id = generate_ids.gen_root_id()
1182
1255
        base = TransformGroup("base", root_id)
1212
1285
        this.tt.new_file('i', this.root, '1\n2\n3\n4\n', 'i')
1213
1286
        this.tt.apply()
1214
1287
        Merge3Merger(this.wt, this.wt, base.wt, other.wt)
 
1288
 
1215
1289
        # textual merge
1216
1290
        self.assertEqual(this.wt.get_file('a').read(), 'y\nb\nc\nd\bz\n')
1217
1291
        # three-way text conflict
1559
1633
        self.assertEqual([], list(target._iter_changes(revision_tree)))
1560
1634
 
1561
1635
    def test_build_tree_accelerator_wrong_kind(self):
 
1636
        self.requireFeature(SymlinkFeature)
1562
1637
        source = self.make_branch_and_tree('source')
1563
1638
        self.build_tree_contents([('source/file1', '')])
1564
1639
        self.build_tree_contents([('source/file2', '')])
1803
1878
        parent = tt.trans_id_file_id('parent-id')
1804
1879
        tt.new_file('file', parent, 'Contents')
1805
1880
        resolve_conflicts(tt)
 
1881
 
 
1882
 
 
1883
class TestTransformPreview(tests.TestCaseWithTransport):
 
1884
 
 
1885
    def create_tree(self):
 
1886
        tree = self.make_branch_and_tree('.')
 
1887
        self.build_tree_contents([('a', 'content 1')])
 
1888
        tree.add('a', 'a-id')
 
1889
        tree.commit('rev1', rev_id='rev1')
 
1890
        return tree.branch.repository.revision_tree('rev1')
 
1891
 
 
1892
    def get_empty_preview(self):
 
1893
        repository = self.make_repository('repo')
 
1894
        tree = repository.revision_tree(_mod_revision.NULL_REVISION)
 
1895
        preview = TransformPreview(tree)
 
1896
        self.addCleanup(preview.finalize)
 
1897
        return preview
 
1898
 
 
1899
    def test_transform_preview(self):
 
1900
        revision_tree = self.create_tree()
 
1901
        preview = TransformPreview(revision_tree)
 
1902
        self.addCleanup(preview.finalize)
 
1903
 
 
1904
    def test_transform_preview_tree(self):
 
1905
        revision_tree = self.create_tree()
 
1906
        preview = TransformPreview(revision_tree)
 
1907
        self.addCleanup(preview.finalize)
 
1908
        preview.get_preview_tree()
 
1909
 
 
1910
    def test_transform_new_file(self):
 
1911
        revision_tree = self.create_tree()
 
1912
        preview = TransformPreview(revision_tree)
 
1913
        self.addCleanup(preview.finalize)
 
1914
        preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
 
1915
        preview_tree = preview.get_preview_tree()
 
1916
        self.assertEqual(preview_tree.kind('file2-id'), 'file')
 
1917
        self.assertEqual(
 
1918
            preview_tree.get_file('file2-id').read(), 'content B\n')
 
1919
 
 
1920
    def test_diff_preview_tree(self):
 
1921
        revision_tree = self.create_tree()
 
1922
        preview = TransformPreview(revision_tree)
 
1923
        self.addCleanup(preview.finalize)
 
1924
        preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
 
1925
        preview_tree = preview.get_preview_tree()
 
1926
        out = StringIO()
 
1927
        show_diff_trees(revision_tree, preview_tree, out)
 
1928
        lines = out.getvalue().splitlines()
 
1929
        self.assertEqual(lines[0], "=== added file 'file2'")
 
1930
        # 3 lines of diff administrivia
 
1931
        self.assertEqual(lines[4], "+content B")
 
1932
 
 
1933
    def test_transform_conflicts(self):
 
1934
        revision_tree = self.create_tree()
 
1935
        preview = TransformPreview(revision_tree)
 
1936
        self.addCleanup(preview.finalize)
 
1937
        preview.new_file('a', preview.root, 'content 2')
 
1938
        resolve_conflicts(preview)
 
1939
        trans_id = preview.trans_id_file_id('a-id')
 
1940
        self.assertEqual('a.moved', preview.final_name(trans_id))
 
1941
 
 
1942
    def get_tree_and_preview_tree(self):
 
1943
        revision_tree = self.create_tree()
 
1944
        preview = TransformPreview(revision_tree)
 
1945
        self.addCleanup(preview.finalize)
 
1946
        a_trans_id = preview.trans_id_file_id('a-id')
 
1947
        preview.delete_contents(a_trans_id)
 
1948
        preview.create_file('b content', a_trans_id)
 
1949
        preview_tree = preview.get_preview_tree()
 
1950
        return revision_tree, preview_tree
 
1951
 
 
1952
    def test_iter_changes(self):
 
1953
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1954
        root = revision_tree.inventory.root.file_id
 
1955
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
 
1956
                          (root, root), ('a', 'a'), ('file', 'file'),
 
1957
                          (False, False))],
 
1958
                          list(preview_tree._iter_changes(revision_tree)))
 
1959
 
 
1960
    def test_wrong_tree_value_error(self):
 
1961
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1962
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1963
                              preview_tree)
 
1964
        self.assertEqual('from_tree must be transform source tree.', str(e))
 
1965
 
 
1966
    def test_include_unchanged_value_error(self):
 
1967
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1968
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1969
                              revision_tree, include_unchanged=True)
 
1970
        self.assertEqual('include_unchanged is not supported', str(e))
 
1971
 
 
1972
    def test_specific_files(self):
 
1973
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1974
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1975
                              revision_tree, specific_files=['pete'])
 
1976
        self.assertEqual('specific_files is not supported', str(e))
 
1977
 
 
1978
    def test_want_unversioned_value_error(self):
 
1979
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1980
        e = self.assertRaises(ValueError, preview_tree._iter_changes,
 
1981
                              revision_tree, want_unversioned=True)
 
1982
        self.assertEqual('want_unversioned is not supported', str(e))
 
1983
 
 
1984
    def test_ignore_extra_trees_no_specific_files(self):
 
1985
        # extra_trees is harmless without specific_files, so we'll silently
 
1986
        # accept it, even though we won't use it.
 
1987
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1988
        preview_tree._iter_changes(revision_tree, extra_trees=[preview_tree])
 
1989
 
 
1990
    def test_ignore_require_versioned_no_specific_files(self):
 
1991
        # require_versioned is meaningless without specific_files.
 
1992
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1993
        preview_tree._iter_changes(revision_tree, require_versioned=False)
 
1994
 
 
1995
    def test_ignore_pb(self):
 
1996
        # pb could be supported, but TT.iter_changes doesn't support it.
 
1997
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
 
1998
        preview_tree._iter_changes(revision_tree, pb=progress.DummyProgress())
 
1999
 
 
2000
    def test_kind(self):
 
2001
        revision_tree = self.create_tree()
 
2002
        preview = TransformPreview(revision_tree)
 
2003
        self.addCleanup(preview.finalize)
 
2004
        preview.new_file('file', preview.root, 'contents', 'file-id')
 
2005
        preview.new_directory('directory', preview.root, 'dir-id')
 
2006
        preview_tree = preview.get_preview_tree()
 
2007
        self.assertEqual('file', preview_tree.kind('file-id'))
 
2008
        self.assertEqual('directory', preview_tree.kind('dir-id'))
 
2009
 
 
2010
    def test_get_file_mtime(self):
 
2011
        preview = self.get_empty_preview()
 
2012
        file_trans_id = preview.new_file('file', preview.root, 'contents',
 
2013
                                         'file-id')
 
2014
        limbo_path = preview._limbo_name(file_trans_id)
 
2015
        preview_tree = preview.get_preview_tree()
 
2016
        self.assertEqual(os.stat(limbo_path).st_mtime,
 
2017
                         preview_tree.get_file_mtime('file-id'))
 
2018
 
 
2019
    def test_get_file(self):
 
2020
        preview = self.get_empty_preview()
 
2021
        preview.new_file('file', preview.root, 'contents', 'file-id')
 
2022
        preview_tree = preview.get_preview_tree()
 
2023
        tree_file = preview_tree.get_file('file-id')
 
2024
        try:
 
2025
            self.assertEqual('contents', tree_file.read())
 
2026
        finally:
 
2027
            tree_file.close()
 
2028
 
 
2029
    def test_get_symlink_target(self):
 
2030
        self.requireFeature(SymlinkFeature)
 
2031
        preview = self.get_empty_preview()
 
2032
        preview.new_symlink('symlink', preview.root, 'target', 'symlink-id')
 
2033
        preview_tree = preview.get_preview_tree()
 
2034
        self.assertEqual('target',
 
2035
                         preview_tree.get_symlink_target('symlink-id'))