/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 bzrlib/tests/test_bundle.py

  • Committer: Andrew Bennetts
  • Date: 2007-08-02 06:40:58 UTC
  • mfrom: (2666 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2668.
  • Revision ID: andrew.bennetts@canonical.com-20070802064058-09eblz1qbc01fcr3
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bundle.py
27
27
    revision as _mod_revision,
28
28
    treebuilder,
29
29
    )
30
 
from bzrlib.builtins import _merge_helper
31
30
from bzrlib.bzrdir import BzrDir
32
31
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
33
32
from bzrlib.bundle.bundle_data import BundleTree
34
 
from bzrlib.bundle.serializer import write_bundle, read_bundle
 
33
from bzrlib.bundle.serializer import write_bundle, read_bundle, v09, v4
35
34
from bzrlib.bundle.serializer.v08 import BundleSerializerV08
36
35
from bzrlib.bundle.serializer.v09 import BundleSerializerV09
 
36
from bzrlib.bundle.serializer.v4 import BundleSerializerV4
37
37
from bzrlib.branch import Branch
38
38
from bzrlib.diff import internal_diff
39
39
from bzrlib.errors import (BzrError, TestamentMismatch, NotABundle, BadBundle, 
42
42
from bzrlib.repofmt import knitrepo
43
43
from bzrlib.osutils import has_symlinks, sha_file
44
44
from bzrlib.tests import (TestCaseInTempDir, TestCaseWithTransport,
45
 
                          TestCase, TestSkipped)
 
45
                          TestCase, TestSkipped, test_commit)
46
46
from bzrlib.transform import TreeTransform
47
47
from bzrlib.workingtree import WorkingTree
48
48
 
348
348
                          target.repository, read_bundle(text))
349
349
 
350
350
 
351
 
class V08BundleTester(TestCaseWithTransport):
352
 
 
353
 
    format = '0.8'
 
351
class BundleTester(object):
354
352
 
355
353
    def bzrdir_format(self):
356
354
        format = bzrdir.BzrDirMetaFormat1()
379
377
        rev = self.b1.repository.get_revision(rev_id)
380
378
        self.assertEqual(bundle_txt.readline().decode('utf-8'),
381
379
                         u'# message:\n')
382
 
 
383
 
        open(',,bundle', 'wb').write(bundle_txt.getvalue())
384
380
        bundle_txt.seek(0)
385
381
        return bundle_txt, rev_ids
386
382
 
551
547
        self.tree1.commit('add one', rev_id='a@cset-0-1')
552
548
 
553
549
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
554
 
        # FIXME: The current write_bundle api no longer supports
555
 
        #        setting a custom summary message
556
 
        #        We should re-introduce the ability, and update
557
 
        #        the tests to make sure it works.
558
 
        # bundle = self.get_valid_bundle(None, 'a@cset-0-1',
559
 
        #         message='With a specialized message')
560
550
 
561
551
        # Make sure we can handle files with spaces, tabs, other
562
552
        # bogus characters
575
565
        tt = TreeTransform(self.tree1)
576
566
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
577
567
        tt.apply()
 
568
        # have to fix length of file-id so that we can predictably rewrite
 
569
        # a (length-prefixed) record containing it later.
 
570
        self.tree1.add('with space.txt', 'withspace-id')
578
571
        self.tree1.add([
579
 
                'with space.txt'
580
 
                , 'dir'
 
572
                  'dir'
581
573
                , 'dir/filein subdir.c'
582
574
                , 'dir/WithCaps.txt'
583
575
                , 'dir/ pre space'
607
599
        self.tree1.commit('removed', rev_id='a@cset-0-3')
608
600
        
609
601
        bundle = self.get_valid_bundle('a@cset-0-2', 'a@cset-0-3')
610
 
        self.assertRaises(TestamentMismatch, self.get_invalid_bundle, 
611
 
                          'a@cset-0-2', 'a@cset-0-3')
 
602
        self.assertRaises((TestamentMismatch,
 
603
            errors.VersionedFileInvalidChecksum), self.get_invalid_bundle,
 
604
            'a@cset-0-2', 'a@cset-0-3')
612
605
        # Check a rollup bundle 
613
606
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
614
607
 
622
615
 
623
616
        # Modified files
624
617
        open('b1/sub/dir/WithCaps.txt', 'ab').write('\nAdding some text\n')
625
 
        open('b1/sub/dir/ pre space', 'ab').write('\r\nAdding some\r\nDOS format lines\r\n')
 
618
        open('b1/sub/dir/ pre space', 'ab').write(
 
619
             '\r\nAdding some\r\nDOS format lines\r\n')
626
620
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
627
621
        self.tree1.rename_one('sub/dir/ pre space', 
628
622
                              'sub/ start space')
642
636
        self.assertEqualDiff(tree1_inv, tree2_inv)
643
637
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
644
638
        other.commit('rename file', rev_id='a@cset-0-6b')
645
 
        _merge_helper([other.basedir, -1], [None, None],
646
 
                      this_dir=self.tree1.basedir)
 
639
        self.tree1.merge_from_branch(other.branch)
647
640
        self.tree1.commit(u'Merge', rev_id='a@cset-0-7',
648
641
                          verbose=False)
649
642
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
687
680
        
688
681
        # Add
689
682
        tt.new_file('file', tt.root, '\x00\n\x00\r\x01\n\x02\r\xff', 'binary-1')
690
 
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff', 'binary-2')
 
683
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
 
684
            'binary-2')
691
685
        tt.apply()
692
686
        self.tree1.commit('add binary', rev_id='b@cset-0-1')
693
687
        self.get_valid_bundle('null:', 'b@cset-0-1')
744
738
        tt.create_file('file2', trans_id)
745
739
        tt.apply()
746
740
        other.commit('modify text in another tree', rev_id='a@lmod-0-2b')
747
 
        _merge_helper([other.basedir, -1], [None, None],
748
 
                      this_dir=self.tree1.basedir)
 
741
        self.tree1.merge_from_branch(other.branch)
749
742
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-3',
750
743
                          verbose=False)
751
744
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-4')
766
759
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
767
760
                               'a@cset-0-1', bundle_file, format=self.format)
768
761
        self.assertNotContainsRe(bundle_file.getvalue(), '\btwo\b')
769
 
        self.assertContainsRe(bundle_file.getvalue(), 'one')
770
 
        self.assertContainsRe(bundle_file.getvalue(), 'three')
 
762
        self.assertContainsRe(self.get_raw(bundle_file), 'one')
 
763
        self.assertContainsRe(self.get_raw(bundle_file), 'three')
 
764
 
 
765
    def test_bundle_same_basis(self):
 
766
        """Ensure using the basis as the target doesn't cause an error"""
 
767
        self.tree1 = self.make_branch_and_tree('b1')
 
768
        self.tree1.commit('add file', rev_id='a@cset-0-1')
 
769
        bundle_file = StringIO()
 
770
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-1',
 
771
                               'a@cset-0-1', bundle_file)
 
772
 
 
773
    @staticmethod
 
774
    def get_raw(bundle_file):
 
775
        return bundle_file.getvalue()
771
776
 
772
777
    def test_unicode_bundle(self):
773
778
        # Handle international characters
892
897
        self.b1 = self.tree1.branch
893
898
        self.tree1.commit('message', rev_id='revid1')
894
899
        bundle = self.get_valid_bundle('null:', 'revid1')
895
 
        tree = bundle.revision_tree(self.b1.repository, 'revid1')
 
900
        tree = self.get_bundle_tree(bundle, 'revid1')
896
901
        self.assertEqual('revid1', tree.inventory.root.revision)
897
902
 
898
903
    def test_install_revisions(self):
915
920
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
916
921
        self.b1 = tree.branch
917
922
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
923
        bundle = read_bundle(bundle_sio)
 
924
        revision_info = bundle.revisions[0]
 
925
        self.assertEqual('rev1', revision_info.revision_id)
 
926
        rev = revision_info.as_revision()
 
927
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
928
                         rev.properties)
 
929
 
 
930
    def test_bundle_sorted_properties(self):
 
931
        """For stability the writer should write properties in sorted order."""
 
932
        tree = self.make_branch_and_memory_tree('tree')
 
933
        tree.lock_write()
 
934
        self.addCleanup(tree.unlock)
 
935
 
 
936
        tree.add([''], ['TREE_ROOT'])
 
937
        tree.commit('One', rev_id='rev1',
 
938
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
 
939
        self.b1 = tree.branch
 
940
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
941
        bundle = read_bundle(bundle_sio)
 
942
        revision_info = bundle.revisions[0]
 
943
        self.assertEqual('rev1', revision_info.revision_id)
 
944
        rev = revision_info.as_revision()
 
945
        self.assertEqual({'branch-nick':'tree', 'a':'4', 'b':'3', 'c':'2',
 
946
                          'd':'1'}, rev.properties)
 
947
 
 
948
    def test_bundle_unicode_properties(self):
 
949
        """We should be able to round trip a non-ascii property."""
 
950
        tree = self.make_branch_and_memory_tree('tree')
 
951
        tree.lock_write()
 
952
        self.addCleanup(tree.unlock)
 
953
 
 
954
        tree.add([''], ['TREE_ROOT'])
 
955
        # Revisions themselves do not require anything about revision property
 
956
        # keys, other than that they are a basestring, and do not contain
 
957
        # whitespace.
 
958
        # However, Testaments assert than they are str(), and thus should not
 
959
        # be Unicode.
 
960
        tree.commit('One', rev_id='rev1',
 
961
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
 
962
        self.b1 = tree.branch
 
963
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
964
        bundle = read_bundle(bundle_sio)
 
965
        revision_info = bundle.revisions[0]
 
966
        self.assertEqual('rev1', revision_info.revision_id)
 
967
        rev = revision_info.as_revision()
 
968
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
 
969
                          'alpha':u'\u03b1'}, rev.properties)
 
970
 
 
971
    def test_bundle_with_ghosts(self):
 
972
        tree = self.make_branch_and_tree('tree')
 
973
        self.b1 = tree.branch
 
974
        self.build_tree_contents([('tree/file', 'content1')])
 
975
        tree.add(['file'])
 
976
        tree.commit('rev1')
 
977
        self.build_tree_contents([('tree/file', 'content2')])
 
978
        tree.add_parent_tree_id('ghost')
 
979
        tree.commit('rev2', rev_id='rev2')
 
980
        bundle = self.get_valid_bundle('null:', 'rev2')
 
981
 
 
982
    def make_simple_tree(self, format=None):
 
983
        tree = self.make_branch_and_tree('b1', format=format)
 
984
        self.b1 = tree.branch
 
985
        self.build_tree(['b1/file'])
 
986
        tree.add('file')
 
987
        return tree
 
988
 
 
989
    def test_across_serializers(self):
 
990
        tree = self.make_simple_tree('knit')
 
991
        tree.commit('hello', rev_id='rev1')
 
992
        tree.commit('hello', rev_id='rev2')
 
993
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
994
        repo = self.make_repository('repo', format='dirstate-with-subtree')
 
995
        bundle.install_revisions(repo)
 
996
        inv_text = repo.get_inventory_xml('rev2')
 
997
        self.assertNotContainsRe(inv_text, 'format="5"')
 
998
        self.assertContainsRe(inv_text, 'format="7"')
 
999
 
 
1000
    def test_across_models(self):
 
1001
        tree = self.make_simple_tree('knit')
 
1002
        tree.commit('hello', rev_id='rev1')
 
1003
        tree.commit('hello', rev_id='rev2')
 
1004
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1005
        repo = self.make_repository('repo', format='dirstate-with-subtree')
 
1006
        bundle.install_revisions(repo)
 
1007
        inv = repo.get_inventory('rev2')
 
1008
        self.assertEqual('rev2', inv.root.revision)
 
1009
        root_vf = repo.weave_store.get_weave(inv.root.file_id,
 
1010
                                             repo.get_transaction())
 
1011
        self.assertEqual(root_vf.versions(), ['rev1', 'rev2'])
 
1012
 
 
1013
    def test_across_models_incompatible(self):
 
1014
        tree = self.make_simple_tree('dirstate-with-subtree')
 
1015
        tree.commit('hello', rev_id='rev1')
 
1016
        tree.commit('hello', rev_id='rev2')
 
1017
        try:
 
1018
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1019
        except errors.IncompatibleBundleFormat:
 
1020
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1021
        repo = self.make_repository('repo', format='knit')
 
1022
        bundle.install_revisions(repo)
 
1023
 
 
1024
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1025
        self.assertRaises(errors.IncompatibleRevision,
 
1026
                          bundle.install_revisions, repo)
 
1027
 
 
1028
    def test_get_merge_request(self):
 
1029
        tree = self.make_simple_tree()
 
1030
        tree.commit('hello', rev_id='rev1')
 
1031
        tree.commit('hello', rev_id='rev2')
 
1032
        bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1033
        result = bundle.get_merge_request(tree.branch.repository)
 
1034
        self.assertEqual((None, 'rev1', 'inapplicable'), result)
 
1035
 
 
1036
    def test_with_subtree(self):
 
1037
        tree = self.make_branch_and_tree('tree',
 
1038
                                         format='dirstate-with-subtree')
 
1039
        self.b1 = tree.branch
 
1040
        subtree = self.make_branch_and_tree('tree/subtree',
 
1041
                                            format='dirstate-with-subtree')
 
1042
        tree.add('subtree')
 
1043
        tree.commit('hello', rev_id='rev1')
 
1044
        try:
 
1045
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1046
        except errors.IncompatibleBundleFormat:
 
1047
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1048
        if isinstance(bundle, v09.BundleInfo09):
 
1049
            raise TestSkipped("Format 0.9 doesn't work with subtrees")
 
1050
        repo = self.make_repository('repo', format='knit')
 
1051
        self.assertRaises(errors.IncompatibleRevision,
 
1052
                          bundle.install_revisions, repo)
 
1053
        repo2 = self.make_repository('repo2', format='dirstate-with-subtree')
 
1054
        bundle.install_revisions(repo2)
 
1055
 
 
1056
    def test_revision_id_with_slash(self):
 
1057
        self.tree1 = self.make_branch_and_tree('tree')
 
1058
        self.b1 = self.tree1.branch
 
1059
        try:
 
1060
            self.tree1.commit('Revision/id/with/slashes', rev_id='rev/id')
 
1061
        except ValueError:
 
1062
            raise TestSkipped("Repository doesn't support revision ids with"
 
1063
                              " slashes")
 
1064
        bundle = self.get_valid_bundle('null:', 'rev/id')
 
1065
 
 
1066
 
 
1067
class V08BundleTester(BundleTester, TestCaseWithTransport):
 
1068
 
 
1069
    format = '0.8'
 
1070
 
 
1071
    def test_bundle_empty_property(self):
 
1072
        """Test serializing revision properties with an empty value."""
 
1073
        tree = self.make_branch_and_memory_tree('tree')
 
1074
        tree.lock_write()
 
1075
        self.addCleanup(tree.unlock)
 
1076
        tree.add([''], ['TREE_ROOT'])
 
1077
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1078
        self.b1 = tree.branch
 
1079
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
918
1080
        self.assertContainsRe(bundle_sio.getvalue(),
919
1081
                              '# properties:\n'
920
1082
                              '#   branch-nick: tree\n'
928
1090
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
929
1091
                         rev.properties)
930
1092
 
 
1093
    def get_bundle_tree(self, bundle, revision_id):
 
1094
        repository = self.make_repository('repo')
 
1095
        return bundle.revision_tree(repository, 'revid1')
 
1096
 
931
1097
    def test_bundle_empty_property_alt(self):
932
1098
        """Test serializing revision properties with an empty value.
933
1099
 
1037
1203
        return format
1038
1204
 
1039
1205
 
1040
 
class MungedBundleTester(TestCaseWithTransport):
 
1206
class V4BundleTester(BundleTester, TestCaseWithTransport):
 
1207
 
 
1208
    format = '4'
 
1209
 
 
1210
    def get_valid_bundle(self, base_rev_id, rev_id, checkout_dir=None):
 
1211
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1212
        Make sure that the text generated is valid, and that it
 
1213
        can be applied against the base, and generate the same information.
 
1214
        
 
1215
        :return: The in-memory bundle 
 
1216
        """
 
1217
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1218
 
 
1219
        # This should also validate the generated bundle 
 
1220
        bundle = read_bundle(bundle_txt)
 
1221
        repository = self.b1.repository
 
1222
        for bundle_rev in bundle.real_revisions:
 
1223
            # These really should have already been checked when we read the
 
1224
            # bundle, since it computes the sha1 hash for the revision, which
 
1225
            # only will match if everything is okay, but lets be explicit about
 
1226
            # it
 
1227
            branch_rev = repository.get_revision(bundle_rev.revision_id)
 
1228
            for a in ('inventory_sha1', 'revision_id', 'parent_ids',
 
1229
                      'timestamp', 'timezone', 'message', 'committer', 
 
1230
                      'parent_ids', 'properties'):
 
1231
                self.assertEqual(getattr(branch_rev, a), 
 
1232
                                 getattr(bundle_rev, a))
 
1233
            self.assertEqual(len(branch_rev.parent_ids), 
 
1234
                             len(bundle_rev.parent_ids))
 
1235
        self.assertEqual(set(rev_ids),
 
1236
                         set([r.revision_id for r in bundle.real_revisions]))
 
1237
        self.valid_apply_bundle(base_rev_id, bundle,
 
1238
                                   checkout_dir=checkout_dir)
 
1239
 
 
1240
        return bundle
 
1241
 
 
1242
    def get_invalid_bundle(self, base_rev_id, rev_id):
 
1243
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1244
        Munge the text so that it's invalid.
 
1245
 
 
1246
        :return: The in-memory bundle
 
1247
        """
 
1248
        from bzrlib.bundle import serializer
 
1249
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1250
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1251
        new_text = new_text.replace('<file file_id="exe-1"',
 
1252
                                    '<file executable="y" file_id="exe-1"')
 
1253
        new_text = new_text.replace('B372', 'B387')
 
1254
        bundle_txt = StringIO()
 
1255
        bundle_txt.write(serializer._get_bundle_header('4'))
 
1256
        bundle_txt.write('\n')
 
1257
        bundle_txt.write(new_text.encode('bz2'))
 
1258
        bundle_txt.seek(0)
 
1259
        bundle = read_bundle(bundle_txt)
 
1260
        self.valid_apply_bundle(base_rev_id, bundle)
 
1261
        return bundle
 
1262
 
 
1263
    def create_bundle_text(self, base_rev_id, rev_id):
 
1264
        bundle_txt = StringIO()
 
1265
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id, 
 
1266
                               bundle_txt, format=self.format)
 
1267
        bundle_txt.seek(0)
 
1268
        self.assertEqual(bundle_txt.readline(), 
 
1269
                         '# Bazaar revision bundle v%s\n' % self.format)
 
1270
        self.assertEqual(bundle_txt.readline(), '#\n')
 
1271
        rev = self.b1.repository.get_revision(rev_id)
 
1272
        bundle_txt.seek(0)
 
1273
        return bundle_txt, rev_ids
 
1274
 
 
1275
    def get_bundle_tree(self, bundle, revision_id):
 
1276
        repository = self.make_repository('repo')
 
1277
        bundle.install_revisions(repository)
 
1278
        return repository.revision_tree(revision_id)
 
1279
 
 
1280
    def test_creation(self):
 
1281
        tree = self.make_branch_and_tree('tree')
 
1282
        self.build_tree_contents([('tree/file', 'contents1\nstatic\n')])
 
1283
        tree.add('file', 'fileid-2')
 
1284
        tree.commit('added file', rev_id='rev1')
 
1285
        self.build_tree_contents([('tree/file', 'contents2\nstatic\n')])
 
1286
        tree.commit('changed file', rev_id='rev2')
 
1287
        s = StringIO()
 
1288
        serializer = BundleSerializerV4('1.0')
 
1289
        serializer.write(tree.branch.repository, ['rev1', 'rev2'], {}, s)
 
1290
        s.seek(0)
 
1291
        tree2 = self.make_branch_and_tree('target')
 
1292
        target_repo = tree2.branch.repository
 
1293
        install_bundle(target_repo, serializer.read(s))
 
1294
        vf = target_repo.weave_store.get_weave('fileid-2',
 
1295
            target_repo.get_transaction())
 
1296
        self.assertEqual('contents1\nstatic\n', vf.get_text('rev1'))
 
1297
        self.assertEqual('contents2\nstatic\n', vf.get_text('rev2'))
 
1298
        rtree = target_repo.revision_tree('rev2')
 
1299
        inventory_vf = target_repo.get_inventory_weave()
 
1300
        self.assertEqual(['rev1'], inventory_vf.get_parents('rev2'))
 
1301
        self.assertEqual('changed file',
 
1302
                         target_repo.get_revision('rev2').message)
 
1303
 
 
1304
    @staticmethod
 
1305
    def get_raw(bundle_file):
 
1306
        bundle_file.seek(0)
 
1307
        line = bundle_file.readline()
 
1308
        line = bundle_file.readline()
 
1309
        lines = bundle_file.readlines()
 
1310
        return ''.join(lines).decode('bz2')
 
1311
 
 
1312
    def test_copy_signatures(self):
 
1313
        tree_a = self.make_branch_and_tree('tree_a')
 
1314
        import bzrlib.gpg
 
1315
        import bzrlib.commit as commit
 
1316
        oldstrategy = bzrlib.gpg.GPGStrategy
 
1317
        branch = tree_a.branch
 
1318
        repo_a = branch.repository
 
1319
        tree_a.commit("base", allow_pointless=True, rev_id='A')
 
1320
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
 
1321
        try:
 
1322
            from bzrlib.testament import Testament
 
1323
            # monkey patch gpg signing mechanism
 
1324
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
1325
            new_config = test_commit.MustSignConfig(branch)
 
1326
            commit.Commit(config=new_config).commit(message="base",
 
1327
                                                    allow_pointless=True,
 
1328
                                                    rev_id='B',
 
1329
                                                    working_tree=tree_a)
 
1330
            def sign(text):
 
1331
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
 
1332
            self.assertTrue(repo_a.has_signature_for_revision_id('B'))
 
1333
        finally:
 
1334
            bzrlib.gpg.GPGStrategy = oldstrategy
 
1335
        tree_b = self.make_branch_and_tree('tree_b')
 
1336
        repo_b = tree_b.branch.repository
 
1337
        s = StringIO()
 
1338
        serializer = BundleSerializerV4('4')
 
1339
        serializer.write(tree_a.branch.repository, ['A', 'B'], {}, s)
 
1340
        s.seek(0)
 
1341
        install_bundle(repo_b, serializer.read(s))
 
1342
        self.assertTrue(repo_b.has_signature_for_revision_id('B'))
 
1343
        self.assertEqual(repo_b.get_signature_text('B'),
 
1344
                         repo_a.get_signature_text('B'))
 
1345
        s.seek(0)
 
1346
        # ensure repeat installs are harmless
 
1347
        install_bundle(repo_b, serializer.read(s))
 
1348
 
 
1349
 
 
1350
class V4WeaveBundleTester(V4BundleTester):
 
1351
 
 
1352
    def bzrdir_format(self):
 
1353
        return 'metaweave'
 
1354
 
 
1355
 
 
1356
class MungedBundleTester(object):
1041
1357
 
1042
1358
    def build_test_bundle(self):
1043
1359
        wt = self.make_branch_and_tree('b1')
1052
1368
 
1053
1369
        bundle_txt = StringIO()
1054
1370
        rev_ids = write_bundle(wt.branch.repository, 'a@cset-0-2',
1055
 
                               'a@cset-0-1', bundle_txt)
1056
 
        self.assertEqual(['a@cset-0-2'], rev_ids)
 
1371
                               'a@cset-0-1', bundle_txt, self.format)
 
1372
        self.assertEqual(set(['a@cset-0-2']), set(rev_ids))
1057
1373
        bundle_txt.seek(0, 0)
1058
1374
        return bundle_txt
1059
1375
 
1088
1404
        bundle = read_bundle(bundle_txt)
1089
1405
        self.check_valid(bundle)
1090
1406
 
 
1407
 
 
1408
class MungedBundleTesterV09(TestCaseWithTransport, MungedBundleTester):
 
1409
 
 
1410
    format = '0.9'
 
1411
 
1091
1412
    def test_missing_trailing_whitespace(self):
1092
1413
        bundle_txt = self.build_test_bundle()
1093
1414
 
1121
1442
        bundle = read_bundle(bundle_txt)
1122
1443
        self.check_valid(bundle)
1123
1444
 
 
1445
 
 
1446
class MungedBundleTesterV4(TestCaseWithTransport, MungedBundleTester):
 
1447
 
 
1448
    format = '4'
 
1449
 
 
1450
 
 
1451
class TestBundleWriterReader(TestCase):
 
1452
 
 
1453
    def test_roundtrip_record(self):
 
1454
        fileobj = StringIO()
 
1455
        writer = v4.BundleWriter(fileobj)
 
1456
        writer.begin()
 
1457
        writer.add_info_record(foo='bar')
 
1458
        writer._add_record("Record body", {'parents': ['1', '3'],
 
1459
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1460
        writer.end()
 
1461
        fileobj.seek(0)
 
1462
        record_iter = v4.BundleReader(fileobj).iter_records()
 
1463
        record = record_iter.next()
 
1464
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1465
            'info', None, None), record)
 
1466
        record = record_iter.next()
 
1467
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
 
1468
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1469
                          record)
 
1470
 
 
1471
    def test_encode_name(self):
 
1472
        self.assertEqual('revision/rev1',
 
1473
            v4.BundleWriter.encode_name('revision', 'rev1'))
 
1474
        self.assertEqual('file/rev//1/file-id-1',
 
1475
            v4.BundleWriter.encode_name('file', 'rev/1', 'file-id-1'))
 
1476
        self.assertEqual('info',
 
1477
            v4.BundleWriter.encode_name('info', None, None))
 
1478
 
 
1479
    def test_decode_name(self):
 
1480
        self.assertEqual(('revision', 'rev1', None),
 
1481
            v4.BundleReader.decode_name('revision/rev1'))
 
1482
        self.assertEqual(('file', 'rev/1', 'file-id-1'),
 
1483
            v4.BundleReader.decode_name('file/rev//1/file-id-1'))
 
1484
        self.assertEqual(('info', None, None),
 
1485
                         v4.BundleReader.decode_name('info'))
 
1486
 
 
1487
    def test_too_many_names(self):
 
1488
        fileobj = StringIO()
 
1489
        writer = v4.BundleWriter(fileobj)
 
1490
        writer.begin()
 
1491
        writer.add_info_record(foo='bar')
 
1492
        writer._container.add_bytes_record('blah', ['two', 'names'])
 
1493
        writer.end()
 
1494
        fileobj.seek(0)
 
1495
        record_iter = v4.BundleReader(fileobj).iter_records()
 
1496
        record = record_iter.next()
 
1497
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1498
            'info', None, None), record)
 
1499
        self.assertRaises(BadBundle, record_iter.next)