1
# Copyright (C) 2006 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
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
19
from StringIO import StringIO
27
revision as _mod_revision,
32
from bzrlib.bzrdir import BzrDir
33
from bzrlib.conflicts import (DuplicateEntry, DuplicateID, MissingParent,
34
UnversionedParent, ParentLoop, DeletingParent,
36
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
43
from bzrlib.merge import Merge3Merger
44
from bzrlib.tests import (
45
CaseInsensitiveFilesystemFeature,
52
from bzrlib.transform import (TreeTransform, ROOT_PARENT, FinalPaths,
53
resolve_conflicts, cook_conflicts,
54
build_tree, get_backup_name,
55
_FileMover, resolve_checkout,
58
class TestTreeTransform(tests.TestCaseWithTransport):
61
super(TestTreeTransform, self).setUp()
62
self.wt = self.make_branch_and_tree('.', format='dirstate-with-subtree')
65
def get_transform(self):
66
transform = TreeTransform(self.wt)
67
#self.addCleanup(transform.finalize)
68
return transform, transform.root
70
def test_existing_limbo(self):
71
transform, root = self.get_transform()
72
limbo_name = transform._limbodir
73
deletion_path = transform._deletiondir
74
os.mkdir(pathjoin(limbo_name, 'hehe'))
75
self.assertRaises(ImmortalLimbo, transform.apply)
76
self.assertRaises(LockError, self.wt.unlock)
77
self.assertRaises(ExistingLimbo, self.get_transform)
78
self.assertRaises(LockError, self.wt.unlock)
79
os.rmdir(pathjoin(limbo_name, 'hehe'))
81
os.rmdir(deletion_path)
82
transform, root = self.get_transform()
85
def test_existing_pending_deletion(self):
86
transform, root = self.get_transform()
87
deletion_path = self._limbodir = urlutils.local_path_from_url(
88
transform._tree._transport.abspath('pending-deletion'))
89
os.mkdir(pathjoin(deletion_path, 'blocking-directory'))
90
self.assertRaises(ImmortalPendingDeletion, transform.apply)
91
self.assertRaises(LockError, self.wt.unlock)
92
self.assertRaises(ExistingPendingDeletion, self.get_transform)
95
transform, root = self.get_transform()
96
self.wt.lock_tree_write()
97
self.addCleanup(self.wt.unlock)
98
self.assertIs(transform.get_tree_parent(root), ROOT_PARENT)
99
imaginary_id = transform.trans_id_tree_path('imaginary')
100
imaginary_id2 = transform.trans_id_tree_path('imaginary/')
101
self.assertEqual(imaginary_id, imaginary_id2)
102
self.assertEqual(transform.get_tree_parent(imaginary_id), root)
103
self.assertEqual(transform.final_kind(root), 'directory')
104
self.assertEqual(transform.final_file_id(root), self.wt.get_root_id())
105
trans_id = transform.create_path('name', root)
106
self.assertIs(transform.final_file_id(trans_id), None)
107
self.assertRaises(NoSuchFile, transform.final_kind, trans_id)
108
transform.create_file('contents', trans_id)
109
transform.set_executability(True, trans_id)
110
transform.version_file('my_pretties', trans_id)
111
self.assertRaises(DuplicateKey, transform.version_file,
112
'my_pretties', trans_id)
113
self.assertEqual(transform.final_file_id(trans_id), 'my_pretties')
114
self.assertEqual(transform.final_parent(trans_id), root)
115
self.assertIs(transform.final_parent(root), ROOT_PARENT)
116
self.assertIs(transform.get_tree_parent(root), ROOT_PARENT)
117
oz_id = transform.create_path('oz', root)
118
transform.create_directory(oz_id)
119
transform.version_file('ozzie', oz_id)
120
trans_id2 = transform.create_path('name2', root)
121
transform.create_file('contents', trans_id2)
122
transform.set_executability(False, trans_id2)
123
transform.version_file('my_pretties2', trans_id2)
124
modified_paths = transform.apply().modified_paths
125
self.assertEqual('contents', self.wt.get_file_byname('name').read())
126
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
127
self.assertIs(self.wt.is_executable('my_pretties'), True)
128
self.assertIs(self.wt.is_executable('my_pretties2'), False)
129
self.assertEqual('directory', file_kind(self.wt.abspath('oz')))
130
self.assertEqual(len(modified_paths), 3)
131
tree_mod_paths = [self.wt.id2abspath(f) for f in
132
('ozzie', 'my_pretties', 'my_pretties2')]
133
self.assertSubset(tree_mod_paths, modified_paths)
134
# is it safe to finalize repeatedly?
138
def test_hardlink(self):
139
self.requireFeature(HardlinkFeature)
140
transform, root = self.get_transform()
141
transform.new_file('file1', root, 'contents')
143
target = self.make_branch_and_tree('target')
144
target_transform = TreeTransform(target)
145
trans_id = target_transform.create_path('file1', target_transform.root)
146
target_transform.create_hardlink(self.wt.abspath('file1'), trans_id)
147
target_transform.apply()
148
self.failUnlessExists('target/file1')
149
source_stat = os.stat(self.wt.abspath('file1'))
150
target_stat = os.stat('target/file1')
151
self.assertEqual(source_stat, target_stat)
153
def test_convenience(self):
154
transform, root = self.get_transform()
155
self.wt.lock_tree_write()
156
self.addCleanup(self.wt.unlock)
157
trans_id = transform.new_file('name', root, 'contents',
159
oz = transform.new_directory('oz', root, 'oz-id')
160
dorothy = transform.new_directory('dorothy', oz, 'dorothy-id')
161
toto = transform.new_file('toto', dorothy, 'toto-contents',
164
self.assertEqual(len(transform.find_conflicts()), 0)
166
self.assertRaises(ReusingTransform, transform.find_conflicts)
167
self.assertEqual('contents', file(self.wt.abspath('name')).read())
168
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
169
self.assertIs(self.wt.is_executable('my_pretties'), True)
170
self.assertEqual(self.wt.path2id('oz'), 'oz-id')
171
self.assertEqual(self.wt.path2id('oz/dorothy'), 'dorothy-id')
172
self.assertEqual(self.wt.path2id('oz/dorothy/toto'), 'toto-id')
174
self.assertEqual('toto-contents',
175
self.wt.get_file_byname('oz/dorothy/toto').read())
176
self.assertIs(self.wt.is_executable('toto-id'), False)
178
def test_tree_reference(self):
179
transform, root = self.get_transform()
180
tree = transform._tree
181
trans_id = transform.new_directory('reference', root, 'subtree-id')
182
transform.set_tree_reference('subtree-revision', trans_id)
185
self.addCleanup(tree.unlock)
186
self.assertEqual('subtree-revision',
187
tree.inventory['subtree-id'].reference_revision)
189
def test_conflicts(self):
190
transform, root = self.get_transform()
191
trans_id = transform.new_file('name', root, 'contents',
193
self.assertEqual(len(transform.find_conflicts()), 0)
194
trans_id2 = transform.new_file('name', root, 'Crontents', 'toto')
195
self.assertEqual(transform.find_conflicts(),
196
[('duplicate', trans_id, trans_id2, 'name')])
197
self.assertRaises(MalformedTransform, transform.apply)
198
transform.adjust_path('name', trans_id, trans_id2)
199
self.assertEqual(transform.find_conflicts(),
200
[('non-directory parent', trans_id)])
201
tinman_id = transform.trans_id_tree_path('tinman')
202
transform.adjust_path('name', tinman_id, trans_id2)
203
self.assertEqual(transform.find_conflicts(),
204
[('unversioned parent', tinman_id),
205
('missing parent', tinman_id)])
206
lion_id = transform.create_path('lion', root)
207
self.assertEqual(transform.find_conflicts(),
208
[('unversioned parent', tinman_id),
209
('missing parent', tinman_id)])
210
transform.adjust_path('name', lion_id, trans_id2)
211
self.assertEqual(transform.find_conflicts(),
212
[('unversioned parent', lion_id),
213
('missing parent', lion_id)])
214
transform.version_file("Courage", lion_id)
215
self.assertEqual(transform.find_conflicts(),
216
[('missing parent', lion_id),
217
('versioning no contents', lion_id)])
218
transform.adjust_path('name2', root, trans_id2)
219
self.assertEqual(transform.find_conflicts(),
220
[('versioning no contents', lion_id)])
221
transform.create_file('Contents, okay?', lion_id)
222
transform.adjust_path('name2', trans_id2, trans_id2)
223
self.assertEqual(transform.find_conflicts(),
224
[('parent loop', trans_id2),
225
('non-directory parent', trans_id2)])
226
transform.adjust_path('name2', root, trans_id2)
227
oz_id = transform.new_directory('oz', root)
228
transform.set_executability(True, oz_id)
229
self.assertEqual(transform.find_conflicts(),
230
[('unversioned executability', oz_id)])
231
transform.version_file('oz-id', oz_id)
232
self.assertEqual(transform.find_conflicts(),
233
[('non-file executability', oz_id)])
234
transform.set_executability(None, oz_id)
235
tip_id = transform.new_file('tip', oz_id, 'ozma', 'tip-id')
237
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
238
self.assertEqual('contents', file(self.wt.abspath('name')).read())
239
transform2, root = self.get_transform()
240
oz_id = transform2.trans_id_tree_file_id('oz-id')
241
newtip = transform2.new_file('tip', oz_id, 'other', 'tip-id')
242
result = transform2.find_conflicts()
243
fp = FinalPaths(transform2)
244
self.assert_('oz/tip' in transform2._tree_path_ids)
245
self.assertEqual(fp.get_path(newtip), pathjoin('oz', 'tip'))
246
self.assertEqual(len(result), 2)
247
self.assertEqual((result[0][0], result[0][1]),
248
('duplicate', newtip))
249
self.assertEqual((result[1][0], result[1][2]),
250
('duplicate id', newtip))
251
transform2.finalize()
252
transform3 = TreeTransform(self.wt)
253
self.addCleanup(transform3.finalize)
254
oz_id = transform3.trans_id_tree_file_id('oz-id')
255
transform3.delete_contents(oz_id)
256
self.assertEqual(transform3.find_conflicts(),
257
[('missing parent', oz_id)])
258
root_id = transform3.root
259
tip_id = transform3.trans_id_tree_file_id('tip-id')
260
transform3.adjust_path('tip', root_id, tip_id)
263
def test_conflict_on_case_insensitive(self):
264
tree = self.make_branch_and_tree('tree')
265
# Don't try this at home, kids!
266
# Force the tree to report that it is case sensitive, for conflict
268
tree.case_sensitive = True
269
transform = TreeTransform(tree)
270
self.addCleanup(transform.finalize)
271
transform.new_file('file', transform.root, 'content')
272
transform.new_file('FiLe', transform.root, 'content')
273
result = transform.find_conflicts()
274
self.assertEqual([], result)
276
# Force the tree to report that it is case insensitive, for conflict
278
tree.case_sensitive = False
279
transform = TreeTransform(tree)
280
self.addCleanup(transform.finalize)
281
transform.new_file('file', transform.root, 'content')
282
transform.new_file('FiLe', transform.root, 'content')
283
result = transform.find_conflicts()
284
self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
286
def test_conflict_on_case_insensitive_existing(self):
287
tree = self.make_branch_and_tree('tree')
288
self.build_tree(['tree/FiLe'])
289
# Don't try this at home, kids!
290
# Force the tree to report that it is case sensitive, for conflict
292
tree.case_sensitive = True
293
transform = TreeTransform(tree)
294
self.addCleanup(transform.finalize)
295
transform.new_file('file', transform.root, 'content')
296
result = transform.find_conflicts()
297
self.assertEqual([], result)
299
# Force the tree to report that it is case insensitive, for conflict
301
tree.case_sensitive = False
302
transform = TreeTransform(tree)
303
self.addCleanup(transform.finalize)
304
transform.new_file('file', transform.root, 'content')
305
result = transform.find_conflicts()
306
self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
308
def test_resolve_case_insensitive_conflict(self):
309
tree = self.make_branch_and_tree('tree')
310
# Don't try this at home, kids!
311
# Force the tree to report that it is case insensitive, for conflict
313
tree.case_sensitive = False
314
transform = TreeTransform(tree)
315
self.addCleanup(transform.finalize)
316
transform.new_file('file', transform.root, 'content')
317
transform.new_file('FiLe', transform.root, 'content')
318
resolve_conflicts(transform)
320
self.failUnlessExists('tree/file')
321
self.failUnlessExists('tree/FiLe.moved')
323
def test_resolve_checkout_case_conflict(self):
324
tree = self.make_branch_and_tree('tree')
325
# Don't try this at home, kids!
326
# Force the tree to report that it is case insensitive, for conflict
328
tree.case_sensitive = False
329
transform = TreeTransform(tree)
330
self.addCleanup(transform.finalize)
331
transform.new_file('file', transform.root, 'content')
332
transform.new_file('FiLe', transform.root, 'content')
333
resolve_conflicts(transform,
334
pass_func=lambda t, c: resolve_checkout(t, c, []))
336
self.failUnlessExists('tree/file')
337
self.failUnlessExists('tree/FiLe.moved')
339
def test_apply_case_conflict(self):
340
"""Ensure that a transform with case conflicts can always be applied"""
341
tree = self.make_branch_and_tree('tree')
342
transform = TreeTransform(tree)
343
self.addCleanup(transform.finalize)
344
transform.new_file('file', transform.root, 'content')
345
transform.new_file('FiLe', transform.root, 'content')
346
dir = transform.new_directory('dir', transform.root)
347
transform.new_file('dirfile', dir, 'content')
348
transform.new_file('dirFiLe', dir, 'content')
349
resolve_conflicts(transform)
351
self.failUnlessExists('tree/file')
352
if not os.path.exists('tree/FiLe.moved'):
353
self.failUnlessExists('tree/FiLe')
354
self.failUnlessExists('tree/dir/dirfile')
355
if not os.path.exists('tree/dir/dirFiLe.moved'):
356
self.failUnlessExists('tree/dir/dirFiLe')
358
def test_case_insensitive_limbo(self):
359
tree = self.make_branch_and_tree('tree')
360
# Don't try this at home, kids!
361
# Force the tree to report that it is case insensitive
362
tree.case_sensitive = False
363
transform = TreeTransform(tree)
364
self.addCleanup(transform.finalize)
365
dir = transform.new_directory('dir', transform.root)
366
first = transform.new_file('file', dir, 'content')
367
second = transform.new_file('FiLe', dir, 'content')
368
self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
369
self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
371
def test_add_del(self):
372
start, root = self.get_transform()
373
start.new_directory('a', root, 'a')
375
transform, root = self.get_transform()
376
transform.delete_versioned(transform.trans_id_tree_file_id('a'))
377
transform.new_directory('a', root, 'a')
380
def test_unversioning(self):
381
create_tree, root = self.get_transform()
382
parent_id = create_tree.new_directory('parent', root, 'parent-id')
383
create_tree.new_file('child', parent_id, 'child', 'child-id')
385
unversion = TreeTransform(self.wt)
386
self.addCleanup(unversion.finalize)
387
parent = unversion.trans_id_tree_path('parent')
388
unversion.unversion_file(parent)
389
self.assertEqual(unversion.find_conflicts(),
390
[('unversioned parent', parent_id)])
391
file_id = unversion.trans_id_tree_file_id('child-id')
392
unversion.unversion_file(file_id)
395
def test_name_invariants(self):
396
create_tree, root = self.get_transform()
398
root = create_tree.root
399
create_tree.new_file('name1', root, 'hello1', 'name1')
400
create_tree.new_file('name2', root, 'hello2', 'name2')
401
ddir = create_tree.new_directory('dying_directory', root, 'ddir')
402
create_tree.new_file('dying_file', ddir, 'goodbye1', 'dfile')
403
create_tree.new_file('moving_file', ddir, 'later1', 'mfile')
404
create_tree.new_file('moving_file2', root, 'later2', 'mfile2')
407
mangle_tree,root = self.get_transform()
408
root = mangle_tree.root
410
name1 = mangle_tree.trans_id_tree_file_id('name1')
411
name2 = mangle_tree.trans_id_tree_file_id('name2')
412
mangle_tree.adjust_path('name2', root, name1)
413
mangle_tree.adjust_path('name1', root, name2)
415
#tests for deleting parent directories
416
ddir = mangle_tree.trans_id_tree_file_id('ddir')
417
mangle_tree.delete_contents(ddir)
418
dfile = mangle_tree.trans_id_tree_file_id('dfile')
419
mangle_tree.delete_versioned(dfile)
420
mangle_tree.unversion_file(dfile)
421
mfile = mangle_tree.trans_id_tree_file_id('mfile')
422
mangle_tree.adjust_path('mfile', root, mfile)
424
#tests for adding parent directories
425
newdir = mangle_tree.new_directory('new_directory', root, 'newdir')
426
mfile2 = mangle_tree.trans_id_tree_file_id('mfile2')
427
mangle_tree.adjust_path('mfile2', newdir, mfile2)
428
mangle_tree.new_file('newfile', newdir, 'hello3', 'dfile')
429
self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
430
self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
431
self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
433
self.assertEqual(file(self.wt.abspath('name1')).read(), 'hello2')
434
self.assertEqual(file(self.wt.abspath('name2')).read(), 'hello1')
435
mfile2_path = self.wt.abspath(pathjoin('new_directory','mfile2'))
436
self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
437
self.assertEqual(file(mfile2_path).read(), 'later2')
438
self.assertEqual(self.wt.id2path('mfile2'), 'new_directory/mfile2')
439
self.assertEqual(self.wt.path2id('new_directory/mfile2'), 'mfile2')
440
newfile_path = self.wt.abspath(pathjoin('new_directory','newfile'))
441
self.assertEqual(file(newfile_path).read(), 'hello3')
442
self.assertEqual(self.wt.path2id('dying_directory'), 'ddir')
443
self.assertIs(self.wt.path2id('dying_directory/dying_file'), None)
444
mfile2_path = self.wt.abspath(pathjoin('new_directory','mfile2'))
446
def test_both_rename(self):
447
create_tree,root = self.get_transform()
448
newdir = create_tree.new_directory('selftest', root, 'selftest-id')
449
create_tree.new_file('blackbox.py', newdir, 'hello1', 'blackbox-id')
451
mangle_tree,root = self.get_transform()
452
selftest = mangle_tree.trans_id_tree_file_id('selftest-id')
453
blackbox = mangle_tree.trans_id_tree_file_id('blackbox-id')
454
mangle_tree.adjust_path('test', root, selftest)
455
mangle_tree.adjust_path('test_too_much', root, selftest)
456
mangle_tree.set_executability(True, blackbox)
459
def test_both_rename2(self):
460
create_tree,root = self.get_transform()
461
bzrlib = create_tree.new_directory('bzrlib', root, 'bzrlib-id')
462
tests = create_tree.new_directory('tests', bzrlib, 'tests-id')
463
blackbox = create_tree.new_directory('blackbox', tests, 'blackbox-id')
464
create_tree.new_file('test_too_much.py', blackbox, 'hello1',
467
mangle_tree,root = self.get_transform()
468
bzrlib = mangle_tree.trans_id_tree_file_id('bzrlib-id')
469
tests = mangle_tree.trans_id_tree_file_id('tests-id')
470
test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
471
mangle_tree.adjust_path('selftest', bzrlib, tests)
472
mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
473
mangle_tree.set_executability(True, test_too_much)
476
def test_both_rename3(self):
477
create_tree,root = self.get_transform()
478
tests = create_tree.new_directory('tests', root, 'tests-id')
479
create_tree.new_file('test_too_much.py', tests, 'hello1',
482
mangle_tree,root = self.get_transform()
483
tests = mangle_tree.trans_id_tree_file_id('tests-id')
484
test_too_much = mangle_tree.trans_id_tree_file_id('test_too_much-id')
485
mangle_tree.adjust_path('selftest', root, tests)
486
mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
487
mangle_tree.set_executability(True, test_too_much)
490
def test_move_dangling_ie(self):
491
create_tree, root = self.get_transform()
493
root = create_tree.root
494
create_tree.new_file('name1', root, 'hello1', 'name1')
496
delete_contents, root = self.get_transform()
497
file = delete_contents.trans_id_tree_file_id('name1')
498
delete_contents.delete_contents(file)
499
delete_contents.apply()
500
move_id, root = self.get_transform()
501
name1 = move_id.trans_id_tree_file_id('name1')
502
newdir = move_id.new_directory('dir', root, 'newdir')
503
move_id.adjust_path('name2', newdir, name1)
506
def test_replace_dangling_ie(self):
507
create_tree, root = self.get_transform()
509
root = create_tree.root
510
create_tree.new_file('name1', root, 'hello1', 'name1')
512
delete_contents = TreeTransform(self.wt)
513
self.addCleanup(delete_contents.finalize)
514
file = delete_contents.trans_id_tree_file_id('name1')
515
delete_contents.delete_contents(file)
516
delete_contents.apply()
517
delete_contents.finalize()
518
replace = TreeTransform(self.wt)
519
self.addCleanup(replace.finalize)
520
name2 = replace.new_file('name2', root, 'hello2', 'name1')
521
conflicts = replace.find_conflicts()
522
name1 = replace.trans_id_tree_file_id('name1')
523
self.assertEqual(conflicts, [('duplicate id', name1, name2)])
524
resolve_conflicts(replace)
527
def test_symlinks(self):
528
self.requireFeature(SymlinkFeature)
529
transform,root = self.get_transform()
530
oz_id = transform.new_directory('oz', root, 'oz-id')
531
wizard = transform.new_symlink('wizard', oz_id, 'wizard-target',
533
wiz_id = transform.create_path('wizard2', oz_id)
534
transform.create_symlink('behind_curtain', wiz_id)
535
transform.version_file('wiz-id2', wiz_id)
536
transform.set_executability(True, wiz_id)
537
self.assertEqual(transform.find_conflicts(),
538
[('non-file executability', wiz_id)])
539
transform.set_executability(None, wiz_id)
541
self.assertEqual(self.wt.path2id('oz/wizard'), 'wizard-id')
542
self.assertEqual(file_kind(self.wt.abspath('oz/wizard')), 'symlink')
543
self.assertEqual(os.readlink(self.wt.abspath('oz/wizard2')),
545
self.assertEqual(os.readlink(self.wt.abspath('oz/wizard')),
548
def test_unable_create_symlink(self):
550
wt = self.make_branch_and_tree('.')
551
tt = TreeTransform(wt) # TreeTransform obtains write lock
553
tt.new_symlink('foo', tt.root, 'bar')
557
os_symlink = getattr(os, 'symlink', None)
560
err = self.assertRaises(errors.UnableCreateSymlink, tt_helper)
562
"Unable to create symlink 'foo' on this platform",
566
os.symlink = os_symlink
568
def get_conflicted(self):
569
create,root = self.get_transform()
570
create.new_file('dorothy', root, 'dorothy', 'dorothy-id')
571
oz = create.new_directory('oz', root, 'oz-id')
572
create.new_directory('emeraldcity', oz, 'emerald-id')
574
conflicts,root = self.get_transform()
575
# set up duplicate entry, duplicate id
576
new_dorothy = conflicts.new_file('dorothy', root, 'dorothy',
578
old_dorothy = conflicts.trans_id_tree_file_id('dorothy-id')
579
oz = conflicts.trans_id_tree_file_id('oz-id')
580
# set up DeletedParent parent conflict
581
conflicts.delete_versioned(oz)
582
emerald = conflicts.trans_id_tree_file_id('emerald-id')
583
# set up MissingParent conflict
584
munchkincity = conflicts.trans_id_file_id('munchkincity-id')
585
conflicts.adjust_path('munchkincity', root, munchkincity)
586
conflicts.new_directory('auntem', munchkincity, 'auntem-id')
588
conflicts.adjust_path('emeraldcity', emerald, emerald)
589
return conflicts, emerald, oz, old_dorothy, new_dorothy
591
def test_conflict_resolution(self):
592
conflicts, emerald, oz, old_dorothy, new_dorothy =\
593
self.get_conflicted()
594
resolve_conflicts(conflicts)
595
self.assertEqual(conflicts.final_name(old_dorothy), 'dorothy.moved')
596
self.assertIs(conflicts.final_file_id(old_dorothy), None)
597
self.assertEqual(conflicts.final_name(new_dorothy), 'dorothy')
598
self.assertEqual(conflicts.final_file_id(new_dorothy), 'dorothy-id')
599
self.assertEqual(conflicts.final_parent(emerald), oz)
602
def test_cook_conflicts(self):
603
tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
604
raw_conflicts = resolve_conflicts(tt)
605
cooked_conflicts = cook_conflicts(raw_conflicts, tt)
606
duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
607
'dorothy', None, 'dorothy-id')
608
self.assertEqual(cooked_conflicts[0], duplicate)
609
duplicate_id = DuplicateID('Unversioned existing file',
610
'dorothy.moved', 'dorothy', None,
612
self.assertEqual(cooked_conflicts[1], duplicate_id)
613
missing_parent = MissingParent('Created directory', 'munchkincity',
615
deleted_parent = DeletingParent('Not deleting', 'oz', 'oz-id')
616
self.assertEqual(cooked_conflicts[2], missing_parent)
617
unversioned_parent = UnversionedParent('Versioned directory',
620
unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
622
self.assertEqual(cooked_conflicts[3], unversioned_parent)
623
parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity',
624
'oz/emeraldcity', 'emerald-id', 'emerald-id')
625
self.assertEqual(cooked_conflicts[4], deleted_parent)
626
self.assertEqual(cooked_conflicts[5], unversioned_parent2)
627
self.assertEqual(cooked_conflicts[6], parent_loop)
628
self.assertEqual(len(cooked_conflicts), 7)
631
def test_string_conflicts(self):
632
tt, emerald, oz, old_dorothy, new_dorothy = self.get_conflicted()
633
raw_conflicts = resolve_conflicts(tt)
634
cooked_conflicts = cook_conflicts(raw_conflicts, tt)
636
conflicts_s = [str(c) for c in cooked_conflicts]
637
self.assertEqual(len(cooked_conflicts), len(conflicts_s))
638
self.assertEqual(conflicts_s[0], 'Conflict adding file dorothy. '
639
'Moved existing file to '
641
self.assertEqual(conflicts_s[1], 'Conflict adding id to dorothy. '
642
'Unversioned existing file '
644
self.assertEqual(conflicts_s[2], 'Conflict adding files to'
645
' munchkincity. Created directory.')
646
self.assertEqual(conflicts_s[3], 'Conflict because munchkincity is not'
647
' versioned, but has versioned'
648
' children. Versioned directory.')
649
self.assertEqualDiff(conflicts_s[4], "Conflict: can't delete oz because it"
650
" is not empty. Not deleting.")
651
self.assertEqual(conflicts_s[5], 'Conflict because oz is not'
652
' versioned, but has versioned'
653
' children. Versioned directory.')
654
self.assertEqual(conflicts_s[6], 'Conflict moving oz/emeraldcity into'
655
' oz/emeraldcity. Cancelled move.')
657
def prepare_wrong_parent_kind(self):
658
tt, root = self.get_transform()
659
tt.new_file('parent', root, 'contents', 'parent-id')
661
tt, root = self.get_transform()
662
parent_id = tt.trans_id_file_id('parent-id')
663
tt.new_file('child,', parent_id, 'contents2', 'file-id')
666
def test_find_conflicts_wrong_parent_kind(self):
667
tt = self.prepare_wrong_parent_kind()
670
def test_resolve_conflicts_wrong_existing_parent_kind(self):
671
tt = self.prepare_wrong_parent_kind()
672
raw_conflicts = resolve_conflicts(tt)
673
self.assertEqual(set([('non-directory parent', 'Created directory',
674
'new-3')]), raw_conflicts)
675
cooked_conflicts = cook_conflicts(raw_conflicts, tt)
676
self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
677
'parent-id')], cooked_conflicts)
679
self.assertEqual(None, self.wt.path2id('parent'))
680
self.assertEqual('parent-id', self.wt.path2id('parent.new'))
682
def test_resolve_conflicts_wrong_new_parent_kind(self):
683
tt, root = self.get_transform()
684
parent_id = tt.new_directory('parent', root, 'parent-id')
685
tt.new_file('child,', parent_id, 'contents2', 'file-id')
687
tt, root = self.get_transform()
688
parent_id = tt.trans_id_file_id('parent-id')
689
tt.delete_contents(parent_id)
690
tt.create_file('contents', parent_id)
691
raw_conflicts = resolve_conflicts(tt)
692
self.assertEqual(set([('non-directory parent', 'Created directory',
693
'new-3')]), raw_conflicts)
695
self.assertEqual(None, self.wt.path2id('parent'))
696
self.assertEqual('parent-id', self.wt.path2id('parent.new'))
698
def test_resolve_conflicts_wrong_parent_kind_unversioned(self):
699
tt, root = self.get_transform()
700
parent_id = tt.new_directory('parent', root)
701
tt.new_file('child,', parent_id, 'contents2')
703
tt, root = self.get_transform()
704
parent_id = tt.trans_id_tree_path('parent')
705
tt.delete_contents(parent_id)
706
tt.create_file('contents', parent_id)
707
resolve_conflicts(tt)
709
self.assertIs(None, self.wt.path2id('parent'))
710
self.assertIs(None, self.wt.path2id('parent.new'))
712
def test_moving_versioned_directories(self):
713
create, root = self.get_transform()
714
kansas = create.new_directory('kansas', root, 'kansas-id')
715
create.new_directory('house', kansas, 'house-id')
716
create.new_directory('oz', root, 'oz-id')
718
cyclone, root = self.get_transform()
719
oz = cyclone.trans_id_tree_file_id('oz-id')
720
house = cyclone.trans_id_tree_file_id('house-id')
721
cyclone.adjust_path('house', oz, house)
724
def test_moving_root(self):
725
create, root = self.get_transform()
726
fun = create.new_directory('fun', root, 'fun-id')
727
create.new_directory('sun', root, 'sun-id')
728
create.new_directory('moon', root, 'moon')
730
transform, root = self.get_transform()
731
transform.adjust_root_path('oldroot', fun)
732
new_root=transform.trans_id_tree_path('')
733
transform.version_file('new-root', new_root)
736
def test_renames(self):
737
create, root = self.get_transform()
738
old = create.new_directory('old-parent', root, 'old-id')
739
intermediate = create.new_directory('intermediate', old, 'im-id')
740
myfile = create.new_file('myfile', intermediate, 'myfile-text',
743
rename, root = self.get_transform()
744
old = rename.trans_id_file_id('old-id')
745
rename.adjust_path('new', root, old)
746
myfile = rename.trans_id_file_id('myfile-id')
747
rename.set_executability(True, myfile)
750
def test_set_executability_order(self):
751
"""Ensure that executability behaves the same, no matter what order.
753
- create file and set executability simultaneously
754
- create file and set executability afterward
755
- unsetting the executability of a file whose executability has not been
756
declared should throw an exception (this may happen when a
757
merge attempts to create a file with a duplicate ID)
759
transform, root = self.get_transform()
762
self.addCleanup(wt.unlock)
763
transform.new_file('set_on_creation', root, 'Set on creation', 'soc',
765
sac = transform.new_file('set_after_creation', root,
766
'Set after creation', 'sac')
767
transform.set_executability(True, sac)
768
uws = transform.new_file('unset_without_set', root, 'Unset badly',
770
self.assertRaises(KeyError, transform.set_executability, None, uws)
772
self.assertTrue(wt.is_executable('soc'))
773
self.assertTrue(wt.is_executable('sac'))
775
def test_preserve_mode(self):
776
"""File mode is preserved when replacing content"""
777
if sys.platform == 'win32':
778
raise TestSkipped('chmod has no effect on win32')
779
transform, root = self.get_transform()
780
transform.new_file('file1', root, 'contents', 'file1-id', True)
783
self.addCleanup(self.wt.unlock)
784
self.assertTrue(self.wt.is_executable('file1-id'))
785
transform, root = self.get_transform()
786
file1_id = transform.trans_id_tree_file_id('file1-id')
787
transform.delete_contents(file1_id)
788
transform.create_file('contents2', file1_id)
790
self.assertTrue(self.wt.is_executable('file1-id'))
792
def test__set_mode_stats_correctly(self):
793
"""_set_mode stats to determine file mode."""
794
if sys.platform == 'win32':
795
raise TestSkipped('chmod has no effect on win32')
799
def instrumented_stat(path):
800
stat_paths.append(path)
801
return real_stat(path)
803
transform, root = self.get_transform()
805
bar1_id = transform.new_file('bar', root, 'bar contents 1\n',
806
file_id='bar-id-1', executable=False)
809
transform, root = self.get_transform()
810
bar1_id = transform.trans_id_tree_path('bar')
811
bar2_id = transform.trans_id_tree_path('bar2')
813
os.stat = instrumented_stat
814
transform.create_file('bar2 contents\n', bar2_id, mode_id=bar1_id)
819
bar1_abspath = self.wt.abspath('bar')
820
self.assertEqual([bar1_abspath], stat_paths)
822
def test_iter_changes(self):
823
self.wt.set_root_id('eert_toor')
824
transform, root = self.get_transform()
825
transform.new_file('old', root, 'blah', 'id-1', True)
827
transform, root = self.get_transform()
829
self.assertEqual([], list(transform.iter_changes()))
830
old = transform.trans_id_tree_file_id('id-1')
831
transform.unversion_file(old)
832
self.assertEqual([('id-1', ('old', None), False, (True, False),
833
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
834
(True, True))], list(transform.iter_changes()))
835
transform.new_directory('new', root, 'id-1')
836
self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
837
('eert_toor', 'eert_toor'), ('old', 'new'),
838
('file', 'directory'),
839
(True, False))], list(transform.iter_changes()))
843
def test_iter_changes_new(self):
844
self.wt.set_root_id('eert_toor')
845
transform, root = self.get_transform()
846
transform.new_file('old', root, 'blah')
848
transform, root = self.get_transform()
850
old = transform.trans_id_tree_path('old')
851
transform.version_file('id-1', old)
852
self.assertEqual([('id-1', (None, 'old'), False, (False, True),
853
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
854
(False, False))], list(transform.iter_changes()))
858
def test_iter_changes_modifications(self):
859
self.wt.set_root_id('eert_toor')
860
transform, root = self.get_transform()
861
transform.new_file('old', root, 'blah', 'id-1')
862
transform.new_file('new', root, 'blah')
863
transform.new_directory('subdir', root, 'subdir-id')
865
transform, root = self.get_transform()
867
old = transform.trans_id_tree_path('old')
868
subdir = transform.trans_id_tree_file_id('subdir-id')
869
new = transform.trans_id_tree_path('new')
870
self.assertEqual([], list(transform.iter_changes()))
873
transform.delete_contents(old)
874
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
875
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', None),
876
(False, False))], list(transform.iter_changes()))
879
transform.create_file('blah', old)
880
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
881
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
882
(False, False))], list(transform.iter_changes()))
883
transform.cancel_deletion(old)
884
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
885
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
886
(False, False))], list(transform.iter_changes()))
887
transform.cancel_creation(old)
889
# move file_id to a different file
890
self.assertEqual([], list(transform.iter_changes()))
891
transform.unversion_file(old)
892
transform.version_file('id-1', new)
893
transform.adjust_path('old', root, new)
894
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
895
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
896
(False, False))], list(transform.iter_changes()))
897
transform.cancel_versioning(new)
898
transform._removed_id = set()
901
self.assertEqual([], list(transform.iter_changes()))
902
transform.set_executability(True, old)
903
self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
904
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
905
(False, True))], list(transform.iter_changes()))
906
transform.set_executability(None, old)
909
self.assertEqual([], list(transform.iter_changes()))
910
transform.adjust_path('new', root, old)
911
transform._new_parent = {}
912
self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
913
('eert_toor', 'eert_toor'), ('old', 'new'), ('file', 'file'),
914
(False, False))], list(transform.iter_changes()))
915
transform._new_name = {}
918
self.assertEqual([], list(transform.iter_changes()))
919
transform.adjust_path('new', subdir, old)
920
transform._new_name = {}
921
self.assertEqual([('id-1', ('old', 'subdir/old'), False,
922
(True, True), ('eert_toor', 'subdir-id'), ('old', 'old'),
923
('file', 'file'), (False, False))],
924
list(transform.iter_changes()))
925
transform._new_path = {}
930
def test_iter_changes_modified_bleed(self):
931
self.wt.set_root_id('eert_toor')
932
"""Modified flag should not bleed from one change to another"""
933
# unfortunately, we have no guarantee that file1 (which is modified)
934
# will be applied before file2. And if it's applied after file2, it
935
# obviously can't bleed into file2's change output. But for now, it
937
transform, root = self.get_transform()
938
transform.new_file('file1', root, 'blah', 'id-1')
939
transform.new_file('file2', root, 'blah', 'id-2')
941
transform, root = self.get_transform()
943
transform.delete_contents(transform.trans_id_file_id('id-1'))
944
transform.set_executability(True,
945
transform.trans_id_file_id('id-2'))
946
self.assertEqual([('id-1', (u'file1', u'file1'), True, (True, True),
947
('eert_toor', 'eert_toor'), ('file1', u'file1'),
948
('file', None), (False, False)),
949
('id-2', (u'file2', u'file2'), False, (True, True),
950
('eert_toor', 'eert_toor'), ('file2', u'file2'),
951
('file', 'file'), (False, True))],
952
list(transform.iter_changes()))
956
def test_iter_changes_move_missing(self):
957
"""Test moving ids with no files around"""
958
self.wt.set_root_id('toor_eert')
959
# Need two steps because versioning a non-existant file is a conflict.
960
transform, root = self.get_transform()
961
transform.new_directory('floater', root, 'floater-id')
963
transform, root = self.get_transform()
964
transform.delete_contents(transform.trans_id_tree_path('floater'))
966
transform, root = self.get_transform()
967
floater = transform.trans_id_tree_path('floater')
969
transform.adjust_path('flitter', root, floater)
970
self.assertEqual([('floater-id', ('floater', 'flitter'), False,
971
(True, True), ('toor_eert', 'toor_eert'), ('floater', 'flitter'),
972
(None, None), (False, False))], list(transform.iter_changes()))
976
def test_iter_changes_pointless(self):
977
"""Ensure that no-ops are not treated as modifications"""
978
self.wt.set_root_id('eert_toor')
979
transform, root = self.get_transform()
980
transform.new_file('old', root, 'blah', 'id-1')
981
transform.new_directory('subdir', root, 'subdir-id')
983
transform, root = self.get_transform()
985
old = transform.trans_id_tree_path('old')
986
subdir = transform.trans_id_tree_file_id('subdir-id')
987
self.assertEqual([], list(transform.iter_changes()))
988
transform.delete_contents(subdir)
989
transform.create_directory(subdir)
990
transform.set_executability(False, old)
991
transform.unversion_file(old)
992
transform.version_file('id-1', old)
993
transform.adjust_path('old', root, old)
994
self.assertEqual([], list(transform.iter_changes()))
998
def test_rename_count(self):
999
transform, root = self.get_transform()
1000
transform.new_file('name1', root, 'contents')
1001
self.assertEqual(transform.rename_count, 0)
1003
self.assertEqual(transform.rename_count, 1)
1004
transform2, root = self.get_transform()
1005
transform2.adjust_path('name2', root,
1006
transform2.trans_id_tree_path('name1'))
1007
self.assertEqual(transform2.rename_count, 0)
1009
self.assertEqual(transform2.rename_count, 2)
1011
def test_change_parent(self):
1012
"""Ensure that after we change a parent, the results are still right.
1014
Renames and parent changes on pending transforms can happen as part
1015
of conflict resolution, and are explicitly permitted by the
1018
This test ensures they work correctly with the rename-avoidance
1021
transform, root = self.get_transform()
1022
parent1 = transform.new_directory('parent1', root)
1023
child1 = transform.new_file('child1', parent1, 'contents')
1024
parent2 = transform.new_directory('parent2', root)
1025
transform.adjust_path('child1', parent2, child1)
1027
self.failIfExists(self.wt.abspath('parent1/child1'))
1028
self.failUnlessExists(self.wt.abspath('parent2/child1'))
1029
# rename limbo/new-1 => parent1, rename limbo/new-3 => parent2
1030
# no rename for child1 (counting only renames during apply)
1031
self.failUnlessEqual(2, transform.rename_count)
1033
def test_cancel_parent(self):
1034
"""Cancelling a parent doesn't cause deletion of a non-empty directory
1036
This is like the test_change_parent, except that we cancel the parent
1037
before adjusting the path. The transform must detect that the
1038
directory is non-empty, and move children to safe locations.
1040
transform, root = self.get_transform()
1041
parent1 = transform.new_directory('parent1', root)
1042
child1 = transform.new_file('child1', parent1, 'contents')
1043
child2 = transform.new_file('child2', parent1, 'contents')
1045
transform.cancel_creation(parent1)
1047
self.fail('Failed to move child1 before deleting parent1')
1048
transform.cancel_creation(child2)
1049
transform.create_directory(parent1)
1051
transform.cancel_creation(parent1)
1052
# If the transform incorrectly believes that child2 is still in
1053
# parent1's limbo directory, it will try to rename it and fail
1054
# because was already moved by the first cancel_creation.
1056
self.fail('Transform still thinks child2 is a child of parent1')
1057
parent2 = transform.new_directory('parent2', root)
1058
transform.adjust_path('child1', parent2, child1)
1060
self.failIfExists(self.wt.abspath('parent1'))
1061
self.failUnlessExists(self.wt.abspath('parent2/child1'))
1062
# rename limbo/new-3 => parent2, rename limbo/new-2 => child1
1063
self.failUnlessEqual(2, transform.rename_count)
1065
def test_adjust_and_cancel(self):
1066
"""Make sure adjust_path keeps track of limbo children properly"""
1067
transform, root = self.get_transform()
1068
parent1 = transform.new_directory('parent1', root)
1069
child1 = transform.new_file('child1', parent1, 'contents')
1070
parent2 = transform.new_directory('parent2', root)
1071
transform.adjust_path('child1', parent2, child1)
1072
transform.cancel_creation(child1)
1074
transform.cancel_creation(parent1)
1075
# if the transform thinks child1 is still in parent1's limbo
1076
# directory, it will attempt to move it and fail.
1078
self.fail('Transform still thinks child1 is a child of parent1')
1079
transform.finalize()
1081
def test_noname_contents(self):
1082
"""TreeTransform should permit deferring naming files."""
1083
transform, root = self.get_transform()
1084
parent = transform.trans_id_file_id('parent-id')
1086
transform.create_directory(parent)
1088
self.fail("Can't handle contents with no name")
1089
transform.finalize()
1091
def test_noname_contents_nested(self):
1092
"""TreeTransform should permit deferring naming files."""
1093
transform, root = self.get_transform()
1094
parent = transform.trans_id_file_id('parent-id')
1096
transform.create_directory(parent)
1098
self.fail("Can't handle contents with no name")
1099
child = transform.new_directory('child', parent)
1100
transform.adjust_path('parent', root, parent)
1102
self.failUnlessExists(self.wt.abspath('parent/child'))
1103
self.assertEqual(1, transform.rename_count)
1105
def test_reuse_name(self):
1106
"""Avoid reusing the same limbo name for different files"""
1107
transform, root = self.get_transform()
1108
parent = transform.new_directory('parent', root)
1109
child1 = transform.new_directory('child', parent)
1111
child2 = transform.new_directory('child', parent)
1113
self.fail('Tranform tried to use the same limbo name twice')
1114
transform.adjust_path('child2', parent, child2)
1116
# limbo/new-1 => parent, limbo/new-3 => parent/child2
1117
# child2 is put into top-level limbo because child1 has already
1118
# claimed the direct limbo path when child2 is created. There is no
1119
# advantage in renaming files once they're in top-level limbo, except
1121
self.assertEqual(2, transform.rename_count)
1123
def test_reuse_when_first_moved(self):
1124
"""Don't avoid direct paths when it is safe to use them"""
1125
transform, root = self.get_transform()
1126
parent = transform.new_directory('parent', root)
1127
child1 = transform.new_directory('child', parent)
1128
transform.adjust_path('child1', parent, child1)
1129
child2 = transform.new_directory('child', parent)
1131
# limbo/new-1 => parent
1132
self.assertEqual(1, transform.rename_count)
1134
def test_reuse_after_cancel(self):
1135
"""Don't avoid direct paths when it is safe to use them"""
1136
transform, root = self.get_transform()
1137
parent2 = transform.new_directory('parent2', root)
1138
child1 = transform.new_directory('child1', parent2)
1139
transform.cancel_creation(parent2)
1140
transform.create_directory(parent2)
1141
child2 = transform.new_directory('child1', parent2)
1142
transform.adjust_path('child2', parent2, child1)
1144
# limbo/new-1 => parent2, limbo/new-2 => parent2/child1
1145
self.assertEqual(2, transform.rename_count)
1147
def test_finalize_order(self):
1148
"""Finalize must be done in child-to-parent order"""
1149
transform, root = self.get_transform()
1150
parent = transform.new_directory('parent', root)
1151
child = transform.new_directory('child', parent)
1153
transform.finalize()
1155
self.fail('Tried to remove parent before child1')
1157
def test_cancel_with_cancelled_child_should_succeed(self):
1158
transform, root = self.get_transform()
1159
parent = transform.new_directory('parent', root)
1160
child = transform.new_directory('child', parent)
1161
transform.cancel_creation(child)
1162
transform.cancel_creation(parent)
1163
transform.finalize()
1165
def test_case_insensitive_clash(self):
1166
self.requireFeature(CaseInsensitiveFilesystemFeature)
1168
wt = self.make_branch_and_tree('.')
1169
tt = TreeTransform(wt) # TreeTransform obtains write lock
1171
tt.new_file('foo', tt.root, 'bar')
1172
tt.new_file('Foo', tt.root, 'spam')
1173
# Lie to tt that we've already resolved all conflicts.
1174
tt.apply(no_conflicts=True)
1178
err = self.assertRaises(errors.FileExists, tt_helper)
1179
self.assertContainsRe(str(err),
1180
"^File exists: .+/foo")
1182
def test_two_directories_clash(self):
1184
wt = self.make_branch_and_tree('.')
1185
tt = TreeTransform(wt) # TreeTransform obtains write lock
1187
foo_1 = tt.new_directory('foo', tt.root)
1188
tt.new_directory('bar', foo_1)
1189
foo_2 = tt.new_directory('foo', tt.root)
1190
tt.new_directory('baz', foo_2)
1191
# Lie to tt that we've already resolved all conflicts.
1192
tt.apply(no_conflicts=True)
1196
err = self.assertRaises(errors.FileExists, tt_helper)
1197
self.assertContainsRe(str(err),
1198
"^File exists: .+/foo")
1200
def test_two_directories_clash_finalize(self):
1202
wt = self.make_branch_and_tree('.')
1203
tt = TreeTransform(wt) # TreeTransform obtains write lock
1205
foo_1 = tt.new_directory('foo', tt.root)
1206
tt.new_directory('bar', foo_1)
1207
foo_2 = tt.new_directory('foo', tt.root)
1208
tt.new_directory('baz', foo_2)
1209
# Lie to tt that we've already resolved all conflicts.
1210
tt.apply(no_conflicts=True)
1214
err = self.assertRaises(errors.FileExists, tt_helper)
1215
self.assertContainsRe(str(err),
1216
"^File exists: .+/foo")
1219
class TransformGroup(object):
1221
def __init__(self, dirname, root_id):
1224
self.wt = BzrDir.create_standalone_workingtree(dirname)
1225
self.wt.set_root_id(root_id)
1226
self.b = self.wt.branch
1227
self.tt = TreeTransform(self.wt)
1228
self.root = self.tt.trans_id_tree_file_id(self.wt.get_root_id())
1231
def conflict_text(tree, merge):
1232
template = '%s TREE\n%s%s\n%s%s MERGE-SOURCE\n'
1233
return template % ('<' * 7, tree, '=' * 7, merge, '>' * 7)
1236
class TestTransformMerge(TestCaseInTempDir):
1238
def test_text_merge(self):
1239
root_id = generate_ids.gen_root_id()
1240
base = TransformGroup("base", root_id)
1241
base.tt.new_file('a', base.root, 'a\nb\nc\nd\be\n', 'a')
1242
base.tt.new_file('b', base.root, 'b1', 'b')
1243
base.tt.new_file('c', base.root, 'c', 'c')
1244
base.tt.new_file('d', base.root, 'd', 'd')
1245
base.tt.new_file('e', base.root, 'e', 'e')
1246
base.tt.new_file('f', base.root, 'f', 'f')
1247
base.tt.new_directory('g', base.root, 'g')
1248
base.tt.new_directory('h', base.root, 'h')
1250
other = TransformGroup("other", root_id)
1251
other.tt.new_file('a', other.root, 'y\nb\nc\nd\be\n', 'a')
1252
other.tt.new_file('b', other.root, 'b2', 'b')
1253
other.tt.new_file('c', other.root, 'c2', 'c')
1254
other.tt.new_file('d', other.root, 'd', 'd')
1255
other.tt.new_file('e', other.root, 'e2', 'e')
1256
other.tt.new_file('f', other.root, 'f', 'f')
1257
other.tt.new_file('g', other.root, 'g', 'g')
1258
other.tt.new_file('h', other.root, 'h\ni\nj\nk\n', 'h')
1259
other.tt.new_file('i', other.root, 'h\ni\nj\nk\n', 'i')
1261
this = TransformGroup("this", root_id)
1262
this.tt.new_file('a', this.root, 'a\nb\nc\nd\bz\n', 'a')
1263
this.tt.new_file('b', this.root, 'b', 'b')
1264
this.tt.new_file('c', this.root, 'c', 'c')
1265
this.tt.new_file('d', this.root, 'd2', 'd')
1266
this.tt.new_file('e', this.root, 'e2', 'e')
1267
this.tt.new_file('f', this.root, 'f', 'f')
1268
this.tt.new_file('g', this.root, 'g', 'g')
1269
this.tt.new_file('h', this.root, '1\n2\n3\n4\n', 'h')
1270
this.tt.new_file('i', this.root, '1\n2\n3\n4\n', 'i')
1272
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1275
self.assertEqual(this.wt.get_file('a').read(), 'y\nb\nc\nd\bz\n')
1276
# three-way text conflict
1277
self.assertEqual(this.wt.get_file('b').read(),
1278
conflict_text('b', 'b2'))
1280
self.assertEqual(this.wt.get_file('c').read(), 'c2')
1282
self.assertEqual(this.wt.get_file('d').read(), 'd2')
1283
# Ambigious clean merge
1284
self.assertEqual(this.wt.get_file('e').read(), 'e2')
1286
self.assertEqual(this.wt.get_file('f').read(), 'f')
1287
# Correct correct results when THIS == OTHER
1288
self.assertEqual(this.wt.get_file('g').read(), 'g')
1289
# Text conflict when THIS & OTHER are text and BASE is dir
1290
self.assertEqual(this.wt.get_file('h').read(),
1291
conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1292
self.assertEqual(this.wt.get_file_byname('h.THIS').read(),
1294
self.assertEqual(this.wt.get_file_byname('h.OTHER').read(),
1296
self.assertEqual(file_kind(this.wt.abspath('h.BASE')), 'directory')
1297
self.assertEqual(this.wt.get_file('i').read(),
1298
conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1299
self.assertEqual(this.wt.get_file_byname('i.THIS').read(),
1301
self.assertEqual(this.wt.get_file_byname('i.OTHER').read(),
1303
self.assertEqual(os.path.exists(this.wt.abspath('i.BASE')), False)
1304
modified = ['a', 'b', 'c', 'h', 'i']
1305
merge_modified = this.wt.merge_modified()
1306
self.assertSubset(merge_modified, modified)
1307
self.assertEqual(len(merge_modified), len(modified))
1308
file(this.wt.id2abspath('a'), 'wb').write('booga')
1310
merge_modified = this.wt.merge_modified()
1311
self.assertSubset(merge_modified, modified)
1312
self.assertEqual(len(merge_modified), len(modified))
1316
def test_file_merge(self):
1317
self.requireFeature(SymlinkFeature)
1318
root_id = generate_ids.gen_root_id()
1319
base = TransformGroup("BASE", root_id)
1320
this = TransformGroup("THIS", root_id)
1321
other = TransformGroup("OTHER", root_id)
1322
for tg in this, base, other:
1323
tg.tt.new_directory('a', tg.root, 'a')
1324
tg.tt.new_symlink('b', tg.root, 'b', 'b')
1325
tg.tt.new_file('c', tg.root, 'c', 'c')
1326
tg.tt.new_symlink('d', tg.root, tg.name, 'd')
1327
targets = ((base, 'base-e', 'base-f', None, None),
1328
(this, 'other-e', 'this-f', 'other-g', 'this-h'),
1329
(other, 'other-e', None, 'other-g', 'other-h'))
1330
for tg, e_target, f_target, g_target, h_target in targets:
1331
for link, target in (('e', e_target), ('f', f_target),
1332
('g', g_target), ('h', h_target)):
1333
if target is not None:
1334
tg.tt.new_symlink(link, tg.root, target, link)
1336
for tg in this, base, other:
1338
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1339
self.assertIs(os.path.isdir(this.wt.abspath('a')), True)
1340
self.assertIs(os.path.islink(this.wt.abspath('b')), True)
1341
self.assertIs(os.path.isfile(this.wt.abspath('c')), True)
1342
for suffix in ('THIS', 'BASE', 'OTHER'):
1343
self.assertEqual(os.readlink(this.wt.abspath('d.'+suffix)), suffix)
1344
self.assertIs(os.path.lexists(this.wt.abspath('d')), False)
1345
self.assertEqual(this.wt.id2path('d'), 'd.OTHER')
1346
self.assertEqual(this.wt.id2path('f'), 'f.THIS')
1347
self.assertEqual(os.readlink(this.wt.abspath('e')), 'other-e')
1348
self.assertIs(os.path.lexists(this.wt.abspath('e.THIS')), False)
1349
self.assertIs(os.path.lexists(this.wt.abspath('e.OTHER')), False)
1350
self.assertIs(os.path.lexists(this.wt.abspath('e.BASE')), False)
1351
self.assertIs(os.path.lexists(this.wt.abspath('g')), True)
1352
self.assertIs(os.path.lexists(this.wt.abspath('g.BASE')), False)
1353
self.assertIs(os.path.lexists(this.wt.abspath('h')), False)
1354
self.assertIs(os.path.lexists(this.wt.abspath('h.BASE')), False)
1355
self.assertIs(os.path.lexists(this.wt.abspath('h.THIS')), True)
1356
self.assertIs(os.path.lexists(this.wt.abspath('h.OTHER')), True)
1358
def test_filename_merge(self):
1359
root_id = generate_ids.gen_root_id()
1360
base = TransformGroup("BASE", root_id)
1361
this = TransformGroup("THIS", root_id)
1362
other = TransformGroup("OTHER", root_id)
1363
base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
1364
for t in [base, this, other]]
1365
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1366
for t in [base, this, other]]
1367
base.tt.new_directory('c', base_a, 'c')
1368
this.tt.new_directory('c1', this_a, 'c')
1369
other.tt.new_directory('c', other_b, 'c')
1371
base.tt.new_directory('d', base_a, 'd')
1372
this.tt.new_directory('d1', this_b, 'd')
1373
other.tt.new_directory('d', other_a, 'd')
1375
base.tt.new_directory('e', base_a, 'e')
1376
this.tt.new_directory('e', this_a, 'e')
1377
other.tt.new_directory('e1', other_b, 'e')
1379
base.tt.new_directory('f', base_a, 'f')
1380
this.tt.new_directory('f1', this_b, 'f')
1381
other.tt.new_directory('f1', other_b, 'f')
1383
for tg in [this, base, other]:
1385
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1386
self.assertEqual(this.wt.id2path('c'), pathjoin('b/c1'))
1387
self.assertEqual(this.wt.id2path('d'), pathjoin('b/d1'))
1388
self.assertEqual(this.wt.id2path('e'), pathjoin('b/e1'))
1389
self.assertEqual(this.wt.id2path('f'), pathjoin('b/f1'))
1391
def test_filename_merge_conflicts(self):
1392
root_id = generate_ids.gen_root_id()
1393
base = TransformGroup("BASE", root_id)
1394
this = TransformGroup("THIS", root_id)
1395
other = TransformGroup("OTHER", root_id)
1396
base_a, this_a, other_a = [t.tt.new_directory('a', t.root, 'a')
1397
for t in [base, this, other]]
1398
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1399
for t in [base, this, other]]
1401
base.tt.new_file('g', base_a, 'g', 'g')
1402
other.tt.new_file('g1', other_b, 'g1', 'g')
1404
base.tt.new_file('h', base_a, 'h', 'h')
1405
this.tt.new_file('h1', this_b, 'h1', 'h')
1407
base.tt.new_file('i', base.root, 'i', 'i')
1408
other.tt.new_directory('i1', this_b, 'i')
1410
for tg in [this, base, other]:
1412
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1414
self.assertEqual(this.wt.id2path('g'), pathjoin('b/g1.OTHER'))
1415
self.assertIs(os.path.lexists(this.wt.abspath('b/g1.BASE')), True)
1416
self.assertIs(os.path.lexists(this.wt.abspath('b/g1.THIS')), False)
1417
self.assertEqual(this.wt.id2path('h'), pathjoin('b/h1.THIS'))
1418
self.assertIs(os.path.lexists(this.wt.abspath('b/h1.BASE')), True)
1419
self.assertIs(os.path.lexists(this.wt.abspath('b/h1.OTHER')), False)
1420
self.assertEqual(this.wt.id2path('i'), pathjoin('b/i1.OTHER'))
1423
class TestBuildTree(tests.TestCaseWithTransport):
1425
def test_build_tree_with_symlinks(self):
1426
self.requireFeature(SymlinkFeature)
1428
a = BzrDir.create_standalone_workingtree('a')
1430
file('a/foo/bar', 'wb').write('contents')
1431
os.symlink('a/foo/bar', 'a/foo/baz')
1432
a.add(['foo', 'foo/bar', 'foo/baz'])
1433
a.commit('initial commit')
1434
b = BzrDir.create_standalone_workingtree('b')
1435
basis = a.basis_tree()
1437
self.addCleanup(basis.unlock)
1438
build_tree(basis, b)
1439
self.assertIs(os.path.isdir('b/foo'), True)
1440
self.assertEqual(file('b/foo/bar', 'rb').read(), "contents")
1441
self.assertEqual(os.readlink('b/foo/baz'), 'a/foo/bar')
1443
def test_build_with_references(self):
1444
tree = self.make_branch_and_tree('source',
1445
format='dirstate-with-subtree')
1446
subtree = self.make_branch_and_tree('source/subtree',
1447
format='dirstate-with-subtree')
1448
tree.add_reference(subtree)
1449
tree.commit('a revision')
1450
tree.branch.create_checkout('target')
1451
self.failUnlessExists('target')
1452
self.failUnlessExists('target/subtree')
1454
def test_file_conflict_handling(self):
1455
"""Ensure that when building trees, conflict handling is done"""
1456
source = self.make_branch_and_tree('source')
1457
target = self.make_branch_and_tree('target')
1458
self.build_tree(['source/file', 'target/file'])
1459
source.add('file', 'new-file')
1460
source.commit('added file')
1461
build_tree(source.basis_tree(), target)
1462
self.assertEqual([DuplicateEntry('Moved existing file to',
1463
'file.moved', 'file', None, 'new-file')],
1465
target2 = self.make_branch_and_tree('target2')
1466
target_file = file('target2/file', 'wb')
1468
source_file = file('source/file', 'rb')
1470
target_file.write(source_file.read())
1475
build_tree(source.basis_tree(), target2)
1476
self.assertEqual([], target2.conflicts())
1478
def test_symlink_conflict_handling(self):
1479
"""Ensure that when building trees, conflict handling is done"""
1480
self.requireFeature(SymlinkFeature)
1481
source = self.make_branch_and_tree('source')
1482
os.symlink('foo', 'source/symlink')
1483
source.add('symlink', 'new-symlink')
1484
source.commit('added file')
1485
target = self.make_branch_and_tree('target')
1486
os.symlink('bar', 'target/symlink')
1487
build_tree(source.basis_tree(), target)
1488
self.assertEqual([DuplicateEntry('Moved existing file to',
1489
'symlink.moved', 'symlink', None, 'new-symlink')],
1491
target = self.make_branch_and_tree('target2')
1492
os.symlink('foo', 'target2/symlink')
1493
build_tree(source.basis_tree(), target)
1494
self.assertEqual([], target.conflicts())
1496
def test_directory_conflict_handling(self):
1497
"""Ensure that when building trees, conflict handling is done"""
1498
source = self.make_branch_and_tree('source')
1499
target = self.make_branch_and_tree('target')
1500
self.build_tree(['source/dir1/', 'source/dir1/file', 'target/dir1/'])
1501
source.add(['dir1', 'dir1/file'], ['new-dir1', 'new-file'])
1502
source.commit('added file')
1503
build_tree(source.basis_tree(), target)
1504
self.assertEqual([], target.conflicts())
1505
self.failUnlessExists('target/dir1/file')
1507
# Ensure contents are merged
1508
target = self.make_branch_and_tree('target2')
1509
self.build_tree(['target2/dir1/', 'target2/dir1/file2'])
1510
build_tree(source.basis_tree(), target)
1511
self.assertEqual([], target.conflicts())
1512
self.failUnlessExists('target2/dir1/file2')
1513
self.failUnlessExists('target2/dir1/file')
1515
# Ensure new contents are suppressed for existing branches
1516
target = self.make_branch_and_tree('target3')
1517
self.make_branch('target3/dir1')
1518
self.build_tree(['target3/dir1/file2'])
1519
build_tree(source.basis_tree(), target)
1520
self.failIfExists('target3/dir1/file')
1521
self.failUnlessExists('target3/dir1/file2')
1522
self.failUnlessExists('target3/dir1.diverted/file')
1523
self.assertEqual([DuplicateEntry('Diverted to',
1524
'dir1.diverted', 'dir1', 'new-dir1', None)],
1527
target = self.make_branch_and_tree('target4')
1528
self.build_tree(['target4/dir1/'])
1529
self.make_branch('target4/dir1/file')
1530
build_tree(source.basis_tree(), target)
1531
self.failUnlessExists('target4/dir1/file')
1532
self.assertEqual('directory', file_kind('target4/dir1/file'))
1533
self.failUnlessExists('target4/dir1/file.diverted')
1534
self.assertEqual([DuplicateEntry('Diverted to',
1535
'dir1/file.diverted', 'dir1/file', 'new-file', None)],
1538
def test_mixed_conflict_handling(self):
1539
"""Ensure that when building trees, conflict handling is done"""
1540
source = self.make_branch_and_tree('source')
1541
target = self.make_branch_and_tree('target')
1542
self.build_tree(['source/name', 'target/name/'])
1543
source.add('name', 'new-name')
1544
source.commit('added file')
1545
build_tree(source.basis_tree(), target)
1546
self.assertEqual([DuplicateEntry('Moved existing file to',
1547
'name.moved', 'name', None, 'new-name')], target.conflicts())
1549
def test_raises_in_populated(self):
1550
source = self.make_branch_and_tree('source')
1551
self.build_tree(['source/name'])
1553
source.commit('added name')
1554
target = self.make_branch_and_tree('target')
1555
self.build_tree(['target/name'])
1557
self.assertRaises(errors.WorkingTreeAlreadyPopulated,
1558
build_tree, source.basis_tree(), target)
1560
def test_build_tree_rename_count(self):
1561
source = self.make_branch_and_tree('source')
1562
self.build_tree(['source/file1', 'source/dir1/'])
1563
source.add(['file1', 'dir1'])
1564
source.commit('add1')
1565
target1 = self.make_branch_and_tree('target1')
1566
transform_result = build_tree(source.basis_tree(), target1)
1567
self.assertEqual(2, transform_result.rename_count)
1569
self.build_tree(['source/dir1/file2'])
1570
source.add(['dir1/file2'])
1571
source.commit('add3')
1572
target2 = self.make_branch_and_tree('target2')
1573
transform_result = build_tree(source.basis_tree(), target2)
1574
# children of non-root directories should not be renamed
1575
self.assertEqual(2, transform_result.rename_count)
1577
def create_ab_tree(self):
1578
"""Create a committed test tree with two files"""
1579
source = self.make_branch_and_tree('source')
1580
self.build_tree_contents([('source/file1', 'A')])
1581
self.build_tree_contents([('source/file2', 'B')])
1582
source.add(['file1', 'file2'], ['file1-id', 'file2-id'])
1583
source.commit('commit files')
1585
self.addCleanup(source.unlock)
1588
def test_build_tree_accelerator_tree(self):
1589
source = self.create_ab_tree()
1590
self.build_tree_contents([('source/file2', 'C')])
1592
real_source_get_file = source.get_file
1593
def get_file(file_id, path=None):
1594
calls.append(file_id)
1595
return real_source_get_file(file_id, path)
1596
source.get_file = get_file
1597
target = self.make_branch_and_tree('target')
1598
revision_tree = source.basis_tree()
1599
revision_tree.lock_read()
1600
self.addCleanup(revision_tree.unlock)
1601
build_tree(revision_tree, target, source)
1602
self.assertEqual(['file1-id'], calls)
1604
self.addCleanup(target.unlock)
1605
self.assertEqual([], list(target.iter_changes(revision_tree)))
1607
def test_build_tree_accelerator_tree_missing_file(self):
1608
source = self.create_ab_tree()
1609
os.unlink('source/file1')
1610
source.remove(['file2'])
1611
target = self.make_branch_and_tree('target')
1612
revision_tree = source.basis_tree()
1613
revision_tree.lock_read()
1614
self.addCleanup(revision_tree.unlock)
1615
build_tree(revision_tree, target, source)
1617
self.addCleanup(target.unlock)
1618
self.assertEqual([], list(target.iter_changes(revision_tree)))
1620
def test_build_tree_accelerator_wrong_kind(self):
1621
self.requireFeature(SymlinkFeature)
1622
source = self.make_branch_and_tree('source')
1623
self.build_tree_contents([('source/file1', '')])
1624
self.build_tree_contents([('source/file2', '')])
1625
source.add(['file1', 'file2'], ['file1-id', 'file2-id'])
1626
source.commit('commit files')
1627
os.unlink('source/file2')
1628
self.build_tree_contents([('source/file2/', 'C')])
1629
os.unlink('source/file1')
1630
os.symlink('file2', 'source/file1')
1632
real_source_get_file = source.get_file
1633
def get_file(file_id, path=None):
1634
calls.append(file_id)
1635
return real_source_get_file(file_id, path)
1636
source.get_file = get_file
1637
target = self.make_branch_and_tree('target')
1638
revision_tree = source.basis_tree()
1639
revision_tree.lock_read()
1640
self.addCleanup(revision_tree.unlock)
1641
build_tree(revision_tree, target, source)
1642
self.assertEqual([], calls)
1644
self.addCleanup(target.unlock)
1645
self.assertEqual([], list(target.iter_changes(revision_tree)))
1647
def test_build_tree_hardlink(self):
1648
self.requireFeature(HardlinkFeature)
1649
source = self.create_ab_tree()
1650
target = self.make_branch_and_tree('target')
1651
revision_tree = source.basis_tree()
1652
revision_tree.lock_read()
1653
self.addCleanup(revision_tree.unlock)
1654
build_tree(revision_tree, target, source, hardlink=True)
1656
self.addCleanup(target.unlock)
1657
self.assertEqual([], list(target.iter_changes(revision_tree)))
1658
source_stat = os.stat('source/file1')
1659
target_stat = os.stat('target/file1')
1660
self.assertEqual(source_stat, target_stat)
1662
# Explicitly disallowing hardlinks should prevent them.
1663
target2 = self.make_branch_and_tree('target2')
1664
build_tree(revision_tree, target2, source, hardlink=False)
1666
self.addCleanup(target2.unlock)
1667
self.assertEqual([], list(target2.iter_changes(revision_tree)))
1668
source_stat = os.stat('source/file1')
1669
target2_stat = os.stat('target2/file1')
1670
self.assertNotEqual(source_stat, target2_stat)
1672
def test_build_tree_accelerator_tree_moved(self):
1673
source = self.make_branch_and_tree('source')
1674
self.build_tree_contents([('source/file1', 'A')])
1675
source.add(['file1'], ['file1-id'])
1676
source.commit('commit files')
1677
source.rename_one('file1', 'file2')
1679
self.addCleanup(source.unlock)
1680
target = self.make_branch_and_tree('target')
1681
revision_tree = source.basis_tree()
1682
revision_tree.lock_read()
1683
self.addCleanup(revision_tree.unlock)
1684
build_tree(revision_tree, target, source)
1686
self.addCleanup(target.unlock)
1687
self.assertEqual([], list(target.iter_changes(revision_tree)))
1689
def test_build_tree_hardlinks_preserve_execute(self):
1690
self.requireFeature(HardlinkFeature)
1691
source = self.create_ab_tree()
1692
tt = TreeTransform(source)
1693
trans_id = tt.trans_id_tree_file_id('file1-id')
1694
tt.set_executability(True, trans_id)
1696
self.assertTrue(source.is_executable('file1-id'))
1697
target = self.make_branch_and_tree('target')
1698
revision_tree = source.basis_tree()
1699
revision_tree.lock_read()
1700
self.addCleanup(revision_tree.unlock)
1701
build_tree(revision_tree, target, source, hardlink=True)
1703
self.addCleanup(target.unlock)
1704
self.assertEqual([], list(target.iter_changes(revision_tree)))
1705
self.assertTrue(source.is_executable('file1-id'))
1708
class MockTransform(object):
1710
def has_named_child(self, by_parent, parent_id, name):
1711
for child_id in by_parent[parent_id]:
1715
elif name == "name.~%s~" % child_id:
1720
class MockEntry(object):
1722
object.__init__(self)
1726
class TestGetBackupName(TestCase):
1727
def test_get_backup_name(self):
1728
tt = MockTransform()
1729
name = get_backup_name(MockEntry(), {'a':[]}, 'a', tt)
1730
self.assertEqual(name, 'name.~1~')
1731
name = get_backup_name(MockEntry(), {'a':['1']}, 'a', tt)
1732
self.assertEqual(name, 'name.~2~')
1733
name = get_backup_name(MockEntry(), {'a':['2']}, 'a', tt)
1734
self.assertEqual(name, 'name.~1~')
1735
name = get_backup_name(MockEntry(), {'a':['2'], 'b':[]}, 'b', tt)
1736
self.assertEqual(name, 'name.~1~')
1737
name = get_backup_name(MockEntry(), {'a':['1', '2', '3']}, 'a', tt)
1738
self.assertEqual(name, 'name.~4~')
1741
class TestFileMover(tests.TestCaseWithTransport):
1743
def test_file_mover(self):
1744
self.build_tree(['a/', 'a/b', 'c/', 'c/d'])
1745
mover = _FileMover()
1746
mover.rename('a', 'q')
1747
self.failUnlessExists('q')
1748
self.failIfExists('a')
1749
self.failUnlessExists('q/b')
1750
self.failUnlessExists('c')
1751
self.failUnlessExists('c/d')
1753
def test_pre_delete_rollback(self):
1754
self.build_tree(['a/'])
1755
mover = _FileMover()
1756
mover.pre_delete('a', 'q')
1757
self.failUnlessExists('q')
1758
self.failIfExists('a')
1760
self.failIfExists('q')
1761
self.failUnlessExists('a')
1763
def test_apply_deletions(self):
1764
self.build_tree(['a/', 'b/'])
1765
mover = _FileMover()
1766
mover.pre_delete('a', 'q')
1767
mover.pre_delete('b', 'r')
1768
self.failUnlessExists('q')
1769
self.failUnlessExists('r')
1770
self.failIfExists('a')
1771
self.failIfExists('b')
1772
mover.apply_deletions()
1773
self.failIfExists('q')
1774
self.failIfExists('r')
1775
self.failIfExists('a')
1776
self.failIfExists('b')
1778
def test_file_mover_rollback(self):
1779
self.build_tree(['a/', 'a/b', 'c/', 'c/d/', 'c/e/'])
1780
mover = _FileMover()
1781
mover.rename('c/d', 'c/f')
1782
mover.rename('c/e', 'c/d')
1784
mover.rename('a', 'c')
1785
except errors.FileExists, e:
1787
self.failUnlessExists('a')
1788
self.failUnlessExists('c/d')
1791
class Bogus(Exception):
1795
class TestTransformRollback(tests.TestCaseWithTransport):
1797
class ExceptionFileMover(_FileMover):
1799
def __init__(self, bad_source=None, bad_target=None):
1800
_FileMover.__init__(self)
1801
self.bad_source = bad_source
1802
self.bad_target = bad_target
1804
def rename(self, source, target):
1805
if (self.bad_source is not None and
1806
source.endswith(self.bad_source)):
1808
elif (self.bad_target is not None and
1809
target.endswith(self.bad_target)):
1812
_FileMover.rename(self, source, target)
1814
def test_rollback_rename(self):
1815
tree = self.make_branch_and_tree('.')
1816
self.build_tree(['a/', 'a/b'])
1817
tt = TreeTransform(tree)
1818
self.addCleanup(tt.finalize)
1819
a_id = tt.trans_id_tree_path('a')
1820
tt.adjust_path('c', tt.root, a_id)
1821
tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
1822
self.assertRaises(Bogus, tt.apply,
1823
_mover=self.ExceptionFileMover(bad_source='a'))
1824
self.failUnlessExists('a')
1825
self.failUnlessExists('a/b')
1827
self.failUnlessExists('c')
1828
self.failUnlessExists('c/d')
1830
def test_rollback_rename_into_place(self):
1831
tree = self.make_branch_and_tree('.')
1832
self.build_tree(['a/', 'a/b'])
1833
tt = TreeTransform(tree)
1834
self.addCleanup(tt.finalize)
1835
a_id = tt.trans_id_tree_path('a')
1836
tt.adjust_path('c', tt.root, a_id)
1837
tt.adjust_path('d', a_id, tt.trans_id_tree_path('a/b'))
1838
self.assertRaises(Bogus, tt.apply,
1839
_mover=self.ExceptionFileMover(bad_target='c/d'))
1840
self.failUnlessExists('a')
1841
self.failUnlessExists('a/b')
1843
self.failUnlessExists('c')
1844
self.failUnlessExists('c/d')
1846
def test_rollback_deletion(self):
1847
tree = self.make_branch_and_tree('.')
1848
self.build_tree(['a/', 'a/b'])
1849
tt = TreeTransform(tree)
1850
self.addCleanup(tt.finalize)
1851
a_id = tt.trans_id_tree_path('a')
1852
tt.delete_contents(a_id)
1853
tt.adjust_path('d', tt.root, tt.trans_id_tree_path('a/b'))
1854
self.assertRaises(Bogus, tt.apply,
1855
_mover=self.ExceptionFileMover(bad_target='d'))
1856
self.failUnlessExists('a')
1857
self.failUnlessExists('a/b')
1859
def test_resolve_no_parent(self):
1860
wt = self.make_branch_and_tree('.')
1861
tt = TreeTransform(wt)
1862
self.addCleanup(tt.finalize)
1863
parent = tt.trans_id_file_id('parent-id')
1864
tt.new_file('file', parent, 'Contents')
1865
resolve_conflicts(tt)
1868
class TestTransformPreview(tests.TestCaseWithTransport):
1870
def create_tree(self):
1871
tree = self.make_branch_and_tree('.')
1872
self.build_tree_contents([('a', 'content 1')])
1873
tree.add('a', 'a-id')
1874
tree.commit('rev1', rev_id='rev1')
1875
return tree.branch.repository.revision_tree('rev1')
1877
def get_empty_preview(self):
1878
repository = self.make_repository('repo')
1879
tree = repository.revision_tree(_mod_revision.NULL_REVISION)
1880
preview = TransformPreview(tree)
1881
self.addCleanup(preview.finalize)
1884
def test_transform_preview(self):
1885
revision_tree = self.create_tree()
1886
preview = TransformPreview(revision_tree)
1887
self.addCleanup(preview.finalize)
1889
def test_transform_preview_tree(self):
1890
revision_tree = self.create_tree()
1891
preview = TransformPreview(revision_tree)
1892
self.addCleanup(preview.finalize)
1893
preview.get_preview_tree()
1895
def test_transform_new_file(self):
1896
revision_tree = self.create_tree()
1897
preview = TransformPreview(revision_tree)
1898
self.addCleanup(preview.finalize)
1899
preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
1900
preview_tree = preview.get_preview_tree()
1901
self.assertEqual(preview_tree.kind('file2-id'), 'file')
1903
preview_tree.get_file('file2-id').read(), 'content B\n')
1905
def test_diff_preview_tree(self):
1906
revision_tree = self.create_tree()
1907
preview = TransformPreview(revision_tree)
1908
self.addCleanup(preview.finalize)
1909
preview.new_file('file2', preview.root, 'content B\n', 'file2-id')
1910
preview_tree = preview.get_preview_tree()
1912
show_diff_trees(revision_tree, preview_tree, out)
1913
lines = out.getvalue().splitlines()
1914
self.assertEqual(lines[0], "=== added file 'file2'")
1915
# 3 lines of diff administrivia
1916
self.assertEqual(lines[4], "+content B")
1918
def test_transform_conflicts(self):
1919
revision_tree = self.create_tree()
1920
preview = TransformPreview(revision_tree)
1921
self.addCleanup(preview.finalize)
1922
preview.new_file('a', preview.root, 'content 2')
1923
resolve_conflicts(preview)
1924
trans_id = preview.trans_id_file_id('a-id')
1925
self.assertEqual('a.moved', preview.final_name(trans_id))
1927
def get_tree_and_preview_tree(self):
1928
revision_tree = self.create_tree()
1929
preview = TransformPreview(revision_tree)
1930
self.addCleanup(preview.finalize)
1931
a_trans_id = preview.trans_id_file_id('a-id')
1932
preview.delete_contents(a_trans_id)
1933
preview.create_file('b content', a_trans_id)
1934
preview_tree = preview.get_preview_tree()
1935
return revision_tree, preview_tree
1937
def test_iter_changes(self):
1938
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1939
root = revision_tree.inventory.root.file_id
1940
self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
1941
(root, root), ('a', 'a'), ('file', 'file'),
1943
list(preview_tree.iter_changes(revision_tree)))
1945
def test_wrong_tree_value_error(self):
1946
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1947
e = self.assertRaises(ValueError, preview_tree.iter_changes,
1949
self.assertEqual('from_tree must be transform source tree.', str(e))
1951
def test_include_unchanged_value_error(self):
1952
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1953
e = self.assertRaises(ValueError, preview_tree.iter_changes,
1954
revision_tree, include_unchanged=True)
1955
self.assertEqual('include_unchanged is not supported', str(e))
1957
def test_specific_files(self):
1958
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1959
e = self.assertRaises(ValueError, preview_tree.iter_changes,
1960
revision_tree, specific_files=['pete'])
1961
self.assertEqual('specific_files is not supported', str(e))
1963
def test_want_unversioned_value_error(self):
1964
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1965
e = self.assertRaises(ValueError, preview_tree.iter_changes,
1966
revision_tree, want_unversioned=True)
1967
self.assertEqual('want_unversioned is not supported', str(e))
1969
def test_ignore_extra_trees_no_specific_files(self):
1970
# extra_trees is harmless without specific_files, so we'll silently
1971
# accept it, even though we won't use it.
1972
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1973
preview_tree.iter_changes(revision_tree, extra_trees=[preview_tree])
1975
def test_ignore_require_versioned_no_specific_files(self):
1976
# require_versioned is meaningless without specific_files.
1977
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1978
preview_tree.iter_changes(revision_tree, require_versioned=False)
1980
def test_ignore_pb(self):
1981
# pb could be supported, but TT.iter_changes doesn't support it.
1982
revision_tree, preview_tree = self.get_tree_and_preview_tree()
1983
preview_tree.iter_changes(revision_tree, pb=progress.DummyProgress())
1985
def test_kind(self):
1986
revision_tree = self.create_tree()
1987
preview = TransformPreview(revision_tree)
1988
self.addCleanup(preview.finalize)
1989
preview.new_file('file', preview.root, 'contents', 'file-id')
1990
preview.new_directory('directory', preview.root, 'dir-id')
1991
preview_tree = preview.get_preview_tree()
1992
self.assertEqual('file', preview_tree.kind('file-id'))
1993
self.assertEqual('directory', preview_tree.kind('dir-id'))
1995
def test_get_file_mtime(self):
1996
preview = self.get_empty_preview()
1997
file_trans_id = preview.new_file('file', preview.root, 'contents',
1999
limbo_path = preview._limbo_name(file_trans_id)
2000
preview_tree = preview.get_preview_tree()
2001
self.assertEqual(os.stat(limbo_path).st_mtime,
2002
preview_tree.get_file_mtime('file-id'))
2004
def test_get_file(self):
2005
preview = self.get_empty_preview()
2006
preview.new_file('file', preview.root, 'contents', 'file-id')
2007
preview_tree = preview.get_preview_tree()
2008
tree_file = preview_tree.get_file('file-id')
2010
self.assertEqual('contents', tree_file.read())
2014
def test_get_symlink_target(self):
2015
self.requireFeature(SymlinkFeature)
2016
preview = self.get_empty_preview()
2017
preview.new_symlink('symlink', preview.root, 'target', 'symlink-id')
2018
preview_tree = preview.get_preview_tree()
2019
self.assertEqual('target',
2020
preview_tree.get_symlink_target('symlink-id'))
added
removed
bzrlib/tests/test_transform.py
