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 6989.3.5
- compare with another revision
- compare with revision 1663
- download diff
- download tarball
- view history from revision 6989.3.5
- Committer: Jelmer Vernooij
- Date: 2018-06-30 14:28:33 UTC
- mfrom: (7005 work)
- mto: This revision was merged to the branch mainline in revision 7008.
- Revision ID: jelmer@jelmer.uk-20180630142833-eg208wfe8la76m0x
Merge trunk.
- files added:
- tools/testr-run.py
- files modified:
- .testr.conf
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()
383
384
self.assertRaises(ReusingTransform, transform.find_conflicts)
384
self.assertEqual('contents', file(self.wt.abspath('name')).read())
385
with open(self.wt.abspath('name'), 'r') as f:
386
self.assertEqual('contents', f.read())
385
387
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
386
388
self.assertIs(self.wt.is_executable('name'), True)
387
self.assertEqual(self.wt.path2id('oz'), 'oz-id')
388
self.assertEqual(self.wt.path2id('oz/dorothy'), 'dorothy-id')
389
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')
390
392
391
self.assertEqual('toto-contents',
393
self.assertEqual(b'toto-contents',
392
394
self.wt.get_file('oz/dorothy/toto').read())
393
395
self.assertIs(self.wt.is_executable('oz/dorothy/toto'), False)
394
396
405
407
406
408
def test_conflicts(self):
407
409
transform, root = self.get_transform()
408
trans_id = transform.new_file('name', root, b'contents',
409
'my_pretties')
410
trans_id = transform.new_file('name', root, [b'contents'],
411
b'my_pretties')
410
412
self.assertEqual(len(transform.find_conflicts()), 0)
411
trans_id2 = transform.new_file('name', root, b'Crontents', 'toto')
413
trans_id2 = transform.new_file('name', root, [b'Crontents'], b'toto')
412
414
self.assertEqual(transform.find_conflicts(),
413
415
[('duplicate', trans_id, trans_id2, 'name')])
414
416
self.assertRaises(MalformedTransform, transform.apply)
445
447
transform.set_executability(True, oz_id)
446
448
self.assertEqual(transform.find_conflicts(),
447
449
[('unversioned executability', oz_id)])
448
transform.version_file('oz-id', oz_id)
450
transform.version_file(b'oz-id', oz_id)
449
451
self.assertEqual(transform.find_conflicts(),
450
452
[('non-file executability', oz_id)])
451
453
transform.set_executability(None, oz_id)
452
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')
453
455
transform.apply()
454
self.assertEqual(self.wt.path2id('name'), 'my_pretties')
455
self.assertEqual('contents', file(self.wt.abspath('name')).read())
456
self.assertEqual(self.wt.path2id('name'), b'my_pretties')
457
with open(self.wt.abspath('name'), 'r') as f:
458
self.assertEqual(b'contents', f.read())
456
459
transform2, root = self.get_transform()
457
460
oz_id = transform2.trans_id_tree_path('oz')
458
newtip = transform2.new_file('tip', oz_id, b'other', 'tip-id')
461
newtip = transform2.new_file('tip', oz_id, [b'other'], b'tip-id')
459
462
result = transform2.find_conflicts()
460
463
fp = FinalPaths(transform2)
461
464
self.assertTrue('oz/tip' in transform2._tree_path_ids)
485
488
tree.case_sensitive = True
486
489
transform = TreeTransform(tree)
487
490
self.addCleanup(transform.finalize)
488
transform.new_file('file', transform.root, b'content')
489
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'])
490
493
result = transform.find_conflicts()
491
494
self.assertEqual([], result)
492
495
transform.finalize()
495
498
tree.case_sensitive = False
496
499
transform = TreeTransform(tree)
497
500
self.addCleanup(transform.finalize)
498
transform.new_file('file', transform.root, b'content')
499
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'])
500
503
result = transform.find_conflicts()
501
504
self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
502
505
509
512
tree.case_sensitive = True
510
513
transform = TreeTransform(tree)
511
514
self.addCleanup(transform.finalize)
512
transform.new_file('file', transform.root, b'content')
515
transform.new_file('file', transform.root, [b'content'])
513
516
result = transform.find_conflicts()
514
517
self.assertEqual([], result)
515
518
transform.finalize()
518
521
tree.case_sensitive = False
519
522
transform = TreeTransform(tree)
520
523
self.addCleanup(transform.finalize)
521
transform.new_file('file', transform.root, b'content')
524
transform.new_file('file', transform.root, [b'content'])
522
525
result = transform.find_conflicts()
523
526
self.assertEqual([('duplicate', 'new-1', 'new-2', 'file')], result)
524
527
530
533
tree.case_sensitive = False
531
534
transform = TreeTransform(tree)
532
535
self.addCleanup(transform.finalize)
533
transform.new_file('file', transform.root, b'content')
534
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'])
535
538
resolve_conflicts(transform)
536
539
transform.apply()
537
540
self.assertPathExists('tree/file')
545
548
tree.case_sensitive = False
546
549
transform = TreeTransform(tree)
547
550
self.addCleanup(transform.finalize)
548
transform.new_file('file', transform.root, b'content')
549
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'])
550
553
resolve_conflicts(transform,
551
554
pass_func=lambda t, c: resolve_checkout(t, c, []))
552
555
transform.apply()
558
561
tree = self.make_branch_and_tree('tree')
559
562
transform = TreeTransform(tree)
560
563
self.addCleanup(transform.finalize)
561
transform.new_file('file', transform.root, b'content')
562
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'])
563
566
dir = transform.new_directory('dir', transform.root)
564
transform.new_file('dirfile', dir, b'content')
565
transform.new_file('dirFiLe', dir, b'content')
567
transform.new_file('dirfile', dir, [b'content'])
568
transform.new_file('dirFiLe', dir, [b'content'])
566
569
resolve_conflicts(transform)
567
570
transform.apply()
568
571
self.assertPathExists('tree/file')
580
583
transform = TreeTransform(tree)
581
584
self.addCleanup(transform.finalize)
582
585
dir = transform.new_directory('dir', transform.root)
583
first = transform.new_file('file', dir, b'content')
584
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'])
585
588
self.assertContainsRe(transform._limbo_name(first), 'new-1/file')
586
589
self.assertNotContainsRe(transform._limbo_name(second), 'new-1/FiLe')
587
590
609
612
def test_unversioning(self):
610
613
create_tree, root = self.get_transform()
611
614
parent_id = create_tree.new_directory('parent', root, b'parent-id')
612
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')
613
616
create_tree.apply()
614
617
unversion = TreeTransform(self.wt)
615
618
self.addCleanup(unversion.finalize)
625
628
create_tree, root = self.get_transform()
626
629
# prepare tree
627
630
root = create_tree.root
628
create_tree.new_file('name1', root, b'hello1', 'name1')
629
create_tree.new_file('name2', root, b'hello2', 'name2')
630
ddir = create_tree.new_directory('dying_directory', root, 'ddir')
631
create_tree.new_file('dying_file', ddir, b'goodbye1', 'dfile')
632
create_tree.new_file('moving_file', ddir, b'later1', 'mfile')
633
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')
634
637
create_tree.apply()
635
638
636
639
mangle_tree, root = self.get_transform()
654
657
newdir = mangle_tree.new_directory('new_directory', root, 'newdir')
655
658
mfile2 = mangle_tree.trans_id_tree_path('moving_file2')
656
659
mangle_tree.adjust_path('mfile2', newdir, mfile2)
657
mangle_tree.new_file('newfile', newdir, b'hello3', 'dfile')
658
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')
659
662
self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
660
self.assertEqual(mangle_tree.final_file_id(mfile2), 'mfile2')
663
self.assertEqual(mangle_tree.final_file_id(mfile2), b'mfile2')
661
664
mangle_tree.apply()
662
self.assertEqual(file(self.wt.abspath('name1')).read(), 'hello2')
663
self.assertEqual(file(self.wt.abspath('name2')).read(), 'hello1')
665
with open(self.wt.abspath('name1'), 'r') as f:
666
self.assertEqual(f.read(), 'hello2')
667
with open(self.wt.abspath('name2'), 'r') as f:
668
self.assertEqual(f.read(), 'hello1')
664
669
mfile2_path = self.wt.abspath(pathjoin('new_directory', 'mfile2'))
665
670
self.assertEqual(mangle_tree.final_parent(mfile2), newdir)
666
self.assertEqual(file(mfile2_path).read(), 'later2')
671
with open(mfile2_path, 'r') as f:
672
self.assertEqual(f.read(), 'later2')
667
673
self.assertEqual(self.wt.id2path(b'mfile2'), 'new_directory/mfile2')
668
674
self.assertEqual(self.wt.path2id('new_directory/mfile2'), b'mfile2')
669
675
newfile_path = self.wt.abspath(pathjoin('new_directory', 'newfile'))
670
self.assertEqual(file(newfile_path).read(), 'hello3')
676
with open(newfile_path, 'r') as f:
677
self.assertEqual(f.read(), 'hello3')
671
678
self.assertEqual(self.wt.path2id('dying_directory'), b'ddir')
672
679
self.assertIs(self.wt.path2id('dying_directory/dying_file'), None)
673
680
mfile2_path = self.wt.abspath(pathjoin('new_directory', 'mfile2'))
674
681
675
682
def test_both_rename(self):
676
683
create_tree, root = self.get_transform()
677
newdir = create_tree.new_directory('selftest', root, 'selftest-id')
678
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')
679
686
create_tree.apply()
680
687
mangle_tree, root = self.get_transform()
681
688
selftest = mangle_tree.trans_id_tree_path('selftest')
690
697
breezy = create_tree.new_directory('breezy', root, 'breezy-id')
691
698
tests = create_tree.new_directory('tests', breezy, 'tests-id')
692
699
blackbox = create_tree.new_directory('blackbox', tests, 'blackbox-id')
693
create_tree.new_file('test_too_much.py', blackbox, b'hello1',
694
'test_too_much-id')
700
create_tree.new_file('test_too_much.py', blackbox, [b'hello1'],
701
b'test_too_much-id')
695
702
create_tree.apply()
696
703
mangle_tree, root = self.get_transform()
697
704
breezy = mangle_tree.trans_id_tree_path('breezy')
704
711
705
712
def test_both_rename3(self):
706
713
create_tree, root = self.get_transform()
707
tests = create_tree.new_directory('tests', root, 'tests-id')
708
create_tree.new_file('test_too_much.py', tests, b'hello1',
709
'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')
710
717
create_tree.apply()
711
718
mangle_tree, root = self.get_transform()
712
719
tests = mangle_tree.trans_id_tree_path('tests')
720
727
create_tree, root = self.get_transform()
721
728
# prepare tree
722
729
root = create_tree.root
723
create_tree.new_file('name1', root, b'hello1', 'name1')
730
create_tree.new_file('name1', root, [b'hello1'], b'name1')
724
731
create_tree.apply()
725
732
delete_contents, root = self.get_transform()
726
file = delete_contents.trans_id_tree_path('name1')
733
file = delete_contents.trans_id_tree_path(b'name1')
727
734
delete_contents.delete_contents(file)
728
735
delete_contents.apply()
729
736
move_id, root = self.get_transform()
736
743
create_tree, root = self.get_transform()
737
744
# prepare tree
738
745
root = create_tree.root
739
create_tree.new_file('name1', root, b'hello1', 'name1')
746
create_tree.new_file('name1', root, [b'hello1'], 'name1')
740
747
create_tree.apply()
741
748
delete_contents = TreeTransform(self.wt)
742
749
self.addCleanup(delete_contents.finalize)
746
753
delete_contents.finalize()
747
754
replace = TreeTransform(self.wt)
748
755
self.addCleanup(replace.finalize)
749
name2 = replace.new_file('name2', root, b'hello2', 'name1')
756
name2 = replace.new_file('name2', root, [b'hello2'], 'name1')
750
757
conflicts = replace.find_conflicts()
751
758
name1 = replace.trans_id_tree_path('name1')
752
759
self.assertEqual(conflicts, [('duplicate id', name1, name2)])
760
767
761
768
self.requireFeature(SymlinkFeature)
762
769
transform, root = self.get_transform()
763
oz_id = transform.new_directory('oz', root, 'oz-id')
770
oz_id = transform.new_directory('oz', root, b'oz-id')
764
771
wizard = transform.new_symlink(link_name1, oz_id, link_target1,
765
'wizard-id')
772
b'wizard-id')
766
773
wiz_id = transform.create_path(link_name2, oz_id)
767
774
transform.create_symlink(link_target2, wiz_id)
768
transform.version_file('wiz-id2', wiz_id)
775
transform.version_file(b'wiz-id2', wiz_id)
769
776
transform.set_executability(True, wiz_id)
770
777
self.assertEqual(transform.find_conflicts(),
771
778
[('non-file executability', wiz_id)])
772
779
transform.set_executability(None, wiz_id)
773
780
transform.apply()
774
self.assertEqual(self.wt.path2id(ozpath(link_name1)), 'wizard-id')
781
self.assertEqual(self.wt.path2id(ozpath(link_name1)), b'wizard-id')
775
782
self.assertEqual('symlink',
776
783
file_kind(self.wt.abspath(ozpath(link_name1))))
777
784
self.assertEqual(link_target2,
812
819
813
820
def get_conflicted(self):
814
821
create, root = self.get_transform()
815
create.new_file('dorothy', root, b'dorothy', 'dorothy-id')
816
oz = create.new_directory('oz', root, 'oz-id')
817
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')
818
825
create.apply()
819
826
conflicts, root = self.get_transform()
820
827
# set up duplicate entry, duplicate id
821
new_dorothy = conflicts.new_file('dorothy', root, b'dorothy',
822
'dorothy-id')
828
new_dorothy = conflicts.new_file('dorothy', root, [b'dorothy'],
829
b'dorothy-id')
823
830
old_dorothy = conflicts.trans_id_tree_path('dorothy')
824
831
oz = conflicts.trans_id_tree_path('oz')
825
832
# set up DeletedParent parent conflict
826
833
conflicts.delete_versioned(oz)
827
834
emerald = conflicts.trans_id_tree_path('oz/emeraldcity')
828
835
# set up MissingParent conflict
829
munchkincity = conflicts.trans_id_file_id('munchkincity-id')
836
munchkincity = conflicts.trans_id_file_id(b'munchkincity-id')
830
837
conflicts.adjust_path('munchkincity', root, munchkincity)
831
conflicts.new_directory('auntem', munchkincity, 'auntem-id')
838
conflicts.new_directory('auntem', munchkincity, b'auntem-id')
832
839
# set up parent loop
833
840
conflicts.adjust_path('emeraldcity', emerald, emerald)
834
841
return conflicts, emerald, oz, old_dorothy, new_dorothy
849
856
raw_conflicts = resolve_conflicts(tt)
850
857
cooked_conflicts = cook_conflicts(raw_conflicts, tt)
851
858
duplicate = DuplicateEntry('Moved existing file to', 'dorothy.moved',
852
'dorothy', None, 'dorothy-id')
859
'dorothy', None, b'dorothy-id')
853
860
self.assertEqual(cooked_conflicts[0], duplicate)
854
861
duplicate_id = DuplicateID('Unversioned existing file',
855
862
'dorothy.moved', 'dorothy', None,
856
'dorothy-id')
863
b'dorothy-id')
857
864
self.assertEqual(cooked_conflicts[1], duplicate_id)
858
865
missing_parent = MissingParent('Created directory', 'munchkincity',
859
'munchkincity-id')
860
deleted_parent = DeletingParent('Not deleting', 'oz', 'oz-id')
866
b'munchkincity-id')
867
deleted_parent = DeletingParent('Not deleting', 'oz', b'oz-id')
861
868
self.assertEqual(cooked_conflicts[2], missing_parent)
862
869
unversioned_parent = UnversionedParent('Versioned directory',
863
870
'munchkincity',
864
'munchkincity-id')
871
b'munchkincity-id')
865
872
unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
866
'oz-id')
873
b'oz-id')
867
874
self.assertEqual(cooked_conflicts[3], unversioned_parent)
868
875
parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity',
869
'oz/emeraldcity', 'emerald-id', 'emerald-id')
876
'oz/emeraldcity', b'emerald-id', b'emerald-id')
870
877
self.assertEqual(cooked_conflicts[4], deleted_parent)
871
878
self.assertEqual(cooked_conflicts[5], unversioned_parent2)
872
879
self.assertEqual(cooked_conflicts[6], parent_loop)
901
908
902
909
def prepare_wrong_parent_kind(self):
903
910
tt, root = self.get_transform()
904
tt.new_file('parent', root, b'contents', b'parent-id')
911
tt.new_file('parent', root, [b'contents'], b'parent-id')
905
912
tt.apply()
906
913
tt, root = self.get_transform()
907
parent_id = tt.trans_id_file_id('parent-id')
908
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')
909
916
return tt
910
917
911
918
def test_find_conflicts_wrong_parent_kind(self):
927
934
def test_resolve_conflicts_wrong_new_parent_kind(self):
928
935
tt, root = self.get_transform()
929
936
parent_id = tt.new_directory('parent', root, b'parent-id')
930
tt.new_file('child,', parent_id, b'contents2', b'file-id')
937
tt.new_file('child,', parent_id, [b'contents2'], b'file-id')
931
938
tt.apply()
932
939
tt, root = self.get_transform()
933
parent_id = tt.trans_id_file_id('parent-id')
940
parent_id = tt.trans_id_file_id(b'parent-id')
934
941
tt.delete_contents(parent_id)
935
942
tt.create_file([b'contents'], parent_id)
936
943
raw_conflicts = resolve_conflicts(tt)
938
945
'new-3')}, raw_conflicts)
939
946
tt.apply()
940
947
self.assertFalse(self.wt.is_versioned('parent'))
941
self.assertEqual('parent-id', self.wt.path2id('parent.new'))
948
self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
942
949
943
950
def test_resolve_conflicts_wrong_parent_kind_unversioned(self):
944
951
tt, root = self.get_transform()
945
952
parent_id = tt.new_directory('parent', root)
946
tt.new_file('child,', parent_id, b'contents2')
953
tt.new_file('child,', parent_id, [b'contents2'])
947
954
tt.apply()
948
955
tt, root = self.get_transform()
949
956
parent_id = tt.trans_id_tree_path('parent')
958
965
wt = self.make_branch_and_tree('.')
959
966
tt = TreeTransform(wt)
960
967
self.addCleanup(tt.finalize)
961
parent = tt.trans_id_file_id('parent-id')
962
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'])
963
970
raw_conflicts = resolve_conflicts(tt)
964
971
# Since the directory doesn't exist it's seen as 'missing'. So
965
972
# 'resolve_conflicts' create a conflict asking for it to be created.
983
990
984
991
def test_moving_root(self):
985
992
create, root = self.get_transform()
986
fun = create.new_directory('fun', root, 'fun-id')
987
create.new_directory('sun', root, 'sun-id')
988
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')
989
996
create.apply()
990
997
transform, root = self.get_transform()
991
998
transform.adjust_root_path('oldroot', fun)
992
999
new_root = transform.trans_id_tree_path('')
993
transform.version_file('new-root', new_root)
1000
transform.version_file(b'new-root', new_root)
994
1001
transform.apply()
995
1002
996
1003
def test_renames(self):
997
1004
create, root = self.get_transform()
998
old = create.new_directory('old-parent', root, 'old-id')
999
intermediate = create.new_directory('intermediate', old, 'im-id')
1000
myfile = create.new_file('myfile', intermediate, b'myfile-text',
1001
'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')
1002
1009
create.apply()
1003
1010
rename, root = self.get_transform()
1004
old = rename.trans_id_file_id('old-id')
1011
old = rename.trans_id_file_id(b'old-id')
1005
1012
rename.adjust_path('new', root, old)
1006
myfile = rename.trans_id_file_id('myfile-id')
1013
myfile = rename.trans_id_file_id(b'myfile-id')
1007
1014
rename.set_executability(True, myfile)
1008
1015
rename.apply()
1009
1016
1011
1018
self.requireFeature(features.not_running_as_root)
1012
1019
# see https://bugs.launchpad.net/bzr/+bug/491763
1013
1020
create, root_id = self.get_transform()
1014
first_dir = create.new_directory('first-dir', root_id, 'first-id')
1015
myfile = create.new_file('myfile', root_id, b'myfile-text',
1016
'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')
1017
1024
create.apply()
1018
1025
if os.name == "posix" and sys.platform != "cygwin":
1019
1026
# posix filesystems fail on renaming if the readonly bit is set
1020
1027
osutils.make_readonly(self.wt.abspath('first-dir'))
1021
1028
elif os.name == "nt":
1022
1029
# windows filesystems fail on renaming open files
1023
self.addCleanup(file(self.wt.abspath('myfile')).close)
1030
self.addCleanup(open(self.wt.abspath('myfile')).close)
1024
1031
else:
1025
1032
self.skipTest("Can't force a permissions error on rename")
1026
1033
# now transform to rename
1027
1034
rename_transform, root_id = self.get_transform()
1028
file_trans_id = rename_transform.trans_id_file_id('myfile-id')
1029
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')
1030
1037
rename_transform.adjust_path('newname', dir_id, file_trans_id)
1031
1038
e = self.assertRaises(errors.TransformRenameFailed,
1032
1039
rename_transform.apply)
1058
1065
wt = transform._tree
1059
1066
wt.lock_read()
1060
1067
self.addCleanup(wt.unlock)
1061
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',
1062
1069
True)
1063
1070
sac = transform.new_file('set_after_creation', root,
1064
'Set after creation', 'sac')
1071
[b'Set after creation'], 'sac')
1065
1072
transform.set_executability(True, sac)
1066
uws = transform.new_file('unset_without_set', root, b'Unset badly',
1073
uws = transform.new_file('unset_without_set', root, [b'Unset badly'],
1067
1074
'uws')
1068
1075
self.assertRaises(KeyError, transform.set_executability, None, uws)
1069
1076
transform.apply()
1075
1082
if sys.platform == 'win32':
1076
1083
raise TestSkipped('chmod has no effect on win32')
1077
1084
transform, root = self.get_transform()
1078
transform.new_file('file1', root, b'contents', b'file1-id', True)
1085
transform.new_file('file1', root, [b'contents'], b'file1-id', True)
1079
1086
transform.apply()
1080
1087
self.wt.lock_write()
1081
1088
self.addCleanup(self.wt.unlock)
1100
1107
1101
1108
transform, root = self.get_transform()
1102
1109
1103
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'],
1104
1111
file_id=b'bar-id-1', executable=False)
1105
1112
transform.apply()
1106
1113
1120
1127
def test_iter_changes(self):
1121
1128
self.wt.set_root_id(b'eert_toor')
1122
1129
transform, root = self.get_transform()
1123
transform.new_file('old', root, b'blah', b'id-1', True)
1130
transform.new_file('old', root, [b'blah'], b'id-1', True)
1124
1131
transform.apply()
1125
1132
transform, root = self.get_transform()
1126
1133
try:
1127
1134
self.assertEqual([], list(transform.iter_changes()))
1128
1135
old = transform.trans_id_tree_path('old')
1129
1136
transform.unversion_file(old)
1130
self.assertEqual([('id-1', ('old', None), False, (True, False),
1131
('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'),
1132
1139
(True, True))], list(transform.iter_changes()))
1133
transform.new_directory('new', root, 'id-1')
1134
self.assertEqual([('id-1', ('old', 'new'), True, (True, True),
1135
('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'),
1136
1143
('file', 'directory'),
1137
1144
(True, False))], list(transform.iter_changes()))
1138
1145
finally:
1141
1148
def test_iter_changes_new(self):
1142
1149
self.wt.set_root_id(b'eert_toor')
1143
1150
transform, root = self.get_transform()
1144
transform.new_file('old', root, b'blah')
1151
transform.new_file('old', root, [b'blah'])
1145
1152
transform.apply()
1146
1153
transform, root = self.get_transform()
1147
1154
try:
1148
1155
old = transform.trans_id_tree_path('old')
1149
transform.version_file('id-1', old)
1150
self.assertEqual([('id-1', (None, 'old'), False, (False, True),
1151
('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'),
1152
1159
(False, False))], list(transform.iter_changes()))
1153
1160
finally:
1154
1161
transform.finalize()
1156
1163
def test_iter_changes_modifications(self):
1157
1164
self.wt.set_root_id(b'eert_toor')
1158
1165
transform, root = self.get_transform()
1159
transform.new_file('old', root, b'blah', 'id-1')
1160
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'])
1161
1168
transform.new_directory('subdir', root, 'subdir-id')
1162
1169
transform.apply()
1163
1170
transform, root = self.get_transform()
1169
1176
1170
1177
#content deletion
1171
1178
transform.delete_contents(old)
1172
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1173
('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),
1174
1181
(False, False))], list(transform.iter_changes()))
1175
1182
1176
1183
#content change
1177
1184
transform.create_file([b'blah'], old)
1178
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1179
('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'),
1180
1187
(False, False))], list(transform.iter_changes()))
1181
1188
transform.cancel_deletion(old)
1182
1189
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1183
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1190
(b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1184
1191
(False, False))], list(transform.iter_changes()))
1185
1192
transform.cancel_creation(old)
1186
1193
1187
1194
# move file_id to a different file
1188
1195
self.assertEqual([], list(transform.iter_changes()))
1189
1196
transform.unversion_file(old)
1190
transform.version_file('id-1', new)
1197
transform.version_file(b'id-1', new)
1191
1198
transform.adjust_path('old', root, new)
1192
self.assertEqual([('id-1', ('old', 'old'), True, (True, True),
1199
self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1193
1200
('eert_toor', 'eert_toor'), ('old', 'old'), ('file', 'file'),
1194
1201
(False, False))], list(transform.iter_changes()))
1195
1202
transform.cancel_versioning(new)
1198
1205
#execute bit
1199
1206
self.assertEqual([], list(transform.iter_changes()))
1200
1207
transform.set_executability(True, old)
1201
self.assertEqual([('id-1', ('old', 'old'), False, (True, True),
1202
('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'),
1203
1210
(False, True))], list(transform.iter_changes()))
1204
1211
transform.set_executability(None, old)
1205
1212
1207
1214
self.assertEqual([], list(transform.iter_changes()))
1208
1215
transform.adjust_path('new', root, old)
1209
1216
transform._new_parent = {}
1210
self.assertEqual([('id-1', ('old', 'new'), False, (True, True),
1211
('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'),
1212
1219
(False, False))], list(transform.iter_changes()))
1213
1220
transform._new_name = {}
1214
1221
1216
1223
self.assertEqual([], list(transform.iter_changes()))
1217
1224
transform.adjust_path('new', subdir, old)
1218
1225
transform._new_name = {}
1219
self.assertEqual([('id-1', ('old', 'subdir/old'), False,
1220
(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'),
1221
1228
('file', 'file'), (False, False))],
1222
1229
list(transform.iter_changes()))
1223
1230
transform._new_path = {}
1233
1240
# obviously can't bleed into file2's change output. But for now, it
1234
1241
# works.
1235
1242
transform, root = self.get_transform()
1236
transform.new_file('file1', root, b'blah', 'id-1')
1237
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')
1238
1245
transform.apply()
1239
1246
transform, root = self.get_transform()
1240
1247
try:
1241
transform.delete_contents(transform.trans_id_file_id('id-1'))
1248
transform.delete_contents(transform.trans_id_file_id(b'id-1'))
1242
1249
transform.set_executability(True,
1243
transform.trans_id_file_id('id-2'))
1244
self.assertEqual([('id-1', (u'file1', u'file1'), True, (True, True),
1245
('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'),
1246
1253
('file', None), (False, False)),
1247
('id-2', (u'file2', u'file2'), False, (True, True),
1248
('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'),
1249
1256
('file', 'file'), (False, True))],
1250
1257
list(transform.iter_changes()))
1251
1258
finally:
1256
1263
self.wt.set_root_id(b'toor_eert')
1257
1264
# Need two steps because versioning a non-existant file is a conflict.
1258
1265
transform, root = self.get_transform()
1259
transform.new_directory('floater', root, 'floater-id')
1266
transform.new_directory('floater', root, b'floater-id')
1260
1267
transform.apply()
1261
1268
transform, root = self.get_transform()
1262
1269
transform.delete_contents(transform.trans_id_tree_path('floater'))
1265
1272
floater = transform.trans_id_tree_path('floater')
1266
1273
try:
1267
1274
transform.adjust_path('flitter', root, floater)
1268
self.assertEqual([('floater-id', ('floater', 'flitter'), False,
1275
self.assertEqual([(b'floater-id', ('floater', 'flitter'), False,
1269
1276
(True, True), ('toor_eert', 'toor_eert'), ('floater', 'flitter'),
1270
1277
(None, None), (False, False))], list(transform.iter_changes()))
1271
1278
finally:
1275
1282
"""Ensure that no-ops are not treated as modifications"""
1276
1283
self.wt.set_root_id(b'eert_toor')
1277
1284
transform, root = self.get_transform()
1278
transform.new_file('old', root, b'blah', b'id-1')
1285
transform.new_file('old', root, [b'blah'], b'id-1')
1279
1286
transform.new_directory('subdir', root, b'subdir-id')
1280
1287
transform.apply()
1281
1288
transform, root = self.get_transform()
1287
1294
transform.create_directory(subdir)
1288
1295
transform.set_executability(False, old)
1289
1296
transform.unversion_file(old)
1290
transform.version_file('id-1', old)
1297
transform.version_file(b'id-1', old)
1291
1298
transform.adjust_path('old', root, old)
1292
1299
self.assertEqual([], list(transform.iter_changes()))
1293
1300
finally:
1295
1302
1296
1303
def test_rename_count(self):
1297
1304
transform, root = self.get_transform()
1298
transform.new_file('name1', root, b'contents')
1305
transform.new_file('name1', root, [b'contents'])
1299
1306
self.assertEqual(transform.rename_count, 0)
1300
1307
transform.apply()
1301
1308
self.assertEqual(transform.rename_count, 1)
1318
1325
"""
1319
1326
transform, root = self.get_transform()
1320
1327
parent1 = transform.new_directory('parent1', root)
1321
child1 = transform.new_file('child1', parent1, b'contents')
1328
child1 = transform.new_file('child1', parent1, [b'contents'])
1322
1329
parent2 = transform.new_directory('parent2', root)
1323
1330
transform.adjust_path('child1', parent2, child1)
1324
1331
transform.apply()
1337
1344
"""
1338
1345
transform, root = self.get_transform()
1339
1346
parent1 = transform.new_directory('parent1', root)
1340
child1 = transform.new_file('child1', parent1, b'contents')
1341
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'])
1342
1349
try:
1343
1350
transform.cancel_creation(parent1)
1344
1351
except OSError:
1364
1371
"""Make sure adjust_path keeps track of limbo children properly"""
1365
1372
transform, root = self.get_transform()
1366
1373
parent1 = transform.new_directory('parent1', root)
1367
child1 = transform.new_file('child1', parent1, b'contents')
1374
child1 = transform.new_file('child1', parent1, [b'contents'])
1368
1375
parent2 = transform.new_directory('parent2', root)
1369
1376
transform.adjust_path('child1', parent2, child1)
1370
1377
transform.cancel_creation(child1)
1379
1386
def test_noname_contents(self):
1380
1387
"""TreeTransform should permit deferring naming files."""
1381
1388
transform, root = self.get_transform()
1382
parent = transform.trans_id_file_id('parent-id')
1389
parent = transform.trans_id_file_id(b'parent-id')
1383
1390
try:
1384
1391
transform.create_directory(parent)
1385
1392
except KeyError:
1389
1396
def test_noname_contents_nested(self):
1390
1397
"""TreeTransform should permit deferring naming files."""
1391
1398
transform, root = self.get_transform()
1392
parent = transform.trans_id_file_id('parent-id')
1399
parent = transform.trans_id_file_id(b'parent-id')
1393
1400
try:
1394
1401
transform.create_directory(parent)
1395
1402
except KeyError:
1466
1473
tt = TreeTransform(wt) # TreeTransform obtains write lock
1467
1474
try:
1468
1475
foo = tt.new_directory('foo', tt.root)
1469
tt.new_file('bar', foo, b'foobar')
1476
tt.new_file('bar', foo, [b'foobar'])
1470
1477
baz = tt.new_directory('baz', tt.root)
1471
tt.new_file('qux', baz, b'quux')
1478
tt.new_file('qux', baz, [b'quux'])
1472
1479
# Ask for a rename 'foo' -> 'baz'
1473
1480
tt.adjust_path('baz', tt.root, foo)
1474
1481
# Lie to tt that we've already resolved all conflicts.
1599
1606
1600
1607
def test_no_final_path(self):
1601
1608
transform, root = self.get_transform()
1602
trans_id = transform.trans_id_file_id('foo')
1609
trans_id = transform.trans_id_file_id(b'foo')
1603
1610
transform.create_file([b'bar'], trans_id)
1604
1611
transform.cancel_creation(trans_id)
1605
1612
transform.apply()
1613
1620
foo_trans_id = tt.create_path('foo', tt.root)
1614
1621
create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id')
1615
1622
bar_trans_id = tt.create_path('bar', tt.root)
1616
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')
1617
1624
tt.apply()
1618
1625
self.assertEqual('directory', osutils.file_kind('tree2/foo'))
1619
self.assertFileEqual('baz', 'tree2/bar')
1626
self.assertFileEqual(b'baz', 'tree2/bar')
1620
1627
1621
1628
def test_create_from_tree_bytes(self):
1622
1629
"""Provided lines are used instead of tree content."""
1623
1630
tree1 = self.make_branch_and_tree('tree1')
1624
self.build_tree_contents([('tree1/foo', 'bar'),])
1631
self.build_tree_contents([('tree1/foo', b'bar'),])
1625
1632
tree1.add('foo', b'foo-id')
1626
1633
tree2 = self.make_branch_and_tree('tree2')
1627
1634
tt = TreeTransform(tree2)
1628
1635
foo_trans_id = tt.create_path('foo', tt.root)
1629
1636
create_from_tree(tt, foo_trans_id, tree1, 'foo', file_id=b'foo-id',
1630
chunks=['qux'])
1637
chunks=[b'qux'])
1631
1638
tt.apply()
1632
self.assertFileEqual('qux', 'tree2/foo')
1639
self.assertFileEqual(b'qux', 'tree2/foo')
1633
1640
1634
1641
def test_create_from_tree_symlink(self):
1635
1642
self.requireFeature(SymlinkFeature)
1656
1663
1657
1664
1658
1665
def conflict_text(tree, merge):
1659
template = '%s TREE\n%s%s\n%s%s MERGE-SOURCE\n'
1660
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)
1661
1668
1662
1669
1663
1670
class TestInventoryAltered(tests.TestCaseWithTransport):
1697
1704
def test_text_merge(self):
1698
1705
root_id = generate_ids.gen_root_id()
1699
1706
base = TransformGroup("base", root_id)
1700
base.tt.new_file('a', base.root, b'a\nb\nc\nd\be\n', b'a')
1701
base.tt.new_file('b', base.root, b'b1', b'b')
1702
base.tt.new_file('c', base.root, b'c', b'c')
1703
base.tt.new_file('d', base.root, b'd', b'd')
1704
base.tt.new_file('e', base.root, b'e', b'e')
1705
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')
1706
1713
base.tt.new_directory('g', base.root, b'g')
1707
1714
base.tt.new_directory('h', base.root, b'h')
1708
1715
base.tt.apply()
1709
1716
other = TransformGroup("other", root_id)
1710
other.tt.new_file('a', other.root, b'y\nb\nc\nd\be\n', b'a')
1711
other.tt.new_file('b', other.root, b'b2', b'b')
1712
other.tt.new_file('c', other.root, b'c2', b'c')
1713
other.tt.new_file('d', other.root, b'd', b'd')
1714
other.tt.new_file('e', other.root, b'e2', b'e')
1715
other.tt.new_file('f', other.root, b'f', b'f')
1716
other.tt.new_file('g', other.root, b'g', b'g')
1717
other.tt.new_file('h', other.root, b'h\ni\nj\nk\n', b'h')
1718
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')
1719
1726
other.tt.apply()
1720
1727
this = TransformGroup("this", root_id)
1721
this.tt.new_file('a', this.root, b'a\nb\nc\nd\bz\n', b'a')
1722
this.tt.new_file('b', this.root, b'b', b'b')
1723
this.tt.new_file('c', this.root, b'c', b'c')
1724
this.tt.new_file('d', this.root, b'd2', b'd')
1725
this.tt.new_file('e', this.root, b'e2', b'e')
1726
this.tt.new_file('f', this.root, b'f', b'f')
1727
this.tt.new_file('g', this.root, b'g', b'g')
1728
this.tt.new_file('h', this.root, b'1\n2\n3\n4\n', b'h')
1729
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')
1730
1737
this.tt.apply()
1731
1738
Merge3Merger(this.wt, this.wt, base.wt, other.wt)
1732
1739
1733
1740
# textual merge
1734
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')
1735
1743
# three-way text conflict
1736
self.assertEqual(this.wt.get_file(this.wt.id2path(b'b')).read(),
1737
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'))
1738
1746
# OTHER wins
1739
1747
self.assertEqual(this.wt.get_file(this.wt.id2path(b'c')).read(), b'c2')
1740
1748
# THIS wins
1747
1755
self.assertEqual(this.wt.get_file(this.wt.id2path(b'g')).read(), b'g')
1748
1756
# Text conflict when THIS & OTHER are text and BASE is dir
1749
1757
self.assertEqual(this.wt.get_file(this.wt.id2path(b'h')).read(),
1750
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'))
1751
1759
self.assertEqual(this.wt.get_file('h.THIS').read(),
1752
1760
b'1\n2\n3\n4\n')
1753
1761
self.assertEqual(this.wt.get_file('h.OTHER').read(),
1764
1772
merge_modified = this.wt.merge_modified()
1765
1773
self.assertSubset(merge_modified, modified)
1766
1774
self.assertEqual(len(merge_modified), len(modified))
1767
with file(this.wt.abspath(this.wt.id2path('a')), 'wb') as f: f.write('booga')
1775
with open(this.wt.abspath(this.wt.id2path('a')), 'wb') as f: f.write(b'booga')
1768
1776
modified.pop(0)
1769
1777
merge_modified = this.wt.merge_modified()
1770
1778
self.assertSubset(merge_modified, modified)
1780
1788
other = TransformGroup("OTHER", root_id)
1781
1789
for tg in this, base, other:
1782
1790
tg.tt.new_directory('a', tg.root, b'a')
1783
tg.tt.new_symlink('b', tg.root, 'b', 'b')
1784
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')
1785
1793
tg.tt.new_symlink('d', tg.root, tg.name, b'd')
1786
1794
targets = ((base, 'base-e', 'base-f', None, None),
1787
1795
(this, 'other-e', 'this-f', 'other-g', 'this-h'),
1857
1865
base_b, this_b, other_b = [t.tt.new_directory('b', t.root, 'b')
1858
1866
for t in [base, this, other]]
1859
1867
1860
base.tt.new_file('g', base_a, 'g', 'g')
1861
other.tt.new_file('g1', other_b, 'g1', 'g')
1862
1863
base.tt.new_file('h', base_a, 'h', 'h')
1864
this.tt.new_file('h1', this_b, 'h1', 'h')
1865
1866
base.tt.new_file('i', base.root, 'i', 'i')
1867
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')
1868
1876
1869
1877
for tg in [this, base, other]:
1870
1878
tg.tt.apply()
1886
1894
os.mkdir('a')
1887
1895
a = ControlDir.create_standalone_workingtree('a')
1888
1896
os.mkdir('a/foo')
1889
with file('a/foo/bar', 'wb') as f: f.write('contents')
1897
with open('a/foo/bar', 'wb') as f: f.write(b'contents')
1890
1898
os.symlink('a/foo/bar', 'a/foo/baz')
1891
1899
a.add(['foo', 'foo/bar', 'foo/baz'])
1892
1900
a.commit('initial commit')
1896
1904
self.addCleanup(basis.unlock)
1897
1905
build_tree(basis, b)
1898
1906
self.assertIs(os.path.isdir('b/foo'), True)
1899
self.assertEqual(file('b/foo/bar', 'rb').read(), "contents")
1907
with open('b/foo/bar', 'rb') as f:
1908
self.assertEqual(f.read(), "contents")
1900
1909
self.assertEqual(os.readlink('b/foo/baz'), 'a/foo/bar')
1901
1910
1902
1911
def test_build_with_references(self):
1922
1931
'file.moved', 'file', None, 'new-file')],
1923
1932
target.conflicts())
1924
1933
target2 = self.make_branch_and_tree('target2')
1925
target_file = file('target2/file', 'wb')
1926
try:
1927
source_file = file('source/file', 'rb')
1928
try:
1929
target_file.write(source_file.read())
1930
finally:
1931
source_file.close()
1932
finally:
1933
target_file.close()
1934
with open('target2/file', 'wb') as target_file, \
1935
open('source/file', 'rb') as source_file:
1936
target_file.write(source_file.read())
1934
1937
build_tree(source.basis_tree(), target2)
1935
1938
self.assertEqual([], target2.conflicts())
1936
1939
2058
2061
revision_tree.lock_read()
2059
2062
self.addCleanup(revision_tree.unlock)
2060
2063
build_tree(revision_tree, target, source)
2061
self.assertEqual(['file1-id'], calls)
2064
self.assertEqual([b'file1-id'], calls)
2062
2065
target.lock_read()
2063
2066
self.addCleanup(target.unlock)
2064
2067
self.assertEqual([], list(target.iter_changes(revision_tree)))
2065
2068
2066
2069
def test_build_tree_accelerator_tree_observes_sha1(self):
2067
2070
source = self.create_ab_tree()
2068
sha1 = osutils.sha_string('A')
2071
sha1 = osutils.sha_string(b'A')
2069
2072
target = self.make_branch_and_tree('target')
2070
2073
target.lock_write()
2071
2074
self.addCleanup(target.unlock)
2072
2075
state = target.current_dirstate()
2073
2076
state._cutoff_time = time.time() + 60
2074
2077
build_tree(source.basis_tree(), target, source)
2075
entry = state._get_entry(0, path_utf8='file1')
2078
entry = state._get_entry(0, path_utf8=b'file1')
2076
2079
self.assertEqual(sha1, entry[1][0][1])
2077
2080
2078
2081
def test_build_tree_accelerator_tree_missing_file(self):
2185
2188
filters._reset_registry(original_registry)
2186
2189
self.addCleanup(restore_registry)
2187
2190
def rot13(chunks, context=None):
2188
return [''.join(chunks).encode('rot13')]
2191
return [b''.join(chunks).encode('rot13')]
2189
2192
rot13filter = filters.ContentFilter(rot13, rot13)
2190
2193
filters.filter_stacks_registry.register(
2191
2194
'rot13', {'yes': [rot13filter]}.get)
2192
2195
os.mkdir(self.test_home_dir + '/.bazaar')
2193
2196
rules_filename = self.test_home_dir + '/.bazaar/rules'
2194
f = open(rules_filename, 'wb')
2195
f.write('[name %s]\nrot13=yes\n' % (pattern,))
2196
f.close()
2197
with open(rules_filename, 'wb') as f:
2198
f.write(b'[name %s]\nrot13=yes\n' % (pattern,))
2197
2199
def uninstall_rules():
2198
2200
os.remove(rules_filename)
2199
2201
rules.reset_rules()
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