← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bundle.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-01-03 18:09:01 UTC
  • mfrom: (3159.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20080103180901-w987y1ftqoh02qbm
(vila) Fix #179368 by keeping the current range hint on
        ShortReadvErrors

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bundle.py
24
24
    errors,
25
25
    inventory,
26
26
    repository,
 
27
    revision as _mod_revision,
27
28
    treebuilder,
28
29
    )
29
 
from bzrlib.builtins import _merge_helper
30
30
from bzrlib.bzrdir import BzrDir
31
31
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
32
32
from bzrlib.bundle.bundle_data import BundleTree
33
 
from bzrlib.bundle.serializer import write_bundle, read_bundle
 
33
from bzrlib.bundle.serializer import write_bundle, read_bundle, v09, v4
34
34
from bzrlib.bundle.serializer.v08 import BundleSerializerV08
35
35
from bzrlib.bundle.serializer.v09 import BundleSerializerV09
 
36
from bzrlib.bundle.serializer.v4 import BundleSerializerV4
36
37
from bzrlib.branch import Branch
37
38
from bzrlib.diff import internal_diff
38
39
from bzrlib.errors import (BzrError, TestamentMismatch, NotABundle, BadBundle, 
39
40
                           NoSuchFile,)
40
41
from bzrlib.merge import Merge3Merger
41
42
from bzrlib.repofmt import knitrepo
42
 
from bzrlib.osutils import has_symlinks, sha_file
43
 
from bzrlib.tests import (TestCaseInTempDir, TestCaseWithTransport,
44
 
                          TestCase, TestSkipped)
 
43
from bzrlib.osutils import sha_file
 
44
from bzrlib.tests import (
 
45
    SymlinkFeature,
 
46
    TestCase,
 
47
    TestCaseInTempDir,
 
48
    TestCaseWithTransport,
 
49
    TestSkipped,
 
50
    test_commit,
 
51
    )
45
52
from bzrlib.transform import TreeTransform
46
 
from bzrlib.workingtree import WorkingTree
47
53
 
48
54
 
49
55
class MockTree(object):
336
342
        source.commit('one', rev_id='one-id')
337
343
        source.commit('two', rev_id='two-id')
338
344
        text = StringIO()
339
 
        write_bundle(source.branch.repository, 'two-id', None, text, 
 
345
        write_bundle(source.branch.repository, 'two-id', 'null:', text,
340
346
                     format='0.9')
341
347
        text.seek(0)
342
348
 
347
353
                          target.repository, read_bundle(text))
348
354
 
349
355
 
350
 
class V08BundleTester(TestCaseWithTransport):
351
 
 
352
 
    format = '0.8'
 
356
class BundleTester(object):
353
357
 
354
358
    def bzrdir_format(self):
355
359
        format = bzrdir.BzrDirMetaFormat1()
378
382
        rev = self.b1.repository.get_revision(rev_id)
379
383
        self.assertEqual(bundle_txt.readline().decode('utf-8'),
380
384
                         u'# message:\n')
381
 
 
382
 
        open(',,bundle', 'wb').write(bundle_txt.getvalue())
383
385
        bundle_txt.seek(0)
384
386
        return bundle_txt, rev_ids
385
387
 
456
458
                os.mkdir(checkout_dir)
457
459
        tree = self.make_branch_and_tree(checkout_dir)
458
460
        s = StringIO()
459
 
        ancestors = write_bundle(self.b1.repository, rev_id, None, s,
 
461
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
460
462
                                 format=self.format)
461
463
        s.seek(0)
462
464
        assert isinstance(s.getvalue(), str), (
482
484
                    continue
483
485
                self.assertEqual(old_file.read(),
484
486
                                 new.get_file(inventory_id).read())
485
 
        if rev_id is not None:
 
487
        if not _mod_revision.is_null(rev_id):
486
488
            rh = self.b1.revision_history()
487
489
            tree.branch.set_revision_history(rh[:rh.index(rev_id)+1])
488
490
            tree.update()
549
551
        self.tree1.add('one')
550
552
        self.tree1.commit('add one', rev_id='a@cset-0-1')
551
553
 
552
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-1')
553
 
        # FIXME: The current write_bundle api no longer supports
554
 
        #        setting a custom summary message
555
 
        #        We should re-introduce the ability, and update
556
 
        #        the tests to make sure it works.
557
 
        # bundle = self.get_valid_bundle(None, 'a@cset-0-1',
558
 
        #         message='With a specialized message')
 
554
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
559
555
 
560
556
        # Make sure we can handle files with spaces, tabs, other
561
557
        # bogus characters
574
570
        tt = TreeTransform(self.tree1)
575
571
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
576
572
        tt.apply()
 
573
        # have to fix length of file-id so that we can predictably rewrite
 
574
        # a (length-prefixed) record containing it later.
 
575
        self.tree1.add('with space.txt', 'withspace-id')
577
576
        self.tree1.add([
578
 
                'with space.txt'
579
 
                , 'dir'
 
577
                  'dir'
580
578
                , 'dir/filein subdir.c'
581
579
                , 'dir/WithCaps.txt'
582
580
                , 'dir/ pre space'
591
589
        bundle = self.get_valid_bundle('a@cset-0-1', 'a@cset-0-2')
592
590
 
593
591
        # Check a rollup bundle 
594
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-2')
 
592
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
595
593
 
596
594
        # Now delete entries
597
595
        self.tree1.remove(
606
604
        self.tree1.commit('removed', rev_id='a@cset-0-3')
607
605
        
608
606
        bundle = self.get_valid_bundle('a@cset-0-2', 'a@cset-0-3')
609
 
        self.assertRaises(TestamentMismatch, self.get_invalid_bundle, 
610
 
                          'a@cset-0-2', 'a@cset-0-3')
 
607
        self.assertRaises((TestamentMismatch,
 
608
            errors.VersionedFileInvalidChecksum), self.get_invalid_bundle,
 
609
            'a@cset-0-2', 'a@cset-0-3')
611
610
        # Check a rollup bundle 
612
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-3')
 
611
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
613
612
 
614
613
        # Now move the directory
615
614
        self.tree1.rename_one('dir', 'sub/dir')
617
616
 
618
617
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
619
618
        # Check a rollup bundle 
620
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-4')
 
619
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
621
620
 
622
621
        # Modified files
623
622
        open('b1/sub/dir/WithCaps.txt', 'ab').write('\nAdding some text\n')
624
 
        open('b1/sub/dir/ pre space', 'ab').write('\r\nAdding some\r\nDOS format lines\r\n')
 
623
        open('b1/sub/dir/ pre space', 'ab').write(
 
624
             '\r\nAdding some\r\nDOS format lines\r\n')
625
625
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
626
626
        self.tree1.rename_one('sub/dir/ pre space', 
627
627
                              'sub/ start space')
641
641
        self.assertEqualDiff(tree1_inv, tree2_inv)
642
642
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
643
643
        other.commit('rename file', rev_id='a@cset-0-6b')
644
 
        _merge_helper([other.basedir, -1], [None, None],
645
 
                      this_dir=self.tree1.basedir)
 
644
        self.tree1.merge_from_branch(other.branch)
646
645
        self.tree1.commit(u'Merge', rev_id='a@cset-0-7',
647
646
                          verbose=False)
648
647
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
649
648
 
650
649
    def test_symlink_bundle(self):
651
 
        if not has_symlinks():
652
 
            raise TestSkipped("No symlink support")
 
650
        self.requireFeature(SymlinkFeature)
653
651
        self.tree1 = self.make_branch_and_tree('b1')
654
652
        self.b1 = self.tree1.branch
655
653
        tt = TreeTransform(self.tree1)
656
654
        tt.new_symlink('link', tt.root, 'bar/foo', 'link-1')
657
655
        tt.apply()
658
656
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
659
 
        self.get_valid_bundle(None, 'l@cset-0-1')
 
657
        self.get_valid_bundle('null:', 'l@cset-0-1')
660
658
        tt = TreeTransform(self.tree1)
661
659
        trans_id = tt.trans_id_tree_file_id('link-1')
662
660
        tt.adjust_path('link2', tt.root, trans_id)
686
684
        
687
685
        # Add
688
686
        tt.new_file('file', tt.root, '\x00\n\x00\r\x01\n\x02\r\xff', 'binary-1')
689
 
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff', 'binary-2')
 
687
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
 
688
            'binary-2')
690
689
        tt.apply()
691
690
        self.tree1.commit('add binary', rev_id='b@cset-0-1')
692
 
        self.get_valid_bundle(None, 'b@cset-0-1')
 
691
        self.get_valid_bundle('null:', 'b@cset-0-1')
693
692
 
694
693
        # Delete
695
694
        tt = TreeTransform(self.tree1)
719
718
        self.get_valid_bundle('b@cset-0-3', 'b@cset-0-4')
720
719
 
721
720
        # Rollup
722
 
        self.get_valid_bundle(None, 'b@cset-0-4')
 
721
        self.get_valid_bundle('null:', 'b@cset-0-4')
723
722
 
724
723
    def test_last_modified(self):
725
724
        self.tree1 = self.make_branch_and_tree('b1')
743
742
        tt.create_file('file2', trans_id)
744
743
        tt.apply()
745
744
        other.commit('modify text in another tree', rev_id='a@lmod-0-2b')
746
 
        _merge_helper([other.basedir, -1], [None, None],
747
 
                      this_dir=self.tree1.basedir)
 
745
        self.tree1.merge_from_branch(other.branch)
748
746
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-3',
749
747
                          verbose=False)
750
748
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-4')
765
763
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
766
764
                               'a@cset-0-1', bundle_file, format=self.format)
767
765
        self.assertNotContainsRe(bundle_file.getvalue(), '\btwo\b')
768
 
        self.assertContainsRe(bundle_file.getvalue(), 'one')
769
 
        self.assertContainsRe(bundle_file.getvalue(), 'three')
 
766
        self.assertContainsRe(self.get_raw(bundle_file), 'one')
 
767
        self.assertContainsRe(self.get_raw(bundle_file), 'three')
 
768
 
 
769
    def test_bundle_same_basis(self):
 
770
        """Ensure using the basis as the target doesn't cause an error"""
 
771
        self.tree1 = self.make_branch_and_tree('b1')
 
772
        self.tree1.commit('add file', rev_id='a@cset-0-1')
 
773
        bundle_file = StringIO()
 
774
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-1',
 
775
                               'a@cset-0-1', bundle_file)
 
776
 
 
777
    @staticmethod
 
778
    def get_raw(bundle_file):
 
779
        return bundle_file.getvalue()
770
780
 
771
781
    def test_unicode_bundle(self):
772
782
        # Handle international characters
789
799
                          rev_id='i18n-1', committer=u'William Dod\xe9')
790
800
 
791
801
        if sys.platform == 'darwin':
 
802
            from bzrlib.workingtree import WorkingTree3
 
803
            if type(self.tree1) is WorkingTree3:
 
804
                self.knownFailure("Bug #141438: fails for WorkingTree3 on OSX")
 
805
 
792
806
            # On Mac the '\xe9' gets changed to 'e\u0301'
793
807
            self.assertEqual([u'.bzr', u'with Dode\u0301'],
794
808
                             sorted(os.listdir(u'b1')))
799
813
                              " combining characters.")
800
814
 
801
815
        # Add
802
 
        bundle = self.get_valid_bundle(None, 'i18n-1')
 
816
        bundle = self.get_valid_bundle('null:', 'i18n-1')
803
817
 
804
818
        # Modified
805
819
        f = open(u'b1/with Dod\xe9', 'wb')
823
837
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
824
838
 
825
839
        # Rollup
826
 
        bundle = self.get_valid_bundle(None, 'i18n-4')
 
840
        bundle = self.get_valid_bundle('null:', 'i18n-4')
827
841
 
828
842
 
829
843
    def test_whitespace_bundle(self):
841
855
        # Added
842
856
        self.tree1.commit('funky whitespace', rev_id='white-1')
843
857
 
844
 
        bundle = self.get_valid_bundle(None, 'white-1')
 
858
        bundle = self.get_valid_bundle('null:', 'white-1')
845
859
 
846
860
        # Modified
847
861
        open('b1/trailing space ', 'ab').write('add some text\n')
862
876
        bundle = self.get_valid_bundle('white-3', 'white-4')
863
877
        
864
878
        # Now test a complet roll-up
865
 
        bundle = self.get_valid_bundle(None, 'white-4')
 
879
        bundle = self.get_valid_bundle('null:', 'white-4')
866
880
 
867
881
    def test_alt_timezone_bundle(self):
868
882
        self.tree1 = self.make_branch_and_memory_tree('b1')
878
892
        self.tree1.commit('non-hour offset timezone', rev_id='tz-1',
879
893
                          timezone=19800, timestamp=1152544886.0)
880
894
 
881
 
        bundle = self.get_valid_bundle(None, 'tz-1')
 
895
        bundle = self.get_valid_bundle('null:', 'tz-1')
882
896
        
883
897
        rev = bundle.revisions[0]
884
898
        self.assertEqual('Mon 2006-07-10 20:51:26.000000000 +0530', rev.date)
890
904
        self.tree1 = self.make_branch_and_tree('b1')
891
905
        self.b1 = self.tree1.branch
892
906
        self.tree1.commit('message', rev_id='revid1')
893
 
        bundle = self.get_valid_bundle(None, 'revid1')
894
 
        tree = bundle.revision_tree(self.b1.repository, 'revid1')
 
907
        bundle = self.get_valid_bundle('null:', 'revid1')
 
908
        tree = self.get_bundle_tree(bundle, 'revid1')
895
909
        self.assertEqual('revid1', tree.inventory.root.revision)
896
910
 
897
911
    def test_install_revisions(self):
898
912
        self.tree1 = self.make_branch_and_tree('b1')
899
913
        self.b1 = self.tree1.branch
900
914
        self.tree1.commit('message', rev_id='rev2a')
901
 
        bundle = self.get_valid_bundle(None, 'rev2a')
 
915
        bundle = self.get_valid_bundle('null:', 'rev2a')
902
916
        branch2 = self.make_branch('b2')
903
917
        self.assertFalse(branch2.repository.has_revision('rev2a'))
904
918
        target_revision = bundle.install_revisions(branch2.repository)
913
927
        tree.add([''], ['TREE_ROOT'])
914
928
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
915
929
        self.b1 = tree.branch
916
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
930
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
931
        bundle = read_bundle(bundle_sio)
 
932
        revision_info = bundle.revisions[0]
 
933
        self.assertEqual('rev1', revision_info.revision_id)
 
934
        rev = revision_info.as_revision()
 
935
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
936
                         rev.properties)
 
937
 
 
938
    def test_bundle_sorted_properties(self):
 
939
        """For stability the writer should write properties in sorted order."""
 
940
        tree = self.make_branch_and_memory_tree('tree')
 
941
        tree.lock_write()
 
942
        self.addCleanup(tree.unlock)
 
943
 
 
944
        tree.add([''], ['TREE_ROOT'])
 
945
        tree.commit('One', rev_id='rev1',
 
946
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
 
947
        self.b1 = tree.branch
 
948
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
949
        bundle = read_bundle(bundle_sio)
 
950
        revision_info = bundle.revisions[0]
 
951
        self.assertEqual('rev1', revision_info.revision_id)
 
952
        rev = revision_info.as_revision()
 
953
        self.assertEqual({'branch-nick':'tree', 'a':'4', 'b':'3', 'c':'2',
 
954
                          'd':'1'}, rev.properties)
 
955
 
 
956
    def test_bundle_unicode_properties(self):
 
957
        """We should be able to round trip a non-ascii property."""
 
958
        tree = self.make_branch_and_memory_tree('tree')
 
959
        tree.lock_write()
 
960
        self.addCleanup(tree.unlock)
 
961
 
 
962
        tree.add([''], ['TREE_ROOT'])
 
963
        # Revisions themselves do not require anything about revision property
 
964
        # keys, other than that they are a basestring, and do not contain
 
965
        # whitespace.
 
966
        # However, Testaments assert than they are str(), and thus should not
 
967
        # be Unicode.
 
968
        tree.commit('One', rev_id='rev1',
 
969
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
 
970
        self.b1 = tree.branch
 
971
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
972
        bundle = read_bundle(bundle_sio)
 
973
        revision_info = bundle.revisions[0]
 
974
        self.assertEqual('rev1', revision_info.revision_id)
 
975
        rev = revision_info.as_revision()
 
976
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
 
977
                          'alpha':u'\u03b1'}, rev.properties)
 
978
 
 
979
    def test_bundle_with_ghosts(self):
 
980
        tree = self.make_branch_and_tree('tree')
 
981
        self.b1 = tree.branch
 
982
        self.build_tree_contents([('tree/file', 'content1')])
 
983
        tree.add(['file'])
 
984
        tree.commit('rev1')
 
985
        self.build_tree_contents([('tree/file', 'content2')])
 
986
        tree.add_parent_tree_id('ghost')
 
987
        tree.commit('rev2', rev_id='rev2')
 
988
        bundle = self.get_valid_bundle('null:', 'rev2')
 
989
 
 
990
    def make_simple_tree(self, format=None):
 
991
        tree = self.make_branch_and_tree('b1', format=format)
 
992
        self.b1 = tree.branch
 
993
        self.build_tree(['b1/file'])
 
994
        tree.add('file')
 
995
        return tree
 
996
 
 
997
    def test_across_serializers(self):
 
998
        tree = self.make_simple_tree('knit')
 
999
        tree.commit('hello', rev_id='rev1')
 
1000
        tree.commit('hello', rev_id='rev2')
 
1001
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1002
        repo = self.make_repository('repo', format='dirstate-with-subtree')
 
1003
        bundle.install_revisions(repo)
 
1004
        inv_text = repo.get_inventory_xml('rev2')
 
1005
        self.assertNotContainsRe(inv_text, 'format="5"')
 
1006
        self.assertContainsRe(inv_text, 'format="7"')
 
1007
 
 
1008
    def test_across_models(self):
 
1009
        tree = self.make_simple_tree('knit')
 
1010
        tree.commit('hello', rev_id='rev1')
 
1011
        tree.commit('hello', rev_id='rev2')
 
1012
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1013
        repo = self.make_repository('repo', format='dirstate-with-subtree')
 
1014
        bundle.install_revisions(repo)
 
1015
        inv = repo.get_inventory('rev2')
 
1016
        self.assertEqual('rev2', inv.root.revision)
 
1017
        root_vf = repo.weave_store.get_weave(inv.root.file_id,
 
1018
                                             repo.get_transaction())
 
1019
        self.assertEqual(root_vf.versions(), ['rev1', 'rev2'])
 
1020
 
 
1021
    def test_across_models_incompatible(self):
 
1022
        tree = self.make_simple_tree('dirstate-with-subtree')
 
1023
        tree.commit('hello', rev_id='rev1')
 
1024
        tree.commit('hello', rev_id='rev2')
 
1025
        try:
 
1026
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1027
        except errors.IncompatibleBundleFormat:
 
1028
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1029
        repo = self.make_repository('repo', format='knit')
 
1030
        bundle.install_revisions(repo)
 
1031
 
 
1032
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1033
        self.assertRaises(errors.IncompatibleRevision,
 
1034
                          bundle.install_revisions, repo)
 
1035
 
 
1036
    def test_get_merge_request(self):
 
1037
        tree = self.make_simple_tree()
 
1038
        tree.commit('hello', rev_id='rev1')
 
1039
        tree.commit('hello', rev_id='rev2')
 
1040
        bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1041
        result = bundle.get_merge_request(tree.branch.repository)
 
1042
        self.assertEqual((None, 'rev1', 'inapplicable'), result)
 
1043
 
 
1044
    def test_with_subtree(self):
 
1045
        tree = self.make_branch_and_tree('tree',
 
1046
                                         format='dirstate-with-subtree')
 
1047
        self.b1 = tree.branch
 
1048
        subtree = self.make_branch_and_tree('tree/subtree',
 
1049
                                            format='dirstate-with-subtree')
 
1050
        tree.add('subtree')
 
1051
        tree.commit('hello', rev_id='rev1')
 
1052
        try:
 
1053
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1054
        except errors.IncompatibleBundleFormat:
 
1055
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1056
        if isinstance(bundle, v09.BundleInfo09):
 
1057
            raise TestSkipped("Format 0.9 doesn't work with subtrees")
 
1058
        repo = self.make_repository('repo', format='knit')
 
1059
        self.assertRaises(errors.IncompatibleRevision,
 
1060
                          bundle.install_revisions, repo)
 
1061
        repo2 = self.make_repository('repo2', format='dirstate-with-subtree')
 
1062
        bundle.install_revisions(repo2)
 
1063
 
 
1064
    def test_revision_id_with_slash(self):
 
1065
        self.tree1 = self.make_branch_and_tree('tree')
 
1066
        self.b1 = self.tree1.branch
 
1067
        try:
 
1068
            self.tree1.commit('Revision/id/with/slashes', rev_id='rev/id')
 
1069
        except ValueError:
 
1070
            raise TestSkipped("Repository doesn't support revision ids with"
 
1071
                              " slashes")
 
1072
        bundle = self.get_valid_bundle('null:', 'rev/id')
 
1073
 
 
1074
    def test_skip_file(self):
 
1075
        """Make sure we don't accidentally write to the wrong versionedfile"""
 
1076
        self.tree1 = self.make_branch_and_tree('tree')
 
1077
        self.b1 = self.tree1.branch
 
1078
        # rev1 is not present in bundle, done by fetch
 
1079
        self.build_tree_contents([('tree/file2', 'contents1')])
 
1080
        self.tree1.add('file2', 'file2-id')
 
1081
        self.tree1.commit('rev1', rev_id='reva')
 
1082
        self.build_tree_contents([('tree/file3', 'contents2')])
 
1083
        # rev2 is present in bundle, and done by fetch
 
1084
        # having file1 in the bunle causes file1's versionedfile to be opened.
 
1085
        self.tree1.add('file3', 'file3-id')
 
1086
        self.tree1.commit('rev2')
 
1087
        # Updating file2 should not cause an attempt to add to file1's vf
 
1088
        target = self.tree1.bzrdir.sprout('target').open_workingtree()
 
1089
        self.build_tree_contents([('tree/file2', 'contents3')])
 
1090
        self.tree1.commit('rev3', rev_id='rev3')
 
1091
        bundle = self.get_valid_bundle('reva', 'rev3')
 
1092
        if getattr(bundle, 'get_bundle_reader', None) is None:
 
1093
            raise TestSkipped('Bundle format cannot provide reader')
 
1094
        # be sure that file1 comes before file2
 
1095
        for b, m, k, r, f in bundle.get_bundle_reader().iter_records():
 
1096
            if f == 'file3-id':
 
1097
                break
 
1098
            self.assertNotEqual(f, 'file2-id')
 
1099
        bundle.install_revisions(target.branch.repository)
 
1100
 
 
1101
 
 
1102
class V08BundleTester(BundleTester, TestCaseWithTransport):
 
1103
 
 
1104
    format = '0.8'
 
1105
 
 
1106
    def test_bundle_empty_property(self):
 
1107
        """Test serializing revision properties with an empty value."""
 
1108
        tree = self.make_branch_and_memory_tree('tree')
 
1109
        tree.lock_write()
 
1110
        self.addCleanup(tree.unlock)
 
1111
        tree.add([''], ['TREE_ROOT'])
 
1112
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1113
        self.b1 = tree.branch
 
1114
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
917
1115
        self.assertContainsRe(bundle_sio.getvalue(),
918
1116
                              '# properties:\n'
919
1117
                              '#   branch-nick: tree\n'
927
1125
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
928
1126
                         rev.properties)
929
1127
 
 
1128
    def get_bundle_tree(self, bundle, revision_id):
 
1129
        repository = self.make_repository('repo')
 
1130
        return bundle.revision_tree(repository, 'revid1')
 
1131
 
930
1132
    def test_bundle_empty_property_alt(self):
931
1133
        """Test serializing revision properties with an empty value.
932
1134
 
941
1143
        tree.add([''], ['TREE_ROOT'])
942
1144
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
943
1145
        self.b1 = tree.branch
944
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
1146
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
945
1147
        txt = bundle_sio.getvalue()
946
1148
        loc = txt.find('#   empty: ') + len('#   empty:')
947
1149
        # Create a new bundle, which strips the trailing space after empty
970
1172
        tree.commit('One', rev_id='rev1',
971
1173
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
972
1174
        self.b1 = tree.branch
973
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
1175
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
974
1176
        self.assertContainsRe(bundle_sio.getvalue(),
975
1177
                              '# properties:\n'
976
1178
                              '#   a: 4\n'
1001
1203
        tree.commit('One', rev_id='rev1',
1002
1204
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
1003
1205
        self.b1 = tree.branch
1004
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
1206
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1005
1207
        self.assertContainsRe(bundle_sio.getvalue(),
1006
1208
                              '# properties:\n'
1007
1209
                              '#   alpha: \xce\xb1\n'
1036
1238
        return format
1037
1239
 
1038
1240
 
1039
 
class MungedBundleTester(TestCaseWithTransport):
 
1241
class V4BundleTester(BundleTester, TestCaseWithTransport):
 
1242
 
 
1243
    format = '4'
 
1244
 
 
1245
    def get_valid_bundle(self, base_rev_id, rev_id, checkout_dir=None):
 
1246
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1247
        Make sure that the text generated is valid, and that it
 
1248
        can be applied against the base, and generate the same information.
 
1249
        
 
1250
        :return: The in-memory bundle 
 
1251
        """
 
1252
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1253
 
 
1254
        # This should also validate the generated bundle 
 
1255
        bundle = read_bundle(bundle_txt)
 
1256
        repository = self.b1.repository
 
1257
        for bundle_rev in bundle.real_revisions:
 
1258
            # These really should have already been checked when we read the
 
1259
            # bundle, since it computes the sha1 hash for the revision, which
 
1260
            # only will match if everything is okay, but lets be explicit about
 
1261
            # it
 
1262
            branch_rev = repository.get_revision(bundle_rev.revision_id)
 
1263
            for a in ('inventory_sha1', 'revision_id', 'parent_ids',
 
1264
                      'timestamp', 'timezone', 'message', 'committer', 
 
1265
                      'parent_ids', 'properties'):
 
1266
                self.assertEqual(getattr(branch_rev, a), 
 
1267
                                 getattr(bundle_rev, a))
 
1268
            self.assertEqual(len(branch_rev.parent_ids), 
 
1269
                             len(bundle_rev.parent_ids))
 
1270
        self.assertEqual(set(rev_ids),
 
1271
                         set([r.revision_id for r in bundle.real_revisions]))
 
1272
        self.valid_apply_bundle(base_rev_id, bundle,
 
1273
                                   checkout_dir=checkout_dir)
 
1274
 
 
1275
        return bundle
 
1276
 
 
1277
    def get_invalid_bundle(self, base_rev_id, rev_id):
 
1278
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1279
        Munge the text so that it's invalid.
 
1280
 
 
1281
        :return: The in-memory bundle
 
1282
        """
 
1283
        from bzrlib.bundle import serializer
 
1284
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1285
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1286
        new_text = new_text.replace('<file file_id="exe-1"',
 
1287
                                    '<file executable="y" file_id="exe-1"')
 
1288
        new_text = new_text.replace('B222', 'B237')
 
1289
        bundle_txt = StringIO()
 
1290
        bundle_txt.write(serializer._get_bundle_header('4'))
 
1291
        bundle_txt.write('\n')
 
1292
        bundle_txt.write(new_text.encode('bz2'))
 
1293
        bundle_txt.seek(0)
 
1294
        bundle = read_bundle(bundle_txt)
 
1295
        self.valid_apply_bundle(base_rev_id, bundle)
 
1296
        return bundle
 
1297
 
 
1298
    def create_bundle_text(self, base_rev_id, rev_id):
 
1299
        bundle_txt = StringIO()
 
1300
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id, 
 
1301
                               bundle_txt, format=self.format)
 
1302
        bundle_txt.seek(0)
 
1303
        self.assertEqual(bundle_txt.readline(), 
 
1304
                         '# Bazaar revision bundle v%s\n' % self.format)
 
1305
        self.assertEqual(bundle_txt.readline(), '#\n')
 
1306
        rev = self.b1.repository.get_revision(rev_id)
 
1307
        bundle_txt.seek(0)
 
1308
        return bundle_txt, rev_ids
 
1309
 
 
1310
    def get_bundle_tree(self, bundle, revision_id):
 
1311
        repository = self.make_repository('repo')
 
1312
        bundle.install_revisions(repository)
 
1313
        return repository.revision_tree(revision_id)
 
1314
 
 
1315
    def test_creation(self):
 
1316
        tree = self.make_branch_and_tree('tree')
 
1317
        self.build_tree_contents([('tree/file', 'contents1\nstatic\n')])
 
1318
        tree.add('file', 'fileid-2')
 
1319
        tree.commit('added file', rev_id='rev1')
 
1320
        self.build_tree_contents([('tree/file', 'contents2\nstatic\n')])
 
1321
        tree.commit('changed file', rev_id='rev2')
 
1322
        s = StringIO()
 
1323
        serializer = BundleSerializerV4('1.0')
 
1324
        serializer.write(tree.branch.repository, ['rev1', 'rev2'], {}, s)
 
1325
        s.seek(0)
 
1326
        tree2 = self.make_branch_and_tree('target')
 
1327
        target_repo = tree2.branch.repository
 
1328
        install_bundle(target_repo, serializer.read(s))
 
1329
        vf = target_repo.weave_store.get_weave('fileid-2',
 
1330
            target_repo.get_transaction())
 
1331
        self.assertEqual('contents1\nstatic\n', vf.get_text('rev1'))
 
1332
        self.assertEqual('contents2\nstatic\n', vf.get_text('rev2'))
 
1333
        rtree = target_repo.revision_tree('rev2')
 
1334
        inventory_vf = target_repo.get_inventory_weave()
 
1335
        self.assertEqual(['rev1'], inventory_vf.get_parents('rev2'))
 
1336
        self.assertEqual('changed file',
 
1337
                         target_repo.get_revision('rev2').message)
 
1338
 
 
1339
    @staticmethod
 
1340
    def get_raw(bundle_file):
 
1341
        bundle_file.seek(0)
 
1342
        line = bundle_file.readline()
 
1343
        line = bundle_file.readline()
 
1344
        lines = bundle_file.readlines()
 
1345
        return ''.join(lines).decode('bz2')
 
1346
 
 
1347
    def test_copy_signatures(self):
 
1348
        tree_a = self.make_branch_and_tree('tree_a')
 
1349
        import bzrlib.gpg
 
1350
        import bzrlib.commit as commit
 
1351
        oldstrategy = bzrlib.gpg.GPGStrategy
 
1352
        branch = tree_a.branch
 
1353
        repo_a = branch.repository
 
1354
        tree_a.commit("base", allow_pointless=True, rev_id='A')
 
1355
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
 
1356
        try:
 
1357
            from bzrlib.testament import Testament
 
1358
            # monkey patch gpg signing mechanism
 
1359
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
1360
            new_config = test_commit.MustSignConfig(branch)
 
1361
            commit.Commit(config=new_config).commit(message="base",
 
1362
                                                    allow_pointless=True,
 
1363
                                                    rev_id='B',
 
1364
                                                    working_tree=tree_a)
 
1365
            def sign(text):
 
1366
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
 
1367
            self.assertTrue(repo_a.has_signature_for_revision_id('B'))
 
1368
        finally:
 
1369
            bzrlib.gpg.GPGStrategy = oldstrategy
 
1370
        tree_b = self.make_branch_and_tree('tree_b')
 
1371
        repo_b = tree_b.branch.repository
 
1372
        s = StringIO()
 
1373
        serializer = BundleSerializerV4('4')
 
1374
        serializer.write(tree_a.branch.repository, ['A', 'B'], {}, s)
 
1375
        s.seek(0)
 
1376
        install_bundle(repo_b, serializer.read(s))
 
1377
        self.assertTrue(repo_b.has_signature_for_revision_id('B'))
 
1378
        self.assertEqual(repo_b.get_signature_text('B'),
 
1379
                         repo_a.get_signature_text('B'))
 
1380
        s.seek(0)
 
1381
        # ensure repeat installs are harmless
 
1382
        install_bundle(repo_b, serializer.read(s))
 
1383
 
 
1384
 
 
1385
class V4WeaveBundleTester(V4BundleTester):
 
1386
 
 
1387
    def bzrdir_format(self):
 
1388
        return 'metaweave'
 
1389
 
 
1390
 
 
1391
class MungedBundleTester(object):
1040
1392
 
1041
1393
    def build_test_bundle(self):
1042
1394
        wt = self.make_branch_and_tree('b1')
1051
1403
 
1052
1404
        bundle_txt = StringIO()
1053
1405
        rev_ids = write_bundle(wt.branch.repository, 'a@cset-0-2',
1054
 
                               'a@cset-0-1', bundle_txt)
1055
 
        self.assertEqual(['a@cset-0-2'], rev_ids)
 
1406
                               'a@cset-0-1', bundle_txt, self.format)
 
1407
        self.assertEqual(set(['a@cset-0-2']), set(rev_ids))
1056
1408
        bundle_txt.seek(0, 0)
1057
1409
        return bundle_txt
1058
1410
 
1087
1439
        bundle = read_bundle(bundle_txt)
1088
1440
        self.check_valid(bundle)
1089
1441
 
 
1442
 
 
1443
class MungedBundleTesterV09(TestCaseWithTransport, MungedBundleTester):
 
1444
 
 
1445
    format = '0.9'
 
1446
 
1090
1447
    def test_missing_trailing_whitespace(self):
1091
1448
        bundle_txt = self.build_test_bundle()
1092
1449
 
1120
1477
        bundle = read_bundle(bundle_txt)
1121
1478
        self.check_valid(bundle)
1122
1479
 
 
1480
 
 
1481
class MungedBundleTesterV4(TestCaseWithTransport, MungedBundleTester):
 
1482
 
 
1483
    format = '4'
 
1484
 
 
1485
 
 
1486
class TestBundleWriterReader(TestCase):
 
1487
 
 
1488
    def test_roundtrip_record(self):
 
1489
        fileobj = StringIO()
 
1490
        writer = v4.BundleWriter(fileobj)
 
1491
        writer.begin()
 
1492
        writer.add_info_record(foo='bar')
 
1493
        writer._add_record("Record body", {'parents': ['1', '3'],
 
1494
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1495
        writer.end()
 
1496
        fileobj.seek(0)
 
1497
        reader = v4.BundleReader(fileobj, stream_input=True)
 
1498
        record_iter = reader.iter_records()
 
1499
        record = record_iter.next()
 
1500
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1501
            'info', None, None), record)
 
1502
        record = record_iter.next()
 
1503
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
 
1504
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1505
                          record)
 
1506
 
 
1507
    def test_roundtrip_record_memory_hungry(self):
 
1508
        fileobj = StringIO()
 
1509
        writer = v4.BundleWriter(fileobj)
 
1510
        writer.begin()
 
1511
        writer.add_info_record(foo='bar')
 
1512
        writer._add_record("Record body", {'parents': ['1', '3'],
 
1513
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1514
        writer.end()
 
1515
        fileobj.seek(0)
 
1516
        reader = v4.BundleReader(fileobj, stream_input=False)
 
1517
        record_iter = reader.iter_records()
 
1518
        record = record_iter.next()
 
1519
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1520
            'info', None, None), record)
 
1521
        record = record_iter.next()
 
1522
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
 
1523
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1524
                          record)
 
1525
 
 
1526
    def test_encode_name(self):
 
1527
        self.assertEqual('revision/rev1',
 
1528
            v4.BundleWriter.encode_name('revision', 'rev1'))
 
1529
        self.assertEqual('file/rev//1/file-id-1',
 
1530
            v4.BundleWriter.encode_name('file', 'rev/1', 'file-id-1'))
 
1531
        self.assertEqual('info',
 
1532
            v4.BundleWriter.encode_name('info', None, None))
 
1533
 
 
1534
    def test_decode_name(self):
 
1535
        self.assertEqual(('revision', 'rev1', None),
 
1536
            v4.BundleReader.decode_name('revision/rev1'))
 
1537
        self.assertEqual(('file', 'rev/1', 'file-id-1'),
 
1538
            v4.BundleReader.decode_name('file/rev//1/file-id-1'))
 
1539
        self.assertEqual(('info', None, None),
 
1540
                         v4.BundleReader.decode_name('info'))
 
1541
 
 
1542
    def test_too_many_names(self):
 
1543
        fileobj = StringIO()
 
1544
        writer = v4.BundleWriter(fileobj)
 
1545
        writer.begin()
 
1546
        writer.add_info_record(foo='bar')
 
1547
        writer._container.add_bytes_record('blah', ['two', 'names'])
 
1548
        writer.end()
 
1549
        fileobj.seek(0)
 
1550
        record_iter = v4.BundleReader(fileobj).iter_records()
 
1551
        record = record_iter.next()
 
1552
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1553
            'info', None, None), record)
 
1554
        self.assertRaises(BadBundle, record_iter.next)