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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/tests/test_transform.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2012, 2016 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
import errno
17
18
import os
18
19
from StringIO import StringIO
19
20
import sys
20
21
import time
21
22
 
22
 
from bzrlib import (
 
23
from brzlib import (
23
24
    bencode,
24
25
    errors,
25
26
    filters,
26
27
    generate_ids,
27
28
    osutils,
28
 
    progress,
29
29
    revision as _mod_revision,
30
30
    rules,
 
31
    symbol_versioning,
31
32
    tests,
 
33
    trace,
 
34
    transform,
32
35
    urlutils,
33
36
    )
34
 
from bzrlib.bzrdir import BzrDir
35
 
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
36
 
                              UnversionedParent, ParentLoop, DeletingParent,
37
 
                              NonDirectoryParent)
38
 
from bzrlib.diff import show_diff_trees
39
 
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
40
 
                           ReusingTransform, CantMoveRoot,
41
 
                           PathsNotVersionedError, ExistingLimbo,
42
 
                           ExistingPendingDeletion, ImmortalLimbo,
43
 
                           ImmortalPendingDeletion, LockError)
44
 
from bzrlib.osutils import file_kind, pathjoin
45
 
from bzrlib.merge import Merge3Merger, Merger
46
 
from bzrlib.tests import (
 
37
from brzlib.conflicts import (
 
38
    DeletingParent,
 
39
    DuplicateEntry,
 
40
    DuplicateID,
 
41
    MissingParent,
 
42
    NonDirectoryParent,
 
43
    ParentLoop,
 
44
    UnversionedParent,
 
45
)
 
46
from brzlib.controldir import ControlDir
 
47
from brzlib.diff import show_diff_trees
 
48
from brzlib.errors import (
 
49
    DuplicateKey,
 
50
    ExistingLimbo,
 
51
    ExistingPendingDeletion,
 
52
    ImmortalLimbo,
 
53
    ImmortalPendingDeletion,
 
54
    LockError,
 
55
    MalformedTransform,
 
56
    ReusingTransform,
 
57
)
 
58
from brzlib.osutils import (
 
59
    file_kind,
 
60
    pathjoin,
 
61
)
 
62
from brzlib.merge import Merge3Merger, Merger
 
63
from brzlib.mutabletree import MutableTree
 
64
from brzlib.tests import (
 
65
    features,
 
66
    TestCaseInTempDir,
 
67
    TestSkipped,
 
68
    )
 
69
from brzlib.tests.features import (
47
70
    HardlinkFeature,
48
71
    SymlinkFeature,
49
 
    TestCase,
50
 
    TestCaseInTempDir,
51
 
    TestSkipped,
52
72
    )
53
 
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths,
54
 
                              resolve_conflicts, cook_conflicts,
55
 
                              build_tree, get_backup_name,
56
 
                              _FileMover, resolve_checkout,
57
 
                              TransformPreview, create_from_tree)
 
73
from brzlib.transform import (
 
74
    build_tree,
 
75
    create_from_tree,
 
76
    cook_conflicts,
 
77
    _FileMover,
 
78
    FinalPaths,
 
79
    resolve_conflicts,
 
80
    resolve_checkout,
 
81
    ROOT_PARENT,
 
82
    TransformPreview,
 
83
    TreeTransform,
 
84
)
58
85
 
59
86
 
60
87
class TestTreeTransform(tests.TestCaseWithTransport):
61
88
 
62
89
    def setUp(self):
63
90
        super(TestTreeTransform, self).setUp()
64
 
        self.wt = self.make_branch_and_tree('.', format='dirstate-with-subtree')
 
91
        self.wt = self.make_branch_and_tree('.', format='development-subtree')
65
92
        os.chdir('..')
66
93
 
67
94
    def get_transform(self):
69
96
        self.addCleanup(transform.finalize)
70
97
        return transform, transform.root
71
98
 
 
99
    def get_transform_for_sha1_test(self):
 
100
        trans, root = self.get_transform()
 
101
        self.wt.lock_tree_write()
 
102
        self.addCleanup(self.wt.unlock)
 
103
        contents = ['just some content\n']
 
104
        sha1 = osutils.sha_strings(contents)
 
105
        # Roll back the clock
 
106
        trans._creation_mtime = time.time() - 20.0
 
107
        return trans, root, contents, sha1
 
108
 
72
109
    def test_existing_limbo(self):
73
110
        transform, root = self.get_transform()
74
111
        limbo_name = transform._limbodir
101
138
        imaginary_id = transform.trans_id_tree_path('imaginary')
102
139
        imaginary_id2 = transform.trans_id_tree_path('imaginary/')
103
140
        self.assertEqual(imaginary_id, imaginary_id2)
104
 
        self.assertEqual(transform.get_tree_parent(imaginary_id), root)
105
 
        self.assertEqual(transform.final_kind(root), 'directory')
106
 
        self.assertEqual(transform.final_file_id(root), self.wt.get_root_id())
 
141
        self.assertEqual(root, transform.get_tree_parent(imaginary_id))
 
142
        self.assertEqual('directory', transform.final_kind(root))
 
143
        self.assertEqual(self.wt.get_root_id(), transform.final_file_id(root))
107
144
        trans_id = transform.create_path('name', root)
108
145
        self.assertIs(transform.final_file_id(trans_id), None)
109
 
        self.assertRaises(NoSuchFile, transform.final_kind, trans_id)
 
146
        self.assertIs(None, transform.final_kind(trans_id))
110
147
        transform.create_file('contents', trans_id)
111
148
        transform.set_executability(True, trans_id)
112
149
        transform.version_file('my_pretties', trans_id)
137
174
        transform.finalize()
138
175
        transform.finalize()
139
176
 
 
177
    def test_apply_informs_tree_of_observed_sha1(self):
 
178
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
 
179
        trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
 
180
                                  sha1=sha1)
 
181
        calls = []
 
182
        orig = self.wt._observed_sha1
 
183
        def _observed_sha1(*args):
 
184
            calls.append(args)
 
185
            orig(*args)
 
186
        self.wt._observed_sha1 = _observed_sha1
 
187
        trans.apply()
 
188
        self.assertEqual([(None, 'file1', trans._observed_sha1s[trans_id])],
 
189
                         calls)
 
190
 
 
191
    def test_create_file_caches_sha1(self):
 
192
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
 
193
        trans_id = trans.create_path('file1', root)
 
194
        trans.create_file(contents, trans_id, sha1=sha1)
 
195
        st_val = osutils.lstat(trans._limbo_name(trans_id))
 
196
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
 
197
        self.assertEqual(o_sha1, sha1)
 
198
        self.assertEqualStat(o_st_val, st_val)
 
199
 
 
200
    def test__apply_insertions_updates_sha1(self):
 
201
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
 
202
        trans_id = trans.create_path('file1', root)
 
203
        trans.create_file(contents, trans_id, sha1=sha1)
 
204
        st_val = osutils.lstat(trans._limbo_name(trans_id))
 
205
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
 
206
        self.assertEqual(o_sha1, sha1)
 
207
        self.assertEqualStat(o_st_val, st_val)
 
208
        creation_mtime = trans._creation_mtime + 10.0
 
209
        # We fake a time difference from when the file was created until now it
 
210
        # is being renamed by using os.utime. Note that the change we actually
 
211
        # want to see is the real ctime change from 'os.rename()', but as long
 
212
        # as we observe a new stat value, we should be fine.
 
213
        os.utime(trans._limbo_name(trans_id), (creation_mtime, creation_mtime))
 
214
        trans.apply()
 
215
        new_st_val = osutils.lstat(self.wt.abspath('file1'))
 
216
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
 
217
        self.assertEqual(o_sha1, sha1)
 
218
        self.assertEqualStat(o_st_val, new_st_val)
 
219
        self.assertNotEqual(st_val.st_mtime, new_st_val.st_mtime)
 
220
 
 
221
    def test_new_file_caches_sha1(self):
 
222
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
 
223
        trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
 
224
                                  sha1=sha1)
 
225
        st_val = osutils.lstat(trans._limbo_name(trans_id))
 
226
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
 
227
        self.assertEqual(o_sha1, sha1)
 
228
        self.assertEqualStat(o_st_val, st_val)
 
229
 
 
230
    def test_cancel_creation_removes_observed_sha1(self):
 
231
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
 
232
        trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
 
233
                                  sha1=sha1)
 
234
        self.assertTrue(trans_id in trans._observed_sha1s)
 
235
        trans.cancel_creation(trans_id)
 
236
        self.assertFalse(trans_id in trans._observed_sha1s)
 
237
 
140
238
    def test_create_files_same_timestamp(self):
141
239
        transform, root = self.get_transform()
142
240
        self.wt.lock_tree_write()
190
288
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
191
289
        self.assertRaises(ValueError, transform.fixup_new_roots)
192
290
 
 
291
    def test_retain_existing_root(self):
 
292
        tt, root = self.get_transform()
 
293
        with tt:
 
294
            tt.new_directory('', ROOT_PARENT, 'new-root-id')
 
295
            tt.fixup_new_roots()
 
296
            self.assertNotEqual('new-root-id', tt.final_file_id(tt.root))
 
297
 
 
298
    def test_retain_existing_root_added_file(self):
 
299
        tt, root = self.get_transform()
 
300
        new_trans_id = tt.new_directory('', ROOT_PARENT, 'new-root-id')
 
301
        child = tt.new_directory('child', new_trans_id, 'child-id')
 
302
        tt.fixup_new_roots()
 
303
        self.assertEqual(tt.root, tt.final_parent(child))
 
304
 
 
305
    def test_add_unversioned_root(self):
 
306
        transform, root = self.get_transform()
 
307
        new_trans_id = transform.new_directory('', ROOT_PARENT, None)
 
308
        transform.delete_contents(transform.root)
 
309
        transform.fixup_new_roots()
 
310
        self.assertNotIn(transform.root, transform._new_id)
 
311
 
 
312
    def test_remove_root_fixup(self):
 
313
        transform, root = self.get_transform()
 
314
        old_root_id = self.wt.get_root_id()
 
315
        self.assertNotEqual('new-root-id', old_root_id)
 
316
        transform.delete_contents(root)
 
317
        transform.unversion_file(root)
 
318
        transform.fixup_new_roots()
 
319
        transform.apply()
 
320
        self.assertEqual(old_root_id, self.wt.get_root_id())
 
321
 
 
322
        transform, root = self.get_transform()
 
323
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
 
324
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
 
325
        self.assertRaises(ValueError, transform.fixup_new_roots)
 
326
 
 
327
    def test_fixup_new_roots_permits_empty_tree(self):
 
328
        transform, root = self.get_transform()
 
329
        transform.delete_contents(root)
 
330
        transform.unversion_file(root)
 
331
        transform.fixup_new_roots()
 
332
        self.assertIs(None, transform.final_kind(root))
 
333
        self.assertIs(None, transform.final_file_id(root))
 
334
 
 
335
    def test_apply_retains_root_directory(self):
 
336
        # Do not attempt to delete the physical root directory, because that
 
337
        # is impossible.
 
338
        transform, root = self.get_transform()
 
339
        with transform:
 
340
            transform.delete_contents(root)
 
341
            e = self.assertRaises(AssertionError, self.assertRaises,
 
342
                                  errors.TransformRenameFailed,
 
343
                                  transform.apply)
 
344
        self.assertContainsRe('TransformRenameFailed not raised', str(e))
 
345
 
 
346
    def test_apply_retains_file_id(self):
 
347
        transform, root = self.get_transform()
 
348
        old_root_id = transform.tree_file_id(root)
 
349
        transform.unversion_file(root)
 
350
        transform.apply()
 
351
        self.assertEqual(old_root_id, self.wt.get_root_id())
 
352
 
193
353
    def test_hardlink(self):
194
354
        self.requireFeature(HardlinkFeature)
195
355
        transform, root = self.get_transform()
200
360
        trans_id = target_transform.create_path('file1', target_transform.root)
201
361
        target_transform.create_hardlink(self.wt.abspath('file1'), trans_id)
202
362
        target_transform.apply()
203
 
        self.failUnlessExists('target/file1')
 
363
        self.assertPathExists('target/file1')
204
364
        source_stat = os.stat(self.wt.abspath('file1'))
205
365
        target_stat = os.stat('target/file1')
206
366
        self.assertEqual(source_stat, target_stat)
239
399
        tree.lock_read()
240
400
        self.addCleanup(tree.unlock)
241
401
        self.assertEqual('subtree-revision',
242
 
                         tree.inventory['subtree-id'].reference_revision)
 
402
                         tree.root_inventory['subtree-id'].reference_revision)
243
403
 
244
404
    def test_conflicts(self):
245
405
        transform, root = self.get_transform()
296
456
        newtip = transform2.new_file('tip', oz_id, 'other', 'tip-id')
297
457
        result = transform2.find_conflicts()
298
458
        fp = FinalPaths(transform2)
299
 
        self.assert_('oz/tip' in transform2._tree_path_ids)
 
459
        self.assertTrue('oz/tip' in transform2._tree_path_ids)
300
460
        self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
301
461
        self.assertEqual(len(result), 2)
302
462
        self.assertEqual((result[0][0], result[0][1]),
372
532
        transform.new_file('FiLe', transform.root, 'content')
373
533
        resolve_conflicts(transform)
374
534
        transform.apply()
375
 
        self.failUnlessExists('tree/file')
376
 
        self.failUnlessExists('tree/FiLe.moved')
 
535
        self.assertPathExists('tree/file')
 
536
        self.assertPathExists('tree/FiLe.moved')
377
537
 
378
538
    def test_resolve_checkout_case_conflict(self):
379
539
        tree = self.make_branch_and_tree('tree')
388
548
        resolve_conflicts(transform,
389
549
                          pass_func=lambda t, c: resolve_checkout(t, c, []))
390
550
        transform.apply()
391
 
        self.failUnlessExists('tree/file')
392
 
        self.failUnlessExists('tree/FiLe.moved')
 
551
        self.assertPathExists('tree/file')
 
552
        self.assertPathExists('tree/FiLe.moved')
393
553
 
394
554
    def test_apply_case_conflict(self):
395
555
        """Ensure that a transform with case conflicts can always be applied"""
403
563
        transform.new_file('dirFiLe', dir, 'content')
404
564
        resolve_conflicts(transform)
405
565
        transform.apply()
406
 
        self.failUnlessExists('tree/file')
 
566
        self.assertPathExists('tree/file')
407
567
        if not os.path.exists('tree/FiLe.moved'):
408
 
            self.failUnlessExists('tree/FiLe')
409
 
        self.failUnlessExists('tree/dir/dirfile')
 
568
            self.assertPathExists('tree/FiLe')
 
569
        self.assertPathExists('tree/dir/dirfile')
410
570
        if not os.path.exists('tree/dir/dirFiLe.moved'):
411
 
            self.failUnlessExists('tree/dir/dirFiLe')
 
571
            self.assertPathExists('tree/dir/dirFiLe')
412
572
 
413
573
    def test_case_insensitive_limbo(self):
414
574
        tree = self.make_branch_and_tree('tree')
525
685
 
526
686
    def test_both_rename2(self):
527
687
        create_tree,root = self.get_transform()
528
 
        bzrlib = create_tree.new_directory('bzrlib', root, 'bzrlib-id')
529
 
        tests = create_tree.new_directory('tests', bzrlib, 'tests-id')
 
688
        brzlib = create_tree.new_directory('brzlib', root, 'bzrlib-id')
 
689
        tests = create_tree.new_directory('tests', brzlib, 'tests-id')
530
690
        blackbox = create_tree.new_directory('blackbox', tests, 'blackbox-id')
531
691
        create_tree.new_file('test_too_much.py', blackbox, 'hello1',
532
692
                             'test_too_much-id')
533
693
        create_tree.apply()
534
694
        mangle_tree,root = self.get_transform()
535
 
        bzrlib = mangle_tree.trans_id_tree_file_id('bzrlib-id')
 
695
        brzlib = mangle_tree.trans_id_tree_file_id('brzlib-id')
536
696
        tests = mangle_tree.trans_id_tree_file_id('tests-id')
537
697
        test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
538
 
        mangle_tree.adjust_path('selftest', bzrlib, tests)
 
698
        mangle_tree.adjust_path('selftest', brzlib, tests)
539
699
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
540
700
        mangle_tree.set_executability(True, test_too_much)
541
701
        mangle_tree.apply()
622
782
                            'wizard2', 'behind_curtain')
623
783
 
624
784
    def test_symlinks_unicode(self):
625
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
785
        self.requireFeature(features.UnicodeFilenameFeature)
626
786
        self._test_symlinks(u'\N{Euro Sign}wizard',
627
787
                            u'wizard-targ\N{Euro Sign}t',
628
788
                            u'\N{Euro Sign}wizard2',
641
801
        os.symlink = None
642
802
        try:
643
803
            err = self.assertRaises(errors.UnableCreateSymlink, tt_helper)
644
 
            self.assertEquals(
 
804
            self.assertEqual(
645
805
                "Unable to create symlink 'foo' on this platform",
646
806
                str(err))
647
807
        finally:
716
876
        raw_conflicts = resolve_conflicts(tt)
717
877
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
718
878
        tt.finalize()
719
 
        conflicts_s = [str(c) for c in cooked_conflicts]
 
879
        conflicts_s = [unicode(c) for c in cooked_conflicts]
720
880
        self.assertEqual(len(cooked_conflicts), len(conflicts_s))
721
881
        self.assertEqual(conflicts_s[0], 'Conflict adding file dorothy.  '
722
882
                                         'Moved existing file to '
792
952
        self.assertIs(None, self.wt.path2id('parent'))
793
953
        self.assertIs(None, self.wt.path2id('parent.new'))
794
954
 
 
955
    def test_resolve_conflicts_missing_parent(self):
 
956
        wt = self.make_branch_and_tree('.')
 
957
        tt = TreeTransform(wt)
 
958
        self.addCleanup(tt.finalize)
 
959
        parent = tt.trans_id_file_id('parent-id')
 
960
        tt.new_file('file', parent, 'Contents')
 
961
        raw_conflicts = resolve_conflicts(tt)
 
962
        # Since the directory doesn't exist it's seen as 'missing'.  So
 
963
        # 'resolve_conflicts' create a conflict asking for it to be created.
 
964
        self.assertLength(1, raw_conflicts)
 
965
        self.assertEqual(('missing parent', 'Created directory', 'new-1'),
 
966
                         raw_conflicts.pop())
 
967
        # apply fail since the missing directory doesn't exist
 
968
        self.assertRaises(errors.NoFinalPath, tt.apply)
 
969
 
795
970
    def test_moving_versioned_directories(self):
796
971
        create, root = self.get_transform()
797
972
        kansas = create.new_directory('kansas', root, 'kansas-id')
830
1005
        rename.set_executability(True, myfile)
831
1006
        rename.apply()
832
1007
 
 
1008
    def test_rename_fails(self):
 
1009
        self.requireFeature(features.not_running_as_root)
 
1010
        # see https://bugs.launchpad.net/bzr/+bug/491763
 
1011
        create, root_id = self.get_transform()
 
1012
        first_dir = create.new_directory('first-dir', root_id, 'first-id')
 
1013
        myfile = create.new_file('myfile', root_id, 'myfile-text',
 
1014
                                 'myfile-id')
 
1015
        create.apply()
 
1016
        if os.name == "posix" and sys.platform != "cygwin":
 
1017
            # posix filesystems fail on renaming if the readonly bit is set
 
1018
            osutils.make_readonly(self.wt.abspath('first-dir'))
 
1019
        elif os.name == "nt":
 
1020
            # windows filesystems fail on renaming open files
 
1021
            self.addCleanup(file(self.wt.abspath('myfile')).close)
 
1022
        else:
 
1023
            self.skip("Don't know how to force a permissions error on rename")
 
1024
        # now transform to rename
 
1025
        rename_transform, root_id = self.get_transform()
 
1026
        file_trans_id = rename_transform.trans_id_file_id('myfile-id')
 
1027
        dir_id = rename_transform.trans_id_file_id('first-id')
 
1028
        rename_transform.adjust_path('newname', dir_id, file_trans_id)
 
1029
        e = self.assertRaises(errors.TransformRenameFailed,
 
1030
            rename_transform.apply)
 
1031
        # On nix looks like: 
 
1032
        # "Failed to rename .../work/.bzr/checkout/limbo/new-1
 
1033
        # to .../first-dir/newname: [Errno 13] Permission denied"
 
1034
        # On windows looks like:
 
1035
        # "Failed to rename .../work/myfile to 
 
1036
        # .../work/.bzr/checkout/limbo/new-1: [Errno 13] Permission denied"
 
1037
        # This test isn't concerned with exactly what the error looks like,
 
1038
        # and the strerror will vary across OS and locales, but the assert
 
1039
        # that the exeception attributes are what we expect
 
1040
        self.assertEqual(e.errno, errno.EACCES)
 
1041
        if os.name == "posix":
 
1042
            self.assertEndsWith(e.to_path, "/first-dir/newname")
 
1043
        else:
 
1044
            self.assertEqual(os.path.basename(e.from_path), "myfile")
 
1045
 
833
1046
    def test_set_executability_order(self):
834
1047
        """Ensure that executability behaves the same, no matter what order.
835
1048
 
1107
1320
        parent2 = transform.new_directory('parent2', root)
1108
1321
        transform.adjust_path('child1', parent2, child1)
1109
1322
        transform.apply()
1110
 
        self.failIfExists(self.wt.abspath('parent1/child1'))
1111
 
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
 
1323
        self.assertPathDoesNotExist(self.wt.abspath('parent1/child1'))
 
1324
        self.assertPathExists(self.wt.abspath('parent2/child1'))
1112
1325
        # rename limbo/new-1 => parent1, rename limbo/new-3 => parent2
1113
1326
        # no rename for child1 (counting only renames during apply)
1114
 
        self.failUnlessEqual(2, transform.rename_count)
 
1327
        self.assertEqual(2, transform.rename_count)
1115
1328
 
1116
1329
    def test_cancel_parent(self):
1117
1330
        """Cancelling a parent doesn't cause deletion of a non-empty directory
1140
1353
        parent2 = transform.new_directory('parent2', root)
1141
1354
        transform.adjust_path('child1', parent2, child1)
1142
1355
        transform.apply()
1143
 
        self.failIfExists(self.wt.abspath('parent1'))
1144
 
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
 
1356
        self.assertPathDoesNotExist(self.wt.abspath('parent1'))
 
1357
        self.assertPathExists(self.wt.abspath('parent2/child1'))
1145
1358
        # rename limbo/new-3 => parent2, rename limbo/new-2 => child1
1146
 
        self.failUnlessEqual(2, transform.rename_count)
 
1359
        self.assertEqual(2, transform.rename_count)
1147
1360
 
1148
1361
    def test_adjust_and_cancel(self):
1149
1362
        """Make sure adjust_path keeps track of limbo children properly"""
1182
1395
        child = transform.new_directory('child', parent)
1183
1396
        transform.adjust_path('parent', root, parent)
1184
1397
        transform.apply()
1185
 
        self.failUnlessExists(self.wt.abspath('parent/child'))
 
1398
        self.assertPathExists(self.wt.abspath('parent/child'))
1186
1399
        self.assertEqual(1, transform.rename_count)
1187
1400
 
1188
1401
    def test_reuse_name(self):
1264
1477
        # The rename will fail because the target directory is not empty (but
1265
1478
        # raises FileExists anyway).
1266
1479
        err = self.assertRaises(errors.FileExists, tt_helper)
1267
 
        self.assertContainsRe(str(err),
1268
 
            "^File exists: .+/baz")
 
1480
        self.assertEndsWith(err.path, "/baz")
1269
1481
 
1270
1482
    def test_two_directories_clash(self):
1271
1483
        def tt_helper():
1283
1495
                wt.unlock()
1284
1496
                raise
1285
1497
        err = self.assertRaises(errors.FileExists, tt_helper)
1286
 
        self.assertContainsRe(str(err),
1287
 
            "^File exists: .+/foo")
 
1498
        self.assertEndsWith(err.path, "/foo")
1288
1499
 
1289
1500
    def test_two_directories_clash_finalize(self):
1290
1501
        def tt_helper():
1302
1513
                tt.finalize()
1303
1514
                raise
1304
1515
        err = self.assertRaises(errors.FileExists, tt_helper)
1305
 
        self.assertContainsRe(str(err),
1306
 
            "^File exists: .+/foo")
 
1516
        self.assertEndsWith(err.path, "/foo")
1307
1517
 
1308
1518
    def test_file_to_directory(self):
1309
1519
        wt = self.make_branch_and_tree('.')
1319
1529
        tt.create_file(["aa\n"], bar_trans_id)
1320
1530
        tt.version_file("bar-1", bar_trans_id)
1321
1531
        tt.apply()
1322
 
        self.failUnlessExists("foo/bar")
 
1532
        self.assertPathExists("foo/bar")
1323
1533
        wt.lock_read()
1324
1534
        try:
1325
 
            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1326
 
                    "directory")
 
1535
            self.assertEqual(wt.kind(wt.path2id("foo")), "directory")
1327
1536
        finally:
1328
1537
            wt.unlock()
1329
1538
        wt.commit("two")
1342
1551
        tt.delete_contents(foo_trans_id)
1343
1552
        tt.create_symlink("bar", foo_trans_id)
1344
1553
        tt.apply()
1345
 
        self.failUnlessExists("foo")
 
1554
        self.assertPathExists("foo")
1346
1555
        wt.lock_read()
1347
1556
        self.addCleanup(wt.unlock)
1348
 
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1349
 
                "symlink")
 
1557
        self.assertEqual(wt.kind(wt.path2id("foo")), "symlink")
1350
1558
 
1351
1559
    def test_dir_to_file(self):
1352
1560
        wt = self.make_branch_and_tree('.')
1361
1569
        tt.delete_versioned(bar_trans_id)
1362
1570
        tt.create_file(["aa\n"], foo_trans_id)
1363
1571
        tt.apply()
1364
 
        self.failUnlessExists("foo")
 
1572
        self.assertPathExists("foo")
1365
1573
        wt.lock_read()
1366
1574
        self.addCleanup(wt.unlock)
1367
 
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1368
 
                "file")
 
1575
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
1369
1576
 
1370
1577
    def test_dir_to_hardlink(self):
1371
1578
        self.requireFeature(HardlinkFeature)
1382
1589
        self.build_tree(['baz'])
1383
1590
        tt.create_hardlink("baz", foo_trans_id)
1384
1591
        tt.apply()
1385
 
        self.failUnlessExists("foo")
1386
 
        self.failUnlessExists("baz")
 
1592
        self.assertPathExists("foo")
 
1593
        self.assertPathExists("baz")
1387
1594
        wt.lock_read()
1388
1595
        self.addCleanup(wt.unlock)
1389
 
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1390
 
                "file")
 
1596
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
1391
1597
 
1392
1598
    def test_no_final_path(self):
1393
1599
        transform, root = self.get_transform()
1439
1645
    def __init__(self, dirname, root_id):
1440
1646
        self.name = dirname
1441
1647
        os.mkdir(dirname)
1442
 
        self.wt = BzrDir.create_standalone_workingtree(dirname)
 
1648
        self.wt = ControlDir.create_standalone_workingtree(dirname)
1443
1649
        self.wt.set_root_id(root_id)
1444
1650
        self.b = self.wt.branch
1445
1651
        self.tt = TreeTransform(self.wt)
1451
1657
    return template % ('<' * 7, tree, '=' * 7, merge, '>' * 7)
1452
1658
 
1453
1659
 
 
1660
class TestInventoryAltered(tests.TestCaseWithTransport):
 
1661
 
 
1662
    def test_inventory_altered_unchanged(self):
 
1663
        tree = self.make_branch_and_tree('tree')
 
1664
        self.build_tree(['tree/foo'])
 
1665
        tree.add('foo', 'foo-id')
 
1666
        with TransformPreview(tree) as tt:
 
1667
            self.assertEqual([], tt._inventory_altered())
 
1668
 
 
1669
    def test_inventory_altered_changed_parent_id(self):
 
1670
        tree = self.make_branch_and_tree('tree')
 
1671
        self.build_tree(['tree/foo'])
 
1672
        tree.add('foo', 'foo-id')
 
1673
        with TransformPreview(tree) as tt:
 
1674
            tt.unversion_file(tt.root)
 
1675
            tt.version_file('new-id', tt.root)
 
1676
            foo_trans_id = tt.trans_id_tree_file_id('foo-id')
 
1677
            foo_tuple = ('foo', foo_trans_id)
 
1678
            root_tuple = ('', tt.root)
 
1679
            self.assertEqual([root_tuple, foo_tuple], tt._inventory_altered())
 
1680
 
 
1681
    def test_inventory_altered_noop_changed_parent_id(self):
 
1682
        tree = self.make_branch_and_tree('tree')
 
1683
        self.build_tree(['tree/foo'])
 
1684
        tree.add('foo', 'foo-id')
 
1685
        with TransformPreview(tree) as tt:
 
1686
            tt.unversion_file(tt.root)
 
1687
            tt.version_file(tree.get_root_id(), tt.root)
 
1688
            foo_trans_id = tt.trans_id_tree_file_id('foo-id')
 
1689
            self.assertEqual([], tt._inventory_altered())
 
1690
 
 
1691
 
1454
1692
class TestTransformMerge(TestCaseInTempDir):
1455
1693
 
1456
1694
    def test_text_merge(self):
1523
1761
        merge_modified = this.wt.merge_modified()
1524
1762
        self.assertSubset(merge_modified, modified)
1525
1763
        self.assertEqual(len(merge_modified), len(modified))
1526
 
        file(this.wt.id2abspath('a'), 'wb').write('booga')
 
1764
        with file(this.wt.id2abspath('a'), 'wb') as f: f.write('booga')
1527
1765
        modified.pop(0)
1528
1766
        merge_modified = this.wt.merge_modified()
1529
1767
        self.assertSubset(merge_modified, modified)
1643
1881
    def test_build_tree_with_symlinks(self):
1644
1882
        self.requireFeature(SymlinkFeature)
1645
1883
        os.mkdir('a')
1646
 
        a = BzrDir.create_standalone_workingtree('a')
 
1884
        a = ControlDir.create_standalone_workingtree('a')
1647
1885
        os.mkdir('a/foo')
1648
 
        file('a/foo/bar', 'wb').write('contents')
 
1886
        with file('a/foo/bar', 'wb') as f: f.write('contents')
1649
1887
        os.symlink('a/foo/bar', 'a/foo/baz')
1650
1888
        a.add(['foo', 'foo/bar', 'foo/baz'])
1651
1889
        a.commit('initial commit')
1652
 
        b = BzrDir.create_standalone_workingtree('b')
 
1890
        b = ControlDir.create_standalone_workingtree('b')
1653
1891
        basis = a.basis_tree()
1654
1892
        basis.lock_read()
1655
1893
        self.addCleanup(basis.unlock)
1660
1898
 
1661
1899
    def test_build_with_references(self):
1662
1900
        tree = self.make_branch_and_tree('source',
1663
 
            format='dirstate-with-subtree')
 
1901
            format='development-subtree')
1664
1902
        subtree = self.make_branch_and_tree('source/subtree',
1665
 
            format='dirstate-with-subtree')
 
1903
            format='development-subtree')
1666
1904
        tree.add_reference(subtree)
1667
1905
        tree.commit('a revision')
1668
1906
        tree.branch.create_checkout('target')
1669
 
        self.failUnlessExists('target')
1670
 
        self.failUnlessExists('target/subtree')
 
1907
        self.assertPathExists('target')
 
1908
        self.assertPathExists('target/subtree')
1671
1909
 
1672
1910
    def test_file_conflict_handling(self):
1673
1911
        """Ensure that when building trees, conflict handling is done"""
1720
1958
        source.commit('added file')
1721
1959
        build_tree(source.basis_tree(), target)
1722
1960
        self.assertEqual([], target.conflicts())
1723
 
        self.failUnlessExists('target/dir1/file')
 
1961
        self.assertPathExists('target/dir1/file')
1724
1962
 
1725
1963
        # Ensure contents are merged
1726
1964
        target = self.make_branch_and_tree('target2')
1727
1965
        self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
1728
1966
        build_tree(source.basis_tree(), target)
1729
1967
        self.assertEqual([], target.conflicts())
1730
 
        self.failUnlessExists('target2/dir1/file2')
1731
 
        self.failUnlessExists('target2/dir1/file')
 
1968
        self.assertPathExists('target2/dir1/file2')
 
1969
        self.assertPathExists('target2/dir1/file')
1732
1970
 
1733
1971
        # Ensure new contents are suppressed for existing branches
1734
1972
        target = self.make_branch_and_tree('target3')
1735
1973
        self.make_branch('target3/dir1')
1736
1974
        self.build_tree(['target3/dir1/file2'])
1737
1975
        build_tree(source.basis_tree(), target)
1738
 
        self.failIfExists('target3/dir1/file')
1739
 
        self.failUnlessExists('target3/dir1/file2')
1740
 
        self.failUnlessExists('target3/dir1.diverted/file')
 
1976
        self.assertPathDoesNotExist('target3/dir1/file')
 
1977
        self.assertPathExists('target3/dir1/file2')
 
1978
        self.assertPathExists('target3/dir1.diverted/file')
1741
1979
        self.assertEqual([DuplicateEntry('Diverted to',
1742
1980
            'dir1.diverted', 'dir1', 'new-dir1', None)],
1743
1981
            target.conflicts())
1746
1984
        self.build_tree(['target4/dir1/'])
1747
1985
        self.make_branch('target4/dir1/file')
1748
1986
        build_tree(source.basis_tree(), target)
1749
 
        self.failUnlessExists('target4/dir1/file')
 
1987
        self.assertPathExists('target4/dir1/file')
1750
1988
        self.assertEqual('directory', file_kind('target4/dir1/file'))
1751
 
        self.failUnlessExists('target4/dir1/file.diverted')
 
1989
        self.assertPathExists('target4/dir1/file.diverted')
1752
1990
        self.assertEqual([DuplicateEntry('Diverted to',
1753
1991
            'dir1/file.diverted', 'dir1/file', 'new-file', None)],
1754
1992
            target.conflicts())
1822
2060
        self.addCleanup(target.unlock)
1823
2061
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1824
2062
 
 
2063
    def test_build_tree_accelerator_tree_observes_sha1(self):
 
2064
        source = self.create_ab_tree()
 
2065
        sha1 = osutils.sha_string('A')
 
2066
        target = self.make_branch_and_tree('target')
 
2067
        target.lock_write()
 
2068
        self.addCleanup(target.unlock)
 
2069
        state = target.current_dirstate()
 
2070
        state._cutoff_time = time.time() + 60
 
2071
        build_tree(source.basis_tree(), target, source)
 
2072
        entry = state._get_entry(0, path_utf8='file1')
 
2073
        self.assertEqual(sha1, entry[1][0][1])
 
2074
 
1825
2075
    def test_build_tree_accelerator_tree_missing_file(self):
1826
2076
        source = self.create_ab_tree()
1827
2077
        os.unlink('source/file1')
1934
2184
        def rot13(chunks, context=None):
1935
2185
            return [''.join(chunks).encode('rot13')]
1936
2186
        rot13filter = filters.ContentFilter(rot13, rot13)
1937
 
        filters.register_filter_stack_map('rot13', {'yes': [rot13filter]}.get)
 
2187
        filters.filter_stacks_registry.register(
 
2188
            'rot13', {'yes': [rot13filter]}.get)
1938
2189
        os.mkdir(self.test_home_dir + '/.bazaar')
1939
2190
        rules_filename = self.test_home_dir + '/.bazaar/rules'
1940
2191
        f = open(rules_filename, 'wb')
1970
2221
        self.assertEqualStat(source_stat, target_stat)
1971
2222
 
1972
2223
    def test_case_insensitive_build_tree_inventory(self):
1973
 
        if (tests.CaseInsensitiveFilesystemFeature.available()
1974
 
            or tests.CaseInsCasePresFilenameFeature.available()):
 
2224
        if (features.CaseInsensitiveFilesystemFeature.available()
 
2225
            or features.CaseInsCasePresFilenameFeature.available()):
1975
2226
            raise tests.UnavailableFeature('Fully case sensitive filesystem')
1976
2227
        source = self.make_branch_and_tree('source')
1977
2228
        self.build_tree(['source/file', 'source/FILE'])
1985
2236
        self.assertEqual('file.moved', target.id2path('lower-id'))
1986
2237
        self.assertEqual('FILE', target.id2path('upper-id'))
1987
2238
 
 
2239
    def test_build_tree_observes_sha(self):
 
2240
        source = self.make_branch_and_tree('source')
 
2241
        self.build_tree(['source/file1', 'source/dir/', 'source/dir/file2'])
 
2242
        source.add(['file1', 'dir', 'dir/file2'],
 
2243
                   ['file1-id', 'dir-id', 'file2-id'])
 
2244
        source.commit('new files')
 
2245
        target = self.make_branch_and_tree('target')
 
2246
        target.lock_write()
 
2247
        self.addCleanup(target.unlock)
 
2248
        # We make use of the fact that DirState caches its cutoff time. So we
 
2249
        # set the 'safe' time to one minute in the future.
 
2250
        state = target.current_dirstate()
 
2251
        state._cutoff_time = time.time() + 60
 
2252
        build_tree(source.basis_tree(), target)
 
2253
        entry1_sha = osutils.sha_file_by_name('source/file1')
 
2254
        entry2_sha = osutils.sha_file_by_name('source/dir/file2')
 
2255
        # entry[1] is the state information, entry[1][0] is the state of the
 
2256
        # working tree, entry[1][0][1] is the sha value for the current working
 
2257
        # tree
 
2258
        entry1 = state._get_entry(0, path_utf8='file1')
 
2259
        self.assertEqual(entry1_sha, entry1[1][0][1])
 
2260
        # The 'size' field must also be set.
 
2261
        self.assertEqual(25, entry1[1][0][2])
 
2262
        entry1_state = entry1[1][0]
 
2263
        entry2 = state._get_entry(0, path_utf8='dir/file2')
 
2264
        self.assertEqual(entry2_sha, entry2[1][0][1])
 
2265
        self.assertEqual(29, entry2[1][0][2])
 
2266
        entry2_state = entry2[1][0]
 
2267
        # Now, make sure that we don't have to re-read the content. The
 
2268
        # packed_stat should match exactly.
 
2269
        self.assertEqual(entry1_sha, target.get_file_sha1('file1-id', 'file1'))
 
2270
        self.assertEqual(entry2_sha,
 
2271
                         target.get_file_sha1('file2-id', 'dir/file2'))
 
2272
        self.assertEqual(entry1_state, entry1[1][0])
 
2273
        self.assertEqual(entry2_state, entry2[1][0])
 
2274
 
1988
2275
 
1989
2276
class TestCommitTransform(tests.TestCaseWithTransport):
1990
2277
 
2091
2378
        self.assertRaises(errors.MalformedTransform, tt.commit, branch,
2092
2379
                          'message')
2093
2380
 
2094
 
 
2095
 
class MockTransform(object):
2096
 
 
2097
 
    def has_named_child(self, by_parent, parent_id, name):
2098
 
        for child_id in by_parent[parent_id]:
2099
 
            if child_id == '0':
2100
 
                if name == "name~":
2101
 
                    return True
2102
 
            elif name == "name.~%s~" % child_id:
2103
 
                return True
2104
 
        return False
2105
 
 
2106
 
 
2107
 
class MockEntry(object):
2108
 
    def __init__(self):
2109
 
        object.__init__(self)
2110
 
        self.name = "name"
2111
 
 
2112
 
 
2113
 
class TestGetBackupName(TestCase):
2114
 
    def test_get_backup_name(self):
2115
 
        tt = MockTransform()
2116
 
        name = get_backup_name(MockEntry(), {'a':[]}, 'a', tt)
2117
 
        self.assertEqual(name, 'name.~1~')
2118
 
        name = get_backup_name(MockEntry(), {'a':['1']}, 'a', tt)
2119
 
        self.assertEqual(name, 'name.~2~')
2120
 
        name = get_backup_name(MockEntry(), {'a':['2']}, 'a', tt)
2121
 
        self.assertEqual(name, 'name.~1~')
2122
 
        name = get_backup_name(MockEntry(), {'a':['2'], 'b':[]}, 'b', tt)
2123
 
        self.assertEqual(name, 'name.~1~')
2124
 
        name = get_backup_name(MockEntry(), {'a':['1', '2', '3']}, 'a', tt)
2125
 
        self.assertEqual(name, 'name.~4~')
 
2381
    def test_commit_rich_revision_data(self):
 
2382
        branch, tt = self.get_branch_and_transform()
 
2383
        rev_id = tt.commit(branch, 'message', timestamp=1, timezone=43201,
 
2384
                           committer='me <me@example.com>',
 
2385
                           revprops={'foo': 'bar'}, revision_id='revid-1',
 
2386
                           authors=['Author1 <author1@example.com>',
 
2387
                              'Author2 <author2@example.com>',
 
2388
                               ])
 
2389
        self.assertEqual('revid-1', rev_id)
 
2390
        revision = branch.repository.get_revision(rev_id)
 
2391
        self.assertEqual(1, revision.timestamp)
 
2392
        self.assertEqual(43201, revision.timezone)
 
2393
        self.assertEqual('me <me@example.com>', revision.committer)
 
2394
        self.assertEqual(['Author1 <author1@example.com>',
 
2395
                          'Author2 <author2@example.com>'],
 
2396
                         revision.get_apparent_authors())
 
2397
        del revision.properties['authors']
 
2398
        self.assertEqual({'foo': 'bar',
 
2399
                          'branch-nick': 'tree'},
 
2400
                         revision.properties)
 
2401
 
 
2402
    def test_no_explicit_revprops(self):
 
2403
        branch, tt = self.get_branch_and_transform()
 
2404
        rev_id = tt.commit(branch, 'message', authors=[
 
2405
            'Author1 <author1@example.com>',
 
2406
            'Author2 <author2@example.com>', ])
 
2407
        revision = branch.repository.get_revision(rev_id)
 
2408
        self.assertEqual(['Author1 <author1@example.com>',
 
2409
                          'Author2 <author2@example.com>'],
 
2410
                         revision.get_apparent_authors())
 
2411
        self.assertEqual('tree', revision.properties['branch-nick'])
2126
2412
 
2127
2413
 
2128
2414
class TestFileMover(tests.TestCaseWithTransport):
2131
2417
        self.build_tree(['a/', 'a/b', 'c/', 'c/d'])
2132
2418
        mover = _FileMover()
2133
2419
        mover.rename('a', 'q')
2134
 
        self.failUnlessExists('q')
2135
 
        self.failIfExists('a')
2136
 
        self.failUnlessExists('q/b')
2137
 
        self.failUnlessExists('c')
2138
 
        self.failUnlessExists('c/d')
 
2420
        self.assertPathExists('q')
 
2421
        self.assertPathDoesNotExist('a')
 
2422
        self.assertPathExists('q/b')
 
2423
        self.assertPathExists('c')
 
2424
        self.assertPathExists('c/d')
2139
2425
 
2140
2426
    def test_pre_delete_rollback(self):
2141
2427
        self.build_tree(['a/'])
2142
2428
        mover = _FileMover()
2143
2429
        mover.pre_delete('a', 'q')
2144
 
        self.failUnlessExists('q')
2145
 
        self.failIfExists('a')
 
2430
        self.assertPathExists('q')
 
2431
        self.assertPathDoesNotExist('a')
2146
2432
        mover.rollback()
2147
 
        self.failIfExists('q')
2148
 
        self.failUnlessExists('a')
 
2433
        self.assertPathDoesNotExist('q')
 
2434
        self.assertPathExists('a')
2149
2435
 
2150
2436
    def test_apply_deletions(self):
2151
2437
        self.build_tree(['a/', 'b/'])
2152
2438
        mover = _FileMover()
2153
2439
        mover.pre_delete('a', 'q')
2154
2440
        mover.pre_delete('b', 'r')
2155
 
        self.failUnlessExists('q')
2156
 
        self.failUnlessExists('r')
2157
 
        self.failIfExists('a')
2158
 
        self.failIfExists('b')
 
2441
        self.assertPathExists('q')
 
2442
        self.assertPathExists('r')
 
2443
        self.assertPathDoesNotExist('a')
 
2444
        self.assertPathDoesNotExist('b')
2159
2445
        mover.apply_deletions()
2160
 
        self.failIfExists('q')
2161
 
        self.failIfExists('r')
2162
 
        self.failIfExists('a')
2163
 
        self.failIfExists('b')
 
2446
        self.assertPathDoesNotExist('q')
 
2447
        self.assertPathDoesNotExist('r')
 
2448
        self.assertPathDoesNotExist('a')
 
2449
        self.assertPathDoesNotExist('b')
2164
2450
 
2165
2451
    def test_file_mover_rollback(self):
2166
2452
        self.build_tree(['a/', 'a/b', 'c/', 'c/d/', 'c/e/'])
2171
2457
            mover.rename('a', 'c')
2172
2458
        except errors.FileExists, e:
2173
2459
            mover.rollback()
2174
 
        self.failUnlessExists('a')
2175
 
        self.failUnlessExists('c/d')
 
2460
        self.assertPathExists('a')
 
2461
        self.assertPathExists('c/d')
2176
2462
 
2177
2463
 
2178
2464
class Bogus(Exception):
2208
2494
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2209
2495
        self.assertRaises(Bogus, tt.apply,
2210
2496
                          _mover=self.ExceptionFileMover(bad_source='a'))
2211
 
        self.failUnlessExists('a')
2212
 
        self.failUnlessExists('a/b')
 
2497
        self.assertPathExists('a')
 
2498
        self.assertPathExists('a/b')
2213
2499
        tt.apply()
2214
 
        self.failUnlessExists('c')
2215
 
        self.failUnlessExists('c/d')
 
2500
        self.assertPathExists('c')
 
2501
        self.assertPathExists('c/d')
2216
2502
 
2217
2503
    def test_rollback_rename_into_place(self):
2218
2504
        tree = self.make_branch_and_tree('.')
2224
2510
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2225
2511
        self.assertRaises(Bogus, tt.apply,
2226
2512
                          _mover=self.ExceptionFileMover(bad_target='c/d'))
2227
 
        self.failUnlessExists('a')
2228
 
        self.failUnlessExists('a/b')
 
2513
        self.assertPathExists('a')
 
2514
        self.assertPathExists('a/b')
2229
2515
        tt.apply()
2230
 
        self.failUnlessExists('c')
2231
 
        self.failUnlessExists('c/d')
 
2516
        self.assertPathExists('c')
 
2517
        self.assertPathExists('c/d')
2232
2518
 
2233
2519
    def test_rollback_deletion(self):
2234
2520
        tree = self.make_branch_and_tree('.')
2240
2526
        tt.adjust_path('d', tt.root, tt.trans_id_tree_path('a/b'))
2241
2527
        self.assertRaises(Bogus, tt.apply,
2242
2528
                          _mover=self.ExceptionFileMover(bad_target='d'))
2243
 
        self.failUnlessExists('a')
2244
 
        self.failUnlessExists('a/b')
2245
 
 
2246
 
    def test_resolve_no_parent(self):
 
2529
        self.assertPathExists('a')
 
2530
        self.assertPathExists('a/b')
 
2531
 
 
2532
 
 
2533
class TestFinalizeRobustness(tests.TestCaseWithTransport):
 
2534
    """Ensure treetransform creation errors can be safely cleaned up after"""
 
2535
 
 
2536
    def _override_globals_in_method(self, instance, method_name, globals):
 
2537
        """Replace method on instance with one with updated globals"""
 
2538
        import types
 
2539
        func = getattr(instance, method_name).im_func
 
2540
        new_globals = dict(func.func_globals)
 
2541
        new_globals.update(globals)
 
2542
        new_func = types.FunctionType(func.func_code, new_globals,
 
2543
            func.func_name, func.func_defaults)
 
2544
        setattr(instance, method_name,
 
2545
            types.MethodType(new_func, instance, instance.__class__))
 
2546
        self.addCleanup(delattr, instance, method_name)
 
2547
 
 
2548
    @staticmethod
 
2549
    def _fake_open_raises_before(name, mode):
 
2550
        """Like open() but raises before doing anything"""
 
2551
        raise RuntimeError
 
2552
 
 
2553
    @staticmethod
 
2554
    def _fake_open_raises_after(name, mode):
 
2555
        """Like open() but raises after creating file without returning"""
 
2556
        open(name, mode).close()
 
2557
        raise RuntimeError
 
2558
 
 
2559
    def create_transform_and_root_trans_id(self):
 
2560
        """Setup a transform creating a file in limbo"""
 
2561
        tree = self.make_branch_and_tree('.')
 
2562
        tt = TreeTransform(tree)
 
2563
        return tt, tt.create_path("a", tt.root)
 
2564
 
 
2565
    def create_transform_and_subdir_trans_id(self):
 
2566
        """Setup a transform creating a directory containing a file in limbo"""
 
2567
        tree = self.make_branch_and_tree('.')
 
2568
        tt = TreeTransform(tree)
 
2569
        d_trans_id = tt.create_path("d", tt.root)
 
2570
        tt.create_directory(d_trans_id)
 
2571
        f_trans_id = tt.create_path("a", d_trans_id)
 
2572
        tt.adjust_path("a", d_trans_id, f_trans_id)
 
2573
        return tt, f_trans_id
 
2574
 
 
2575
    def test_root_create_file_open_raises_before_creation(self):
 
2576
        tt, trans_id = self.create_transform_and_root_trans_id()
 
2577
        self._override_globals_in_method(tt, "create_file",
 
2578
            {"open": self._fake_open_raises_before})
 
2579
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
 
2580
        path = tt._limbo_name(trans_id)
 
2581
        self.assertPathDoesNotExist(path)
 
2582
        tt.finalize()
 
2583
        self.assertPathDoesNotExist(tt._limbodir)
 
2584
 
 
2585
    def test_root_create_file_open_raises_after_creation(self):
 
2586
        tt, trans_id = self.create_transform_and_root_trans_id()
 
2587
        self._override_globals_in_method(tt, "create_file",
 
2588
            {"open": self._fake_open_raises_after})
 
2589
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
 
2590
        path = tt._limbo_name(trans_id)
 
2591
        self.assertPathExists(path)
 
2592
        tt.finalize()
 
2593
        self.assertPathDoesNotExist(path)
 
2594
        self.assertPathDoesNotExist(tt._limbodir)
 
2595
 
 
2596
    def test_subdir_create_file_open_raises_before_creation(self):
 
2597
        tt, trans_id = self.create_transform_and_subdir_trans_id()
 
2598
        self._override_globals_in_method(tt, "create_file",
 
2599
            {"open": self._fake_open_raises_before})
 
2600
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
 
2601
        path = tt._limbo_name(trans_id)
 
2602
        self.assertPathDoesNotExist(path)
 
2603
        tt.finalize()
 
2604
        self.assertPathDoesNotExist(tt._limbodir)
 
2605
 
 
2606
    def test_subdir_create_file_open_raises_after_creation(self):
 
2607
        tt, trans_id = self.create_transform_and_subdir_trans_id()
 
2608
        self._override_globals_in_method(tt, "create_file",
 
2609
            {"open": self._fake_open_raises_after})
 
2610
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
 
2611
        path = tt._limbo_name(trans_id)
 
2612
        self.assertPathExists(path)
 
2613
        tt.finalize()
 
2614
        self.assertPathDoesNotExist(path)
 
2615
        self.assertPathDoesNotExist(tt._limbodir)
 
2616
 
 
2617
    def test_rename_in_limbo_rename_raises_after_rename(self):
 
2618
        tt, trans_id = self.create_transform_and_root_trans_id()
 
2619
        parent1 = tt.new_directory('parent1', tt.root)
 
2620
        child1 = tt.new_file('child1', parent1, 'contents')
 
2621
        parent2 = tt.new_directory('parent2', tt.root)
 
2622
 
 
2623
        class FakeOSModule(object):
 
2624
            def rename(self, old, new):
 
2625
                os.rename(old, new)
 
2626
                raise RuntimeError
 
2627
        self._override_globals_in_method(tt, "_rename_in_limbo",
 
2628
            {"os": FakeOSModule()})
 
2629
        self.assertRaises(
 
2630
            RuntimeError, tt.adjust_path, "child1", parent2, child1)
 
2631
        path = osutils.pathjoin(tt._limbo_name(parent2), "child1")
 
2632
        self.assertPathExists(path)
 
2633
        tt.finalize()
 
2634
        self.assertPathDoesNotExist(path)
 
2635
        self.assertPathDoesNotExist(tt._limbodir)
 
2636
 
 
2637
    def test_rename_in_limbo_rename_raises_before_rename(self):
 
2638
        tt, trans_id = self.create_transform_and_root_trans_id()
 
2639
        parent1 = tt.new_directory('parent1', tt.root)
 
2640
        child1 = tt.new_file('child1', parent1, 'contents')
 
2641
        parent2 = tt.new_directory('parent2', tt.root)
 
2642
 
 
2643
        class FakeOSModule(object):
 
2644
            def rename(self, old, new):
 
2645
                raise RuntimeError
 
2646
        self._override_globals_in_method(tt, "_rename_in_limbo",
 
2647
            {"os": FakeOSModule()})
 
2648
        self.assertRaises(
 
2649
            RuntimeError, tt.adjust_path, "child1", parent2, child1)
 
2650
        path = osutils.pathjoin(tt._limbo_name(parent1), "child1")
 
2651
        self.assertPathExists(path)
 
2652
        tt.finalize()
 
2653
        self.assertPathDoesNotExist(path)
 
2654
        self.assertPathDoesNotExist(tt._limbodir)
 
2655
 
 
2656
 
 
2657
class TestTransformMissingParent(tests.TestCaseWithTransport):
 
2658
 
 
2659
    def make_tt_with_versioned_dir(self):
2247
2660
        wt = self.make_branch_and_tree('.')
 
2661
        self.build_tree(['dir/',])
 
2662
        wt.add(['dir'], ['dir-id'])
 
2663
        wt.commit('Create dir')
2248
2664
        tt = TreeTransform(wt)
2249
2665
        self.addCleanup(tt.finalize)
2250
 
        parent = tt.trans_id_file_id('parent-id')
2251
 
        tt.new_file('file', parent, 'Contents')
2252
 
        resolve_conflicts(tt)
 
2666
        return wt, tt
 
2667
 
 
2668
    def test_resolve_create_parent_for_versioned_file(self):
 
2669
        wt, tt = self.make_tt_with_versioned_dir()
 
2670
        dir_tid = tt.trans_id_tree_file_id('dir-id')
 
2671
        file_tid = tt.new_file('file', dir_tid, 'Contents', file_id='file-id')
 
2672
        tt.delete_contents(dir_tid)
 
2673
        tt.unversion_file(dir_tid)
 
2674
        conflicts = resolve_conflicts(tt)
 
2675
        # one conflict for the missing directory, one for the unversioned
 
2676
        # parent
 
2677
        self.assertLength(2, conflicts)
 
2678
 
 
2679
    def test_non_versioned_file_create_conflict(self):
 
2680
        wt, tt = self.make_tt_with_versioned_dir()
 
2681
        dir_tid = tt.trans_id_tree_file_id('dir-id')
 
2682
        tt.new_file('file', dir_tid, 'Contents')
 
2683
        tt.delete_contents(dir_tid)
 
2684
        tt.unversion_file(dir_tid)
 
2685
        conflicts = resolve_conflicts(tt)
 
2686
        # no conflicts or rather: orphaning 'file' resolve the 'dir' conflict
 
2687
        self.assertLength(1, conflicts)
 
2688
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
 
2689
                         conflicts.pop())
2253
2690
 
2254
2691
 
2255
2692
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
2256
2693
                  ('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2257
2694
                  (False, False))
2258
2695
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
2259
 
              ('', ''), ('directory', 'directory'), (False, None))
 
2696
              ('', ''), ('directory', 'directory'), (False, False))
2260
2697
 
2261
2698
 
2262
2699
class TestTransformPreview(tests.TestCaseWithTransport):
2331
2768
 
2332
2769
    def test_iter_changes(self):
2333
2770
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2334
 
        root = revision_tree.inventory.root.file_id
 
2771
        root = revision_tree.get_root_id()
2335
2772
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
2336
2773
                          (root, root), ('a', 'a'), ('file', 'file'),
2337
2774
                          (False, False))],
2341
2778
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2342
2779
        changes = preview_tree.iter_changes(revision_tree,
2343
2780
                                            include_unchanged=True)
2344
 
        root = revision_tree.inventory.root.file_id
 
2781
        root = revision_tree.get_root_id()
2345
2782
 
2346
2783
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2347
2784
 
2349
2786
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2350
2787
        changes = preview_tree.iter_changes(revision_tree,
2351
2788
                                            specific_files=[''])
2352
 
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
 
2789
        self.assertEqual([A_ENTRY], list(changes))
2353
2790
 
2354
2791
    def test_want_unversioned(self):
2355
2792
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2356
2793
        changes = preview_tree.iter_changes(revision_tree,
2357
2794
                                            want_unversioned=True)
2358
 
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
 
2795
        self.assertEqual([A_ENTRY], list(changes))
2359
2796
 
2360
2797
    def test_ignore_extra_trees_no_specific_files(self):
2361
2798
        # extra_trees is harmless without specific_files, so we'll silently
2404
2841
        preview_mtime = preview_tree.get_file_mtime('file-id', 'renamed')
2405
2842
        work_mtime = work_tree.get_file_mtime('file-id', 'file')
2406
2843
 
 
2844
    def test_get_file_size(self):
 
2845
        work_tree = self.make_branch_and_tree('tree')
 
2846
        self.build_tree_contents([('tree/old', 'old')])
 
2847
        work_tree.add('old', 'old-id')
 
2848
        preview = TransformPreview(work_tree)
 
2849
        self.addCleanup(preview.finalize)
 
2850
        new_id = preview.new_file('name', preview.root, 'contents', 'new-id',
 
2851
                                  'executable')
 
2852
        tree = preview.get_preview_tree()
 
2853
        self.assertEqual(len('old'), tree.get_file_size('old-id'))
 
2854
        self.assertEqual(len('contents'), tree.get_file_size('new-id'))
 
2855
 
2407
2856
    def test_get_file(self):
2408
2857
        preview = self.get_empty_preview()
2409
2858
        preview.new_file('file', preview.root, 'contents', 'file-id')
2821
3270
        merger.merge_type = Merge3Merger
2822
3271
        merger.do_merge()
2823
3272
 
 
3273
    def test_has_filename(self):
 
3274
        wt = self.make_branch_and_tree('tree')
 
3275
        self.build_tree(['tree/unmodified', 'tree/removed', 'tree/modified'])
 
3276
        tt = TransformPreview(wt)
 
3277
        removed_id = tt.trans_id_tree_path('removed')
 
3278
        tt.delete_contents(removed_id)
 
3279
        tt.new_file('new', tt.root, 'contents')
 
3280
        modified_id = tt.trans_id_tree_path('modified')
 
3281
        tt.delete_contents(modified_id)
 
3282
        tt.create_file('modified-contents', modified_id)
 
3283
        self.addCleanup(tt.finalize)
 
3284
        tree = tt.get_preview_tree()
 
3285
        self.assertTrue(tree.has_filename('unmodified'))
 
3286
        self.assertFalse(tree.has_filename('not-present'))
 
3287
        self.assertFalse(tree.has_filename('removed'))
 
3288
        self.assertTrue(tree.has_filename('new'))
 
3289
        self.assertTrue(tree.has_filename('modified'))
 
3290
 
2824
3291
    def test_is_executable(self):
2825
3292
        tree = self.make_branch_and_tree('tree')
2826
3293
        preview = TransformPreview(tree)
2849
3316
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
2850
3317
 
2851
3318
    def test_ascii_limbo_paths(self):
2852
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
3319
        self.requireFeature(features.UnicodeFilenameFeature)
2853
3320
        branch = self.make_branch('any')
2854
3321
        tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)
2855
3322
        tt = TransformPreview(tree)
2872
3339
 
2873
3340
class TestSerializeTransform(tests.TestCaseWithTransport):
2874
3341
 
2875
 
    _test_needs_features = [tests.UnicodeFilenameFeature]
 
3342
    _test_needs_features = [features.UnicodeFilenameFeature]
2876
3343
 
2877
3344
    def get_preview(self, tree=None):
2878
3345
        if tree is None:
2953
3420
        return self.make_records(attribs, contents)
2954
3421
 
2955
3422
    def test_serialize_symlink_creation(self):
2956
 
        self.requireFeature(tests.SymlinkFeature)
 
3423
        self.requireFeature(features.SymlinkFeature)
2957
3424
        tt = self.get_preview()
2958
3425
        tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')
2959
3426
        self.assertSerializesTo(self.symlink_creation_records(), tt)
2960
3427
 
2961
3428
    def test_deserialize_symlink_creation(self):
2962
 
        self.requireFeature(tests.SymlinkFeature)
 
3429
        self.requireFeature(features.SymlinkFeature)
2963
3430
        tt = self.get_preview()
2964
3431
        tt.deserialize(iter(self.symlink_creation_records()))
2965
3432
        abspath = tt._limbo_name('new-1')
3132
3599
        trans_id = tt.trans_id_tree_path('file')
3133
3600
        self.assertEqual((LINES_ONE,),
3134
3601
            tt._get_parents_texts(trans_id))
 
3602
 
 
3603
 
 
3604
class TestOrphan(tests.TestCaseWithTransport):
 
3605
 
 
3606
    def test_no_orphan_for_transform_preview(self):
 
3607
        tree = self.make_branch_and_tree('tree')
 
3608
        tt = transform.TransformPreview(tree)
 
3609
        self.addCleanup(tt.finalize)
 
3610
        self.assertRaises(NotImplementedError, tt.new_orphan, 'foo', 'bar')
 
3611
 
 
3612
    def _set_orphan_policy(self, wt, policy):
 
3613
        wt.branch.get_config_stack().set('bzr.transform.orphan_policy',
 
3614
                                               policy)
 
3615
 
 
3616
    def _prepare_orphan(self, wt):
 
3617
        self.build_tree(['dir/', 'dir/file', 'dir/foo'])
 
3618
        wt.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
 
3619
        wt.commit('add dir and file ignoring foo')
 
3620
        tt = transform.TreeTransform(wt)
 
3621
        self.addCleanup(tt.finalize)
 
3622
        # dir and bar are deleted
 
3623
        dir_tid = tt.trans_id_tree_path('dir')
 
3624
        file_tid = tt.trans_id_tree_path('dir/file')
 
3625
        orphan_tid = tt.trans_id_tree_path('dir/foo')
 
3626
        tt.delete_contents(file_tid)
 
3627
        tt.unversion_file(file_tid)
 
3628
        tt.delete_contents(dir_tid)
 
3629
        tt.unversion_file(dir_tid)
 
3630
        # There should be a conflict because dir still contain foo
 
3631
        raw_conflicts = tt.find_conflicts()
 
3632
        self.assertLength(1, raw_conflicts)
 
3633
        self.assertEqual(('missing parent', 'new-1'), raw_conflicts[0])
 
3634
        return tt, orphan_tid
 
3635
 
 
3636
    def test_new_orphan_created(self):
 
3637
        wt = self.make_branch_and_tree('.')
 
3638
        self._set_orphan_policy(wt, 'move')
 
3639
        tt, orphan_tid = self._prepare_orphan(wt)
 
3640
        warnings = []
 
3641
        def warning(*args):
 
3642
            warnings.append(args[0] % args[1:])
 
3643
        self.overrideAttr(trace, 'warning', warning)
 
3644
        remaining_conflicts = resolve_conflicts(tt)
 
3645
        self.assertEqual(['dir/foo has been orphaned in bzr-orphans'],
 
3646
                          warnings)
 
3647
        # Yeah for resolved conflicts !
 
3648
        self.assertLength(0, remaining_conflicts)
 
3649
        # We have a new orphan
 
3650
        self.assertEqual('foo.~1~', tt.final_name(orphan_tid))
 
3651
        self.assertEqual('bzr-orphans',
 
3652
                          tt.final_name(tt.final_parent(orphan_tid)))
 
3653
 
 
3654
    def test_never_orphan(self):
 
3655
        wt = self.make_branch_and_tree('.')
 
3656
        self._set_orphan_policy(wt, 'conflict')
 
3657
        tt, orphan_tid = self._prepare_orphan(wt)
 
3658
        remaining_conflicts = resolve_conflicts(tt)
 
3659
        self.assertLength(1, remaining_conflicts)
 
3660
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
 
3661
                         remaining_conflicts.pop())
 
3662
 
 
3663
    def test_orphan_error(self):
 
3664
        def bogus_orphan(tt, orphan_id, parent_id):
 
3665
            raise transform.OrphaningError(tt.final_name(orphan_id),
 
3666
                                           tt.final_name(parent_id))
 
3667
        transform.orphaning_registry.register('bogus', bogus_orphan,
 
3668
                                              'Raise an error when orphaning')
 
3669
        wt = self.make_branch_and_tree('.')
 
3670
        self._set_orphan_policy(wt, 'bogus')
 
3671
        tt, orphan_tid = self._prepare_orphan(wt)
 
3672
        remaining_conflicts = resolve_conflicts(tt)
 
3673
        self.assertLength(1, remaining_conflicts)
 
3674
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
 
3675
                         remaining_conflicts.pop())
 
3676
 
 
3677
    def test_unknown_orphan_policy(self):
 
3678
        wt = self.make_branch_and_tree('.')
 
3679
        # Set a fictional policy nobody ever implemented
 
3680
        self._set_orphan_policy(wt, 'donttouchmypreciouuus')
 
3681
        tt, orphan_tid = self._prepare_orphan(wt)
 
3682
        warnings = []
 
3683
        def warning(*args):
 
3684
            warnings.append(args[0] % args[1:])
 
3685
        self.overrideAttr(trace, 'warning', warning)
 
3686
        remaining_conflicts = resolve_conflicts(tt)
 
3687
        # We fallback to the default policy which create a conflict
 
3688
        self.assertLength(1, remaining_conflicts)
 
3689
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
 
3690
                         remaining_conflicts.pop())
 
3691
        self.assertLength(1, warnings)
 
3692
        self.assertStartsWith(warnings[0], 'Value "donttouchmypreciouuus" ')
 
3693
 
 
3694
 
 
3695
class TestTransformHooks(tests.TestCaseWithTransport):
 
3696
 
 
3697
    def setUp(self):
 
3698
        super(TestTransformHooks, self).setUp()
 
3699
        self.wt = self.make_branch_and_tree('.')
 
3700
        os.chdir('..')
 
3701
 
 
3702
    def get_transform(self):
 
3703
        transform = TreeTransform(self.wt)
 
3704
        self.addCleanup(transform.finalize)
 
3705
        return transform, transform.root
 
3706
 
 
3707
    def test_pre_commit_hooks(self):
 
3708
        calls = []
 
3709
        def record_pre_transform(tree, tt):
 
3710
            calls.append((tree, tt))
 
3711
        MutableTree.hooks.install_named_hook('pre_transform',
 
3712
            record_pre_transform, "Pre transform")
 
3713
        transform, root = self.get_transform()
 
3714
        old_root_id = transform.tree_file_id(root)
 
3715
        transform.apply()
 
3716
        self.assertEqual(old_root_id, self.wt.get_root_id())
 
3717
        self.assertEqual([(self.wt, transform)], calls)
 
3718
 
 
3719
    def test_post_commit_hooks(self):
 
3720
        calls = []
 
3721
        def record_post_transform(tree, tt):
 
3722
            calls.append((tree, tt))
 
3723
        MutableTree.hooks.install_named_hook('post_transform',
 
3724
            record_post_transform, "Post transform")
 
3725
        transform, root = self.get_transform()
 
3726
        old_root_id = transform.tree_file_id(root)
 
3727
        transform.apply()
 
3728
        self.assertEqual(old_root_id, self.wt.get_root_id())
 
3729
        self.assertEqual([(self.wt, transform)], calls)