← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_transform.py

(jameinel) Allow 'bzr serve' to interpret SIGHUP as a graceful shutdown.
 (bug #795025) (John A Meinel)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_transform.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
import errno
17
18
import os
18
 
import stat
19
19
from StringIO import StringIO
20
20
import sys
 
21
import time
21
22
 
22
23
from bzrlib import (
 
24
    bencode,
23
25
    errors,
 
26
    filters,
24
27
    generate_ids,
25
28
    osutils,
26
 
    progress,
27
29
    revision as _mod_revision,
 
30
    rules,
28
31
    symbol_versioning,
29
32
    tests,
 
33
    trace,
 
34
    transform,
30
35
    urlutils,
31
36
    )
32
37
from bzrlib.bzrdir import BzrDir
33
 
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
34
 
                              UnversionedParent, ParentLoop, DeletingParent,
35
 
                              NonDirectoryParent)
 
38
from bzrlib.conflicts import (
 
39
    DeletingParent,
 
40
    DuplicateEntry,
 
41
    DuplicateID,
 
42
    MissingParent,
 
43
    NonDirectoryParent,
 
44
    ParentLoop,
 
45
    UnversionedParent,
 
46
)
36
47
from bzrlib.diff import show_diff_trees
37
 
from bzrlib.errors import (DuplicateKey, MalformedTransform, NoSuchFile,
38
 
                           ReusingTransform, CantMoveRoot, 
39
 
                           PathsNotVersionedError, ExistingLimbo,
40
 
                           ExistingPendingDeletion, ImmortalLimbo,
41
 
                           ImmortalPendingDeletion, LockError)
42
 
from bzrlib.osutils import file_kind, pathjoin
 
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
)
43
62
from bzrlib.merge import Merge3Merger, Merger
44
63
from bzrlib.tests import (
 
64
    features,
 
65
    TestCaseInTempDir,
 
66
    TestSkipped,
 
67
    )
 
68
from bzrlib.tests.features import (
45
69
    HardlinkFeature,
46
70
    SymlinkFeature,
47
 
    TestCase,
48
 
    TestCaseInTempDir,
49
 
    TestSkipped,
50
71
    )
51
 
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths, 
52
 
                              resolve_conflicts, cook_conflicts, 
53
 
                              build_tree, get_backup_name,
54
 
                              _FileMover, resolve_checkout,
55
 
                              TransformPreview, create_from_tree)
56
 
from bzrlib.util import bencode
 
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
)
57
84
 
58
85
 
59
86
class TestTreeTransform(tests.TestCaseWithTransport):
68
95
        self.addCleanup(transform.finalize)
69
96
        return transform, transform.root
70
97
 
 
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
 
71
108
    def test_existing_limbo(self):
72
109
        transform, root = self.get_transform()
73
110
        limbo_name = transform._limbodir
100
137
        imaginary_id = transform.trans_id_tree_path('imaginary')
101
138
        imaginary_id2 = transform.trans_id_tree_path('imaginary/')
102
139
        self.assertEqual(imaginary_id, imaginary_id2)
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())
 
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))
106
143
        trans_id = transform.create_path('name', root)
107
144
        self.assertIs(transform.final_file_id(trans_id), None)
108
 
        self.assertRaises(NoSuchFile, transform.final_kind, trans_id)
 
145
        self.assertIs(None, transform.final_kind(trans_id))
109
146
        transform.create_file('contents', trans_id)
110
147
        transform.set_executability(True, trans_id)
111
148
        transform.version_file('my_pretties', trans_id)
129
166
        self.assertIs(self.wt.is_executable('my_pretties2'), False)
130
167
        self.assertEqual('directory', file_kind(self.wt.abspath('oz')))
131
168
        self.assertEqual(len(modified_paths), 3)
132
 
        tree_mod_paths = [self.wt.id2abspath(f) for f in 
 
169
        tree_mod_paths = [self.wt.id2abspath(f) for f in
133
170
                          ('ozzie', 'my_pretties', 'my_pretties2')]
134
171
        self.assertSubset(tree_mod_paths, modified_paths)
135
172
        # is it safe to finalize repeatedly?
136
173
        transform.finalize()
137
174
        transform.finalize()
138
175
 
 
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
 
139
352
    def test_hardlink(self):
140
353
        self.requireFeature(HardlinkFeature)
141
354
        transform, root = self.get_transform()
146
359
        trans_id = target_transform.create_path('file1', target_transform.root)
147
360
        target_transform.create_hardlink(self.wt.abspath('file1'), trans_id)
148
361
        target_transform.apply()
149
 
        self.failUnlessExists('target/file1')
 
362
        self.assertPathExists('target/file1')
150
363
        source_stat = os.stat(self.wt.abspath('file1'))
151
364
        target_stat = os.stat('target/file1')
152
365
        self.assertEqual(source_stat, target_stat)
155
368
        transform, root = self.get_transform()
156
369
        self.wt.lock_tree_write()
157
370
        self.addCleanup(self.wt.unlock)
158
 
        trans_id = transform.new_file('name', root, 'contents', 
 
371
        trans_id = transform.new_file('name', root, 'contents',
159
372
                                      'my_pretties', True)
160
373
        oz = transform.new_directory('oz', root, 'oz-id')
161
374
        dorothy = transform.new_directory('dorothy', oz, 'dorothy-id')
162
 
        toto = transform.new_file('toto', dorothy, 'toto-contents', 
 
375
        toto = transform.new_file('toto', dorothy, 'toto-contents',
163
376
                                  'toto-id', False)
164
377
 
165
378
        self.assertEqual(len(transform.find_conflicts()), 0)
189
402
 
190
403
    def test_conflicts(self):
191
404
        transform, root = self.get_transform()
192
 
        trans_id = transform.new_file('name', root, 'contents', 
 
405
        trans_id = transform.new_file('name', root, 'contents',
193
406
                                      'my_pretties')
194
407
        self.assertEqual(len(transform.find_conflicts()), 0)
195
408
        trans_id2 = transform.new_file('name', root, 'Crontents', 'toto')
196
 
        self.assertEqual(transform.find_conflicts(), 
 
409
        self.assertEqual(transform.find_conflicts(),
197
410
                         [('duplicate', trans_id, trans_id2, 'name')])
198
411
        self.assertRaises(MalformedTransform, transform.apply)
199
412
        transform.adjust_path('name', trans_id, trans_id2)
200
 
        self.assertEqual(transform.find_conflicts(), 
 
413
        self.assertEqual(transform.find_conflicts(),
201
414
                         [('non-directory parent', trans_id)])
202
415
        tinman_id = transform.trans_id_tree_path('tinman')
203
416
        transform.adjust_path('name', tinman_id, trans_id2)
204
 
        self.assertEqual(transform.find_conflicts(), 
205
 
                         [('unversioned parent', tinman_id), 
 
417
        self.assertEqual(transform.find_conflicts(),
 
418
                         [('unversioned parent', tinman_id),
206
419
                          ('missing parent', tinman_id)])
207
420
        lion_id = transform.create_path('lion', root)
208
 
        self.assertEqual(transform.find_conflicts(), 
209
 
                         [('unversioned parent', tinman_id), 
 
421
        self.assertEqual(transform.find_conflicts(),
 
422
                         [('unversioned parent', tinman_id),
210
423
                          ('missing parent', tinman_id)])
211
424
        transform.adjust_path('name', lion_id, trans_id2)
212
 
        self.assertEqual(transform.find_conflicts(), 
 
425
        self.assertEqual(transform.find_conflicts(),
213
426
                         [('unversioned parent', lion_id),
214
427
                          ('missing parent', lion_id)])
215
428
        transform.version_file("Courage", lion_id)
216
 
        self.assertEqual(transform.find_conflicts(), 
217
 
                         [('missing parent', lion_id), 
 
429
        self.assertEqual(transform.find_conflicts(),
 
430
                         [('missing parent', lion_id),
218
431
                          ('versioning no contents', lion_id)])
219
432
        transform.adjust_path('name2', root, trans_id2)
220
 
        self.assertEqual(transform.find_conflicts(), 
 
433
        self.assertEqual(transform.find_conflicts(),
221
434
                         [('versioning no contents', lion_id)])
222
435
        transform.create_file('Contents, okay?', lion_id)
223
436
        transform.adjust_path('name2', trans_id2, trans_id2)
224
 
        self.assertEqual(transform.find_conflicts(), 
225
 
                         [('parent loop', trans_id2), 
 
437
        self.assertEqual(transform.find_conflicts(),
 
438
                         [('parent loop', trans_id2),
226
439
                          ('non-directory parent', trans_id2)])
227
440
        transform.adjust_path('name2', root, trans_id2)
228
441
        oz_id = transform.new_directory('oz', root)
229
442
        transform.set_executability(True, oz_id)
230
 
        self.assertEqual(transform.find_conflicts(), 
 
443
        self.assertEqual(transform.find_conflicts(),
231
444
                         [('unversioned executability', oz_id)])
232
445
        transform.version_file('oz-id', oz_id)
233
 
        self.assertEqual(transform.find_conflicts(), 
 
446
        self.assertEqual(transform.find_conflicts(),
234
447
                         [('non-file executability', oz_id)])
235
448
        transform.set_executability(None, oz_id)
236
449
        tip_id = transform.new_file('tip', oz_id, 'ozma', 'tip-id')
245
458
        self.assert_('oz/tip' in transform2._tree_path_ids)
246
459
        self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
247
460
        self.assertEqual(len(result), 2)
248
 
        self.assertEqual((result[0][0], result[0][1]), 
 
461
        self.assertEqual((result[0][0], result[0][1]),
249
462
                         ('duplicate', newtip))
250
 
        self.assertEqual((result[1][0], result[1][2]), 
 
463
        self.assertEqual((result[1][0], result[1][2]),
251
464
                         ('duplicate id', newtip))
252
465
        transform2.finalize()
253
466
        transform3 = TreeTransform(self.wt)
254
467
        self.addCleanup(transform3.finalize)
255
468
        oz_id = transform3.trans_id_tree_file_id('oz-id')
256
469
        transform3.delete_contents(oz_id)
257
 
        self.assertEqual(transform3.find_conflicts(), 
 
470
        self.assertEqual(transform3.find_conflicts(),
258
471
                         [('missing parent', oz_id)])
259
472
        root_id = transform3.root
260
473
        tip_id = transform3.trans_id_tree_file_id('tip-id')
318
531
        transform.new_file('FiLe', transform.root, 'content')
319
532
        resolve_conflicts(transform)
320
533
        transform.apply()
321
 
        self.failUnlessExists('tree/file')
322
 
        self.failUnlessExists('tree/FiLe.moved')
 
534
        self.assertPathExists('tree/file')
 
535
        self.assertPathExists('tree/FiLe.moved')
323
536
 
324
537
    def test_resolve_checkout_case_conflict(self):
325
538
        tree = self.make_branch_and_tree('tree')
334
547
        resolve_conflicts(transform,
335
548
                          pass_func=lambda t, c: resolve_checkout(t, c, []))
336
549
        transform.apply()
337
 
        self.failUnlessExists('tree/file')
338
 
        self.failUnlessExists('tree/FiLe.moved')
 
550
        self.assertPathExists('tree/file')
 
551
        self.assertPathExists('tree/FiLe.moved')
339
552
 
340
553
    def test_apply_case_conflict(self):
341
554
        """Ensure that a transform with case conflicts can always be applied"""
349
562
        transform.new_file('dirFiLe', dir, 'content')
350
563
        resolve_conflicts(transform)
351
564
        transform.apply()
352
 
        self.failUnlessExists('tree/file')
 
565
        self.assertPathExists('tree/file')
353
566
        if not os.path.exists('tree/FiLe.moved'):
354
 
            self.failUnlessExists('tree/FiLe')
355
 
        self.failUnlessExists('tree/dir/dirfile')
 
567
            self.assertPathExists('tree/FiLe')
 
568
        self.assertPathExists('tree/dir/dirfile')
356
569
        if not os.path.exists('tree/dir/dirFiLe.moved'):
357
 
            self.failUnlessExists('tree/dir/dirFiLe')
 
570
            self.assertPathExists('tree/dir/dirFiLe')
358
571
 
359
572
    def test_case_insensitive_limbo(self):
360
573
        tree = self.make_branch_and_tree('tree')
369
582
        self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
370
583
        self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
371
584
 
 
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
 
372
597
    def test_add_del(self):
373
598
        start, root = self.get_transform()
374
599
        start.new_directory('a', root, 'a')
387
612
        self.addCleanup(unversion.finalize)
388
613
        parent = unversion.trans_id_tree_path('parent')
389
614
        unversion.unversion_file(parent)
390
 
        self.assertEqual(unversion.find_conflicts(), 
 
615
        self.assertEqual(unversion.find_conflicts(),
391
616
                         [('unversioned parent', parent_id)])
392
617
        file_id = unversion.trans_id_tree_file_id('child-id')
393
618
        unversion.unversion_file(file_id)
413
638
        mangle_tree.adjust_path('name2', root, name1)
414
639
        mangle_tree.adjust_path('name1', root, name2)
415
640
 
416
 
        #tests for deleting parent directories 
 
641
        #tests for deleting parent directories
417
642
        ddir = mangle_tree.trans_id_tree_file_id('ddir')
418
643
        mangle_tree.delete_contents(ddir)
419
644
        dfile = mangle_tree.trans_id_tree_file_id('dfile')
448
673
        create_tree,root = self.get_transform()
449
674
        newdir = create_tree.new_directory('selftest', root, 'selftest-id')
450
675
        create_tree.new_file('blackbox.py', newdir, 'hello1', 'blackbox-id')
451
 
        create_tree.apply()        
 
676
        create_tree.apply()
452
677
        mangle_tree,root = self.get_transform()
453
678
        selftest = mangle_tree.trans_id_tree_file_id('selftest-id')
454
679
        blackbox = mangle_tree.trans_id_tree_file_id('blackbox-id')
462
687
        bzrlib = create_tree.new_directory('bzrlib', root, 'bzrlib-id')
463
688
        tests = create_tree.new_directory('tests', bzrlib, 'tests-id')
464
689
        blackbox = create_tree.new_directory('blackbox', tests, 'blackbox-id')
465
 
        create_tree.new_file('test_too_much.py', blackbox, 'hello1', 
 
690
        create_tree.new_file('test_too_much.py', blackbox, 'hello1',
466
691
                             'test_too_much-id')
467
 
        create_tree.apply()        
 
692
        create_tree.apply()
468
693
        mangle_tree,root = self.get_transform()
469
694
        bzrlib = mangle_tree.trans_id_tree_file_id('bzrlib-id')
470
695
        tests = mangle_tree.trans_id_tree_file_id('tests-id')
471
696
        test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
472
697
        mangle_tree.adjust_path('selftest', bzrlib, tests)
473
 
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much) 
 
698
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
474
699
        mangle_tree.set_executability(True, test_too_much)
475
700
        mangle_tree.apply()
476
701
 
477
702
    def test_both_rename3(self):
478
703
        create_tree,root = self.get_transform()
479
704
        tests = create_tree.new_directory('tests', root, 'tests-id')
480
 
        create_tree.new_file('test_too_much.py', tests, 'hello1', 
 
705
        create_tree.new_file('test_too_much.py', tests, 'hello1',
481
706
                             'test_too_much-id')
482
 
        create_tree.apply()        
 
707
        create_tree.apply()
483
708
        mangle_tree,root = self.get_transform()
484
709
        tests = mangle_tree.trans_id_tree_file_id('tests-id')
485
710
        test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
486
711
        mangle_tree.adjust_path('selftest', root, tests)
487
 
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much) 
 
712
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
488
713
        mangle_tree.set_executability(True, test_too_much)
489
714
        mangle_tree.apply()
490
715
 
503
728
        newdir = move_id.new_directory('dir', root, 'newdir')
504
729
        move_id.adjust_path('name2', newdir, name1)
505
730
        move_id.apply()
506
 
        
 
731
 
507
732
    def test_replace_dangling_ie(self):
508
733
        create_tree, root = self.get_transform()
509
734
        # prepare tree
525
750
        resolve_conflicts(replace)
526
751
        replace.apply()
527
752
 
528
 
    def test_symlinks(self):
 
753
    def _test_symlinks(self, link_name1,link_target1,
 
754
                       link_name2, link_target2):
 
755
 
 
756
        def ozpath(p): return 'oz/' + p
 
757
 
529
758
        self.requireFeature(SymlinkFeature)
530
 
        transform,root = self.get_transform()
 
759
        transform, root = self.get_transform()
531
760
        oz_id = transform.new_directory('oz', root, 'oz-id')
532
 
        wizard = transform.new_symlink('wizard', oz_id, 'wizard-target', 
 
761
        wizard = transform.new_symlink(link_name1, oz_id, link_target1,
533
762
                                       'wizard-id')
534
 
        wiz_id = transform.create_path('wizard2', oz_id)
535
 
        transform.create_symlink('behind_curtain', wiz_id)
536
 
        transform.version_file('wiz-id2', wiz_id)            
 
763
        wiz_id = transform.create_path(link_name2, oz_id)
 
764
        transform.create_symlink(link_target2, wiz_id)
 
765
        transform.version_file('wiz-id2', wiz_id)
537
766
        transform.set_executability(True, wiz_id)
538
 
        self.assertEqual(transform.find_conflicts(), 
 
767
        self.assertEqual(transform.find_conflicts(),
539
768
                         [('non-file executability', wiz_id)])
540
769
        transform.set_executability(None, wiz_id)
541
770
        transform.apply()
542
 
        self.assertEqual(self.wt.path2id('oz/wizard'), 'wizard-id')
543
 
        self.assertEqual(file_kind(self.wt.abspath('oz/wizard')), 'symlink')
544
 
        self.assertEqual(os.readlink(self.wt.abspath('oz/wizard2')), 
545
 
                         'behind_curtain')
546
 
        self.assertEqual(os.readlink(self.wt.abspath('oz/wizard')),
547
 
                         'wizard-target')
 
771
        self.assertEqual(self.wt.path2id(ozpath(link_name1)), 'wizard-id')
 
772
        self.assertEqual('symlink',
 
773
                         file_kind(self.wt.abspath(ozpath(link_name1))))
 
774
        self.assertEqual(link_target2,
 
775
                         osutils.readlink(self.wt.abspath(ozpath(link_name2))))
 
776
        self.assertEqual(link_target1,
 
777
                         osutils.readlink(self.wt.abspath(ozpath(link_name1))))
 
778
 
 
779
    def test_symlinks(self):
 
780
        self._test_symlinks('wizard', 'wizard-target',
 
781
                            'wizard2', 'behind_curtain')
 
782
 
 
783
    def test_symlinks_unicode(self):
 
784
        self.requireFeature(features.UnicodeFilenameFeature)
 
785
        self._test_symlinks(u'\N{Euro Sign}wizard',
 
786
                            u'wizard-targ\N{Euro Sign}t',
 
787
                            u'\N{Euro Sign}wizard2',
 
788
                            u'b\N{Euro Sign}hind_curtain')
548
789
 
549
790
    def test_unable_create_symlink(self):
550
791
        def tt_helper():
574
815
        create.apply()
575
816
        conflicts,root = self.get_transform()
576
817
        # set up duplicate entry, duplicate id
577
 
        new_dorothy = conflicts.new_file('dorothy', root, 'dorothy', 
 
818
        new_dorothy = conflicts.new_file('dorothy', root, 'dorothy',
578
819
                                         'dorothy-id')
579
820
        old_dorothy = conflicts.trans_id_tree_file_id('dorothy-id')
580
821
        oz = conflicts.trans_id_tree_file_id('oz-id')
604
845
        tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
605
846
        raw_conflicts = resolve_conflicts(tt)
606
847
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
607
 
        duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved', 
 
848
        duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
608
849
                                   'dorothy', None, 'dorothy-id')
609
850
        self.assertEqual(cooked_conflicts[0], duplicate)
610
 
        duplicate_id = DuplicateID('Unversioned existing file', 
 
851
        duplicate_id = DuplicateID('Unversioned existing file',
611
852
                                   'dorothy.moved', 'dorothy', None,
612
853
                                   'dorothy-id')
613
854
        self.assertEqual(cooked_conflicts[1], duplicate_id)
621
862
        unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
622
863
                                               'oz-id')
623
864
        self.assertEqual(cooked_conflicts[3], unversioned_parent)
624
 
        parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity', 
 
865
        parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity',
625
866
                                 'oz/emeraldcity', 'emerald-id', 'emerald-id')
626
867
        self.assertEqual(cooked_conflicts[4], deleted_parent)
627
868
        self.assertEqual(cooked_conflicts[5], unversioned_parent2)
634
875
        raw_conflicts = resolve_conflicts(tt)
635
876
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
636
877
        tt.finalize()
637
 
        conflicts_s = [str(c) for c in cooked_conflicts]
 
878
        conflicts_s = [unicode(c) for c in cooked_conflicts]
638
879
        self.assertEqual(len(cooked_conflicts), len(conflicts_s))
639
880
        self.assertEqual(conflicts_s[0], 'Conflict adding file dorothy.  '
640
881
                                         'Moved existing file to '
653
894
                                         ' versioned, but has versioned'
654
895
                                         ' children.  Versioned directory.')
655
896
        self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
656
 
                                         ' oz/emeraldcity.  Cancelled move.')
 
897
                                         ' oz/emeraldcity. Cancelled move.')
657
898
 
658
899
    def prepare_wrong_parent_kind(self):
659
900
        tt, root = self.get_transform()
710
951
        self.assertIs(None, self.wt.path2id('parent'))
711
952
        self.assertIs(None, self.wt.path2id('parent.new'))
712
953
 
 
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
 
713
969
    def test_moving_versioned_directories(self):
714
970
        create, root = self.get_transform()
715
971
        kansas = create.new_directory('kansas', root, 'kansas-id')
730
986
        create.apply()
731
987
        transform, root = self.get_transform()
732
988
        transform.adjust_root_path('oldroot', fun)
733
 
        new_root=transform.trans_id_tree_path('')
 
989
        new_root = transform.trans_id_tree_path('')
734
990
        transform.version_file('new-root', new_root)
735
991
        transform.apply()
736
992
 
748
1004
        rename.set_executability(True, myfile)
749
1005
        rename.apply()
750
1006
 
 
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
 
751
1045
    def test_set_executability_order(self):
752
1046
        """Ensure that executability behaves the same, no matter what order.
753
 
        
 
1047
 
754
1048
        - create file and set executability simultaneously
755
1049
        - create file and set executability afterward
756
1050
        - unsetting the executability of a file whose executability has not been
1025
1319
        parent2 = transform.new_directory('parent2', root)
1026
1320
        transform.adjust_path('child1', parent2, child1)
1027
1321
        transform.apply()
1028
 
        self.failIfExists(self.wt.abspath('parent1/child1'))
1029
 
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
 
1322
        self.assertPathDoesNotExist(self.wt.abspath('parent1/child1'))
 
1323
        self.assertPathExists(self.wt.abspath('parent2/child1'))
1030
1324
        # rename limbo/new-1 => parent1, rename limbo/new-3 => parent2
1031
1325
        # no rename for child1 (counting only renames during apply)
1032
 
        self.failUnlessEqual(2, transform.rename_count)
 
1326
        self.assertEqual(2, transform.rename_count)
1033
1327
 
1034
1328
    def test_cancel_parent(self):
1035
1329
        """Cancelling a parent doesn't cause deletion of a non-empty directory
1058
1352
        parent2 = transform.new_directory('parent2', root)
1059
1353
        transform.adjust_path('child1', parent2, child1)
1060
1354
        transform.apply()
1061
 
        self.failIfExists(self.wt.abspath('parent1'))
1062
 
        self.failUnlessExists(self.wt.abspath('parent2/child1'))
 
1355
        self.assertPathDoesNotExist(self.wt.abspath('parent1'))
 
1356
        self.assertPathExists(self.wt.abspath('parent2/child1'))
1063
1357
        # rename limbo/new-3 => parent2, rename limbo/new-2 => child1
1064
 
        self.failUnlessEqual(2, transform.rename_count)
 
1358
        self.assertEqual(2, transform.rename_count)
1065
1359
 
1066
1360
    def test_adjust_and_cancel(self):
1067
1361
        """Make sure adjust_path keeps track of limbo children properly"""
1100
1394
        child = transform.new_directory('child', parent)
1101
1395
        transform.adjust_path('parent', root, parent)
1102
1396
        transform.apply()
1103
 
        self.failUnlessExists(self.wt.abspath('parent/child'))
 
1397
        self.assertPathExists(self.wt.abspath('parent/child'))
1104
1398
        self.assertEqual(1, transform.rename_count)
1105
1399
 
1106
1400
    def test_reuse_name(self):
1237
1531
        tt.create_file(["aa\n"], bar_trans_id)
1238
1532
        tt.version_file("bar-1", bar_trans_id)
1239
1533
        tt.apply()
1240
 
        self.failUnlessExists("foo/bar")
 
1534
        self.assertPathExists("foo/bar")
1241
1535
        wt.lock_read()
1242
1536
        try:
1243
1537
            self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1260
1554
        tt.delete_contents(foo_trans_id)
1261
1555
        tt.create_symlink("bar", foo_trans_id)
1262
1556
        tt.apply()
1263
 
        self.failUnlessExists("foo")
 
1557
        self.assertPathExists("foo")
1264
1558
        wt.lock_read()
1265
1559
        self.addCleanup(wt.unlock)
1266
1560
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1279
1573
        tt.delete_versioned(bar_trans_id)
1280
1574
        tt.create_file(["aa\n"], foo_trans_id)
1281
1575
        tt.apply()
1282
 
        self.failUnlessExists("foo")
 
1576
        self.assertPathExists("foo")
1283
1577
        wt.lock_read()
1284
1578
        self.addCleanup(wt.unlock)
1285
1579
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1300
1594
        self.build_tree(['baz'])
1301
1595
        tt.create_hardlink("baz", foo_trans_id)
1302
1596
        tt.apply()
1303
 
        self.failUnlessExists("foo")
1304
 
        self.failUnlessExists("baz")
 
1597
        self.assertPathExists("foo")
 
1598
        self.assertPathExists("baz")
1305
1599
        wt.lock_read()
1306
1600
        self.addCleanup(wt.unlock)
1307
1601
        self.assertEqual(wt.inventory.get_file_kind(wt.path2id("foo")),
1369
1663
    return template % ('<' * 7, tree, '=' * 7, merge, '>' * 7)
1370
1664
 
1371
1665
 
 
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
 
1372
1698
class TestTransformMerge(TestCaseInTempDir):
1373
1699
 
1374
1700
    def test_text_merge(self):
1410
1736
        # textual merge
1411
1737
        self.assertEqual(this.wt.get_file('a').read(), 'y\nb\nc\nd\bz\n')
1412
1738
        # three-way text conflict
1413
 
        self.assertEqual(this.wt.get_file('b').read(), 
 
1739
        self.assertEqual(this.wt.get_file('b').read(),
1414
1740
                         conflict_text('b', 'b2'))
1415
1741
        # OTHER wins
1416
1742
        self.assertEqual(this.wt.get_file('c').read(), 'c2')
1420
1746
        self.assertEqual(this.wt.get_file('e').read(), 'e2')
1421
1747
        # No change
1422
1748
        self.assertEqual(this.wt.get_file('f').read(), 'f')
1423
 
        # Correct correct results when THIS == OTHER 
 
1749
        # Correct correct results when THIS == OTHER
1424
1750
        self.assertEqual(this.wt.get_file('g').read(), 'g')
1425
1751
        # Text conflict when THIS & OTHER are text and BASE is dir
1426
 
        self.assertEqual(this.wt.get_file('h').read(), 
 
1752
        self.assertEqual(this.wt.get_file('h').read(),
1427
1753
                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1428
1754
        self.assertEqual(this.wt.get_file_byname('h.THIS').read(),
1429
1755
                         '1\n2\n3\n4\n')
1430
1756
        self.assertEqual(this.wt.get_file_byname('h.OTHER').read(),
1431
1757
                         'h\ni\nj\nk\n')
1432
1758
        self.assertEqual(file_kind(this.wt.abspath('h.BASE')), 'directory')
1433
 
        self.assertEqual(this.wt.get_file('i').read(), 
 
1759
        self.assertEqual(this.wt.get_file('i').read(),
1434
1760
                         conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1435
1761
        self.assertEqual(this.wt.get_file_byname('i.THIS').read(),
1436
1762
                         '1\n2\n3\n4\n')
1460
1786
            tg.tt.new_symlink('b', tg.root, 'b', 'b')
1461
1787
            tg.tt.new_file('c', tg.root, 'c', 'c')
1462
1788
            tg.tt.new_symlink('d', tg.root, tg.name, 'd')
1463
 
        targets = ((base, 'base-e', 'base-f', None, None), 
1464
 
                   (this, 'other-e', 'this-f', 'other-g', 'this-h'), 
 
1789
        targets = ((base, 'base-e', 'base-f', None, None),
 
1790
                   (this, 'other-e', 'this-f', 'other-g', 'this-h'),
1465
1791
                   (other, 'other-e', None, 'other-g', 'other-h'))
1466
1792
        for tg, e_target, f_target, g_target, h_target in targets:
1467
 
            for link, target in (('e', e_target), ('f', f_target), 
 
1793
            for link, target in (('e', e_target), ('f', f_target),
1468
1794
                                 ('g', g_target), ('h', h_target)):
1469
1795
                if target is not None:
1470
1796
                    tg.tt.new_symlink(link, tg.root, target, link)
1496
1822
        base = TransformGroup("BASE", root_id)
1497
1823
        this = TransformGroup("THIS", root_id)
1498
1824
        other = TransformGroup("OTHER", root_id)
1499
 
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a') 
 
1825
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
1500
1826
                                   for t in [base, this, other]]
1501
 
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b') 
 
1827
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1502
1828
                                   for t in [base, this, other]]
1503
1829
        base.tt.new_directory('c', base_a, 'c')
1504
1830
        this.tt.new_directory('c1', this_a, 'c')
1529
1855
        base = TransformGroup("BASE", root_id)
1530
1856
        this = TransformGroup("THIS", root_id)
1531
1857
        other = TransformGroup("OTHER", root_id)
1532
 
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a') 
 
1858
        base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
1533
1859
                                   for t in [base, this, other]]
1534
 
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b') 
 
1860
        base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1535
1861
                                   for t in [base, this, other]]
1536
1862
 
1537
1863
        base.tt.new_file('g', base_a, 'g', 'g')
1584
1910
        tree.add_reference(subtree)
1585
1911
        tree.commit('a revision')
1586
1912
        tree.branch.create_checkout('target')
1587
 
        self.failUnlessExists('target')
1588
 
        self.failUnlessExists('target/subtree')
 
1913
        self.assertPathExists('target')
 
1914
        self.assertPathExists('target/subtree')
1589
1915
 
1590
1916
    def test_file_conflict_handling(self):
1591
1917
        """Ensure that when building trees, conflict handling is done"""
1628
1954
        os.symlink('foo', 'target2/symlink')
1629
1955
        build_tree(source.basis_tree(), target)
1630
1956
        self.assertEqual([], target.conflicts())
1631
 
        
 
1957
 
1632
1958
    def test_directory_conflict_handling(self):
1633
1959
        """Ensure that when building trees, conflict handling is done"""
1634
1960
        source = self.make_branch_and_tree('source')
1638
1964
        source.commit('added file')
1639
1965
        build_tree(source.basis_tree(), target)
1640
1966
        self.assertEqual([], target.conflicts())
1641
 
        self.failUnlessExists('target/dir1/file')
 
1967
        self.assertPathExists('target/dir1/file')
1642
1968
 
1643
1969
        # Ensure contents are merged
1644
1970
        target = self.make_branch_and_tree('target2')
1645
1971
        self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
1646
1972
        build_tree(source.basis_tree(), target)
1647
1973
        self.assertEqual([], target.conflicts())
1648
 
        self.failUnlessExists('target2/dir1/file2')
1649
 
        self.failUnlessExists('target2/dir1/file')
 
1974
        self.assertPathExists('target2/dir1/file2')
 
1975
        self.assertPathExists('target2/dir1/file')
1650
1976
 
1651
1977
        # Ensure new contents are suppressed for existing branches
1652
1978
        target = self.make_branch_and_tree('target3')
1653
1979
        self.make_branch('target3/dir1')
1654
1980
        self.build_tree(['target3/dir1/file2'])
1655
1981
        build_tree(source.basis_tree(), target)
1656
 
        self.failIfExists('target3/dir1/file')
1657
 
        self.failUnlessExists('target3/dir1/file2')
1658
 
        self.failUnlessExists('target3/dir1.diverted/file')
 
1982
        self.assertPathDoesNotExist('target3/dir1/file')
 
1983
        self.assertPathExists('target3/dir1/file2')
 
1984
        self.assertPathExists('target3/dir1.diverted/file')
1659
1985
        self.assertEqual([DuplicateEntry('Diverted to',
1660
1986
            'dir1.diverted', 'dir1', 'new-dir1', None)],
1661
1987
            target.conflicts())
1664
1990
        self.build_tree(['target4/dir1/'])
1665
1991
        self.make_branch('target4/dir1/file')
1666
1992
        build_tree(source.basis_tree(), target)
1667
 
        self.failUnlessExists('target4/dir1/file')
 
1993
        self.assertPathExists('target4/dir1/file')
1668
1994
        self.assertEqual('directory', file_kind('target4/dir1/file'))
1669
 
        self.failUnlessExists('target4/dir1/file.diverted')
 
1995
        self.assertPathExists('target4/dir1/file.diverted')
1670
1996
        self.assertEqual([DuplicateEntry('Diverted to',
1671
1997
            'dir1/file.diverted', 'dir1/file', 'new-file', None)],
1672
1998
            target.conflicts())
1690
2016
        target = self.make_branch_and_tree('target')
1691
2017
        self.build_tree(['target/name'])
1692
2018
        target.add('name')
1693
 
        self.assertRaises(errors.WorkingTreeAlreadyPopulated, 
 
2019
        self.assertRaises(errors.WorkingTreeAlreadyPopulated,
1694
2020
            build_tree, source.basis_tree(), target)
1695
2021
 
1696
2022
    def test_build_tree_rename_count(self):
1740
2066
        self.addCleanup(target.unlock)
1741
2067
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1742
2068
 
 
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
 
1743
2081
    def test_build_tree_accelerator_tree_missing_file(self):
1744
2082
        source = self.create_ab_tree()
1745
2083
        os.unlink('source/file1')
1840
2178
        self.assertEqual([], list(target.iter_changes(revision_tree)))
1841
2179
        self.assertTrue(source.is_executable('file1-id'))
1842
2180
 
 
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
 
1843
2228
    def test_case_insensitive_build_tree_inventory(self):
 
2229
        if (features.CaseInsensitiveFilesystemFeature.available()
 
2230
            or features.CaseInsCasePresFilenameFeature.available()):
 
2231
            raise tests.UnavailableFeature('Fully case sensitive filesystem')
1844
2232
        source = self.make_branch_and_tree('source')
1845
2233
        self.build_tree(['source/file', 'source/FILE'])
1846
2234
        source.add(['file', 'FILE'], ['lower-id', 'upper-id'])
1853
2241
        self.assertEqual('file.moved', target.id2path('lower-id'))
1854
2242
        self.assertEqual('FILE', target.id2path('upper-id'))
1855
2243
 
1856
 
 
1857
 
class MockTransform(object):
1858
 
 
1859
 
    def has_named_child(self, by_parent, parent_id, name):
1860
 
        for child_id in by_parent[parent_id]:
1861
 
            if child_id == '0':
1862
 
                if name == "name~":
1863
 
                    return True
1864
 
            elif name == "name.~%s~" % child_id:
1865
 
                return True
1866
 
        return False
1867
 
 
1868
 
 
1869
 
class MockEntry(object):
1870
 
    def __init__(self):
1871
 
        object.__init__(self)
1872
 
        self.name = "name"
1873
 
 
1874
 
 
1875
 
class TestGetBackupName(TestCase):
1876
 
    def test_get_backup_name(self):
 
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
 
 
2281
class TestCommitTransform(tests.TestCaseWithTransport):
 
2282
 
 
2283
    def get_branch(self):
 
2284
        tree = self.make_branch_and_tree('tree')
 
2285
        tree.lock_write()
 
2286
        self.addCleanup(tree.unlock)
 
2287
        tree.commit('empty commit')
 
2288
        return tree.branch
 
2289
 
 
2290
    def get_branch_and_transform(self):
 
2291
        branch = self.get_branch()
 
2292
        tt = TransformPreview(branch.basis_tree())
 
2293
        self.addCleanup(tt.finalize)
 
2294
        return branch, tt
 
2295
 
 
2296
    def test_commit_wrong_basis(self):
 
2297
        branch = self.get_branch()
 
2298
        basis = branch.repository.revision_tree(
 
2299
            _mod_revision.NULL_REVISION)
 
2300
        tt = TransformPreview(basis)
 
2301
        self.addCleanup(tt.finalize)
 
2302
        e = self.assertRaises(ValueError, tt.commit, branch, '')
 
2303
        self.assertEqual('TreeTransform not based on branch basis: null:',
 
2304
                         str(e))
 
2305
 
 
2306
    def test_empy_commit(self):
 
2307
        branch, tt = self.get_branch_and_transform()
 
2308
        rev = tt.commit(branch, 'my message')
 
2309
        self.assertEqual(2, branch.revno())
 
2310
        repo = branch.repository
 
2311
        self.assertEqual('my message', repo.get_revision(rev).message)
 
2312
 
 
2313
    def test_merge_parents(self):
 
2314
        branch, tt = self.get_branch_and_transform()
 
2315
        rev = tt.commit(branch, 'my message', ['rev1b', 'rev1c'])
 
2316
        self.assertEqual(['rev1b', 'rev1c'],
 
2317
                         branch.basis_tree().get_parent_ids()[1:])
 
2318
 
 
2319
    def test_first_commit(self):
 
2320
        branch = self.make_branch('branch')
 
2321
        branch.lock_write()
 
2322
        self.addCleanup(branch.unlock)
 
2323
        tt = TransformPreview(branch.basis_tree())
 
2324
        self.addCleanup(tt.finalize)
 
2325
        tt.new_directory('', ROOT_PARENT, 'TREE_ROOT')
 
2326
        rev = tt.commit(branch, 'my message')
 
2327
        self.assertEqual([], branch.basis_tree().get_parent_ids())
 
2328
        self.assertNotEqual(_mod_revision.NULL_REVISION,
 
2329
                            branch.last_revision())
 
2330
 
 
2331
    def test_first_commit_with_merge_parents(self):
 
2332
        branch = self.make_branch('branch')
 
2333
        branch.lock_write()
 
2334
        self.addCleanup(branch.unlock)
 
2335
        tt = TransformPreview(branch.basis_tree())
 
2336
        self.addCleanup(tt.finalize)
 
2337
        e = self.assertRaises(ValueError, tt.commit, branch,
 
2338
                          'my message', ['rev1b-id'])
 
2339
        self.assertEqual('Cannot supply merge parents for first commit.',
 
2340
                         str(e))
 
2341
        self.assertEqual(_mod_revision.NULL_REVISION, branch.last_revision())
 
2342
 
 
2343
    def test_add_files(self):
 
2344
        branch, tt = self.get_branch_and_transform()
 
2345
        tt.new_file('file', tt.root, 'contents', 'file-id')
 
2346
        trans_id = tt.new_directory('dir', tt.root, 'dir-id')
 
2347
        if SymlinkFeature.available():
 
2348
            tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
 
2349
        rev = tt.commit(branch, 'message')
 
2350
        tree = branch.basis_tree()
 
2351
        self.assertEqual('file', tree.id2path('file-id'))
 
2352
        self.assertEqual('contents', tree.get_file_text('file-id'))
 
2353
        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'))
 
2357
 
 
2358
    def test_add_unversioned(self):
 
2359
        branch, tt = self.get_branch_and_transform()
 
2360
        tt.new_file('file', tt.root, 'contents')
 
2361
        self.assertRaises(errors.StrictCommitFailed, tt.commit, branch,
 
2362
                          'message', strict=True)
 
2363
 
 
2364
    def test_modify_strict(self):
 
2365
        branch, tt = self.get_branch_and_transform()
 
2366
        tt.new_file('file', tt.root, 'contents', 'file-id')
 
2367
        tt.commit(branch, 'message', strict=True)
 
2368
        tt = TransformPreview(branch.basis_tree())
 
2369
        self.addCleanup(tt.finalize)
 
2370
        trans_id = tt.trans_id_file_id('file-id')
 
2371
        tt.delete_contents(trans_id)
 
2372
        tt.create_file('contents', trans_id)
 
2373
        tt.commit(branch, 'message', strict=True)
 
2374
 
 
2375
    def test_commit_malformed(self):
 
2376
        """Committing a malformed transform should raise an exception.
 
2377
 
 
2378
        In this case, we are adding a file without adding its parent.
 
2379
        """
 
2380
        branch, tt = self.get_branch_and_transform()
 
2381
        parent_id = tt.trans_id_file_id('parent-id')
 
2382
        tt.new_file('file', parent_id, 'contents', 'file-id')
 
2383
        self.assertRaises(errors.MalformedTransform, tt.commit, branch,
 
2384
                          'message')
 
2385
 
 
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
 
1877
2433
        tt = MockTransform()
1878
 
        name = get_backup_name(MockEntry(), {'a':[]}, 'a', tt)
1879
 
        self.assertEqual(name, 'name.~1~')
1880
 
        name = get_backup_name(MockEntry(), {'a':['1']}, 'a', tt)
1881
 
        self.assertEqual(name, 'name.~2~')
1882
 
        name = get_backup_name(MockEntry(), {'a':['2']}, 'a', tt)
1883
 
        self.assertEqual(name, 'name.~1~')
1884
 
        name = get_backup_name(MockEntry(), {'a':['2'], 'b':[]}, 'b', tt)
1885
 
        self.assertEqual(name, 'name.~1~')
1886
 
        name = get_backup_name(MockEntry(), {'a':['1', '2', '3']}, 'a', tt)
1887
 
        self.assertEqual(name, 'name.~4~')
 
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)
1888
2442
 
1889
2443
 
1890
2444
class TestFileMover(tests.TestCaseWithTransport):
1893
2447
        self.build_tree(['a/', 'a/b', 'c/', 'c/d'])
1894
2448
        mover = _FileMover()
1895
2449
        mover.rename('a', 'q')
1896
 
        self.failUnlessExists('q')
1897
 
        self.failIfExists('a')
1898
 
        self.failUnlessExists('q/b')
1899
 
        self.failUnlessExists('c')
1900
 
        self.failUnlessExists('c/d')
 
2450
        self.assertPathExists('q')
 
2451
        self.assertPathDoesNotExist('a')
 
2452
        self.assertPathExists('q/b')
 
2453
        self.assertPathExists('c')
 
2454
        self.assertPathExists('c/d')
1901
2455
 
1902
2456
    def test_pre_delete_rollback(self):
1903
2457
        self.build_tree(['a/'])
1904
2458
        mover = _FileMover()
1905
2459
        mover.pre_delete('a', 'q')
1906
 
        self.failUnlessExists('q')
1907
 
        self.failIfExists('a')
 
2460
        self.assertPathExists('q')
 
2461
        self.assertPathDoesNotExist('a')
1908
2462
        mover.rollback()
1909
 
        self.failIfExists('q')
1910
 
        self.failUnlessExists('a')
 
2463
        self.assertPathDoesNotExist('q')
 
2464
        self.assertPathExists('a')
1911
2465
 
1912
2466
    def test_apply_deletions(self):
1913
2467
        self.build_tree(['a/', 'b/'])
1914
2468
        mover = _FileMover()
1915
2469
        mover.pre_delete('a', 'q')
1916
2470
        mover.pre_delete('b', 'r')
1917
 
        self.failUnlessExists('q')
1918
 
        self.failUnlessExists('r')
1919
 
        self.failIfExists('a')
1920
 
        self.failIfExists('b')
 
2471
        self.assertPathExists('q')
 
2472
        self.assertPathExists('r')
 
2473
        self.assertPathDoesNotExist('a')
 
2474
        self.assertPathDoesNotExist('b')
1921
2475
        mover.apply_deletions()
1922
 
        self.failIfExists('q')
1923
 
        self.failIfExists('r')
1924
 
        self.failIfExists('a')
1925
 
        self.failIfExists('b')
 
2476
        self.assertPathDoesNotExist('q')
 
2477
        self.assertPathDoesNotExist('r')
 
2478
        self.assertPathDoesNotExist('a')
 
2479
        self.assertPathDoesNotExist('b')
1926
2480
 
1927
2481
    def test_file_mover_rollback(self):
1928
2482
        self.build_tree(['a/', 'a/b', 'c/', 'c/d/', 'c/e/'])
1933
2487
            mover.rename('a', 'c')
1934
2488
        except errors.FileExists, e:
1935
2489
            mover.rollback()
1936
 
        self.failUnlessExists('a')
1937
 
        self.failUnlessExists('c/d')
 
2490
        self.assertPathExists('a')
 
2491
        self.assertPathExists('c/d')
1938
2492
 
1939
2493
 
1940
2494
class Bogus(Exception):
1970
2524
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
1971
2525
        self.assertRaises(Bogus, tt.apply,
1972
2526
                          _mover=self.ExceptionFileMover(bad_source='a'))
1973
 
        self.failUnlessExists('a')
1974
 
        self.failUnlessExists('a/b')
 
2527
        self.assertPathExists('a')
 
2528
        self.assertPathExists('a/b')
1975
2529
        tt.apply()
1976
 
        self.failUnlessExists('c')
1977
 
        self.failUnlessExists('c/d')
 
2530
        self.assertPathExists('c')
 
2531
        self.assertPathExists('c/d')
1978
2532
 
1979
2533
    def test_rollback_rename_into_place(self):
1980
2534
        tree = self.make_branch_and_tree('.')
1986
2540
        tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
1987
2541
        self.assertRaises(Bogus, tt.apply,
1988
2542
                          _mover=self.ExceptionFileMover(bad_target='c/d'))
1989
 
        self.failUnlessExists('a')
1990
 
        self.failUnlessExists('a/b')
 
2543
        self.assertPathExists('a')
 
2544
        self.assertPathExists('a/b')
1991
2545
        tt.apply()
1992
 
        self.failUnlessExists('c')
1993
 
        self.failUnlessExists('c/d')
 
2546
        self.assertPathExists('c')
 
2547
        self.assertPathExists('c/d')
1994
2548
 
1995
2549
    def test_rollback_deletion(self):
1996
2550
        tree = self.make_branch_and_tree('.')
2002
2556
        tt.adjust_path('d', tt.root, tt.trans_id_tree_path('a/b'))
2003
2557
        self.assertRaises(Bogus, tt.apply,
2004
2558
                          _mover=self.ExceptionFileMover(bad_target='d'))
2005
 
        self.failUnlessExists('a')
2006
 
        self.failUnlessExists('a/b')
2007
 
 
2008
 
    def test_resolve_no_parent(self):
 
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):
2009
2690
        wt = self.make_branch_and_tree('.')
 
2691
        self.build_tree(['dir/',])
 
2692
        wt.add(['dir'], ['dir-id'])
 
2693
        wt.commit('Create dir')
2010
2694
        tt = TreeTransform(wt)
2011
2695
        self.addCleanup(tt.finalize)
2012
 
        parent = tt.trans_id_file_id('parent-id')
2013
 
        tt.new_file('file', parent, 'Contents')
2014
 
        resolve_conflicts(tt)
 
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())
2015
2720
 
2016
2721
 
2017
2722
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
2018
2723
                  ('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2019
2724
                  (False, False))
2020
2725
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
2021
 
              ('', ''), ('directory', 'directory'), (False, None))
 
2726
              ('', ''), ('directory', 'directory'), (False, False))
2022
2727
 
2023
2728
 
2024
2729
class TestTransformPreview(tests.TestCaseWithTransport):
2026
2731
    def create_tree(self):
2027
2732
        tree = self.make_branch_and_tree('.')
2028
2733
        self.build_tree_contents([('a', 'content 1')])
 
2734
        tree.set_root_id('TREE_ROOT')
2029
2735
        tree.add('a', 'a-id')
2030
2736
        tree.commit('rev1', rev_id='rev1')
2031
2737
        return tree.branch.repository.revision_tree('rev1')
2110
2816
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2111
2817
        changes = preview_tree.iter_changes(revision_tree,
2112
2818
                                            specific_files=[''])
2113
 
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
 
2819
        self.assertEqual([A_ENTRY], list(changes))
2114
2820
 
2115
2821
    def test_want_unversioned(self):
2116
2822
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2117
2823
        changes = preview_tree.iter_changes(revision_tree,
2118
2824
                                            want_unversioned=True)
2119
 
        self.assertEqual([ROOT_ENTRY, A_ENTRY], list(changes))
 
2825
        self.assertEqual([A_ENTRY], list(changes))
2120
2826
 
2121
2827
    def test_ignore_extra_trees_no_specific_files(self):
2122
2828
        # extra_trees is harmless without specific_files, so we'll silently
2132
2838
    def test_ignore_pb(self):
2133
2839
        # pb could be supported, but TT.iter_changes doesn't support it.
2134
2840
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2135
 
        preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
 
2841
        preview_tree.iter_changes(revision_tree)
2136
2842
 
2137
2843
    def test_kind(self):
2138
2844
        revision_tree = self.create_tree()
2153
2859
        self.assertEqual(os.stat(limbo_path).st_mtime,
2154
2860
                         preview_tree.get_file_mtime('file-id'))
2155
2861
 
 
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
 
2156
2886
    def test_get_file(self):
2157
2887
        preview = self.get_empty_preview()
2158
2888
        preview.new_file('file', preview.root, 'contents', 'file-id')
2306
3036
        self.assertEqual(('missing', None, None, None), summary)
2307
3037
 
2308
3038
    def test_file_content_summary_executable(self):
2309
 
        if not osutils.supports_executable():
2310
 
            raise TestNotApplicable()
2311
3039
        preview = self.get_empty_preview()
2312
3040
        path_id = preview.new_file('path', preview.root, 'contents', 'path-id')
2313
3041
        preview.set_executability(True, path_id)
2322
3050
        self.assertIs(None, summary[3])
2323
3051
 
2324
3052
    def test_change_executability(self):
2325
 
        if not osutils.supports_executable():
2326
 
            raise TestNotApplicable()
2327
3053
        tree = self.make_branch_and_tree('tree')
2328
3054
        self.build_tree(['tree/path'])
2329
3055
        tree.add('path')
2343
3069
        # size must be known
2344
3070
        self.assertEqual(len('contents'), summary[1])
2345
3071
        # not executable
2346
 
        if osutils.supports_executable():
2347
 
            self.assertEqual(False, summary[2])
2348
 
        else:
2349
 
            self.assertEqual(None, summary[2])
 
3072
        self.assertEqual(False, summary[2])
2350
3073
        # will not have hash (not cheap to determine)
2351
3074
        self.assertIs(None, summary[3])
2352
3075
 
2493
3216
 
2494
3217
    def test_walkdirs(self):
2495
3218
        preview = self.get_empty_preview()
2496
 
        preview.version_file('tree-root', preview.root)
 
3219
        root = preview.new_directory('', ROOT_PARENT, 'tree-root')
 
3220
        # FIXME: new_directory should mark root.
 
3221
        preview.fixup_new_roots()
2497
3222
        preview_tree = preview.get_preview_tree()
2498
3223
        file_trans_id = preview.new_file('a', preview.root, 'contents',
2499
3224
                                         'a-id')
2530
3255
        self.addCleanup(work_tree.unlock)
2531
3256
        preview = TransformPreview(work_tree)
2532
3257
        self.addCleanup(preview.finalize)
2533
 
        preview_tree = preview.get_preview_tree()
2534
3258
        file_trans_id = preview.trans_id_file_id('file-id')
2535
3259
        preview.delete_contents(file_trans_id)
2536
3260
        preview.create_file('a\nb\n', file_trans_id)
2537
 
        pb = progress.DummyProgress()
2538
 
        merger = Merger.from_revision_ids(pb, preview_tree,
 
3261
        preview_tree = preview.get_preview_tree()
 
3262
        merger = Merger.from_revision_ids(None, preview_tree,
2539
3263
                                          child_tree.branch.last_revision(),
2540
3264
                                          other_branch=child_tree.branch,
2541
3265
                                          tree_branch=work_tree.branch)
2547
3271
 
2548
3272
    def test_merge_preview_into_workingtree(self):
2549
3273
        tree = self.make_branch_and_tree('tree')
 
3274
        tree.set_root_id('TREE_ROOT')
2550
3275
        tt = TransformPreview(tree)
2551
3276
        self.addCleanup(tt.finalize)
2552
3277
        tt.new_file('name', tt.root, 'content', 'file-id')
2553
3278
        tree2 = self.make_branch_and_tree('tree2')
2554
 
        pb = progress.DummyProgress()
 
3279
        tree2.set_root_id('TREE_ROOT')
2555
3280
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
2556
 
                                         pb, tree.basis_tree())
 
3281
                                         None, tree.basis_tree())
2557
3282
        merger.merge_type = Merge3Merger
2558
3283
        merger.do_merge()
2559
3284
 
2569
3294
        tt.create_file('baz', trans_id)
2570
3295
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
2571
3296
        self.build_tree_contents([('tree2/foo', 'qux')])
2572
 
        pb = progress.DummyProgress()
 
3297
        pb = None
2573
3298
        merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
2574
3299
                                         pb, tree.basis_tree())
2575
3300
        merger.merge_type = Merge3Merger
2576
3301
        merger.do_merge()
2577
3302
 
 
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
 
2578
3321
    def test_is_executable(self):
2579
3322
        tree = self.make_branch_and_tree('tree')
2580
3323
        preview = TransformPreview(tree)
2585
3328
                                                           'tree/foo'))
2586
3329
        self.assertEqual(False, preview_tree.is_executable('baz-id'))
2587
3330
 
 
3331
    def test_commit_preview_tree(self):
 
3332
        tree = self.make_branch_and_tree('tree')
 
3333
        rev_id = tree.commit('rev1')
 
3334
        tree.branch.lock_write()
 
3335
        self.addCleanup(tree.branch.unlock)
 
3336
        tt = TransformPreview(tree)
 
3337
        tt.new_file('file', tt.root, 'contents', 'file_id')
 
3338
        self.addCleanup(tt.finalize)
 
3339
        preview = tt.get_preview_tree()
 
3340
        preview.set_parent_ids([rev_id])
 
3341
        builder = tree.branch.get_commit_builder([rev_id])
 
3342
        list(builder.record_iter_changes(preview, rev_id, tt.iter_changes()))
 
3343
        builder.finish_inventory()
 
3344
        rev2_id = builder.commit('rev2')
 
3345
        rev2_tree = tree.branch.repository.revision_tree(rev2_id)
 
3346
        self.assertEqual('contents', rev2_tree.get_file_text('file_id'))
 
3347
 
 
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
 
2588
3359
 
2589
3360
class FakeSerializer(object):
2590
3361
    """Serializer implementation that simply returns the input.
2598
3369
 
2599
3370
class TestSerializeTransform(tests.TestCaseWithTransport):
2600
3371
 
2601
 
    _test_needs_features = [tests.UnicodeFilenameFeature]
 
3372
    _test_needs_features = [features.UnicodeFilenameFeature]
2602
3373
 
2603
3374
    def get_preview(self, tree=None):
2604
3375
        if tree is None:
2679
3450
        return self.make_records(attribs, contents)
2680
3451
 
2681
3452
    def test_serialize_symlink_creation(self):
2682
 
        self.requireFeature(tests.SymlinkFeature)
 
3453
        self.requireFeature(features.SymlinkFeature)
2683
3454
        tt = self.get_preview()
2684
3455
        tt.new_symlink(u'foo\u1234', tt.root, u'bar\u1234')
2685
3456
        self.assertSerializesTo(self.symlink_creation_records(), tt)
2686
3457
 
2687
3458
    def test_deserialize_symlink_creation(self):
 
3459
        self.requireFeature(features.SymlinkFeature)
2688
3460
        tt = self.get_preview()
2689
3461
        tt.deserialize(iter(self.symlink_creation_records()))
2690
 
        # XXX readlink should be returning unicode, not utf-8
2691
 
        foo_content = os.readlink(tt._limbo_name('new-1')).decode('utf-8')
 
3462
        abspath = tt._limbo_name('new-1')
 
3463
        foo_content = osutils.readlink(abspath)
2692
3464
        self.assertEqual(u'bar\u1234', foo_content)
2693
3465
 
2694
3466
    def make_destruction_preview(self):
2857
3629
        trans_id = tt.trans_id_tree_path('file')
2858
3630
        self.assertEqual((LINES_ONE,),
2859
3631
            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')