← 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: John Arbash Meinel
  • Date: 2009-07-30 23:54:26 UTC
  • mto: This revision was merged to the branch mainline in revision 4580.
  • Revision ID: john@arbash-meinel.com-20090730235426-o8h73swbh7seqaf7
Update the breakin support to support CTRL-BREAK on Windows.

The signal handling code is very similar, but the testing code got a bit clumsy.

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
33
from bzrlib.bzrdir import BzrDir
38
 
from bzrlib.conflicts import (
39
 
    DeletingParent,
40
 
    DuplicateEntry,
41
 
    DuplicateID,
42
 
    MissingParent,
43
 
    NonDirectoryParent,
44
 
    ParentLoop,
45
 
    UnversionedParent,
46
 
)
 
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
45
from bzrlib.tests import (
64
 
    features,
 
46
    HardlinkFeature,
 
47
    SymlinkFeature,
 
48
    TestCase,
65
49
    TestCaseInTempDir,
66
50
    TestSkipped,
67
51
    )
68
 
from bzrlib.tests.features import (
69
 
    HardlinkFeature,
70
 
    SymlinkFeature,
71
 
    )
72
 
from bzrlib.transform import (
73
 
    build_tree,
74
 
    create_from_tree,
75
 
    cook_conflicts,
76
 
    _FileMover,
77
 
    FinalPaths,
78
 
    resolve_conflicts,
79
 
    resolve_checkout,
80
 
    ROOT_PARENT,
81
 
    TransformPreview,
82
 
    TreeTransform,
83
 
)
 
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)
84
57
 
85
58
 
86
59
class TestTreeTransform(tests.TestCaseWithTransport):
95
68
        self.addCleanup(transform.finalize)
96
69
        return transform, transform.root
97
70
 
98
 
    def get_transform_for_sha1_test(self):
99
 
        trans, root = self.get_transform()
100
 
        self.wt.lock_tree_write()
101
 
        self.addCleanup(self.wt.unlock)
102
 
        contents = ['just some content\n']
103
 
        sha1 = osutils.sha_strings(contents)
104
 
        # Roll back the clock
105
 
        trans._creation_mtime = time.time() - 20.0
106
 
        return trans, root, contents, sha1
107
 
 
108
71
    def test_existing_limbo(self):
109
72
        transform, root = self.get_transform()
110
73
        limbo_name = transform._limbodir
137
100
        imaginary_id = transform.trans_id_tree_path('imaginary')
138
101
        imaginary_id2 = transform.trans_id_tree_path('imaginary/')
139
102
        self.assertEqual(imaginary_id, imaginary_id2)
140
 
        self.assertEqual(root, transform.get_tree_parent(imaginary_id))
141
 
        self.assertEqual('directory', transform.final_kind(root))
142
 
        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())
143
106
        trans_id = transform.create_path('name', root)
144
107
        self.assertIs(transform.final_file_id(trans_id), None)
145
 
        self.assertIs(None, transform.final_kind(trans_id))
 
108
        self.assertRaises(NoSuchFile, transform.final_kind, trans_id)
146
109
        transform.create_file('contents', trans_id)
147
110
        transform.set_executability(True, trans_id)
148
111
        transform.version_file('my_pretties', trans_id)
173
136
        transform.finalize()
174
137
        transform.finalize()
175
138
 
176
 
    def test_apply_informs_tree_of_observed_sha1(self):
177
 
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
178
 
        trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
179
 
                                  sha1=sha1)
180
 
        calls = []
181
 
        orig = self.wt._observed_sha1
182
 
        def _observed_sha1(*args):
183
 
            calls.append(args)
184
 
            orig(*args)
185
 
        self.wt._observed_sha1 = _observed_sha1
186
 
        trans.apply()
187
 
        self.assertEqual([(None, 'file1', trans._observed_sha1s[trans_id])],
188
 
                         calls)
189
 
 
190
 
    def test_create_file_caches_sha1(self):
191
 
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
192
 
        trans_id = trans.create_path('file1', root)
193
 
        trans.create_file(contents, trans_id, sha1=sha1)
194
 
        st_val = osutils.lstat(trans._limbo_name(trans_id))
195
 
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
196
 
        self.assertEqual(o_sha1, sha1)
197
 
        self.assertEqualStat(o_st_val, st_val)
198
 
 
199
 
    def test__apply_insertions_updates_sha1(self):
200
 
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
201
 
        trans_id = trans.create_path('file1', root)
202
 
        trans.create_file(contents, trans_id, sha1=sha1)
203
 
        st_val = osutils.lstat(trans._limbo_name(trans_id))
204
 
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
205
 
        self.assertEqual(o_sha1, sha1)
206
 
        self.assertEqualStat(o_st_val, st_val)
207
 
        creation_mtime = trans._creation_mtime + 10.0
208
 
        # We fake a time difference from when the file was created until now it
209
 
        # is being renamed by using os.utime. Note that the change we actually
210
 
        # want to see is the real ctime change from 'os.rename()', but as long
211
 
        # as we observe a new stat value, we should be fine.
212
 
        os.utime(trans._limbo_name(trans_id), (creation_mtime, creation_mtime))
213
 
        trans.apply()
214
 
        new_st_val = osutils.lstat(self.wt.abspath('file1'))
215
 
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
216
 
        self.assertEqual(o_sha1, sha1)
217
 
        self.assertEqualStat(o_st_val, new_st_val)
218
 
        self.assertNotEqual(st_val.st_mtime, new_st_val.st_mtime)
219
 
 
220
 
    def test_new_file_caches_sha1(self):
221
 
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
222
 
        trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
223
 
                                  sha1=sha1)
224
 
        st_val = osutils.lstat(trans._limbo_name(trans_id))
225
 
        o_sha1, o_st_val = trans._observed_sha1s[trans_id]
226
 
        self.assertEqual(o_sha1, sha1)
227
 
        self.assertEqualStat(o_st_val, st_val)
228
 
 
229
 
    def test_cancel_creation_removes_observed_sha1(self):
230
 
        trans, root, contents, sha1 = self.get_transform_for_sha1_test()
231
 
        trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
232
 
                                  sha1=sha1)
233
 
        self.assertTrue(trans_id in trans._observed_sha1s)
234
 
        trans.cancel_creation(trans_id)
235
 
        self.assertFalse(trans_id in trans._observed_sha1s)
236
 
 
237
 
    def test_create_files_same_timestamp(self):
238
 
        transform, root = self.get_transform()
239
 
        self.wt.lock_tree_write()
240
 
        self.addCleanup(self.wt.unlock)
241
 
        # Roll back the clock, so that we know everything is being set to the
242
 
        # exact time
243
 
        transform._creation_mtime = creation_mtime = time.time() - 20.0
244
 
        transform.create_file('content-one',
245
 
                              transform.create_path('one', root))
246
 
        time.sleep(1) # *ugly*
247
 
        transform.create_file('content-two',
248
 
                              transform.create_path('two', root))
249
 
        transform.apply()
250
 
        fo, st1 = self.wt.get_file_with_stat(None, path='one', filtered=False)
251
 
        fo.close()
252
 
        fo, st2 = self.wt.get_file_with_stat(None, path='two', filtered=False)
253
 
        fo.close()
254
 
        # We only guarantee 2s resolution
255
 
        self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
256
 
            "%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
257
 
        # But if we have more than that, all files should get the same result
258
 
        self.assertEqual(st1.st_mtime, st2.st_mtime)
259
 
 
260
 
    def test_change_root_id(self):
261
 
        transform, root = self.get_transform()
262
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
263
 
        transform.new_directory('', ROOT_PARENT, 'new-root-id')
264
 
        transform.delete_contents(root)
265
 
        transform.unversion_file(root)
266
 
        transform.fixup_new_roots()
267
 
        transform.apply()
268
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
269
 
 
270
 
    def test_change_root_id_add_files(self):
271
 
        transform, root = self.get_transform()
272
 
        self.assertNotEqual('new-root-id', self.wt.get_root_id())
273
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
274
 
        transform.new_file('file', new_trans_id, ['new-contents\n'],
275
 
                           'new-file-id')
276
 
        transform.delete_contents(root)
277
 
        transform.unversion_file(root)
278
 
        transform.fixup_new_roots()
279
 
        transform.apply()
280
 
        self.assertEqual('new-root-id', self.wt.get_root_id())
281
 
        self.assertEqual('new-file-id', self.wt.path2id('file'))
282
 
        self.assertFileEqual('new-contents\n', self.wt.abspath('file'))
283
 
 
284
 
    def test_add_two_roots(self):
285
 
        transform, root = self.get_transform()
286
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
287
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
288
 
        self.assertRaises(ValueError, transform.fixup_new_roots)
289
 
 
290
 
    def test_retain_existing_root(self):
291
 
        tt, root = self.get_transform()
292
 
        with tt:
293
 
            tt.new_directory('', ROOT_PARENT, 'new-root-id')
294
 
            tt.fixup_new_roots()
295
 
            self.assertNotEqual('new-root-id', tt.final_file_id(tt.root))
296
 
 
297
 
    def test_retain_existing_root_added_file(self):
298
 
        tt, root = self.get_transform()
299
 
        new_trans_id = tt.new_directory('', ROOT_PARENT, 'new-root-id')
300
 
        child = tt.new_directory('child', new_trans_id, 'child-id')
301
 
        tt.fixup_new_roots()
302
 
        self.assertEqual(tt.root, tt.final_parent(child))
303
 
 
304
 
    def test_add_unversioned_root(self):
305
 
        transform, root = self.get_transform()
306
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, None)
307
 
        transform.delete_contents(transform.root)
308
 
        transform.fixup_new_roots()
309
 
        self.assertNotIn(transform.root, transform._new_id)
310
 
 
311
 
    def test_remove_root_fixup(self):
312
 
        transform, root = self.get_transform()
313
 
        old_root_id = self.wt.get_root_id()
314
 
        self.assertNotEqual('new-root-id', old_root_id)
315
 
        transform.delete_contents(root)
316
 
        transform.unversion_file(root)
317
 
        transform.fixup_new_roots()
318
 
        transform.apply()
319
 
        self.assertEqual(old_root_id, self.wt.get_root_id())
320
 
 
321
 
        transform, root = self.get_transform()
322
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'new-root-id')
323
 
        new_trans_id = transform.new_directory('', ROOT_PARENT, 'alt-root-id')
324
 
        self.assertRaises(ValueError, transform.fixup_new_roots)
325
 
 
326
 
    def test_fixup_new_roots_permits_empty_tree(self):
327
 
        transform, root = self.get_transform()
328
 
        transform.delete_contents(root)
329
 
        transform.unversion_file(root)
330
 
        transform.fixup_new_roots()
331
 
        self.assertIs(None, transform.final_kind(root))
332
 
        self.assertIs(None, transform.final_file_id(root))
333
 
 
334
 
    def test_apply_retains_root_directory(self):
335
 
        # Do not attempt to delete the physical root directory, because that
336
 
        # is impossible.
337
 
        transform, root = self.get_transform()
338
 
        with transform:
339
 
            transform.delete_contents(root)
340
 
            e = self.assertRaises(AssertionError, self.assertRaises,
341
 
                                  errors.TransformRenameFailed,
342
 
                                  transform.apply)
343
 
        self.assertContainsRe('TransformRenameFailed not raised', str(e))
344
 
 
345
 
    def test_apply_retains_file_id(self):
346
 
        transform, root = self.get_transform()
347
 
        old_root_id = transform.tree_file_id(root)
348
 
        transform.unversion_file(root)
349
 
        transform.apply()
350
 
        self.assertEqual(old_root_id, self.wt.get_root_id())
351
 
 
352
139
    def test_hardlink(self):
353
140
        self.requireFeature(HardlinkFeature)
354
141
        transform, root = self.get_transform()
359
146
        trans_id = target_transform.create_path('file1', target_transform.root)
360
147
        target_transform.create_hardlink(self.wt.abspath('file1'), trans_id)
361
148
        target_transform.apply()
362
 
        self.assertPathExists('target/file1')
 
149
        self.failUnlessExists('target/file1')
363
150
        source_stat = os.stat(self.wt.abspath('file1'))
364
151
        target_stat = os.stat('target/file1')
365
152
        self.assertEqual(source_stat, target_stat)
531
318
        transform.new_file('FiLe', transform.root, 'content')
532
319
        resolve_conflicts(transform)
533
320
        transform.apply()
534
 
        self.assertPathExists('tree/file')
535
 
        self.assertPathExists('tree/FiLe.moved')
 
321
        self.failUnlessExists('tree/file')
 
322
        self.failUnlessExists('tree/FiLe.moved')
536
323
 
537
324
    def test_resolve_checkout_case_conflict(self):
538
325
        tree = self.make_branch_and_tree('tree')
547
334
        resolve_conflicts(transform,
548
335
                          pass_func=lambda t, c: resolve_checkout(t, c, []))
549
336
        transform.apply()
550
 
        self.assertPathExists('tree/file')
551
 
        self.assertPathExists('tree/FiLe.moved')
 
337
        self.failUnlessExists('tree/file')
 
338
        self.failUnlessExists('tree/FiLe.moved')
552
339
 
553
340
    def test_apply_case_conflict(self):
554
341
        """Ensure that a transform with case conflicts can always be applied"""
562
349
        transform.new_file('dirFiLe', dir, 'content')
563
350
        resolve_conflicts(transform)
564
351
        transform.apply()
565
 
        self.assertPathExists('tree/file')
 
352
        self.failUnlessExists('tree/file')
566
353
        if not os.path.exists('tree/FiLe.moved'):
567
 
            self.assertPathExists('tree/FiLe')
568
 
        self.assertPathExists('tree/dir/dirfile')
 
354
            self.failUnlessExists('tree/FiLe')
 
355
        self.failUnlessExists('tree/dir/dirfile')
569
356
        if not os.path.exists('tree/dir/dirFiLe.moved'):
570
 
            self.assertPathExists('tree/dir/dirFiLe')
 
357
            self.failUnlessExists('tree/dir/dirFiLe')
571
358
 
572
359
    def test_case_insensitive_limbo(self):
573
360
        tree = self.make_branch_and_tree('tree')
582
369
        self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
583
370
        self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
584
371
 
585
 
    def test_adjust_path_updates_child_limbo_names(self):
586
 
        tree = self.make_branch_and_tree('tree')
587
 
        transform = TreeTransform(tree)
588
 
        self.addCleanup(transform.finalize)
589
 
        foo_id = transform.new_directory('foo', transform.root)
590
 
        bar_id = transform.new_directory('bar', foo_id)
591
 
        baz_id = transform.new_directory('baz', bar_id)
592
 
        qux_id = transform.new_directory('qux', baz_id)
593
 
        transform.adjust_path('quxx', foo_id, bar_id)
594
 
        self.assertStartsWith(transform._limbo_name(qux_id),
595
 
                              transform._limbo_name(bar_id))
596
 
 
597
372
    def test_add_del(self):
598
373
        start, root = self.get_transform()
599
374
        start.new_directory('a', root, 'a')
781
556
                            'wizard2', 'behind_curtain')
782
557
 
783
558
    def test_symlinks_unicode(self):
784
 
        self.requireFeature(features.UnicodeFilenameFeature)
 
559
        self.requireFeature(tests.UnicodeFilenameFeature)
785
560
        self._test_symlinks(u'\N{Euro Sign}wizard',
786
561
                            u'wizard-targ\N{Euro Sign}t',
787
562
                            u'\N{Euro Sign}wizard2',
875
650
        raw_conflicts = resolve_conflicts(tt)
876
651
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
877
652
        tt.finalize()
878
 
        conflicts_s = [unicode(c) for c in cooked_conflicts]
 
653
        conflicts_s = [str(c) for c in cooked_conflicts]
879
654
        self.assertEqual(len(cooked_conflicts), len(conflicts_s))
880
655
        self.assertEqual(conflicts_s[0], 'Conflict adding file dorothy.  '
881
656
                                         'Moved existing file to '
894
669
                                         ' versioned, but has versioned'
895
670
                                         ' children.  Versioned directory.')
896
671
        self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
897
 
                                         ' oz/emeraldcity. Cancelled move.')
 
672
                                         ' oz/emeraldcity.  Cancelled move.')
898
673
 
899
674
    def prepare_wrong_parent_kind(self):
900
675
        tt, root = self.get_transform()
951
726
        self.assertIs(None, self.wt.path2id('parent'))
952
727
        self.assertIs(None, self.wt.path2id('parent.new'))
953
728
 
954
 
    def test_resolve_conflicts_missing_parent(self):
955
 
        wt = self.make_branch_and_tree('.')
956
 
        tt = TreeTransform(wt)
957
 
        self.addCleanup(tt.finalize)
958
 
        parent = tt.trans_id_file_id('parent-id')
959
 
        tt.new_file('file', parent, 'Contents')
960
 
        raw_conflicts = resolve_conflicts(tt)
961
 
        # Since the directory doesn't exist it's seen as 'missing'.  So
962
 
        # 'resolve_conflicts' create a conflict asking for it to be created.
963
 
        self.assertLength(1, raw_conflicts)
964
 
        self.assertEqual(('missing parent', 'Created directory', 'new-1'),
965
 
                         raw_conflicts.pop())
966
 
        # apply fail since the missing directory doesn't exist
967
 
        self.assertRaises(errors.NoFinalPath, tt.apply)
968
 
 
969
729
    def test_moving_versioned_directories(self):
970
730
        create, root = self.get_transform()
971
731
        kansas = create.new_directory('kansas', root, 'kansas-id')
986
746
        create.apply()
987
747
        transform, root = self.get_transform()
988
748
        transform.adjust_root_path('oldroot', fun)
989
 
        new_root = transform.trans_id_tree_path('')
 
749
        new_root=transform.trans_id_tree_path('')
990
750
        transform.version_file('new-root', new_root)
991
751
        transform.apply()
992
752
 
1004
764
        rename.set_executability(True, myfile)
1005
765
        rename.apply()
1006
766
 
1007
 
    def test_rename_fails(self):
1008
 
        self.requireFeature(features.not_running_as_root)
1009
 
        # see https://bugs.launchpad.net/bzr/+bug/491763
1010
 
        create, root_id = self.get_transform()
1011
 
        first_dir = create.new_directory('first-dir', root_id, 'first-id')
1012
 
        myfile = create.new_file('myfile', root_id, 'myfile-text',
1013
 
                                 'myfile-id')
1014
 
        create.apply()
1015
 
        if os.name == "posix" and sys.platform != "cygwin":
1016
 
            # posix filesystems fail on renaming if the readonly bit is set
1017
 
            osutils.make_readonly(self.wt.abspath('first-dir'))
1018
 
        elif os.name == "nt":
1019
 
            # windows filesystems fail on renaming open files
1020
 
            self.addCleanup(file(self.wt.abspath('myfile')).close)
1021
 
        else:
1022
 
            self.skip("Don't know how to force a permissions error on rename")
1023
 
        # now transform to rename
1024
 
        rename_transform, root_id = self.get_transform()
1025
 
        file_trans_id = rename_transform.trans_id_file_id('myfile-id')
1026
 
        dir_id = rename_transform.trans_id_file_id('first-id')
1027
 
        rename_transform.adjust_path('newname', dir_id, file_trans_id)
1028
 
        e = self.assertRaises(errors.TransformRenameFailed,
1029
 
            rename_transform.apply)
1030
 
        # On nix looks like: 
1031
 
        # "Failed to rename .../work/.bzr/checkout/limbo/new-1
1032
 
        # to .../first-dir/newname: [Errno 13] Permission denied"
1033
 
        # On windows looks like:
1034
 
        # "Failed to rename .../work/myfile to 
1035
 
        # .../work/.bzr/checkout/limbo/new-1: [Errno 13] Permission denied"
1036
 
        # This test isn't concerned with exactly what the error looks like,
1037
 
        # and the strerror will vary across OS and locales, but the assert
1038
 
        # that the exeception attributes are what we expect
1039
 
        self.assertEqual(e.errno, errno.EACCES)
1040
 
        if os.name == "posix":
1041
 
            self.assertEndsWith(e.to_path, "/first-dir/newname")
1042
 
        else:
1043
 
            self.assertEqual(os.path.basename(e.from_path), "myfile")
1044
 
 
1045
767
    def test_set_executability_order(self):
1046
768
        """Ensure that executability behaves the same, no matter what order.
1047
769
 
1319
1041
        parent2 = transform.new_directory('parent2', root)
1320
1042
        transform.adjust_path('child1', parent2, child1)
1321
1043
        transform.apply()
1322
 
        self.assertPathDoesNotExist(self.wt.abspath('parent1/child1'))
1323
 
        self.assertPathExists(self.wt.abspath('parent2/child1'))
 
1044
        self.failIfExists(self.wt.abspath('parent1/child1'))
 
1045
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
1324
1046
        # rename limbo/new-1 => parent1, rename limbo/new-3 => parent2
1325
1047
        # no rename for child1 (counting only renames during apply)
1326
 
        self.assertEqual(2, transform.rename_count)
 
1048
        self.failUnlessEqual(2, transform.rename_count)
1327
1049
 
1328
1050
    def test_cancel_parent(self):
1329
1051
        """Cancelling a parent doesn't cause deletion of a non-empty directory
1352
1074
        parent2 = transform.new_directory('parent2', root)
1353
1075
        transform.adjust_path('child1', parent2, child1)
1354
1076
        transform.apply()
1355
 
        self.assertPathDoesNotExist(self.wt.abspath('parent1'))
1356
 
        self.assertPathExists(self.wt.abspath('parent2/child1'))
 
1077
        self.failIfExists(self.wt.abspath('parent1'))
 
1078
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
1357
1079
        # rename limbo/new-3 => parent2, rename limbo/new-2 => child1
1358
 
        self.assertEqual(2, transform.rename_count)
 
1080
        self.failUnlessEqual(2, transform.rename_count)
1359
1081
 
1360
1082
    def test_adjust_and_cancel(self):
1361
1083
        """Make sure adjust_path keeps track of limbo children properly"""
1394
1116
        child = transform.new_directory('child', parent)
1395
1117
        transform.adjust_path('parent', root, parent)
1396
1118
        transform.apply()
1397
 
        self.assertPathExists(self.wt.abspath('parent/child'))
 
1119
        self.failUnlessExists(self.wt.abspath('parent/child'))
1398
1120
        self.assertEqual(1, transform.rename_count)
1399
1121
 
1400
1122
    def test_reuse_name(self):
1531
1253
        tt.create_file(["aa\n"], bar_trans_id)
1532
1254
        tt.version_file("bar-1", bar_trans_id)
1533
1255
        tt.apply()
1534
 
        self.assertPathExists("foo/bar")
 
1256
        self.failUnlessExists("foo/bar")
1535
1257
        wt.lock_read()
1536
1258
        try:
1537
1259
            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1554
1276
        tt.delete_contents(foo_trans_id)
1555
1277
        tt.create_symlink("bar", foo_trans_id)
1556
1278
        tt.apply()
1557
 
        self.assertPathExists("foo")
 
1279
        self.failUnlessExists("foo")
1558
1280
        wt.lock_read()
1559
1281
        self.addCleanup(wt.unlock)
1560
1282
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1573
1295
        tt.delete_versioned(bar_trans_id)
1574
1296
        tt.create_file(["aa\n"], foo_trans_id)
1575
1297
        tt.apply()
1576
 
        self.assertPathExists("foo")
 
1298
        self.failUnlessExists("foo")
1577
1299
        wt.lock_read()
1578
1300
        self.addCleanup(wt.unlock)
1579
1301
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1594
1316
        self.build_tree(['baz'])
1595
1317
        tt.create_hardlink("baz", foo_trans_id)
1596
1318
        tt.apply()
1597
 
        self.assertPathExists("foo")
1598
 
        self.assertPathExists("baz")
 
1319
        self.failUnlessExists("foo")
 
1320
        self.failUnlessExists("baz")
1599
1321
        wt.lock_read()
1600
1322
        self.addCleanup(wt.unlock)
1601
1323
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1663
1385
    return template % ('<' * 7, tree, '=' * 7, merge, '>' * 7)
1664
1386
 
1665
1387
 
1666
 
class TestInventoryAltered(tests.TestCaseWithTransport):
1667
 
 
1668
 
    def test_inventory_altered_unchanged(self):
1669
 
        tree = self.make_branch_and_tree('tree')
1670
 
        self.build_tree(['tree/foo'])
1671
 
        tree.add('foo', 'foo-id')
1672
 
        with TransformPreview(tree) as tt:
1673
 
            self.assertEqual([], tt._inventory_altered())
1674
 
 
1675
 
    def test_inventory_altered_changed_parent_id(self):
1676
 
        tree = self.make_branch_and_tree('tree')
1677
 
        self.build_tree(['tree/foo'])
1678
 
        tree.add('foo', 'foo-id')
1679
 
        with TransformPreview(tree) as tt:
1680
 
            tt.unversion_file(tt.root)
1681
 
            tt.version_file('new-id', tt.root)
1682
 
            foo_trans_id = tt.trans_id_tree_file_id('foo-id')
1683
 
            foo_tuple = ('foo', foo_trans_id)
1684
 
            root_tuple = ('', tt.root)
1685
 
            self.assertEqual([root_tuple, foo_tuple], tt._inventory_altered())
1686
 
 
1687
 
    def test_inventory_altered_noop_changed_parent_id(self):
1688
 
        tree = self.make_branch_and_tree('tree')
1689
 
        self.build_tree(['tree/foo'])
1690
 
        tree.add('foo', 'foo-id')
1691
 
        with TransformPreview(tree) as tt:
1692
 
            tt.unversion_file(tt.root)
1693
 
            tt.version_file(tree.get_root_id(), tt.root)
1694
 
            foo_trans_id = tt.trans_id_tree_file_id('foo-id')
1695
 
            self.assertEqual([], tt._inventory_altered())
1696
 
 
1697
 
 
1698
1388
class TestTransformMerge(TestCaseInTempDir):
1699
1389
 
1700
1390
    def test_text_merge(self):
1910
1600
        tree.add_reference(subtree)
1911
1601
        tree.commit('a revision')
1912
1602
        tree.branch.create_checkout('target')
1913
 
        self.assertPathExists('target')
1914
 
        self.assertPathExists('target/subtree')
 
1603
        self.failUnlessExists('target')
 
1604
        self.failUnlessExists('target/subtree')
1915
1605
 
1916
1606
    def test_file_conflict_handling(self):
1917
1607
        """Ensure that when building trees, conflict handling is done"""
1964
1654
        source.commit('added file')
1965
1655
        build_tree(source.basis_tree(), target)
1966
1656
        self.assertEqual([], target.conflicts())
1967
 
        self.assertPathExists('target/dir1/file')
 
1657
        self.failUnlessExists('target/dir1/file')
1968
1658
 
1969
1659
        # Ensure contents are merged
1970
1660
        target = self.make_branch_and_tree('target2')
1971
1661
        self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
1972
1662
        build_tree(source.basis_tree(), target)
1973
1663
        self.assertEqual([], target.conflicts())
1974
 
        self.assertPathExists('target2/dir1/file2')
1975
 
        self.assertPathExists('target2/dir1/file')
 
1664
        self.failUnlessExists('target2/dir1/file2')
 
1665
        self.failUnlessExists('target2/dir1/file')
1976
1666
 
1977
1667
        # Ensure new contents are suppressed for existing branches
1978
1668
        target = self.make_branch_and_tree('target3')
1979
1669
        self.make_branch('target3/dir1')
1980
1670
        self.build_tree(['target3/dir1/file2'])
1981
1671
        build_tree(source.basis_tree(), target)
1982
 
        self.assertPathDoesNotExist('target3/dir1/file')
1983
 
        self.assertPathExists('target3/dir1/file2')
1984
 
        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')
1985
1675
        self.assertEqual([DuplicateEntry('Diverted to',
1986
1676
            'dir1.diverted', 'dir1', 'new-dir1', None)],
1987
1677
            target.conflicts())
1990
1680
        self.build_tree(['target4/dir1/'])
1991
1681
        self.make_branch('target4/dir1/file')
1992
1682
        build_tree(source.basis_tree(), target)
1993
 
        self.assertPathExists('target4/dir1/file')
 
1683
        self.failUnlessExists('target4/dir1/file')
1994
1684
        self.assertEqual('directory', file_kind('target4/dir1/file'))
1995
 
        self.assertPathExists('target4/dir1/file.diverted')
 
1685
        self.failUnlessExists('target4/dir1/file.diverted')
1996
1686
        self.assertEqual([DuplicateEntry('Diverted to',
1997
1687
            'dir1/file.diverted', 'dir1/file', 'new-file', None)],
1998
1688
            target.conflicts())
2066
1756
        self.addCleanup(target.unlock)
2067
1757
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2068
1758
 
2069
 
    def test_build_tree_accelerator_tree_observes_sha1(self):
2070
 
        source = self.create_ab_tree()
2071
 
        sha1 = osutils.sha_string('A')
2072
 
        target = self.make_branch_and_tree('target')
2073
 
        target.lock_write()
2074
 
        self.addCleanup(target.unlock)
2075
 
        state = target.current_dirstate()
2076
 
        state._cutoff_time = time.time() + 60
2077
 
        build_tree(source.basis_tree(), target, source)
2078
 
        entry = state._get_entry(0, path_utf8='file1')
2079
 
        self.assertEqual(sha1, entry[1][0][1])
2080
 
 
2081
1759
    def test_build_tree_accelerator_tree_missing_file(self):
2082
1760
        source = self.create_ab_tree()
2083
1761
        os.unlink('source/file1')
2178
1856
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2179
1857
        self.assertTrue(source.is_executable('file1-id'))
2180
1858
 
2181
 
    def install_rot13_content_filter(self, pattern):
2182
 
        # We could use
2183
 
        # self.addCleanup(filters._reset_registry, filters._reset_registry())
2184
 
        # below, but that looks a bit... hard to read even if it's exactly
2185
 
        # the same thing.
2186
 
        original_registry = filters._reset_registry()
2187
 
        def restore_registry():
2188
 
            filters._reset_registry(original_registry)
2189
 
        self.addCleanup(restore_registry)
2190
 
        def rot13(chunks, context=None):
2191
 
            return [''.join(chunks).encode('rot13')]
2192
 
        rot13filter = filters.ContentFilter(rot13, rot13)
2193
 
        filters.register_filter_stack_map('rot13', {'yes': [rot13filter]}.get)
2194
 
        os.mkdir(self.test_home_dir + '/.bazaar')
2195
 
        rules_filename = self.test_home_dir + '/.bazaar/rules'
2196
 
        f = open(rules_filename, 'wb')
2197
 
        f.write('[name %s]\nrot13=yes\n' % (pattern,))
2198
 
        f.close()
2199
 
        def uninstall_rules():
2200
 
            os.remove(rules_filename)
2201
 
            rules.reset_rules()
2202
 
        self.addCleanup(uninstall_rules)
2203
 
        rules.reset_rules()
2204
 
 
2205
 
    def test_build_tree_content_filtered_files_are_not_hardlinked(self):
2206
 
        """build_tree will not hardlink files that have content filtering rules
2207
 
        applied to them (but will still hardlink other files from the same tree
2208
 
        if it can).
2209
 
        """
2210
 
        self.requireFeature(HardlinkFeature)
2211
 
        self.install_rot13_content_filter('file1')
2212
 
        source = self.create_ab_tree()
2213
 
        target = self.make_branch_and_tree('target')
2214
 
        revision_tree = source.basis_tree()
2215
 
        revision_tree.lock_read()
2216
 
        self.addCleanup(revision_tree.unlock)
2217
 
        build_tree(revision_tree, target, source, hardlink=True)
2218
 
        target.lock_read()
2219
 
        self.addCleanup(target.unlock)
2220
 
        self.assertEqual([], list(target.iter_changes(revision_tree)))
2221
 
        source_stat = os.stat('source/file1')
2222
 
        target_stat = os.stat('target/file1')
2223
 
        self.assertNotEqual(source_stat, target_stat)
2224
 
        source_stat = os.stat('source/file2')
2225
 
        target_stat = os.stat('target/file2')
2226
 
        self.assertEqualStat(source_stat, target_stat)
2227
 
 
2228
1859
    def test_case_insensitive_build_tree_inventory(self):
2229
 
        if (features.CaseInsensitiveFilesystemFeature.available()
2230
 
            or features.CaseInsCasePresFilenameFeature.available()):
 
1860
        if (tests.CaseInsensitiveFilesystemFeature.available()
 
1861
            or tests.CaseInsCasePresFilenameFeature.available()):
2231
1862
            raise tests.UnavailableFeature('Fully case sensitive filesystem')
2232
1863
        source = self.make_branch_and_tree('source')
2233
1864
        self.build_tree(['source/file', 'source/FILE'])
2241
1872
        self.assertEqual('file.moved', target.id2path('lower-id'))
2242
1873
        self.assertEqual('FILE', target.id2path('upper-id'))
2243
1874
 
2244
 
    def test_build_tree_observes_sha(self):
2245
 
        source = self.make_branch_and_tree('source')
2246
 
        self.build_tree(['source/file1', 'source/dir/', 'source/dir/file2'])
2247
 
        source.add(['file1', 'dir', 'dir/file2'],
2248
 
                   ['file1-id', 'dir-id', 'file2-id'])
2249
 
        source.commit('new files')
2250
 
        target = self.make_branch_and_tree('target')
2251
 
        target.lock_write()
2252
 
        self.addCleanup(target.unlock)
2253
 
        # We make use of the fact that DirState caches its cutoff time. So we
2254
 
        # set the 'safe' time to one minute in the future.
2255
 
        state = target.current_dirstate()
2256
 
        state._cutoff_time = time.time() + 60
2257
 
        build_tree(source.basis_tree(), target)
2258
 
        entry1_sha = osutils.sha_file_by_name('source/file1')
2259
 
        entry2_sha = osutils.sha_file_by_name('source/dir/file2')
2260
 
        # entry[1] is the state information, entry[1][0] is the state of the
2261
 
        # working tree, entry[1][0][1] is the sha value for the current working
2262
 
        # tree
2263
 
        entry1 = state._get_entry(0, path_utf8='file1')
2264
 
        self.assertEqual(entry1_sha, entry1[1][0][1])
2265
 
        # The 'size' field must also be set.
2266
 
        self.assertEqual(25, entry1[1][0][2])
2267
 
        entry1_state = entry1[1][0]
2268
 
        entry2 = state._get_entry(0, path_utf8='dir/file2')
2269
 
        self.assertEqual(entry2_sha, entry2[1][0][1])
2270
 
        self.assertEqual(29, entry2[1][0][2])
2271
 
        entry2_state = entry2[1][0]
2272
 
        # Now, make sure that we don't have to re-read the content. The
2273
 
        # packed_stat should match exactly.
2274
 
        self.assertEqual(entry1_sha, target.get_file_sha1('file1-id', 'file1'))
2275
 
        self.assertEqual(entry2_sha,
2276
 
                         target.get_file_sha1('file2-id', 'dir/file2'))
2277
 
        self.assertEqual(entry1_state, entry1[1][0])
2278
 
        self.assertEqual(entry2_state, entry2[1][0])
2279
 
 
2280
1875
 
2281
1876
class TestCommitTransform(tests.TestCaseWithTransport):
2282
1877
 
2321
1916
        branch.lock_write()
2322
1917
        self.addCleanup(branch.unlock)
2323
1918
        tt = TransformPreview(branch.basis_tree())
2324
 
        self.addCleanup(tt.finalize)
2325
1919
        tt.new_directory('', ROOT_PARENT, 'TREE_ROOT')
2326
1920
        rev = tt.commit(branch, 'my message')
2327
1921
        self.assertEqual([], branch.basis_tree().get_parent_ids())
2333
1927
        branch.lock_write()
2334
1928
        self.addCleanup(branch.unlock)
2335
1929
        tt = TransformPreview(branch.basis_tree())
2336
 
        self.addCleanup(tt.finalize)
2337
1930
        e = self.assertRaises(ValueError, tt.commit, branch,
2338
1931
                          'my message', ['rev1b-id'])
2339
1932
        self.assertEqual('Cannot supply merge parents for first commit.',
2344
1937
        branch, tt = self.get_branch_and_transform()
2345
1938
        tt.new_file('file', tt.root, 'contents', 'file-id')
2346
1939
        trans_id = tt.new_directory('dir', tt.root, 'dir-id')
2347
 
        if SymlinkFeature.available():
2348
 
            tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
 
1940
        tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
2349
1941
        rev = tt.commit(branch, 'message')
2350
1942
        tree = branch.basis_tree()
2351
1943
        self.assertEqual('file', tree.id2path('file-id'))
2352
1944
        self.assertEqual('contents', tree.get_file_text('file-id'))
2353
1945
        self.assertEqual('dir', tree.id2path('dir-id'))
2354
 
        if SymlinkFeature.available():
2355
 
            self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
2356
 
            self.assertEqual('target', tree.get_symlink_target('symlink-id'))
 
1946
        self.assertEqual('dir/symlink', tree.id2path('symlink-id'))
 
1947
        self.assertEqual('target', tree.get_symlink_target('symlink-id'))
2357
1948
 
2358
1949
    def test_add_unversioned(self):
2359
1950
        branch, tt = self.get_branch_and_transform()
2366
1957
        tt.new_file('file', tt.root, 'contents', 'file-id')
2367
1958
        tt.commit(branch, 'message', strict=True)
2368
1959
        tt = TransformPreview(branch.basis_tree())
2369
 
        self.addCleanup(tt.finalize)
2370
1960
        trans_id = tt.trans_id_file_id('file-id')
2371
1961
        tt.delete_contents(trans_id)
2372
1962
        tt.create_file('contents', trans_id)
2383
1973
        self.assertRaises(errors.MalformedTransform, tt.commit, branch,
2384
1974
                          'message')
2385
1975
 
2386
 
    def test_commit_rich_revision_data(self):
2387
 
        branch, tt = self.get_branch_and_transform()
2388
 
        rev_id = tt.commit(branch, 'message', timestamp=1, timezone=43201,
2389
 
                           committer='me <me@example.com>',
2390
 
                           revprops={'foo': 'bar'}, revision_id='revid-1',
2391
 
                           authors=['Author1 <author1@example.com>',
2392
 
                              'Author2 <author2@example.com>',
2393
 
                               ])
2394
 
        self.assertEqual('revid-1', rev_id)
2395
 
        revision = branch.repository.get_revision(rev_id)
2396
 
        self.assertEqual(1, revision.timestamp)
2397
 
        self.assertEqual(43201, revision.timezone)
2398
 
        self.assertEqual('me <me@example.com>', revision.committer)
2399
 
        self.assertEqual(['Author1 <author1@example.com>',
2400
 
                          'Author2 <author2@example.com>'],
2401
 
                         revision.get_apparent_authors())
2402
 
        del revision.properties['authors']
2403
 
        self.assertEqual({'foo': 'bar',
2404
 
                          'branch-nick': 'tree'},
2405
 
                         revision.properties)
2406
 
 
2407
 
    def test_no_explicit_revprops(self):
2408
 
        branch, tt = self.get_branch_and_transform()
2409
 
        rev_id = tt.commit(branch, 'message', authors=[
2410
 
            'Author1 <author1@example.com>',
2411
 
            'Author2 <author2@example.com>', ])
2412
 
        revision = branch.repository.get_revision(rev_id)
2413
 
        self.assertEqual(['Author1 <author1@example.com>',
2414
 
                          'Author2 <author2@example.com>'],
2415
 
                         revision.get_apparent_authors())
2416
 
        self.assertEqual('tree', revision.properties['branch-nick'])
2417
 
 
2418
 
 
2419
 
class TestBackupName(tests.TestCase):
2420
 
 
2421
 
    def test_deprecations(self):
2422
 
        class MockTransform(object):
2423
 
 
2424
 
            def has_named_child(self, by_parent, parent_id, name):
2425
 
                return name in by_parent.get(parent_id, [])
2426
 
 
2427
 
        class MockEntry(object):
2428
 
 
2429
 
            def __init__(self):
2430
 
                object.__init__(self)
2431
 
                self.name = "name"
2432
 
 
 
1976
 
 
1977
class MockTransform(object):
 
1978
 
 
1979
    def has_named_child(self, by_parent, parent_id, name):
 
1980
        for child_id in by_parent[parent_id]:
 
1981
            if child_id == '0':
 
1982
                if name == "name~":
 
1983
                    return True
 
1984
            elif name == "name.~%s~" % child_id:
 
1985
                return True
 
1986
        return False
 
1987
 
 
1988
 
 
1989
class MockEntry(object):
 
1990
    def __init__(self):
 
1991
        object.__init__(self)
 
1992
        self.name = "name"
 
1993
 
 
1994
 
 
1995
class TestGetBackupName(TestCase):
 
1996
    def test_get_backup_name(self):
2433
1997
        tt = MockTransform()
2434
 
        name1 = self.applyDeprecated(
2435
 
            symbol_versioning.deprecated_in((2, 3, 0)),
2436
 
            transform.get_backup_name, MockEntry(), {'a':[]}, 'a', tt)
2437
 
        self.assertEqual('name.~1~', name1)
2438
 
        name2 = self.applyDeprecated(
2439
 
            symbol_versioning.deprecated_in((2, 3, 0)),
2440
 
            transform._get_backup_name, 'name', {'a':['name.~1~']}, 'a', tt)
2441
 
        self.assertEqual('name.~2~', name2)
 
1998
        name = get_backup_name(MockEntry(), {'a':[]}, 'a', tt)
 
1999
        self.assertEqual(name, 'name.~1~')
 
2000
        name = get_backup_name(MockEntry(), {'a':['1']}, 'a', tt)
 
2001
        self.assertEqual(name, 'name.~2~')
 
2002
        name = get_backup_name(MockEntry(), {'a':['2']}, 'a', tt)
 
2003
        self.assertEqual(name, 'name.~1~')
 
2004
        name = get_backup_name(MockEntry(), {'a':['2'], 'b':[]}, 'b', tt)
 
2005
        self.assertEqual(name, 'name.~1~')
 
2006
        name = get_backup_name(MockEntry(), {'a':['1', '2', '3']}, 'a', tt)
 
2007
        self.assertEqual(name, 'name.~4~')
2442
2008
 
2443
2009
 
2444
2010
class TestFileMover(tests.TestCaseWithTransport):
2447
2013
        self.build_tree(['a/', 'a/b', 'c/', 'c/d'])
2448
2014
        mover = _FileMover()
2449
2015
        mover.rename('a', 'q')
2450
 
        self.assertPathExists('q')
2451
 
        self.assertPathDoesNotExist('a')
2452
 
        self.assertPathExists('q/b')
2453
 
        self.assertPathExists('c')
2454
 
        self.assertPathExists('c/d')
 
2016
        self.failUnlessExists('q')
 
2017
        self.failIfExists('a')
 
2018
        self.failUnlessExists('q/b')
 
2019
        self.failUnlessExists('c')
 
2020
        self.failUnlessExists('c/d')
2455
2021
 
2456
2022
    def test_pre_delete_rollback(self):
2457
2023
        self.build_tree(['a/'])
2458
2024
        mover = _FileMover()
2459
2025
        mover.pre_delete('a', 'q')
2460
 
        self.assertPathExists('q')
2461
 
        self.assertPathDoesNotExist('a')
 
2026
        self.failUnlessExists('q')
 
2027
        self.failIfExists('a')
2462
2028
        mover.rollback()
2463
 
        self.assertPathDoesNotExist('q')
2464
 
        self.assertPathExists('a')
 
2029
        self.failIfExists('q')
 
2030
        self.failUnlessExists('a')
2465
2031
 
2466
2032
    def test_apply_deletions(self):
2467
2033
        self.build_tree(['a/', 'b/'])
2468
2034
        mover = _FileMover()
2469
2035
        mover.pre_delete('a', 'q')
2470
2036
        mover.pre_delete('b', 'r')
2471
 
        self.assertPathExists('q')
2472
 
        self.assertPathExists('r')
2473
 
        self.assertPathDoesNotExist('a')
2474
 
        self.assertPathDoesNotExist('b')
 
2037
        self.failUnlessExists('q')
 
2038
        self.failUnlessExists('r')
 
2039
        self.failIfExists('a')
 
2040
        self.failIfExists('b')
2475
2041
        mover.apply_deletions()
2476
 
        self.assertPathDoesNotExist('q')
2477
 
        self.assertPathDoesNotExist('r')
2478
 
        self.assertPathDoesNotExist('a')
2479
 
        self.assertPathDoesNotExist('b')
 
2042
        self.failIfExists('q')
 
2043
        self.failIfExists('r')
 
2044
        self.failIfExists('a')
 
2045
        self.failIfExists('b')
2480
2046
 
2481
2047
    def test_file_mover_rollback(self):
2482
2048
        self.build_tree(['a/', 'a/b', 'c/', 'c/d/', 'c/e/'])
2487
2053
            mover.rename('a', 'c')
2488
2054
        except errors.FileExists, e:
2489
2055
            mover.rollback()
2490
 
        self.assertPathExists('a')
2491
 
        self.assertPathExists('c/d')
 
2056
        self.failUnlessExists('a')
 
2057
        self.failUnlessExists('c/d')
2492
2058
 
2493
2059
 
2494
2060
class Bogus(Exception):
2524
2090
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2525
2091
        self.assertRaises(Bogus, tt.apply,
2526
2092
                          _mover=self.ExceptionFileMover(bad_source='a'))
2527
 
        self.assertPathExists('a')
2528
 
        self.assertPathExists('a/b')
 
2093
        self.failUnlessExists('a')
 
2094
        self.failUnlessExists('a/b')
2529
2095
        tt.apply()
2530
 
        self.assertPathExists('c')
2531
 
        self.assertPathExists('c/d')
 
2096
        self.failUnlessExists('c')
 
2097
        self.failUnlessExists('c/d')
2532
2098
 
2533
2099
    def test_rollback_rename_into_place(self):
2534
2100
        tree = self.make_branch_and_tree('.')
2540
2106
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
2541
2107
        self.assertRaises(Bogus, tt.apply,
2542
2108
                          _mover=self.ExceptionFileMover(bad_target='c/d'))
2543
 
        self.assertPathExists('a')
2544
 
        self.assertPathExists('a/b')
 
2109
        self.failUnlessExists('a')
 
2110
        self.failUnlessExists('a/b')
2545
2111
        tt.apply()
2546
 
        self.assertPathExists('c')
2547
 
        self.assertPathExists('c/d')
 
2112
        self.failUnlessExists('c')
 
2113
        self.failUnlessExists('c/d')
2548
2114
 
2549
2115
    def test_rollback_deletion(self):
2550
2116
        tree = self.make_branch_and_tree('.')
2556
2122
        tt.adjust_path('d', tt.root, tt.trans_id_tree_path('a/b'))
2557
2123
        self.assertRaises(Bogus, tt.apply,
2558
2124
                          _mover=self.ExceptionFileMover(bad_target='d'))
2559
 
        self.assertPathExists('a')
2560
 
        self.assertPathExists('a/b')
2561
 
 
2562
 
 
2563
 
class TestFinalizeRobustness(tests.TestCaseWithTransport):
2564
 
    """Ensure treetransform creation errors can be safely cleaned up after"""
2565
 
 
2566
 
    def _override_globals_in_method(self, instance, method_name, globals):
2567
 
        """Replace method on instance with one with updated globals"""
2568
 
        import types
2569
 
        func = getattr(instance, method_name).im_func
2570
 
        new_globals = dict(func.func_globals)
2571
 
        new_globals.update(globals)
2572
 
        new_func = types.FunctionType(func.func_code, new_globals,
2573
 
            func.func_name, func.func_defaults)
2574
 
        setattr(instance, method_name,
2575
 
            types.MethodType(new_func, instance, instance.__class__))
2576
 
        self.addCleanup(delattr, instance, method_name)
2577
 
 
2578
 
    @staticmethod
2579
 
    def _fake_open_raises_before(name, mode):
2580
 
        """Like open() but raises before doing anything"""
2581
 
        raise RuntimeError
2582
 
 
2583
 
    @staticmethod
2584
 
    def _fake_open_raises_after(name, mode):
2585
 
        """Like open() but raises after creating file without returning"""
2586
 
        open(name, mode).close()
2587
 
        raise RuntimeError
2588
 
 
2589
 
    def create_transform_and_root_trans_id(self):
2590
 
        """Setup a transform creating a file in limbo"""
2591
 
        tree = self.make_branch_and_tree('.')
2592
 
        tt = TreeTransform(tree)
2593
 
        return tt, tt.create_path("a", tt.root)
2594
 
 
2595
 
    def create_transform_and_subdir_trans_id(self):
2596
 
        """Setup a transform creating a directory containing a file in limbo"""
2597
 
        tree = self.make_branch_and_tree('.')
2598
 
        tt = TreeTransform(tree)
2599
 
        d_trans_id = tt.create_path("d", tt.root)
2600
 
        tt.create_directory(d_trans_id)
2601
 
        f_trans_id = tt.create_path("a", d_trans_id)
2602
 
        tt.adjust_path("a", d_trans_id, f_trans_id)
2603
 
        return tt, f_trans_id
2604
 
 
2605
 
    def test_root_create_file_open_raises_before_creation(self):
2606
 
        tt, trans_id = self.create_transform_and_root_trans_id()
2607
 
        self._override_globals_in_method(tt, "create_file",
2608
 
            {"open": self._fake_open_raises_before})
2609
 
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2610
 
        path = tt._limbo_name(trans_id)
2611
 
        self.assertPathDoesNotExist(path)
2612
 
        tt.finalize()
2613
 
        self.assertPathDoesNotExist(tt._limbodir)
2614
 
 
2615
 
    def test_root_create_file_open_raises_after_creation(self):
2616
 
        tt, trans_id = self.create_transform_and_root_trans_id()
2617
 
        self._override_globals_in_method(tt, "create_file",
2618
 
            {"open": self._fake_open_raises_after})
2619
 
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2620
 
        path = tt._limbo_name(trans_id)
2621
 
        self.assertPathExists(path)
2622
 
        tt.finalize()
2623
 
        self.assertPathDoesNotExist(path)
2624
 
        self.assertPathDoesNotExist(tt._limbodir)
2625
 
 
2626
 
    def test_subdir_create_file_open_raises_before_creation(self):
2627
 
        tt, trans_id = self.create_transform_and_subdir_trans_id()
2628
 
        self._override_globals_in_method(tt, "create_file",
2629
 
            {"open": self._fake_open_raises_before})
2630
 
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2631
 
        path = tt._limbo_name(trans_id)
2632
 
        self.assertPathDoesNotExist(path)
2633
 
        tt.finalize()
2634
 
        self.assertPathDoesNotExist(tt._limbodir)
2635
 
 
2636
 
    def test_subdir_create_file_open_raises_after_creation(self):
2637
 
        tt, trans_id = self.create_transform_and_subdir_trans_id()
2638
 
        self._override_globals_in_method(tt, "create_file",
2639
 
            {"open": self._fake_open_raises_after})
2640
 
        self.assertRaises(RuntimeError, tt.create_file, ["contents"], trans_id)
2641
 
        path = tt._limbo_name(trans_id)
2642
 
        self.assertPathExists(path)
2643
 
        tt.finalize()
2644
 
        self.assertPathDoesNotExist(path)
2645
 
        self.assertPathDoesNotExist(tt._limbodir)
2646
 
 
2647
 
    def test_rename_in_limbo_rename_raises_after_rename(self):
2648
 
        tt, trans_id = self.create_transform_and_root_trans_id()
2649
 
        parent1 = tt.new_directory('parent1', tt.root)
2650
 
        child1 = tt.new_file('child1', parent1, 'contents')
2651
 
        parent2 = tt.new_directory('parent2', tt.root)
2652
 
 
2653
 
        class FakeOSModule(object):
2654
 
            def rename(self, old, new):
2655
 
                os.rename(old, new)
2656
 
                raise RuntimeError
2657
 
        self._override_globals_in_method(tt, "_rename_in_limbo",
2658
 
            {"os": FakeOSModule()})
2659
 
        self.assertRaises(
2660
 
            RuntimeError, tt.adjust_path, "child1", parent2, child1)
2661
 
        path = osutils.pathjoin(tt._limbo_name(parent2), "child1")
2662
 
        self.assertPathExists(path)
2663
 
        tt.finalize()
2664
 
        self.assertPathDoesNotExist(path)
2665
 
        self.assertPathDoesNotExist(tt._limbodir)
2666
 
 
2667
 
    def test_rename_in_limbo_rename_raises_before_rename(self):
2668
 
        tt, trans_id = self.create_transform_and_root_trans_id()
2669
 
        parent1 = tt.new_directory('parent1', tt.root)
2670
 
        child1 = tt.new_file('child1', parent1, 'contents')
2671
 
        parent2 = tt.new_directory('parent2', tt.root)
2672
 
 
2673
 
        class FakeOSModule(object):
2674
 
            def rename(self, old, new):
2675
 
                raise RuntimeError
2676
 
        self._override_globals_in_method(tt, "_rename_in_limbo",
2677
 
            {"os": FakeOSModule()})
2678
 
        self.assertRaises(
2679
 
            RuntimeError, tt.adjust_path, "child1", parent2, child1)
2680
 
        path = osutils.pathjoin(tt._limbo_name(parent1), "child1")
2681
 
        self.assertPathExists(path)
2682
 
        tt.finalize()
2683
 
        self.assertPathDoesNotExist(path)
2684
 
        self.assertPathDoesNotExist(tt._limbodir)
2685
 
 
2686
 
 
2687
 
class TestTransformMissingParent(tests.TestCaseWithTransport):
2688
 
 
2689
 
    def make_tt_with_versioned_dir(self):
 
2125
        self.failUnlessExists('a')
 
2126
        self.failUnlessExists('a/b')
 
2127
 
 
2128
    def test_resolve_no_parent(self):
2690
2129
        wt = self.make_branch_and_tree('.')
2691
 
        self.build_tree(['dir/',])
2692
 
        wt.add(['dir'], ['dir-id'])
2693
 
        wt.commit('Create dir')
2694
2130
        tt = TreeTransform(wt)
2695
2131
        self.addCleanup(tt.finalize)
2696
 
        return wt, tt
2697
 
 
2698
 
    def test_resolve_create_parent_for_versioned_file(self):
2699
 
        wt, tt = self.make_tt_with_versioned_dir()
2700
 
        dir_tid = tt.trans_id_tree_file_id('dir-id')
2701
 
        file_tid = tt.new_file('file', dir_tid, 'Contents', file_id='file-id')
2702
 
        tt.delete_contents(dir_tid)
2703
 
        tt.unversion_file(dir_tid)
2704
 
        conflicts = resolve_conflicts(tt)
2705
 
        # one conflict for the missing directory, one for the unversioned
2706
 
        # parent
2707
 
        self.assertLength(2, conflicts)
2708
 
 
2709
 
    def test_non_versioned_file_create_conflict(self):
2710
 
        wt, tt = self.make_tt_with_versioned_dir()
2711
 
        dir_tid = tt.trans_id_tree_file_id('dir-id')
2712
 
        tt.new_file('file', dir_tid, 'Contents')
2713
 
        tt.delete_contents(dir_tid)
2714
 
        tt.unversion_file(dir_tid)
2715
 
        conflicts = resolve_conflicts(tt)
2716
 
        # no conflicts or rather: orphaning 'file' resolve the 'dir' conflict
2717
 
        self.assertLength(1, conflicts)
2718
 
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
2719
 
                         conflicts.pop())
 
2132
        parent = tt.trans_id_file_id('parent-id')
 
2133
        tt.new_file('file', parent, 'Contents')
 
2134
        resolve_conflicts(tt)
2720
2135
 
2721
2136
 
2722
2137
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
2723
2138
                  ('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2724
2139
                  (False, False))
2725
2140
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
2726
 
              ('', ''), ('directory', 'directory'), (False, False))
 
2141
              ('', ''), ('directory', 'directory'), (False, None))
2727
2142
 
2728
2143
 
2729
2144
class TestTransformPreview(tests.TestCaseWithTransport):
2731
2146
    def create_tree(self):
2732
2147
        tree = self.make_branch_and_tree('.')
2733
2148
        self.build_tree_contents([('a', 'content 1')])
2734
 
        tree.set_root_id('TREE_ROOT')
2735
2149
        tree.add('a', 'a-id')
2736
2150
        tree.commit('rev1', rev_id='rev1')
2737
2151
        return tree.branch.repository.revision_tree('rev1')
2816
2230
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2817
2231
        changes = preview_tree.iter_changes(revision_tree,
2818
2232
                                            specific_files=[''])
2819
 
        self.assertEqual([A_ENTRY], list(changes))
 
2233
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2820
2234
 
2821
2235
    def test_want_unversioned(self):
2822
2236
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2823
2237
        changes = preview_tree.iter_changes(revision_tree,
2824
2238
                                            want_unversioned=True)
2825
 
        self.assertEqual([A_ENTRY], list(changes))
 
2239
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
2826
2240
 
2827
2241
    def test_ignore_extra_trees_no_specific_files(self):
2828
2242
        # extra_trees is harmless without specific_files, so we'll silently
2838
2252
    def test_ignore_pb(self):
2839
2253
        # pb could be supported, but TT.iter_changes doesn't support it.
2840
2254
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2841
 
        preview_tree.iter_changes(revision_tree)
 
2255
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
2842
2256
 
2843
2257
    def test_kind(self):
2844
2258
        revision_tree = self.create_tree()
2859
2273
        self.assertEqual(os.stat(limbo_path).st_mtime,
2860
2274
                         preview_tree.get_file_mtime('file-id'))
2861
2275
 
2862
 
    def test_get_file_mtime_renamed(self):
2863
 
        work_tree = self.make_branch_and_tree('tree')
2864
 
        self.build_tree(['tree/file'])
2865
 
        work_tree.add('file', 'file-id')
2866
 
        preview = TransformPreview(work_tree)
2867
 
        self.addCleanup(preview.finalize)
2868
 
        file_trans_id = preview.trans_id_tree_file_id('file-id')
2869
 
        preview.adjust_path('renamed', preview.root, file_trans_id)
2870
 
        preview_tree = preview.get_preview_tree()
2871
 
        preview_mtime = preview_tree.get_file_mtime('file-id', 'renamed')
2872
 
        work_mtime = work_tree.get_file_mtime('file-id', 'file')
2873
 
 
2874
 
    def test_get_file_size(self):
2875
 
        work_tree = self.make_branch_and_tree('tree')
2876
 
        self.build_tree_contents([('tree/old', 'old')])
2877
 
        work_tree.add('old', 'old-id')
2878
 
        preview = TransformPreview(work_tree)
2879
 
        self.addCleanup(preview.finalize)
2880
 
        new_id = preview.new_file('name', preview.root, 'contents', 'new-id',
2881
 
                                  'executable')
2882
 
        tree = preview.get_preview_tree()
2883
 
        self.assertEqual(len('old'), tree.get_file_size('old-id'))
2884
 
        self.assertEqual(len('contents'), tree.get_file_size('new-id'))
2885
 
 
2886
2276
    def test_get_file(self):
2887
2277
        preview = self.get_empty_preview()
2888
2278
        preview.new_file('file', preview.root, 'contents', 'file-id')
3036
2426
        self.assertEqual(('missing', None, None, None), summary)
3037
2427
 
3038
2428
    def test_file_content_summary_executable(self):
 
2429
        if not osutils.supports_executable():
 
2430
            raise TestNotApplicable()
3039
2431
        preview = self.get_empty_preview()
3040
2432
        path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
3041
2433
        preview.set_executability(True, path_id)
3050
2442
        self.assertIs(None, summary[3])
3051
2443
 
3052
2444
    def test_change_executability(self):
 
2445
        if not osutils.supports_executable():
 
2446
            raise TestNotApplicable()
3053
2447
        tree = self.make_branch_and_tree('tree')
3054
2448
        self.build_tree(['tree/path'])
3055
2449
        tree.add('path')
3069
2463
        # size must be known
3070
2464
        self.assertEqual(len('contents'), summary[1])
3071
2465
        # not executable
3072
 
        self.assertEqual(False, summary[2])
 
2466
        if osutils.supports_executable():
 
2467
            self.assertEqual(False, summary[2])
 
2468
        else:
 
2469
            self.assertEqual(None, summary[2])
3073
2470
        # will not have hash (not cheap to determine)
3074
2471
        self.assertIs(None, summary[3])
3075
2472
 
3216
2613
 
3217
2614
    def test_walkdirs(self):
3218
2615
        preview = self.get_empty_preview()
3219
 
        root = preview.new_directory('', ROOT_PARENT, 'tree-root')
3220
 
        # FIXME: new_directory should mark root.
3221
 
        preview.fixup_new_roots()
 
2616
        preview.version_file('tree-root', preview.root)
3222
2617
        preview_tree = preview.get_preview_tree()
3223
2618
        file_trans_id = preview.new_file('a', preview.root, 'contents',
3224
2619
                                         'a-id')
3255
2650
        self.addCleanup(work_tree.unlock)
3256
2651
        preview = TransformPreview(work_tree)
3257
2652
        self.addCleanup(preview.finalize)
 
2653
        preview_tree = preview.get_preview_tree()
3258
2654
        file_trans_id = preview.trans_id_file_id('file-id')
3259
2655
        preview.delete_contents(file_trans_id)
3260
2656
        preview.create_file('a\nb\n', file_trans_id)
3261
 
        preview_tree = preview.get_preview_tree()
3262
 
        merger = Merger.from_revision_ids(None, preview_tree,
 
2657
        pb = progress.DummyProgress()
 
2658
        merger = Merger.from_revision_ids(pb, preview_tree,
3263
2659
                                          child_tree.branch.last_revision(),
3264
2660
                                          other_branch=child_tree.branch,
3265
2661
                                          tree_branch=work_tree.branch)
3271
2667
 
3272
2668
    def test_merge_preview_into_workingtree(self):
3273
2669
        tree = self.make_branch_and_tree('tree')
3274
 
        tree.set_root_id('TREE_ROOT')
3275
2670
        tt = TransformPreview(tree)
3276
2671
        self.addCleanup(tt.finalize)
3277
2672
        tt.new_file('name', tt.root, 'content', 'file-id')
3278
2673
        tree2 = self.make_branch_and_tree('tree2')
3279
 
        tree2.set_root_id('TREE_ROOT')
 
2674
        pb = progress.DummyProgress()
3280
2675
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
3281
 
                                         None, tree.basis_tree())
 
2676
                                         pb, tree.basis_tree())
3282
2677
        merger.merge_type = Merge3Merger
3283
2678
        merger.do_merge()
3284
2679
 
3294
2689
        tt.create_file('baz', trans_id)
3295
2690
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
3296
2691
        self.build_tree_contents([('tree2/foo', 'qux')])
3297
 
        pb = None
 
2692
        pb = progress.DummyProgress()
3298
2693
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
3299
2694
                                         pb, tree.basis_tree())
3300
2695
        merger.merge_type = Merge3Merger
3301
2696
        merger.do_merge()
3302
2697
 
3303
 
    def test_has_filename(self):
3304
 
        wt = self.make_branch_and_tree('tree')
3305
 
        self.build_tree(['tree/unmodified', 'tree/removed', 'tree/modified'])
3306
 
        tt = TransformPreview(wt)
3307
 
        removed_id = tt.trans_id_tree_path('removed')
3308
 
        tt.delete_contents(removed_id)
3309
 
        tt.new_file('new', tt.root, 'contents')
3310
 
        modified_id = tt.trans_id_tree_path('modified')
3311
 
        tt.delete_contents(modified_id)
3312
 
        tt.create_file('modified-contents', modified_id)
3313
 
        self.addCleanup(tt.finalize)
3314
 
        tree = tt.get_preview_tree()
3315
 
        self.assertTrue(tree.has_filename('unmodified'))
3316
 
        self.assertFalse(tree.has_filename('not-present'))
3317
 
        self.assertFalse(tree.has_filename('removed'))
3318
 
        self.assertTrue(tree.has_filename('new'))
3319
 
        self.assertTrue(tree.has_filename('modified'))
3320
 
 
3321
2698
    def test_is_executable(self):
3322
2699
        tree = self.make_branch_and_tree('tree')
3323
2700
        preview = TransformPreview(tree)
3345
2722
        rev2_tree = tree.branch.repository.revision_tree(rev2_id)
3346
2723
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
3347
2724
 
3348
 
    def test_ascii_limbo_paths(self):
3349
 
        self.requireFeature(features.UnicodeFilenameFeature)
3350
 
        branch = self.make_branch('any')
3351
 
        tree = branch.repository.revision_tree(_mod_revision.NULL_REVISION)
3352
 
        tt = TransformPreview(tree)
3353
 
        self.addCleanup(tt.finalize)
3354
 
        foo_id = tt.new_directory('', ROOT_PARENT)
3355
 
        bar_id = tt.new_file(u'\u1234bar', foo_id, 'contents')
3356
 
        limbo_path = tt._limbo_name(bar_id)
3357
 
        self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)
3358
 
 
3359
2725
 
3360
2726
class FakeSerializer(object):
3361
2727
    """Serializer implementation that simply returns the input.
3369
2735
 
3370
2736
class TestSerializeTransform(tests.TestCaseWithTransport):
3371
2737
 
3372
 
    _test_needs_features = [features.UnicodeFilenameFeature]
 
2738
    _test_needs_features = [tests.UnicodeFilenameFeature]
3373
2739
 
3374
2740
    def get_preview(self, tree=None):
3375
2741
        if tree is None:
3450
2816
        return self.make_records(attribs, contents)
3451
2817
 
3452
2818
    def test_serialize_symlink_creation(self):
3453
 
        self.requireFeature(features.SymlinkFeature)
 
2819
        self.requireFeature(tests.SymlinkFeature)
3454
2820
        tt = self.get_preview()
3455
2821
        tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')
3456
2822
        self.assertSerializesTo(self.symlink_creation_records(), tt)
3457
2823
 
3458
2824
    def test_deserialize_symlink_creation(self):
3459
 
        self.requireFeature(features.SymlinkFeature)
 
2825
        self.requireFeature(tests.SymlinkFeature)
3460
2826
        tt = self.get_preview()
3461
2827
        tt.deserialize(iter(self.symlink_creation_records()))
3462
2828
        abspath = tt._limbo_name('new-1')
3629
2995
        trans_id = tt.trans_id_tree_path('file')
3630
2996
        self.assertEqual((LINES_ONE,),
3631
2997
            tt._get_parents_texts(trans_id))
3632
 
 
3633
 
 
3634
 
class TestOrphan(tests.TestCaseWithTransport):
3635
 
 
3636
 
    def test_no_orphan_for_transform_preview(self):
3637
 
        tree = self.make_branch_and_tree('tree')
3638
 
        tt = transform.TransformPreview(tree)
3639
 
        self.addCleanup(tt.finalize)
3640
 
        self.assertRaises(NotImplementedError, tt.new_orphan, 'foo', 'bar')
3641
 
 
3642
 
    def _set_orphan_policy(self, wt, policy):
3643
 
        wt.branch.get_config().set_user_option('bzr.transform.orphan_policy',
3644
 
                                               policy)
3645
 
 
3646
 
    def _prepare_orphan(self, wt):
3647
 
        self.build_tree(['dir/', 'dir/file', 'dir/foo'])
3648
 
        wt.add(['dir', 'dir/file'], ['dir-id', 'file-id'])
3649
 
        wt.commit('add dir and file ignoring foo')
3650
 
        tt = transform.TreeTransform(wt)
3651
 
        self.addCleanup(tt.finalize)
3652
 
        # dir and bar are deleted
3653
 
        dir_tid = tt.trans_id_tree_path('dir')
3654
 
        file_tid = tt.trans_id_tree_path('dir/file')
3655
 
        orphan_tid = tt.trans_id_tree_path('dir/foo')
3656
 
        tt.delete_contents(file_tid)
3657
 
        tt.unversion_file(file_tid)
3658
 
        tt.delete_contents(dir_tid)
3659
 
        tt.unversion_file(dir_tid)
3660
 
        # There should be a conflict because dir still contain foo
3661
 
        raw_conflicts = tt.find_conflicts()
3662
 
        self.assertLength(1, raw_conflicts)
3663
 
        self.assertEqual(('missing parent', 'new-1'), raw_conflicts[0])
3664
 
        return tt, orphan_tid
3665
 
 
3666
 
    def test_new_orphan_created(self):
3667
 
        wt = self.make_branch_and_tree('.')
3668
 
        self._set_orphan_policy(wt, 'move')
3669
 
        tt, orphan_tid = self._prepare_orphan(wt)
3670
 
        warnings = []
3671
 
        def warning(*args):
3672
 
            warnings.append(args[0] % args[1:])
3673
 
        self.overrideAttr(trace, 'warning', warning)
3674
 
        remaining_conflicts = resolve_conflicts(tt)
3675
 
        self.assertEquals(['dir/foo has been orphaned in bzr-orphans'],
3676
 
                          warnings)
3677
 
        # Yeah for resolved conflicts !
3678
 
        self.assertLength(0, remaining_conflicts)
3679
 
        # We have a new orphan
3680
 
        self.assertEquals('foo.~1~', tt.final_name(orphan_tid))
3681
 
        self.assertEquals('bzr-orphans',
3682
 
                          tt.final_name(tt.final_parent(orphan_tid)))
3683
 
 
3684
 
    def test_never_orphan(self):
3685
 
        wt = self.make_branch_and_tree('.')
3686
 
        self._set_orphan_policy(wt, 'conflict')
3687
 
        tt, orphan_tid = self._prepare_orphan(wt)
3688
 
        remaining_conflicts = resolve_conflicts(tt)
3689
 
        self.assertLength(1, remaining_conflicts)
3690
 
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
3691
 
                         remaining_conflicts.pop())
3692
 
 
3693
 
    def test_orphan_error(self):
3694
 
        def bogus_orphan(tt, orphan_id, parent_id):
3695
 
            raise transform.OrphaningError(tt.final_name(orphan_id),
3696
 
                                           tt.final_name(parent_id))
3697
 
        transform.orphaning_registry.register('bogus', bogus_orphan,
3698
 
                                              'Raise an error when orphaning')
3699
 
        wt = self.make_branch_and_tree('.')
3700
 
        self._set_orphan_policy(wt, 'bogus')
3701
 
        tt, orphan_tid = self._prepare_orphan(wt)
3702
 
        remaining_conflicts = resolve_conflicts(tt)
3703
 
        self.assertLength(1, remaining_conflicts)
3704
 
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
3705
 
                         remaining_conflicts.pop())
3706
 
 
3707
 
    def test_unknown_orphan_policy(self):
3708
 
        wt = self.make_branch_and_tree('.')
3709
 
        # Set a fictional policy nobody ever implemented
3710
 
        self._set_orphan_policy(wt, 'donttouchmypreciouuus')
3711
 
        tt, orphan_tid = self._prepare_orphan(wt)
3712
 
        warnings = []
3713
 
        def warning(*args):
3714
 
            warnings.append(args[0] % args[1:])
3715
 
        self.overrideAttr(trace, 'warning', warning)
3716
 
        remaining_conflicts = resolve_conflicts(tt)
3717
 
        # We fallback to the default policy which create a conflict
3718
 
        self.assertLength(1, remaining_conflicts)
3719
 
        self.assertEqual(('deleting parent', 'Not deleting', 'new-1'),
3720
 
                         remaining_conflicts.pop())
3721
 
        self.assertLength(1, warnings)
3722
 
        self.assertStartsWith(warnings[0], 'donttouchmypreciouuus')