← 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: Robert Collins
  • Author(s): Vincent Ladeuil
  • Date: 2009-04-07 07:20:17 UTC
  • mto: This revision was merged to the branch mainline in revision 4262.
  • Revision ID: robertc@robertcollins.net-20090407072017-rxvtpahno3yfb52e
Add InterCHKRevisionTree

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bundle.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2004, 2005, 2006, 2007 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
22
22
 
23
23
from bzrlib import (
24
24
    bzrdir,
25
 
    diff,
26
25
    errors,
27
26
    inventory,
28
 
    merge,
29
27
    osutils,
 
28
    repository,
30
29
    revision as _mod_revision,
31
 
    symbol_versioning,
32
 
    tests,
33
30
    treebuilder,
34
31
    )
35
32
from bzrlib.bundle import read_mergeable_from_url
36
33
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
37
34
from bzrlib.bundle.bundle_data import BundleTree
 
35
from bzrlib.bzrdir import BzrDir
38
36
from bzrlib.directory_service import directories
39
37
from bzrlib.bundle.serializer import write_bundle, read_bundle, v09, v4
40
38
from bzrlib.bundle.serializer.v08 import BundleSerializerV08
41
39
from bzrlib.bundle.serializer.v09 import BundleSerializerV09
42
40
from bzrlib.bundle.serializer.v4 import BundleSerializerV4
 
41
from bzrlib.branch import Branch
 
42
from bzrlib.diff import internal_diff
 
43
from bzrlib.merge import Merge3Merger
43
44
from bzrlib.repofmt import knitrepo
 
45
from bzrlib.osutils import sha_file, sha_string
44
46
from bzrlib.tests import (
 
47
    SymlinkFeature,
 
48
    TestCase,
 
49
    TestCaseInTempDir,
 
50
    TestCaseWithTransport,
 
51
    TestSkipped,
45
52
    test_read_bundle,
46
53
    test_commit,
47
54
    )
48
55
from bzrlib.transform import TreeTransform
49
56
 
50
57
 
51
 
def get_text(vf, key):
52
 
    """Get the fulltext for a given revision id that is present in the vf"""
53
 
    stream = vf.get_record_stream([key], 'unordered', True)
54
 
    record = stream.next()
55
 
    return record.get_bytes_as('fulltext')
56
 
 
57
 
 
58
 
def get_inventory_text(repo, revision_id):
59
 
    """Get the fulltext for the inventory at revision id"""
60
 
    repo.lock_read()
61
 
    try:
62
 
        return get_text(repo.inventories, (revision_id,))
63
 
    finally:
64
 
        repo.unlock()
65
 
 
66
 
 
67
58
class MockTree(object):
68
 
 
69
59
    def __init__(self):
70
60
        from bzrlib.inventory import InventoryDirectory, ROOT_ID
71
61
        object.__init__(self)
76
66
 
77
67
    inventory = property(lambda x:x)
78
68
 
79
 
    def all_file_ids(self):
80
 
        return set(self.paths.keys())
 
69
    def __iter__(self):
 
70
        return self.paths.iterkeys()
81
71
 
82
72
    def __getitem__(self, file_id):
83
73
        if file_id == self.root.file_id:
113
103
            ie = InventoryDirectory(file_id, name, parent_id)
114
104
        elif kind == 'file':
115
105
            ie = InventoryFile(file_id, name, parent_id)
116
 
            ie.text_sha1 = text_sha_1
117
 
            ie.text_size = text_size
118
106
        elif kind == 'symlink':
119
107
            ie = InventoryLink(file_id, name, parent_id)
120
108
        else:
121
109
            raise errors.BzrError('unknown kind %r' % kind)
 
110
        ie.text_sha1 = text_sha_1
 
111
        ie.text_size = text_size
122
112
        return ie
123
113
 
124
114
    def add_dir(self, file_id, path):
144
134
        result.seek(0,0)
145
135
        return result
146
136
 
147
 
    def get_file_revision(self, file_id):
148
 
        return self.inventory[file_id].revision
149
 
 
150
137
    def contents_stats(self, file_id):
151
138
        if file_id not in self.contents:
152
139
            return None, None
153
 
        text_sha1 = osutils.sha_file(self.get_file(file_id))
 
140
        text_sha1 = sha_file(self.get_file(file_id))
154
141
        return text_sha1, len(self.contents[file_id])
155
142
 
156
143
 
157
 
class BTreeTester(tests.TestCase):
 
144
class BTreeTester(TestCase):
158
145
    """A simple unittest tester for the BundleTree class."""
159
146
 
160
147
    def make_tree_1(self):
238
225
 
239
226
    def unified_diff(self, old, new):
240
227
        out = StringIO()
241
 
        diff.internal_diff("old", old, "new", new, out)
 
228
        internal_diff("old", old, "new", new, out)
242
229
        out.seek(0,0)
243
230
        return out.read()
244
231
 
332
319
            [inventory.ROOT_ID, 'a', 'b', 'd', 'e'])
333
320
 
334
321
 
335
 
class BundleTester1(tests.TestCaseWithTransport):
 
322
class BundleTester1(TestCaseWithTransport):
336
323
 
337
324
    def test_mismatched_bundle(self):
338
325
        format = bzrdir.BzrDirMetaFormat1()
379
366
    def make_branch_and_tree(self, path, format=None):
380
367
        if format is None:
381
368
            format = self.bzrdir_format()
382
 
        return tests.TestCaseWithTransport.make_branch_and_tree(
383
 
            self, path, format)
 
369
        return TestCaseWithTransport.make_branch_and_tree(self, path, format)
384
370
 
385
371
    def make_branch(self, path, format=None):
386
372
        if format is None:
387
373
            format = self.bzrdir_format()
388
 
        return tests.TestCaseWithTransport.make_branch(self, path, format)
 
374
        return TestCaseWithTransport.make_branch(self, path, format)
389
375
 
390
376
    def create_bundle_text(self, base_rev_id, rev_id):
391
377
        bundle_txt = StringIO()
494
480
                                 % (ancestor,))
495
481
 
496
482
                # Now check that the file contents are all correct
497
 
                for inventory_id in old.all_file_ids():
 
483
                for inventory_id in old:
498
484
                    try:
499
485
                        old_file = old.get_file(inventory_id)
500
486
                    except errors.NoSuchFile:
508
494
                old.unlock()
509
495
        if not _mod_revision.is_null(rev_id):
510
496
            rh = self.b1.revision_history()
511
 
            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),
512
 
                tree.branch.set_revision_history, rh[:rh.index(rev_id)+1])
 
497
            tree.branch.set_revision_history(rh[:rh.index(rev_id)+1])
513
498
            tree.update()
514
499
            delta = tree.changes_from(self.b1.repository.revision_tree(rev_id))
515
500
            self.assertFalse(delta.has_changed(),
536
521
            self.assert_(not repository.has_revision(rev.revision_id),
537
522
                'Revision {%s} present before applying bundle'
538
523
                % rev.revision_id)
539
 
        merge_bundle(info, to_tree, True, merge.Merge3Merger, False, False)
 
524
        merge_bundle(info, to_tree, True, Merge3Merger, False, False)
540
525
 
541
526
        for rev in info.real_revisions:
542
527
            self.assert_(repository.has_revision(rev.revision_id),
577
562
        self.tree1 = self.make_branch_and_tree('b1')
578
563
        self.b1 = self.tree1.branch
579
564
 
580
 
        self.build_tree_contents([('b1/one', 'one\n')])
581
 
        self.tree1.add('one', 'one-id')
582
 
        self.tree1.set_root_id('root-id')
 
565
        open('b1/one', 'wb').write('one\n')
 
566
        self.tree1.add('one')
583
567
        self.tree1.commit('add one', rev_id='a@cset-0-1')
584
568
 
585
569
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
596
580
                , 'b1/sub/sub/'
597
581
                , 'b1/sub/sub/nonempty.txt'
598
582
                ])
599
 
        self.build_tree_contents([('b1/sub/sub/emptyfile.txt', ''),
600
 
                                  ('b1/dir/nolastnewline.txt', 'bloop')])
 
583
        open('b1/sub/sub/emptyfile.txt', 'wb').close()
 
584
        open('b1/dir/nolastnewline.txt', 'wb').write('bloop')
601
585
        tt = TreeTransform(self.tree1)
602
586
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
603
587
        tt.apply()
636
620
 
637
621
        bundle = self.get_valid_bundle('a@cset-0-2', 'a@cset-0-3')
638
622
        self.assertRaises((errors.TestamentMismatch,
639
 
            errors.VersionedFileInvalidChecksum,
640
 
            errors.BadBundle), self.get_invalid_bundle,
 
623
            errors.VersionedFileInvalidChecksum), self.get_invalid_bundle,
641
624
            'a@cset-0-2', 'a@cset-0-3')
642
625
        # Check a rollup bundle
643
626
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
667
650
                          verbose=False)
668
651
        bundle = self.get_valid_bundle('a@cset-0-5', 'a@cset-0-6')
669
652
        other = self.get_checkout('a@cset-0-5')
670
 
        tree1_inv = get_inventory_text(self.tree1.branch.repository,
671
 
                                       'a@cset-0-5')
672
 
        tree2_inv = get_inventory_text(other.branch.repository,
673
 
                                       'a@cset-0-5')
 
653
        tree1_inv = self.tree1.branch.repository.get_inventory_xml(
 
654
            'a@cset-0-5')
 
655
        tree2_inv = other.branch.repository.get_inventory_xml('a@cset-0-5')
674
656
        self.assertEqualDiff(tree1_inv, tree2_inv)
675
657
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
676
658
        other.commit('rename file', rev_id='a@cset-0-6b')
679
661
                          verbose=False)
680
662
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
681
663
 
682
 
    def _test_symlink_bundle(self, link_name, link_target, new_link_target):
683
 
        link_id = 'link-1'
684
 
 
685
 
        self.requireFeature(tests.SymlinkFeature)
 
664
    def test_symlink_bundle(self):
 
665
        self.requireFeature(SymlinkFeature)
686
666
        self.tree1 = self.make_branch_and_tree('b1')
687
667
        self.b1 = self.tree1.branch
688
 
 
689
668
        tt = TreeTransform(self.tree1)
690
 
        tt.new_symlink(link_name, tt.root, link_target, link_id)
 
669
        tt.new_symlink('link', tt.root, 'bar/foo', 'link-1')
691
670
        tt.apply()
692
671
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
693
 
        bundle = self.get_valid_bundle('null:', 'l@cset-0-1')
694
 
        if getattr(bundle ,'revision_tree', None) is not None:
695
 
            # Not all bundle formats supports revision_tree
696
 
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-1')
697
 
            self.assertEqual(link_target, bund_tree.get_symlink_target(link_id))
698
 
 
 
672
        self.get_valid_bundle('null:', 'l@cset-0-1')
699
673
        tt = TreeTransform(self.tree1)
700
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
674
        trans_id = tt.trans_id_tree_file_id('link-1')
701
675
        tt.adjust_path('link2', tt.root, trans_id)
702
676
        tt.delete_contents(trans_id)
703
 
        tt.create_symlink(new_link_target, trans_id)
 
677
        tt.create_symlink('mars', trans_id)
704
678
        tt.apply()
705
679
        self.tree1.commit('rename and change symlink', rev_id='l@cset-0-2')
706
 
        bundle = self.get_valid_bundle('l@cset-0-1', 'l@cset-0-2')
707
 
        if getattr(bundle ,'revision_tree', None) is not None:
708
 
            # Not all bundle formats supports revision_tree
709
 
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-2')
710
 
            self.assertEqual(new_link_target,
711
 
                             bund_tree.get_symlink_target(link_id))
712
 
 
 
680
        self.get_valid_bundle('l@cset-0-1', 'l@cset-0-2')
713
681
        tt = TreeTransform(self.tree1)
714
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
682
        trans_id = tt.trans_id_tree_file_id('link-1')
715
683
        tt.delete_contents(trans_id)
716
684
        tt.create_symlink('jupiter', trans_id)
717
685
        tt.apply()
718
686
        self.tree1.commit('just change symlink target', rev_id='l@cset-0-3')
719
 
        bundle = self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
720
 
 
 
687
        self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
721
688
        tt = TreeTransform(self.tree1)
722
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
689
        trans_id = tt.trans_id_tree_file_id('link-1')
723
690
        tt.delete_contents(trans_id)
724
691
        tt.apply()
725
692
        self.tree1.commit('Delete symlink', rev_id='l@cset-0-4')
726
 
        bundle = self.get_valid_bundle('l@cset-0-3', 'l@cset-0-4')
727
 
 
728
 
    def test_symlink_bundle(self):
729
 
        self._test_symlink_bundle('link', 'bar/foo', 'mars')
730
 
 
731
 
    def test_unicode_symlink_bundle(self):
732
 
        self.requireFeature(tests.UnicodeFilenameFeature)
733
 
        self._test_symlink_bundle(u'\N{Euro Sign}link',
734
 
                                  u'bar/\N{Euro Sign}foo',
735
 
                                  u'mars\N{Euro Sign}')
 
693
        self.get_valid_bundle('l@cset-0-3', 'l@cset-0-4')
736
694
 
737
695
    def test_binary_bundle(self):
738
696
        self.tree1 = self.make_branch_and_tree('b1')
836
794
        return bundle_file.getvalue()
837
795
 
838
796
    def test_unicode_bundle(self):
839
 
        self.requireFeature(tests.UnicodeFilenameFeature)
840
797
        # Handle international characters
841
798
        os.mkdir('b1')
842
 
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
 
799
        try:
 
800
            f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
 
801
        except UnicodeEncodeError:
 
802
            raise TestSkipped("Filesystem doesn't support unicode")
843
803
 
844
804
        self.tree1 = self.make_branch_and_tree('b1')
845
805
        self.b1 = self.tree1.branch
883
843
 
884
844
    def test_whitespace_bundle(self):
885
845
        if sys.platform in ('win32', 'cygwin'):
886
 
            raise tests.TestSkipped('Windows doesn\'t support filenames'
887
 
                                    ' with tabs or trailing spaces')
 
846
            raise TestSkipped('Windows doesn\'t support filenames'
 
847
                              ' with tabs or trailing spaces')
888
848
        self.tree1 = self.make_branch_and_tree('b1')
889
849
        self.b1 = self.tree1.branch
890
850
 
1042
1002
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
1043
1003
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1044
1004
        bundle.install_revisions(repo)
1045
 
        inv_text = repo._get_inventory_xml('rev2')
 
1005
        inv_text = repo.get_inventory_xml('rev2')
1046
1006
        self.assertNotContainsRe(inv_text, 'format="5"')
1047
1007
        self.assertContainsRe(inv_text, 'format="7"')
1048
1008
 
1068
1028
 
1069
1029
    def test_inv_hash_across_serializers(self):
1070
1030
        repo = self.make_repo_with_installed_revisions()
1071
 
        recorded_inv_sha1 = repo.get_revision('rev2').inventory_sha1
1072
 
        xml = repo._get_inventory_xml('rev2')
1073
 
        self.assertEqual(osutils.sha_string(xml), recorded_inv_sha1)
 
1031
        recorded_inv_sha1 = repo.get_inventory_sha1('rev2')
 
1032
        xml = repo.get_inventory_xml('rev2')
 
1033
        self.assertEqual(sha_string(xml), recorded_inv_sha1)
1074
1034
 
1075
1035
    def test_across_models_incompatible(self):
1076
1036
        tree = self.make_simple_tree('dirstate-with-subtree')
1079
1039
        try:
1080
1040
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
1081
1041
        except errors.IncompatibleBundleFormat:
1082
 
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
 
1042
            raise TestSkipped("Format 0.8 doesn't work with knit3")
1083
1043
        repo = self.make_repository('repo', format='knit')
1084
1044
        bundle.install_revisions(repo)
1085
1045
 
1106
1066
        try:
1107
1067
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
1108
1068
        except errors.IncompatibleBundleFormat:
1109
 
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
 
1069
            raise TestSkipped("Format 0.8 doesn't work with knit3")
1110
1070
        if isinstance(bundle, v09.BundleInfo09):
1111
 
            raise tests.TestSkipped("Format 0.9 doesn't work with subtrees")
 
1071
            raise TestSkipped("Format 0.9 doesn't work with subtrees")
1112
1072
        repo = self.make_repository('repo', format='knit')
1113
1073
        self.assertRaises(errors.IncompatibleRevision,
1114
1074
                          bundle.install_revisions, repo)
1121
1081
        try:
1122
1082
            self.tree1.commit('Revision/id/with/slashes', rev_id='rev/id')
1123
1083
        except ValueError:
1124
 
            raise tests.TestSkipped(
1125
 
                "Repository doesn't support revision ids with slashes")
 
1084
            raise TestSkipped("Repository doesn't support revision ids with"
 
1085
                              " slashes")
1126
1086
        bundle = self.get_valid_bundle('null:', 'rev/id')
1127
1087
 
1128
1088
    def test_skip_file(self):
1144
1104
        self.tree1.commit('rev3', rev_id='rev3')
1145
1105
        bundle = self.get_valid_bundle('reva', 'rev3')
1146
1106
        if getattr(bundle, 'get_bundle_reader', None) is None:
1147
 
            raise tests.TestSkipped('Bundle format cannot provide reader')
 
1107
            raise TestSkipped('Bundle format cannot provide reader')
1148
1108
        # be sure that file1 comes before file2
1149
1109
        for b, m, k, r, f in bundle.get_bundle_reader().iter_records():
1150
1110
            if f == 'file3-id':
1153
1113
        bundle.install_revisions(target.branch.repository)
1154
1114
 
1155
1115
 
1156
 
class V08BundleTester(BundleTester, tests.TestCaseWithTransport):
 
1116
class V08BundleTester(BundleTester, TestCaseWithTransport):
1157
1117
 
1158
1118
    format = '0.8'
1159
1119
 
1292
1252
        return format
1293
1253
 
1294
1254
 
1295
 
class V4BundleTester(BundleTester, tests.TestCaseWithTransport):
 
1255
class V4BundleTester(BundleTester, TestCaseWithTransport):
1296
1256
 
1297
1257
    format = '4'
1298
1258
 
1339
1299
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
1340
1300
        new_text = new_text.replace('<file file_id="exe-1"',
1341
1301
                                    '<file executable="y" file_id="exe-1"')
1342
 
        new_text = new_text.replace('B260', 'B275')
 
1302
        new_text = new_text.replace('B222', 'B237')
1343
1303
        bundle_txt = StringIO()
1344
1304
        bundle_txt.write(serializer._get_bundle_header('4'))
1345
1305
        bundle_txt.write('\n')
1415
1375
        branch = tree_a.branch
1416
1376
        repo_a = branch.repository
1417
1377
        tree_a.commit("base", allow_pointless=True, rev_id='A')
1418
 
        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
 
1378
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
1419
1379
        try:
1420
1380
            from bzrlib.testament import Testament
1421
1381
            # monkey patch gpg signing mechanism
1445
1405
        install_bundle(repo_b, serializer.read(s))
1446
1406
 
1447
1407
 
1448
 
class V4_2aBundleTester(V4BundleTester):
 
1408
class V4WeaveBundleTester(V4BundleTester):
1449
1409
 
1450
1410
    def bzrdir_format(self):
1451
 
        return '2a'
1452
 
 
1453
 
    def get_invalid_bundle(self, base_rev_id, rev_id):
1454
 
        """Create a bundle from base_rev_id -> rev_id in built-in branch.
1455
 
        Munge the text so that it's invalid.
1456
 
 
1457
 
        :return: The in-memory bundle
1458
 
        """
1459
 
        from bzrlib.bundle import serializer
1460
 
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1461
 
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
1462
 
        # We are going to be replacing some text to set the executable bit on a
1463
 
        # file. Make sure the text replacement actually works correctly.
1464
 
        self.assertContainsRe(new_text, '(?m)B244\n\ni 1\n<inventory')
1465
 
        new_text = new_text.replace('<file file_id="exe-1"',
1466
 
                                    '<file executable="y" file_id="exe-1"')
1467
 
        new_text = new_text.replace('B244', 'B259')
1468
 
        bundle_txt = StringIO()
1469
 
        bundle_txt.write(serializer._get_bundle_header('4'))
1470
 
        bundle_txt.write('\n')
1471
 
        bundle_txt.write(new_text.encode('bz2'))
1472
 
        bundle_txt.seek(0)
1473
 
        bundle = read_bundle(bundle_txt)
1474
 
        self.valid_apply_bundle(base_rev_id, bundle)
1475
 
        return bundle
1476
 
 
1477
 
    def make_merged_branch(self):
1478
 
        builder = self.make_branch_builder('source')
1479
 
        builder.start_series()
1480
 
        builder.build_snapshot('a@cset-0-1', None, [
1481
 
            ('add', ('', 'root-id', 'directory', None)),
1482
 
            ('add', ('file', 'file-id', 'file', 'original content\n')),
1483
 
            ])
1484
 
        builder.build_snapshot('a@cset-0-2a', ['a@cset-0-1'], [
1485
 
            ('modify', ('file-id', 'new-content\n')),
1486
 
            ])
1487
 
        builder.build_snapshot('a@cset-0-2b', ['a@cset-0-1'], [
1488
 
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
1489
 
            ])
1490
 
        builder.build_snapshot('a@cset-0-3', ['a@cset-0-2a', 'a@cset-0-2b'], [
1491
 
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
1492
 
            ])
1493
 
        builder.finish_series()
1494
 
        self.b1 = builder.get_branch()
1495
 
        self.b1.lock_read()
1496
 
        self.addCleanup(self.b1.unlock)
1497
 
 
1498
 
    def make_bundle_just_inventories(self, base_revision_id,
1499
 
                                     target_revision_id,
1500
 
                                     revision_ids):
1501
 
        sio = StringIO()
1502
 
        writer = v4.BundleWriteOperation(base_revision_id, target_revision_id,
1503
 
                                         self.b1.repository, sio)
1504
 
        writer.bundle.begin()
1505
 
        writer._add_inventory_mpdiffs_from_serializer(revision_ids)
1506
 
        writer.bundle.end()
1507
 
        sio.seek(0)
1508
 
        return sio
1509
 
 
1510
 
    def test_single_inventory_multiple_parents_as_xml(self):
1511
 
        self.make_merged_branch()
1512
 
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
1513
 
                                                ['a@cset-0-3'])
1514
 
        reader = v4.BundleReader(sio, stream_input=False)
1515
 
        records = list(reader.iter_records())
1516
 
        self.assertEqual(1, len(records))
1517
 
        (bytes, metadata, repo_kind, revision_id,
1518
 
         file_id) = records[0]
1519
 
        self.assertIs(None, file_id)
1520
 
        self.assertEqual('a@cset-0-3', revision_id)
1521
 
        self.assertEqual('inventory', repo_kind)
1522
 
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
1523
 
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
1524
 
                          'storage_kind': 'mpdiff',
1525
 
                         }, metadata)
1526
 
        # We should have an mpdiff that takes some lines from both parents.
1527
 
        self.assertEqualDiff(
1528
 
            'i 1\n'
1529
 
            '<inventory format="10" revision_id="a@cset-0-3">\n'
1530
 
            '\n'
1531
 
            'c 0 1 1 2\n'
1532
 
            'c 1 3 3 2\n', bytes)
1533
 
 
1534
 
    def test_single_inv_no_parents_as_xml(self):
1535
 
        self.make_merged_branch()
1536
 
        sio = self.make_bundle_just_inventories('null:', 'a@cset-0-1',
1537
 
                                                ['a@cset-0-1'])
1538
 
        reader = v4.BundleReader(sio, stream_input=False)
1539
 
        records = list(reader.iter_records())
1540
 
        self.assertEqual(1, len(records))
1541
 
        (bytes, metadata, repo_kind, revision_id,
1542
 
         file_id) = records[0]
1543
 
        self.assertIs(None, file_id)
1544
 
        self.assertEqual('a@cset-0-1', revision_id)
1545
 
        self.assertEqual('inventory', repo_kind)
1546
 
        self.assertEqual({'parents': [],
1547
 
                          'sha1': 'a13f42b142d544aac9b085c42595d304150e31a2',
1548
 
                          'storage_kind': 'mpdiff',
1549
 
                         }, metadata)
1550
 
        # We should have an mpdiff that takes some lines from both parents.
1551
 
        self.assertEqualDiff(
1552
 
            'i 4\n'
1553
 
            '<inventory format="10" revision_id="a@cset-0-1">\n'
1554
 
            '<directory file_id="root-id" name=""'
1555
 
                ' revision="a@cset-0-1" />\n'
1556
 
            '<file file_id="file-id" name="file" parent_id="root-id"'
1557
 
                ' revision="a@cset-0-1"'
1558
 
                ' text_sha1="09c2f8647e14e49e922b955c194102070597c2d1"'
1559
 
                ' text_size="17" />\n'
1560
 
            '</inventory>\n'
1561
 
            '\n', bytes)
1562
 
 
1563
 
    def test_multiple_inventories_as_xml(self):
1564
 
        self.make_merged_branch()
1565
 
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
1566
 
            ['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'])
1567
 
        reader = v4.BundleReader(sio, stream_input=False)
1568
 
        records = list(reader.iter_records())
1569
 
        self.assertEqual(3, len(records))
1570
 
        revision_ids = [rev_id for b, m, k, rev_id, f in records]
1571
 
        self.assertEqual(['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'],
1572
 
                         revision_ids)
1573
 
        metadata_2a = records[0][1]
1574
 
        self.assertEqual({'parents': ['a@cset-0-1'],
1575
 
                          'sha1': '1e105886d62d510763e22885eec733b66f5f09bf',
1576
 
                          'storage_kind': 'mpdiff',
1577
 
                         }, metadata_2a)
1578
 
        metadata_2b = records[1][1]
1579
 
        self.assertEqual({'parents': ['a@cset-0-1'],
1580
 
                          'sha1': 'f03f12574bdb5ed2204c28636c98a8547544ccd8',
1581
 
                          'storage_kind': 'mpdiff',
1582
 
                         }, metadata_2b)
1583
 
        metadata_3 = records[2][1]
1584
 
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
1585
 
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
1586
 
                          'storage_kind': 'mpdiff',
1587
 
                         }, metadata_3)
1588
 
        bytes_2a = records[0][0]
1589
 
        self.assertEqualDiff(
1590
 
            'i 1\n'
1591
 
            '<inventory format="10" revision_id="a@cset-0-2a">\n'
1592
 
            '\n'
1593
 
            'c 0 1 1 1\n'
1594
 
            'i 1\n'
1595
 
            '<file file_id="file-id" name="file" parent_id="root-id"'
1596
 
                ' revision="a@cset-0-2a"'
1597
 
                ' text_sha1="50f545ff40e57b6924b1f3174b267ffc4576e9a9"'
1598
 
                ' text_size="12" />\n'
1599
 
            '\n'
1600
 
            'c 0 3 3 1\n', bytes_2a)
1601
 
        bytes_2b = records[1][0]
1602
 
        self.assertEqualDiff(
1603
 
            'i 1\n'
1604
 
            '<inventory format="10" revision_id="a@cset-0-2b">\n'
1605
 
            '\n'
1606
 
            'c 0 1 1 2\n'
1607
 
            'i 1\n'
1608
 
            '<file file_id="file2-id" name="other-file" parent_id="root-id"'
1609
 
                ' revision="a@cset-0-2b"'
1610
 
                ' text_sha1="b46c0c8ea1e5ef8e46fc8894bfd4752a88ec939e"'
1611
 
                ' text_size="14" />\n'
1612
 
            '\n'
1613
 
            'c 0 3 4 1\n', bytes_2b)
1614
 
        bytes_3 = records[2][0]
1615
 
        self.assertEqualDiff(
1616
 
            'i 1\n'
1617
 
            '<inventory format="10" revision_id="a@cset-0-3">\n'
1618
 
            '\n'
1619
 
            'c 0 1 1 2\n'
1620
 
            'c 1 3 3 2\n', bytes_3)
1621
 
 
1622
 
    def test_creating_bundle_preserves_chk_pages(self):
1623
 
        self.make_merged_branch()
1624
 
        target = self.b1.bzrdir.sprout('target',
1625
 
                                       revision_id='a@cset-0-2a').open_branch()
1626
 
        bundle_txt, rev_ids = self.create_bundle_text('a@cset-0-2a',
1627
 
                                                      'a@cset-0-3')
1628
 
        self.assertEqual(['a@cset-0-2b', 'a@cset-0-3'], rev_ids)
1629
 
        bundle = read_bundle(bundle_txt)
1630
 
        target.lock_write()
1631
 
        self.addCleanup(target.unlock)
1632
 
        install_bundle(target.repository, bundle)
1633
 
        inv1 = self.b1.repository.inventories.get_record_stream([
1634
 
            ('a@cset-0-3',)], 'unordered',
1635
 
            True).next().get_bytes_as('fulltext')
1636
 
        inv2 = target.repository.inventories.get_record_stream([
1637
 
            ('a@cset-0-3',)], 'unordered',
1638
 
            True).next().get_bytes_as('fulltext')
1639
 
        self.assertEqualDiff(inv1, inv2)
 
1411
        return 'metaweave'
1640
1412
 
1641
1413
 
1642
1414
class MungedBundleTester(object):
1691
1463
        self.check_valid(bundle)
1692
1464
 
1693
1465
 
1694
 
class MungedBundleTesterV09(tests.TestCaseWithTransport, MungedBundleTester):
 
1466
class MungedBundleTesterV09(TestCaseWithTransport, MungedBundleTester):
1695
1467
 
1696
1468
    format = '0.9'
1697
1469
 
1729
1501
        self.check_valid(bundle)
1730
1502
 
1731
1503
 
1732
 
class MungedBundleTesterV4(tests.TestCaseWithTransport, MungedBundleTester):
 
1504
class MungedBundleTesterV4(TestCaseWithTransport, MungedBundleTester):
1733
1505
 
1734
1506
    format = '4'
1735
1507
 
1736
1508
 
1737
 
class TestBundleWriterReader(tests.TestCase):
 
1509
class TestBundleWriterReader(TestCase):
1738
1510
 
1739
1511
    def test_roundtrip_record(self):
1740
1512
        fileobj = StringIO()
1805
1577
        self.assertRaises(errors.BadBundle, record_iter.next)
1806
1578
 
1807
1579
 
1808
 
class TestReadMergeableFromUrl(tests.TestCaseWithTransport):
 
1580
class TestReadMergeableFromUrl(TestCaseWithTransport):
1809
1581
 
1810
1582
    def test_read_mergeable_skips_local(self):
1811
1583
        """A local bundle named like the URL should not be read.
1817
1589
            def look_up(self, name, url):
1818
1590
                return 'source'
1819
1591
        directories.register('foo:', FooService, 'Testing directory service')
1820
 
        self.addCleanup(directories.remove, 'foo:')
 
1592
        self.addCleanup(lambda: directories.remove('foo:'))
1821
1593
        self.build_tree_contents([('./foo:bar', out.getvalue())])
1822
1594
        self.assertRaises(errors.NotABundle, read_mergeable_from_url,
1823
1595
                          'foo:bar')
1824
1596
 
1825
 
    def test_infinite_redirects_are_not_a_bundle(self):
1826
 
        """If a URL causes TooManyRedirections then NotABundle is raised.
1827
 
        """
1828
 
        from bzrlib.tests.blackbox.test_push import RedirectingMemoryServer
1829
 
        server = RedirectingMemoryServer()
1830
 
        self.start_server(server)
1831
 
        url = server.get_url() + 'infinite-loop'
1832
 
        self.assertRaises(errors.NotABundle, read_mergeable_from_url, url)
1833
 
 
1834
1597
    def test_smart_server_connection_reset(self):
1835
1598
        """If a smart server connection fails during the attempt to read a
1836
1599
        bundle, then the ConnectionReset error should be propagated.
1837
1600
        """
1838
1601
        # Instantiate a server that will provoke a ConnectionReset
1839
1602
        sock_server = _DisconnectingTCPServer()
1840
 
        self.start_server(sock_server)
 
1603
        sock_server.setUp()
 
1604
        self.addCleanup(sock_server.tearDown)
1841
1605
        # We don't really care what the url is since the server will close the
1842
1606
        # connection without interpreting it
1843
1607
        url = sock_server.get_url()
1847
1611
class _DisconnectingTCPServer(object):
1848
1612
    """A TCP server that immediately closes any connection made to it."""
1849
1613
 
1850
 
    def start_server(self):
 
1614
    def setUp(self):
1851
1615
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1852
1616
        self.sock.bind(('127.0.0.1', 0))
1853
1617
        self.sock.listen(1)
1865
1629
    def get_url(self):
1866
1630
        return 'bzr://127.0.0.1:%d/' % (self.port,)
1867
1631
 
1868
 
    def stop_server(self):
 
1632
    def tearDown(self):
1869
1633
        try:
1870
1634
            # make sure the thread dies by connecting to the listening socket,
1871
1635
            # just in case the test failed to do so.
1876
1640
            pass
1877
1641
        self.sock.close()
1878
1642
        self.thread.join()
 
1643