/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: Martin Pool
  • Date: 2007-08-20 05:53:39 UTC
  • mfrom: (2727 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2730.
  • Revision ID: mbp@sourcefrog.net-20070820055339-uzei7f7i7jo6tugg
merge trunk

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, 
41
42
from bzrlib.repofmt import knitrepo
42
43
from bzrlib.osutils import has_symlinks, sha_file
43
44
from bzrlib.tests import (TestCaseInTempDir, TestCaseWithTransport,
44
 
                          TestCase, TestSkipped)
 
45
                          TestCase, TestSkipped, test_commit)
45
46
from bzrlib.transform import TreeTransform
46
47
from bzrlib.workingtree import WorkingTree
47
48
 
336
337
        source.commit('one', rev_id='one-id')
337
338
        source.commit('two', rev_id='two-id')
338
339
        text = StringIO()
339
 
        write_bundle(source.branch.repository, 'two-id', None, text, 
 
340
        write_bundle(source.branch.repository, 'two-id', 'null:', text,
340
341
                     format='0.9')
341
342
        text.seek(0)
342
343
 
347
348
                          target.repository, read_bundle(text))
348
349
 
349
350
 
350
 
class V08BundleTester(TestCaseWithTransport):
351
 
 
352
 
    format = '0.8'
 
351
class BundleTester(object):
353
352
 
354
353
    def bzrdir_format(self):
355
354
        format = bzrdir.BzrDirMetaFormat1()
378
377
        rev = self.b1.repository.get_revision(rev_id)
379
378
        self.assertEqual(bundle_txt.readline().decode('utf-8'),
380
379
                         u'# message:\n')
381
 
 
382
 
        open(',,bundle', 'wb').write(bundle_txt.getvalue())
383
380
        bundle_txt.seek(0)
384
381
        return bundle_txt, rev_ids
385
382
 
456
453
                os.mkdir(checkout_dir)
457
454
        tree = self.make_branch_and_tree(checkout_dir)
458
455
        s = StringIO()
459
 
        ancestors = write_bundle(self.b1.repository, rev_id, None, s,
 
456
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
460
457
                                 format=self.format)
461
458
        s.seek(0)
462
459
        assert isinstance(s.getvalue(), str), (
482
479
                    continue
483
480
                self.assertEqual(old_file.read(),
484
481
                                 new.get_file(inventory_id).read())
485
 
        if rev_id is not None:
 
482
        if not _mod_revision.is_null(rev_id):
486
483
            rh = self.b1.revision_history()
487
484
            tree.branch.set_revision_history(rh[:rh.index(rev_id)+1])
488
485
            tree.update()
549
546
        self.tree1.add('one')
550
547
        self.tree1.commit('add one', rev_id='a@cset-0-1')
551
548
 
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')
 
549
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
559
550
 
560
551
        # Make sure we can handle files with spaces, tabs, other
561
552
        # bogus characters
574
565
        tt = TreeTransform(self.tree1)
575
566
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
576
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')
577
571
        self.tree1.add([
578
 
                'with space.txt'
579
 
                , 'dir'
 
572
                  'dir'
580
573
                , 'dir/filein subdir.c'
581
574
                , 'dir/WithCaps.txt'
582
575
                , 'dir/ pre space'
591
584
        bundle = self.get_valid_bundle('a@cset-0-1', 'a@cset-0-2')
592
585
 
593
586
        # Check a rollup bundle 
594
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-2')
 
587
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
595
588
 
596
589
        # Now delete entries
597
590
        self.tree1.remove(
606
599
        self.tree1.commit('removed', rev_id='a@cset-0-3')
607
600
        
608
601
        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')
 
602
        self.assertRaises((TestamentMismatch,
 
603
            errors.VersionedFileInvalidChecksum), self.get_invalid_bundle,
 
604
            'a@cset-0-2', 'a@cset-0-3')
611
605
        # Check a rollup bundle 
612
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-3')
 
606
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
613
607
 
614
608
        # Now move the directory
615
609
        self.tree1.rename_one('dir', 'sub/dir')
617
611
 
618
612
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
619
613
        # Check a rollup bundle 
620
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-4')
 
614
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
621
615
 
622
616
        # Modified files
623
617
        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')
 
618
        open('b1/sub/dir/ pre space', 'ab').write(
 
619
             '\r\nAdding some\r\nDOS format lines\r\n')
625
620
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
626
621
        self.tree1.rename_one('sub/dir/ pre space', 
627
622
                              'sub/ start space')
641
636
        self.assertEqualDiff(tree1_inv, tree2_inv)
642
637
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
643
638
        other.commit('rename file', rev_id='a@cset-0-6b')
644
 
        _merge_helper([other.basedir, -1], [None, None],
645
 
                      this_dir=self.tree1.basedir)
 
639
        self.tree1.merge_from_branch(other.branch)
646
640
        self.tree1.commit(u'Merge', rev_id='a@cset-0-7',
647
641
                          verbose=False)
648
642
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
656
650
        tt.new_symlink('link', tt.root, 'bar/foo', 'link-1')
657
651
        tt.apply()
658
652
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
659
 
        self.get_valid_bundle(None, 'l@cset-0-1')
 
653
        self.get_valid_bundle('null:', 'l@cset-0-1')
660
654
        tt = TreeTransform(self.tree1)
661
655
        trans_id = tt.trans_id_tree_file_id('link-1')
662
656
        tt.adjust_path('link2', tt.root, trans_id)
686
680
        
687
681
        # Add
688
682
        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')
 
683
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
 
684
            'binary-2')
690
685
        tt.apply()
691
686
        self.tree1.commit('add binary', rev_id='b@cset-0-1')
692
 
        self.get_valid_bundle(None, 'b@cset-0-1')
 
687
        self.get_valid_bundle('null:', 'b@cset-0-1')
693
688
 
694
689
        # Delete
695
690
        tt = TreeTransform(self.tree1)
719
714
        self.get_valid_bundle('b@cset-0-3', 'b@cset-0-4')
720
715
 
721
716
        # Rollup
722
 
        self.get_valid_bundle(None, 'b@cset-0-4')
 
717
        self.get_valid_bundle('null:', 'b@cset-0-4')
723
718
 
724
719
    def test_last_modified(self):
725
720
        self.tree1 = self.make_branch_and_tree('b1')
743
738
        tt.create_file('file2', trans_id)
744
739
        tt.apply()
745
740
        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)
 
741
        self.tree1.merge_from_branch(other.branch)
748
742
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-3',
749
743
                          verbose=False)
750
744
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-4')
765
759
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
766
760
                               'a@cset-0-1', bundle_file, format=self.format)
767
761
        self.assertNotContainsRe(bundle_file.getvalue(), '\btwo\b')
768
 
        self.assertContainsRe(bundle_file.getvalue(), 'one')
769
 
        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()
770
776
 
771
777
    def test_unicode_bundle(self):
772
778
        # Handle international characters
799
805
                              " combining characters.")
800
806
 
801
807
        # Add
802
 
        bundle = self.get_valid_bundle(None, 'i18n-1')
 
808
        bundle = self.get_valid_bundle('null:', 'i18n-1')
803
809
 
804
810
        # Modified
805
811
        f = open(u'b1/with Dod\xe9', 'wb')
823
829
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
824
830
 
825
831
        # Rollup
826
 
        bundle = self.get_valid_bundle(None, 'i18n-4')
 
832
        bundle = self.get_valid_bundle('null:', 'i18n-4')
827
833
 
828
834
 
829
835
    def test_whitespace_bundle(self):
841
847
        # Added
842
848
        self.tree1.commit('funky whitespace', rev_id='white-1')
843
849
 
844
 
        bundle = self.get_valid_bundle(None, 'white-1')
 
850
        bundle = self.get_valid_bundle('null:', 'white-1')
845
851
 
846
852
        # Modified
847
853
        open('b1/trailing space ', 'ab').write('add some text\n')
862
868
        bundle = self.get_valid_bundle('white-3', 'white-4')
863
869
        
864
870
        # Now test a complet roll-up
865
 
        bundle = self.get_valid_bundle(None, 'white-4')
 
871
        bundle = self.get_valid_bundle('null:', 'white-4')
866
872
 
867
873
    def test_alt_timezone_bundle(self):
868
874
        self.tree1 = self.make_branch_and_memory_tree('b1')
878
884
        self.tree1.commit('non-hour offset timezone', rev_id='tz-1',
879
885
                          timezone=19800, timestamp=1152544886.0)
880
886
 
881
 
        bundle = self.get_valid_bundle(None, 'tz-1')
 
887
        bundle = self.get_valid_bundle('null:', 'tz-1')
882
888
        
883
889
        rev = bundle.revisions[0]
884
890
        self.assertEqual('Mon 2006-07-10 20:51:26.000000000 +0530', rev.date)
890
896
        self.tree1 = self.make_branch_and_tree('b1')
891
897
        self.b1 = self.tree1.branch
892
898
        self.tree1.commit('message', rev_id='revid1')
893
 
        bundle = self.get_valid_bundle(None, 'revid1')
894
 
        tree = bundle.revision_tree(self.b1.repository, 'revid1')
 
899
        bundle = self.get_valid_bundle('null:', 'revid1')
 
900
        tree = self.get_bundle_tree(bundle, 'revid1')
895
901
        self.assertEqual('revid1', tree.inventory.root.revision)
896
902
 
897
903
    def test_install_revisions(self):
898
904
        self.tree1 = self.make_branch_and_tree('b1')
899
905
        self.b1 = self.tree1.branch
900
906
        self.tree1.commit('message', rev_id='rev2a')
901
 
        bundle = self.get_valid_bundle(None, 'rev2a')
 
907
        bundle = self.get_valid_bundle('null:', 'rev2a')
902
908
        branch2 = self.make_branch('b2')
903
909
        self.assertFalse(branch2.repository.has_revision('rev2a'))
904
910
        target_revision = bundle.install_revisions(branch2.repository)
913
919
        tree.add([''], ['TREE_ROOT'])
914
920
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
915
921
        self.b1 = tree.branch
916
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
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
    def test_skip_file(self):
 
1067
        """Make sure we don't accidentally write to the wrong versionedfile"""
 
1068
        self.tree1 = self.make_branch_and_tree('tree')
 
1069
        self.b1 = self.tree1.branch
 
1070
        # rev1 is not present in bundle, done by fetch
 
1071
        self.build_tree_contents([('tree/file2', 'contents1')])
 
1072
        self.tree1.add('file2', 'file2-id')
 
1073
        self.tree1.commit('rev1', rev_id='reva')
 
1074
        self.build_tree_contents([('tree/file3', 'contents2')])
 
1075
        # rev2 is present in bundle, and done by fetch
 
1076
        # having file1 in the bunle causes file1's versionedfile to be opened.
 
1077
        self.tree1.add('file3', 'file3-id')
 
1078
        self.tree1.commit('rev2')
 
1079
        # Updating file2 should not cause an attempt to add to file1's vf
 
1080
        target = self.tree1.bzrdir.sprout('target').open_workingtree()
 
1081
        self.build_tree_contents([('tree/file2', 'contents3')])
 
1082
        self.tree1.commit('rev3', rev_id='rev3')
 
1083
        bundle = self.get_valid_bundle('reva', 'rev3')
 
1084
        if getattr(bundle, 'get_bundle_reader', None) is None:
 
1085
            raise TestSkipped('Bundle format cannot provide reader')
 
1086
        # be sure that file1 comes before file2
 
1087
        for b, m, k, r, f in bundle.get_bundle_reader().iter_records():
 
1088
            if f == 'file3-id':
 
1089
                break
 
1090
            self.assertNotEqual(f, 'file2-id')
 
1091
        bundle.install_revisions(target.branch.repository)
 
1092
 
 
1093
 
 
1094
class V08BundleTester(BundleTester, TestCaseWithTransport):
 
1095
 
 
1096
    format = '0.8'
 
1097
 
 
1098
    def test_bundle_empty_property(self):
 
1099
        """Test serializing revision properties with an empty value."""
 
1100
        tree = self.make_branch_and_memory_tree('tree')
 
1101
        tree.lock_write()
 
1102
        self.addCleanup(tree.unlock)
 
1103
        tree.add([''], ['TREE_ROOT'])
 
1104
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1105
        self.b1 = tree.branch
 
1106
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
917
1107
        self.assertContainsRe(bundle_sio.getvalue(),
918
1108
                              '# properties:\n'
919
1109
                              '#   branch-nick: tree\n'
927
1117
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
928
1118
                         rev.properties)
929
1119
 
 
1120
    def get_bundle_tree(self, bundle, revision_id):
 
1121
        repository = self.make_repository('repo')
 
1122
        return bundle.revision_tree(repository, 'revid1')
 
1123
 
930
1124
    def test_bundle_empty_property_alt(self):
931
1125
        """Test serializing revision properties with an empty value.
932
1126
 
941
1135
        tree.add([''], ['TREE_ROOT'])
942
1136
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
943
1137
        self.b1 = tree.branch
944
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
1138
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
945
1139
        txt = bundle_sio.getvalue()
946
1140
        loc = txt.find('#   empty: ') + len('#   empty:')
947
1141
        # Create a new bundle, which strips the trailing space after empty
970
1164
        tree.commit('One', rev_id='rev1',
971
1165
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
972
1166
        self.b1 = tree.branch
973
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
1167
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
974
1168
        self.assertContainsRe(bundle_sio.getvalue(),
975
1169
                              '# properties:\n'
976
1170
                              '#   a: 4\n'
1001
1195
        tree.commit('One', rev_id='rev1',
1002
1196
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
1003
1197
        self.b1 = tree.branch
1004
 
        bundle_sio, revision_ids = self.create_bundle_text(None, 'rev1')
 
1198
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1005
1199
        self.assertContainsRe(bundle_sio.getvalue(),
1006
1200
                              '# properties:\n'
1007
1201
                              '#   alpha: \xce\xb1\n'
1036
1230
        return format
1037
1231
 
1038
1232
 
1039
 
class MungedBundleTester(TestCaseWithTransport):
 
1233
class V4BundleTester(BundleTester, TestCaseWithTransport):
 
1234
 
 
1235
    format = '4'
 
1236
 
 
1237
    def get_valid_bundle(self, base_rev_id, rev_id, checkout_dir=None):
 
1238
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1239
        Make sure that the text generated is valid, and that it
 
1240
        can be applied against the base, and generate the same information.
 
1241
        
 
1242
        :return: The in-memory bundle 
 
1243
        """
 
1244
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1245
 
 
1246
        # This should also validate the generated bundle 
 
1247
        bundle = read_bundle(bundle_txt)
 
1248
        repository = self.b1.repository
 
1249
        for bundle_rev in bundle.real_revisions:
 
1250
            # These really should have already been checked when we read the
 
1251
            # bundle, since it computes the sha1 hash for the revision, which
 
1252
            # only will match if everything is okay, but lets be explicit about
 
1253
            # it
 
1254
            branch_rev = repository.get_revision(bundle_rev.revision_id)
 
1255
            for a in ('inventory_sha1', 'revision_id', 'parent_ids',
 
1256
                      'timestamp', 'timezone', 'message', 'committer', 
 
1257
                      'parent_ids', 'properties'):
 
1258
                self.assertEqual(getattr(branch_rev, a), 
 
1259
                                 getattr(bundle_rev, a))
 
1260
            self.assertEqual(len(branch_rev.parent_ids), 
 
1261
                             len(bundle_rev.parent_ids))
 
1262
        self.assertEqual(set(rev_ids),
 
1263
                         set([r.revision_id for r in bundle.real_revisions]))
 
1264
        self.valid_apply_bundle(base_rev_id, bundle,
 
1265
                                   checkout_dir=checkout_dir)
 
1266
 
 
1267
        return bundle
 
1268
 
 
1269
    def get_invalid_bundle(self, base_rev_id, rev_id):
 
1270
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1271
        Munge the text so that it's invalid.
 
1272
 
 
1273
        :return: The in-memory bundle
 
1274
        """
 
1275
        from bzrlib.bundle import serializer
 
1276
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1277
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1278
        new_text = new_text.replace('<file file_id="exe-1"',
 
1279
                                    '<file executable="y" file_id="exe-1"')
 
1280
        new_text = new_text.replace('B222', 'B237')
 
1281
        bundle_txt = StringIO()
 
1282
        bundle_txt.write(serializer._get_bundle_header('4'))
 
1283
        bundle_txt.write('\n')
 
1284
        bundle_txt.write(new_text.encode('bz2'))
 
1285
        bundle_txt.seek(0)
 
1286
        bundle = read_bundle(bundle_txt)
 
1287
        self.valid_apply_bundle(base_rev_id, bundle)
 
1288
        return bundle
 
1289
 
 
1290
    def create_bundle_text(self, base_rev_id, rev_id):
 
1291
        bundle_txt = StringIO()
 
1292
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id, 
 
1293
                               bundle_txt, format=self.format)
 
1294
        bundle_txt.seek(0)
 
1295
        self.assertEqual(bundle_txt.readline(), 
 
1296
                         '# Bazaar revision bundle v%s\n' % self.format)
 
1297
        self.assertEqual(bundle_txt.readline(), '#\n')
 
1298
        rev = self.b1.repository.get_revision(rev_id)
 
1299
        bundle_txt.seek(0)
 
1300
        return bundle_txt, rev_ids
 
1301
 
 
1302
    def get_bundle_tree(self, bundle, revision_id):
 
1303
        repository = self.make_repository('repo')
 
1304
        bundle.install_revisions(repository)
 
1305
        return repository.revision_tree(revision_id)
 
1306
 
 
1307
    def test_creation(self):
 
1308
        tree = self.make_branch_and_tree('tree')
 
1309
        self.build_tree_contents([('tree/file', 'contents1\nstatic\n')])
 
1310
        tree.add('file', 'fileid-2')
 
1311
        tree.commit('added file', rev_id='rev1')
 
1312
        self.build_tree_contents([('tree/file', 'contents2\nstatic\n')])
 
1313
        tree.commit('changed file', rev_id='rev2')
 
1314
        s = StringIO()
 
1315
        serializer = BundleSerializerV4('1.0')
 
1316
        serializer.write(tree.branch.repository, ['rev1', 'rev2'], {}, s)
 
1317
        s.seek(0)
 
1318
        tree2 = self.make_branch_and_tree('target')
 
1319
        target_repo = tree2.branch.repository
 
1320
        install_bundle(target_repo, serializer.read(s))
 
1321
        vf = target_repo.weave_store.get_weave('fileid-2',
 
1322
            target_repo.get_transaction())
 
1323
        self.assertEqual('contents1\nstatic\n', vf.get_text('rev1'))
 
1324
        self.assertEqual('contents2\nstatic\n', vf.get_text('rev2'))
 
1325
        rtree = target_repo.revision_tree('rev2')
 
1326
        inventory_vf = target_repo.get_inventory_weave()
 
1327
        self.assertEqual(['rev1'], inventory_vf.get_parents('rev2'))
 
1328
        self.assertEqual('changed file',
 
1329
                         target_repo.get_revision('rev2').message)
 
1330
 
 
1331
    @staticmethod
 
1332
    def get_raw(bundle_file):
 
1333
        bundle_file.seek(0)
 
1334
        line = bundle_file.readline()
 
1335
        line = bundle_file.readline()
 
1336
        lines = bundle_file.readlines()
 
1337
        return ''.join(lines).decode('bz2')
 
1338
 
 
1339
    def test_copy_signatures(self):
 
1340
        tree_a = self.make_branch_and_tree('tree_a')
 
1341
        import bzrlib.gpg
 
1342
        import bzrlib.commit as commit
 
1343
        oldstrategy = bzrlib.gpg.GPGStrategy
 
1344
        branch = tree_a.branch
 
1345
        repo_a = branch.repository
 
1346
        tree_a.commit("base", allow_pointless=True, rev_id='A')
 
1347
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
 
1348
        try:
 
1349
            from bzrlib.testament import Testament
 
1350
            # monkey patch gpg signing mechanism
 
1351
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
1352
            new_config = test_commit.MustSignConfig(branch)
 
1353
            commit.Commit(config=new_config).commit(message="base",
 
1354
                                                    allow_pointless=True,
 
1355
                                                    rev_id='B',
 
1356
                                                    working_tree=tree_a)
 
1357
            def sign(text):
 
1358
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
 
1359
            self.assertTrue(repo_a.has_signature_for_revision_id('B'))
 
1360
        finally:
 
1361
            bzrlib.gpg.GPGStrategy = oldstrategy
 
1362
        tree_b = self.make_branch_and_tree('tree_b')
 
1363
        repo_b = tree_b.branch.repository
 
1364
        s = StringIO()
 
1365
        serializer = BundleSerializerV4('4')
 
1366
        serializer.write(tree_a.branch.repository, ['A', 'B'], {}, s)
 
1367
        s.seek(0)
 
1368
        install_bundle(repo_b, serializer.read(s))
 
1369
        self.assertTrue(repo_b.has_signature_for_revision_id('B'))
 
1370
        self.assertEqual(repo_b.get_signature_text('B'),
 
1371
                         repo_a.get_signature_text('B'))
 
1372
        s.seek(0)
 
1373
        # ensure repeat installs are harmless
 
1374
        install_bundle(repo_b, serializer.read(s))
 
1375
 
 
1376
 
 
1377
class V4WeaveBundleTester(V4BundleTester):
 
1378
 
 
1379
    def bzrdir_format(self):
 
1380
        return 'metaweave'
 
1381
 
 
1382
 
 
1383
class MungedBundleTester(object):
1040
1384
 
1041
1385
    def build_test_bundle(self):
1042
1386
        wt = self.make_branch_and_tree('b1')
1051
1395
 
1052
1396
        bundle_txt = StringIO()
1053
1397
        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)
 
1398
                               'a@cset-0-1', bundle_txt, self.format)
 
1399
        self.assertEqual(set(['a@cset-0-2']), set(rev_ids))
1056
1400
        bundle_txt.seek(0, 0)
1057
1401
        return bundle_txt
1058
1402
 
1087
1431
        bundle = read_bundle(bundle_txt)
1088
1432
        self.check_valid(bundle)
1089
1433
 
 
1434
 
 
1435
class MungedBundleTesterV09(TestCaseWithTransport, MungedBundleTester):
 
1436
 
 
1437
    format = '0.9'
 
1438
 
1090
1439
    def test_missing_trailing_whitespace(self):
1091
1440
        bundle_txt = self.build_test_bundle()
1092
1441
 
1120
1469
        bundle = read_bundle(bundle_txt)
1121
1470
        self.check_valid(bundle)
1122
1471
 
 
1472
 
 
1473
class MungedBundleTesterV4(TestCaseWithTransport, MungedBundleTester):
 
1474
 
 
1475
    format = '4'
 
1476
 
 
1477
 
 
1478
class TestBundleWriterReader(TestCase):
 
1479
 
 
1480
    def test_roundtrip_record(self):
 
1481
        fileobj = StringIO()
 
1482
        writer = v4.BundleWriter(fileobj)
 
1483
        writer.begin()
 
1484
        writer.add_info_record(foo='bar')
 
1485
        writer._add_record("Record body", {'parents': ['1', '3'],
 
1486
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1487
        writer.end()
 
1488
        fileobj.seek(0)
 
1489
        reader = v4.BundleReader(fileobj, stream_input=True)
 
1490
        record_iter = reader.iter_records()
 
1491
        record = record_iter.next()
 
1492
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1493
            'info', None, None), record)
 
1494
        record = record_iter.next()
 
1495
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
 
1496
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1497
                          record)
 
1498
 
 
1499
    def test_roundtrip_record_memory_hungry(self):
 
1500
        fileobj = StringIO()
 
1501
        writer = v4.BundleWriter(fileobj)
 
1502
        writer.begin()
 
1503
        writer.add_info_record(foo='bar')
 
1504
        writer._add_record("Record body", {'parents': ['1', '3'],
 
1505
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1506
        writer.end()
 
1507
        fileobj.seek(0)
 
1508
        reader = v4.BundleReader(fileobj, stream_input=False)
 
1509
        record_iter = reader.iter_records()
 
1510
        record = record_iter.next()
 
1511
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1512
            'info', None, None), record)
 
1513
        record = record_iter.next()
 
1514
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
 
1515
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1516
                          record)
 
1517
 
 
1518
    def test_encode_name(self):
 
1519
        self.assertEqual('revision/rev1',
 
1520
            v4.BundleWriter.encode_name('revision', 'rev1'))
 
1521
        self.assertEqual('file/rev//1/file-id-1',
 
1522
            v4.BundleWriter.encode_name('file', 'rev/1', 'file-id-1'))
 
1523
        self.assertEqual('info',
 
1524
            v4.BundleWriter.encode_name('info', None, None))
 
1525
 
 
1526
    def test_decode_name(self):
 
1527
        self.assertEqual(('revision', 'rev1', None),
 
1528
            v4.BundleReader.decode_name('revision/rev1'))
 
1529
        self.assertEqual(('file', 'rev/1', 'file-id-1'),
 
1530
            v4.BundleReader.decode_name('file/rev//1/file-id-1'))
 
1531
        self.assertEqual(('info', None, None),
 
1532
                         v4.BundleReader.decode_name('info'))
 
1533
 
 
1534
    def test_too_many_names(self):
 
1535
        fileobj = StringIO()
 
1536
        writer = v4.BundleWriter(fileobj)
 
1537
        writer.begin()
 
1538
        writer.add_info_record(foo='bar')
 
1539
        writer._container.add_bytes_record('blah', ['two', 'names'])
 
1540
        writer.end()
 
1541
        fileobj.seek(0)
 
1542
        record_iter = v4.BundleReader(fileobj).iter_records()
 
1543
        record = record_iter.next()
 
1544
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1545
            'info', None, None), record)
 
1546
        self.assertRaises(BadBundle, record_iter.next)