To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar
« back to all changes in this revision
Viewing changes to breezy/tests/test_transform.py
- browse files at revision 7005
- compare with another revision
- compare with revision 1663
- download diff
- download tarball
- view history from revision 7005
- Committer: Breezy landing bot
- Author(s): Jelmer Vernooij
- Date: 2018-06-30 12:37:04 UTC
- mfrom: (6973.10.9 python3-i)
- Revision ID: breezy.the.bot@gmail.com-20180630123704-jq2qazweqd3u5ssp
Add more bees.
Merged from https://code.launchpad.net/~jelmer/brz/python3-i/+merge/348244
Merged from https://code.launchpad.net/~jelmer/brz/python3-i/+merge/348244
- files modified:
- breezy/bzr/branch.py
added
removed
breezy/tests/test_transform.py
148
148
self.assertIs(None, transform.final_kind(trans_id))
149
149
transform.create_file([b'contents'], trans_id)
150
150
transform.set_executability(True, trans_id)
151
transform.version_file('my_pretties', trans_id)
151
transform.version_file(b'my_pretties', trans_id)
152
152
self.assertRaises(DuplicateKey, transform.version_file,
153
'my_pretties', trans_id)
154
self.assertEqual(transform.final_file_id(trans_id), 'my_pretties')
153
b'my_pretties', trans_id)
154
self.assertEqual(transform.final_file_id(trans_id), b'my_pretties')
155
155
self.assertEqual(transform.final_parent(trans_id), root)
156
156
self.assertIs(transform.final_parent(root), ROOT_PARENT)
157
157
self.assertIs(transform.get_tree_parent(root), ROOT_PARENT)
158
158
oz_id = transform.create_path('oz', root)
159
159
transform.create_directory(oz_id)
160
transform.version_file('ozzie', oz_id)
160
transform.version_file(b'ozzie', oz_id)
161
161
trans_id2 = transform.create_path('name2', root)
162
162
transform.create_file([b'contents'], trans_id2)
163
163
transform.set_executability(False, trans_id2)
164
transform.version_file('my_pretties2', trans_id2)
164
transform.version_file(b'my_pretties2', trans_id2)
165
165
modified_paths = transform.apply().modified_paths
166
self.assertEqual('contents', self.wt.get_file('name').read())
167
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
166
with self.wt.get_file('name') as f:
167
self.assertEqual(b'contents', f.read())
168
self.assertEqual(self.wt.path2id('name'), b'my_pretties')
168
169
self.assertIs(self.wt.is_executable('name'), True)
169
170
self.assertIs(self.wt.is_executable('name2'), False)
170
171
self.assertEqual('directory', file_kind(self.wt.abspath('oz')))
171
172
self.assertEqual(len(modified_paths), 3)
172
173
tree_mod_paths = [self.wt.abspath(self.wt.id2path(f)) for f in
173
('ozzie', 'my_pretties', 'my_pretties2')]
174
(b'ozzie', b'my_pretties', b'my_pretties2')]
174
175
self.assertSubset(tree_mod_paths, modified_paths)
175
176
# is it safe to finalize repeatedly?
176
177
transform.finalize()
178
179
179
180
def test_apply_informs_tree_of_observed_sha1(self):
180
181
trans, root, contents, sha1 = self.get_transform_for_sha1_test()
181
trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
182
trans_id = trans.new_file('file1', root, contents, file_id=b'file1-id',
182
183
sha1=sha1)
183
184
calls = []
184
185
orig = self.wt._observed_sha1
222
223
223
224
def test_new_file_caches_sha1(self):
224
225
trans, root, contents, sha1 = self.get_transform_for_sha1_test()
225
trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
226
trans_id = trans.new_file('file1', root, contents, file_id=b'file1-id',
226
227
sha1=sha1)
227
228
st_val = osutils.lstat(trans._limbo_name(trans_id))
228
229
o_sha1, o_st_val = trans._observed_sha1s[trans_id]
231
232
232
233
def test_cancel_creation_removes_observed_sha1(self):
233
234
trans, root, contents, sha1 = self.get_transform_for_sha1_test()
234
trans_id = trans.new_file('file1', root, contents, file_id='file1-id',
235
trans_id = trans.new_file('file1', root, contents, file_id=b'file1-id',
235
236
sha1=sha1)
236
237
self.assertTrue(trans_id in trans._observed_sha1s)
237
238
trans.cancel_creation(trans_id)
274
275
transform, root = self.get_transform()
275
276
self.assertNotEqual(b'new-root-id', self.wt.get_root_id())
276
277
new_trans_id = transform.new_directory('', ROOT_PARENT, b'new-root-id')
277
transform.new_file('file', new_trans_id, ['new-contents\n'],
278
'new-file-id')
278
transform.new_file('file', new_trans_id, [b'new-contents\n'],
279
b'new-file-id')
279
280
transform.delete_contents(root)
280
281
transform.unversion_file(root)
281
282
transform.fixup_new_roots()
282
283
transform.apply()
283
284
self.assertEqual(b'new-root-id', self.wt.get_root_id())
284
285
self.assertEqual(b'new-file-id', self.wt.path2id('file'))
285
self.assertFileEqual('new-contents\n', self.wt.abspath('file'))
286
self.assertFileEqual(b'new-contents\n', self.wt.abspath('file'))
286
287
287
288
def test_add_two_roots(self):
288
289
transform, root = self.get_transform()
355
356
def test_hardlink(self):
356
357
self.requireFeature(HardlinkFeature)
357
358
transform, root = self.get_transform()
358
transform.new_file('file1', root, b'contents')
359
transform.new_file('file1', root, [b'contents'])
359
360
transform.apply()
360
361
target = self.make_branch_and_tree('target')
361
362
target_transform = TreeTransform(target)
371
372
transform, root = self.get_transform()
372
373
self.wt.lock_tree_write()
373
374
self.addCleanup(self.wt.unlock)
374
trans_id = transform.new_file('name', root, b'contents',
375
'my_pretties', True)
375
trans_id = transform.new_file('name', root, [b'contents'],
376
b'my_pretties', True)
376
377
oz = transform.new_directory('oz', root, 'oz-id')
377
dorothy = transform.new_directory('dorothy', oz, 'dorothy-id')
378
toto = transform.new_file('toto', dorothy, b'toto-contents',
379
'toto-id', False)
378
dorothy = transform.new_directory('dorothy', oz, b'dorothy-id')
379
toto = transform.new_file('toto', dorothy, [b'toto-contents'],
380
b'toto-id', False)
380
381
381
382
self.assertEqual(len(transform.find_conflicts()), 0)
382
383
transform.apply()
385
386
self.assertEqual('contents', f.read())
386
387
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
387
388
self.assertIs(self.wt.is_executable('name'), True)
388
self.assertEqual(self.wt.path2id('oz'), 'oz-id')
389
self.assertEqual(self.wt.path2id('oz/dorothy'), 'dorothy-id')
390
self.assertEqual(self.wt.path2id('oz/dorothy/toto'), 'toto-id')
389
self.assertEqual(self.wt.path2id('oz'), b'oz-id')
390
self.assertEqual(self.wt.path2id('oz/dorothy'), b'dorothy-id')
391
self.assertEqual(self.wt.path2id('oz/dorothy/toto'), b'toto-id')
391
392
392
self.assertEqual('toto-contents',
393
self.assertEqual(b'toto-contents',
393
394
self.wt.get_file('oz/dorothy/toto').read())
394
395
self.assertIs(self.wt.is_executable('oz/dorothy/toto'), False)
395
396
406
407
407
408
def test_conflicts(self):
408
409
transform, root = self.get_transform()
409
trans_id = transform.new_file('name', root, b'contents',
410
'my_pretties')
410
trans_id = transform.new_file('name', root, [b'contents'],
411
b'my_pretties')
411
412
self.assertEqual(len(transform.find_conflicts()), 0)
412
trans_id2 = transform.new_file('name', root, b'Crontents', 'toto')
413
trans_id2 = transform.new_file('name', root, [b'Crontents'], b'toto')
413
414
self.assertEqual(transform.find_conflicts(),
414
415
[('duplicate', trans_id, trans_id2, 'name')])
415
416
self.assertRaises(MalformedTransform, transform.apply)
446
447
transform.set_executability(True, oz_id)
447
448
self.assertEqual(transform.find_conflicts(),
448
449
[('unversioned executability', oz_id)])
449
transform.version_file('oz-id', oz_id)
450
transform.version_file(b'oz-id', oz_id)
450
451
self.assertEqual(transform.find_conflicts(),
451
452
[('non-file executability', oz_id)])
452
453
transform.set_executability(None, oz_id)
453
tip_id = transform.new_file('tip', oz_id, b'ozma', 'tip-id')
454
tip_id = transform.new_file('tip', oz_id, [b'ozma'], b'tip-id')
454
455
transform.apply()
455
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
456
self.assertEqual(self.wt.path2id('name'), b'my_pretties')
456
457
with open(self.wt.abspath('name'), 'r') as f:
457
self.assertEqual('contents', f.read())
458
self.assertEqual(b'contents', f.read())
458
459
transform2, root = self.get_transform()
459
460
oz_id = transform2.trans_id_tree_path('oz')
460
newtip = transform2.new_file('tip', oz_id, b'other', 'tip-id')
461
newtip = transform2.new_file('tip', oz_id, [b'other'], b'tip-id')
461
462
result = transform2.find_conflicts()
462
463
fp = FinalPaths(transform2)
463
464
self.assertTrue('oz/tip' in transform2._tree_path_ids)
487
488
tree.case_sensitive = True
488
489
transform = TreeTransform(tree)
489
490
self.addCleanup(transform.finalize)
490
transform.new_file('file', transform.root, b'content')
491
transform.new_file('FiLe', transform.root, b'content')
491
transform.new_file('file', transform.root, [b'content'])
492
transform.new_file('FiLe', transform.root, [b'content'])
492
493
result = transform.find_conflicts()
493
494
self.assertEqual([], result)
494
495
transform.finalize()
497
498
tree.case_sensitive = False
498
499
transform = TreeTransform(tree)
499
500
self.addCleanup(transform.finalize)
500
transform.new_file('file', transform.root, b'content')
501
transform.new_file('FiLe', transform.root, b'content')
501
transform.new_file('file', transform.root, [b'content'])
502
transform.new_file('FiLe', transform.root, [b'content'])
502
503
result = transform.find_conflicts()
503
504
self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
504
505
511
512
tree.case_sensitive = True
512
513
transform = TreeTransform(tree)
513
514
self.addCleanup(transform.finalize)
514
transform.new_file('file', transform.root, b'content')
515
transform.new_file('file', transform.root, [b'content'])
515
516
result = transform.find_conflicts()
516
517
self.assertEqual([], result)
517
518
transform.finalize()
520
521
tree.case_sensitive = False
521
522
transform = TreeTransform(tree)
522
523
self.addCleanup(transform.finalize)
523
transform.new_file('file', transform.root, b'content')
524
transform.new_file('file', transform.root, [b'content'])
524
525
result = transform.find_conflicts()
525
526
self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
526
527
532
533
tree.case_sensitive = False
533
534
transform = TreeTransform(tree)
534
535
self.addCleanup(transform.finalize)
535
transform.new_file('file', transform.root, b'content')
536
transform.new_file('FiLe', transform.root, b'content')
536
transform.new_file('file', transform.root, [b'content'])
537
transform.new_file('FiLe', transform.root, [b'content'])
537
538
resolve_conflicts(transform)
538
539
transform.apply()
539
540
self.assertPathExists('tree/file')
547
548
tree.case_sensitive = False
548
549
transform = TreeTransform(tree)
549
550
self.addCleanup(transform.finalize)
550
transform.new_file('file', transform.root, b'content')
551
transform.new_file('FiLe', transform.root, b'content')
551
transform.new_file('file', transform.root, [b'content'])
552
transform.new_file('FiLe', transform.root, [b'content'])
552
553
resolve_conflicts(transform,
553
554
pass_func=lambda t, c: resolve_checkout(t, c, []))
554
555
transform.apply()
560
561
tree = self.make_branch_and_tree('tree')
561
562
transform = TreeTransform(tree)
562
563
self.addCleanup(transform.finalize)
563
transform.new_file('file', transform.root, b'content')
564
transform.new_file('FiLe', transform.root, b'content')
564
transform.new_file('file', transform.root, [b'content'])
565
transform.new_file('FiLe', transform.root, [b'content'])
565
566
dir = transform.new_directory('dir', transform.root)
566
transform.new_file('dirfile', dir, b'content')
567
transform.new_file('dirFiLe', dir, b'content')
567
transform.new_file('dirfile', dir, [b'content'])
568
transform.new_file('dirFiLe', dir, [b'content'])
568
569
resolve_conflicts(transform)
569
570
transform.apply()
570
571
self.assertPathExists('tree/file')
582
583
transform = TreeTransform(tree)
583
584
self.addCleanup(transform.finalize)
584
585
dir = transform.new_directory('dir', transform.root)
585
first = transform.new_file('file', dir, b'content')
586
second = transform.new_file('FiLe', dir, b'content')
586
first = transform.new_file('file', dir, [b'content'])
587
second = transform.new_file('FiLe', dir, [b'content'])
587
588
self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
588
589
self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
589
590
611
612
def test_unversioning(self):
612
613
create_tree, root = self.get_transform()
613
614
parent_id = create_tree.new_directory('parent', root, b'parent-id')
614
create_tree.new_file('child', parent_id, b'child', b'child-id')
615
create_tree.new_file('child', parent_id, [b'child'], b'child-id')
615
616
create_tree.apply()
616
617
unversion = TreeTransform(self.wt)
617
618
self.addCleanup(unversion.finalize)
627
628
create_tree, root = self.get_transform()
628
629
# prepare tree
629
630
root = create_tree.root
630
create_tree.new_file('name1', root, b'hello1', 'name1')
631
create_tree.new_file('name2', root, b'hello2', 'name2')
632
ddir = create_tree.new_directory('dying_directory', root, 'ddir')
633
create_tree.new_file('dying_file', ddir, b'goodbye1', 'dfile')
634
create_tree.new_file('moving_file', ddir, b'later1', 'mfile')
635
create_tree.new_file('moving_file2', root, b'later2', 'mfile2')
631
create_tree.new_file('name1', root, [b'hello1'], b'name1')
632
create_tree.new_file('name2', root, [b'hello2'], b'name2')
633
ddir = create_tree.new_directory('dying_directory', root, b'ddir')
634
create_tree.new_file('dying_file', ddir, [b'goodbye1'], b'dfile')
635
create_tree.new_file('moving_file', ddir, [b'later1'], b'mfile')
636
create_tree.new_file('moving_file2', root, [b'later2'], b'mfile2')
636
637
create_tree.apply()
637
638
638
639
mangle_tree, root = self.get_transform()
656
657
newdir = mangle_tree.new_directory('new_directory', root, 'newdir')
657
658
mfile2 = mangle_tree.trans_id_tree_path('moving_file2')
658
659
mangle_tree.adjust_path('mfile2', newdir, mfile2)
659
mangle_tree.new_file('newfile', newdir, b'hello3', 'dfile')
660
self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
660
mangle_tree.new_file('newfile', newdir, [b'hello3'], b'dfile')
661
self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
661
662
self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
662
self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
663
self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
663
664
mangle_tree.apply()
664
665
with open(self.wt.abspath('name1'), 'r') as f:
665
666
self.assertEqual(f.read(), 'hello2')
680
681
681
682
def test_both_rename(self):
682
683
create_tree, root = self.get_transform()
683
newdir = create_tree.new_directory('selftest', root, 'selftest-id')
684
create_tree.new_file('blackbox.py', newdir, b'hello1', 'blackbox-id')
684
newdir = create_tree.new_directory('selftest', root, b'selftest-id')
685
create_tree.new_file('blackbox.py', newdir, [b'hello1'], b'blackbox-id')
685
686
create_tree.apply()
686
687
mangle_tree, root = self.get_transform()
687
688
selftest = mangle_tree.trans_id_tree_path('selftest')
696
697
breezy = create_tree.new_directory('breezy', root, 'breezy-id')
697
698
tests = create_tree.new_directory('tests', breezy, 'tests-id')
698
699
blackbox = create_tree.new_directory('blackbox', tests, 'blackbox-id')
699
create_tree.new_file('test_too_much.py', blackbox, b'hello1',
700
'test_too_much-id')
700
create_tree.new_file('test_too_much.py', blackbox, [b'hello1'],
701
b'test_too_much-id')
701
702
create_tree.apply()
702
703
mangle_tree, root = self.get_transform()
703
704
breezy = mangle_tree.trans_id_tree_path('breezy')
710
711
711
712
def test_both_rename3(self):
712
713
create_tree, root = self.get_transform()
713
tests = create_tree.new_directory('tests', root, 'tests-id')
714
create_tree.new_file('test_too_much.py', tests, b'hello1',
715
'test_too_much-id')
714
tests = create_tree.new_directory('tests', root, b'tests-id')
715
create_tree.new_file('test_too_much.py', tests, [b'hello1'],
716
b'test_too_much-id')
716
717
create_tree.apply()
717
718
mangle_tree, root = self.get_transform()
718
719
tests = mangle_tree.trans_id_tree_path('tests')
726
727
create_tree, root = self.get_transform()
727
728
# prepare tree
728
729
root = create_tree.root
729
create_tree.new_file('name1', root, b'hello1', 'name1')
730
create_tree.new_file('name1', root, [b'hello1'], b'name1')
730
731
create_tree.apply()
731
732
delete_contents, root = self.get_transform()
732
file = delete_contents.trans_id_tree_path('name1')
733
file = delete_contents.trans_id_tree_path(b'name1')
733
734
delete_contents.delete_contents(file)
734
735
delete_contents.apply()
735
736
move_id, root = self.get_transform()
742
743
create_tree, root = self.get_transform()
743
744
# prepare tree
744
745
root = create_tree.root
745
create_tree.new_file('name1', root, b'hello1', 'name1')
746
create_tree.new_file('name1', root, [b'hello1'], 'name1')
746
747
create_tree.apply()
747
748
delete_contents = TreeTransform(self.wt)
748
749
self.addCleanup(delete_contents.finalize)
752
753
delete_contents.finalize()
753
754
replace = TreeTransform(self.wt)
754
755
self.addCleanup(replace.finalize)
755
name2 = replace.new_file('name2', root, b'hello2', 'name1')
756
name2 = replace.new_file('name2', root, [b'hello2'], 'name1')
756
757
conflicts = replace.find_conflicts()
757
758
name1 = replace.trans_id_tree_path('name1')
758
759
self.assertEqual(conflicts, [('duplicate id', name1, name2)])
766
767
767
768
self.requireFeature(SymlinkFeature)
768
769
transform, root = self.get_transform()
769
oz_id = transform.new_directory('oz', root, 'oz-id')
770
oz_id = transform.new_directory('oz', root, b'oz-id')
770
771
wizard = transform.new_symlink(link_name1, oz_id, link_target1,
771
'wizard-id')
772
b'wizard-id')
772
773
wiz_id = transform.create_path(link_name2, oz_id)
773
774
transform.create_symlink(link_target2, wiz_id)
774
transform.version_file('wiz-id2', wiz_id)
775
transform.version_file(b'wiz-id2', wiz_id)
775
776
transform.set_executability(True, wiz_id)
776
777
self.assertEqual(transform.find_conflicts(),
777
778
[('non-file executability', wiz_id)])
778
779
transform.set_executability(None, wiz_id)
779
780
transform.apply()
780
self.assertEqual(self.wt.path2id(ozpath(link_name1)), 'wizard-id')
781
self.assertEqual(self.wt.path2id(ozpath(link_name1)), b'wizard-id')
781
782
self.assertEqual('symlink',
782
783
file_kind(self.wt.abspath(ozpath(link_name1))))
783
784
self.assertEqual(link_target2,
818
819
819
820
def get_conflicted(self):
820
821
create, root = self.get_transform()
821
create.new_file('dorothy', root, b'dorothy', 'dorothy-id')
822
oz = create.new_directory('oz', root, 'oz-id')
823
create.new_directory('emeraldcity', oz, 'emerald-id')
822
create.new_file('dorothy', root, [b'dorothy'], b'dorothy-id')
823
oz = create.new_directory('oz', root, b'oz-id')
824
create.new_directory('emeraldcity', oz, b'emerald-id')
824
825
create.apply()
825
826
conflicts, root = self.get_transform()
826
827
# set up duplicate entry, duplicate id
827
new_dorothy = conflicts.new_file('dorothy', root, b'dorothy',
828
'dorothy-id')
828
new_dorothy = conflicts.new_file('dorothy', root, [b'dorothy'],
829
b'dorothy-id')
829
830
old_dorothy = conflicts.trans_id_tree_path('dorothy')
830
831
oz = conflicts.trans_id_tree_path('oz')
831
832
# set up DeletedParent parent conflict
832
833
conflicts.delete_versioned(oz)
833
834
emerald = conflicts.trans_id_tree_path('oz/emeraldcity')
834
835
# set up MissingParent conflict
835
munchkincity = conflicts.trans_id_file_id('munchkincity-id')
836
munchkincity = conflicts.trans_id_file_id(b'munchkincity-id')
836
837
conflicts.adjust_path('munchkincity', root, munchkincity)
837
conflicts.new_directory('auntem', munchkincity, 'auntem-id')
838
conflicts.new_directory('auntem', munchkincity, b'auntem-id')
838
839
# set up parent loop
839
840
conflicts.adjust_path('emeraldcity', emerald, emerald)
840
841
return conflicts, emerald, oz, old_dorothy, new_dorothy
855
856
raw_conflicts = resolve_conflicts(tt)
856
857
cooked_conflicts = cook_conflicts(raw_conflicts, tt)
857
858
duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
858
'dorothy', None, 'dorothy-id')
859
'dorothy', None, b'dorothy-id')
859
860
self.assertEqual(cooked_conflicts[0], duplicate)
860
861
duplicate_id = DuplicateID('Unversioned existing file',
861
862
'dorothy.moved', 'dorothy', None,
862
'dorothy-id')
863
b'dorothy-id')
863
864
self.assertEqual(cooked_conflicts[1], duplicate_id)
864
865
missing_parent = MissingParent('Created directory', 'munchkincity',
865
'munchkincity-id')
866
deleted_parent = DeletingParent('Not deleting', 'oz', 'oz-id')
866
b'munchkincity-id')
867
deleted_parent = DeletingParent('Not deleting', 'oz', b'oz-id')
867
868
self.assertEqual(cooked_conflicts[2], missing_parent)
868
869
unversioned_parent = UnversionedParent('Versioned directory',
869
870
'munchkincity',
870
'munchkincity-id')
871
b'munchkincity-id')
871
872
unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
872
'oz-id')
873
b'oz-id')
873
874
self.assertEqual(cooked_conflicts[3], unversioned_parent)
874
875
parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity',
875
'oz/emeraldcity', 'emerald-id', 'emerald-id')
876
'oz/emeraldcity', b'emerald-id', b'emerald-id')
876
877
self.assertEqual(cooked_conflicts[4], deleted_parent)
877
878
self.assertEqual(cooked_conflicts[5], unversioned_parent2)
878
879
self.assertEqual(cooked_conflicts[6], parent_loop)
907
908
908
909
def prepare_wrong_parent_kind(self):
909
910
tt, root = self.get_transform()
910
tt.new_file('parent', root, b'contents', b'parent-id')
911
tt.new_file('parent', root, [b'contents'], b'parent-id')
911
912
tt.apply()
912
913
tt, root = self.get_transform()
913
parent_id = tt.trans_id_file_id('parent-id')
914
tt.new_file('child,', parent_id, b'contents2', b'file-id')
914
parent_id = tt.trans_id_file_id(b'parent-id')
915
tt.new_file('child,', parent_id, [b'contents2'], b'file-id')
915
916
return tt
916
917
917
918
def test_find_conflicts_wrong_parent_kind(self):
933
934
def test_resolve_conflicts_wrong_new_parent_kind(self):
934
935
tt, root = self.get_transform()
935
936
parent_id = tt.new_directory('parent', root, b'parent-id')
936
tt.new_file('child,', parent_id, b'contents2', b'file-id')
937
tt.new_file('child,', parent_id, [b'contents2'], b'file-id')
937
938
tt.apply()
938
939
tt, root = self.get_transform()
939
parent_id = tt.trans_id_file_id('parent-id')
940
parent_id = tt.trans_id_file_id(b'parent-id')
940
941
tt.delete_contents(parent_id)
941
942
tt.create_file([b'contents'], parent_id)
942
943
raw_conflicts = resolve_conflicts(tt)
944
945
'new-3')}, raw_conflicts)
945
946
tt.apply()
946
947
self.assertFalse(self.wt.is_versioned('parent'))
947
self.assertEqual('parent-id', self.wt.path2id('parent.new'))
948
self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
948
949
949
950
def test_resolve_conflicts_wrong_parent_kind_unversioned(self):
950
951
tt, root = self.get_transform()
951
952
parent_id = tt.new_directory('parent', root)
952
tt.new_file('child,', parent_id, b'contents2')
953
tt.new_file('child,', parent_id, [b'contents2'])
953
954
tt.apply()
954
955
tt, root = self.get_transform()
955
956
parent_id = tt.trans_id_tree_path('parent')
964
965
wt = self.make_branch_and_tree('.')
965
966
tt = TreeTransform(wt)
966
967
self.addCleanup(tt.finalize)
967
parent = tt.trans_id_file_id('parent-id')
968
tt.new_file('file', parent, b'Contents')
968
parent = tt.trans_id_file_id(b'parent-id')
969
tt.new_file('file', parent, [b'Contents'])
969
970
raw_conflicts = resolve_conflicts(tt)
970
971
# Since the directory doesn't exist it's seen as 'missing'. So
971
972
# 'resolve_conflicts' create a conflict asking for it to be created.
989
990
990
991
def test_moving_root(self):
991
992
create, root = self.get_transform()
992
fun = create.new_directory('fun', root, 'fun-id')
993
create.new_directory('sun', root, 'sun-id')
994
create.new_directory('moon', root, 'moon')
993
fun = create.new_directory('fun', root, b'fun-id')
994
create.new_directory('sun', root, b'sun-id')
995
create.new_directory('moon', root, b'moon')
995
996
create.apply()
996
997
transform, root = self.get_transform()
997
998
transform.adjust_root_path('oldroot', fun)
998
999
new_root = transform.trans_id_tree_path('')
999
transform.version_file('new-root', new_root)
1000
transform.version_file(b'new-root', new_root)
1000
1001
transform.apply()
1001
1002
1002
1003
def test_renames(self):
1003
1004
create, root = self.get_transform()
1004
old = create.new_directory('old-parent', root, 'old-id')
1005
intermediate = create.new_directory('intermediate', old, 'im-id')
1006
myfile = create.new_file('myfile', intermediate, b'myfile-text',
1007
'myfile-id')
1005
old = create.new_directory('old-parent', root, b'old-id')
1006
intermediate = create.new_directory('intermediate', old, b'im-id')
1007
myfile = create.new_file('myfile', intermediate, [b'myfile-text'],
1008
b'myfile-id')
1008
1009
create.apply()
1009
1010
rename, root = self.get_transform()
1010
old = rename.trans_id_file_id('old-id')
1011
old = rename.trans_id_file_id(b'old-id')
1011
1012
rename.adjust_path('new', root, old)
1012
myfile = rename.trans_id_file_id('myfile-id')
1013
myfile = rename.trans_id_file_id(b'myfile-id')
1013
1014
rename.set_executability(True, myfile)
1014
1015
rename.apply()
1015
1016
1017
1018
self.requireFeature(features.not_running_as_root)
1018
1019
# see https://bugs.launchpad.net/bzr/+bug/491763
1019
1020
create, root_id = self.get_transform()
1020
first_dir = create.new_directory('first-dir', root_id, 'first-id')
1021
myfile = create.new_file('myfile', root_id, b'myfile-text',
1022
'myfile-id')
1021
first_dir = create.new_directory('first-dir', root_id, b'first-id')
1022
myfile = create.new_file('myfile', root_id, [b'myfile-text'],
1023
b'myfile-id')
1023
1024
create.apply()
1024
1025
if os.name == "posix" and sys.platform != "cygwin":
1025
1026
# posix filesystems fail on renaming if the readonly bit is set
1031
1032
self.skipTest("Can't force a permissions error on rename")
1032
1033
# now transform to rename
1033
1034
rename_transform, root_id = self.get_transform()
1034
file_trans_id = rename_transform.trans_id_file_id('myfile-id')
1035
dir_id = rename_transform.trans_id_file_id('first-id')
1035
file_trans_id = rename_transform.trans_id_file_id(b'myfile-id')
1036
dir_id = rename_transform.trans_id_file_id(b'first-id')
1036
1037
rename_transform.adjust_path('newname', dir_id, file_trans_id)
1037
1038
e = self.assertRaises(errors.TransformRenameFailed,
1038
1039
rename_transform.apply)
1064
1065
wt = transform._tree
1065
1066
wt.lock_read()
1066
1067
self.addCleanup(wt.unlock)
1067
transform.new_file('set_on_creation', root, b'Set on creation', 'soc',
1068
transform.new_file('set_on_creation', root, [b'Set on creation'], 'soc',
1068
1069
True)
1069
1070
sac = transform.new_file('set_after_creation', root,
1070
'Set after creation', 'sac')
1071
[b'Set after creation'], 'sac')
1071
1072
transform.set_executability(True, sac)
1072
uws = transform.new_file('unset_without_set', root, b'Unset badly',
1073
uws = transform.new_file('unset_without_set', root, [b'Unset badly'],
1073
1074
'uws')
1074
1075
self.assertRaises(KeyError, transform.set_executability, None, uws)
1075
1076
transform.apply()
1081
1082
if sys.platform == 'win32':
1082
1083
raise TestSkipped('chmod has no effect on win32')
1083
1084
transform, root = self.get_transform()
1084
transform.new_file('file1', root, b'contents', b'file1-id', True)
1085
transform.new_file('file1', root, [b'contents'], b'file1-id', True)
1085
1086
transform.apply()
1086
1087
self.wt.lock_write()
1087
1088
self.addCleanup(self.wt.unlock)
1106
1107
1107
1108
transform, root = self.get_transform()
1108
1109
1109
bar1_id = transform.new_file('bar', root, b'bar contents 1\n',
1110
bar1_id = transform.new_file('bar', root, [b'bar contents 1\n'],
1110
1111
file_id=b'bar-id-1', executable=False)
1111
1112
transform.apply()
1112
1113
1126
1127
def test_iter_changes(self):
1127
1128
self.wt.set_root_id(b'eert_toor')
1128
1129
transform, root = self.get_transform()
1129
transform.new_file('old', root, b'blah', b'id-1', True)
1130
transform.new_file('old', root, [b'blah'], b'id-1', True)
1130
1131
transform.apply()
1131
1132
transform, root = self.get_transform()
1132
1133
try:
1133
1134
self.assertEqual([], list(transform.iter_changes()))
1134
1135
old = transform.trans_id_tree_path('old')
1135
1136
transform.unversion_file(old)
1136
self.assertEqual([('id-1', ('old', None), False, (True, False),
1137
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1137
self.assertEqual([(b'id-1', ('old', None), False, (True, False),
1138
(b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1138
1139
(True, True))], list(transform.iter_changes()))
1139
transform.new_directory('new', root, 'id-1')
1140
self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
1141
('eert_toor', 'eert_toor'), ('old', 'new'),
1140
transform.new_directory('new', root, b'id-1')
1141
self.assertEqual([(b'id-1', ('old', 'new'), True, (True, True),
1142
(b'eert_toor', b'eert_toor'), ('old', 'new'),
1142
1143
('file', 'directory'),
1143
1144
(True, False))], list(transform.iter_changes()))
1144
1145
finally:
1147
1148
def test_iter_changes_new(self):
1148
1149
self.wt.set_root_id(b'eert_toor')
1149
1150
transform, root = self.get_transform()
1150
transform.new_file('old', root, b'blah')
1151
transform.new_file('old', root, [b'blah'])
1151
1152
transform.apply()
1152
1153
transform, root = self.get_transform()
1153
1154
try:
1154
1155
old = transform.trans_id_tree_path('old')
1155
transform.version_file('id-1', old)
1156
self.assertEqual([('id-1', (None, 'old'), False, (False, True),
1157
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1156
transform.version_file(b'id-1', old)
1157
self.assertEqual([(b'id-1', (None, 'old'), False, (False, True),
1158
(b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1158
1159
(False, False))], list(transform.iter_changes()))
1159
1160
finally:
1160
1161
transform.finalize()
1162
1163
def test_iter_changes_modifications(self):
1163
1164
self.wt.set_root_id(b'eert_toor')
1164
1165
transform, root = self.get_transform()
1165
transform.new_file('old', root, b'blah', 'id-1')
1166
transform.new_file('new', root, b'blah')
1166
transform.new_file('old', root, [b'blah'], 'id-1')
1167
transform.new_file('new', root, [b'blah'])
1167
1168
transform.new_directory('subdir', root, 'subdir-id')
1168
1169
transform.apply()
1169
1170
transform, root = self.get_transform()
1175
1176
1176
1177
#content deletion
1177
1178
transform.delete_contents(old)
1178
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1179
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', None),
1179
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1180
(b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', None),
1180
1181
(False, False))], list(transform.iter_changes()))
1181
1182
1182
1183
#content change
1183
1184
transform.create_file([b'blah'], old)
1184
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1185
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1185
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1186
(b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1186
1187
(False, False))], list(transform.iter_changes()))
1187
1188
transform.cancel_deletion(old)
1188
1189
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1189
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1190
(b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1190
1191
(False, False))], list(transform.iter_changes()))
1191
1192
transform.cancel_creation(old)
1192
1193
1193
1194
# move file_id to a different file
1194
1195
self.assertEqual([], list(transform.iter_changes()))
1195
1196
transform.unversion_file(old)
1196
transform.version_file('id-1', new)
1197
transform.version_file(b'id-1', new)
1197
1198
transform.adjust_path('old', root, new)
1198
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1199
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1199
1200
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1200
1201
(False, False))], list(transform.iter_changes()))
1201
1202
transform.cancel_versioning(new)
1204
1205
#execute bit
1205
1206
self.assertEqual([], list(transform.iter_changes()))
1206
1207
transform.set_executability(True, old)
1207
self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
1208
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1208
self.assertEqual([(b'id-1', ('old', 'old'), False, (True, True),
1209
(b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1209
1210
(False, True))], list(transform.iter_changes()))
1210
1211
transform.set_executability(None, old)
1211
1212
1213
1214
self.assertEqual([], list(transform.iter_changes()))
1214
1215
transform.adjust_path('new', root, old)
1215
1216
transform._new_parent = {}
1216
self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
1217
('eert_toor', 'eert_toor'), ('old', 'new'), ('file', 'file'),
1217
self.assertEqual([(b'id-1', ('old', 'new'), False, (True, True),
1218
(b'eert_toor', b'eert_toor'), ('old', 'new'), ('file', 'file'),
1218
1219
(False, False))], list(transform.iter_changes()))
1219
1220
transform._new_name = {}
1220
1221
1222
1223
self.assertEqual([], list(transform.iter_changes()))
1223
1224
transform.adjust_path('new', subdir, old)
1224
1225
transform._new_name = {}
1225
self.assertEqual([('id-1', ('old', 'subdir/old'), False,
1226
(True, True), ('eert_toor', 'subdir-id'), ('old', 'old'),
1226
self.assertEqual([(b'id-1', ('old', 'subdir/old'), False,
1227
(True, True), (b'eert_toor', b'subdir-id'), ('old', 'old'),
1227
1228
('file', 'file'), (False, False))],
1228
1229
list(transform.iter_changes()))
1229
1230
transform._new_path = {}
1239
1240
# obviously can't bleed into file2's change output. But for now, it
1240
1241
# works.
1241
1242
transform, root = self.get_transform()
1242
transform.new_file('file1', root, b'blah', 'id-1')
1243
transform.new_file('file2', root, b'blah', 'id-2')
1243
transform.new_file('file1', root, [b'blah'], b'id-1')
1244
transform.new_file('file2', root, [b'blah'], b'id-2')
1244
1245
transform.apply()
1245
1246
transform, root = self.get_transform()
1246
1247
try:
1247
transform.delete_contents(transform.trans_id_file_id('id-1'))
1248
transform.delete_contents(transform.trans_id_file_id(b'id-1'))
1248
1249
transform.set_executability(True,
1249
transform.trans_id_file_id('id-2'))
1250
self.assertEqual([('id-1', (u'file1', u'file1'), True, (True, True),
1251
('eert_toor', 'eert_toor'), ('file1', u'file1'),
1250
transform.trans_id_file_id(b'id-2'))
1251
self.assertEqual([(b'id-1', (u'file1', u'file1'), True, (True, True),
1252
(b'eert_toor', b'eert_toor'), ('file1', u'file1'),
1252
1253
('file', None), (False, False)),
1253
('id-2', (u'file2', u'file2'), False, (True, True),
1254
('eert_toor', 'eert_toor'), ('file2', u'file2'),
1254
(b'id-2', (u'file2', u'file2'), False, (True, True),
1255
(b'eert_toor', b'eert_toor'), ('file2', u'file2'),
1255
1256
('file', 'file'), (False, True))],
1256
1257
list(transform.iter_changes()))
1257
1258
finally:
1262
1263
self.wt.set_root_id(b'toor_eert')
1263
1264
# Need two steps because versioning a non-existant file is a conflict.
1264
1265
transform, root = self.get_transform()
1265
transform.new_directory('floater', root, 'floater-id')
1266
transform.new_directory('floater', root, b'floater-id')
1266
1267
transform.apply()
1267
1268
transform, root = self.get_transform()
1268
1269
transform.delete_contents(transform.trans_id_tree_path('floater'))
1271
1272
floater = transform.trans_id_tree_path('floater')
1272
1273
try:
1273
1274
transform.adjust_path('flitter', root, floater)
1274
self.assertEqual([('floater-id', ('floater', 'flitter'), False,
1275
self.assertEqual([(b'floater-id', ('floater', 'flitter'), False,
1275
1276
(True, True), ('toor_eert', 'toor_eert'), ('floater', 'flitter'),
1276
1277
(None, None), (False, False))], list(transform.iter_changes()))
1277
1278
finally:
1281
1282
"""Ensure that no-ops are not treated as modifications"""
1282
1283
self.wt.set_root_id(b'eert_toor')
1283
1284
transform, root = self.get_transform()
1284
transform.new_file('old', root, b'blah', b'id-1')
1285
transform.new_file('old', root, [b'blah'], b'id-1')
1285
1286
transform.new_directory('subdir', root, b'subdir-id')
1286
1287
transform.apply()
1287
1288
transform, root = self.get_transform()
1293
1294
transform.create_directory(subdir)
1294
1295
transform.set_executability(False, old)
1295
1296
transform.unversion_file(old)
1296
transform.version_file('id-1', old)
1297
transform.version_file(b'id-1', old)
1297
1298
transform.adjust_path('old', root, old)
1298
1299
self.assertEqual([], list(transform.iter_changes()))
1299
1300
finally:
1301
1302
1302
1303
def test_rename_count(self):
1303
1304
transform, root = self.get_transform()
1304
transform.new_file('name1', root, b'contents')
1305
transform.new_file('name1', root, [b'contents'])
1305
1306
self.assertEqual(transform.rename_count, 0)
1306
1307
transform.apply()
1307
1308
self.assertEqual(transform.rename_count, 1)
1324
1325
"""
1325
1326
transform, root = self.get_transform()
1326
1327
parent1 = transform.new_directory('parent1', root)
1327
child1 = transform.new_file('child1', parent1, b'contents')
1328
child1 = transform.new_file('child1', parent1, [b'contents'])
1328
1329
parent2 = transform.new_directory('parent2', root)
1329
1330
transform.adjust_path('child1', parent2, child1)
1330
1331
transform.apply()
1343
1344
"""
1344
1345
transform, root = self.get_transform()
1345
1346
parent1 = transform.new_directory('parent1', root)
1346
child1 = transform.new_file('child1', parent1, b'contents')
1347
child2 = transform.new_file('child2', parent1, b'contents')
1347
child1 = transform.new_file('child1', parent1, [b'contents'])
1348
child2 = transform.new_file('child2', parent1, [b'contents'])
1348
1349
try:
1349
1350
transform.cancel_creation(parent1)
1350
1351
except OSError:
1370
1371
"""Make sure adjust_path keeps track of limbo children properly"""
1371
1372
transform, root = self.get_transform()
1372
1373
parent1 = transform.new_directory('parent1', root)
1373
child1 = transform.new_file('child1', parent1, b'contents')
1374
child1 = transform.new_file('child1', parent1, [b'contents'])
1374
1375
parent2 = transform.new_directory('parent2', root)
1375
1376
transform.adjust_path('child1', parent2, child1)
1376
1377
transform.cancel_creation(child1)
1385
1386
def test_noname_contents(self):
1386
1387
"""TreeTransform should permit deferring naming files."""
1387
1388
transform, root = self.get_transform()
1388
parent = transform.trans_id_file_id('parent-id')
1389
parent = transform.trans_id_file_id(b'parent-id')
1389
1390
try:
1390
1391
transform.create_directory(parent)
1391
1392
except KeyError:
1395
1396
def test_noname_contents_nested(self):
1396
1397
"""TreeTransform should permit deferring naming files."""
1397
1398
transform, root = self.get_transform()
1398
parent = transform.trans_id_file_id('parent-id')
1399
parent = transform.trans_id_file_id(b'parent-id')
1399
1400
try:
1400
1401
transform.create_directory(parent)
1401
1402
except KeyError:
1472
1473
tt = TreeTransform(wt) # TreeTransform obtains write lock
1473
1474
try:
1474
1475
foo = tt.new_directory('foo', tt.root)
1475
tt.new_file('bar', foo, b'foobar')
1476
tt.new_file('bar', foo, [b'foobar'])
1476
1477
baz = tt.new_directory('baz', tt.root)
1477
tt.new_file('qux', baz, b'quux')
1478
tt.new_file('qux', baz, [b'quux'])
1478
1479
# Ask for a rename 'foo' -> 'baz'
1479
1480
tt.adjust_path('baz', tt.root, foo)
1480
1481
# Lie to tt that we've already resolved all conflicts.
1605
1606
1606
1607
def test_no_final_path(self):
1607
1608
transform, root = self.get_transform()
1608
trans_id = transform.trans_id_file_id('foo')
1609
trans_id = transform.trans_id_file_id(b'foo')
1609
1610
transform.create_file([b'bar'], trans_id)
1610
1611
transform.cancel_creation(trans_id)
1611
1612
transform.apply()
1619
1620
foo_trans_id = tt.create_path('foo', tt.root)
1620
1621
create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id')
1621
1622
bar_trans_id = tt.create_path('bar', tt.root)
1622
create_from_tree(tt, bar_trans_id, tree1, 'bar', file_id='bbar-id')
1623
create_from_tree(tt, bar_trans_id, tree1, 'bar', file_id=b'bar-id')
1623
1624
tt.apply()
1624
1625
self.assertEqual('directory', osutils.file_kind('tree2/foo'))
1625
self.assertFileEqual('baz', 'tree2/bar')
1626
self.assertFileEqual(b'baz', 'tree2/bar')
1626
1627
1627
1628
def test_create_from_tree_bytes(self):
1628
1629
"""Provided lines are used instead of tree content."""
1629
1630
tree1 = self.make_branch_and_tree('tree1')
1630
self.build_tree_contents([('tree1/foo', 'bar'),])
1631
self.build_tree_contents([('tree1/foo', b'bar'),])
1631
1632
tree1.add('foo', b'foo-id')
1632
1633
tree2 = self.make_branch_and_tree('tree2')
1633
1634
tt = TreeTransform(tree2)
1634
1635
foo_trans_id = tt.create_path('foo', tt.root)
1635
1636
create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id',
1636
chunks=['qux'])
1637
chunks=[b'qux'])
1637
1638
tt.apply()
1638
self.assertFileEqual('qux', 'tree2/foo')
1639
self.assertFileEqual(b'qux', 'tree2/foo')
1639
1640
1640
1641
def test_create_from_tree_symlink(self):
1641
1642
self.requireFeature(SymlinkFeature)
1662
1663
1663
1664
1664
1665
def conflict_text(tree, merge):
1665
template = '%s TREE\n%s%s\n%s%s MERGE-SOURCE\n'
1666
return template % ('<' * 7, tree, '=' * 7, merge, '>' * 7)
1666
template = b'%s TREE\n%s%s\n%s%s MERGE-SOURCE\n'
1667
return template % (b'<' * 7, tree, b'=' * 7, merge, b'>' * 7)
1667
1668
1668
1669
1669
1670
class TestInventoryAltered(tests.TestCaseWithTransport):
1703
1704
def test_text_merge(self):
1704
1705
root_id = generate_ids.gen_root_id()
1705
1706
base = TransformGroup("base", root_id)
1706
base.tt.new_file('a', base.root, b'a\nb\nc\nd\be\n', b'a')
1707
base.tt.new_file('b', base.root, b'b1', b'b')
1708
base.tt.new_file('c', base.root, b'c', b'c')
1709
base.tt.new_file('d', base.root, b'd', b'd')
1710
base.tt.new_file('e', base.root, b'e', b'e')
1711
base.tt.new_file('f', base.root, b'f', b'f')
1707
base.tt.new_file('a', base.root, [b'a\nb\nc\nd\be\n'], b'a')
1708
base.tt.new_file('b', base.root, [b'b1'], b'b')
1709
base.tt.new_file('c', base.root, [b'c'], b'c')
1710
base.tt.new_file('d', base.root, [b'd'], b'd')
1711
base.tt.new_file('e', base.root, [b'e'], b'e')
1712
base.tt.new_file('f', base.root, [b'f'], b'f')
1712
1713
base.tt.new_directory('g', base.root, b'g')
1713
1714
base.tt.new_directory('h', base.root, b'h')
1714
1715
base.tt.apply()
1715
1716
other = TransformGroup("other", root_id)
1716
other.tt.new_file('a', other.root, b'y\nb\nc\nd\be\n', b'a')
1717
other.tt.new_file('b', other.root, b'b2', b'b')
1718
other.tt.new_file('c', other.root, b'c2', b'c')
1719
other.tt.new_file('d', other.root, b'd', b'd')
1720
other.tt.new_file('e', other.root, b'e2', b'e')
1721
other.tt.new_file('f', other.root, b'f', b'f')
1722
other.tt.new_file('g', other.root, b'g', b'g')
1723
other.tt.new_file('h', other.root, b'h\ni\nj\nk\n', b'h')
1724
other.tt.new_file('i', other.root, b'h\ni\nj\nk\n', b'i')
1717
other.tt.new_file('a', other.root, [b'y\nb\nc\nd\be\n'], b'a')
1718
other.tt.new_file('b', other.root, [b'b2'], b'b')
1719
other.tt.new_file('c', other.root, [b'c2'], b'c')
1720
other.tt.new_file('d', other.root, [b'd'], b'd')
1721
other.tt.new_file('e', other.root, [b'e2'], b'e')
1722
other.tt.new_file('f', other.root, [b'f'], b'f')
1723
other.tt.new_file('g', other.root, [b'g'], b'g')
1724
other.tt.new_file('h', other.root, [b'h\ni\nj\nk\n'], b'h')
1725
other.tt.new_file('i', other.root, [b'h\ni\nj\nk\n'], b'i')
1725
1726
other.tt.apply()
1726
1727
this = TransformGroup("this", root_id)
1727
this.tt.new_file('a', this.root, b'a\nb\nc\nd\bz\n', b'a')
1728
this.tt.new_file('b', this.root, b'b', b'b')
1729
this.tt.new_file('c', this.root, b'c', b'c')
1730
this.tt.new_file('d', this.root, b'd2', b'd')
1731
this.tt.new_file('e', this.root, b'e2', b'e')
1732
this.tt.new_file('f', this.root, b'f', b'f')
1733
this.tt.new_file('g', this.root, b'g', b'g')
1734
this.tt.new_file('h', this.root, b'1\n2\n3\n4\n', b'h')
1735
this.tt.new_file('i', this.root, b'1\n2\n3\n4\n', b'i')
1728
this.tt.new_file('a', this.root, [b'a\nb\nc\nd\bz\n'], b'a')
1729
this.tt.new_file('b', this.root, [b'b'], b'b')
1730
this.tt.new_file('c', this.root, [b'c'], b'c')
1731
this.tt.new_file('d', this.root, [b'd2'], b'd')
1732
this.tt.new_file('e', this.root, [b'e2'], b'e')
1733
this.tt.new_file('f', this.root, [b'f'], b'f')
1734
this.tt.new_file('g', this.root, [b'g'], b'g')
1735
this.tt.new_file('h', this.root, [b'1\n2\n3\n4\n'], b'h')
1736
this.tt.new_file('i', this.root, [b'1\n2\n3\n4\n'], b'i')
1736
1737
this.tt.apply()
1737
1738
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1738
1739
1739
1740
# textual merge
1740
self.assertEqual(this.wt.get_file(this.wt.id2path(b'a')).read(), b'y\nb\nc\nd\bz\n')
1741
with this.wt.get_file(this.wt.id2path(b'a')) as f:
1742
self.assertEqual(f.read(), b'y\nb\nc\nd\bz\n')
1741
1743
# three-way text conflict
1742
self.assertEqual(this.wt.get_file(this.wt.id2path(b'b')).read(),
1743
conflict_text('b', 'b2'))
1744
with this.wt.get_file(this.wt.id2path(b'b')) as f:
1745
self.assertEqual(f.read(), conflict_text('b', 'b2'))
1744
1746
# OTHER wins
1745
1747
self.assertEqual(this.wt.get_file(this.wt.id2path(b'c')).read(), b'c2')
1746
1748
# THIS wins
1753
1755
self.assertEqual(this.wt.get_file(this.wt.id2path(b'g')).read(), b'g')
1754
1756
# Text conflict when THIS & OTHER are text and BASE is dir
1755
1757
self.assertEqual(this.wt.get_file(this.wt.id2path(b'h')).read(),
1756
conflict_text('1\n2\n3\n4\n', 'h\ni\nj\nk\n'))
1758
conflict_text(b'1\n2\n3\n4\n', b'h\ni\nj\nk\n'))
1757
1759
self.assertEqual(this.wt.get_file('h.THIS').read(),
1758
1760
b'1\n2\n3\n4\n')
1759
1761
self.assertEqual(this.wt.get_file('h.OTHER').read(),
1786
1788
other = TransformGroup("OTHER", root_id)
1787
1789
for tg in this, base, other:
1788
1790
tg.tt.new_directory('a', tg.root, b'a')
1789
tg.tt.new_symlink('b', tg.root, 'b', 'b')
1790
tg.tt.new_file('c', tg.root, b'c', b'c')
1791
tg.tt.new_symlink('b', tg.root, 'b', b'b')
1792
tg.tt.new_file('c', tg.root, [b'c'], b'c')
1791
1793
tg.tt.new_symlink('d', tg.root, tg.name, b'd')
1792
1794
targets = ((base, 'base-e', 'base-f', None, None),
1793
1795
(this, 'other-e', 'this-f', 'other-g', 'this-h'),
1863
1865
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1864
1866
for t in [base, this, other]]
1865
1867
1866
base.tt.new_file('g', base_a, 'g', 'g')
1867
other.tt.new_file('g1', other_b, 'g1', 'g')
1868
1869
base.tt.new_file('h', base_a, 'h', 'h')
1870
this.tt.new_file('h1', this_b, 'h1', 'h')
1871
1872
base.tt.new_file('i', base.root, 'i', 'i')
1873
other.tt.new_directory('i1', this_b, 'i')
1868
base.tt.new_file('g', base_a, [b'g'], b'g')
1869
other.tt.new_file('g1', other_b, [b'g1'], b'g')
1870
1871
base.tt.new_file('h', base_a, [b'h'], b'h')
1872
this.tt.new_file('h1', this_b, [b'h1'], b'h')
1873
1874
base.tt.new_file('i', base.root, [b'i'], b'i')
1875
other.tt.new_directory('i1', this_b, b'i')
1874
1876
1875
1877
for tg in [this, base, other]:
1876
1878
tg.tt.apply()
2059
2061
revision_tree.lock_read()
2060
2062
self.addCleanup(revision_tree.unlock)
2061
2063
build_tree(revision_tree, target, source)
2062
self.assertEqual(['file1-id'], calls)
2064
self.assertEqual([b'file1-id'], calls)
2063
2065
target.lock_read()
2064
2066
self.addCleanup(target.unlock)
2065
2067
self.assertEqual([], list(target.iter_changes(revision_tree)))
2066
2068
2067
2069
def test_build_tree_accelerator_tree_observes_sha1(self):
2068
2070
source = self.create_ab_tree()
2069
sha1 = osutils.sha_string('A')
2071
sha1 = osutils.sha_string(b'A')
2070
2072
target = self.make_branch_and_tree('target')
2071
2073
target.lock_write()
2072
2074
self.addCleanup(target.unlock)
2073
2075
state = target.current_dirstate()
2074
2076
state._cutoff_time = time.time() + 60
2075
2077
build_tree(source.basis_tree(), target, source)
2076
entry = state._get_entry(0, path_utf8='file1')
2078
entry = state._get_entry(0, path_utf8=b'file1')
2077
2079
self.assertEqual(sha1, entry[1][0][1])
2078
2080
2079
2081
def test_build_tree_accelerator_tree_missing_file(self):
2186
2188
filters._reset_registry(original_registry)
2187
2189
self.addCleanup(restore_registry)
2188
2190
def rot13(chunks, context=None):
2189
return [''.join(chunks).encode('rot13')]
2191
return [b''.join(chunks).encode('rot13')]
2190
2192
rot13filter = filters.ContentFilter(rot13, rot13)
2191
2193
filters.filter_stacks_registry.register(
2192
2194
'rot13', {'yes': [rot13filter]}.get)
2206
2208
if it can).
2207
2209
"""
2208
2210
self.requireFeature(HardlinkFeature)
2209
self.install_rot13_content_filter('file1')
2211
self.install_rot13_content_filter(b'file1')
2210
2212
source = self.create_ab_tree()
2211
2213
target = self.make_branch_and_tree('target')
2212
2214
revision_tree = source.basis_tree()
2340
2342
2341
2343
def test_add_files(self):
2342
2344
branch, tt = self.get_branch_and_transform()
2343
tt.new_file('file', tt.root, b'contents', b'file-id')
2344
trans_id = tt.new_directory('dir', tt.root, 'dir-id')
2345
tt.new_file('file', tt.root, [b'contents'], b'file-id')
2346
trans_id = tt.new_directory('dir', tt.root, b'dir-id')
2345
2347
if SymlinkFeature.available():
2346
tt.new_symlink('symlink', trans_id, 'target', 'symlink-id')
2348
tt.new_symlink('symlink', trans_id, 'target', b'symlink-id')
2347
2349
rev = tt.commit(branch, 'message')
2348
2350
tree = branch.basis_tree()
2349
2351
self.assertEqual('file', tree.id2path(b'file-id'))
2355
2357
2356
2358
def test_add_unversioned(self):
2357
2359
branch, tt = self.get_branch_and_transform()
2358
tt.new_file('file', tt.root, b'contents')
2360
tt.new_file('file', tt.root, [b'contents'])
2359
2361
self.assertRaises(errors.StrictCommitFailed, tt.commit, branch,
2360
2362
'message', strict=True)
2361
2363
2362
2364
def test_modify_strict(self):
2363
2365
branch, tt = self.get_branch_and_transform()
2364
tt.new_file('file', tt.root, b'contents', b'file-id')
2366
tt.new_file('file', tt.root, [b'contents'], b'file-id')
2365
2367
tt.commit(branch, 'message', strict=True)
2366
2368
tt = TransformPreview(branch.basis_tree())
2367
2369
self.addCleanup(tt.finalize)
2368
trans_id = tt.trans_id_file_id('file-id')
2370
trans_id = tt.trans_id_file_id(b'file-id')
2369
2371
tt.delete_contents(trans_id)
2370
2372
tt.create_file([b'contents'], trans_id)
2371
2373
tt.commit(branch, 'message', strict=True)
2376
2378
In this case, we are adding a file without adding its parent.
2377
2379
"""
2378
2380
branch, tt = self.get_branch_and_transform()
2379
parent_id = tt.trans_id_file_id('parent-id')
2380
tt.new_file('file', parent_id, b'contents', b'file-id')
2381
parent_id = tt.trans_id_file_id(b'parent-id')
2382
tt.new_file('file', parent_id, [b'contents'], b'file-id')
2381
2383
self.assertRaises(errors.MalformedTransform, tt.commit, branch,
2382
2384
'message')
2383
2385
2389
2391
authors=['Author1 <author1@example.com>',
2390
2392
'Author2 <author2@example.com>',
2391
2393
])
2392
self.assertEqual('revid-1', rev_id)
2394
self.assertEqual(b'revid-1', rev_id)
2393
2395
revision = branch.repository.get_revision(rev_id)
2394
2396
self.assertEqual(1, revision.timestamp)
2395
2397
self.assertEqual(43201, revision.timezone)
2620
2622
def test_rename_in_limbo_rename_raises_after_rename(self):
2621
2623
tt, trans_id = self.create_transform_and_root_trans_id()
2622
2624
parent1 = tt.new_directory('parent1', tt.root)
2623
child1 = tt.new_file('child1', parent1, b'contents')
2625
child1 = tt.new_file('child1', parent1, [b'contents'])
2624
2626
parent2 = tt.new_directory('parent2', tt.root)
2625
2627
2626
2628
class FakeOSModule(object):
2640
2642
def test_rename_in_limbo_rename_raises_before_rename(self):
2641
2643
tt, trans_id = self.create_transform_and_root_trans_id()
2642
2644
parent1 = tt.new_directory('parent1', tt.root)
2643
child1 = tt.new_file('child1', parent1, b'contents')
2645
child1 = tt.new_file('child1', parent1, [b'contents'])
2644
2646
parent2 = tt.new_directory('parent2', tt.root)
2645
2647
2646
2648
class FakeOSModule(object):
2671
2673
def test_resolve_create_parent_for_versioned_file(self):
2672
2674
wt, tt = self.make_tt_with_versioned_dir()
2673
2675
dir_tid = tt.trans_id_tree_path('dir')
2674
file_tid = tt.new_file('file', dir_tid, b'Contents', file_id=b'file-id')
2676
file_tid = tt.new_file('file', dir_tid, [b'Contents'], file_id=b'file-id')
2675
2677
tt.delete_contents(dir_tid)
2676
2678
tt.unversion_file(dir_tid)
2677
2679
conflicts = resolve_conflicts(tt)
2682
2684
def test_non_versioned_file_create_conflict(self):
2683
2685
wt, tt = self.make_tt_with_versioned_dir()
2684
2686
dir_tid = tt.trans_id_tree_path('dir')
2685
tt.new_file('file', dir_tid, b'Contents')
2687
tt.new_file('file', dir_tid, [b'Contents'])
2686
2688
tt.delete_contents(dir_tid)
2687
2689
tt.unversion_file(dir_tid)
2688
2690
conflicts = resolve_conflicts(tt)
2692
2694
conflicts.pop())
2693
2695
2694
2696
2695
A_ENTRY = ('a-id', ('a', 'a'), True, (True, True),
2696
('TREE_ROOT', 'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2697
A_ENTRY = (b'a-id', ('a', 'a'), True, (True, True),
2698
(b'TREE_ROOT', b'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2697
2699
(False, False))
2698
ROOT_ENTRY = ('TREE_ROOT', ('', ''), False, (True, True), (None, None),
2700
ROOT_ENTRY = (b'TREE_ROOT', ('', ''), False, (True, True), (None, None),
2699
2701
('', ''), ('directory', 'directory'), (False, False))
2700
2702
2701
2703
2731
2733
revision_tree = self.create_tree()
2732
2734
preview = TransformPreview(revision_tree)
2733
2735
self.addCleanup(preview.finalize)
2734
preview.new_file('file2', preview.root, b'content B\n', b'file2-id')
2736
preview.new_file('file2', preview.root, [b'content B\n'], b'file2-id')
2735
2737
preview_tree = preview.get_preview_tree()
2736
2738
self.assertEqual(preview_tree.kind('file2'), 'file')
2737
self.assertEqual(
2738
preview_tree.get_file('file2', b'file2-id').read(), b'content B\n')
2739
with preview_tree.get_file('file2', b'file2-id') as f:
2740
self.assertEqual(f.read(), b'content B\n')
2739
2741
2740
2742
def test_diff_preview_tree(self):
2741
2743
revision_tree = self.create_tree()
2742
2744
preview = TransformPreview(revision_tree)
2743
2745
self.addCleanup(preview.finalize)
2744
preview.new_file('file2', preview.root, b'content B\n', b'file2-id')
2746
preview.new_file('file2', preview.root, [b'content B\n'], b'file2-id')
2745
2747
preview_tree = preview.get_preview_tree()
2746
2748
out = BytesIO()
2747
2749
show_diff_trees(revision_tree, preview_tree, out)
2754
2756
revision_tree = self.create_tree()
2755
2757
preview = TransformPreview(revision_tree)
2756
2758
self.addCleanup(preview.finalize)
2757
preview.new_file('a', preview.root, b'content 2')
2759
preview.new_file('a', preview.root, [b'content 2'])
2758
2760
resolve_conflicts(preview)
2759
trans_id = preview.trans_id_file_id('a-id')
2761
trans_id = preview.trans_id_file_id(b'a-id')
2760
2762
self.assertEqual('a.moved', preview.final_name(trans_id))
2761
2763
2762
2764
def get_tree_and_preview_tree(self):
2763
2765
revision_tree = self.create_tree()
2764
2766
preview = TransformPreview(revision_tree)
2765
2767
self.addCleanup(preview.finalize)
2766
a_trans_id = preview.trans_id_file_id('a-id')
2768
a_trans_id = preview.trans_id_file_id(b'a-id')
2767
2769
preview.delete_contents(a_trans_id)
2768
2770
preview.create_file([b'b content'], a_trans_id)
2769
2771
preview_tree = preview.get_preview_tree()
2772
2774
def test_iter_changes(self):
2773
2775
revision_tree, preview_tree = self.get_tree_and_preview_tree()
2774
2776
root = revision_tree.get_root_id()
2775
self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
2777
self.assertEqual([(b'a-id', ('a', 'a'), True, (True, True),
2776
2778
(root, root), ('a', 'a'), ('file', 'file'),
2777
2779
(False, False))],
2778
2780
list(preview_tree.iter_changes(revision_tree)))
2817
2819
revision_tree = self.create_tree()
2818
2820
preview = TransformPreview(revision_tree)
2819
2821
self.addCleanup(preview.finalize)
2820
preview.new_file('file', preview.root, b'contents', b'file-id')
2822
preview.new_file('file', preview.root, [b'contents'], b'file-id')
2821
2823
preview.new_directory('directory', preview.root, 'dir-id')
2822
2824
preview_tree = preview.get_preview_tree()
2823
2825
self.assertEqual('file', preview_tree.kind('file'))
2825
2827
2826
2828
def test_get_file_mtime(self):
2827
2829
preview = self.get_empty_preview()
2828
file_trans_id = preview.new_file('file', preview.root, b'contents',
2830
file_trans_id = preview.new_file('file', preview.root, [b'contents'],
2829
2831
b'file-id')
2830
2832
limbo_path = preview._limbo_name(file_trans_id)
2831
2833
preview_tree = preview.get_preview_tree()
2850
2852
work_tree.add('old', b'old-id')
2851
2853
preview = TransformPreview(work_tree)
2852
2854
self.addCleanup(preview.finalize)
2853
new_id = preview.new_file('name', preview.root, b'contents', b'new-id',
2855
new_id = preview.new_file('name', preview.root, [b'contents'], b'new-id',
2854
2856
'executable')
2855
2857
tree = preview.get_preview_tree()
2856
2858
self.assertEqual(len('old'), tree.get_file_size('old'))
2858
2860
2859
2861
def test_get_file(self):
2860
2862
preview = self.get_empty_preview()
2861
preview.new_file('file', preview.root, b'contents', b'file-id')
2863
preview.new_file('file', preview.root, [b'contents'], b'file-id')
2862
2864
preview_tree = preview.get_preview_tree()
2863
tree_file = preview_tree.get_file('file')
2864
try:
2865
self.assertEqual('contents', tree_file.read())
2866
finally:
2867
tree_file.close()
2865
with preview_tree.get_file('file') as tree_file:
2866
self.assertEqual(b'contents', tree_file.read())
2868
2867
2869
2868
def test_get_symlink_target(self):
2870
2869
self.requireFeature(SymlinkFeature)
2906
2905
preview = TransformPreview(tree)
2907
2906
self.addCleanup(preview.finalize)
2908
2907
preview.new_file('new', preview.trans_id_file_id(b'unchanged-id'),
2909
'contents', 'new-id')
2908
[b'contents'], b'new-id')
2910
2909
preview_tree = preview.get_preview_tree()
2911
2910
self.assertEqual(b'new-id', preview_tree.path2id('unchanged/new'))
2912
2911
2951
2950
def test_iter_entries_by_dir_new(self):
2952
2951
tree = self.make_branch_and_tree('tree')
2953
2952
tt = TreeTransform(tree)
2954
tt.new_file('new', tt.root, b'contents', b'new-id')
2953
tt.new_file('new', tt.root, [b'contents'], b'new-id')
2955
2954
self.assertMatchingIterEntries(tt)
2956
2955
2957
2956
def test_iter_entries_by_dir_deleted(self):
3011
3010
3012
3011
def test_file_content_summary_executable(self):
3013
3012
preview = self.get_empty_preview()
3014
path_id = preview.new_file('path', preview.root, b'contents', 'path-id')
3013
path_id = preview.new_file('path', preview.root, [b'contents'], b'path-id')
3015
3014
preview.set_executability(True, path_id)
3016
3015
summary = preview.get_preview_tree().path_content_summary('path')
3017
3016
self.assertEqual(4, len(summary))
3036
3035
3037
3036
def test_file_content_summary_non_exec(self):
3038
3037
preview = self.get_empty_preview()
3039
preview.new_file('path', preview.root, b'contents', 'path-id')
3038
preview.new_file('path', preview.root, [b'contents'], b'path-id')
3040
3039
summary = preview.get_preview_tree().path_content_summary('path')
3041
3040
self.assertEqual(4, len(summary))
3042
3041
self.assertEqual('file', summary[0])
3049
3048
3050
3049
def test_dir_content_summary(self):
3051
3050
preview = self.get_empty_preview()
3052
preview.new_directory('path', preview.root, 'path-id')
3051
preview.new_directory('path', preview.root, b'path-id')
3053
3052
summary = preview.get_preview_tree().path_content_summary('path')
3054
3053
self.assertEqual(('directory', None, None, None), summary)
3055
3054
3056
3055
def test_tree_content_summary(self):
3057
3056
preview = self.get_empty_preview()
3058
path = preview.new_directory('path', preview.root, 'path-id')
3057
path = preview.new_directory('path', preview.root, b'path-id')
3059
3058
preview.set_tree_reference('rev-1', path)
3060
3059
summary = preview.get_preview_tree().path_content_summary('path')
3061
3060
self.assertEqual(4, len(summary))
3074
3073
preview.create_file([b'a\nb\nc\n'], file_trans_id)
3075
3074
preview_tree = preview.get_preview_tree()
3076
3075
expected = [
3077
('one', 'a\n'),
3078
('me:', 'b\n'),
3079
('me:', 'c\n'),
3076
(b'one', b'a\n'),
3077
(b'me:', b'b\n'),
3078
(b'me:', b'c\n'),
3080
3079
]
3081
3080
annotation = preview_tree.annotate_iter('file', default_revision=b'me:')
3082
3081
self.assertEqual(expected, annotation)
3083
3082
3084
3083
def test_annotate_missing(self):
3085
3084
preview = self.get_empty_preview()
3086
preview.new_file('file', preview.root, b'a\nb\nc\n', 'file-id')
3085
preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
3087
3086
preview_tree = preview.get_preview_tree()
3088
3087
expected = [
3089
('me:', 'a\n'),
3090
('me:', 'b\n'),
3091
('me:', 'c\n'),
3088
(b'me:', b'a\n'),
3089
(b'me:', b'b\n'),
3090
(b'me:', b'c\n'),
3092
3091
]
3093
3092
annotation = preview_tree.annotate_iter('file', default_revision=b'me:')
3094
3093
self.assertEqual(expected, annotation)
3125
3124
3126
3125
def test_stored_kind(self):
3127
3126
preview = self.get_empty_preview()
3128
preview.new_file('file', preview.root, b'a\nb\nc\n', b'file-id')
3127
preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
3129
3128
preview_tree = preview.get_preview_tree()
3130
3129
self.assertEqual('file', preview_tree.stored_kind('file'))
3131
3130
3132
3131
def test_is_executable(self):
3133
3132
preview = self.get_empty_preview()
3134
preview.new_file('file', preview.root, b'a\nb\nc\n', b'file-id')
3133
preview.new_file('file', preview.root, [b'a\nb\nc\n'], b'file-id')
3135
3134
preview.set_executability(True, preview.trans_id_file_id(b'file-id'))
3136
3135
preview_tree = preview.get_preview_tree()
3137
3136
self.assertEqual(True, preview_tree.is_executable('file'))
3190
3189
3191
3190
def test_walkdirs(self):
3192
3191
preview = self.get_empty_preview()
3193
root = preview.new_directory('', ROOT_PARENT, 'tree-root')
3192
root = preview.new_directory('', ROOT_PARENT, b'tree-root')
3194
3193
# FIXME: new_directory should mark root.
3195
3194
preview.fixup_new_roots()
3196
3195
preview_tree = preview.get_preview_tree()
3197
file_trans_id = preview.new_file('a', preview.root, b'contents',
3196
file_trans_id = preview.new_file('a', preview.root, [b'contents'],
3198
3197
b'a-id')
3199
3198
expected = [(('', b'tree-root'),
3200
3199
[('a', 'a', 'file', None, b'a-id', 'file')])]
3207
3206
work_tree.add(['removed-file', 'not-removed-file'])
3208
3207
preview = TransformPreview(work_tree)
3209
3208
self.addCleanup(preview.finalize)
3210
preview.new_file('new-file', preview.root, b'contents')
3211
preview.new_file('new-versioned-file', preview.root, b'contents',
3209
preview.new_file('new-file', preview.root, [b'contents'])
3210
preview.new_file('new-versioned-file', preview.root, [b'contents'],
3212
3211
b'new-versioned-id')
3213
3212
tree = preview.get_preview_tree()
3214
3213
preview.unversion_file(preview.trans_id_tree_path('removed-file'))
3250
3249
tree.set_root_id(b'TREE_ROOT')
3251
3250
tt = TransformPreview(tree)
3252
3251
self.addCleanup(tt.finalize)
3253
tt.new_file('name', tt.root, b'content', b'file-id')
3252
tt.new_file('name', tt.root, [b'content'], b'file-id')
3254
3253
tree2 = self.make_branch_and_tree('tree2')
3255
3254
tree2.set_root_id(b'TREE_ROOT')
3256
3255
merger = Merger.from_uncommitted(tree2, tt.get_preview_tree(),
3281
3280
tt = TransformPreview(wt)
3282
3281
removed_id = tt.trans_id_tree_path('removed')
3283
3282
tt.delete_contents(removed_id)
3284
tt.new_file('new', tt.root, b'contents')
3283
tt.new_file('new', tt.root, [b'contents'])
3285
3284
modified_id = tt.trans_id_tree_path('modified')
3286
3285
tt.delete_contents(modified_id)
3287
3286
tt.create_file([b'modified-contents'], modified_id)
3297
3296
tree = self.make_branch_and_tree('tree')
3298
3297
preview = TransformPreview(tree)
3299
3298
self.addCleanup(preview.finalize)
3300
preview.new_file('foo', preview.root, b'bar', 'baz-id')
3299
preview.new_file('foo', preview.root, [b'bar'], b'baz-id')
3301
3300
preview_tree = preview.get_preview_tree()
3302
self.assertEqual(False, preview_tree.is_executable('tree/foo', 'baz-id'))
3301
self.assertEqual(False, preview_tree.is_executable('tree/foo', b'baz-id'))
3303
3302
self.assertEqual(False, preview_tree.is_executable('tree/foo'))
3304
3303
3305
3304
def test_commit_preview_tree(self):
3308
3307
tree.branch.lock_write()
3309
3308
self.addCleanup(tree.branch.unlock)
3310
3309
tt = TransformPreview(tree)
3311
tt.new_file('file', tt.root, b'contents', b'file_id')
3310
tt.new_file('file', tt.root, [b'contents'], b'file_id')
3312
3311
self.addCleanup(tt.finalize)
3313
3312
preview = tt.get_preview_tree()
3314
3313
preview.set_parent_ids([rev_id])
3326
3325
tt = TransformPreview(tree)
3327
3326
self.addCleanup(tt.finalize)
3328
3327
foo_id = tt.new_directory('', ROOT_PARENT)
3329
bar_id = tt.new_file(u'\u1234bar', foo_id, b'contents')
3328
bar_id = tt.new_file(u'\u1234bar', foo_id, [b'contents'])
3330
3329
limbo_path = tt._limbo_name(bar_id)
3331
self.assertEqual(limbo_path.encode('ascii', 'replace'), limbo_path)
3330
self.assertEqual(limbo_path, limbo_path)
3332
3331
3333
3332
3334
3333
class FakeSerializer(object):
3359
3358
@staticmethod
3360
3359
def default_attribs():
3361
3360
return {
3362
'_id_number': 1,
3363
'_new_name': {},
3364
'_new_parent': {},
3365
'_new_executability': {},
3366
'_new_id': {},
3367
'_tree_path_ids': {'': 'new-0'},
3368
'_removed_id': [],
3369
'_removed_contents': [],
3370
'_non_present_ids': {},
3361
b'_id_number': 1,
3362
b'_new_name': {},
3363
b'_new_parent': {},
3364
b'_new_executability': {},
3365
b'_new_id': {},
3366
b'_tree_path_ids': {b'': b'new-0'},
3367
b'_removed_id': [],
3368
b'_removed_contents': [],
3369
b'_non_present_ids': {},
3371
3370
}
3372
3371
3373
3372
def make_records(self, attribs, contents):
3378
3377
3379
3378
def creation_records(self):
3380
3379
attribs = self.default_attribs()
3381
attribs['_id_number'] = 3
3382
attribs['_new_name'] = {
3383
'new-1': u'foo\u1234'.encode('utf-8'), 'new-2': 'qux'}
3384
attribs['_new_id'] = {'new-1': 'baz', 'new-2': 'quxx'}
3385
attribs['_new_parent'] = {'new-1': 'new-0', 'new-2': 'new-0'}
3386
attribs['_new_executability'] = {'new-1': 1}
3380
attribs[b'_id_number'] = 3
3381
attribs[b'_new_name'] = {
3382
b'new-1': u'foo\u1234'.encode('utf-8'), b'new-2': b'qux'}
3383
attribs[b'_new_id'] = {b'new-1': b'baz', b'new-2': b'quxx'}
3384
attribs[b'_new_parent'] = {b'new-1': b'new-0', b'new-2': b'new-0'}
3385
attribs[b'_new_executability'] = {b'new-1': 1}
3387
3386
contents = [
3388
('new-1', 'file', 'i 1\nbar\n'),
3389
('new-2', 'directory', ''),
3387
('new-1', 'file', b'i 1\nbar\n'),
3388
('new-2', 'directory', b''),
3390
3389
]
3391
3390
return self.make_records(attribs, contents)
3392
3391
3393
3392
def test_serialize_creation(self):
3394
3393
tt = self.get_preview()
3395
tt.new_file(u'foo\u1234', tt.root, b'bar', 'baz', True)
3394
tt.new_file(u'foo\u1234', tt.root, [b'bar'], b'baz', True)
3396
3395
tt.new_directory('qux', tt.root, 'quxx')
3397
3396
self.assertSerializesTo(self.creation_records(), tt)
3398
3397
3477
3476
3478
3477
def missing_records(self):
3479
3478
attribs = self.default_attribs()
3480
attribs['_id_number'] = 2
3481
attribs['_non_present_ids'] = {
3482
'boo': 'new-1',}
3479
attribs[b'_id_number'] = 2
3480
attribs[b'_non_present_ids'] = {
3481
b'boo': b'new-1',}
3483
3482
return self.make_records(attribs, [])
3484
3483
3485
3484
def test_serialize_missing(self):
3486
3485
tt = self.get_preview()
3487
boo_trans_id = tt.trans_id_file_id('boo')
3486
boo_trans_id = tt.trans_id_file_id(b'boo')
3488
3487
self.assertSerializesTo(self.missing_records(), tt)
3489
3488
3490
3489
def test_deserialize_missing(self):
3491
3490
tt = self.get_preview()
3492
3491
tt.deserialize(iter(self.missing_records()))
3493
self.assertEqual({'boo': 'new-1'}, tt._non_present_ids)
3492
self.assertEqual({b'boo': b'new-1'}, tt._non_present_ids)
3494
3493
3495
3494
def make_modification_preview(self):
3496
3495
LINES_ONE = b'aa\nbb\ncc\ndd\n'
3513
3512
3514
3513
def test_serialize_modification(self):
3515
3514
tt, LINES = self.make_modification_preview()
3516
trans_id = tt.trans_id_file_id('file-id')
3515
trans_id = tt.trans_id_file_id(b'file-id')
3517
3516
tt.delete_contents(trans_id)
3518
3517
tt.create_file(LINES, trans_id)
3519
3518
self.assertSerializesTo(self.modification_records(), tt)
3524
3523
self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3525
3524
3526
3525
def make_kind_change_preview(self):
3527
LINES = 'a\nb\nc\nd\n'
3526
LINES = b'a\nb\nc\nd\n'
3528
3527
tree = self.make_branch_and_tree('tree')
3529
3528
self.build_tree(['tree/foo/'])
3530
3529
tree.add('foo', b'foo-id')
3532
3531
3533
3532
def kind_change_records(self):
3534
3533
attribs = self.default_attribs()
3535
attribs['_id_number'] = 2
3536
attribs['_tree_path_ids'] = {
3537
'foo': 'new-1',
3538
'': 'new-0',}
3539
attribs['_removed_contents'] = ['new-1']
3534
attribs[b'_id_number'] = 2
3535
attribs[b'_tree_path_ids'] = {
3536
b'foo': b'new-1',
3537
b'': b'new-0',}
3538
attribs[b'_removed_contents'] = [b'new-1']
3540
3539
contents = [('new-1', 'file',
3541
'i 4\na\nb\nc\nd\n\n')]
3540
b'i 4\na\nb\nc\nd\n\n')]
3542
3541
return self.make_records(attribs, contents)
3543
3542
3544
3543
def test_serialize_kind_change(self):
3554
3553
self.assertFileEqual(LINES, tt._limbo_name('new-1'))
3555
3554
3556
3555
def make_add_contents_preview(self):
3557
LINES = 'a\nb\nc\nd\n'
3556
LINES = b'a\nb\nc\nd\n'
3558
3557
tree = self.make_branch_and_tree('tree')
3559
3558
self.build_tree(['tree/foo'])
3560
3559
tree.add('foo')
3563
3562
3564
3563
def add_contents_records(self):
3565
3564
attribs = self.default_attribs()
3566
attribs['_id_number'] = 2
3567
attribs['_tree_path_ids'] = {
3568
'foo': 'new-1',
3569
'': 'new-0',}
3565
attribs[b'_id_number'] = 2
3566
attribs[b'_tree_path_ids'] = {
3567
b'foo': b'new-1',
3568
b'': b'new-0',}
3570
3569
contents = [('new-1', 'file',
3571
'i 4\na\nb\nc\nd\n\n')]
3570
b'i 4\na\nb\nc\nd\n\n')]
3572
3571
return self.make_records(attribs, contents)
3573
3572
3574
3573
def test_serialize_add_contents(self):
3575
3574
tt, LINES = self.make_add_contents_preview()
3576
3575
trans_id = tt.trans_id_tree_path('foo')
3577
tt.create_file(LINES, trans_id)
3576
tt.create_file([LINES], trans_id)
3578
3577
self.assertSerializesTo(self.add_contents_records(), tt)
3579
3578
3580
3579
def test_deserialize_add_contents(self):
3590
3589
tree.add('file', b'file-id')
3591
3590
tt = self.get_preview(tree)
3592
3591
trans_id = tt.trans_id_tree_path('file')
3593
self.assertEqual((['aa\n', 'bb\n', 'cc\n', 'dd\n'],),
3592
self.assertEqual(([b'aa\n', b'bb\n', b'cc\n', b'dd\n'],),
3594
3593
tt._get_parents_lines(trans_id))
3595
3594
3596
3595
def test_get_parents_texts(self):
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0