← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_bundle.py

  • Committer: Aaron Bentley
  • Date: 2007-02-06 14:52:16 UTC
  • mfrom: (2266 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2268.
  • Revision ID: abentley@panoramicfeedback.com-20070206145216-fcpi8o3ufvuzwbp9
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bundle.py
1
 
# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
24
24
    errors,
25
25
    inventory,
26
26
    repository,
27
 
    revision as _mod_revision,
28
27
    treebuilder,
29
28
    )
 
29
from bzrlib.builtins import _merge_helper
30
30
from bzrlib.bzrdir import BzrDir
31
 
from bzrlib.bundle import read_mergeable_from_url
32
31
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
33
32
from bzrlib.bundle.bundle_data import BundleTree
34
 
from bzrlib.directory_service import directories
35
 
from bzrlib.bundle.serializer import write_bundle, read_bundle, v09, v4
 
33
from bzrlib.bundle.serializer import write_bundle, read_bundle
36
34
from bzrlib.bundle.serializer.v08 import BundleSerializerV08
37
35
from bzrlib.bundle.serializer.v09 import BundleSerializerV09
38
 
from bzrlib.bundle.serializer.v4 import BundleSerializerV4
39
36
from bzrlib.branch import Branch
40
37
from bzrlib.diff import internal_diff
41
38
from bzrlib.errors import (BzrError, TestamentMismatch, NotABundle, BadBundle, 
42
39
                           NoSuchFile,)
43
40
from bzrlib.merge import Merge3Merger
44
 
from bzrlib.repofmt import knitrepo
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
 
    )
 
41
from bzrlib.osutils import has_symlinks, sha_file
 
42
from bzrlib.tests import (TestCaseInTempDir, TestCaseWithTransport,
 
43
                          TestCase, TestSkipped)
55
44
from bzrlib.transform import TreeTransform
 
45
from bzrlib.workingtree import WorkingTree
56
46
 
57
47
 
58
48
class MockTree(object):
169
159
        self.assertEqual(btree.path2id("grandparent/parent"), "b")
170
160
        self.assertEqual(btree.path2id("grandparent/parent/file"), "c")
171
161
 
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)
 
162
        assert btree.path2id("grandparent2") is None
 
163
        assert btree.path2id("grandparent2/parent") is None
 
164
        assert btree.path2id("grandparent2/parent/file") is None
175
165
 
176
166
        btree.note_rename("grandparent", "grandparent2")
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)
 
167
        assert btree.old_path("grandparent") is None
 
168
        assert btree.old_path("grandparent/parent") is None
 
169
        assert btree.old_path("grandparent/parent/file") is None
180
170
 
181
171
        self.assertEqual(btree.id2path("a"), "grandparent2")
182
172
        self.assertEqual(btree.id2path("b"), "grandparent2/parent")
186
176
        self.assertEqual(btree.path2id("grandparent2/parent"), "b")
187
177
        self.assertEqual(btree.path2id("grandparent2/parent/file"), "c")
188
178
 
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)
 
179
        assert btree.path2id("grandparent") is None
 
180
        assert btree.path2id("grandparent/parent") is None
 
181
        assert btree.path2id("grandparent/parent/file") is None
192
182
 
193
183
        btree.note_rename("grandparent/parent", "grandparent2/parent2")
194
184
        self.assertEqual(btree.id2path("a"), "grandparent2")
199
189
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
200
190
        self.assertEqual(btree.path2id("grandparent2/parent2/file"), "c")
201
191
 
202
 
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
203
 
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
 
192
        assert btree.path2id("grandparent2/parent") is None
 
193
        assert btree.path2id("grandparent2/parent/file") is None
204
194
 
205
195
        btree.note_rename("grandparent/parent/file", 
206
196
                          "grandparent2/parent2/file2")
212
202
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
213
203
        self.assertEqual(btree.path2id("grandparent2/parent2/file2"), "c")
214
204
 
215
 
        self.assertTrue(btree.path2id("grandparent2/parent2/file") is None)
 
205
        assert btree.path2id("grandparent2/parent2/file") is None
216
206
 
217
207
    def test_moves(self):
218
208
        """Ensure that file moves have the proper effect on children"""
221
211
                          "grandparent/alt_parent/file")
222
212
        self.assertEqual(btree.id2path("c"), "grandparent/alt_parent/file")
223
213
        self.assertEqual(btree.path2id("grandparent/alt_parent/file"), "c")
224
 
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
 
214
        assert btree.path2id("grandparent/parent/file") is None
225
215
 
226
216
    def unified_diff(self, old, new):
227
217
        out = StringIO()
233
223
        btree = self.make_tree_1()[0]
234
224
        btree.note_rename("grandparent/parent/file", 
235
225
                          "grandparent/alt_parent/file")
236
 
        self.assertTrue(btree.id2path("e") is None)
237
 
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
 
226
        assert btree.id2path("e") is None
 
227
        assert btree.path2id("grandparent/parent/file") is None
238
228
        btree.note_id("e", "grandparent/parent/file")
239
229
        return btree
240
230
 
298
288
        btree = self.make_tree_1()[0]
299
289
        self.assertEqual(btree.get_file("c").read(), "Hello\n")
300
290
        btree.note_deletion("grandparent/parent/file")
301
 
        self.assertTrue(btree.id2path("c") is None)
302
 
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
 
291
        assert btree.id2path("c") is None
 
292
        assert btree.path2id("grandparent/parent/file") is None
303
293
 
304
294
    def sorted_ids(self, tree):
305
295
        ids = list(tree)
323
313
 
324
314
    def test_mismatched_bundle(self):
325
315
        format = bzrdir.BzrDirMetaFormat1()
326
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
316
        format.repository_format = repository.RepositoryFormatKnit2()
327
317
        serializer = BundleSerializerV08('0.8')
328
318
        b = self.make_branch('.', format=format)
329
319
        self.assertRaises(errors.IncompatibleBundleFormat, serializer.write, 
332
322
    def test_matched_bundle(self):
333
323
        """Don't raise IncompatibleBundleFormat for knit2 and bundle0.9"""
334
324
        format = bzrdir.BzrDirMetaFormat1()
335
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
325
        format.repository_format = repository.RepositoryFormatKnit2()
336
326
        serializer = BundleSerializerV09('0.9')
337
327
        b = self.make_branch('.', format=format)
338
328
        serializer.write(b.repository, [], {}, StringIO())
340
330
    def test_mismatched_model(self):
341
331
        """Try copying a bundle from knit2 to knit1"""
342
332
        format = bzrdir.BzrDirMetaFormat1()
343
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
333
        format.repository_format = repository.RepositoryFormatKnit2()
344
334
        source = self.make_branch_and_tree('source', format=format)
345
335
        source.commit('one', rev_id='one-id')
346
336
        source.commit('two', rev_id='two-id')
347
337
        text = StringIO()
348
 
        write_bundle(source.branch.repository, 'two-id', 'null:', text,
 
338
        write_bundle(source.branch.repository, 'two-id', None, text, 
349
339
                     format='0.9')
350
340
        text.seek(0)
351
341
 
352
342
        format = bzrdir.BzrDirMetaFormat1()
353
 
        format.repository_format = knitrepo.RepositoryFormatKnit1()
 
343
        format.repository_format = repository.RepositoryFormatKnit1()
354
344
        target = self.make_branch('target', format=format)
355
345
        self.assertRaises(errors.IncompatibleRevision, install_bundle, 
356
346
                          target.repository, read_bundle(text))
357
347
 
358
348
 
359
 
class BundleTester(object):
 
349
class V08BundleTester(TestCaseWithTransport):
 
350
 
 
351
    format = '0.8'
360
352
 
361
353
    def bzrdir_format(self):
362
354
        format = bzrdir.BzrDirMetaFormat1()
363
 
        format.repository_format = knitrepo.RepositoryFormatKnit1()
 
355
        format.repository_format = repository.RepositoryFormatKnit1()
364
356
        return format
365
357
 
366
358
    def make_branch_and_tree(self, path, format=None):
385
377
        rev = self.b1.repository.get_revision(rev_id)
386
378
        self.assertEqual(bundle_txt.readline().decode('utf-8'),
387
379
                         u'# message:\n')
 
380
 
 
381
        open(',,bundle', 'wb').write(bundle_txt.getvalue())
388
382
        bundle_txt.seek(0)
389
383
        return bundle_txt, rev_ids
390
384
 
461
455
                os.mkdir(checkout_dir)
462
456
        tree = self.make_branch_and_tree(checkout_dir)
463
457
        s = StringIO()
464
 
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
 
458
        ancestors = write_bundle(self.b1.repository, rev_id, None, s,
465
459
                                 format=self.format)
466
460
        s.seek(0)
467
 
        self.assertIsInstance(s.getvalue(), str)
 
461
        assert isinstance(s.getvalue(), str), (
 
462
            "Bundle isn't a bytestring:\n %s..." % repr(s.getvalue())[:40])
468
463
        install_bundle(tree.branch.repository, read_bundle(s))
469
464
        for ancestor in ancestors:
470
465
            old = self.b1.repository.revision_tree(ancestor)
471
466
            new = tree.branch.repository.revision_tree(ancestor)
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):
 
467
 
 
468
            # Check that there aren't any inventory level changes
 
469
            delta = new.changes_from(old)
 
470
            self.assertFalse(delta.has_changed(),
 
471
                             'Revision %s not copied correctly.'
 
472
                             % (ancestor,))
 
473
 
 
474
            # Now check that the file contents are all correct
 
475
            for inventory_id in old:
 
476
                try:
 
477
                    old_file = old.get_file(inventory_id)
 
478
                except NoSuchFile:
 
479
                    continue
 
480
                if old_file is None:
 
481
                    continue
 
482
                self.assertEqual(old_file.read(),
 
483
                                 new.get_file(inventory_id).read())
 
484
        if rev_id is not None:
495
485
            rh = self.b1.revision_history()
496
486
            tree.branch.set_revision_history(rh[:rh.index(rev_id)+1])
497
487
            tree.update()
498
488
            delta = tree.changes_from(self.b1.repository.revision_tree(rev_id))
499
489
            self.assertFalse(delta.has_changed(),
500
 
                             'Working tree has modifications: %s' % delta)
 
490
                             'Working tree has modifications')
501
491
        return tree
502
492
 
503
493
    def valid_apply_bundle(self, base_rev_id, info, checkout_dir=None):
505
495
        sure everything matches the builtin branch.
506
496
        """
507
497
        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):
515
498
        original_parents = to_tree.get_parent_ids()
516
499
        repository = to_tree.branch.repository
517
500
        original_parents = to_tree.get_parent_ids()
565
548
        self.tree1.add('one')
566
549
        self.tree1.commit('add one', rev_id='a@cset-0-1')
567
550
 
568
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
 
551
        bundle = self.get_valid_bundle(None, 'a@cset-0-1')
 
552
        # FIXME: The current write_bundle api no longer supports
 
553
        #        setting a custom summary message
 
554
        #        We should re-introduce the ability, and update
 
555
        #        the tests to make sure it works.
 
556
        # bundle = self.get_valid_bundle(None, 'a@cset-0-1',
 
557
        #         message='With a specialized message')
569
558
 
570
559
        # Make sure we can handle files with spaces, tabs, other
571
560
        # bogus characters
584
573
        tt = TreeTransform(self.tree1)
585
574
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
586
575
        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')
590
576
        self.tree1.add([
591
 
                  'dir'
 
577
                'with space.txt'
 
578
                , 'dir'
592
579
                , 'dir/filein subdir.c'
593
580
                , 'dir/WithCaps.txt'
594
581
                , 'dir/ pre space'
603
590
        bundle = self.get_valid_bundle('a@cset-0-1', 'a@cset-0-2')
604
591
 
605
592
        # Check a rollup bundle 
606
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
 
593
        bundle = self.get_valid_bundle(None, 'a@cset-0-2')
607
594
 
608
595
        # Now delete entries
609
596
        self.tree1.remove(
618
605
        self.tree1.commit('removed', rev_id='a@cset-0-3')
619
606
        
620
607
        bundle = self.get_valid_bundle('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')
 
608
        self.assertRaises(TestamentMismatch, self.get_invalid_bundle, 
 
609
                          'a@cset-0-2', 'a@cset-0-3')
624
610
        # Check a rollup bundle 
625
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
 
611
        bundle = self.get_valid_bundle(None, 'a@cset-0-3')
626
612
 
627
613
        # Now move the directory
628
614
        self.tree1.rename_one('dir', 'sub/dir')
630
616
 
631
617
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
632
618
        # Check a rollup bundle 
633
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
 
619
        bundle = self.get_valid_bundle(None, 'a@cset-0-4')
634
620
 
635
621
        # Modified files
636
622
        open('b1/sub/dir/WithCaps.txt', 'ab').write('\nAdding some text\n')
637
 
        open('b1/sub/dir/ pre space', 'ab').write(
638
 
             '\r\nAdding some\r\nDOS format lines\r\n')
 
623
        open('b1/sub/dir/ pre space', 'ab').write('\r\nAdding some\r\nDOS format lines\r\n')
639
624
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
640
625
        self.tree1.rename_one('sub/dir/ pre space', 
641
626
                              'sub/ start space')
655
640
        self.assertEqualDiff(tree1_inv, tree2_inv)
656
641
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
657
642
        other.commit('rename file', rev_id='a@cset-0-6b')
658
 
        self.tree1.merge_from_branch(other.branch)
 
643
        _merge_helper([other.basedir, -1], [None, None],
 
644
                      this_dir=self.tree1.basedir)
659
645
        self.tree1.commit(u'Merge', rev_id='a@cset-0-7',
660
646
                          verbose=False)
661
647
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
662
648
 
663
649
    def test_symlink_bundle(self):
664
 
        self.requireFeature(SymlinkFeature)
 
650
        if not has_symlinks():
 
651
            raise TestSkipped("No symlink support")
665
652
        self.tree1 = self.make_branch_and_tree('b1')
666
653
        self.b1 = self.tree1.branch
667
654
        tt = TreeTransform(self.tree1)
668
655
        tt.new_symlink('link', tt.root, 'bar/foo', 'link-1')
669
656
        tt.apply()
670
657
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
671
 
        self.get_valid_bundle('null:', 'l@cset-0-1')
 
658
        self.get_valid_bundle(None, 'l@cset-0-1')
672
659
        tt = TreeTransform(self.tree1)
673
660
        trans_id = tt.trans_id_tree_file_id('link-1')
674
661
        tt.adjust_path('link2', tt.root, trans_id)
698
685
        
699
686
        # Add
700
687
        tt.new_file('file', tt.root, '\x00\n\x00\r\x01\n\x02\r\xff', 'binary-1')
701
 
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
702
 
            'binary-2')
 
688
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff', 'binary-2')
703
689
        tt.apply()
704
690
        self.tree1.commit('add binary', rev_id='b@cset-0-1')
705
 
        self.get_valid_bundle('null:', 'b@cset-0-1')
 
691
        self.get_valid_bundle(None, 'b@cset-0-1')
706
692
 
707
693
        # Delete
708
694
        tt = TreeTransform(self.tree1)
732
718
        self.get_valid_bundle('b@cset-0-3', 'b@cset-0-4')
733
719
 
734
720
        # Rollup
735
 
        self.get_valid_bundle('null:', 'b@cset-0-4')
 
721
        self.get_valid_bundle(None, 'b@cset-0-4')
736
722
 
737
723
    def test_last_modified(self):
738
724
        self.tree1 = self.make_branch_and_tree('b1')
756
742
        tt.create_file('file2', trans_id)
757
743
        tt.apply()
758
744
        other.commit('modify text in another tree', rev_id='a@lmod-0-2b')
759
 
        self.tree1.merge_from_branch(other.branch)
 
745
        _merge_helper([other.basedir, -1], [None, None],
 
746
                      this_dir=self.tree1.basedir)
760
747
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-3',
761
748
                          verbose=False)
762
749
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-4')
776
763
        bundle_file = StringIO()
777
764
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
778
765
                               'a@cset-0-1', bundle_file, format=self.format)
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()
 
766
        self.assertNotContainsRe(bundle_file.getvalue(), 'two')
 
767
        self.assertContainsRe(bundle_file.getvalue(), 'one')
 
768
        self.assertContainsRe(bundle_file.getvalue(), 'three')
794
769
 
795
770
    def test_unicode_bundle(self):
796
771
        # Handle international characters
808
783
            u'William Dod\xe9\n').encode('utf-8'))
809
784
        f.close()
810
785
 
811
 
        self.tree1.add([u'with Dod\xe9'], ['withdod-id'])
812
 
        self.tree1.commit(u'i18n commit from William Dod\xe9',
 
786
        self.tree1.add([u'with Dod\xe9'])
 
787
        self.tree1.commit(u'i18n commit from William Dod\xe9', 
813
788
                          rev_id='i18n-1', committer=u'William Dod\xe9')
814
789
 
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
 
 
829
790
        # Add
830
 
        bundle = self.get_valid_bundle('null:', 'i18n-1')
 
791
        bundle = self.get_valid_bundle(None, 'i18n-1')
831
792
 
832
793
        # Modified
833
794
        f = open(u'b1/with Dod\xe9', 'wb')
851
812
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
852
813
 
853
814
        # Rollup
854
 
        bundle = self.get_valid_bundle('null:', 'i18n-4')
 
815
        bundle = self.get_valid_bundle(None, 'i18n-4')
855
816
 
856
817
 
857
818
    def test_whitespace_bundle(self):
869
830
        # Added
870
831
        self.tree1.commit('funky whitespace', rev_id='white-1')
871
832
 
872
 
        bundle = self.get_valid_bundle('null:', 'white-1')
 
833
        bundle = self.get_valid_bundle(None, 'white-1')
873
834
 
874
835
        # Modified
875
836
        open('b1/trailing space ', 'ab').write('add some text\n')
890
851
        bundle = self.get_valid_bundle('white-3', 'white-4')
891
852
        
892
853
        # Now test a complet roll-up
893
 
        bundle = self.get_valid_bundle('null:', 'white-4')
 
854
        bundle = self.get_valid_bundle(None, 'white-4')
894
855
 
895
856
    def test_alt_timezone_bundle(self):
896
857
        self.tree1 = self.make_branch_and_memory_tree('b1')
906
867
        self.tree1.commit('non-hour offset timezone', rev_id='tz-1',
907
868
                          timezone=19800, timestamp=1152544886.0)
908
869
 
909
 
        bundle = self.get_valid_bundle('null:', 'tz-1')
 
870
        bundle = self.get_valid_bundle(None, 'tz-1')
910
871
        
911
872
        rev = bundle.revisions[0]
912
873
        self.assertEqual('Mon 2006-07-10 20:51:26.000000000 +0530', rev.date)
918
879
        self.tree1 = self.make_branch_and_tree('b1')
919
880
        self.b1 = self.tree1.branch
920
881
        self.tree1.commit('message', rev_id='revid1')
921
 
        bundle = self.get_valid_bundle('null:', 'revid1')
922
 
        tree = self.get_bundle_tree(bundle, 'revid1')
 
882
        bundle = self.get_valid_bundle(None, 'revid1')
 
883
        tree = bundle.revision_tree(self.b1.repository, 'revid1')
923
884
        self.assertEqual('revid1', tree.inventory.root.revision)
924
885
 
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
 
 
1247
886
 
1248
887
class V09BundleKnit2Tester(V08BundleTester):
1249
888
 
1251
890
 
1252
891
    def bzrdir_format(self):
1253
892
        format = bzrdir.BzrDirMetaFormat1()
1254
 
        format.repository_format = knitrepo.RepositoryFormatKnit3()
 
893
        format.repository_format = repository.RepositoryFormatKnit2()
1255
894
        return format
1256
895
 
1257
896
 
1261
900
 
1262
901
    def bzrdir_format(self):
1263
902
        format = bzrdir.BzrDirMetaFormat1()
1264
 
        format.repository_format = knitrepo.RepositoryFormatKnit1()
 
903
        format.repository_format = repository.RepositoryFormatKnit1()
1265
904
        return format
1266
905
 
1267
906
 
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):
 
907
class MungedBundleTester(TestCaseWithTransport):
1424
908
 
1425
909
    def build_test_bundle(self):
1426
910
        wt = self.make_branch_and_tree('b1')
1435
919
 
1436
920
        bundle_txt = StringIO()
1437
921
        rev_ids = write_bundle(wt.branch.repository, 'a@cset-0-2',
1438
 
                               'a@cset-0-1', bundle_txt, self.format)
1439
 
        self.assertEqual(set(['a@cset-0-2']), set(rev_ids))
 
922
                               'a@cset-0-1', bundle_txt)
 
923
        self.assertEqual(['a@cset-0-2'], rev_ids)
1440
924
        bundle_txt.seek(0, 0)
1441
925
        return bundle_txt
1442
926
 
1471
955
        bundle = read_bundle(bundle_txt)
1472
956
        self.check_valid(bundle)
1473
957
 
1474
 
 
1475
 
class MungedBundleTesterV09(TestCaseWithTransport, MungedBundleTester):
1476
 
 
1477
 
    format = '0.9'
1478
 
 
1479
958
    def test_missing_trailing_whitespace(self):
1480
959
        bundle_txt = self.build_test_bundle()
1481
960
 
1509
988
        bundle = read_bundle(bundle_txt)
1510
989
        self.check_valid(bundle)
1511
990
 
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')