← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bundle.py

First cut at pluralised VersionedFiles. Some rather massive API incompatabilities, primarily because of the difficulty of coherence among competing stores.

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
from bzrlib.bundle import read_mergeable_from_url
31
32
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
32
33
from bzrlib.bundle.bundle_data import BundleTree
33
 
from bzrlib.bundle.serializer import write_bundle, read_bundle
 
34
from bzrlib.directory_service import directories
 
35
from bzrlib.bundle.serializer import write_bundle, read_bundle, v09, v4
34
36
from bzrlib.bundle.serializer.v08 import BundleSerializerV08
35
37
from bzrlib.bundle.serializer.v09 import BundleSerializerV09
 
38
from bzrlib.bundle.serializer.v4 import BundleSerializerV4
36
39
from bzrlib.branch import Branch
37
40
from bzrlib.diff import internal_diff
38
41
from bzrlib.errors import (BzrError, TestamentMismatch, NotABundle, BadBundle, 
39
42
                           NoSuchFile,)
40
43
from bzrlib.merge import Merge3Merger
41
44
from bzrlib.repofmt import knitrepo
42
 
from bzrlib.osutils import has_symlinks, sha_file
43
 
from bzrlib.tests import (TestCaseInTempDir, TestCaseWithTransport,
44
 
                          TestCase, TestSkipped)
 
45
from bzrlib.osutils import sha_file, sha_string
 
46
from bzrlib.tests import (
 
47
    SymlinkFeature,
 
48
    TestCase,
 
49
    TestCaseInTempDir,
 
50
    TestCaseWithTransport,
 
51
    TestSkipped,
 
52
    test_read_bundle,
 
53
    test_commit,
 
54
    )
45
55
from bzrlib.transform import TreeTransform
46
 
from bzrlib.workingtree import WorkingTree
47
56
 
48
57
 
49
58
class MockTree(object):
160
169
        self.assertEqual(btree.path2id("grandparent/parent"), "b")
161
170
        self.assertEqual(btree.path2id("grandparent/parent/file"), "c")
162
171
 
163
 
        assert btree.path2id("grandparent2") is None
164
 
        assert btree.path2id("grandparent2/parent") is None
165
 
        assert btree.path2id("grandparent2/parent/file") is None
 
172
        self.assertTrue(btree.path2id("grandparent2") is None)
 
173
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
 
174
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
166
175
 
167
176
        btree.note_rename("grandparent", "grandparent2")
168
 
        assert btree.old_path("grandparent") is None
169
 
        assert btree.old_path("grandparent/parent") is None
170
 
        assert btree.old_path("grandparent/parent/file") is None
 
177
        self.assertTrue(btree.old_path("grandparent") is None)
 
178
        self.assertTrue(btree.old_path("grandparent/parent") is None)
 
179
        self.assertTrue(btree.old_path("grandparent/parent/file") is None)
171
180
 
172
181
        self.assertEqual(btree.id2path("a"), "grandparent2")
173
182
        self.assertEqual(btree.id2path("b"), "grandparent2/parent")
177
186
        self.assertEqual(btree.path2id("grandparent2/parent"), "b")
178
187
        self.assertEqual(btree.path2id("grandparent2/parent/file"), "c")
179
188
 
180
 
        assert btree.path2id("grandparent") is None
181
 
        assert btree.path2id("grandparent/parent") is None
182
 
        assert btree.path2id("grandparent/parent/file") is None
 
189
        self.assertTrue(btree.path2id("grandparent") is None)
 
190
        self.assertTrue(btree.path2id("grandparent/parent") is None)
 
191
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
183
192
 
184
193
        btree.note_rename("grandparent/parent", "grandparent2/parent2")
185
194
        self.assertEqual(btree.id2path("a"), "grandparent2")
190
199
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
191
200
        self.assertEqual(btree.path2id("grandparent2/parent2/file"), "c")
192
201
 
193
 
        assert btree.path2id("grandparent2/parent") is None
194
 
        assert btree.path2id("grandparent2/parent/file") is None
 
202
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
 
203
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
195
204
 
196
205
        btree.note_rename("grandparent/parent/file", 
197
206
                          "grandparent2/parent2/file2")
203
212
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
204
213
        self.assertEqual(btree.path2id("grandparent2/parent2/file2"), "c")
205
214
 
206
 
        assert btree.path2id("grandparent2/parent2/file") is None
 
215
        self.assertTrue(btree.path2id("grandparent2/parent2/file") is None)
207
216
 
208
217
    def test_moves(self):
209
218
        """Ensure that file moves have the proper effect on children"""
212
221
                          "grandparent/alt_parent/file")
213
222
        self.assertEqual(btree.id2path("c"), "grandparent/alt_parent/file")
214
223
        self.assertEqual(btree.path2id("grandparent/alt_parent/file"), "c")
215
 
        assert btree.path2id("grandparent/parent/file") is None
 
224
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
216
225
 
217
226
    def unified_diff(self, old, new):
218
227
        out = StringIO()
224
233
        btree = self.make_tree_1()[0]
225
234
        btree.note_rename("grandparent/parent/file", 
226
235
                          "grandparent/alt_parent/file")
227
 
        assert btree.id2path("e") is None
228
 
        assert btree.path2id("grandparent/parent/file") is None
 
236
        self.assertTrue(btree.id2path("e") is None)
 
237
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
229
238
        btree.note_id("e", "grandparent/parent/file")
230
239
        return btree
231
240
 
289
298
        btree = self.make_tree_1()[0]
290
299
        self.assertEqual(btree.get_file("c").read(), "Hello\n")
291
300
        btree.note_deletion("grandparent/parent/file")
292
 
        assert btree.id2path("c") is None
293
 
        assert btree.path2id("grandparent/parent/file") is None
 
301
        self.assertTrue(btree.id2path("c") is None)
 
302
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
294
303
 
295
304
    def sorted_ids(self, tree):
296
305
        ids = list(tree)
314
323
 
315
324
    def test_mismatched_bundle(self):
316
325
        format = bzrdir.BzrDirMetaFormat1()
317
 
        format.repository_format = knitrepo.RepositoryFormatKnit2()
 
326
        format.repository_format = knitrepo.RepositoryFormatKnit3()
318
327
        serializer = BundleSerializerV08('0.8')
319
328
        b = self.make_branch('.', format=format)
320
329
        self.assertRaises(errors.IncompatibleBundleFormat, serializer.write, 
323
332
    def test_matched_bundle(self):
324
333
        """Don't raise IncompatibleBundleFormat for knit2 and bundle0.9"""
325
334
        format = bzrdir.BzrDirMetaFormat1()
326
 
        format.repository_format = knitrepo.RepositoryFormatKnit2()
 
335
        format.repository_format = knitrepo.RepositoryFormatKnit3()
327
336
        serializer = BundleSerializerV09('0.9')
328
337
        b = self.make_branch('.', format=format)
329
338
        serializer.write(b.repository, [], {}, StringIO())
331
340
    def test_mismatched_model(self):
332
341
        """Try copying a bundle from knit2 to knit1"""
333
342
        format = bzrdir.BzrDirMetaFormat1()
334
 
        format.repository_format = knitrepo.RepositoryFormatKnit2()
 
343
        format.repository_format = knitrepo.RepositoryFormatKnit3()
335
344
        source = self.make_branch_and_tree('source', format=format)
336
345
        source.commit('one', rev_id='one-id')
337
346
        source.commit('two', rev_id='two-id')
338
347
        text = StringIO()
339
 
        write_bundle(source.branch.repository, 'two-id', None, text, 
 
348
        write_bundle(source.branch.repository, 'two-id', 'null:', text,
340
349
                     format='0.9')
341
350
        text.seek(0)
342
351
 
347
356
                          target.repository, read_bundle(text))
348
357
 
349
358
 
350
 
class V08BundleTester(TestCaseWithTransport):
351
 
 
352
 
    format = '0.8'
 
359
class BundleTester(object):
353
360
 
354
361
    def bzrdir_format(self):
355
362
        format = bzrdir.BzrDirMetaFormat1()
378
385
        rev = self.b1.repository.get_revision(rev_id)
379
386
        self.assertEqual(bundle_txt.readline().decode('utf-8'),
380
387
                         u'# message:\n')
381
 
 
382
 
        open(',,bundle', 'wb').write(bundle_txt.getvalue())
383
388
        bundle_txt.seek(0)
384
389
        return bundle_txt, rev_ids
385
390
 
456
461
                os.mkdir(checkout_dir)
457
462
        tree = self.make_branch_and_tree(checkout_dir)
458
463
        s = StringIO()
459
 
        ancestors = write_bundle(self.b1.repository, rev_id, None, s,
 
464
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
460
465
                                 format=self.format)
461
466
        s.seek(0)
462
 
        assert isinstance(s.getvalue(), str), (
463
 
            "Bundle isn't a bytestring:\n %s..." % repr(s.getvalue())[:40])
 
467
        self.assertIsInstance(s.getvalue(), str)
464
468
        install_bundle(tree.branch.repository, read_bundle(s))
465
469
        for ancestor in ancestors:
466
470
            old = self.b1.repository.revision_tree(ancestor)
467
471
            new = tree.branch.repository.revision_tree(ancestor)
468
 
 
469
 
            # Check that there aren't any inventory level changes
470
 
            delta = new.changes_from(old)
471
 
            self.assertFalse(delta.has_changed(),
472
 
                             'Revision %s not copied correctly.'
473
 
                             % (ancestor,))
474
 
 
475
 
            # Now check that the file contents are all correct
476
 
            for inventory_id in old:
477
 
                try:
478
 
                    old_file = old.get_file(inventory_id)
479
 
                except NoSuchFile:
480
 
                    continue
481
 
                if old_file is None:
482
 
                    continue
483
 
                self.assertEqual(old_file.read(),
484
 
                                 new.get_file(inventory_id).read())
485
 
        if rev_id is not None:
 
472
            old.lock_read()
 
473
            new.lock_read()
 
474
            try:
 
475
                # Check that there aren't any inventory level changes
 
476
                delta = new.changes_from(old)
 
477
                self.assertFalse(delta.has_changed(),
 
478
                                 'Revision %s not copied correctly.'
 
479
                                 % (ancestor,))
 
480
 
 
481
                # Now check that the file contents are all correct
 
482
                for inventory_id in old:
 
483
                    try:
 
484
                        old_file = old.get_file(inventory_id)
 
485
                    except NoSuchFile:
 
486
                        continue
 
487
                    if old_file is None:
 
488
                        continue
 
489
                    self.assertEqual(old_file.read(),
 
490
                                     new.get_file(inventory_id).read())
 
491
            finally:
 
492
                new.unlock()
 
493
                old.unlock()
 
494
        if not _mod_revision.is_null(rev_id):
486
495
            rh = self.b1.revision_history()
487
496
            tree.branch.set_revision_history(rh[:rh.index(rev_id)+1])
488
497
            tree.update()
489
498
            delta = tree.changes_from(self.b1.repository.revision_tree(rev_id))
490
499
            self.assertFalse(delta.has_changed(),
491
 
                             'Working tree has modifications')
 
500
                             'Working tree has modifications: %s' % delta)
492
501
        return tree
493
502
 
494
503
    def valid_apply_bundle(self, base_rev_id, info, checkout_dir=None):
496
505
        sure everything matches the builtin branch.
497
506
        """
498
507
        to_tree = self.get_checkout(base_rev_id, checkout_dir=checkout_dir)
 
508
        to_tree.lock_write()
 
509
        try:
 
510
            self._valid_apply_bundle(base_rev_id, info, to_tree)
 
511
        finally:
 
512
            to_tree.unlock()
 
513
 
 
514
    def _valid_apply_bundle(self, base_rev_id, info, to_tree):
499
515
        original_parents = to_tree.get_parent_ids()
500
516
        repository = to_tree.branch.repository
501
517
        original_parents = to_tree.get_parent_ids()
549
565
        self.tree1.add('one')
550
566
        self.tree1.commit('add one', rev_id='a@cset-0-1')
551
567
 
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')
 
568
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
559
569
 
560
570
        # Make sure we can handle files with spaces, tabs, other
561
571
        # bogus characters
574
584
        tt = TreeTransform(self.tree1)
575
585
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
576
586
        tt.apply()
 
587
        # have to fix length of file-id so that we can predictably rewrite
 
588
        # a (length-prefixed) record containing it later.
 
589
        self.tree1.add('with space.txt', 'withspace-id')
577
590
        self.tree1.add([
578
 
                'with space.txt'
579
 
                , 'dir'
 
591
                  'dir'
580
592
                , 'dir/filein subdir.c'
581
593
                , 'dir/WithCaps.txt'
582
594
                , 'dir/ pre space'
591
603
        bundle = self.get_valid_bundle('a@cset-0-1', 'a@cset-0-2')
592
604
 
593
605
        # Check a rollup bundle 
594
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-2')
 
606
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
595
607
 
596
608
        # Now delete entries
597
609
        self.tree1.remove(
606
618
        self.tree1.commit('removed', rev_id='a@cset-0-3')
607
619
        
608
620
        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')
 
621
        self.assertRaises((TestamentMismatch,
 
622
            errors.VersionedFileInvalidChecksum), self.get_invalid_bundle,
 
623
            'a@cset-0-2', 'a@cset-0-3')
611
624
        # Check a rollup bundle 
612
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-3')
 
625
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
613
626
 
614
627
        # Now move the directory
615
628
        self.tree1.rename_one('dir', 'sub/dir')
617
630
 
618
631
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
619
632
        # Check a rollup bundle 
620
 
        bundle = self.get_valid_bundle(None, 'a@cset-0-4')
 
633
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
621
634
 
622
635
        # Modified files
623
636
        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')
 
637
        open('b1/sub/dir/ pre space', 'ab').write(
 
638
             '\r\nAdding some\r\nDOS format lines\r\n')
625
639
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
626
640
        self.tree1.rename_one('sub/dir/ pre space', 
627
641
                              'sub/ start space')
641
655
        self.assertEqualDiff(tree1_inv, tree2_inv)
642
656
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
643
657
        other.commit('rename file', rev_id='a@cset-0-6b')
644
 
        _merge_helper([other.basedir, -1], [None, None],
645
 
                      this_dir=self.tree1.basedir)
 
658
        self.tree1.merge_from_branch(other.branch)
646
659
        self.tree1.commit(u'Merge', rev_id='a@cset-0-7',
647
660
                          verbose=False)
648
661
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
649
662
 
650
663
    def test_symlink_bundle(self):
651
 
        if not has_symlinks():
652
 
            raise TestSkipped("No symlink support")
 
664
        self.requireFeature(SymlinkFeature)
653
665
        self.tree1 = self.make_branch_and_tree('b1')
654
666
        self.b1 = self.tree1.branch
655
667
        tt = TreeTransform(self.tree1)
656
668
        tt.new_symlink('link', tt.root, 'bar/foo', 'link-1')
657
669
        tt.apply()
658
670
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
659
 
        self.get_valid_bundle(None, 'l@cset-0-1')
 
671
        self.get_valid_bundle('null:', 'l@cset-0-1')
660
672
        tt = TreeTransform(self.tree1)
661
673
        trans_id = tt.trans_id_tree_file_id('link-1')
662
674
        tt.adjust_path('link2', tt.root, trans_id)
686
698
        
687
699
        # Add
688
700
        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')
 
701
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
 
702
            'binary-2')
690
703
        tt.apply()
691
704
        self.tree1.commit('add binary', rev_id='b@cset-0-1')
692
 
        self.get_valid_bundle(None, 'b@cset-0-1')
 
705
        self.get_valid_bundle('null:', 'b@cset-0-1')
693
706
 
694
707
        # Delete
695
708
        tt = TreeTransform(self.tree1)
719
732
        self.get_valid_bundle('b@cset-0-3', 'b@cset-0-4')
720
733
 
721
734
        # Rollup
722
 
        self.get_valid_bundle(None, 'b@cset-0-4')
 
735
        self.get_valid_bundle('null:', 'b@cset-0-4')
723
736
 
724
737
    def test_last_modified(self):
725
738
        self.tree1 = self.make_branch_and_tree('b1')
743
756
        tt.create_file('file2', trans_id)
744
757
        tt.apply()
745
758
        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)
 
759
        self.tree1.merge_from_branch(other.branch)
748
760
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-3',
749
761
                          verbose=False)
750
762
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-4')
764
776
        bundle_file = StringIO()
765
777
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
766
778
                               'a@cset-0-1', bundle_file, format=self.format)
767
 
        self.assertNotContainsRe(bundle_file.getvalue(), 'two')
768
 
        self.assertContainsRe(bundle_file.getvalue(), 'one')
769
 
        self.assertContainsRe(bundle_file.getvalue(), 'three')
 
779
        self.assertNotContainsRe(bundle_file.getvalue(), '\btwo\b')
 
780
        self.assertContainsRe(self.get_raw(bundle_file), 'one')
 
781
        self.assertContainsRe(self.get_raw(bundle_file), 'three')
 
782
 
 
783
    def test_bundle_same_basis(self):
 
784
        """Ensure using the basis as the target doesn't cause an error"""
 
785
        self.tree1 = self.make_branch_and_tree('b1')
 
786
        self.tree1.commit('add file', rev_id='a@cset-0-1')
 
787
        bundle_file = StringIO()
 
788
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-1',
 
789
                               'a@cset-0-1', bundle_file)
 
790
 
 
791
    @staticmethod
 
792
    def get_raw(bundle_file):
 
793
        return bundle_file.getvalue()
770
794
 
771
795
    def test_unicode_bundle(self):
772
796
        # Handle international characters
784
808
            u'William Dod\xe9\n').encode('utf-8'))
785
809
        f.close()
786
810
 
787
 
        self.tree1.add([u'with Dod\xe9'])
788
 
        self.tree1.commit(u'i18n commit from William Dod\xe9', 
 
811
        self.tree1.add([u'with Dod\xe9'], ['withdod-id'])
 
812
        self.tree1.commit(u'i18n commit from William Dod\xe9',
789
813
                          rev_id='i18n-1', committer=u'William Dod\xe9')
790
814
 
 
815
        if sys.platform == 'darwin':
 
816
            from bzrlib.workingtree import WorkingTree3
 
817
            if type(self.tree1) is WorkingTree3:
 
818
                self.knownFailure("Bug #141438: fails for WorkingTree3 on OSX")
 
819
 
 
820
            # On Mac the '\xe9' gets changed to 'e\u0301'
 
821
            self.assertEqual([u'.bzr', u'with Dode\u0301'],
 
822
                             sorted(os.listdir(u'b1')))
 
823
            delta = self.tree1.changes_from(self.tree1.basis_tree())
 
824
            self.assertEqual([(u'with Dod\xe9', 'withdod-id', 'file')],
 
825
                             delta.removed)
 
826
            self.knownFailure("Mac OSX doesn't preserve unicode"
 
827
                              " combining characters.")
 
828
 
791
829
        # Add
792
 
        bundle = self.get_valid_bundle(None, 'i18n-1')
 
830
        bundle = self.get_valid_bundle('null:', 'i18n-1')
793
831
 
794
832
        # Modified
795
833
        f = open(u'b1/with Dod\xe9', 'wb')
813
851
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
814
852
 
815
853
        # Rollup
816
 
        bundle = self.get_valid_bundle(None, 'i18n-4')
 
854
        bundle = self.get_valid_bundle('null:', 'i18n-4')
817
855
 
818
856
 
819
857
    def test_whitespace_bundle(self):
831
869
        # Added
832
870
        self.tree1.commit('funky whitespace', rev_id='white-1')
833
871
 
834
 
        bundle = self.get_valid_bundle(None, 'white-1')
 
872
        bundle = self.get_valid_bundle('null:', 'white-1')
835
873
 
836
874
        # Modified
837
875
        open('b1/trailing space ', 'ab').write('add some text\n')
852
890
        bundle = self.get_valid_bundle('white-3', 'white-4')
853
891
        
854
892
        # Now test a complet roll-up
855
 
        bundle = self.get_valid_bundle(None, 'white-4')
 
893
        bundle = self.get_valid_bundle('null:', 'white-4')
856
894
 
857
895
    def test_alt_timezone_bundle(self):
858
896
        self.tree1 = self.make_branch_and_memory_tree('b1')
868
906
        self.tree1.commit('non-hour offset timezone', rev_id='tz-1',
869
907
                          timezone=19800, timestamp=1152544886.0)
870
908
 
871
 
        bundle = self.get_valid_bundle(None, 'tz-1')
 
909
        bundle = self.get_valid_bundle('null:', 'tz-1')
872
910
        
873
911
        rev = bundle.revisions[0]
874
912
        self.assertEqual('Mon 2006-07-10 20:51:26.000000000 +0530', rev.date)
880
918
        self.tree1 = self.make_branch_and_tree('b1')
881
919
        self.b1 = self.tree1.branch
882
920
        self.tree1.commit('message', rev_id='revid1')
883
 
        bundle = self.get_valid_bundle(None, 'revid1')
884
 
        tree = bundle.revision_tree(self.b1.repository, 'revid1')
 
921
        bundle = self.get_valid_bundle('null:', 'revid1')
 
922
        tree = self.get_bundle_tree(bundle, 'revid1')
885
923
        self.assertEqual('revid1', tree.inventory.root.revision)
886
924
 
 
925
    def test_install_revisions(self):
 
926
        self.tree1 = self.make_branch_and_tree('b1')
 
927
        self.b1 = self.tree1.branch
 
928
        self.tree1.commit('message', rev_id='rev2a')
 
929
        bundle = self.get_valid_bundle('null:', 'rev2a')
 
930
        branch2 = self.make_branch('b2')
 
931
        self.assertFalse(branch2.repository.has_revision('rev2a'))
 
932
        target_revision = bundle.install_revisions(branch2.repository)
 
933
        self.assertTrue(branch2.repository.has_revision('rev2a'))
 
934
        self.assertEqual('rev2a', target_revision)
 
935
 
 
936
    def test_bundle_empty_property(self):
 
937
        """Test serializing revision properties with an empty value."""
 
938
        tree = self.make_branch_and_memory_tree('tree')
 
939
        tree.lock_write()
 
940
        self.addCleanup(tree.unlock)
 
941
        tree.add([''], ['TREE_ROOT'])
 
942
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
943
        self.b1 = tree.branch
 
944
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
945
        bundle = read_bundle(bundle_sio)
 
946
        revision_info = bundle.revisions[0]
 
947
        self.assertEqual('rev1', revision_info.revision_id)
 
948
        rev = revision_info.as_revision()
 
949
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
950
                         rev.properties)
 
951
 
 
952
    def test_bundle_sorted_properties(self):
 
953
        """For stability the writer should write properties in sorted order."""
 
954
        tree = self.make_branch_and_memory_tree('tree')
 
955
        tree.lock_write()
 
956
        self.addCleanup(tree.unlock)
 
957
 
 
958
        tree.add([''], ['TREE_ROOT'])
 
959
        tree.commit('One', rev_id='rev1',
 
960
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
 
961
        self.b1 = tree.branch
 
962
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
963
        bundle = read_bundle(bundle_sio)
 
964
        revision_info = bundle.revisions[0]
 
965
        self.assertEqual('rev1', revision_info.revision_id)
 
966
        rev = revision_info.as_revision()
 
967
        self.assertEqual({'branch-nick':'tree', 'a':'4', 'b':'3', 'c':'2',
 
968
                          'd':'1'}, rev.properties)
 
969
 
 
970
    def test_bundle_unicode_properties(self):
 
971
        """We should be able to round trip a non-ascii property."""
 
972
        tree = self.make_branch_and_memory_tree('tree')
 
973
        tree.lock_write()
 
974
        self.addCleanup(tree.unlock)
 
975
 
 
976
        tree.add([''], ['TREE_ROOT'])
 
977
        # Revisions themselves do not require anything about revision property
 
978
        # keys, other than that they are a basestring, and do not contain
 
979
        # whitespace.
 
980
        # However, Testaments assert than they are str(), and thus should not
 
981
        # be Unicode.
 
982
        tree.commit('One', rev_id='rev1',
 
983
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
 
984
        self.b1 = tree.branch
 
985
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
986
        bundle = read_bundle(bundle_sio)
 
987
        revision_info = bundle.revisions[0]
 
988
        self.assertEqual('rev1', revision_info.revision_id)
 
989
        rev = revision_info.as_revision()
 
990
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
 
991
                          'alpha':u'\u03b1'}, rev.properties)
 
992
 
 
993
    def test_bundle_with_ghosts(self):
 
994
        tree = self.make_branch_and_tree('tree')
 
995
        self.b1 = tree.branch
 
996
        self.build_tree_contents([('tree/file', 'content1')])
 
997
        tree.add(['file'])
 
998
        tree.commit('rev1')
 
999
        self.build_tree_contents([('tree/file', 'content2')])
 
1000
        tree.add_parent_tree_id('ghost')
 
1001
        tree.commit('rev2', rev_id='rev2')
 
1002
        bundle = self.get_valid_bundle('null:', 'rev2')
 
1003
 
 
1004
    def make_simple_tree(self, format=None):
 
1005
        tree = self.make_branch_and_tree('b1', format=format)
 
1006
        self.b1 = tree.branch
 
1007
        self.build_tree(['b1/file'])
 
1008
        tree.add('file')
 
1009
        return tree
 
1010
 
 
1011
    def test_across_serializers(self):
 
1012
        tree = self.make_simple_tree('knit')
 
1013
        tree.commit('hello', rev_id='rev1')
 
1014
        tree.commit('hello', rev_id='rev2')
 
1015
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1016
        repo = self.make_repository('repo', format='dirstate-with-subtree')
 
1017
        bundle.install_revisions(repo)
 
1018
        inv_text = repo.get_inventory_xml('rev2')
 
1019
        self.assertNotContainsRe(inv_text, 'format="5"')
 
1020
        self.assertContainsRe(inv_text, 'format="7"')
 
1021
 
 
1022
    def make_repo_with_installed_revisions(self):
 
1023
        tree = self.make_simple_tree('knit')
 
1024
        tree.commit('hello', rev_id='rev1')
 
1025
        tree.commit('hello', rev_id='rev2')
 
1026
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1027
        repo = self.make_repository('repo', format='dirstate-with-subtree')
 
1028
        bundle.install_revisions(repo)
 
1029
        return repo
 
1030
 
 
1031
    def test_across_models(self):
 
1032
        repo = self.make_repo_with_installed_revisions()
 
1033
        inv = repo.get_inventory('rev2')
 
1034
        self.assertEqual('rev2', inv.root.revision)
 
1035
        root_id = inv.root.file_id
 
1036
        repo.lock_read()
 
1037
        self.addCleanup(repo.unlock)
 
1038
        self.assertEqual({(root_id, 'rev1'):(),
 
1039
            (root_id, 'rev2'):((root_id, 'rev1'),)},
 
1040
            repo.texts.get_parent_map([(root_id, 'rev1'), (root_id, 'rev2')]))
 
1041
 
 
1042
    def test_inv_hash_across_serializers(self):
 
1043
        repo = self.make_repo_with_installed_revisions()
 
1044
        recorded_inv_sha1 = repo.get_inventory_sha1('rev2')
 
1045
        xml = repo.get_inventory_xml('rev2')
 
1046
        self.assertEqual(sha_string(xml), recorded_inv_sha1)
 
1047
 
 
1048
    def test_across_models_incompatible(self):
 
1049
        tree = self.make_simple_tree('dirstate-with-subtree')
 
1050
        tree.commit('hello', rev_id='rev1')
 
1051
        tree.commit('hello', rev_id='rev2')
 
1052
        try:
 
1053
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1054
        except errors.IncompatibleBundleFormat:
 
1055
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1056
        repo = self.make_repository('repo', format='knit')
 
1057
        bundle.install_revisions(repo)
 
1058
 
 
1059
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1060
        self.assertRaises(errors.IncompatibleRevision,
 
1061
                          bundle.install_revisions, repo)
 
1062
 
 
1063
    def test_get_merge_request(self):
 
1064
        tree = self.make_simple_tree()
 
1065
        tree.commit('hello', rev_id='rev1')
 
1066
        tree.commit('hello', rev_id='rev2')
 
1067
        bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1068
        result = bundle.get_merge_request(tree.branch.repository)
 
1069
        self.assertEqual((None, 'rev1', 'inapplicable'), result)
 
1070
 
 
1071
    def test_with_subtree(self):
 
1072
        tree = self.make_branch_and_tree('tree',
 
1073
                                         format='dirstate-with-subtree')
 
1074
        self.b1 = tree.branch
 
1075
        subtree = self.make_branch_and_tree('tree/subtree',
 
1076
                                            format='dirstate-with-subtree')
 
1077
        tree.add('subtree')
 
1078
        tree.commit('hello', rev_id='rev1')
 
1079
        try:
 
1080
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1081
        except errors.IncompatibleBundleFormat:
 
1082
            raise TestSkipped("Format 0.8 doesn't work with knit3")
 
1083
        if isinstance(bundle, v09.BundleInfo09):
 
1084
            raise TestSkipped("Format 0.9 doesn't work with subtrees")
 
1085
        repo = self.make_repository('repo', format='knit')
 
1086
        self.assertRaises(errors.IncompatibleRevision,
 
1087
                          bundle.install_revisions, repo)
 
1088
        repo2 = self.make_repository('repo2', format='dirstate-with-subtree')
 
1089
        bundle.install_revisions(repo2)
 
1090
 
 
1091
    def test_revision_id_with_slash(self):
 
1092
        self.tree1 = self.make_branch_and_tree('tree')
 
1093
        self.b1 = self.tree1.branch
 
1094
        try:
 
1095
            self.tree1.commit('Revision/id/with/slashes', rev_id='rev/id')
 
1096
        except ValueError:
 
1097
            raise TestSkipped("Repository doesn't support revision ids with"
 
1098
                              " slashes")
 
1099
        bundle = self.get_valid_bundle('null:', 'rev/id')
 
1100
 
 
1101
    def test_skip_file(self):
 
1102
        """Make sure we don't accidentally write to the wrong versionedfile"""
 
1103
        self.tree1 = self.make_branch_and_tree('tree')
 
1104
        self.b1 = self.tree1.branch
 
1105
        # rev1 is not present in bundle, done by fetch
 
1106
        self.build_tree_contents([('tree/file2', 'contents1')])
 
1107
        self.tree1.add('file2', 'file2-id')
 
1108
        self.tree1.commit('rev1', rev_id='reva')
 
1109
        self.build_tree_contents([('tree/file3', 'contents2')])
 
1110
        # rev2 is present in bundle, and done by fetch
 
1111
        # having file1 in the bunle causes file1's versionedfile to be opened.
 
1112
        self.tree1.add('file3', 'file3-id')
 
1113
        self.tree1.commit('rev2')
 
1114
        # Updating file2 should not cause an attempt to add to file1's vf
 
1115
        target = self.tree1.bzrdir.sprout('target').open_workingtree()
 
1116
        self.build_tree_contents([('tree/file2', 'contents3')])
 
1117
        self.tree1.commit('rev3', rev_id='rev3')
 
1118
        bundle = self.get_valid_bundle('reva', 'rev3')
 
1119
        if getattr(bundle, 'get_bundle_reader', None) is None:
 
1120
            raise TestSkipped('Bundle format cannot provide reader')
 
1121
        # be sure that file1 comes before file2
 
1122
        for b, m, k, r, f in bundle.get_bundle_reader().iter_records():
 
1123
            if f == 'file3-id':
 
1124
                break
 
1125
            self.assertNotEqual(f, 'file2-id')
 
1126
        bundle.install_revisions(target.branch.repository)
 
1127
 
 
1128
 
 
1129
class V08BundleTester(BundleTester, TestCaseWithTransport):
 
1130
 
 
1131
    format = '0.8'
 
1132
 
 
1133
    def test_bundle_empty_property(self):
 
1134
        """Test serializing revision properties with an empty value."""
 
1135
        tree = self.make_branch_and_memory_tree('tree')
 
1136
        tree.lock_write()
 
1137
        self.addCleanup(tree.unlock)
 
1138
        tree.add([''], ['TREE_ROOT'])
 
1139
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1140
        self.b1 = tree.branch
 
1141
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1142
        self.assertContainsRe(bundle_sio.getvalue(),
 
1143
                              '# properties:\n'
 
1144
                              '#   branch-nick: tree\n'
 
1145
                              '#   empty: \n'
 
1146
                              '#   one: two\n'
 
1147
                             )
 
1148
        bundle = read_bundle(bundle_sio)
 
1149
        revision_info = bundle.revisions[0]
 
1150
        self.assertEqual('rev1', revision_info.revision_id)
 
1151
        rev = revision_info.as_revision()
 
1152
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
1153
                         rev.properties)
 
1154
 
 
1155
    def get_bundle_tree(self, bundle, revision_id):
 
1156
        repository = self.make_repository('repo')
 
1157
        return bundle.revision_tree(repository, 'revid1')
 
1158
 
 
1159
    def test_bundle_empty_property_alt(self):
 
1160
        """Test serializing revision properties with an empty value.
 
1161
 
 
1162
        Older readers had a bug when reading an empty property.
 
1163
        They assumed that all keys ended in ': \n'. However they would write an
 
1164
        empty value as ':\n'. This tests make sure that all newer bzr versions
 
1165
        can handle th second form.
 
1166
        """
 
1167
        tree = self.make_branch_and_memory_tree('tree')
 
1168
        tree.lock_write()
 
1169
        self.addCleanup(tree.unlock)
 
1170
        tree.add([''], ['TREE_ROOT'])
 
1171
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1172
        self.b1 = tree.branch
 
1173
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1174
        txt = bundle_sio.getvalue()
 
1175
        loc = txt.find('#   empty: ') + len('#   empty:')
 
1176
        # Create a new bundle, which strips the trailing space after empty
 
1177
        bundle_sio = StringIO(txt[:loc] + txt[loc+1:])
 
1178
 
 
1179
        self.assertContainsRe(bundle_sio.getvalue(),
 
1180
                              '# properties:\n'
 
1181
                              '#   branch-nick: tree\n'
 
1182
                              '#   empty:\n'
 
1183
                              '#   one: two\n'
 
1184
                             )
 
1185
        bundle = read_bundle(bundle_sio)
 
1186
        revision_info = bundle.revisions[0]
 
1187
        self.assertEqual('rev1', revision_info.revision_id)
 
1188
        rev = revision_info.as_revision()
 
1189
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
1190
                         rev.properties)
 
1191
 
 
1192
    def test_bundle_sorted_properties(self):
 
1193
        """For stability the writer should write properties in sorted order."""
 
1194
        tree = self.make_branch_and_memory_tree('tree')
 
1195
        tree.lock_write()
 
1196
        self.addCleanup(tree.unlock)
 
1197
 
 
1198
        tree.add([''], ['TREE_ROOT'])
 
1199
        tree.commit('One', rev_id='rev1',
 
1200
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
 
1201
        self.b1 = tree.branch
 
1202
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1203
        self.assertContainsRe(bundle_sio.getvalue(),
 
1204
                              '# properties:\n'
 
1205
                              '#   a: 4\n'
 
1206
                              '#   b: 3\n'
 
1207
                              '#   branch-nick: tree\n'
 
1208
                              '#   c: 2\n'
 
1209
                              '#   d: 1\n'
 
1210
                             )
 
1211
        bundle = read_bundle(bundle_sio)
 
1212
        revision_info = bundle.revisions[0]
 
1213
        self.assertEqual('rev1', revision_info.revision_id)
 
1214
        rev = revision_info.as_revision()
 
1215
        self.assertEqual({'branch-nick':'tree', 'a':'4', 'b':'3', 'c':'2',
 
1216
                          'd':'1'}, rev.properties)
 
1217
 
 
1218
    def test_bundle_unicode_properties(self):
 
1219
        """We should be able to round trip a non-ascii property."""
 
1220
        tree = self.make_branch_and_memory_tree('tree')
 
1221
        tree.lock_write()
 
1222
        self.addCleanup(tree.unlock)
 
1223
 
 
1224
        tree.add([''], ['TREE_ROOT'])
 
1225
        # Revisions themselves do not require anything about revision property
 
1226
        # keys, other than that they are a basestring, and do not contain
 
1227
        # whitespace.
 
1228
        # However, Testaments assert than they are str(), and thus should not
 
1229
        # be Unicode.
 
1230
        tree.commit('One', rev_id='rev1',
 
1231
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
 
1232
        self.b1 = tree.branch
 
1233
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1234
        self.assertContainsRe(bundle_sio.getvalue(),
 
1235
                              '# properties:\n'
 
1236
                              '#   alpha: \xce\xb1\n'
 
1237
                              '#   branch-nick: tree\n'
 
1238
                              '#   omega: \xce\xa9\n'
 
1239
                             )
 
1240
        bundle = read_bundle(bundle_sio)
 
1241
        revision_info = bundle.revisions[0]
 
1242
        self.assertEqual('rev1', revision_info.revision_id)
 
1243
        rev = revision_info.as_revision()
 
1244
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
 
1245
                          'alpha':u'\u03b1'}, rev.properties)
 
1246
 
887
1247
 
888
1248
class V09BundleKnit2Tester(V08BundleTester):
889
1249
 
891
1251
 
892
1252
    def bzrdir_format(self):
893
1253
        format = bzrdir.BzrDirMetaFormat1()
894
 
        format.repository_format = knitrepo.RepositoryFormatKnit2()
 
1254
        format.repository_format = knitrepo.RepositoryFormatKnit3()
895
1255
        return format
896
1256
 
897
1257
 
905
1265
        return format
906
1266
 
907
1267
 
908
 
class MungedBundleTester(TestCaseWithTransport):
 
1268
class V4BundleTester(BundleTester, TestCaseWithTransport):
 
1269
 
 
1270
    format = '4'
 
1271
 
 
1272
    def get_valid_bundle(self, base_rev_id, rev_id, checkout_dir=None):
 
1273
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1274
        Make sure that the text generated is valid, and that it
 
1275
        can be applied against the base, and generate the same information.
 
1276
        
 
1277
        :return: The in-memory bundle 
 
1278
        """
 
1279
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1280
 
 
1281
        # This should also validate the generated bundle 
 
1282
        bundle = read_bundle(bundle_txt)
 
1283
        repository = self.b1.repository
 
1284
        for bundle_rev in bundle.real_revisions:
 
1285
            # These really should have already been checked when we read the
 
1286
            # bundle, since it computes the sha1 hash for the revision, which
 
1287
            # only will match if everything is okay, but lets be explicit about
 
1288
            # it
 
1289
            branch_rev = repository.get_revision(bundle_rev.revision_id)
 
1290
            for a in ('inventory_sha1', 'revision_id', 'parent_ids',
 
1291
                      'timestamp', 'timezone', 'message', 'committer', 
 
1292
                      'parent_ids', 'properties'):
 
1293
                self.assertEqual(getattr(branch_rev, a), 
 
1294
                                 getattr(bundle_rev, a))
 
1295
            self.assertEqual(len(branch_rev.parent_ids), 
 
1296
                             len(bundle_rev.parent_ids))
 
1297
        self.assertEqual(set(rev_ids),
 
1298
                         set([r.revision_id for r in bundle.real_revisions]))
 
1299
        self.valid_apply_bundle(base_rev_id, bundle,
 
1300
                                   checkout_dir=checkout_dir)
 
1301
 
 
1302
        return bundle
 
1303
 
 
1304
    def get_invalid_bundle(self, base_rev_id, rev_id):
 
1305
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
 
1306
        Munge the text so that it's invalid.
 
1307
 
 
1308
        :return: The in-memory bundle
 
1309
        """
 
1310
        from bzrlib.bundle import serializer
 
1311
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
 
1312
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1313
        new_text = new_text.replace('<file file_id="exe-1"',
 
1314
                                    '<file executable="y" file_id="exe-1"')
 
1315
        new_text = new_text.replace('B222', 'B237')
 
1316
        bundle_txt = StringIO()
 
1317
        bundle_txt.write(serializer._get_bundle_header('4'))
 
1318
        bundle_txt.write('\n')
 
1319
        bundle_txt.write(new_text.encode('bz2'))
 
1320
        bundle_txt.seek(0)
 
1321
        bundle = read_bundle(bundle_txt)
 
1322
        self.valid_apply_bundle(base_rev_id, bundle)
 
1323
        return bundle
 
1324
 
 
1325
    def create_bundle_text(self, base_rev_id, rev_id):
 
1326
        bundle_txt = StringIO()
 
1327
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id, 
 
1328
                               bundle_txt, format=self.format)
 
1329
        bundle_txt.seek(0)
 
1330
        self.assertEqual(bundle_txt.readline(), 
 
1331
                         '# Bazaar revision bundle v%s\n' % self.format)
 
1332
        self.assertEqual(bundle_txt.readline(), '#\n')
 
1333
        rev = self.b1.repository.get_revision(rev_id)
 
1334
        bundle_txt.seek(0)
 
1335
        return bundle_txt, rev_ids
 
1336
 
 
1337
    def get_bundle_tree(self, bundle, revision_id):
 
1338
        repository = self.make_repository('repo')
 
1339
        bundle.install_revisions(repository)
 
1340
        return repository.revision_tree(revision_id)
 
1341
 
 
1342
    def test_creation(self):
 
1343
        tree = self.make_branch_and_tree('tree')
 
1344
        self.build_tree_contents([('tree/file', 'contents1\nstatic\n')])
 
1345
        tree.add('file', 'fileid-2')
 
1346
        tree.commit('added file', rev_id='rev1')
 
1347
        self.build_tree_contents([('tree/file', 'contents2\nstatic\n')])
 
1348
        tree.commit('changed file', rev_id='rev2')
 
1349
        s = StringIO()
 
1350
        serializer = BundleSerializerV4('1.0')
 
1351
        serializer.write(tree.branch.repository, ['rev1', 'rev2'], {}, s)
 
1352
        s.seek(0)
 
1353
        tree2 = self.make_branch_and_tree('target')
 
1354
        target_repo = tree2.branch.repository
 
1355
        install_bundle(target_repo, serializer.read(s))
 
1356
        target_repo.lock_read()
 
1357
        self.addCleanup(target_repo.unlock)
 
1358
        self.assertEqual({'1':'contents1\nstatic\n',
 
1359
            '2':'contents2\nstatic\n'},
 
1360
            dict(target_repo.iter_files_bytes(
 
1361
                [('fileid-2', 'rev1', '1'), ('fileid-2', 'rev2', '2')])))
 
1362
        rtree = target_repo.revision_tree('rev2')
 
1363
        inventory_vf = target_repo.inventories
 
1364
        # If the inventory store has a graph, it must match the revision graph.
 
1365
        self.assertSubset(
 
1366
            [inventory_vf.get_parent_map([('rev2',)])[('rev2',)]],
 
1367
            [None, (('rev1',),)])
 
1368
        self.assertEqual('changed file',
 
1369
                         target_repo.get_revision('rev2').message)
 
1370
 
 
1371
    @staticmethod
 
1372
    def get_raw(bundle_file):
 
1373
        bundle_file.seek(0)
 
1374
        line = bundle_file.readline()
 
1375
        line = bundle_file.readline()
 
1376
        lines = bundle_file.readlines()
 
1377
        return ''.join(lines).decode('bz2')
 
1378
 
 
1379
    def test_copy_signatures(self):
 
1380
        tree_a = self.make_branch_and_tree('tree_a')
 
1381
        import bzrlib.gpg
 
1382
        import bzrlib.commit as commit
 
1383
        oldstrategy = bzrlib.gpg.GPGStrategy
 
1384
        branch = tree_a.branch
 
1385
        repo_a = branch.repository
 
1386
        tree_a.commit("base", allow_pointless=True, rev_id='A')
 
1387
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
 
1388
        try:
 
1389
            from bzrlib.testament import Testament
 
1390
            # monkey patch gpg signing mechanism
 
1391
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
1392
            new_config = test_commit.MustSignConfig(branch)
 
1393
            commit.Commit(config=new_config).commit(message="base",
 
1394
                                                    allow_pointless=True,
 
1395
                                                    rev_id='B',
 
1396
                                                    working_tree=tree_a)
 
1397
            def sign(text):
 
1398
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
 
1399
            self.assertTrue(repo_a.has_signature_for_revision_id('B'))
 
1400
        finally:
 
1401
            bzrlib.gpg.GPGStrategy = oldstrategy
 
1402
        tree_b = self.make_branch_and_tree('tree_b')
 
1403
        repo_b = tree_b.branch.repository
 
1404
        s = StringIO()
 
1405
        serializer = BundleSerializerV4('4')
 
1406
        serializer.write(tree_a.branch.repository, ['A', 'B'], {}, s)
 
1407
        s.seek(0)
 
1408
        install_bundle(repo_b, serializer.read(s))
 
1409
        self.assertTrue(repo_b.has_signature_for_revision_id('B'))
 
1410
        self.assertEqual(repo_b.get_signature_text('B'),
 
1411
                         repo_a.get_signature_text('B'))
 
1412
        s.seek(0)
 
1413
        # ensure repeat installs are harmless
 
1414
        install_bundle(repo_b, serializer.read(s))
 
1415
 
 
1416
 
 
1417
class V4WeaveBundleTester(V4BundleTester):
 
1418
 
 
1419
    def bzrdir_format(self):
 
1420
        return 'metaweave'
 
1421
 
 
1422
 
 
1423
class MungedBundleTester(object):
909
1424
 
910
1425
    def build_test_bundle(self):
911
1426
        wt = self.make_branch_and_tree('b1')
920
1435
 
921
1436
        bundle_txt = StringIO()
922
1437
        rev_ids = write_bundle(wt.branch.repository, 'a@cset-0-2',
923
 
                               'a@cset-0-1', bundle_txt)
924
 
        self.assertEqual(['a@cset-0-2'], rev_ids)
 
1438
                               'a@cset-0-1', bundle_txt, self.format)
 
1439
        self.assertEqual(set(['a@cset-0-2']), set(rev_ids))
925
1440
        bundle_txt.seek(0, 0)
926
1441
        return bundle_txt
927
1442
 
956
1471
        bundle = read_bundle(bundle_txt)
957
1472
        self.check_valid(bundle)
958
1473
 
 
1474
 
 
1475
class MungedBundleTesterV09(TestCaseWithTransport, MungedBundleTester):
 
1476
 
 
1477
    format = '0.9'
 
1478
 
959
1479
    def test_missing_trailing_whitespace(self):
960
1480
        bundle_txt = self.build_test_bundle()
961
1481
 
989
1509
        bundle = read_bundle(bundle_txt)
990
1510
        self.check_valid(bundle)
991
1511
 
 
1512
 
 
1513
class MungedBundleTesterV4(TestCaseWithTransport, MungedBundleTester):
 
1514
 
 
1515
    format = '4'
 
1516
 
 
1517
 
 
1518
class TestBundleWriterReader(TestCase):
 
1519
 
 
1520
    def test_roundtrip_record(self):
 
1521
        fileobj = StringIO()
 
1522
        writer = v4.BundleWriter(fileobj)
 
1523
        writer.begin()
 
1524
        writer.add_info_record(foo='bar')
 
1525
        writer._add_record("Record body", {'parents': ['1', '3'],
 
1526
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1527
        writer.end()
 
1528
        fileobj.seek(0)
 
1529
        reader = v4.BundleReader(fileobj, stream_input=True)
 
1530
        record_iter = reader.iter_records()
 
1531
        record = record_iter.next()
 
1532
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1533
            'info', None, None), record)
 
1534
        record = record_iter.next()
 
1535
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
 
1536
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1537
                          record)
 
1538
 
 
1539
    def test_roundtrip_record_memory_hungry(self):
 
1540
        fileobj = StringIO()
 
1541
        writer = v4.BundleWriter(fileobj)
 
1542
        writer.begin()
 
1543
        writer.add_info_record(foo='bar')
 
1544
        writer._add_record("Record body", {'parents': ['1', '3'],
 
1545
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1546
        writer.end()
 
1547
        fileobj.seek(0)
 
1548
        reader = v4.BundleReader(fileobj, stream_input=False)
 
1549
        record_iter = reader.iter_records()
 
1550
        record = record_iter.next()
 
1551
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1552
            'info', None, None), record)
 
1553
        record = record_iter.next()
 
1554
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
 
1555
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
 
1556
                          record)
 
1557
 
 
1558
    def test_encode_name(self):
 
1559
        self.assertEqual('revision/rev1',
 
1560
            v4.BundleWriter.encode_name('revision', 'rev1'))
 
1561
        self.assertEqual('file/rev//1/file-id-1',
 
1562
            v4.BundleWriter.encode_name('file', 'rev/1', 'file-id-1'))
 
1563
        self.assertEqual('info',
 
1564
            v4.BundleWriter.encode_name('info', None, None))
 
1565
 
 
1566
    def test_decode_name(self):
 
1567
        self.assertEqual(('revision', 'rev1', None),
 
1568
            v4.BundleReader.decode_name('revision/rev1'))
 
1569
        self.assertEqual(('file', 'rev/1', 'file-id-1'),
 
1570
            v4.BundleReader.decode_name('file/rev//1/file-id-1'))
 
1571
        self.assertEqual(('info', None, None),
 
1572
                         v4.BundleReader.decode_name('info'))
 
1573
 
 
1574
    def test_too_many_names(self):
 
1575
        fileobj = StringIO()
 
1576
        writer = v4.BundleWriter(fileobj)
 
1577
        writer.begin()
 
1578
        writer.add_info_record(foo='bar')
 
1579
        writer._container.add_bytes_record('blah', ['two', 'names'])
 
1580
        writer.end()
 
1581
        fileobj.seek(0)
 
1582
        record_iter = v4.BundleReader(fileobj).iter_records()
 
1583
        record = record_iter.next()
 
1584
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
 
1585
            'info', None, None), record)
 
1586
        self.assertRaises(BadBundle, record_iter.next)
 
1587
 
 
1588
 
 
1589
class TestReadMergeableFromUrl(TestCaseWithTransport):
 
1590
 
 
1591
    def test_read_mergeable_skips_local(self):
 
1592
        """A local bundle named like the URL should not be read.
 
1593
        """
 
1594
        out, wt = test_read_bundle.create_bundle_file(self)
 
1595
        class FooService(object):
 
1596
            """A directory service that always returns source"""
 
1597
 
 
1598
            def look_up(self, name, url):
 
1599
                return 'source'
 
1600
        directories.register('foo:', FooService, 'Testing directory service')
 
1601
        self.addCleanup(lambda: directories.remove('foo:'))
 
1602
        self.build_tree_contents([('./foo:bar', out.getvalue())])
 
1603
        self.assertRaises(errors.NotABundle, read_mergeable_from_url,
 
1604
                          'foo:bar')