/brz/remove-bazaar

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_bundle.py

  • Committer: Jelmer Vernooij
  • Date: 2019-06-03 23:48:08 UTC
  • mfrom: (7316 work)
  • mto: This revision was merged to the branch mainline in revision 7328.
  • Revision ID: jelmer@jelmer.uk-20190603234808-15yk5c7054tj8e2b
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_bundle.py
32
32
    bzrdir,
33
33
    inventory,
34
34
    )
35
 
from ..bzr.bundle.apply_bundle import install_bundle, merge_bundle
36
 
from ..bzr.bundle.bundle_data import BundleTree
37
 
from ..bzr.bundle.serializer import write_bundle, read_bundle, v09, v4
38
 
from ..bzr.bundle.serializer.v08 import BundleSerializerV08
39
 
from ..bzr.bundle.serializer.v09 import BundleSerializerV09
40
 
from ..bzr.bundle.serializer.v4 import BundleSerializerV4
 
35
from ..bundle.apply_bundle import install_bundle, merge_bundle
 
36
from ..bundle.bundle_data import BundleTree
 
37
from ..bundle.serializer import write_bundle, read_bundle, v09, v4
 
38
from ..bundle.serializer.v08 import BundleSerializerV08
 
39
from ..bundle.serializer.v09 import BundleSerializerV09
 
40
from ..bundle.serializer.v4 import BundleSerializerV4
41
41
from ..bzr import knitrepo
42
42
from . import (
43
43
    features,
44
44
    test_commit,
45
45
    )
46
 
from ..tree import InterTree
 
46
from ..transform import TreeTransform
47
47
 
48
48
 
49
49
def get_text(vf, key):
147
147
    def path2id(self, path):
148
148
        return self.ids.get(path)
149
149
 
150
 
    def id2path(self, file_id, recurse='down'):
151
 
        try:
152
 
            return self.paths[file_id]
153
 
        except KeyError:
154
 
            raise errors.NoSuchId(file_id, self)
 
150
    def id2path(self, file_id):
 
151
        return self.paths.get(file_id)
 
152
 
 
153
    def has_id(self, file_id):
 
154
        return self.id2path(file_id) is not None
155
155
 
156
156
    def get_file(self, path):
157
157
        result = BytesIO()
270
270
        btree = self.make_tree_1()[0]
271
271
        btree.note_rename("grandparent/parent/file",
272
272
                          "grandparent/alt_parent/file")
273
 
        self.assertRaises(errors.NoSuchId, btree.id2path, b"e")
 
273
        self.assertTrue(btree.id2path(b"e") is None)
274
274
        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
275
275
        btree.note_id(b"e", "grandparent/parent/file")
276
276
        return btree
292
292
        self.assertEqual(
293
293
            btree.get_symlink_target('grandparent/parent/symlink'), 'venus')
294
294
 
 
295
    def test_adds2(self):
 
296
        """File/inventory adds, with patch-compatibile renames"""
 
297
        btree = self.make_tree_2()
 
298
        btree.contents_by_id = False
 
299
        add_patch = self.unified_diff([b"Hello\n"], [b"Extra cheese\n"])
 
300
        btree.note_patch("grandparent/parent/file", add_patch)
 
301
        btree.note_id(b'f', 'grandparent/parent/symlink', kind='symlink')
 
302
        btree.note_target('grandparent/parent/symlink', 'venus')
 
303
        self.adds_test(btree)
 
304
 
295
305
    def make_tree_3(self):
296
306
        btree, mtree = self.make_tree_1()
297
307
        mtree.add_file(b"e", "grandparent/parent/topping", b"Anchovies\n")
314
324
        btree.note_patch("grandparent/alt_parent/stopping", mod_patch)
315
325
        self.get_file_test(btree)
316
326
 
 
327
    def test_get_file2(self):
 
328
        """Get file contents, with patch-compatible renames"""
 
329
        btree = self.make_tree_3()
 
330
        btree.contents_by_id = False
 
331
        mod_patch = self.unified_diff([], [b"Lemon\n"])
 
332
        btree.note_patch("grandparent/alt_parent/stopping", mod_patch)
 
333
        mod_patch = self.unified_diff([], [b"Hello\n"])
 
334
        btree.note_patch("grandparent/alt_parent/file", mod_patch)
 
335
        self.get_file_test(btree)
 
336
 
317
337
    def test_delete(self):
318
338
        "Deletion by bundle"
319
339
        btree = self.make_tree_1()[0]
320
340
        with btree.get_file(btree.id2path(b"c")) as f:
321
341
            self.assertEqual(f.read(), b"Hello\n")
322
342
        btree.note_deletion("grandparent/parent/file")
323
 
        self.assertRaises(errors.NoSuchId, btree.id2path, b"c")
 
343
        self.assertTrue(btree.id2path(b"c") is None)
324
344
        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
325
345
 
326
346
    def sorted_ids(self, tree):
491
511
        for ancestor in ancestors:
492
512
            old = self.b1.repository.revision_tree(ancestor)
493
513
            new = tree.branch.repository.revision_tree(ancestor)
494
 
            with old.lock_read(), new.lock_read():
 
514
            old.lock_read()
 
515
            new.lock_read()
 
516
            try:
495
517
                # Check that there aren't any inventory level changes
496
518
                delta = new.changes_from(old)
497
519
                self.assertFalse(delta.has_changed(),
506
528
                        continue
507
529
                    self.assertEqual(
508
530
                        old_file.read(), new.get_file(path).read())
 
531
            finally:
 
532
                new.unlock()
 
533
                old.unlock()
509
534
        if not _mod_revision.is_null(rev_id):
510
535
            tree.branch.generate_revision_history(rev_id)
511
536
            tree.update()
562
587
 
563
588
        for path, status, kind, entry in base_files:
564
589
            # Check that the meta information is the same
565
 
            to_path = InterTree.get(base_tree, to_tree).find_target_path(path)
566
590
            self.assertEqual(
567
591
                base_tree.get_file_size(path),
568
 
                to_tree.get_file_size(to_path))
 
592
                to_tree.get_file_size(to_tree.id2path(entry.file_id)))
569
593
            self.assertEqual(
570
 
                base_tree.get_file_sha1(path),
571
 
                to_tree.get_file_sha1(to_path))
 
594
                base_tree.get_file_sha1(path, entry.file_id),
 
595
                to_tree.get_file_sha1(to_tree.id2path(entry.file_id)))
572
596
            # Check that the contents are the same
573
597
            # This is pretty expensive
574
598
            # self.assertEqual(base_tree.get_file(fileid).read(),
592
616
            ])
593
617
        self.build_tree_contents([('b1/sub/sub/emptyfile.txt', b''),
594
618
                                  ('b1/dir/nolastnewline.txt', b'bloop')])
595
 
        tt = self.tree1.get_transform()
 
619
        tt = TreeTransform(self.tree1)
596
620
        tt.new_file('executable', tt.root, [b'#!/bin/sh\n'], b'exe-1', True)
597
621
        tt.apply()
598
622
        # have to fix length of file-id so that we can predictably rewrite
612
636
        self.tree1.remove(
613
637
            ['sub/sub/nonempty.txt', 'sub/sub/emptyfile.txt', 'sub/sub'
614
638
             ])
615
 
        tt = self.tree1.get_transform()
 
639
        tt = TreeTransform(self.tree1)
616
640
        trans_id = tt.trans_id_tree_path('executable')
617
641
        tt.set_executability(False, trans_id)
618
642
        tt.apply()
673
697
        self.tree1 = self.make_branch_and_tree('b1')
674
698
        self.b1 = self.tree1.branch
675
699
 
676
 
        tt = self.tree1.get_transform()
 
700
        tt = TreeTransform(self.tree1)
677
701
        tt.new_symlink(link_name, tt.root, link_target, link_id)
678
702
        tt.apply()
679
703
        self.tree1.commit('add symlink', rev_id=b'l@cset-0-1')
684
708
            self.assertEqual(
685
709
                link_target, bund_tree.get_symlink_target(link_name))
686
710
 
687
 
        tt = self.tree1.get_transform()
 
711
        tt = TreeTransform(self.tree1)
688
712
        trans_id = tt.trans_id_tree_path(link_name)
689
713
        tt.adjust_path('link2', tt.root, trans_id)
690
714
        tt.delete_contents(trans_id)
698
722
            self.assertEqual(new_link_target,
699
723
                             bund_tree.get_symlink_target('link2'))
700
724
 
701
 
        tt = self.tree1.get_transform()
 
725
        tt = TreeTransform(self.tree1)
702
726
        trans_id = tt.trans_id_tree_path('link2')
703
727
        tt.delete_contents(trans_id)
704
728
        tt.create_symlink('jupiter', trans_id)
706
730
        self.tree1.commit('just change symlink target', rev_id=b'l@cset-0-3')
707
731
        bundle = self.get_valid_bundle(b'l@cset-0-2', b'l@cset-0-3')
708
732
 
709
 
        tt = self.tree1.get_transform()
 
733
        tt = TreeTransform(self.tree1)
710
734
        trans_id = tt.trans_id_tree_path('link2')
711
735
        tt.delete_contents(trans_id)
712
736
        tt.apply()
725
749
    def test_binary_bundle(self):
726
750
        self.tree1 = self.make_branch_and_tree('b1')
727
751
        self.b1 = self.tree1.branch
728
 
        tt = self.tree1.get_transform()
 
752
        tt = TreeTransform(self.tree1)
729
753
 
730
754
        # Add
731
755
        tt.new_file('file', tt.root, [
737
761
        self.get_valid_bundle(b'null:', b'b@cset-0-1')
738
762
 
739
763
        # Delete
740
 
        tt = self.tree1.get_transform()
 
764
        tt = TreeTransform(self.tree1)
741
765
        trans_id = tt.trans_id_tree_path('file')
742
766
        tt.delete_contents(trans_id)
743
767
        tt.apply()
745
769
        self.get_valid_bundle(b'b@cset-0-1', b'b@cset-0-2')
746
770
 
747
771
        # Rename & modify
748
 
        tt = self.tree1.get_transform()
 
772
        tt = TreeTransform(self.tree1)
749
773
        trans_id = tt.trans_id_tree_path('file2')
750
774
        tt.adjust_path('file3', tt.root, trans_id)
751
775
        tt.delete_contents(trans_id)
755
779
        self.get_valid_bundle(b'b@cset-0-2', b'b@cset-0-3')
756
780
 
757
781
        # Modify
758
 
        tt = self.tree1.get_transform()
 
782
        tt = TreeTransform(self.tree1)
759
783
        trans_id = tt.trans_id_tree_path('file3')
760
784
        tt.delete_contents(trans_id)
761
785
        tt.create_file([b'\x00file\rcontents'], trans_id)
769
793
    def test_last_modified(self):
770
794
        self.tree1 = self.make_branch_and_tree('b1')
771
795
        self.b1 = self.tree1.branch
772
 
        tt = self.tree1.get_transform()
 
796
        tt = TreeTransform(self.tree1)
773
797
        tt.new_file('file', tt.root, [b'file'], b'file')
774
798
        tt.apply()
775
799
        self.tree1.commit('create file', rev_id=b'a@lmod-0-1')
776
800
 
777
 
        tt = self.tree1.get_transform()
 
801
        tt = TreeTransform(self.tree1)
778
802
        trans_id = tt.trans_id_tree_path('file')
779
803
        tt.delete_contents(trans_id)
780
804
        tt.create_file([b'file2'], trans_id)
782
806
        self.tree1.commit('modify text', rev_id=b'a@lmod-0-2a')
783
807
 
784
808
        other = self.get_checkout(b'a@lmod-0-1')
785
 
        tt = other.get_transform()
 
809
        tt = TreeTransform(other)
786
810
        trans_id = tt.trans_id_tree_path('file2')
787
811
        tt.delete_contents(trans_id)
788
812
        tt.create_file([b'file2'], trans_id)
1036
1060
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
1037
1061
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1038
1062
        bundle.install_revisions(repo)
1039
 
        inv_text = b''.join(repo._get_inventory_xml(b'rev2'))
 
1063
        inv_text = repo._get_inventory_xml(b'rev2')
1040
1064
        self.assertNotContainsRe(inv_text, b'format="5"')
1041
1065
        self.assertContainsRe(inv_text, b'format="7"')
1042
1066
 
1063
1087
    def test_inv_hash_across_serializers(self):
1064
1088
        repo = self.make_repo_with_installed_revisions()
1065
1089
        recorded_inv_sha1 = repo.get_revision(b'rev2').inventory_sha1
1066
 
        xml = b''.join(repo._get_inventory_xml(b'rev2'))
 
1090
        xml = repo._get_inventory_xml(b'rev2')
1067
1091
        self.assertEqual(osutils.sha_string(xml), recorded_inv_sha1)
1068
1092
 
1069
1093
    def test_across_models_incompatible(self):
1330
1354
 
1331
1355
        :return: The in-memory bundle
1332
1356
        """
1333
 
        from ..bzr.bundle import serializer
 
1357
        from ..bundle import serializer
1334
1358
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1335
1359
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
1336
1360
        new_text = new_text.replace(b'<file file_id="exe-1"',
1457
1481
 
1458
1482
        :return: The in-memory bundle
1459
1483
        """
1460
 
        from ..bzr.bundle import serializer
 
1484
        from ..bundle import serializer
1461
1485
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1462
1486
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
1463
1487
        # We are going to be replacing some text to set the executable bit on a
1796
1820
        writer = v4.BundleWriter(fileobj)
1797
1821
        writer.begin()
1798
1822
        writer.add_info_record({b'foo': b'bar'})
1799
 
        writer._container.add_bytes_record([b'blah'], len(b'blah'), [(b'two', ), (b'names', )])
 
1823
        writer._container.add_bytes_record(b'blah', [(b'two', ), (b'names', )])
1800
1824
        writer.end()
1801
1825
        fileobj.seek(0)
1802
1826
        record_iter = v4.BundleReader(fileobj).iter_records()