/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: Vincent Ladeuil
  • Date: 2009-07-10 12:40:36 UTC
  • mfrom: (4523.1.5 per-tests)
  • mto: This revision was merged to the branch mainline in revision 4526.
  • Revision ID: v.ladeuil+lp@free.fr-20090710124036-enqp2kri098c24ub
Finish the *_implementation to per_* test renaming

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
import os
 
18
import stat
18
19
from StringIO import StringIO
19
20
import sys
20
 
import time
21
21
 
22
22
from bzrlib import (
23
23
    bencode,
24
24
    errors,
25
 
    filters,
26
25
    generate_ids,
27
26
    osutils,
 
27
    progress,
28
28
    revision as _mod_revision,
29
 
    rules,
 
29
    symbol_versioning,
30
30
    tests,
31
31
    urlutils,
32
32
    )
33
33
from bzrlib.bzrdir import BzrDir
34
 
from bzrlib.conflicts import (
35
 
    DeletingParent,
36
 
    DuplicateEntry,
37
 
    DuplicateID,
38
 
    MissingParent,
39
 
    NonDirectoryParent,
40
 
    ParentLoop,
41
 
    UnversionedParent,
42
 
)
 
34
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
 
35
                              UnversionedParent, ParentLoop, DeletingParent,
 
36
                              NonDirectoryParent)
43
37
from bzrlib.diff import show_diff_trees
44
 
from bzrlib.errors import (
45
 
    DuplicateKey,
46
 
    ExistingLimbo,
47
 
    ExistingPendingDeletion,
48
 
    ImmortalLimbo,
49
 
    ImmortalPendingDeletion,
50
 
    LockError,
51
 
    MalformedTransform,
52
 
    NoSuchFile,
53
 
    ReusingTransform,
54
 
)
55
 
from bzrlib.osutils import (
56
 
    file_kind,
57
 
    pathjoin,
58
 
)
 
38
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
 
39
                           ReusingTransform, CantMoveRoot,
 
40
                           PathsNotVersionedError, ExistingLimbo,
 
41
                           ExistingPendingDeletion, ImmortalLimbo,
 
42
                           ImmortalPendingDeletion, LockError)
 
43
from bzrlib.osutils import file_kind, pathjoin
59
44
from bzrlib.merge import Merge3Merger, Merger
60
45
from bzrlib.tests import (
61
46
    HardlinkFeature,
63
48
    TestCase,
64
49
    TestCaseInTempDir,
65
50
    TestSkipped,
66
 
)
67
 
from bzrlib.transform import (
68
 
    build_tree,
69
 
    create_from_tree,
70
 
    cook_conflicts,
71
 
    _FileMover,
72
 
    FinalPaths,
73
 
    get_backup_name,
74
 
    resolve_conflicts,
75
 
    resolve_checkout,
76
 
    ROOT_PARENT,
77
 
    TransformPreview,
78
 
    TreeTransform,
79
 
)
 
51
    )
 
52
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths,
 
53
                              resolve_conflicts, cook_conflicts,
 
54
                              build_tree, get_backup_name,
 
55
                              _FileMover, resolve_checkout,
 
56
                              TransformPreview, create_from_tree)
80
57
 
81
58
 
82
59
class TestTreeTransform(tests.TestCaseWithTransport):
159
136
        transform.finalize()
160
137
        transform.finalize()
161
138
 
162
 
    def test_create_files_same_timestamp(self):
163
 
        transform, root = self.get_transform()
164
 
        self.wt.lock_tree_write()
165
 
        self.addCleanup(self.wt.unlock)
166
 
        # Roll back the clock, so that we know everything is being set to the
167
 
        # exact time
168
 
        transform._creation_mtime = creation_mtime = time.time() - 20.0
169
 
        transform.create_file('content-one',
170
 
                              transform.create_path('one', root))
171
 
        time.sleep(1) # *ugly*
172
 
        transform.create_file('content-two',
173
 
                              transform.create_path('two', root))
174
 
        transform.apply()
175
 
        fo, st1 = self.wt.get_file_with_stat(None, path='one', filtered=False)
176
 
        fo.close()
177
 
        fo, st2 = self.wt.get_file_with_stat(None, path='two', filtered=False)
178
 
        fo.close()
179
 
        # We only guarantee 2s resolution
180
 
        self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
181
 
            "%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
182
 
        # But if we have more than that, all files should get the same result
183
 
        self.assertEqual(st1.st_mtime, st2.st_mtime)
184
 
 
185
 
    def test_change_root_id(self):
186
 
        transform, root = self.get_transform()
187
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
188
 
        transform.new_directory('', ROOT_PARENT, 'new-root-id')
189
 
        transform.delete_contents(root)
190
 
        transform.unversion_file(root)
191
 
        transform.fixup_new_roots()
192
 
        transform.apply()
193
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
194
 
 
195
 
    def test_change_root_id_add_files(self):
196
 
        transform, root = self.get_transform()
197
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
198
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
199
 
        transform.new_file('file', new_trans_id, ['new-contents\n'],
200
 
                           'new-file-id')
201
 
        transform.delete_contents(root)
202
 
        transform.unversion_file(root)
203
 
        transform.fixup_new_roots()
204
 
        transform.apply()
205
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
206
 
        self.assertEqual('new-file-id', self.wt.path2id('file'))
207
 
        self.assertFileEqual('new-contents\n', self.wt.abspath('file'))
208
 
 
209
 
    def test_add_two_roots(self):
210
 
        transform, root = self.get_transform()
211
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
212
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
213
 
        self.assertRaises(ValueError, transform.fixup_new_roots)
214
 
 
215
139
    def test_hardlink(self):
216
140
        self.requireFeature(HardlinkFeature)
217
141
        transform, root = self.get_transform()
445
369
        self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
446
370
        self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
447
371
 
448
 
    def test_adjust_path_updates_child_limbo_names(self):
449
 
        tree = self.make_branch_and_tree('tree')
450
 
        transform = TreeTransform(tree)
451
 
        self.addCleanup(transform.finalize)
452
 
        foo_id = transform.new_directory('foo', transform.root)
453
 
        bar_id = transform.new_directory('bar', foo_id)
454
 
        baz_id = transform.new_directory('baz', bar_id)
455
 
        qux_id = transform.new_directory('qux', baz_id)
456
 
        transform.adjust_path('quxx', foo_id, bar_id)
457
 
        self.assertStartsWith(transform._limbo_name(qux_id),
458
 
                              transform._limbo_name(bar_id))
459
 
 
460
372
    def test_add_del(self):
461
373
        start, root = self.get_transform()
462
374
        start.new_directory('a', root, 'a')
757
669
                                         ' versioned, but has versioned'
758
670
                                         ' children.  Versioned directory.')
759
671
        self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
760
 
                                         ' oz/emeraldcity. Cancelled move.')
 
672
                                         ' oz/emeraldcity.  Cancelled move.')
761
673
 
762
674
    def prepare_wrong_parent_kind(self):
763
675
        tt, root = self.get_transform()
834
746
        create.apply()
835
747
        transform, root = self.get_transform()
836
748
        transform.adjust_root_path('oldroot', fun)
837
 
        new_root = transform.trans_id_tree_path('')
 
749
        new_root=transform.trans_id_tree_path('')
838
750
        transform.version_file('new-root', new_root)
839
751
        transform.apply()
840
752
 
852
764
        rename.set_executability(True, myfile)
853
765
        rename.apply()
854
766
 
855
 
    def test_rename_fails(self):
856
 
        # see https://bugs.launchpad.net/bzr/+bug/491763
857
 
        create, root_id = self.get_transform()
858
 
        first_dir = create.new_directory('first-dir', root_id, 'first-id')
859
 
        myfile = create.new_file('myfile', root_id, 'myfile-text',
860
 
                                 'myfile-id')
861
 
        create.apply()
862
 
        # make the file and directory readonly in the hope this will prevent
863
 
        # renames
864
 
        osutils.make_readonly(self.wt.abspath('first-dir'))
865
 
        osutils.make_readonly(self.wt.abspath('myfile'))
866
 
        # now transform to rename
867
 
        rename_transform, root_id = self.get_transform()
868
 
        file_trans_id = rename_transform.trans_id_file_id('myfile-id')
869
 
        dir_id = rename_transform.trans_id_file_id('first-id')
870
 
        rename_transform.adjust_path('newname', dir_id, file_trans_id)
871
 
        e = self.assertRaises(errors.TransformRenameFailed,
872
 
            rename_transform.apply)
873
 
        # Looks like: 
874
 
        # "Failed to rename .../work/.bzr/checkout/limbo/new-1
875
 
        # to .../first-dir/newname: [Errno 13] Permission denied"
876
 
        # so the first filename is not visible in it; we expect a strerror but
877
 
        # it may vary per OS and language so it's not checked here
878
 
        self.assertContainsRe(str(e),
879
 
            "Failed to rename .*first-dir.newname:")
880
 
 
881
767
    def test_set_executability_order(self):
882
768
        """Ensure that executability behaves the same, no matter what order.
883
769
 
1970
1856
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1971
1857
        self.assertTrue(source.is_executable('file1-id'))
1972
1858
 
1973
 
    def install_rot13_content_filter(self, pattern):
1974
 
        # We could use
1975
 
        # self.addCleanup(filters._reset_registry, filters._reset_registry())
1976
 
        # below, but that looks a bit... hard to read even if it's exactly
1977
 
        # the same thing.
1978
 
        original_registry = filters._reset_registry()
1979
 
        def restore_registry():
1980
 
            filters._reset_registry(original_registry)
1981
 
        self.addCleanup(restore_registry)
1982
 
        def rot13(chunks, context=None):
1983
 
            return [''.join(chunks).encode('rot13')]
1984
 
        rot13filter = filters.ContentFilter(rot13, rot13)
1985
 
        filters.register_filter_stack_map('rot13', {'yes': [rot13filter]}.get)
1986
 
        os.mkdir(self.test_home_dir + '/.bazaar')
1987
 
        rules_filename = self.test_home_dir + '/.bazaar/rules'
1988
 
        f = open(rules_filename, 'wb')
1989
 
        f.write('[name %s]\nrot13=yes\n' % (pattern,))
1990
 
        f.close()
1991
 
        def uninstall_rules():
1992
 
            os.remove(rules_filename)
1993
 
            rules.reset_rules()
1994
 
        self.addCleanup(uninstall_rules)
1995
 
        rules.reset_rules()
1996
 
 
1997
 
    def test_build_tree_content_filtered_files_are_not_hardlinked(self):
1998
 
        """build_tree will not hardlink files that have content filtering rules
1999
 
        applied to them (but will still hardlink other files from the same tree
2000
 
        if it can).
2001
 
        """
2002
 
        self.requireFeature(HardlinkFeature)
2003
 
        self.install_rot13_content_filter('file1')
2004
 
        source = self.create_ab_tree()
2005
 
        target = self.make_branch_and_tree('target')
2006
 
        revision_tree = source.basis_tree()
2007
 
        revision_tree.lock_read()
2008
 
        self.addCleanup(revision_tree.unlock)
2009
 
        build_tree(revision_tree, target, source, hardlink=True)
2010
 
        target.lock_read()
2011
 
        self.addCleanup(target.unlock)
2012
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2013
 
        source_stat = os.stat('source/file1')
2014
 
        target_stat = os.stat('target/file1')
2015
 
        self.assertNotEqual(source_stat, target_stat)
2016
 
        source_stat = os.stat('source/file2')
2017
 
        target_stat = os.stat('target/file2')
2018
 
        self.assertEqualStat(source_stat, target_stat)
2019
 
 
2020
1859
    def test_case_insensitive_build_tree_inventory(self):
2021
1860
        if (tests.CaseInsensitiveFilesystemFeature.available()
2022
1861
            or tests.CaseInsCasePresFilenameFeature.available()):
2034
1873
        self.assertEqual('FILE', target.id2path('upper-id'))
2035
1874
 
2036
1875
 
2037
 
class TestCommitTransform(tests.TestCaseWithTransport):
2038
 
 
2039
 
    def get_branch(self):
2040
 
        tree = self.make_branch_and_tree('tree')
2041
 
        tree.lock_write()
2042
 
        self.addCleanup(tree.unlock)
2043
 
        tree.commit('empty commit')
2044
 
        return tree.branch
2045
 
 
2046
 
    def get_branch_and_transform(self):
2047
 
        branch = self.get_branch()
2048
 
        tt = TransformPreview(branch.basis_tree())
2049
 
        self.addCleanup(tt.finalize)
2050
 
        return branch, tt
2051
 
 
2052
 
    def test_commit_wrong_basis(self):
2053
 
        branch = self.get_branch()
2054
 
        basis = branch.repository.revision_tree(
2055
 
            _mod_revision.NULL_REVISION)
2056
 
        tt = TransformPreview(basis)
2057
 
        self.addCleanup(tt.finalize)
2058
 
        e = self.assertRaises(ValueError, tt.commit, branch, '')
2059
 
        self.assertEqual('TreeTransform not based on branch basis: null:',
2060
 
                         str(e))
2061
 
 
2062
 
    def test_empy_commit(self):
2063
 
        branch, tt = self.get_branch_and_transform()
2064
 
        rev = tt.commit(branch, 'my message')
2065
 
        self.assertEqual(2, branch.revno())
2066
 
        repo = branch.repository
2067
 
        self.assertEqual('my message', repo.get_revision(rev).message)
2068
 
 
2069
 
    def test_merge_parents(self):
2070
 
        branch, tt = self.get_branch_and_transform()
2071
 
        rev = tt.commit(branch, 'my message', ['rev1b', 'rev1c'])
2072
 
        self.assertEqual(['rev1b', 'rev1c'],
2073
 
                         branch.basis_tree().get_parent_ids()[1:])
2074
 
 
2075
 
    def test_first_commit(self):
2076
 
        branch = self.make_branch('branch')
2077
 
        branch.lock_write()
2078
 
        self.addCleanup(branch.unlock)
2079
 
        tt = TransformPreview(branch.basis_tree())
2080
 
        self.addCleanup(tt.finalize)
2081
 
        tt.new_directory('', ROOT_PARENT, 'TREE_ROOT')
2082
 
        rev = tt.commit(branch, 'my message')
2083
 
        self.assertEqual([], branch.basis_tree().get_parent_ids())
2084
 
        self.assertNotEqual(_mod_revision.NULL_REVISION,
2085
 
                            branch.last_revision())
2086
 
 
2087
 
    def test_first_commit_with_merge_parents(self):
2088
 
        branch = self.make_branch('branch')
2089
 
        branch.lock_write()
2090
 
        self.addCleanup(branch.unlock)
2091
 
        tt = TransformPreview(branch.basis_tree())
2092
 
        self.addCleanup(tt.finalize)
2093
 
        e = self.assertRaises(ValueError, tt.commit, branch,
2094
 
                          'my message', ['rev1b-id'])
2095
 
        self.assertEqual('Cannot supply merge parents for first commit.',
2096
 
                         str(e))
2097
 
        self.assertEqual(_mod_revision.NULL_REVISION, branch.last_revision())
2098
 
 
2099
 
    def test_add_files(self):
2100
 
        branch, tt = self.get_branch_and_transform()
2101
 
        tt.new_file('file', tt.root, 'contents', 'file-id')
2102
 
        trans_id = tt.new_directory('dir', tt.root, 'dir-id')
2103
 
        if SymlinkFeature.available():
2104
 
            tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
2105
 
        rev = tt.commit(branch, 'message')
2106
 
        tree = branch.basis_tree()
2107
 
        self.assertEqual('file', tree.id2path('file-id'))
2108
 
        self.assertEqual('contents', tree.get_file_text('file-id'))
2109
 
        self.assertEqual('dir', tree.id2path('dir-id'))
2110
 
        if SymlinkFeature.available():
2111
 
            self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
2112
 
            self.assertEqual('target', tree.get_symlink_target('symlink-id'))
2113
 
 
2114
 
    def test_add_unversioned(self):
2115
 
        branch, tt = self.get_branch_and_transform()
2116
 
        tt.new_file('file', tt.root, 'contents')
2117
 
        self.assertRaises(errors.StrictCommitFailed, tt.commit, branch,
2118
 
                          'message', strict=True)
2119
 
 
2120
 
    def test_modify_strict(self):
2121
 
        branch, tt = self.get_branch_and_transform()
2122
 
        tt.new_file('file', tt.root, 'contents', 'file-id')
2123
 
        tt.commit(branch, 'message', strict=True)
2124
 
        tt = TransformPreview(branch.basis_tree())
2125
 
        self.addCleanup(tt.finalize)
2126
 
        trans_id = tt.trans_id_file_id('file-id')
2127
 
        tt.delete_contents(trans_id)
2128
 
        tt.create_file('contents', trans_id)
2129
 
        tt.commit(branch, 'message', strict=True)
2130
 
 
2131
 
    def test_commit_malformed(self):
2132
 
        """Committing a malformed transform should raise an exception.
2133
 
 
2134
 
        In this case, we are adding a file without adding its parent.
2135
 
        """
2136
 
        branch, tt = self.get_branch_and_transform()
2137
 
        parent_id = tt.trans_id_file_id('parent-id')
2138
 
        tt.new_file('file', parent_id, 'contents', 'file-id')
2139
 
        self.assertRaises(errors.MalformedTransform, tt.commit, branch,
2140
 
                          'message')
2141
 
 
2142
 
    def test_commit_rich_revision_data(self):
2143
 
        branch, tt = self.get_branch_and_transform()
2144
 
        rev_id = tt.commit(branch, 'message', timestamp=1, timezone=43201,
2145
 
                           committer='me <me@example.com>',
2146
 
                           revprops={'foo': 'bar'}, revision_id='revid-1',
2147
 
                           authors=['Author1 <author1@example.com>',
2148
 
                              'Author2 <author2@example.com>',
2149
 
                               ])
2150
 
        self.assertEqual('revid-1', rev_id)
2151
 
        revision = branch.repository.get_revision(rev_id)
2152
 
        self.assertEqual(1, revision.timestamp)
2153
 
        self.assertEqual(43201, revision.timezone)
2154
 
        self.assertEqual('me <me@example.com>', revision.committer)
2155
 
        self.assertEqual(['Author1 <author1@example.com>',
2156
 
                          'Author2 <author2@example.com>'],
2157
 
                         revision.get_apparent_authors())
2158
 
        del revision.properties['authors']
2159
 
        self.assertEqual({'foo': 'bar',
2160
 
                          'branch-nick': 'tree'},
2161
 
                         revision.properties)
2162
 
 
2163
 
    def test_no_explicit_revprops(self):
2164
 
        branch, tt = self.get_branch_and_transform()
2165
 
        rev_id = tt.commit(branch, 'message', authors=[
2166
 
            'Author1 <author1@example.com>',
2167
 
            'Author2 <author2@example.com>', ])
2168
 
        revision = branch.repository.get_revision(rev_id)
2169
 
        self.assertEqual(['Author1 <author1@example.com>',
2170
 
                          'Author2 <author2@example.com>'],
2171
 
                         revision.get_apparent_authors())
2172
 
        self.assertEqual('tree', revision.properties['branch-nick'])
2173
 
 
2174
 
 
2175
1876
class MockTransform(object):
2176
1877
 
2177
1878
    def has_named_child(self, by_parent, parent_id, name):
2344
2045
    def create_tree(self):
2345
2046
        tree = self.make_branch_and_tree('.')
2346
2047
        self.build_tree_contents([('a', 'content 1')])
2347
 
        tree.set_root_id('TREE_ROOT')
2348
2048
        tree.add('a', 'a-id')
2349
2049
        tree.commit('rev1', rev_id='rev1')
2350
2050
        return tree.branch.repository.revision_tree('rev1')
2451
2151
    def test_ignore_pb(self):
2452
2152
        # pb could be supported, but TT.iter_changes doesn't support it.
2453
2153
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2454
 
        preview_tree.iter_changes(revision_tree)
 
2154
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
2455
2155
 
2456
2156
    def test_kind(self):
2457
2157
        revision_tree = self.create_tree()
2472
2172
        self.assertEqual(os.stat(limbo_path).st_mtime,
2473
2173
                         preview_tree.get_file_mtime('file-id'))
2474
2174
 
2475
 
    def test_get_file_mtime_renamed(self):
2476
 
        work_tree = self.make_branch_and_tree('tree')
2477
 
        self.build_tree(['tree/file'])
2478
 
        work_tree.add('file', 'file-id')
2479
 
        preview = TransformPreview(work_tree)
2480
 
        self.addCleanup(preview.finalize)
2481
 
        file_trans_id = preview.trans_id_tree_file_id('file-id')
2482
 
        preview.adjust_path('renamed', preview.root, file_trans_id)
2483
 
        preview_tree = preview.get_preview_tree()
2484
 
        preview_mtime = preview_tree.get_file_mtime('file-id', 'renamed')
2485
 
        work_mtime = work_tree.get_file_mtime('file-id', 'file')
2486
 
 
2487
2175
    def test_get_file(self):
2488
2176
        preview = self.get_empty_preview()
2489
2177
        preview.new_file('file', preview.root, 'contents', 'file-id')
2637
2325
        self.assertEqual(('missing', None, None, None), summary)
2638
2326
 
2639
2327
    def test_file_content_summary_executable(self):
 
2328
        if not osutils.supports_executable():
 
2329
            raise TestNotApplicable()
2640
2330
        preview = self.get_empty_preview()
2641
2331
        path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
2642
2332
        preview.set_executability(True, path_id)
2651
2341
        self.assertIs(None, summary[3])
2652
2342
 
2653
2343
    def test_change_executability(self):
 
2344
        if not osutils.supports_executable():
 
2345
            raise TestNotApplicable()
2654
2346
        tree = self.make_branch_and_tree('tree')
2655
2347
        self.build_tree(['tree/path'])
2656
2348
        tree.add('path')
2670
2362
        # size must be known
2671
2363
        self.assertEqual(len('contents'), summary[1])
2672
2364
        # not executable
2673
 
        self.assertEqual(False, summary[2])
 
2365
        if osutils.supports_executable():
 
2366
            self.assertEqual(False, summary[2])
 
2367
        else:
 
2368
            self.assertEqual(None, summary[2])
2674
2369
        # will not have hash (not cheap to determine)
2675
2370
        self.assertIs(None, summary[3])
2676
2371
 
2817
2512
 
2818
2513
    def test_walkdirs(self):
2819
2514
        preview = self.get_empty_preview()
2820
 
        root = preview.new_directory('', ROOT_PARENT, 'tree-root')
2821
 
        # FIXME: new_directory should mark root.
2822
 
        preview.fixup_new_roots()
 
2515
        preview.version_file('tree-root', preview.root)
2823
2516
        preview_tree = preview.get_preview_tree()
2824
2517
        file_trans_id = preview.new_file('a', preview.root, 'contents',
2825
2518
                                         'a-id')
2856
2549
        self.addCleanup(work_tree.unlock)
2857
2550
        preview = TransformPreview(work_tree)
2858
2551
        self.addCleanup(preview.finalize)
 
2552
        preview_tree = preview.get_preview_tree()
2859
2553
        file_trans_id = preview.trans_id_file_id('file-id')
2860
2554
        preview.delete_contents(file_trans_id)
2861
2555
        preview.create_file('a\nb\n', file_trans_id)
2862
 
        preview_tree = preview.get_preview_tree()
2863
 
        merger = Merger.from_revision_ids(None, preview_tree,
 
2556
        pb = progress.DummyProgress()
 
2557
        merger = Merger.from_revision_ids(pb, preview_tree,
2864
2558
                                          child_tree.branch.last_revision(),
2865
2559
                                          other_branch=child_tree.branch,
2866
2560
                                          tree_branch=work_tree.branch)
2872
2566
 
2873
2567
    def test_merge_preview_into_workingtree(self):
2874
2568
        tree = self.make_branch_and_tree('tree')
2875
 
        tree.set_root_id('TREE_ROOT')
2876
2569
        tt = TransformPreview(tree)
2877
2570
        self.addCleanup(tt.finalize)
2878
2571
        tt.new_file('name', tt.root, 'content', 'file-id')
2879
2572
        tree2 = self.make_branch_and_tree('tree2')
2880
 
        tree2.set_root_id('TREE_ROOT')
 
2573
        pb = progress.DummyProgress()
2881
2574
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
2882
 
                                         None, tree.basis_tree())
 
2575
                                         pb, tree.basis_tree())
2883
2576
        merger.merge_type = Merge3Merger
2884
2577
        merger.do_merge()
2885
2578
 
2895
2588
        tt.create_file('baz', trans_id)
2896
2589
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
2897
2590
        self.build_tree_contents([('tree2/foo', 'qux')])
2898
 
        pb = None
 
2591
        pb = progress.DummyProgress()
2899
2592
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
2900
2593
                                         pb, tree.basis_tree())
2901
2594
        merger.merge_type = Merge3Merger
2928
2621
        rev2_tree = tree.branch.repository.revision_tree(rev2_id)
2929
2622
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
2930
2623
 
2931
 
    def test_ascii_limbo_paths(self):
2932
 
        self.requireFeature(tests.UnicodeFilenameFeature)
2933
 
        branch = self.make_branch('any')
2934
 
        tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)
2935
 
        tt = TransformPreview(tree)
2936
 
        self.addCleanup(tt.finalize)
2937
 
        foo_id = tt.new_directory('', ROOT_PARENT)
2938
 
        bar_id = tt.new_file(u'\u1234bar', foo_id, 'contents')
2939
 
        limbo_path = tt._limbo_name(bar_id)
2940
 
        self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)
2941
 
 
2942
2624
 
2943
2625
class FakeSerializer(object):
2944
2626
    """Serializer implementation that simply returns the input.