/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_bundle.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-06-30 10:19:02 UTC
  • mfrom: (6973.7.13 python3-g-real)
  • Revision ID: breezy.the.bot@gmail.com-20180630101902-thpqkbi44kqom06g
Fix more tests.

Merged from https://code.launchpad.net/~jelmer/brz/python3-g/+merge/348134

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_bundle.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
import bz2
 
18
from io import BytesIO
17
19
import os
18
20
try:
19
21
    import socketserver
43
45
from ..bundle.serializer.v09 import BundleSerializerV09
44
46
from ..bundle.serializer.v4 import BundleSerializerV4
45
47
from ..bzr import knitrepo
46
 
from ..sixish import (
47
 
    BytesIO,
48
 
    )
49
48
from . import (
50
49
    features,
51
50
    test_commit,
198
197
        mtree = MockTree()
199
198
        mtree.add_dir(b"a", "grandparent")
200
199
        mtree.add_dir(b"b", "grandparent/parent")
201
 
        mtree.add_file(b"c", "grandparent/parent/file", "Hello\n")
 
200
        mtree.add_file(b"c", "grandparent/parent/file", b"Hello\n")
202
201
        mtree.add_dir(b"d", "grandparent/alt_parent")
203
202
        return BundleTree(mtree, ''), mtree
204
203
 
284
283
        btree.note_rename("grandparent/parent/file",
285
284
                          "grandparent/alt_parent/file")
286
285
        self.assertTrue(btree.id2path(b"e") is None)
287
 
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
288
 
        btree.note_id("e", "grandparent/parent/file")
 
286
        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
 
287
        btree.note_id(b"e", "grandparent/parent/file")
289
288
        return btree
290
289
 
291
290
    def test_adds(self):
300
299
    def adds_test(self, btree):
301
300
        self.assertEqual(btree.id2path(b"e"), "grandparent/parent/file")
302
301
        self.assertEqual(btree.path2id("grandparent/parent/file"), b"e")
303
 
        self.assertEqual(btree.get_file("grandparent/parent/file").read(),
304
 
                         "Extra cheese\n")
 
302
        with btree.get_file("grandparent/parent/file") as f:
 
303
            self.assertEqual(f.read(), b"Extra cheese\n")
305
304
        self.assertEqual(
306
305
            btree.get_symlink_target('grandparent/parent/symlink'), 'venus')
307
306
 
311
310
        btree.contents_by_id = False
312
311
        add_patch = self.unified_diff(["Hello\n"], ["Extra cheese\n"])
313
312
        btree.note_patch("grandparent/parent/file", add_patch)
314
 
        btree.note_id('f', 'grandparent/parent/symlink', kind='symlink')
 
313
        btree.note_id(b'f', 'grandparent/parent/symlink', kind='symlink')
315
314
        btree.note_target('grandparent/parent/symlink', 'venus')
316
315
        self.adds_test(btree)
317
316
 
325
324
        return btree
326
325
 
327
326
    def get_file_test(self, btree):
328
 
        self.assertEqual(btree.get_file(btree.id2path(b"e")).read(), "Lemon\n")
329
 
        self.assertEqual(btree.get_file(btree.id2path(b"c")).read(), "Hello\n")
 
327
        with btree.get_file(btree.id2path(b"e")) as f:
 
328
            self.assertEqual(f.read(), b"Lemon\n")
 
329
        with btree.get_file(btree.id2path(b"c")) as f:
 
330
            self.assertEqual(f.read(), b"Hello\n")
330
331
 
331
332
    def test_get_file(self):
332
333
        """Get file contents"""
348
349
    def test_delete(self):
349
350
        "Deletion by bundle"
350
351
        btree = self.make_tree_1()[0]
351
 
        self.assertEqual(btree.get_file(btree.id2path(b"c")).read(), "Hello\n")
 
352
        with btree.get_file(btree.id2path(b"c")) as f:
 
353
            self.assertEqual(f.read(), b"Hello\n")
352
354
        btree.note_deletion("grandparent/parent/file")
353
355
        self.assertTrue(btree.id2path(b"c") is None)
354
356
        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
361
363
        """Ensure that iteration through ids works properly"""
362
364
        btree = self.make_tree_1()[0]
363
365
        self.assertEqual(self.sorted_ids(btree),
364
 
            [inventory.ROOT_ID, 'a', 'b', 'c', 'd'])
 
366
            [inventory.ROOT_ID, b'a', b'b', b'c', b'd'])
365
367
        btree.note_deletion("grandparent/parent/file")
366
 
        btree.note_id("e", "grandparent/alt_parent/fool", kind="directory")
 
368
        btree.note_id(b"e", "grandparent/alt_parent/fool", kind="directory")
367
369
        btree.note_last_changed("grandparent/alt_parent/fool",
368
370
                                "revisionidiguess")
369
371
        self.assertEqual(self.sorted_ids(btree),
370
 
            [inventory.ROOT_ID, 'a', 'b', 'd', 'e'])
 
372
            [inventory.ROOT_ID, b'a', b'b', b'd', b'e'])
371
373
 
372
374
 
373
375
class BundleTester1(tests.TestCaseWithTransport):
396
398
        source.commit('one', rev_id=b'one-id')
397
399
        source.commit('two', rev_id=b'two-id')
398
400
        text = BytesIO()
399
 
        write_bundle(source.branch.repository, 'two-id', 'null:', text,
 
401
        write_bundle(source.branch.repository, b'two-id', b'null:', text,
400
402
                     format='0.9')
401
403
        text.seek(0)
402
404
 
431
433
                               bundle_txt, format=self.format)
432
434
        bundle_txt.seek(0)
433
435
        self.assertEqual(bundle_txt.readline(),
434
 
                         '# Bazaar revision bundle v%s\n' % self.format)
435
 
        self.assertEqual(bundle_txt.readline(), '#\n')
 
436
                         b'# Bazaar revision bundle v%s\n' % self.format.encode('ascii'))
 
437
        self.assertEqual(bundle_txt.readline(), b'#\n')
436
438
 
437
439
        rev = self.b1.repository.get_revision(rev_id)
438
440
        self.assertEqual(bundle_txt.readline().decode('utf-8'),
514
516
                os.mkdir(checkout_dir)
515
517
        tree = self.make_branch_and_tree(checkout_dir)
516
518
        s = BytesIO()
517
 
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
 
519
        ancestors = write_bundle(self.b1.repository, rev_id, b'null:', s,
518
520
                                 format=self.format)
519
521
        s.seek(0)
520
 
        self.assertIsInstance(s.getvalue(), str)
 
522
        self.assertIsInstance(s.getvalue(), bytes)
521
523
        install_bundle(tree.branch.repository, read_bundle(s))
522
524
        for ancestor in ancestors:
523
525
            old = self.b1.repository.revision_tree(ancestor)
616
618
        self.tree1.set_root_id(b'root-id')
617
619
        self.tree1.commit('add one', rev_id=b'a@cset-0-1')
618
620
 
619
 
        bundle = self.get_valid_bundle('null:', b'a@cset-0-1')
 
621
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-1')
620
622
 
621
623
        # Make sure we can handle files with spaces, tabs, other
622
624
        # bogus characters
633
635
        self.build_tree_contents([('b1/sub/sub/emptyfile.txt', b''),
634
636
                                  ('b1/dir/nolastnewline.txt', b'bloop')])
635
637
        tt = TreeTransform(self.tree1)
636
 
        tt.new_file('executable', tt.root, [b'#!/bin/sh\n'], 'exe-1', True)
 
638
        tt.new_file('executable', tt.root, [b'#!/bin/sh\n'], b'exe-1', True)
637
639
        tt.apply()
638
640
        # have to fix length of file-id so that we can predictably rewrite
639
641
        # a (length-prefixed) record containing it later.
651
653
                ])
652
654
        self.tree1.commit('add whitespace', rev_id=b'a@cset-0-2')
653
655
 
654
 
        bundle = self.get_valid_bundle('a@cset-0-1', b'a@cset-0-2')
 
656
        bundle = self.get_valid_bundle(b'a@cset-0-1', b'a@cset-0-2')
655
657
 
656
658
        # Check a rollup bundle
657
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
 
659
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-2')
658
660
 
659
661
        # Now delete entries
660
662
        self.tree1.remove(
668
670
        tt.apply()
669
671
        self.tree1.commit('removed', rev_id=b'a@cset-0-3')
670
672
 
671
 
        bundle = self.get_valid_bundle('a@cset-0-2', 'a@cset-0-3')
 
673
        bundle = self.get_valid_bundle(b'a@cset-0-2', b'a@cset-0-3')
672
674
        self.assertRaises((errors.TestamentMismatch,
673
675
            errors.VersionedFileInvalidChecksum,
674
676
            errors.BadBundle), self.get_invalid_bundle,
675
 
            'a@cset-0-2', 'a@cset-0-3')
 
677
            b'a@cset-0-2', b'a@cset-0-3')
676
678
        # Check a rollup bundle
677
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
 
679
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-3')
678
680
 
679
681
        # Now move the directory
680
682
        self.tree1.rename_one('dir', 'sub/dir')
681
683
        self.tree1.commit('rename dir', rev_id=b'a@cset-0-4')
682
684
 
683
 
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
 
685
        bundle = self.get_valid_bundle(b'a@cset-0-3', b'a@cset-0-4')
684
686
        # Check a rollup bundle
685
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
 
687
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-4')
686
688
 
687
689
        # Modified files
688
 
        with open('b1/sub/dir/WithCaps.txt', 'ab') as f: f.write('\nAdding some text\n')
 
690
        with open('b1/sub/dir/WithCaps.txt', 'ab') as f: f.write(b'\nAdding some text\n')
689
691
        with open('b1/sub/dir/ pre space', 'ab') as f: f.write(
690
 
             '\r\nAdding some\r\nDOS format lines\r\n')
691
 
        with open('b1/sub/dir/nolastnewline.txt', 'ab') as f: f.write('\n')
 
692
             b'\r\nAdding some\r\nDOS format lines\r\n')
 
693
        with open('b1/sub/dir/nolastnewline.txt', 'ab') as f: f.write(b'\n')
692
694
        self.tree1.rename_one('sub/dir/ pre space',
693
695
                              'sub/ start space')
694
696
        self.tree1.commit('Modified files', rev_id=b'a@cset-0-5')
695
 
        bundle = self.get_valid_bundle('a@cset-0-4', 'a@cset-0-5')
 
697
        bundle = self.get_valid_bundle(b'a@cset-0-4', b'a@cset-0-5')
696
698
 
697
699
        self.tree1.rename_one('sub/dir/WithCaps.txt', 'temp')
698
700
        self.tree1.rename_one('with space.txt', 'WithCaps.txt')
699
701
        self.tree1.rename_one('temp', 'with space.txt')
700
702
        self.tree1.commit(u'swap filenames', rev_id=b'a@cset-0-6',
701
703
                          verbose=False)
702
 
        bundle = self.get_valid_bundle('a@cset-0-5', 'a@cset-0-6')
703
 
        other = self.get_checkout('a@cset-0-5')
 
704
        bundle = self.get_valid_bundle(b'a@cset-0-5', b'a@cset-0-6')
 
705
        other = self.get_checkout(b'a@cset-0-5')
704
706
        tree1_inv = get_inventory_text(self.tree1.branch.repository,
705
 
                                       'a@cset-0-5')
 
707
                                       b'a@cset-0-5')
706
708
        tree2_inv = get_inventory_text(other.branch.repository,
707
 
                                       'a@cset-0-5')
 
709
                                       b'a@cset-0-5')
708
710
        self.assertEqualDiff(tree1_inv, tree2_inv)
709
711
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
710
712
        other.commit('rename file', rev_id=b'a@cset-0-6b')
711
713
        self.tree1.merge_from_branch(other.branch)
712
714
        self.tree1.commit(u'Merge', rev_id=b'a@cset-0-7',
713
715
                          verbose=False)
714
 
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
 
716
        bundle = self.get_valid_bundle(b'a@cset-0-6', b'a@cset-0-7')
715
717
 
716
718
    def _test_symlink_bundle(self, link_name, link_target, new_link_target):
717
 
        link_id = 'link-1'
 
719
        link_id = b'link-1'
718
720
 
719
721
        self.requireFeature(features.SymlinkFeature)
720
722
        self.tree1 = self.make_branch_and_tree('b1')
724
726
        tt.new_symlink(link_name, tt.root, link_target, link_id)
725
727
        tt.apply()
726
728
        self.tree1.commit('add symlink', rev_id=b'l@cset-0-1')
727
 
        bundle = self.get_valid_bundle('null:', 'l@cset-0-1')
 
729
        bundle = self.get_valid_bundle(b'null:', b'l@cset-0-1')
728
730
        if getattr(bundle, 'revision_tree', None) is not None:
729
731
            # Not all bundle formats supports revision_tree
730
 
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-1')
 
732
            bund_tree = bundle.revision_tree(self.b1.repository, b'l@cset-0-1')
731
733
            self.assertEqual(link_target, bund_tree.get_symlink_target(link_name))
732
734
 
733
735
        tt = TreeTransform(self.tree1)
737
739
        tt.create_symlink(new_link_target, trans_id)
738
740
        tt.apply()
739
741
        self.tree1.commit('rename and change symlink', rev_id=b'l@cset-0-2')
740
 
        bundle = self.get_valid_bundle('l@cset-0-1', 'l@cset-0-2')
 
742
        bundle = self.get_valid_bundle(b'l@cset-0-1', b'l@cset-0-2')
741
743
        if getattr(bundle, 'revision_tree', None) is not None:
742
744
            # Not all bundle formats supports revision_tree
743
 
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-2')
 
745
            bund_tree = bundle.revision_tree(self.b1.repository, b'l@cset-0-2')
744
746
            self.assertEqual(new_link_target,
745
747
                             bund_tree.get_symlink_target('link2'))
746
748
 
750
752
        tt.create_symlink('jupiter', trans_id)
751
753
        tt.apply()
752
754
        self.tree1.commit('just change symlink target', rev_id=b'l@cset-0-3')
753
 
        bundle = self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
 
755
        bundle = self.get_valid_bundle(b'l@cset-0-2', b'l@cset-0-3')
754
756
 
755
757
        tt = TreeTransform(self.tree1)
756
758
        trans_id = tt.trans_id_tree_path('link2')
757
759
        tt.delete_contents(trans_id)
758
760
        tt.apply()
759
761
        self.tree1.commit('Delete symlink', rev_id=b'l@cset-0-4')
760
 
        bundle = self.get_valid_bundle('l@cset-0-3', 'l@cset-0-4')
 
762
        bundle = self.get_valid_bundle(b'l@cset-0-3', b'l@cset-0-4')
761
763
 
762
764
    def test_symlink_bundle(self):
763
765
        self._test_symlink_bundle('link', 'bar/foo', 'mars')
774
776
        tt = TreeTransform(self.tree1)
775
777
 
776
778
        # Add
777
 
        tt.new_file('file', tt.root, [b'\x00\n\x00\r\x01\n\x02\r\xff'], 'binary-1')
 
779
        tt.new_file('file', tt.root, [b'\x00\n\x00\r\x01\n\x02\r\xff'], b'binary-1')
778
780
        tt.new_file('file2', tt.root, [b'\x01\n\x02\r\x03\n\x04\r\xff'],
779
 
            'binary-2')
 
781
            b'binary-2')
780
782
        tt.apply()
781
783
        self.tree1.commit('add binary', rev_id=b'b@cset-0-1')
782
784
        self.get_valid_bundle(b'null:', b'b@cset-0-1')
794
796
        trans_id = tt.trans_id_tree_path('file2')
795
797
        tt.adjust_path('file3', tt.root, trans_id)
796
798
        tt.delete_contents(trans_id)
797
 
        tt.create_file(b'file\rcontents\x00\n\x00', trans_id)
 
799
        tt.create_file([b'file\rcontents\x00\n\x00'], trans_id)
798
800
        tt.apply()
799
801
        self.tree1.commit('rename and modify binary', rev_id=b'b@cset-0-3')
800
802
        self.get_valid_bundle(b'b@cset-0-2', b'b@cset-0-3')
803
805
        tt = TreeTransform(self.tree1)
804
806
        trans_id = tt.trans_id_tree_path('file3')
805
807
        tt.delete_contents(trans_id)
806
 
        tt.create_file(b'\x00file\rcontents', trans_id)
 
808
        tt.create_file([b'\x00file\rcontents'], trans_id)
807
809
        tt.apply()
808
810
        self.tree1.commit('just modify binary', rev_id=b'b@cset-0-4')
809
811
        self.get_valid_bundle(b'b@cset-0-3', b'b@cset-0-4')
815
817
        self.tree1 = self.make_branch_and_tree('b1')
816
818
        self.b1 = self.tree1.branch
817
819
        tt = TreeTransform(self.tree1)
818
 
        tt.new_file('file', tt.root, [b'file'], 'file')
 
820
        tt.new_file('file', tt.root, [b'file'], b'file')
819
821
        tt.apply()
820
822
        self.tree1.commit('create file', rev_id=b'a@lmod-0-1')
821
823
 
822
824
        tt = TreeTransform(self.tree1)
823
825
        trans_id = tt.trans_id_tree_path('file')
824
826
        tt.delete_contents(trans_id)
825
 
        tt.create_file(b'file2', trans_id)
 
827
        tt.create_file([b'file2'], trans_id)
826
828
        tt.apply()
827
829
        self.tree1.commit('modify text', rev_id=b'a@lmod-0-2a')
828
830
 
830
832
        tt = TreeTransform(other)
831
833
        trans_id = tt.trans_id_tree_path('file2')
832
834
        tt.delete_contents(trans_id)
833
 
        tt.create_file(b'file2', trans_id)
 
835
        tt.create_file([b'file2'], trans_id)
834
836
        tt.apply()
835
837
        other.commit('modify text in another tree', rev_id=b'a@lmod-0-2b')
836
838
        self.tree1.merge_from_branch(other.branch)
851
853
        with open('b1/one', 'wb') as f: f.write(b'three\n')
852
854
        self.tree1.commit('modify', rev_id=b'a@cset-0-3')
853
855
        bundle_file = BytesIO()
854
 
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
855
 
                               'a@cset-0-1', bundle_file, format=self.format)
856
 
        self.assertNotContainsRe(bundle_file.getvalue(), '\btwo\b')
857
 
        self.assertContainsRe(self.get_raw(bundle_file), 'one')
858
 
        self.assertContainsRe(self.get_raw(bundle_file), 'three')
 
856
        rev_ids = write_bundle(self.tree1.branch.repository, b'a@cset-0-3',
 
857
                               b'a@cset-0-1', bundle_file, format=self.format)
 
858
        self.assertNotContainsRe(bundle_file.getvalue(), b'\btwo\b')
 
859
        self.assertContainsRe(self.get_raw(bundle_file), b'one')
 
860
        self.assertContainsRe(self.get_raw(bundle_file), b'three')
859
861
 
860
862
    def test_bundle_same_basis(self):
861
863
        """Ensure using the basis as the target doesn't cause an error"""
862
864
        self.tree1 = self.make_branch_and_tree('b1')
863
865
        self.tree1.commit('add file', rev_id=b'a@cset-0-1')
864
866
        bundle_file = BytesIO()
865
 
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-1',
866
 
                               'a@cset-0-1', bundle_file)
 
867
        rev_ids = write_bundle(self.tree1.branch.repository, b'a@cset-0-1',
 
868
                               b'a@cset-0-1', bundle_file)
867
869
 
868
870
    @staticmethod
869
871
    def get_raw(bundle_file):
888
890
                          rev_id=b'i18n-1', committer=u'William Dod\xe9')
889
891
 
890
892
        # Add
891
 
        bundle = self.get_valid_bundle('null:', 'i18n-1')
 
893
        bundle = self.get_valid_bundle(b'null:', b'i18n-1')
892
894
 
893
895
        # Modified
894
896
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
896
898
        f.close()
897
899
        self.tree1.commit(u'modified', rev_id=b'i18n-2')
898
900
 
899
 
        bundle = self.get_valid_bundle('i18n-1', 'i18n-2')
 
901
        bundle = self.get_valid_bundle(b'i18n-1', b'i18n-2')
900
902
 
901
903
        # Renamed
902
904
        self.tree1.rename_one(u'with Dod\N{Euro Sign}', u'B\N{Euro Sign}gfors')
903
905
        self.tree1.commit(u'renamed, the new i18n man', rev_id=b'i18n-3',
904
906
                          committer=u'Erik B\xe5gfors')
905
907
 
906
 
        bundle = self.get_valid_bundle('i18n-2', 'i18n-3')
 
908
        bundle = self.get_valid_bundle(b'i18n-2', b'i18n-3')
907
909
 
908
910
        # Removed
909
911
        self.tree1.remove([u'B\N{Euro Sign}gfors'])
910
912
        self.tree1.commit(u'removed', rev_id=b'i18n-4')
911
913
 
912
 
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
 
914
        bundle = self.get_valid_bundle(b'i18n-3', b'i18n-4')
913
915
 
914
916
        # Rollup
915
 
        bundle = self.get_valid_bundle('null:', 'i18n-4')
 
917
        bundle = self.get_valid_bundle(b'null:', b'i18n-4')
916
918
 
917
919
 
918
920
    def test_whitespace_bundle(self):
930
932
        # Added
931
933
        self.tree1.commit('funky whitespace', rev_id=b'white-1')
932
934
 
933
 
        bundle = self.get_valid_bundle('null:', 'white-1')
 
935
        bundle = self.get_valid_bundle(b'null:', b'white-1')
934
936
 
935
937
        # Modified
936
 
        with open('b1/trailing space ', 'ab') as f: f.write('add some text\n')
 
938
        with open('b1/trailing space ', 'ab') as f: f.write(b'add some text\n')
937
939
        self.tree1.commit('add text', rev_id=b'white-2')
938
940
 
939
 
        bundle = self.get_valid_bundle('white-1', 'white-2')
 
941
        bundle = self.get_valid_bundle(b'white-1', b'white-2')
940
942
 
941
943
        # Renamed
942
944
        self.tree1.rename_one('trailing space ', ' start and end space ')
943
945
        self.tree1.commit('rename', rev_id=b'white-3')
944
946
 
945
 
        bundle = self.get_valid_bundle('white-2', 'white-3')
 
947
        bundle = self.get_valid_bundle(b'white-2', b'white-3')
946
948
 
947
949
        # Removed
948
950
        self.tree1.remove([' start and end space '])
949
951
        self.tree1.commit('removed', rev_id=b'white-4')
950
952
 
951
 
        bundle = self.get_valid_bundle('white-3', 'white-4')
 
953
        bundle = self.get_valid_bundle(b'white-3', b'white-4')
952
954
 
953
955
        # Now test a complet roll-up
954
 
        bundle = self.get_valid_bundle('null:', 'white-4')
 
956
        bundle = self.get_valid_bundle(b'null:', b'white-4')
955
957
 
956
958
    def test_alt_timezone_bundle(self):
957
959
        self.tree1 = self.make_branch_and_memory_tree('b1')
967
969
        self.tree1.commit('non-hour offset timezone', rev_id=b'tz-1',
968
970
                          timezone=19800, timestamp=1152544886.0)
969
971
 
970
 
        bundle = self.get_valid_bundle('null:', 'tz-1')
 
972
        bundle = self.get_valid_bundle(b'null:', b'tz-1')
971
973
 
972
974
        rev = bundle.revisions[0]
973
975
        self.assertEqual('Mon 2006-07-10 20:51:26.000000000 +0530', rev.date)
979
981
        self.tree1 = self.make_branch_and_tree('b1')
980
982
        self.b1 = self.tree1.branch
981
983
        self.tree1.commit('message', rev_id=b'revid1')
982
 
        bundle = self.get_valid_bundle('null:', 'revid1')
983
 
        tree = self.get_bundle_tree(bundle, 'revid1')
 
984
        bundle = self.get_valid_bundle(b'null:', b'revid1')
 
985
        tree = self.get_bundle_tree(bundle, b'revid1')
984
986
        root_revision = tree.get_file_revision(u'', tree.get_root_id())
985
 
        self.assertEqual('revid1', root_revision)
 
987
        self.assertEqual(b'revid1', root_revision)
986
988
 
987
989
    def test_install_revisions(self):
988
990
        self.tree1 = self.make_branch_and_tree('b1')
1001
1003
        tree.lock_write()
1002
1004
        self.addCleanup(tree.unlock)
1003
1005
        tree.add([''], [b'TREE_ROOT'])
1004
 
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id=b'rev1')
 
1006
        tree.commit('One', revprops={'one': 'two', 'empty': ''}, rev_id=b'rev1')
1005
1007
        self.b1 = tree.branch
1006
1008
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1007
1009
        bundle = read_bundle(bundle_sio)
1021
1023
        tree.commit('One', rev_id=b'rev1',
1022
1024
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
1023
1025
        self.b1 = tree.branch
1024
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1026
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1025
1027
        bundle = read_bundle(bundle_sio)
1026
1028
        revision_info = bundle.revisions[0]
1027
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1029
        self.assertEqual(b'rev1', revision_info.revision_id)
1028
1030
        rev = revision_info.as_revision()
1029
1031
        self.assertEqual({'branch-nick':'tree', 'a':'4', 'b':'3', 'c':'2',
1030
1032
                          'd':'1'}, rev.properties)
1044
1046
        tree.commit('One', rev_id=b'rev1',
1045
1047
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
1046
1048
        self.b1 = tree.branch
1047
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1049
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1048
1050
        bundle = read_bundle(bundle_sio)
1049
1051
        revision_info = bundle.revisions[0]
1050
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1052
        self.assertEqual(b'rev1', revision_info.revision_id)
1051
1053
        rev = revision_info.as_revision()
1052
1054
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
1053
1055
                          'alpha':u'\u03b1'}, rev.properties)
1074
1076
        tree = self.make_simple_tree('knit')
1075
1077
        tree.commit('hello', rev_id=b'rev1')
1076
1078
        tree.commit('hello', rev_id=b'rev2')
1077
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1079
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
1078
1080
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1079
1081
        bundle.install_revisions(repo)
1080
 
        inv_text = repo._get_inventory_xml('rev2')
1081
 
        self.assertNotContainsRe(inv_text, 'format="5"')
1082
 
        self.assertContainsRe(inv_text, 'format="7"')
 
1082
        inv_text = repo._get_inventory_xml(b'rev2')
 
1083
        self.assertNotContainsRe(inv_text, b'format="5"')
 
1084
        self.assertContainsRe(inv_text, b'format="7"')
1083
1085
 
1084
1086
    def make_repo_with_installed_revisions(self):
1085
1087
        tree = self.make_simple_tree('knit')
1112
1114
        tree.commit('hello', rev_id=b'rev1')
1113
1115
        tree.commit('hello', rev_id=b'rev2')
1114
1116
        try:
1115
 
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1117
            bundle = read_bundle(self.create_bundle_text(b'null:', b'rev1')[0])
1116
1118
        except errors.IncompatibleBundleFormat:
1117
1119
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
1118
1120
        repo = self.make_repository('repo', format='knit')
1119
1121
        bundle.install_revisions(repo)
1120
1122
 
1121
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1123
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
1122
1124
        self.assertRaises(errors.IncompatibleRevision,
1123
1125
                          bundle.install_revisions, repo)
1124
1126
 
1126
1128
        tree = self.make_simple_tree()
1127
1129
        tree.commit('hello', rev_id=b'rev1')
1128
1130
        tree.commit('hello', rev_id=b'rev2')
1129
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1131
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev1')[0])
1130
1132
        result = bundle.get_merge_request(tree.branch.repository)
1131
 
        self.assertEqual((None, 'rev1', 'inapplicable'), result)
 
1133
        self.assertEqual((None, b'rev1', 'inapplicable'), result)
1132
1134
 
1133
1135
    def test_with_subtree(self):
1134
1136
        tree = self.make_branch_and_tree('tree',
1139
1141
        tree.add('subtree')
1140
1142
        tree.commit('hello', rev_id=b'rev1')
1141
1143
        try:
1142
 
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1144
            bundle = read_bundle(self.create_bundle_text(b'null:', b'rev1')[0])
1143
1145
        except errors.IncompatibleBundleFormat:
1144
1146
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
1145
1147
        if isinstance(bundle, v09.BundleInfo09):
1158
1160
        except ValueError:
1159
1161
            raise tests.TestSkipped(
1160
1162
                "Repository doesn't support revision ids with slashes")
1161
 
        bundle = self.get_valid_bundle('null:', 'rev/id')
 
1163
        bundle = self.get_valid_bundle(b'null:', b'rev/id')
1162
1164
 
1163
1165
    def test_skip_file(self):
1164
1166
        """Make sure we don't accidentally write to the wrong versionedfile"""
1177
1179
        target = self.tree1.controldir.sprout('target').open_workingtree()
1178
1180
        self.build_tree_contents([('tree/file2', b'contents3')])
1179
1181
        self.tree1.commit('rev3', rev_id=b'rev3')
1180
 
        bundle = self.get_valid_bundle('reva', 'rev3')
 
1182
        bundle = self.get_valid_bundle(b'reva', b'rev3')
1181
1183
        if getattr(bundle, 'get_bundle_reader', None) is None:
1182
1184
            raise tests.TestSkipped('Bundle format cannot provide reader')
1183
1185
        # be sure that file1 comes before file2
1200
1202
        tree.add([''], [b'TREE_ROOT'])
1201
1203
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id=b'rev1')
1202
1204
        self.b1 = tree.branch
1203
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1205
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1204
1206
        self.assertContainsRe(bundle_sio.getvalue(),
1205
 
                              '# properties:\n'
1206
 
                              '#   branch-nick: tree\n'
1207
 
                              '#   empty: \n'
1208
 
                              '#   one: two\n'
 
1207
                              b'# properties:\n'
 
1208
                              b'#   branch-nick: tree\n'
 
1209
                              b'#   empty: \n'
 
1210
                              b'#   one: two\n'
1209
1211
                             )
1210
1212
        bundle = read_bundle(bundle_sio)
1211
1213
        revision_info = bundle.revisions[0]
1216
1218
 
1217
1219
    def get_bundle_tree(self, bundle, revision_id):
1218
1220
        repository = self.make_repository('repo')
1219
 
        return bundle.revision_tree(repository, 'revid1')
 
1221
        return bundle.revision_tree(repository, b'revid1')
1220
1222
 
1221
1223
    def test_bundle_empty_property_alt(self):
1222
1224
        """Test serializing revision properties with an empty value.
1232
1234
        tree.add([''], [b'TREE_ROOT'])
1233
1235
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id=b'rev1')
1234
1236
        self.b1 = tree.branch
1235
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1237
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1236
1238
        txt = bundle_sio.getvalue()
1237
 
        loc = txt.find('#   empty: ') + len('#   empty:')
 
1239
        loc = txt.find(b'#   empty: ') + len(b'#   empty:')
1238
1240
        # Create a new bundle, which strips the trailing space after empty
1239
1241
        bundle_sio = BytesIO(txt[:loc] + txt[loc+1:])
1240
1242
 
1241
1243
        self.assertContainsRe(bundle_sio.getvalue(),
1242
 
                              '# properties:\n'
1243
 
                              '#   branch-nick: tree\n'
1244
 
                              '#   empty:\n'
1245
 
                              '#   one: two\n'
 
1244
                              b'# properties:\n'
 
1245
                              b'#   branch-nick: tree\n'
 
1246
                              b'#   empty:\n'
 
1247
                              b'#   one: two\n'
1246
1248
                             )
1247
1249
        bundle = read_bundle(bundle_sio)
1248
1250
        revision_info = bundle.revisions[0]
1261
1263
        tree.commit('One', rev_id=b'rev1',
1262
1264
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
1263
1265
        self.b1 = tree.branch
1264
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1266
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1265
1267
        self.assertContainsRe(bundle_sio.getvalue(),
1266
 
                              '# properties:\n'
1267
 
                              '#   a: 4\n'
1268
 
                              '#   b: 3\n'
1269
 
                              '#   branch-nick: tree\n'
1270
 
                              '#   c: 2\n'
1271
 
                              '#   d: 1\n'
 
1268
                              b'# properties:\n'
 
1269
                              b'#   a: 4\n'
 
1270
                              b'#   b: 3\n'
 
1271
                              b'#   branch-nick: tree\n'
 
1272
                              b'#   c: 2\n'
 
1273
                              b'#   d: 1\n'
1272
1274
                             )
1273
1275
        bundle = read_bundle(bundle_sio)
1274
1276
        revision_info = bundle.revisions[0]
1292
1294
        tree.commit('One', rev_id=b'rev1',
1293
1295
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
1294
1296
        self.b1 = tree.branch
1295
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1297
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1296
1298
        self.assertContainsRe(bundle_sio.getvalue(),
1297
 
                              '# properties:\n'
1298
 
                              '#   alpha: \xce\xb1\n'
1299
 
                              '#   branch-nick: tree\n'
1300
 
                              '#   omega: \xce\xa9\n'
 
1299
                              b'# properties:\n'
 
1300
                              b'#   alpha: \xce\xb1\n'
 
1301
                              b'#   branch-nick: tree\n'
 
1302
                              b'#   omega: \xce\xa9\n'
1301
1303
                             )
1302
1304
        bundle = read_bundle(bundle_sio)
1303
1305
        revision_info = bundle.revisions[0]
1304
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1306
        self.assertEqual(b'rev1', revision_info.revision_id)
1305
1307
        rev = revision_info.as_revision()
1306
1308
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
1307
1309
                          'alpha':u'\u03b1'}, rev.properties)
1372
1374
        from ..bundle import serializer
1373
1375
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1374
1376
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
1375
 
        new_text = new_text.replace('<file file_id="exe-1"',
1376
 
                                    '<file executable="y" file_id="exe-1"')
1377
 
        new_text = new_text.replace('B260', 'B275')
 
1377
        new_text = new_text.replace(b'<file file_id="exe-1"',
 
1378
                                    b'<file executable="y" file_id="exe-1"')
 
1379
        new_text = new_text.replace(b'B260', b'B275')
1378
1380
        bundle_txt = BytesIO()
1379
1381
        bundle_txt.write(serializer._get_bundle_header('4'))
1380
 
        bundle_txt.write('\n')
1381
 
        bundle_txt.write(new_text.encode('bz2'))
 
1382
        bundle_txt.write(b'\n')
 
1383
        bundle_txt.write(bz2.compress(new_text))
1382
1384
        bundle_txt.seek(0)
1383
1385
        bundle = read_bundle(bundle_txt)
1384
1386
        self.valid_apply_bundle(base_rev_id, bundle)
1390
1392
                               bundle_txt, format=self.format)
1391
1393
        bundle_txt.seek(0)
1392
1394
        self.assertEqual(bundle_txt.readline(),
1393
 
                         '# Bazaar revision bundle v%s\n' % self.format)
1394
 
        self.assertEqual(bundle_txt.readline(), '#\n')
 
1395
                         b'# Bazaar revision bundle v%s\n' % self.format.encode('ascii'))
 
1396
        self.assertEqual(bundle_txt.readline(), b'#\n')
1395
1397
        rev = self.b1.repository.get_revision(rev_id)
1396
1398
        bundle_txt.seek(0)
1397
1399
        return bundle_txt, rev_ids
1418
1420
        target_repo.lock_read()
1419
1421
        self.addCleanup(target_repo.unlock)
1420
1422
        # Turn the 'iterators_of_bytes' back into simple strings for comparison
1421
 
        repo_texts = dict((i, ''.join(content)) for i, content
 
1423
        repo_texts = dict((i, b''.join(content)) for i, content
1422
1424
                          in target_repo.iter_files_bytes(
1423
1425
                                [(b'fileid-2', b'rev1', '1'),
1424
1426
                                 (b'fileid-2', b'rev2', '2')]))
1440
1442
        line = bundle_file.readline()
1441
1443
        line = bundle_file.readline()
1442
1444
        lines = bundle_file.readlines()
1443
 
        return ''.join(lines).decode('bz2')
 
1445
        return bz2.decompress(b''.join(lines))
1444
1446
 
1445
1447
    def test_copy_signatures(self):
1446
1448
        tree_a = self.make_branch_and_tree('tree_a')
1450
1452
        branch = tree_a.branch
1451
1453
        repo_a = branch.repository
1452
1454
        tree_a.commit("base", allow_pointless=True, rev_id=b'A')
1453
 
        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
 
1455
        self.assertFalse(branch.repository.has_signature_for_revision_id(b'A'))
1454
1456
        try:
1455
1457
            from ..testament import Testament
1456
1458
            # monkey patch gpg signing mechanism
1462
1464
                                                    working_tree=tree_a)
1463
1465
            def sign(text):
1464
1466
                return breezy.gpg.LoopbackGPGStrategy(None).sign(text)
1465
 
            self.assertTrue(repo_a.has_signature_for_revision_id('B'))
 
1467
            self.assertTrue(repo_a.has_signature_for_revision_id(b'B'))
1466
1468
        finally:
1467
1469
            breezy.gpg.GPGStrategy = oldstrategy
1468
1470
        tree_b = self.make_branch_and_tree('tree_b')
1469
1471
        repo_b = tree_b.branch.repository
1470
1472
        s = BytesIO()
1471
1473
        serializer = BundleSerializerV4('4')
1472
 
        serializer.write(tree_a.branch.repository, ['A', 'B'], {}, s)
 
1474
        serializer.write(tree_a.branch.repository, [b'A', b'B'], {}, s)
1473
1475
        s.seek(0)
1474
1476
        install_bundle(repo_b, serializer.read(s))
1475
 
        self.assertTrue(repo_b.has_signature_for_revision_id('B'))
1476
 
        self.assertEqual(repo_b.get_signature_text('B'),
1477
 
                         repo_a.get_signature_text('B'))
 
1477
        self.assertTrue(repo_b.has_signature_for_revision_id(b'B'))
 
1478
        self.assertEqual(repo_b.get_signature_text(b'B'),
 
1479
                         repo_a.get_signature_text(b'B'))
1478
1480
        s.seek(0)
1479
1481
        # ensure repeat installs are harmless
1480
1482
        install_bundle(repo_b, serializer.read(s))
1496
1498
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
1497
1499
        # We are going to be replacing some text to set the executable bit on a
1498
1500
        # file. Make sure the text replacement actually works correctly.
1499
 
        self.assertContainsRe(new_text, '(?m)B244\n\ni 1\n<inventory')
1500
 
        new_text = new_text.replace('<file file_id="exe-1"',
1501
 
                                    '<file executable="y" file_id="exe-1"')
1502
 
        new_text = new_text.replace('B244', 'B259')
 
1501
        self.assertContainsRe(new_text, b'(?m)B244\n\ni 1\n<inventory')
 
1502
        new_text = new_text.replace(b'<file file_id="exe-1"',
 
1503
                                    b'<file executable="y" file_id="exe-1"')
 
1504
        new_text = new_text.replace(b'B244', b'B259')
1503
1505
        bundle_txt = BytesIO()
1504
1506
        bundle_txt.write(serializer._get_bundle_header('4'))
1505
 
        bundle_txt.write('\n')
1506
 
        bundle_txt.write(new_text.encode('bz2'))
 
1507
        bundle_txt.write(b'\n')
 
1508
        bundle_txt.write(bz2.compress(new_text))
1507
1509
        bundle_txt.seek(0)
1508
1510
        bundle = read_bundle(bundle_txt)
1509
1511
        self.valid_apply_bundle(base_rev_id, bundle)
1513
1515
        builder = self.make_branch_builder('source')
1514
1516
        builder.start_series()
1515
1517
        builder.build_snapshot(None, [
1516
 
            ('add', ('', 'root-id', 'directory', None)),
1517
 
            ('add', ('file', 'file-id', 'file', 'original content\n')),
 
1518
            ('add', ('', b'root-id', 'directory', None)),
 
1519
            ('add', ('file', b'file-id', 'file', b'original content\n')),
1518
1520
            ], revision_id=b'a@cset-0-1')
1519
 
        builder.build_snapshot(['a@cset-0-1'], [
1520
 
            ('modify', ('file', 'new-content\n')),
 
1521
        builder.build_snapshot([b'a@cset-0-1'], [
 
1522
            ('modify', ('file', b'new-content\n')),
1521
1523
            ], revision_id=b'a@cset-0-2a')
1522
 
        builder.build_snapshot(['a@cset-0-1'], [
1523
 
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
 
1524
        builder.build_snapshot([b'a@cset-0-1'], [
 
1525
            ('add', ('other-file', b'file2-id', 'file', b'file2-content\n')),
1524
1526
            ], revision_id=b'a@cset-0-2b')
1525
 
        builder.build_snapshot(['a@cset-0-2a', 'a@cset-0-2b'], [
1526
 
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
 
1527
        builder.build_snapshot([b'a@cset-0-2a', b'a@cset-0-2b'], [
 
1528
            ('add', ('other-file', b'file2-id', 'file', b'file2-content\n')),
1527
1529
            ], revision_id=b'a@cset-0-3')
1528
1530
        builder.finish_series()
1529
1531
        self.b1 = builder.get_branch()
1544
1546
 
1545
1547
    def test_single_inventory_multiple_parents_as_xml(self):
1546
1548
        self.make_merged_branch()
1547
 
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
1548
 
                                                ['a@cset-0-3'])
 
1549
        sio = self.make_bundle_just_inventories(b'a@cset-0-1', b'a@cset-0-3',
 
1550
                                                [b'a@cset-0-3'])
1549
1551
        reader = v4.BundleReader(sio, stream_input=False)
1550
1552
        records = list(reader.iter_records())
1551
1553
        self.assertEqual(1, len(records))
1552
1554
        (bytes, metadata, repo_kind, revision_id,
1553
1555
         file_id) = records[0]
1554
1556
        self.assertIs(None, file_id)
1555
 
        self.assertEqual('a@cset-0-3', revision_id)
 
1557
        self.assertEqual(b'a@cset-0-3', revision_id)
1556
1558
        self.assertEqual('inventory', repo_kind)
1557
 
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
1558
 
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
1559
 
                          'storage_kind': 'mpdiff',
 
1559
        self.assertEqual({b'parents': [b'a@cset-0-2a', b'a@cset-0-2b'],
 
1560
                          b'sha1': b'09c53b0c4de0895e11a2aacc34fef60a6e70865c',
 
1561
                          b'storage_kind': b'mpdiff',
1560
1562
                         }, metadata)
1561
1563
        # We should have an mpdiff that takes some lines from both parents.
1562
1564
        self.assertEqualDiff(
1563
 
            'i 1\n'
1564
 
            '<inventory format="10" revision_id="a@cset-0-3">\n'
1565
 
            '\n'
1566
 
            'c 0 1 1 2\n'
1567
 
            'c 1 3 3 2\n', bytes)
 
1565
            b'i 1\n'
 
1566
            b'<inventory format="10" revision_id="a@cset-0-3">\n'
 
1567
            b'\n'
 
1568
            b'c 0 1 1 2\n'
 
1569
            b'c 1 3 3 2\n', bytes)
1568
1570
 
1569
1571
    def test_single_inv_no_parents_as_xml(self):
1570
1572
        self.make_merged_branch()
1571
 
        sio = self.make_bundle_just_inventories('null:', 'a@cset-0-1',
1572
 
                                                ['a@cset-0-1'])
 
1573
        sio = self.make_bundle_just_inventories(b'null:', b'a@cset-0-1',
 
1574
                                                [b'a@cset-0-1'])
1573
1575
        reader = v4.BundleReader(sio, stream_input=False)
1574
1576
        records = list(reader.iter_records())
1575
1577
        self.assertEqual(1, len(records))
1576
1578
        (bytes, metadata, repo_kind, revision_id,
1577
1579
         file_id) = records[0]
1578
1580
        self.assertIs(None, file_id)
1579
 
        self.assertEqual('a@cset-0-1', revision_id)
 
1581
        self.assertEqual(b'a@cset-0-1', revision_id)
1580
1582
        self.assertEqual('inventory', repo_kind)
1581
 
        self.assertEqual({'parents': [],
1582
 
                          'sha1': 'a13f42b142d544aac9b085c42595d304150e31a2',
1583
 
                          'storage_kind': 'mpdiff',
 
1583
        self.assertEqual({b'parents': [],
 
1584
                          b'sha1': b'a13f42b142d544aac9b085c42595d304150e31a2',
 
1585
                          b'storage_kind': b'mpdiff',
1584
1586
                         }, metadata)
1585
1587
        # We should have an mpdiff that takes some lines from both parents.
1586
1588
        self.assertEqualDiff(
1587
 
            'i 4\n'
1588
 
            '<inventory format="10" revision_id="a@cset-0-1">\n'
1589
 
            '<directory file_id="root-id" name=""'
1590
 
                ' revision="a@cset-0-1" />\n'
1591
 
            '<file file_id="file-id" name="file" parent_id="root-id"'
1592
 
                ' revision="a@cset-0-1"'
1593
 
                ' text_sha1="09c2f8647e14e49e922b955c194102070597c2d1"'
1594
 
                ' text_size="17" />\n'
1595
 
            '</inventory>\n'
1596
 
            '\n', bytes)
 
1589
            b'i 4\n'
 
1590
            b'<inventory format="10" revision_id="a@cset-0-1">\n'
 
1591
            b'<directory file_id="root-id" name=""'
 
1592
                b' revision="a@cset-0-1" />\n'
 
1593
            b'<file file_id="file-id" name="file" parent_id="root-id"'
 
1594
                b' revision="a@cset-0-1"'
 
1595
                b' text_sha1="09c2f8647e14e49e922b955c194102070597c2d1"'
 
1596
                b' text_size="17" />\n'
 
1597
            b'</inventory>\n'
 
1598
            b'\n', bytes)
1597
1599
 
1598
1600
    def test_multiple_inventories_as_xml(self):
1599
1601
        self.make_merged_branch()
1600
 
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
1601
 
            ['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'])
 
1602
        sio = self.make_bundle_just_inventories(b'a@cset-0-1', b'a@cset-0-3',
 
1603
            [b'a@cset-0-2a', b'a@cset-0-2b', b'a@cset-0-3'])
1602
1604
        reader = v4.BundleReader(sio, stream_input=False)
1603
1605
        records = list(reader.iter_records())
1604
1606
        self.assertEqual(3, len(records))
1605
1607
        revision_ids = [rev_id for b, m, k, rev_id, f in records]
1606
 
        self.assertEqual(['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'],
 
1608
        self.assertEqual([b'a@cset-0-2a', b'a@cset-0-2b', b'a@cset-0-3'],
1607
1609
                         revision_ids)
1608
1610
        metadata_2a = records[0][1]
1609
 
        self.assertEqual({'parents': ['a@cset-0-1'],
1610
 
                          'sha1': '1e105886d62d510763e22885eec733b66f5f09bf',
1611
 
                          'storage_kind': 'mpdiff',
 
1611
        self.assertEqual({b'parents': [b'a@cset-0-1'],
 
1612
                          b'sha1': b'1e105886d62d510763e22885eec733b66f5f09bf',
 
1613
                          b'storage_kind': b'mpdiff',
1612
1614
                         }, metadata_2a)
1613
1615
        metadata_2b = records[1][1]
1614
 
        self.assertEqual({'parents': ['a@cset-0-1'],
1615
 
                          'sha1': 'f03f12574bdb5ed2204c28636c98a8547544ccd8',
1616
 
                          'storage_kind': 'mpdiff',
 
1616
        self.assertEqual({b'parents': [b'a@cset-0-1'],
 
1617
                          b'sha1': b'f03f12574bdb5ed2204c28636c98a8547544ccd8',
 
1618
                          b'storage_kind': b'mpdiff',
1617
1619
                         }, metadata_2b)
1618
1620
        metadata_3 = records[2][1]
1619
 
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
1620
 
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
1621
 
                          'storage_kind': 'mpdiff',
 
1621
        self.assertEqual({b'parents': [b'a@cset-0-2a', b'a@cset-0-2b'],
 
1622
                          b'sha1': b'09c53b0c4de0895e11a2aacc34fef60a6e70865c',
 
1623
                          b'storage_kind': b'mpdiff',
1622
1624
                         }, metadata_3)
1623
1625
        bytes_2a = records[0][0]
1624
1626
        self.assertEqualDiff(
1625
 
            'i 1\n'
1626
 
            '<inventory format="10" revision_id="a@cset-0-2a">\n'
1627
 
            '\n'
1628
 
            'c 0 1 1 1\n'
1629
 
            'i 1\n'
1630
 
            '<file file_id="file-id" name="file" parent_id="root-id"'
1631
 
                ' revision="a@cset-0-2a"'
1632
 
                ' text_sha1="50f545ff40e57b6924b1f3174b267ffc4576e9a9"'
1633
 
                ' text_size="12" />\n'
1634
 
            '\n'
1635
 
            'c 0 3 3 1\n', bytes_2a)
 
1627
            b'i 1\n'
 
1628
            b'<inventory format="10" revision_id="a@cset-0-2a">\n'
 
1629
            b'\n'
 
1630
            b'c 0 1 1 1\n'
 
1631
            b'i 1\n'
 
1632
            b'<file file_id="file-id" name="file" parent_id="root-id"'
 
1633
                b' revision="a@cset-0-2a"'
 
1634
                b' text_sha1="50f545ff40e57b6924b1f3174b267ffc4576e9a9"'
 
1635
                b' text_size="12" />\n'
 
1636
            b'\n'
 
1637
            b'c 0 3 3 1\n', bytes_2a)
1636
1638
        bytes_2b = records[1][0]
1637
1639
        self.assertEqualDiff(
1638
 
            'i 1\n'
1639
 
            '<inventory format="10" revision_id="a@cset-0-2b">\n'
1640
 
            '\n'
1641
 
            'c 0 1 1 2\n'
1642
 
            'i 1\n'
1643
 
            '<file file_id="file2-id" name="other-file" parent_id="root-id"'
1644
 
                ' revision="a@cset-0-2b"'
1645
 
                ' text_sha1="b46c0c8ea1e5ef8e46fc8894bfd4752a88ec939e"'
1646
 
                ' text_size="14" />\n'
1647
 
            '\n'
1648
 
            'c 0 3 4 1\n', bytes_2b)
 
1640
            b'i 1\n'
 
1641
            b'<inventory format="10" revision_id="a@cset-0-2b">\n'
 
1642
            b'\n'
 
1643
            b'c 0 1 1 2\n'
 
1644
            b'i 1\n'
 
1645
            b'<file file_id="file2-id" name="other-file" parent_id="root-id"'
 
1646
                b' revision="a@cset-0-2b"'
 
1647
                b' text_sha1="b46c0c8ea1e5ef8e46fc8894bfd4752a88ec939e"'
 
1648
                b' text_size="14" />\n'
 
1649
            b'\n'
 
1650
            b'c 0 3 4 1\n', bytes_2b)
1649
1651
        bytes_3 = records[2][0]
1650
1652
        self.assertEqualDiff(
1651
 
            'i 1\n'
1652
 
            '<inventory format="10" revision_id="a@cset-0-3">\n'
1653
 
            '\n'
1654
 
            'c 0 1 1 2\n'
1655
 
            'c 1 3 3 2\n', bytes_3)
 
1653
            b'i 1\n'
 
1654
            b'<inventory format="10" revision_id="a@cset-0-3">\n'
 
1655
            b'\n'
 
1656
            b'c 0 1 1 2\n'
 
1657
            b'c 1 3 3 2\n', bytes_3)
1656
1658
 
1657
1659
    def test_creating_bundle_preserves_chk_pages(self):
1658
1660
        self.make_merged_branch()
1659
1661
        target = self.b1.controldir.sprout('target',
1660
1662
                                       revision_id=b'a@cset-0-2a').open_branch()
1661
 
        bundle_txt, rev_ids = self.create_bundle_text('a@cset-0-2a',
1662
 
                                                      'a@cset-0-3')
1663
 
        self.assertEqual(['a@cset-0-2b', 'a@cset-0-3'], rev_ids)
 
1663
        bundle_txt, rev_ids = self.create_bundle_text(b'a@cset-0-2a',
 
1664
                                                      b'a@cset-0-3')
 
1665
        self.assertEqual([b'a@cset-0-2b', b'a@cset-0-3'], rev_ids)
1664
1666
        bundle = read_bundle(bundle_txt)
1665
1667
        target.lock_write()
1666
1668
        self.addCleanup(target.unlock)
1667
1669
        install_bundle(target.repository, bundle)
1668
1670
        inv1 = self.b1.repository.inventories.get_record_stream([
1669
 
            ('a@cset-0-3',)], 'unordered',
 
1671
            (b'a@cset-0-3',)], 'unordered',
1670
1672
            True).next().get_bytes_as('fulltext')
1671
1673
        inv2 = target.repository.inventories.get_record_stream([
1672
 
            ('a@cset-0-3',)], 'unordered',
 
1674
            (b'a@cset-0-3',)], 'unordered',
1673
1675
            True).next().get_bytes_as('fulltext')
1674
1676
        self.assertEqualDiff(inv1, inv2)
1675
1677
 
1688
1690
                  revprops={'branch-nick':'test'})
1689
1691
 
1690
1692
        bundle_txt = BytesIO()
1691
 
        rev_ids = write_bundle(wt.branch.repository, 'a@cset-0-2',
1692
 
                               'a@cset-0-1', bundle_txt, self.format)
1693
 
        self.assertEqual({'a@cset-0-2'}, set(rev_ids))
 
1693
        rev_ids = write_bundle(wt.branch.repository, b'a@cset-0-2',
 
1694
                               b'a@cset-0-1', bundle_txt, self.format)
 
1695
        self.assertEqual({b'a@cset-0-2'}, set(rev_ids))
1694
1696
        bundle_txt.seek(0, 0)
1695
1697
        return bundle_txt
1696
1698
 
1697
1699
    def check_valid(self, bundle):
1698
1700
        """Check that after whatever munging, the final object is valid."""
1699
 
        self.assertEqual(['a@cset-0-2'],
 
1701
        self.assertEqual([b'a@cset-0-2'],
1700
1702
            [r.revision_id for r in bundle.real_revisions])
1701
1703
 
1702
1704
    def test_extra_whitespace(self):
1706
1708
        # Adding one extra newline used to give us
1707
1709
        # TypeError: float() argument must be a string or a number
1708
1710
        bundle_txt.seek(0, 2)
1709
 
        bundle_txt.write('\n')
 
1711
        bundle_txt.write(b'\n')
1710
1712
        bundle_txt.seek(0)
1711
1713
 
1712
1714
        bundle = read_bundle(bundle_txt)
1719
1721
        # Adding two extra newlines used to give us
1720
1722
        # MalformedPatches: The first line of all patches should be ...
1721
1723
        bundle_txt.seek(0, 2)
1722
 
        bundle_txt.write('\n\n')
 
1724
        bundle_txt.write(b'\n\n')
1723
1725
        bundle_txt.seek(0)
1724
1726
 
1725
1727
        bundle = read_bundle(bundle_txt)
1739
1741
        # test is concerned with the exact case where the serializer
1740
1742
        # creates a blank line at the end, and fails if that
1741
1743
        # line is stripped
1742
 
        self.assertEqual('\n\n', raw[-2:])
 
1744
        self.assertEqual(b'\n\n', raw[-2:])
1743
1745
        bundle_txt = BytesIO(raw[:-1])
1744
1746
 
1745
1747
        bundle = read_bundle(bundle_txt)
1775
1777
        fileobj = BytesIO()
1776
1778
        writer = v4.BundleWriter(fileobj)
1777
1779
        writer.begin()
1778
 
        writer.add_info_record(foo='bar')
1779
 
        writer._add_record("Record body", {'parents': ['1', '3'],
1780
 
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1780
        writer.add_info_record({b'foo': b'bar'})
 
1781
        writer._add_record("Record body", {b'parents': [b'1', b'3'],
 
1782
            b'storage_kind': b'fulltext'}, 'file', b'revid', b'fileid')
1781
1783
        writer.end()
1782
1784
        fileobj.seek(0)
1783
1785
        reader = v4.BundleReader(fileobj, stream_input=True)
1784
1786
        record_iter = reader.iter_records()
1785
1787
        record = next(record_iter)
1786
 
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1788
        self.assertEqual((None, {b'foo': b'bar', b'storage_kind': b'header'},
1787
1789
            'info', None, None), record)
1788
1790
        record = next(record_iter)
1789
 
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
1790
 
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1791
        self.assertEqual(("Record body", {b'storage_kind': b'fulltext',
 
1792
                          b'parents': [b'1', b'3']}, 'file', b'revid', b'fileid'),
1791
1793
                          record)
1792
1794
 
1793
1795
    def test_roundtrip_record_memory_hungry(self):
1794
1796
        fileobj = BytesIO()
1795
1797
        writer = v4.BundleWriter(fileobj)
1796
1798
        writer.begin()
1797
 
        writer.add_info_record(foo='bar')
1798
 
        writer._add_record("Record body", {'parents': ['1', '3'],
1799
 
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1799
        writer.add_info_record({b'foo': b'bar'})
 
1800
        writer._add_record("Record body", {b'parents': [b'1', b'3'],
 
1801
            b'storage_kind': b'fulltext'}, 'file', b'revid', b'fileid')
1800
1802
        writer.end()
1801
1803
        fileobj.seek(0)
1802
1804
        reader = v4.BundleReader(fileobj, stream_input=False)
1803
1805
        record_iter = reader.iter_records()
1804
1806
        record = next(record_iter)
1805
 
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1807
        self.assertEqual((None, {b'foo': b'bar', b'storage_kind': b'header'},
1806
1808
            'info', None, None), record)
1807
1809
        record = next(record_iter)
1808
 
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
1809
 
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1810
        self.assertEqual(("Record body", {b'storage_kind': b'fulltext',
 
1811
                          b'parents': [b'1', b'3']}, 'file', b'revid', b'fileid'),
1810
1812
                          record)
1811
1813
 
1812
1814
    def test_encode_name(self):
1813
 
        self.assertEqual('revision/rev1',
1814
 
            v4.BundleWriter.encode_name('revision', 'rev1'))
1815
 
        self.assertEqual('file/rev//1/file-id-1',
1816
 
            v4.BundleWriter.encode_name('file', 'rev/1', 'file-id-1'))
1817
 
        self.assertEqual('info',
 
1815
        self.assertEqual(b'revision/rev1',
 
1816
            v4.BundleWriter.encode_name('revision', b'rev1'))
 
1817
        self.assertEqual(b'file/rev//1/file-id-1',
 
1818
            v4.BundleWriter.encode_name('file', b'rev/1', b'file-id-1'))
 
1819
        self.assertEqual(b'info',
1818
1820
            v4.BundleWriter.encode_name('info', None, None))
1819
1821
 
1820
1822
    def test_decode_name(self):
1821
 
        self.assertEqual(('revision', 'rev1', None),
1822
 
            v4.BundleReader.decode_name('revision/rev1'))
1823
 
        self.assertEqual(('file', 'rev/1', 'file-id-1'),
1824
 
            v4.BundleReader.decode_name('file/rev//1/file-id-1'))
 
1823
        self.assertEqual(('revision', b'rev1', None),
 
1824
            v4.BundleReader.decode_name(b'revision/rev1'))
 
1825
        self.assertEqual(('file', b'rev/1', b'file-id-1'),
 
1826
            v4.BundleReader.decode_name(b'file/rev//1/file-id-1'))
1825
1827
        self.assertEqual(('info', None, None),
1826
 
                         v4.BundleReader.decode_name('info'))
 
1828
                         v4.BundleReader.decode_name(b'info'))
1827
1829
 
1828
1830
    def test_too_many_names(self):
1829
1831
        fileobj = BytesIO()
1830
1832
        writer = v4.BundleWriter(fileobj)
1831
1833
        writer.begin()
1832
 
        writer.add_info_record(foo='bar')
1833
 
        writer._container.add_bytes_record('blah', ['two', 'names'])
 
1834
        writer.add_info_record({b'foo': b'bar'})
 
1835
        writer._container.add_bytes_record(b'blah', [b'two', b'names'])
1834
1836
        writer.end()
1835
1837
        fileobj.seek(0)
1836
1838
        record_iter = v4.BundleReader(fileobj).iter_records()
1837
1839
        record = next(record_iter)
1838
 
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1840
        self.assertEqual((None, {b'foo': b'bar', b'storage_kind': b'header'},
1839
1841
            'info', None, None), record)
1840
1842
        self.assertRaises(errors.BadBundle, next, record_iter)
1841
1843