← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-10-13 06:08:53 UTC
  • mfrom: (4737.1.1 merge-2.0-into-devel)
  • Revision ID: pqm@pqm.ubuntu.com-20091013060853-erk2aaj80fnkrv25
(andrew) Merge lp:bzr/2.0 into lp:bzr, including fixes for #322807,
        #389413, #402623 and documentation improvements.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
1
 
# Copyright (C) 2006-2011 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
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
18
17
import os
 
18
import stat
19
19
from StringIO import StringIO
20
20
import sys
21
 
import time
22
21
 
23
22
from bzrlib import (
24
23
    bencode,
25
24
    errors,
26
 
    filters,
27
25
    generate_ids,
28
26
    osutils,
 
27
    progress,
29
28
    revision as _mod_revision,
30
 
    rules,
31
29
    symbol_versioning,
32
30
    tests,
33
 
    trace,
34
 
    transform,
35
31
    urlutils,
36
32
    )
37
 
from bzrlib.conflicts import (
38
 
    DeletingParent,
39
 
    DuplicateEntry,
40
 
    DuplicateID,
41
 
    MissingParent,
42
 
    NonDirectoryParent,
43
 
    ParentLoop,
44
 
    UnversionedParent,
45
 
)
46
 
from bzrlib.controldir import ControlDir
 
33
from bzrlib.bzrdir import BzrDir
 
34
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
 
35
                              UnversionedParent, ParentLoop, DeletingParent,
 
36
                              NonDirectoryParent)
47
37
from bzrlib.diff import show_diff_trees
48
 
from bzrlib.errors import (
49
 
    DuplicateKey,
50
 
    ExistingLimbo,
51
 
    ExistingPendingDeletion,
52
 
    ImmortalLimbo,
53
 
    ImmortalPendingDeletion,
54
 
    LockError,
55
 
    MalformedTransform,
56
 
    ReusingTransform,
57
 
)
58
 
from bzrlib.osutils import (
59
 
    file_kind,
60
 
    pathjoin,
61
 
)
 
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
62
44
from bzrlib.merge import Merge3Merger, Merger
63
 
from bzrlib.mutabletree import MutableTree
64
45
from bzrlib.tests import (
65
 
    features,
 
46
    HardlinkFeature,
 
47
    SymlinkFeature,
 
48
    TestCase,
66
49
    TestCaseInTempDir,
67
50
    TestSkipped,
68
51
    )
69
 
from bzrlib.tests.features import (
70
 
    HardlinkFeature,
71
 
    SymlinkFeature,
72
 
    )
73
 
from bzrlib.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
 
)
 
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)
85
57
 
86
58
 
87
59
class TestTreeTransform(tests.TestCaseWithTransport):
88
60
 
89
61
    def setUp(self):
90
62
        super(TestTreeTransform, self).setUp()
91
 
        self.wt = self.make_branch_and_tree('.', format='development-subtree')
 
63
        self.wt = self.make_branch_and_tree('.', format='dirstate-with-subtree')
92
64
        os.chdir('..')
93
65
 
94
66
    def get_transform(self):
96
68
        self.addCleanup(transform.finalize)
97
69
        return transform, transform.root
98
70
 
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
 
 
109
71
    def test_existing_limbo(self):
110
72
        transform, root = self.get_transform()
111
73
        limbo_name = transform._limbodir
138
100
        imaginary_id = transform.trans_id_tree_path('imaginary')
139
101
        imaginary_id2 = transform.trans_id_tree_path('imaginary/')
140
102
        self.assertEqual(imaginary_id, imaginary_id2)
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))
 
103
        self.assertEqual(transform.get_tree_parent(imaginary_id), root)
 
104
        self.assertEqual(transform.final_kind(root), 'directory')
 
105
        self.assertEqual(transform.final_file_id(root), self.wt.get_root_id())
144
106
        trans_id = transform.create_path('name', root)
145
107
        self.assertIs(transform.final_file_id(trans_id), None)
146
 
        self.assertIs(None, transform.final_kind(trans_id))
 
108
        self.assertRaises(NoSuchFile, transform.final_kind, trans_id)
147
109
        transform.create_file('contents', trans_id)
148
110
        transform.set_executability(True, trans_id)
149
111
        transform.version_file('my_pretties', trans_id)
174
136
        transform.finalize()
175
137
        transform.finalize()
176
138
 
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
 
 
238
 
    def test_create_files_same_timestamp(self):
239
 
        transform, root = self.get_transform()
240
 
        self.wt.lock_tree_write()
241
 
        self.addCleanup(self.wt.unlock)
242
 
        # Roll back the clock, so that we know everything is being set to the
243
 
        # exact time
244
 
        transform._creation_mtime = creation_mtime = time.time() - 20.0
245
 
        transform.create_file('content-one',
246
 
                              transform.create_path('one', root))
247
 
        time.sleep(1) # *ugly*
248
 
        transform.create_file('content-two',
249
 
                              transform.create_path('two', root))
250
 
        transform.apply()
251
 
        fo, st1 = self.wt.get_file_with_stat(None, path='one', filtered=False)
252
 
        fo.close()
253
 
        fo, st2 = self.wt.get_file_with_stat(None, path='two', filtered=False)
254
 
        fo.close()
255
 
        # We only guarantee 2s resolution
256
 
        self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
257
 
            "%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
258
 
        # But if we have more than that, all files should get the same result
259
 
        self.assertEqual(st1.st_mtime, st2.st_mtime)
260
 
 
261
 
    def test_change_root_id(self):
262
 
        transform, root = self.get_transform()
263
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
264
 
        transform.new_directory('', ROOT_PARENT, 'new-root-id')
265
 
        transform.delete_contents(root)
266
 
        transform.unversion_file(root)
267
 
        transform.fixup_new_roots()
268
 
        transform.apply()
269
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
270
 
 
271
 
    def test_change_root_id_add_files(self):
272
 
        transform, root = self.get_transform()
273
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
274
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
275
 
        transform.new_file('file', new_trans_id, ['new-contents\n'],
276
 
                           'new-file-id')
277
 
        transform.delete_contents(root)
278
 
        transform.unversion_file(root)
279
 
        transform.fixup_new_roots()
280
 
        transform.apply()
281
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
282
 
        self.assertEqual('new-file-id', self.wt.path2id('file'))
283
 
        self.assertFileEqual('new-contents\n', self.wt.abspath('file'))
284
 
 
285
 
    def test_add_two_roots(self):
286
 
        transform, root = self.get_transform()
287
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
288
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
289
 
        self.assertRaises(ValueError, transform.fixup_new_roots)
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
 
 
353
139
    def test_hardlink(self):
354
140
        self.requireFeature(HardlinkFeature)
355
141
        transform, root = self.get_transform()
360
146
        trans_id = target_transform.create_path('file1', target_transform.root)
361
147
        target_transform.create_hardlink(self.wt.abspath('file1'), trans_id)
362
148
        target_transform.apply()
363
 
        self.assertPathExists('target/file1')
 
149
        self.failUnlessExists('target/file1')
364
150
        source_stat = os.stat(self.wt.abspath('file1'))
365
151
        target_stat = os.stat('target/file1')
366
152
        self.assertEqual(source_stat, target_stat)
399
185
        tree.lock_read()
400
186
        self.addCleanup(tree.unlock)
401
187
        self.assertEqual('subtree-revision',
402
 
                         tree.root_inventory['subtree-id'].reference_revision)
 
188
                         tree.inventory['subtree-id'].reference_revision)
403
189
 
404
190
    def test_conflicts(self):
405
191
        transform, root = self.get_transform()
532
318
        transform.new_file('FiLe', transform.root, 'content')
533
319
        resolve_conflicts(transform)
534
320
        transform.apply()
535
 
        self.assertPathExists('tree/file')
536
 
        self.assertPathExists('tree/FiLe.moved')
 
321
        self.failUnlessExists('tree/file')
 
322
        self.failUnlessExists('tree/FiLe.moved')
537
323
 
538
324
    def test_resolve_checkout_case_conflict(self):
539
325
        tree = self.make_branch_and_tree('tree')
548
334
        resolve_conflicts(transform,
549
335
                          pass_func=lambda t, c: resolve_checkout(t, c, []))
550
336
        transform.apply()
551
 
        self.assertPathExists('tree/file')
552
 
        self.assertPathExists('tree/FiLe.moved')
 
337
        self.failUnlessExists('tree/file')
 
338
        self.failUnlessExists('tree/FiLe.moved')
553
339
 
554
340
    def test_apply_case_conflict(self):
555
341
        """Ensure that a transform with case conflicts can always be applied"""
563
349
        transform.new_file('dirFiLe', dir, 'content')
564
350
        resolve_conflicts(transform)
565
351
        transform.apply()
566
 
        self.assertPathExists('tree/file')
 
352
        self.failUnlessExists('tree/file')
567
353
        if not os.path.exists('tree/FiLe.moved'):
568
 
            self.assertPathExists('tree/FiLe')
569
 
        self.assertPathExists('tree/dir/dirfile')
 
354
            self.failUnlessExists('tree/FiLe')
 
355
        self.failUnlessExists('tree/dir/dirfile')
570
356
        if not os.path.exists('tree/dir/dirFiLe.moved'):
571
 
            self.assertPathExists('tree/dir/dirFiLe')
 
357
            self.failUnlessExists('tree/dir/dirFiLe')
572
358
 
573
359
    def test_case_insensitive_limbo(self):
574
360
        tree = self.make_branch_and_tree('tree')
583
369
        self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
584
370
        self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
585
371
 
586
 
    def test_adjust_path_updates_child_limbo_names(self):
587
 
        tree = self.make_branch_and_tree('tree')
588
 
        transform = TreeTransform(tree)
589
 
        self.addCleanup(transform.finalize)
590
 
        foo_id = transform.new_directory('foo', transform.root)
591
 
        bar_id = transform.new_directory('bar', foo_id)
592
 
        baz_id = transform.new_directory('baz', bar_id)
593
 
        qux_id = transform.new_directory('qux', baz_id)
594
 
        transform.adjust_path('quxx', foo_id, bar_id)
595
 
        self.assertStartsWith(transform._limbo_name(qux_id),
596
 
                              transform._limbo_name(bar_id))
597
 
 
598
372
    def test_add_del(self):
599
373
        start, root = self.get_transform()
600
374
        start.new_directory('a', root, 'a')
782
556
                            'wizard2', 'behind_curtain')
783
557
 
784
558
    def test_symlinks_unicode(self):
785
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
559
        self.requireFeature(tests.UnicodeFilenameFeature)
786
560
        self._test_symlinks(u'\N{Euro Sign}wizard',
787
561
                            u'wizard-targ\N{Euro Sign}t',
788
562
                            u'\N{Euro Sign}wizard2',
876
650
        raw_conflicts = resolve_conflicts(tt)
877
651
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
878
652
        tt.finalize()
879
 
        conflicts_s = [unicode(c) for c in cooked_conflicts]
 
653
        conflicts_s = [str(c) for c in cooked_conflicts]
880
654
        self.assertEqual(len(cooked_conflicts), len(conflicts_s))
881
655
        self.assertEqual(conflicts_s[0], 'Conflict adding file dorothy.  '
882
656
                                         'Moved existing file to '
895
669
                                         ' versioned, but has versioned'
896
670
                                         ' children.  Versioned directory.')
897
671
        self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
898
 
                                         ' oz/emeraldcity. Cancelled move.')
 
672
                                         ' oz/emeraldcity.  Cancelled move.')
899
673
 
900
674
    def prepare_wrong_parent_kind(self):
901
675
        tt, root = self.get_transform()
952
726
        self.assertIs(None, self.wt.path2id('parent'))
953
727
        self.assertIs(None, self.wt.path2id('parent.new'))
954
728
 
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
 
 
970
729
    def test_moving_versioned_directories(self):
971
730
        create, root = self.get_transform()
972
731
        kansas = create.new_directory('kansas', root, 'kansas-id')
987
746
        create.apply()
988
747
        transform, root = self.get_transform()
989
748
        transform.adjust_root_path('oldroot', fun)
990
 
        new_root = transform.trans_id_tree_path('')
 
749
        new_root=transform.trans_id_tree_path('')
991
750
        transform.version_file('new-root', new_root)
992
751
        transform.apply()
993
752
 
1005
764
        rename.set_executability(True, myfile)
1006
765
        rename.apply()
1007
766
 
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
 
 
1046
767
    def test_set_executability_order(self):
1047
768
        """Ensure that executability behaves the same, no matter what order.
1048
769
 
1320
1041
        parent2 = transform.new_directory('parent2', root)
1321
1042
        transform.adjust_path('child1', parent2, child1)
1322
1043
        transform.apply()
1323
 
        self.assertPathDoesNotExist(self.wt.abspath('parent1/child1'))
1324
 
        self.assertPathExists(self.wt.abspath('parent2/child1'))
 
1044
        self.failIfExists(self.wt.abspath('parent1/child1'))
 
1045
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
1325
1046
        # rename limbo/new-1 => parent1, rename limbo/new-3 => parent2
1326
1047
        # no rename for child1 (counting only renames during apply)
1327
 
        self.assertEqual(2, transform.rename_count)
 
1048
        self.failUnlessEqual(2, transform.rename_count)
1328
1049
 
1329
1050
    def test_cancel_parent(self):
1330
1051
        """Cancelling a parent doesn't cause deletion of a non-empty directory
1353
1074
        parent2 = transform.new_directory('parent2', root)
1354
1075
        transform.adjust_path('child1', parent2, child1)
1355
1076
        transform.apply()
1356
 
        self.assertPathDoesNotExist(self.wt.abspath('parent1'))
1357
 
        self.assertPathExists(self.wt.abspath('parent2/child1'))
 
1077
        self.failIfExists(self.wt.abspath('parent1'))
 
1078
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
1358
1079
        # rename limbo/new-3 => parent2, rename limbo/new-2 => child1
1359
 
        self.assertEqual(2, transform.rename_count)
 
1080
        self.failUnlessEqual(2, transform.rename_count)
1360
1081
 
1361
1082
    def test_adjust_and_cancel(self):
1362
1083
        """Make sure adjust_path keeps track of limbo children properly"""
1395
1116
        child = transform.new_directory('child', parent)
1396
1117
        transform.adjust_path('parent', root, parent)
1397
1118
        transform.apply()
1398
 
        self.assertPathExists(self.wt.abspath('parent/child'))
 
1119
        self.failUnlessExists(self.wt.abspath('parent/child'))
1399
1120
        self.assertEqual(1, transform.rename_count)
1400
1121
 
1401
1122
    def test_reuse_name(self):
1477
1198
        # The rename will fail because the target directory is not empty (but
1478
1199
        # raises FileExists anyway).
1479
1200
        err = self.assertRaises(errors.FileExists, tt_helper)
1480
 
        self.assertEndsWith(err.path, "/baz")
 
1201
        self.assertContainsRe(str(err),
 
1202
            "^File exists: .+/baz")
1481
1203
 
1482
1204
    def test_two_directories_clash(self):
1483
1205
        def tt_helper():
1495
1217
                wt.unlock()
1496
1218
                raise
1497
1219
        err = self.assertRaises(errors.FileExists, tt_helper)
1498
 
        self.assertEndsWith(err.path, "/foo")
 
1220
        self.assertContainsRe(str(err),
 
1221
            "^File exists: .+/foo")
1499
1222
 
1500
1223
    def test_two_directories_clash_finalize(self):
1501
1224
        def tt_helper():
1513
1236
                tt.finalize()
1514
1237
                raise
1515
1238
        err = self.assertRaises(errors.FileExists, tt_helper)
1516
 
        self.assertEndsWith(err.path, "/foo")
 
1239
        self.assertContainsRe(str(err),
 
1240
            "^File exists: .+/foo")
1517
1241
 
1518
1242
    def test_file_to_directory(self):
1519
1243
        wt = self.make_branch_and_tree('.')
1529
1253
        tt.create_file(["aa\n"], bar_trans_id)
1530
1254
        tt.version_file("bar-1", bar_trans_id)
1531
1255
        tt.apply()
1532
 
        self.assertPathExists("foo/bar")
 
1256
        self.failUnlessExists("foo/bar")
1533
1257
        wt.lock_read()
1534
1258
        try:
1535
 
            self.assertEqual(wt.kind(wt.path2id("foo")), "directory")
 
1259
            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1260
                    "directory")
1536
1261
        finally:
1537
1262
            wt.unlock()
1538
1263
        wt.commit("two")
1551
1276
        tt.delete_contents(foo_trans_id)
1552
1277
        tt.create_symlink("bar", foo_trans_id)
1553
1278
        tt.apply()
1554
 
        self.assertPathExists("foo")
 
1279
        self.failUnlessExists("foo")
1555
1280
        wt.lock_read()
1556
1281
        self.addCleanup(wt.unlock)
1557
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "symlink")
 
1282
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1283
                "symlink")
1558
1284
 
1559
1285
    def test_dir_to_file(self):
1560
1286
        wt = self.make_branch_and_tree('.')
1569
1295
        tt.delete_versioned(bar_trans_id)
1570
1296
        tt.create_file(["aa\n"], foo_trans_id)
1571
1297
        tt.apply()
1572
 
        self.assertPathExists("foo")
 
1298
        self.failUnlessExists("foo")
1573
1299
        wt.lock_read()
1574
1300
        self.addCleanup(wt.unlock)
1575
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
 
1301
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1302
                "file")
1576
1303
 
1577
1304
    def test_dir_to_hardlink(self):
1578
1305
        self.requireFeature(HardlinkFeature)
1589
1316
        self.build_tree(['baz'])
1590
1317
        tt.create_hardlink("baz", foo_trans_id)
1591
1318
        tt.apply()
1592
 
        self.assertPathExists("foo")
1593
 
        self.assertPathExists("baz")
 
1319
        self.failUnlessExists("foo")
 
1320
        self.failUnlessExists("baz")
1594
1321
        wt.lock_read()
1595
1322
        self.addCleanup(wt.unlock)
1596
 
        self.assertEqual(wt.kind(wt.path2id("foo")), "file")
 
1323
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
 
1324
                "file")
1597
1325
 
1598
1326
    def test_no_final_path(self):
1599
1327
        transform, root = self.get_transform()
1645
1373
    def __init__(self, dirname, root_id):
1646
1374
        self.name = dirname
1647
1375
        os.mkdir(dirname)
1648
 
        self.wt = ControlDir.create_standalone_workingtree(dirname)
 
1376
        self.wt = BzrDir.create_standalone_workingtree(dirname)
1649
1377
        self.wt.set_root_id(root_id)
1650
1378
        self.b = self.wt.branch
1651
1379
        self.tt = TreeTransform(self.wt)
1657
1385
    return template % ('<' * 7, tree, '=' * 7, merge, '>' * 7)
1658
1386
 
1659
1387
 
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
 
 
1692
1388
class TestTransformMerge(TestCaseInTempDir):
1693
1389
 
1694
1390
    def test_text_merge(self):
1761
1457
        merge_modified = this.wt.merge_modified()
1762
1458
        self.assertSubset(merge_modified, modified)
1763
1459
        self.assertEqual(len(merge_modified), len(modified))
1764
 
        with file(this.wt.id2abspath('a'), 'wb') as f: f.write('booga')
 
1460
        file(this.wt.id2abspath('a'), 'wb').write('booga')
1765
1461
        modified.pop(0)
1766
1462
        merge_modified = this.wt.merge_modified()
1767
1463
        self.assertSubset(merge_modified, modified)
1881
1577
    def test_build_tree_with_symlinks(self):
1882
1578
        self.requireFeature(SymlinkFeature)
1883
1579
        os.mkdir('a')
1884
 
        a = ControlDir.create_standalone_workingtree('a')
 
1580
        a = BzrDir.create_standalone_workingtree('a')
1885
1581
        os.mkdir('a/foo')
1886
 
        with file('a/foo/bar', 'wb') as f: f.write('contents')
 
1582
        file('a/foo/bar', 'wb').write('contents')
1887
1583
        os.symlink('a/foo/bar', 'a/foo/baz')
1888
1584
        a.add(['foo', 'foo/bar', 'foo/baz'])
1889
1585
        a.commit('initial commit')
1890
 
        b = ControlDir.create_standalone_workingtree('b')
 
1586
        b = BzrDir.create_standalone_workingtree('b')
1891
1587
        basis = a.basis_tree()
1892
1588
        basis.lock_read()
1893
1589
        self.addCleanup(basis.unlock)
1898
1594
 
1899
1595
    def test_build_with_references(self):
1900
1596
        tree = self.make_branch_and_tree('source',
1901
 
            format='development-subtree')
 
1597
            format='dirstate-with-subtree')
1902
1598
        subtree = self.make_branch_and_tree('source/subtree',
1903
 
            format='development-subtree')
 
1599
            format='dirstate-with-subtree')
1904
1600
        tree.add_reference(subtree)
1905
1601
        tree.commit('a revision')
1906
1602
        tree.branch.create_checkout('target')
1907
 
        self.assertPathExists('target')
1908
 
        self.assertPathExists('target/subtree')
 
1603
        self.failUnlessExists('target')
 
1604
        self.failUnlessExists('target/subtree')
1909
1605
 
1910
1606
    def test_file_conflict_handling(self):
1911
1607
        """Ensure that when building trees, conflict handling is done"""
1958
1654
        source.commit('added file')
1959
1655
        build_tree(source.basis_tree(), target)
1960
1656
        self.assertEqual([], target.conflicts())
1961
 
        self.assertPathExists('target/dir1/file')
 
1657
        self.failUnlessExists('target/dir1/file')
1962
1658
 
1963
1659
        # Ensure contents are merged
1964
1660
        target = self.make_branch_and_tree('target2')
1965
1661
        self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
1966
1662
        build_tree(source.basis_tree(), target)
1967
1663
        self.assertEqual([], target.conflicts())
1968
 
        self.assertPathExists('target2/dir1/file2')
1969
 
        self.assertPathExists('target2/dir1/file')
 
1664
        self.failUnlessExists('target2/dir1/file2')
 
1665
        self.failUnlessExists('target2/dir1/file')
1970
1666
 
1971
1667
        # Ensure new contents are suppressed for existing branches
1972
1668
        target = self.make_branch_and_tree('target3')
1973
1669
        self.make_branch('target3/dir1')
1974
1670
        self.build_tree(['target3/dir1/file2'])
1975
1671
        build_tree(source.basis_tree(), target)
1976
 
        self.assertPathDoesNotExist('target3/dir1/file')
1977
 
        self.assertPathExists('target3/dir1/file2')
1978
 
        self.assertPathExists('target3/dir1.diverted/file')
 
1672
        self.failIfExists('target3/dir1/file')
 
1673
        self.failUnlessExists('target3/dir1/file2')
 
1674
        self.failUnlessExists('target3/dir1.diverted/file')
1979
1675
        self.assertEqual([DuplicateEntry('Diverted to',
1980
1676
            'dir1.diverted', 'dir1', 'new-dir1', None)],
1981
1677
            target.conflicts())
1984
1680
        self.build_tree(['target4/dir1/'])
1985
1681
        self.make_branch('target4/dir1/file')
1986
1682
        build_tree(source.basis_tree(), target)
1987
 
        self.assertPathExists('target4/dir1/file')
 
1683
        self.failUnlessExists('target4/dir1/file')
1988
1684
        self.assertEqual('directory', file_kind('target4/dir1/file'))
1989
 
        self.assertPathExists('target4/dir1/file.diverted')
 
1685
        self.failUnlessExists('target4/dir1/file.diverted')
1990
1686
        self.assertEqual([DuplicateEntry('Diverted to',
1991
1687
            'dir1/file.diverted', 'dir1/file', 'new-file', None)],
1992
1688
            target.conflicts())
2060
1756
        self.addCleanup(target.unlock)
2061
1757
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2062
1758
 
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
 
 
2075
1759
    def test_build_tree_accelerator_tree_missing_file(self):
2076
1760
        source = self.create_ab_tree()
2077
1761
        os.unlink('source/file1')
2172
1856
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2173
1857
        self.assertTrue(source.is_executable('file1-id'))
2174
1858
 
2175
 
    def install_rot13_content_filter(self, pattern):
2176
 
        # We could use
2177
 
        # self.addCleanup(filters._reset_registry, filters._reset_registry())
2178
 
        # below, but that looks a bit... hard to read even if it's exactly
2179
 
        # the same thing.
2180
 
        original_registry = filters._reset_registry()
2181
 
        def restore_registry():
2182
 
            filters._reset_registry(original_registry)
2183
 
        self.addCleanup(restore_registry)
2184
 
        def rot13(chunks, context=None):
2185
 
            return [''.join(chunks).encode('rot13')]
2186
 
        rot13filter = filters.ContentFilter(rot13, rot13)
2187
 
        filters.filter_stacks_registry.register(
2188
 
            'rot13', {'yes': [rot13filter]}.get)
2189
 
        os.mkdir(self.test_home_dir + '/.bazaar')
2190
 
        rules_filename = self.test_home_dir + '/.bazaar/rules'
2191
 
        f = open(rules_filename, 'wb')
2192
 
        f.write('[name %s]\nrot13=yes\n' % (pattern,))
2193
 
        f.close()
2194
 
        def uninstall_rules():
2195
 
            os.remove(rules_filename)
2196
 
            rules.reset_rules()
2197
 
        self.addCleanup(uninstall_rules)
2198
 
        rules.reset_rules()
2199
 
 
2200
 
    def test_build_tree_content_filtered_files_are_not_hardlinked(self):
2201
 
        """build_tree will not hardlink files that have content filtering rules
2202
 
        applied to them (but will still hardlink other files from the same tree
2203
 
        if it can).
2204
 
        """
2205
 
        self.requireFeature(HardlinkFeature)
2206
 
        self.install_rot13_content_filter('file1')
2207
 
        source = self.create_ab_tree()
2208
 
        target = self.make_branch_and_tree('target')
2209
 
        revision_tree = source.basis_tree()
2210
 
        revision_tree.lock_read()
2211
 
        self.addCleanup(revision_tree.unlock)
2212
 
        build_tree(revision_tree, target, source, hardlink=True)
2213
 
        target.lock_read()
2214
 
        self.addCleanup(target.unlock)
2215
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2216
 
        source_stat = os.stat('source/file1')
2217
 
        target_stat = os.stat('target/file1')
2218
 
        self.assertNotEqual(source_stat, target_stat)
2219
 
        source_stat = os.stat('source/file2')
2220
 
        target_stat = os.stat('target/file2')
2221
 
        self.assertEqualStat(source_stat, target_stat)
2222
 
 
2223
1859
    def test_case_insensitive_build_tree_inventory(self):
2224
 
        if (features.CaseInsensitiveFilesystemFeature.available()
2225
 
            or features.CaseInsCasePresFilenameFeature.available()):
 
1860
        if (tests.CaseInsensitiveFilesystemFeature.available()
 
1861
            or tests.CaseInsCasePresFilenameFeature.available()):
2226
1862
            raise tests.UnavailableFeature('Fully case sensitive filesystem')
2227
1863
        source = self.make_branch_and_tree('source')
2228
1864
        self.build_tree(['source/file', 'source/FILE'])
2236
1872
        self.assertEqual('file.moved', target.id2path('lower-id'))
2237
1873
        self.assertEqual('FILE', target.id2path('upper-id'))
2238
1874
 
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
 
 
2275
1875
 
2276
1876
class TestCommitTransform(tests.TestCaseWithTransport):
2277
1877
 
2339
1939
        branch, tt = self.get_branch_and_transform()
2340
1940
        tt.new_file('file', tt.root, 'contents', 'file-id')
2341
1941
        trans_id = tt.new_directory('dir', tt.root, 'dir-id')
2342
 
        if SymlinkFeature.available():
2343
 
            tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
 
1942
        tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
2344
1943
        rev = tt.commit(branch, 'message')
2345
1944
        tree = branch.basis_tree()
2346
1945
        self.assertEqual('file', tree.id2path('file-id'))
2347
1946
        self.assertEqual('contents', tree.get_file_text('file-id'))
2348
1947
        self.assertEqual('dir', tree.id2path('dir-id'))
2349
 
        if SymlinkFeature.available():
2350
 
            self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
2351
 
            self.assertEqual('target', tree.get_symlink_target('symlink-id'))
 
1948
        self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
 
1949
        self.assertEqual('target', tree.get_symlink_target('symlink-id'))
2352
1950
 
2353
1951
    def test_add_unversioned(self):
2354
1952
        branch, tt = self.get_branch_and_transform()
2378
1976
        self.assertRaises(errors.MalformedTransform, tt.commit, branch,
2379
1977
                          'message')
2380
1978
 
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'])
 
1979
 
 
1980
class MockTransform(object):
 
1981
 
 
1982
    def has_named_child(self, by_parent, parent_id, name):
 
1983
        for child_id in by_parent[parent_id]:
 
1984
            if child_id == '0':
 
1985
                if name == "name~":
 
1986
                    return True
 
1987
            elif name == "name.~%s~" % child_id:
 
1988
                return True
 
1989
        return False
 
1990
 
 
1991
 
 
1992
class MockEntry(object):
 
1993
    def __init__(self):
 
1994
        object.__init__(self)
 
1995
        self.name = "name"
 
1996
 
 
1997
 
 
1998
class TestGetBackupName(TestCase):
 
1999
    def test_get_backup_name(self):
 
2000
        tt = MockTransform()
 
2001
        name = get_backup_name(MockEntry(), {'a':[]}, 'a', tt)
 
2002
        self.assertEqual(name, 'name.~1~')
 
2003
        name = get_backup_name(MockEntry(), {'a':['1']}, 'a', tt)
 
2004
        self.assertEqual(name, 'name.~2~')
 
2005
        name = get_backup_name(MockEntry(), {'a':['2']}, 'a', tt)
 
2006
        self.assertEqual(name, 'name.~1~')
 
2007
        name = get_backup_name(MockEntry(), {'a':['2'], 'b':[]}, 'b', tt)
 
2008
        self.assertEqual(name, 'name.~1~')
 
2009
        name = get_backup_name(MockEntry(), {'a':['1', '2', '3']}, 'a', tt)
 
2010
        self.assertEqual(name, 'name.~4~')
2412
2011
 
2413
2012
 
2414
2013
class TestFileMover(tests.TestCaseWithTransport):
2417
2016
        self.build_tree(['a/', 'a/b', 'c/', 'c/d'])
2418
2017
        mover = _FileMover()
2419
2018
        mover.rename('a', 'q')
2420
 
        self.assertPathExists('q')
2421
 
        self.assertPathDoesNotExist('a')
2422
 
        self.assertPathExists('q/b')
2423
 
        self.assertPathExists('c')
2424
 
        self.assertPathExists('c/d')
 
2019
        self.failUnlessExists('q')
 
2020
        self.failIfExists('a')
 
2021
        self.failUnlessExists('q/b')
 
2022
        self.failUnlessExists('c')
 
2023
        self.failUnlessExists('c/d')
2425
2024
 
2426
2025
    def test_pre_delete_rollback(self):
2427
2026
        self.build_tree(['a/'])
2428
2027
        mover = _FileMover()
2429
2028
        mover.pre_delete('a', 'q')
2430
 
        self.assertPathExists('q')
2431
 
        self.assertPathDoesNotExist('a')
 
2029
        self.failUnlessExists('q')
 
2030
        self.failIfExists('a')
2432
2031
        mover.rollback()
2433
 
        self.assertPathDoesNotExist('q')
2434
 
        self.assertPathExists('a')
 
2032
        self.failIfExists('q')
 
2033
        self.failUnlessExists('a')
2435
2034
 
2436
2035
    def test_apply_deletions(self):
2437
2036
        self.build_tree(['a/', 'b/'])
2438
2037
        mover = _FileMover()
2439
2038
        mover.pre_delete('a', 'q')
2440
2039
        mover.pre_delete('b', 'r')
2441
 
        self.assertPathExists('q')
2442
 
        self.assertPathExists('r')
2443
 
        self.assertPathDoesNotExist('a')
2444
 
        self.assertPathDoesNotExist('b')
 
2040
        self.failUnlessExists('q')
 
2041
        self.failUnlessExists('r')
 
2042
        self.failIfExists('a')
 
2043
        self.failIfExists('b')
2445
2044
        mover.apply_deletions()
2446
 
        self.assertPathDoesNotExist('q')
2447
 
        self.assertPathDoesNotExist('r')
2448
 
        self.assertPathDoesNotExist('a')
2449
 
        self.assertPathDoesNotExist('b')
 
2045
        self.failIfExists('q')
 
2046
        self.failIfExists('r')
 
2047
        self.failIfExists('a')
 
2048
        self.failIfExists('b')
2450
2049
 
2451
2050
    def test_file_mover_rollback(self):
2452
2051
        self.build_tree(['a/', 'a/b', 'c/', 'c/d/', 'c/e/'])
2457
2056
            mover.rename('a', 'c')
2458
2057
        except errors.FileExists, e:
2459
2058
            mover.rollback()
2460
 
        self.assertPathExists('a')
2461
 
        self.assertPathExists('c/d')
 
2059
        self.failUnlessExists('a')
 
2060
        self.failUnlessExists('c/d')
2462
2061
 
2463
2062
 
2464
2063
class Bogus(Exception):
2494
2093
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2495
2094
        self.assertRaises(Bogus, tt.apply,
2496
2095
                          _mover=self.ExceptionFileMover(bad_source='a'))
2497
 
        self.assertPathExists('a')
2498
 
        self.assertPathExists('a/b')
 
2096
        self.failUnlessExists('a')
 
2097
        self.failUnlessExists('a/b')
2499
2098
        tt.apply()
2500
 
        self.assertPathExists('c')
2501
 
        self.assertPathExists('c/d')
 
2099
        self.failUnlessExists('c')
 
2100
        self.failUnlessExists('c/d')
2502
2101
 
2503
2102
    def test_rollback_rename_into_place(self):
2504
2103
        tree = self.make_branch_and_tree('.')
2510
2109
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2511
2110
        self.assertRaises(Bogus, tt.apply,
2512
2111
                          _mover=self.ExceptionFileMover(bad_target='c/d'))
2513
 
        self.assertPathExists('a')
2514
 
        self.assertPathExists('a/b')
 
2112
        self.failUnlessExists('a')
 
2113
        self.failUnlessExists('a/b')
2515
2114
        tt.apply()
2516
 
        self.assertPathExists('c')
2517
 
        self.assertPathExists('c/d')
 
2115
        self.failUnlessExists('c')
 
2116
        self.failUnlessExists('c/d')
2518
2117
 
2519
2118
    def test_rollback_deletion(self):
2520
2119
        tree = self.make_branch_and_tree('.')
2526
2125
        tt.adjust_path('d', tt.root, tt.trans_id_tree_path('a/b'))
2527
2126
        self.assertRaises(Bogus, tt.apply,
2528
2127
                          _mover=self.ExceptionFileMover(bad_target='d'))
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):
 
2128
        self.failUnlessExists('a')
 
2129
        self.failUnlessExists('a/b')
 
2130
 
 
2131
    def test_resolve_no_parent(self):
2660
2132
        wt = self.make_branch_and_tree('.')
2661
 
        self.build_tree(['dir/',])
2662
 
        wt.add(['dir'], ['dir-id'])
2663
 
        wt.commit('Create dir')
2664
2133
        tt = TreeTransform(wt)
2665
2134
        self.addCleanup(tt.finalize)
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())
 
2135
        parent = tt.trans_id_file_id('parent-id')
 
2136
        tt.new_file('file', parent, 'Contents')
 
2137
        resolve_conflicts(tt)
2690
2138
 
2691
2139
 
2692
2140
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
2693
2141
                  ('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2694
2142
                  (False, False))
2695
2143
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
2696
 
              ('', ''), ('directory', 'directory'), (False, False))
 
2144
              ('', ''), ('directory', 'directory'), (False, None))
2697
2145
 
2698
2146
 
2699
2147
class TestTransformPreview(tests.TestCaseWithTransport):
2768
2216
 
2769
2217
    def test_iter_changes(self):
2770
2218
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2771
 
        root = revision_tree.get_root_id()
 
2219
        root = revision_tree.inventory.root.file_id
2772
2220
        self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
2773
2221
                          (root, root), ('a', 'a'), ('file', 'file'),
2774
2222
                          (False, False))],
2778
2226
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2779
2227
        changes = preview_tree.iter_changes(revision_tree,
2780
2228
                                            include_unchanged=True)
2781
 
        root = revision_tree.get_root_id()
 
2229
        root = revision_tree.inventory.root.file_id
2782
2230
 
2783
2231
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2784
2232
 
2786
2234
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2787
2235
        changes = preview_tree.iter_changes(revision_tree,
2788
2236
                                            specific_files=[''])
2789
 
        self.assertEqual([A_ENTRY], list(changes))
 
2237
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2790
2238
 
2791
2239
    def test_want_unversioned(self):
2792
2240
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2793
2241
        changes = preview_tree.iter_changes(revision_tree,
2794
2242
                                            want_unversioned=True)
2795
 
        self.assertEqual([A_ENTRY], list(changes))
 
2243
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2796
2244
 
2797
2245
    def test_ignore_extra_trees_no_specific_files(self):
2798
2246
        # extra_trees is harmless without specific_files, so we'll silently
2808
2256
    def test_ignore_pb(self):
2809
2257
        # pb could be supported, but TT.iter_changes doesn't support it.
2810
2258
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2811
 
        preview_tree.iter_changes(revision_tree)
 
2259
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
2812
2260
 
2813
2261
    def test_kind(self):
2814
2262
        revision_tree = self.create_tree()
2841
2289
        preview_mtime = preview_tree.get_file_mtime('file-id', 'renamed')
2842
2290
        work_mtime = work_tree.get_file_mtime('file-id', 'file')
2843
2291
 
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
 
 
2856
2292
    def test_get_file(self):
2857
2293
        preview = self.get_empty_preview()
2858
2294
        preview.new_file('file', preview.root, 'contents', 'file-id')
3006
2442
        self.assertEqual(('missing', None, None, None), summary)
3007
2443
 
3008
2444
    def test_file_content_summary_executable(self):
 
2445
        if not osutils.supports_executable():
 
2446
            raise TestNotApplicable()
3009
2447
        preview = self.get_empty_preview()
3010
2448
        path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
3011
2449
        preview.set_executability(True, path_id)
3020
2458
        self.assertIs(None, summary[3])
3021
2459
 
3022
2460
    def test_change_executability(self):
 
2461
        if not osutils.supports_executable():
 
2462
            raise TestNotApplicable()
3023
2463
        tree = self.make_branch_and_tree('tree')
3024
2464
        self.build_tree(['tree/path'])
3025
2465
        tree.add('path')
3039
2479
        # size must be known
3040
2480
        self.assertEqual(len('contents'), summary[1])
3041
2481
        # not executable
3042
 
        self.assertEqual(False, summary[2])
 
2482
        if osutils.supports_executable():
 
2483
            self.assertEqual(False, summary[2])
 
2484
        else:
 
2485
            self.assertEqual(None, summary[2])
3043
2486
        # will not have hash (not cheap to determine)
3044
2487
        self.assertIs(None, summary[3])
3045
2488
 
3188
2631
        preview = self.get_empty_preview()
3189
2632
        root = preview.new_directory('', ROOT_PARENT, 'tree-root')
3190
2633
        # FIXME: new_directory should mark root.
3191
 
        preview.fixup_new_roots()
 
2634
        preview.adjust_path('', ROOT_PARENT, root)
3192
2635
        preview_tree = preview.get_preview_tree()
3193
2636
        file_trans_id = preview.new_file('a', preview.root, 'contents',
3194
2637
                                         'a-id')
3228
2671
        file_trans_id = preview.trans_id_file_id('file-id')
3229
2672
        preview.delete_contents(file_trans_id)
3230
2673
        preview.create_file('a\nb\n', file_trans_id)
 
2674
        pb = progress.DummyProgress()
3231
2675
        preview_tree = preview.get_preview_tree()
3232
 
        merger = Merger.from_revision_ids(None, preview_tree,
 
2676
        merger = Merger.from_revision_ids(pb, preview_tree,
3233
2677
                                          child_tree.branch.last_revision(),
3234
2678
                                          other_branch=child_tree.branch,
3235
2679
                                          tree_branch=work_tree.branch)
3247
2691
        tt.new_file('name', tt.root, 'content', 'file-id')
3248
2692
        tree2 = self.make_branch_and_tree('tree2')
3249
2693
        tree2.set_root_id('TREE_ROOT')
 
2694
        pb = progress.DummyProgress()
3250
2695
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
3251
 
                                         None, tree.basis_tree())
 
2696
                                         pb, tree.basis_tree())
3252
2697
        merger.merge_type = Merge3Merger
3253
2698
        merger.do_merge()
3254
2699
 
3264
2709
        tt.create_file('baz', trans_id)
3265
2710
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
3266
2711
        self.build_tree_contents([('tree2/foo', 'qux')])
3267
 
        pb = None
 
2712
        pb = progress.DummyProgress()
3268
2713
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
3269
2714
                                         pb, tree.basis_tree())
3270
2715
        merger.merge_type = Merge3Merger
3271
2716
        merger.do_merge()
3272
2717
 
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
 
 
3291
2718
    def test_is_executable(self):
3292
2719
        tree = self.make_branch_and_tree('tree')
3293
2720
        preview = TransformPreview(tree)
3315
2742
        rev2_tree = tree.branch.repository.revision_tree(rev2_id)
3316
2743
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
3317
2744
 
3318
 
    def test_ascii_limbo_paths(self):
3319
 
        self.requireFeature(features.UnicodeFilenameFeature)
3320
 
        branch = self.make_branch('any')
3321
 
        tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)
3322
 
        tt = TransformPreview(tree)
3323
 
        self.addCleanup(tt.finalize)
3324
 
        foo_id = tt.new_directory('', ROOT_PARENT)
3325
 
        bar_id = tt.new_file(u'\u1234bar', foo_id, 'contents')
3326
 
        limbo_path = tt._limbo_name(bar_id)
3327
 
        self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)
3328
 
 
3329
2745
 
3330
2746
class FakeSerializer(object):
3331
2747
    """Serializer implementation that simply returns the input.
3339
2755
 
3340
2756
class TestSerializeTransform(tests.TestCaseWithTransport):
3341
2757
 
3342
 
    _test_needs_features = [features.UnicodeFilenameFeature]
 
2758
    _test_needs_features = [tests.UnicodeFilenameFeature]
3343
2759
 
3344
2760
    def get_preview(self, tree=None):
3345
2761
        if tree is None:
3420
2836
        return self.make_records(attribs, contents)
3421
2837
 
3422
2838
    def test_serialize_symlink_creation(self):
3423
 
        self.requireFeature(features.SymlinkFeature)
 
2839
        self.requireFeature(tests.SymlinkFeature)
3424
2840
        tt = self.get_preview()
3425
2841
        tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')
3426
2842
        self.assertSerializesTo(self.symlink_creation_records(), tt)
3427
2843
 
3428
2844
    def test_deserialize_symlink_creation(self):
3429
 
        self.requireFeature(features.SymlinkFeature)
 
2845
        self.requireFeature(tests.SymlinkFeature)
3430
2846
        tt = self.get_preview()
3431
2847
        tt.deserialize(iter(self.symlink_creation_records()))
3432
2848
        abspath = tt._limbo_name('new-1')
3599
3015
        trans_id = tt.trans_id_tree_path('file')
3600
3016
        self.assertEqual((LINES_ONE,),
3601
3017
            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.assertEquals(['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.assertEquals('foo.~1~', tt.final_name(orphan_tid))
3651
 
        self.assertEquals('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.assertEquals([(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.assertEquals([(self.wt, transform)], calls)