/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_bundle.py

  • Committer: Jelmer Vernooij
  • Date: 2018-05-09 23:53:11 UTC
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180509235311-k1zk8mwcb09b8vm0
Update TODO.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_bundle.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2013, 2016 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from cStringIO import StringIO
18
17
import os
19
 
import socket
 
18
try:
 
19
    import socketserver
 
20
except ImportError:
 
21
    import SocketServer as socketserver
20
22
import sys
21
 
import threading
22
23
 
23
 
from bzrlib import (
24
 
    bzrdir,
 
24
from .. import (
25
25
    diff,
26
26
    errors,
27
 
    inventory,
28
27
    merge,
29
28
    osutils,
30
 
    repository,
31
29
    revision as _mod_revision,
32
30
    tests,
33
31
    treebuilder,
34
32
    )
35
 
from bzrlib.bundle import read_mergeable_from_url
36
 
from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle
37
 
from bzrlib.bundle.bundle_data import BundleTree
38
 
from bzrlib.bzrdir import BzrDir
39
 
from bzrlib.directory_service import directories
40
 
from bzrlib.bundle.serializer import write_bundle, read_bundle, v09, v4
41
 
from bzrlib.bundle.serializer.v08 import BundleSerializerV08
42
 
from bzrlib.bundle.serializer.v09 import BundleSerializerV09
43
 
from bzrlib.bundle.serializer.v4 import BundleSerializerV4
44
 
from bzrlib.branch import Branch
45
 
from bzrlib.repofmt import knitrepo
46
 
from bzrlib.tests import (
 
33
from ..bzr import (
 
34
    bzrdir,
 
35
    inventory,
 
36
    )
 
37
from ..bundle import read_mergeable_from_url
 
38
from ..bundle.apply_bundle import install_bundle, merge_bundle
 
39
from ..bundle.bundle_data import BundleTree
 
40
from ..directory_service import directories
 
41
from ..bundle.serializer import write_bundle, read_bundle, v09, v4
 
42
from ..bundle.serializer.v08 import BundleSerializerV08
 
43
from ..bundle.serializer.v09 import BundleSerializerV09
 
44
from ..bundle.serializer.v4 import BundleSerializerV4
 
45
from ..bzr import knitrepo
 
46
from ..sixish import (
 
47
    BytesIO,
 
48
    )
 
49
from . import (
 
50
    features,
 
51
    test_commit,
47
52
    test_read_bundle,
48
 
    test_commit,
 
53
    test_server,
49
54
    )
50
 
from bzrlib.transform import TreeTransform
 
55
from ..transform import TreeTransform
51
56
 
52
57
 
53
58
def get_text(vf, key):
54
59
    """Get the fulltext for a given revision id that is present in the vf"""
55
60
    stream = vf.get_record_stream([key], 'unordered', True)
56
 
    record = stream.next()
 
61
    record = next(stream)
57
62
    return record.get_bytes_as('fulltext')
58
63
 
59
64
 
67
72
 
68
73
 
69
74
class MockTree(object):
 
75
 
70
76
    def __init__(self):
71
 
        from bzrlib.inventory import InventoryDirectory, ROOT_ID
 
77
        from ..bzr.inventory import InventoryDirectory, ROOT_ID
72
78
        object.__init__(self)
73
79
        self.paths = {ROOT_ID: ""}
74
80
        self.ids = {"": ROOT_ID}
76
82
        self.root = InventoryDirectory(ROOT_ID, '', None)
77
83
 
78
84
    inventory = property(lambda x:x)
79
 
 
80
 
    def __iter__(self):
81
 
        return self.paths.iterkeys()
 
85
    root_inventory = property(lambda x:x)
 
86
 
 
87
    def get_root_id(self):
 
88
        return self.root.file_id
 
89
 
 
90
    def all_file_ids(self):
 
91
        return set(self.paths.keys())
 
92
 
 
93
    def all_versioned_paths(self):
 
94
        return set(self.paths.values())
 
95
 
 
96
    def is_executable(self, path, file_id):
 
97
        # Not all the files are executable.
 
98
        return False
82
99
 
83
100
    def __getitem__(self, file_id):
84
101
        if file_id == self.root.file_id:
93
110
        return self.ids[parent_dir]
94
111
 
95
112
    def iter_entries(self):
96
 
        for path, file_id in self.ids.iteritems():
 
113
        for path, file_id in self.ids.items():
97
114
            yield path, self[file_id]
98
115
 
99
 
    def get_file_kind(self, file_id):
 
116
    def kind(self, path, file_id=None):
 
117
        if file_id is None:
 
118
            file_id = self.path2id(path)
100
119
        if file_id in self.contents:
101
120
            kind = 'file'
102
121
        else:
104
123
        return kind
105
124
 
106
125
    def make_entry(self, file_id, path):
107
 
        from bzrlib.inventory import (InventoryEntry, InventoryFile
108
 
                                    , InventoryDirectory, InventoryLink)
 
126
        from ..bzr.inventory import (InventoryFile, InventoryDirectory,
 
127
            InventoryLink)
109
128
        name = os.path.basename(path)
110
 
        kind = self.get_file_kind(file_id)
 
129
        kind = self.kind(path, file_id)
111
130
        parent_id = self.parent_id(file_id)
112
 
        text_sha_1, text_size = self.contents_stats(file_id)
 
131
        text_sha_1, text_size = self.contents_stats(path, file_id)
113
132
        if kind == 'directory':
114
133
            ie = InventoryDirectory(file_id, name, parent_id)
115
134
        elif kind == 'file':
116
135
            ie = InventoryFile(file_id, name, parent_id)
 
136
            ie.text_sha1 = text_sha_1
 
137
            ie.text_size = text_size
117
138
        elif kind == 'symlink':
118
139
            ie = InventoryLink(file_id, name, parent_id)
119
140
        else:
120
141
            raise errors.BzrError('unknown kind %r' % kind)
121
 
        ie.text_sha1 = text_sha_1
122
 
        ie.text_size = text_size
123
142
        return ie
124
143
 
125
144
    def add_dir(self, file_id, path):
139
158
    def has_id(self, file_id):
140
159
        return self.id2path(file_id) is not None
141
160
 
142
 
    def get_file(self, file_id):
143
 
        result = StringIO()
144
 
        result.write(self.contents[file_id])
145
 
        result.seek(0,0)
 
161
    def get_file(self, path, file_id=None):
 
162
        if file_id is None:
 
163
            file_id = self.path2id(path)
 
164
        result = BytesIO()
 
165
        try:
 
166
            result.write(self.contents[file_id])
 
167
        except KeyError:
 
168
            raise errors.NoSuchFile(path)
 
169
        result.seek(0, 0)
146
170
        return result
147
171
 
148
 
    def contents_stats(self, file_id):
 
172
    def get_file_revision(self, path, file_id=None):
 
173
        if file_id is None:
 
174
            file_id = self.path2id(path)
 
175
        return self.inventory[file_id].revision
 
176
 
 
177
    def get_file_size(self, path, file_id=None):
 
178
        if file_id is None:
 
179
            file_id = self.path2id(path)
 
180
        return self.inventory[file_id].text_size
 
181
 
 
182
    def get_file_sha1(self, path, file_id=None):
 
183
        if file_id is None:
 
184
            file_id = self.path2id(path)
 
185
        return self.inventory[file_id].text_sha1
 
186
 
 
187
    def contents_stats(self, path, file_id):
149
188
        if file_id not in self.contents:
150
189
            return None, None
151
 
        text_sha1 = osutils.sha_file(self.get_file(file_id))
 
190
        text_sha1 = osutils.sha_file(self.get_file(path, file_id))
152
191
        return text_sha1, len(self.contents[file_id])
153
192
 
154
193
 
157
196
 
158
197
    def make_tree_1(self):
159
198
        mtree = MockTree()
160
 
        mtree.add_dir("a", "grandparent")
161
 
        mtree.add_dir("b", "grandparent/parent")
162
 
        mtree.add_file("c", "grandparent/parent/file", "Hello\n")
163
 
        mtree.add_dir("d", "grandparent/alt_parent")
 
199
        mtree.add_dir(b"a", "grandparent")
 
200
        mtree.add_dir(b"b", "grandparent/parent")
 
201
        mtree.add_file(b"c", "grandparent/parent/file", "Hello\n")
 
202
        mtree.add_dir(b"d", "grandparent/alt_parent")
164
203
        return BundleTree(mtree, ''), mtree
165
204
 
166
205
    def test_renames(self):
172
211
        self.assertEqual(btree.old_path("grandparent/parent/file"),
173
212
                         "grandparent/parent/file")
174
213
 
175
 
        self.assertEqual(btree.id2path("a"), "grandparent")
176
 
        self.assertEqual(btree.id2path("b"), "grandparent/parent")
177
 
        self.assertEqual(btree.id2path("c"), "grandparent/parent/file")
178
 
 
179
 
        self.assertEqual(btree.path2id("grandparent"), "a")
180
 
        self.assertEqual(btree.path2id("grandparent/parent"), "b")
181
 
        self.assertEqual(btree.path2id("grandparent/parent/file"), "c")
182
 
 
183
 
        self.assertTrue(btree.path2id("grandparent2") is None)
184
 
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
185
 
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
 
214
        self.assertEqual(btree.id2path(b"a"), "grandparent")
 
215
        self.assertEqual(btree.id2path(b"b"), "grandparent/parent")
 
216
        self.assertEqual(btree.id2path(b"c"), "grandparent/parent/file")
 
217
 
 
218
        self.assertEqual(btree.path2id("grandparent"), b"a")
 
219
        self.assertEqual(btree.path2id("grandparent/parent"), b"b")
 
220
        self.assertEqual(btree.path2id("grandparent/parent/file"), b"c")
 
221
 
 
222
        self.assertIs(btree.path2id("grandparent2"), None)
 
223
        self.assertIs(btree.path2id("grandparent2/parent"), None)
 
224
        self.assertIs(btree.path2id("grandparent2/parent/file"), None)
186
225
 
187
226
        btree.note_rename("grandparent", "grandparent2")
188
 
        self.assertTrue(btree.old_path("grandparent") is None)
189
 
        self.assertTrue(btree.old_path("grandparent/parent") is None)
190
 
        self.assertTrue(btree.old_path("grandparent/parent/file") is None)
191
 
 
192
 
        self.assertEqual(btree.id2path("a"), "grandparent2")
193
 
        self.assertEqual(btree.id2path("b"), "grandparent2/parent")
194
 
        self.assertEqual(btree.id2path("c"), "grandparent2/parent/file")
195
 
 
196
 
        self.assertEqual(btree.path2id("grandparent2"), "a")
197
 
        self.assertEqual(btree.path2id("grandparent2/parent"), "b")
198
 
        self.assertEqual(btree.path2id("grandparent2/parent/file"), "c")
 
227
        self.assertIs(btree.old_path("grandparent"), None)
 
228
        self.assertIs(btree.old_path("grandparent/parent"), None)
 
229
        self.assertIs(btree.old_path("grandparent/parent/file"), None)
 
230
 
 
231
        self.assertEqual(btree.id2path(b"a"), "grandparent2")
 
232
        self.assertEqual(btree.id2path(b"b"), "grandparent2/parent")
 
233
        self.assertEqual(btree.id2path(b"c"), "grandparent2/parent/file")
 
234
 
 
235
        self.assertEqual(btree.path2id("grandparent2"), b"a")
 
236
        self.assertEqual(btree.path2id("grandparent2/parent"), b"b")
 
237
        self.assertEqual(btree.path2id("grandparent2/parent/file"), b"c")
199
238
 
200
239
        self.assertTrue(btree.path2id("grandparent") is None)
201
240
        self.assertTrue(btree.path2id("grandparent/parent") is None)
202
241
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
203
242
 
204
243
        btree.note_rename("grandparent/parent", "grandparent2/parent2")
205
 
        self.assertEqual(btree.id2path("a"), "grandparent2")
206
 
        self.assertEqual(btree.id2path("b"), "grandparent2/parent2")
207
 
        self.assertEqual(btree.id2path("c"), "grandparent2/parent2/file")
 
244
        self.assertEqual(btree.id2path(b"a"), "grandparent2")
 
245
        self.assertEqual(btree.id2path(b"b"), "grandparent2/parent2")
 
246
        self.assertEqual(btree.id2path(b"c"), "grandparent2/parent2/file")
208
247
 
209
 
        self.assertEqual(btree.path2id("grandparent2"), "a")
210
 
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
211
 
        self.assertEqual(btree.path2id("grandparent2/parent2/file"), "c")
 
248
        self.assertEqual(btree.path2id("grandparent2"), b"a")
 
249
        self.assertEqual(btree.path2id("grandparent2/parent2"), b"b")
 
250
        self.assertEqual(btree.path2id("grandparent2/parent2/file"), b"c")
212
251
 
213
252
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
214
253
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
215
254
 
216
255
        btree.note_rename("grandparent/parent/file",
217
256
                          "grandparent2/parent2/file2")
218
 
        self.assertEqual(btree.id2path("a"), "grandparent2")
219
 
        self.assertEqual(btree.id2path("b"), "grandparent2/parent2")
220
 
        self.assertEqual(btree.id2path("c"), "grandparent2/parent2/file2")
 
257
        self.assertEqual(btree.id2path(b"a"), "grandparent2")
 
258
        self.assertEqual(btree.id2path(b"b"), "grandparent2/parent2")
 
259
        self.assertEqual(btree.id2path(b"c"), "grandparent2/parent2/file2")
221
260
 
222
 
        self.assertEqual(btree.path2id("grandparent2"), "a")
223
 
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
224
 
        self.assertEqual(btree.path2id("grandparent2/parent2/file2"), "c")
 
261
        self.assertEqual(btree.path2id("grandparent2"), b"a")
 
262
        self.assertEqual(btree.path2id("grandparent2/parent2"), b"b")
 
263
        self.assertEqual(btree.path2id("grandparent2/parent2/file2"), b"c")
225
264
 
226
265
        self.assertTrue(btree.path2id("grandparent2/parent2/file") is None)
227
266
 
230
269
        btree = self.make_tree_1()[0]
231
270
        btree.note_rename("grandparent/parent/file",
232
271
                          "grandparent/alt_parent/file")
233
 
        self.assertEqual(btree.id2path("c"), "grandparent/alt_parent/file")
234
 
        self.assertEqual(btree.path2id("grandparent/alt_parent/file"), "c")
 
272
        self.assertEqual(btree.id2path(b"c"), "grandparent/alt_parent/file")
 
273
        self.assertEqual(btree.path2id("grandparent/alt_parent/file"), b"c")
235
274
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
236
275
 
237
276
    def unified_diff(self, old, new):
238
 
        out = StringIO()
 
277
        out = BytesIO()
239
278
        diff.internal_diff("old", old, "new", new, out)
240
 
        out.seek(0,0)
 
279
        out.seek(0, 0)
241
280
        return out.read()
242
281
 
243
282
    def make_tree_2(self):
244
283
        btree = self.make_tree_1()[0]
245
284
        btree.note_rename("grandparent/parent/file",
246
285
                          "grandparent/alt_parent/file")
247
 
        self.assertTrue(btree.id2path("e") is None)
 
286
        self.assertTrue(btree.id2path(b"e") is None)
248
287
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
249
288
        btree.note_id("e", "grandparent/parent/file")
250
289
        return btree
254
293
        btree = self.make_tree_2()
255
294
        add_patch = self.unified_diff([], ["Extra cheese\n"])
256
295
        btree.note_patch("grandparent/parent/file", add_patch)
257
 
        btree.note_id('f', 'grandparent/parent/symlink', kind='symlink')
 
296
        btree.note_id(b'f', 'grandparent/parent/symlink', kind='symlink')
258
297
        btree.note_target('grandparent/parent/symlink', 'venus')
259
298
        self.adds_test(btree)
260
299
 
261
300
    def adds_test(self, btree):
262
 
        self.assertEqual(btree.id2path("e"), "grandparent/parent/file")
263
 
        self.assertEqual(btree.path2id("grandparent/parent/file"), "e")
264
 
        self.assertEqual(btree.get_file("e").read(), "Extra cheese\n")
265
 
        self.assertEqual(btree.get_symlink_target('f'), 'venus')
 
301
        self.assertEqual(btree.id2path(b"e"), "grandparent/parent/file")
 
302
        self.assertEqual(btree.path2id("grandparent/parent/file"), b"e")
 
303
        self.assertEqual(btree.get_file("grandparent/parent/file").read(),
 
304
                         "Extra cheese\n")
 
305
        self.assertEqual(
 
306
            btree.get_symlink_target('grandparent/parent/symlink'), 'venus')
266
307
 
267
308
    def test_adds2(self):
268
309
        """File/inventory adds, with patch-compatibile renames"""
284
325
        return btree
285
326
 
286
327
    def get_file_test(self, btree):
287
 
        self.assertEqual(btree.get_file("e").read(), "Lemon\n")
288
 
        self.assertEqual(btree.get_file("c").read(), "Hello\n")
 
328
        self.assertEqual(btree.get_file(btree.id2path(b"e")).read(), "Lemon\n")
 
329
        self.assertEqual(btree.get_file(btree.id2path(b"c")).read(), "Hello\n")
289
330
 
290
331
    def test_get_file(self):
291
332
        """Get file contents"""
295
336
        self.get_file_test(btree)
296
337
 
297
338
    def test_get_file2(self):
298
 
        """Get file contents, with patch-compatibile renames"""
 
339
        """Get file contents, with patch-compatible renames"""
299
340
        btree = self.make_tree_3()
300
341
        btree.contents_by_id = False
301
342
        mod_patch = self.unified_diff([], ["Lemon\n"])
307
348
    def test_delete(self):
308
349
        "Deletion by bundle"
309
350
        btree = self.make_tree_1()[0]
310
 
        self.assertEqual(btree.get_file("c").read(), "Hello\n")
 
351
        self.assertEqual(btree.get_file(btree.id2path(b"c")).read(), "Hello\n")
311
352
        btree.note_deletion("grandparent/parent/file")
312
 
        self.assertTrue(btree.id2path("c") is None)
313
 
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
 
353
        self.assertTrue(btree.id2path(b"c") is None)
 
354
        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
314
355
 
315
356
    def sorted_ids(self, tree):
316
 
        ids = list(tree)
317
 
        ids.sort()
 
357
        ids = sorted(tree.all_file_ids())
318
358
        return ids
319
359
 
320
360
    def test_iteration(self):
338
378
        serializer = BundleSerializerV08('0.8')
339
379
        b = self.make_branch('.', format=format)
340
380
        self.assertRaises(errors.IncompatibleBundleFormat, serializer.write,
341
 
                          b.repository, [], {}, StringIO())
 
381
                          b.repository, [], {}, BytesIO())
342
382
 
343
383
    def test_matched_bundle(self):
344
384
        """Don't raise IncompatibleBundleFormat for knit2 and bundle0.9"""
346
386
        format.repository_format = knitrepo.RepositoryFormatKnit3()
347
387
        serializer = BundleSerializerV09('0.9')
348
388
        b = self.make_branch('.', format=format)
349
 
        serializer.write(b.repository, [], {}, StringIO())
 
389
        serializer.write(b.repository, [], {}, BytesIO())
350
390
 
351
391
    def test_mismatched_model(self):
352
392
        """Try copying a bundle from knit2 to knit1"""
353
393
        format = bzrdir.BzrDirMetaFormat1()
354
394
        format.repository_format = knitrepo.RepositoryFormatKnit3()
355
395
        source = self.make_branch_and_tree('source', format=format)
356
 
        source.commit('one', rev_id='one-id')
357
 
        source.commit('two', rev_id='two-id')
358
 
        text = StringIO()
 
396
        source.commit('one', rev_id=b'one-id')
 
397
        source.commit('two', rev_id=b'two-id')
 
398
        text = BytesIO()
359
399
        write_bundle(source.branch.repository, 'two-id', 'null:', text,
360
400
                     format='0.9')
361
401
        text.seek(0)
386
426
        return tests.TestCaseWithTransport.make_branch(self, path, format)
387
427
 
388
428
    def create_bundle_text(self, base_rev_id, rev_id):
389
 
        bundle_txt = StringIO()
 
429
        bundle_txt = BytesIO()
390
430
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id,
391
431
                               bundle_txt, format=self.format)
392
432
        bundle_txt.seek(0)
441
481
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
442
482
        new_text = bundle_txt.getvalue().replace('executable:no',
443
483
                                               'executable:yes')
444
 
        bundle_txt = StringIO(new_text)
 
484
        bundle_txt = BytesIO(new_text)
445
485
        bundle = read_bundle(bundle_txt)
446
486
        self.valid_apply_bundle(base_rev_id, bundle)
447
487
        return bundle
448
488
 
449
489
    def test_non_bundle(self):
450
490
        self.assertRaises(errors.NotABundle,
451
 
                          read_bundle, StringIO('#!/bin/sh\n'))
 
491
                          read_bundle, BytesIO(b'#!/bin/sh\n'))
452
492
 
453
493
    def test_malformed(self):
454
494
        self.assertRaises(errors.BadBundle, read_bundle,
455
 
                          StringIO('# Bazaar revision bundle v'))
 
495
                          BytesIO(b'# Bazaar revision bundle v'))
456
496
 
457
497
    def test_crlf_bundle(self):
458
498
        try:
459
 
            read_bundle(StringIO('# Bazaar revision bundle v0.8\r\n'))
 
499
            read_bundle(BytesIO(b'# Bazaar revision bundle v0.8\r\n'))
460
500
        except errors.BadBundle:
461
501
            # It is currently permitted for bundles with crlf line endings to
462
502
            # make read_bundle raise a BadBundle, but this should be fixed.
473
513
            if not os.path.exists(checkout_dir):
474
514
                os.mkdir(checkout_dir)
475
515
        tree = self.make_branch_and_tree(checkout_dir)
476
 
        s = StringIO()
 
516
        s = BytesIO()
477
517
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
478
518
                                 format=self.format)
479
519
        s.seek(0)
492
532
                                 % (ancestor,))
493
533
 
494
534
                # Now check that the file contents are all correct
495
 
                for inventory_id in old:
 
535
                for path in old.all_versioned_paths():
496
536
                    try:
497
 
                        old_file = old.get_file(inventory_id)
 
537
                        old_file = old.get_file(path)
498
538
                    except errors.NoSuchFile:
499
539
                        continue
500
 
                    if old_file is None:
501
 
                        continue
502
 
                    self.assertEqual(old_file.read(),
503
 
                                     new.get_file(inventory_id).read())
 
540
                    self.assertEqual(
 
541
                            old_file.read(), new.get_file(path).read())
504
542
            finally:
505
543
                new.unlock()
506
544
                old.unlock()
507
545
        if not _mod_revision.is_null(rev_id):
508
 
            rh = self.b1.revision_history()
509
 
            tree.branch.set_revision_history(rh[:rh.index(rev_id)+1])
 
546
            tree.branch.generate_revision_history(rev_id)
510
547
            tree.update()
511
548
            delta = tree.changes_from(self.b1.repository.revision_tree(rev_id))
512
549
            self.assertFalse(delta.has_changed(),
530
567
        original_parents = to_tree.get_parent_ids()
531
568
        self.assertIs(repository.has_revision(base_rev_id), True)
532
569
        for rev in info.real_revisions:
533
 
            self.assert_(not repository.has_revision(rev.revision_id),
534
 
                'Revision {%s} present before applying bundle'
535
 
                % rev.revision_id)
 
570
            self.assertTrue(not repository.has_revision(rev.revision_id),
 
571
                            'Revision {%s} present before applying bundle'
 
572
                            % rev.revision_id)
536
573
        merge_bundle(info, to_tree, True, merge.Merge3Merger, False, False)
537
574
 
538
575
        for rev in info.real_revisions:
539
 
            self.assert_(repository.has_revision(rev.revision_id),
540
 
                'Missing revision {%s} after applying bundle'
541
 
                % rev.revision_id)
 
576
            self.assertTrue(repository.has_revision(rev.revision_id),
 
577
                            'Missing revision {%s} after applying bundle'
 
578
                            % rev.revision_id)
542
579
 
543
 
        self.assert_(to_tree.branch.repository.has_revision(info.target))
 
580
        self.assertTrue(to_tree.branch.repository.has_revision(info.target))
544
581
        # Do we also want to verify that all the texts have been added?
545
582
 
546
583
        self.assertEqual(original_parents + [info.target],
547
 
            to_tree.get_parent_ids())
 
584
                         to_tree.get_parent_ids())
548
585
 
549
586
        rev = info.real_revisions[-1]
550
587
        base_tree = self.b1.repository.revision_tree(rev.revision_id)
561
598
 
562
599
        for path, status, kind, fileid, entry in base_files:
563
600
            # Check that the meta information is the same
564
 
            self.assertEqual(base_tree.get_file_size(fileid),
565
 
                    to_tree.get_file_size(fileid))
566
 
            self.assertEqual(base_tree.get_file_sha1(fileid),
567
 
                    to_tree.get_file_sha1(fileid))
 
601
            self.assertEqual(base_tree.get_file_size(path, fileid),
 
602
                    to_tree.get_file_size(to_tree.id2path(fileid)))
 
603
            self.assertEqual(base_tree.get_file_sha1(path, fileid),
 
604
                    to_tree.get_file_sha1(to_tree.id2path(fileid)))
568
605
            # Check that the contents are the same
569
606
            # This is pretty expensive
570
607
            # self.assertEqual(base_tree.get_file(fileid).read(),
574
611
        self.tree1 = self.make_branch_and_tree('b1')
575
612
        self.b1 = self.tree1.branch
576
613
 
577
 
        self.build_tree_contents([('b1/one', 'one\n')])
578
 
        self.tree1.add('one', 'one-id')
579
 
        self.tree1.set_root_id('root-id')
580
 
        self.tree1.commit('add one', rev_id='a@cset-0-1')
 
614
        self.build_tree_contents([('b1/one', b'one\n')])
 
615
        self.tree1.add('one', b'one-id')
 
616
        self.tree1.set_root_id(b'root-id')
 
617
        self.tree1.commit('add one', rev_id=b'a@cset-0-1')
581
618
 
582
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
 
619
        bundle = self.get_valid_bundle('null:', b'a@cset-0-1')
583
620
 
584
621
        # Make sure we can handle files with spaces, tabs, other
585
622
        # bogus characters
593
630
                , 'b1/sub/sub/'
594
631
                , 'b1/sub/sub/nonempty.txt'
595
632
                ])
596
 
        self.build_tree_contents([('b1/sub/sub/emptyfile.txt', ''),
597
 
                                  ('b1/dir/nolastnewline.txt', 'bloop')])
 
633
        self.build_tree_contents([('b1/sub/sub/emptyfile.txt', b''),
 
634
                                  ('b1/dir/nolastnewline.txt', b'bloop')])
598
635
        tt = TreeTransform(self.tree1)
599
636
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
600
637
        tt.apply()
601
638
        # have to fix length of file-id so that we can predictably rewrite
602
639
        # a (length-prefixed) record containing it later.
603
 
        self.tree1.add('with space.txt', 'withspace-id')
 
640
        self.tree1.add('with space.txt', b'withspace-id')
604
641
        self.tree1.add([
605
642
                  'dir'
606
643
                , 'dir/filein subdir.c'
612
649
                , 'sub/sub/nonempty.txt'
613
650
                , 'sub/sub/emptyfile.txt'
614
651
                ])
615
 
        self.tree1.commit('add whitespace', rev_id='a@cset-0-2')
 
652
        self.tree1.commit('add whitespace', rev_id=b'a@cset-0-2')
616
653
 
617
 
        bundle = self.get_valid_bundle('a@cset-0-1', 'a@cset-0-2')
 
654
        bundle = self.get_valid_bundle('a@cset-0-1', b'a@cset-0-2')
618
655
 
619
656
        # Check a rollup bundle
620
657
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
626
663
                , 'sub/sub'
627
664
                ])
628
665
        tt = TreeTransform(self.tree1)
629
 
        trans_id = tt.trans_id_tree_file_id('exe-1')
 
666
        trans_id = tt.trans_id_tree_path('executable')
630
667
        tt.set_executability(False, trans_id)
631
668
        tt.apply()
632
 
        self.tree1.commit('removed', rev_id='a@cset-0-3')
 
669
        self.tree1.commit('removed', rev_id=b'a@cset-0-3')
633
670
 
634
671
        bundle = self.get_valid_bundle('a@cset-0-2', 'a@cset-0-3')
635
672
        self.assertRaises((errors.TestamentMismatch,
641
678
 
642
679
        # Now move the directory
643
680
        self.tree1.rename_one('dir', 'sub/dir')
644
 
        self.tree1.commit('rename dir', rev_id='a@cset-0-4')
 
681
        self.tree1.commit('rename dir', rev_id=b'a@cset-0-4')
645
682
 
646
683
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
647
684
        # Check a rollup bundle
648
685
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
649
686
 
650
687
        # Modified files
651
 
        open('b1/sub/dir/WithCaps.txt', 'ab').write('\nAdding some text\n')
652
 
        open('b1/sub/dir/ pre space', 'ab').write(
 
688
        with open('b1/sub/dir/WithCaps.txt', 'ab') as f: f.write('\nAdding some text\n')
 
689
        with open('b1/sub/dir/ pre space', 'ab') as f: f.write(
653
690
             '\r\nAdding some\r\nDOS format lines\r\n')
654
 
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
 
691
        with open('b1/sub/dir/nolastnewline.txt', 'ab') as f: f.write('\n')
655
692
        self.tree1.rename_one('sub/dir/ pre space',
656
693
                              'sub/ start space')
657
 
        self.tree1.commit('Modified files', rev_id='a@cset-0-5')
 
694
        self.tree1.commit('Modified files', rev_id=b'a@cset-0-5')
658
695
        bundle = self.get_valid_bundle('a@cset-0-4', 'a@cset-0-5')
659
696
 
660
697
        self.tree1.rename_one('sub/dir/WithCaps.txt', 'temp')
661
698
        self.tree1.rename_one('with space.txt', 'WithCaps.txt')
662
699
        self.tree1.rename_one('temp', 'with space.txt')
663
 
        self.tree1.commit(u'swap filenames', rev_id='a@cset-0-6',
 
700
        self.tree1.commit(u'swap filenames', rev_id=b'a@cset-0-6',
664
701
                          verbose=False)
665
702
        bundle = self.get_valid_bundle('a@cset-0-5', 'a@cset-0-6')
666
703
        other = self.get_checkout('a@cset-0-5')
670
707
                                       'a@cset-0-5')
671
708
        self.assertEqualDiff(tree1_inv, tree2_inv)
672
709
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
673
 
        other.commit('rename file', rev_id='a@cset-0-6b')
 
710
        other.commit('rename file', rev_id=b'a@cset-0-6b')
674
711
        self.tree1.merge_from_branch(other.branch)
675
 
        self.tree1.commit(u'Merge', rev_id='a@cset-0-7',
 
712
        self.tree1.commit(u'Merge', rev_id=b'a@cset-0-7',
676
713
                          verbose=False)
677
714
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
678
715
 
679
716
    def _test_symlink_bundle(self, link_name, link_target, new_link_target):
680
717
        link_id = 'link-1'
681
718
 
682
 
        self.requireFeature(tests.SymlinkFeature)
 
719
        self.requireFeature(features.SymlinkFeature)
683
720
        self.tree1 = self.make_branch_and_tree('b1')
684
721
        self.b1 = self.tree1.branch
685
722
 
686
723
        tt = TreeTransform(self.tree1)
687
724
        tt.new_symlink(link_name, tt.root, link_target, link_id)
688
725
        tt.apply()
689
 
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
 
726
        self.tree1.commit('add symlink', rev_id=b'l@cset-0-1')
690
727
        bundle = self.get_valid_bundle('null:', 'l@cset-0-1')
691
 
        if getattr(bundle ,'revision_tree', None) is not None:
 
728
        if getattr(bundle, 'revision_tree', None) is not None:
692
729
            # Not all bundle formats supports revision_tree
693
730
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-1')
694
 
            self.assertEqual(link_target, bund_tree.get_symlink_target(link_id))
 
731
            self.assertEqual(link_target, bund_tree.get_symlink_target(link_name))
695
732
 
696
733
        tt = TreeTransform(self.tree1)
697
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
734
        trans_id = tt.trans_id_tree_path(link_name)
698
735
        tt.adjust_path('link2', tt.root, trans_id)
699
736
        tt.delete_contents(trans_id)
700
737
        tt.create_symlink(new_link_target, trans_id)
701
738
        tt.apply()
702
 
        self.tree1.commit('rename and change symlink', rev_id='l@cset-0-2')
 
739
        self.tree1.commit('rename and change symlink', rev_id=b'l@cset-0-2')
703
740
        bundle = self.get_valid_bundle('l@cset-0-1', 'l@cset-0-2')
704
 
        if getattr(bundle ,'revision_tree', None) is not None:
 
741
        if getattr(bundle, 'revision_tree', None) is not None:
705
742
            # Not all bundle formats supports revision_tree
706
743
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-2')
707
744
            self.assertEqual(new_link_target,
708
 
                             bund_tree.get_symlink_target(link_id))
 
745
                             bund_tree.get_symlink_target('link2'))
709
746
 
710
747
        tt = TreeTransform(self.tree1)
711
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
748
        trans_id = tt.trans_id_tree_path('link2')
712
749
        tt.delete_contents(trans_id)
713
750
        tt.create_symlink('jupiter', trans_id)
714
751
        tt.apply()
715
 
        self.tree1.commit('just change symlink target', rev_id='l@cset-0-3')
 
752
        self.tree1.commit('just change symlink target', rev_id=b'l@cset-0-3')
716
753
        bundle = self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
717
754
 
718
755
        tt = TreeTransform(self.tree1)
719
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
756
        trans_id = tt.trans_id_tree_path('link2')
720
757
        tt.delete_contents(trans_id)
721
758
        tt.apply()
722
 
        self.tree1.commit('Delete symlink', rev_id='l@cset-0-4')
 
759
        self.tree1.commit('Delete symlink', rev_id=b'l@cset-0-4')
723
760
        bundle = self.get_valid_bundle('l@cset-0-3', 'l@cset-0-4')
724
761
 
725
762
    def test_symlink_bundle(self):
726
763
        self._test_symlink_bundle('link', 'bar/foo', 'mars')
727
764
 
728
765
    def test_unicode_symlink_bundle(self):
729
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
766
        self.requireFeature(features.UnicodeFilenameFeature)
730
767
        self._test_symlink_bundle(u'\N{Euro Sign}link',
731
768
                                  u'bar/\N{Euro Sign}foo',
732
769
                                  u'mars\N{Euro Sign}')
741
778
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
742
779
            'binary-2')
743
780
        tt.apply()
744
 
        self.tree1.commit('add binary', rev_id='b@cset-0-1')
 
781
        self.tree1.commit('add binary', rev_id=b'b@cset-0-1')
745
782
        self.get_valid_bundle('null:', 'b@cset-0-1')
746
783
 
747
784
        # Delete
748
785
        tt = TreeTransform(self.tree1)
749
 
        trans_id = tt.trans_id_tree_file_id('binary-1')
 
786
        trans_id = tt.trans_id_tree_path('file')
750
787
        tt.delete_contents(trans_id)
751
788
        tt.apply()
752
 
        self.tree1.commit('delete binary', rev_id='b@cset-0-2')
 
789
        self.tree1.commit('delete binary', rev_id=b'b@cset-0-2')
753
790
        self.get_valid_bundle('b@cset-0-1', 'b@cset-0-2')
754
791
 
755
792
        # Rename & modify
756
793
        tt = TreeTransform(self.tree1)
757
 
        trans_id = tt.trans_id_tree_file_id('binary-2')
 
794
        trans_id = tt.trans_id_tree_path('file2')
758
795
        tt.adjust_path('file3', tt.root, trans_id)
759
796
        tt.delete_contents(trans_id)
760
797
        tt.create_file('file\rcontents\x00\n\x00', trans_id)
761
798
        tt.apply()
762
 
        self.tree1.commit('rename and modify binary', rev_id='b@cset-0-3')
 
799
        self.tree1.commit('rename and modify binary', rev_id=b'b@cset-0-3')
763
800
        self.get_valid_bundle('b@cset-0-2', 'b@cset-0-3')
764
801
 
765
802
        # Modify
766
803
        tt = TreeTransform(self.tree1)
767
 
        trans_id = tt.trans_id_tree_file_id('binary-2')
 
804
        trans_id = tt.trans_id_tree_path('file3')
768
805
        tt.delete_contents(trans_id)
769
806
        tt.create_file('\x00file\rcontents', trans_id)
770
807
        tt.apply()
771
 
        self.tree1.commit('just modify binary', rev_id='b@cset-0-4')
 
808
        self.tree1.commit('just modify binary', rev_id=b'b@cset-0-4')
772
809
        self.get_valid_bundle('b@cset-0-3', 'b@cset-0-4')
773
810
 
774
811
        # Rollup
780
817
        tt = TreeTransform(self.tree1)
781
818
        tt.new_file('file', tt.root, 'file', 'file')
782
819
        tt.apply()
783
 
        self.tree1.commit('create file', rev_id='a@lmod-0-1')
 
820
        self.tree1.commit('create file', rev_id=b'a@lmod-0-1')
784
821
 
785
822
        tt = TreeTransform(self.tree1)
786
 
        trans_id = tt.trans_id_tree_file_id('file')
 
823
        trans_id = tt.trans_id_tree_path('file')
787
824
        tt.delete_contents(trans_id)
788
825
        tt.create_file('file2', trans_id)
789
826
        tt.apply()
790
 
        self.tree1.commit('modify text', rev_id='a@lmod-0-2a')
 
827
        self.tree1.commit('modify text', rev_id=b'a@lmod-0-2a')
791
828
 
792
829
        other = self.get_checkout('a@lmod-0-1')
793
830
        tt = TreeTransform(other)
794
 
        trans_id = tt.trans_id_tree_file_id('file')
 
831
        trans_id = tt.trans_id_tree_path('file2')
795
832
        tt.delete_contents(trans_id)
796
833
        tt.create_file('file2', trans_id)
797
834
        tt.apply()
798
 
        other.commit('modify text in another tree', rev_id='a@lmod-0-2b')
 
835
        other.commit('modify text in another tree', rev_id=b'a@lmod-0-2b')
799
836
        self.tree1.merge_from_branch(other.branch)
800
 
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-3',
 
837
        self.tree1.commit(u'Merge', rev_id=b'a@lmod-0-3',
801
838
                          verbose=False)
802
 
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-4')
 
839
        self.tree1.commit(u'Merge', rev_id=b'a@lmod-0-4')
803
840
        bundle = self.get_valid_bundle('a@lmod-0-2a', 'a@lmod-0-4')
804
841
 
805
842
    def test_hide_history(self):
806
843
        self.tree1 = self.make_branch_and_tree('b1')
807
844
        self.b1 = self.tree1.branch
808
845
 
809
 
        open('b1/one', 'wb').write('one\n')
 
846
        with open('b1/one', 'wb') as f: f.write(b'one\n')
810
847
        self.tree1.add('one')
811
 
        self.tree1.commit('add file', rev_id='a@cset-0-1')
812
 
        open('b1/one', 'wb').write('two\n')
813
 
        self.tree1.commit('modify', rev_id='a@cset-0-2')
814
 
        open('b1/one', 'wb').write('three\n')
815
 
        self.tree1.commit('modify', rev_id='a@cset-0-3')
816
 
        bundle_file = StringIO()
 
848
        self.tree1.commit('add file', rev_id=b'a@cset-0-1')
 
849
        with open('b1/one', 'wb') as f: f.write(b'two\n')
 
850
        self.tree1.commit('modify', rev_id=b'a@cset-0-2')
 
851
        with open('b1/one', 'wb') as f: f.write(b'three\n')
 
852
        self.tree1.commit('modify', rev_id=b'a@cset-0-3')
 
853
        bundle_file = BytesIO()
817
854
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
818
855
                               'a@cset-0-1', bundle_file, format=self.format)
819
856
        self.assertNotContainsRe(bundle_file.getvalue(), '\btwo\b')
823
860
    def test_bundle_same_basis(self):
824
861
        """Ensure using the basis as the target doesn't cause an error"""
825
862
        self.tree1 = self.make_branch_and_tree('b1')
826
 
        self.tree1.commit('add file', rev_id='a@cset-0-1')
827
 
        bundle_file = StringIO()
 
863
        self.tree1.commit('add file', rev_id=b'a@cset-0-1')
 
864
        bundle_file = BytesIO()
828
865
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-1',
829
866
                               'a@cset-0-1', bundle_file)
830
867
 
833
870
        return bundle_file.getvalue()
834
871
 
835
872
    def test_unicode_bundle(self):
836
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
873
        self.requireFeature(features.UnicodeFilenameFeature)
837
874
        # Handle international characters
838
875
        os.mkdir('b1')
839
876
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
846
883
            u'William Dod\xe9\n').encode('utf-8'))
847
884
        f.close()
848
885
 
849
 
        self.tree1.add([u'with Dod\N{Euro Sign}'], ['withdod-id'])
 
886
        self.tree1.add([u'with Dod\N{Euro Sign}'], [b'withdod-id'])
850
887
        self.tree1.commit(u'i18n commit from William Dod\xe9',
851
 
                          rev_id='i18n-1', committer=u'William Dod\xe9')
 
888
                          rev_id=b'i18n-1', committer=u'William Dod\xe9')
852
889
 
853
890
        # Add
854
891
        bundle = self.get_valid_bundle('null:', 'i18n-1')
857
894
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
858
895
        f.write(u'Modified \xb5\n'.encode('utf8'))
859
896
        f.close()
860
 
        self.tree1.commit(u'modified', rev_id='i18n-2')
 
897
        self.tree1.commit(u'modified', rev_id=b'i18n-2')
861
898
 
862
899
        bundle = self.get_valid_bundle('i18n-1', 'i18n-2')
863
900
 
864
901
        # Renamed
865
902
        self.tree1.rename_one(u'with Dod\N{Euro Sign}', u'B\N{Euro Sign}gfors')
866
 
        self.tree1.commit(u'renamed, the new i18n man', rev_id='i18n-3',
 
903
        self.tree1.commit(u'renamed, the new i18n man', rev_id=b'i18n-3',
867
904
                          committer=u'Erik B\xe5gfors')
868
905
 
869
906
        bundle = self.get_valid_bundle('i18n-2', 'i18n-3')
870
907
 
871
908
        # Removed
872
909
        self.tree1.remove([u'B\N{Euro Sign}gfors'])
873
 
        self.tree1.commit(u'removed', rev_id='i18n-4')
 
910
        self.tree1.commit(u'removed', rev_id=b'i18n-4')
874
911
 
875
912
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
876
913
 
891
928
        #       once we actually support them
892
929
 
893
930
        # Added
894
 
        self.tree1.commit('funky whitespace', rev_id='white-1')
 
931
        self.tree1.commit('funky whitespace', rev_id=b'white-1')
895
932
 
896
933
        bundle = self.get_valid_bundle('null:', 'white-1')
897
934
 
898
935
        # Modified
899
 
        open('b1/trailing space ', 'ab').write('add some text\n')
900
 
        self.tree1.commit('add text', rev_id='white-2')
 
936
        with open('b1/trailing space ', 'ab') as f: f.write('add some text\n')
 
937
        self.tree1.commit('add text', rev_id=b'white-2')
901
938
 
902
939
        bundle = self.get_valid_bundle('white-1', 'white-2')
903
940
 
904
941
        # Renamed
905
942
        self.tree1.rename_one('trailing space ', ' start and end space ')
906
 
        self.tree1.commit('rename', rev_id='white-3')
 
943
        self.tree1.commit('rename', rev_id=b'white-3')
907
944
 
908
945
        bundle = self.get_valid_bundle('white-2', 'white-3')
909
946
 
910
947
        # Removed
911
948
        self.tree1.remove([' start and end space '])
912
 
        self.tree1.commit('removed', rev_id='white-4')
 
949
        self.tree1.commit('removed', rev_id=b'white-4')
913
950
 
914
951
        bundle = self.get_valid_bundle('white-3', 'white-4')
915
952
 
927
964
        builder.finish_tree()
928
965
 
929
966
        # Asia/Colombo offset = 5 hours 30 minutes
930
 
        self.tree1.commit('non-hour offset timezone', rev_id='tz-1',
 
967
        self.tree1.commit('non-hour offset timezone', rev_id=b'tz-1',
931
968
                          timezone=19800, timestamp=1152544886.0)
932
969
 
933
970
        bundle = self.get_valid_bundle('null:', 'tz-1')
941
978
    def test_bundle_root_id(self):
942
979
        self.tree1 = self.make_branch_and_tree('b1')
943
980
        self.b1 = self.tree1.branch
944
 
        self.tree1.commit('message', rev_id='revid1')
 
981
        self.tree1.commit('message', rev_id=b'revid1')
945
982
        bundle = self.get_valid_bundle('null:', 'revid1')
946
983
        tree = self.get_bundle_tree(bundle, 'revid1')
947
 
        self.assertEqual('revid1', tree.inventory.root.revision)
 
984
        root_revision = tree.get_file_revision(u'', tree.get_root_id())
 
985
        self.assertEqual('revid1', root_revision)
948
986
 
949
987
    def test_install_revisions(self):
950
988
        self.tree1 = self.make_branch_and_tree('b1')
951
989
        self.b1 = self.tree1.branch
952
 
        self.tree1.commit('message', rev_id='rev2a')
 
990
        self.tree1.commit('message', rev_id=b'rev2a')
953
991
        bundle = self.get_valid_bundle('null:', 'rev2a')
954
992
        branch2 = self.make_branch('b2')
955
993
        self.assertFalse(branch2.repository.has_revision('rev2a'))
963
1001
        tree.lock_write()
964
1002
        self.addCleanup(tree.unlock)
965
1003
        tree.add([''], ['TREE_ROOT'])
966
 
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1004
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id=b'rev1')
967
1005
        self.b1 = tree.branch
968
1006
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
969
1007
        bundle = read_bundle(bundle_sio)
980
1018
        self.addCleanup(tree.unlock)
981
1019
 
982
1020
        tree.add([''], ['TREE_ROOT'])
983
 
        tree.commit('One', rev_id='rev1',
 
1021
        tree.commit('One', rev_id=b'rev1',
984
1022
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
985
1023
        self.b1 = tree.branch
986
1024
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1003
1041
        # whitespace.
1004
1042
        # However, Testaments assert than they are str(), and thus should not
1005
1043
        # be Unicode.
1006
 
        tree.commit('One', rev_id='rev1',
 
1044
        tree.commit('One', rev_id=b'rev1',
1007
1045
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
1008
1046
        self.b1 = tree.branch
1009
1047
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1017
1055
    def test_bundle_with_ghosts(self):
1018
1056
        tree = self.make_branch_and_tree('tree')
1019
1057
        self.b1 = tree.branch
1020
 
        self.build_tree_contents([('tree/file', 'content1')])
 
1058
        self.build_tree_contents([('tree/file', b'content1')])
1021
1059
        tree.add(['file'])
1022
1060
        tree.commit('rev1')
1023
 
        self.build_tree_contents([('tree/file', 'content2')])
1024
 
        tree.add_parent_tree_id('ghost')
1025
 
        tree.commit('rev2', rev_id='rev2')
1026
 
        bundle = self.get_valid_bundle('null:', 'rev2')
 
1061
        self.build_tree_contents([('tree/file', b'content2')])
 
1062
        tree.add_parent_tree_id(b'ghost')
 
1063
        tree.commit('rev2', rev_id=b'rev2')
 
1064
        bundle = self.get_valid_bundle(b'null:', b'rev2')
1027
1065
 
1028
1066
    def make_simple_tree(self, format=None):
1029
1067
        tree = self.make_branch_and_tree('b1', format=format)
1034
1072
 
1035
1073
    def test_across_serializers(self):
1036
1074
        tree = self.make_simple_tree('knit')
1037
 
        tree.commit('hello', rev_id='rev1')
1038
 
        tree.commit('hello', rev_id='rev2')
 
1075
        tree.commit('hello', rev_id=b'rev1')
 
1076
        tree.commit('hello', rev_id=b'rev2')
1039
1077
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
1040
1078
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1041
1079
        bundle.install_revisions(repo)
1045
1083
 
1046
1084
    def make_repo_with_installed_revisions(self):
1047
1085
        tree = self.make_simple_tree('knit')
1048
 
        tree.commit('hello', rev_id='rev1')
1049
 
        tree.commit('hello', rev_id='rev2')
 
1086
        tree.commit('hello', rev_id=b'rev1')
 
1087
        tree.commit('hello', rev_id=b'rev2')
1050
1088
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
1051
1089
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1052
1090
        bundle.install_revisions(repo)
1071
1109
 
1072
1110
    def test_across_models_incompatible(self):
1073
1111
        tree = self.make_simple_tree('dirstate-with-subtree')
1074
 
        tree.commit('hello', rev_id='rev1')
1075
 
        tree.commit('hello', rev_id='rev2')
 
1112
        tree.commit('hello', rev_id=b'rev1')
 
1113
        tree.commit('hello', rev_id=b'rev2')
1076
1114
        try:
1077
1115
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
1078
1116
        except errors.IncompatibleBundleFormat:
1086
1124
 
1087
1125
    def test_get_merge_request(self):
1088
1126
        tree = self.make_simple_tree()
1089
 
        tree.commit('hello', rev_id='rev1')
1090
 
        tree.commit('hello', rev_id='rev2')
 
1127
        tree.commit('hello', rev_id=b'rev1')
 
1128
        tree.commit('hello', rev_id=b'rev2')
1091
1129
        bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
1092
1130
        result = bundle.get_merge_request(tree.branch.repository)
1093
1131
        self.assertEqual((None, 'rev1', 'inapplicable'), result)
1099
1137
        subtree = self.make_branch_and_tree('tree/subtree',
1100
1138
                                            format='dirstate-with-subtree')
1101
1139
        tree.add('subtree')
1102
 
        tree.commit('hello', rev_id='rev1')
 
1140
        tree.commit('hello', rev_id=b'rev1')
1103
1141
        try:
1104
1142
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
1105
1143
        except errors.IncompatibleBundleFormat:
1116
1154
        self.tree1 = self.make_branch_and_tree('tree')
1117
1155
        self.b1 = self.tree1.branch
1118
1156
        try:
1119
 
            self.tree1.commit('Revision/id/with/slashes', rev_id='rev/id')
 
1157
            self.tree1.commit('Revision/id/with/slashes', rev_id=b'rev/id')
1120
1158
        except ValueError:
1121
1159
            raise tests.TestSkipped(
1122
1160
                "Repository doesn't support revision ids with slashes")
1127
1165
        self.tree1 = self.make_branch_and_tree('tree')
1128
1166
        self.b1 = self.tree1.branch
1129
1167
        # rev1 is not present in bundle, done by fetch
1130
 
        self.build_tree_contents([('tree/file2', 'contents1')])
1131
 
        self.tree1.add('file2', 'file2-id')
1132
 
        self.tree1.commit('rev1', rev_id='reva')
1133
 
        self.build_tree_contents([('tree/file3', 'contents2')])
 
1168
        self.build_tree_contents([('tree/file2', b'contents1')])
 
1169
        self.tree1.add('file2', b'file2-id')
 
1170
        self.tree1.commit('rev1', rev_id=b'reva')
 
1171
        self.build_tree_contents([('tree/file3', b'contents2')])
1134
1172
        # rev2 is present in bundle, and done by fetch
1135
1173
        # having file1 in the bunle causes file1's versionedfile to be opened.
1136
 
        self.tree1.add('file3', 'file3-id')
 
1174
        self.tree1.add('file3', b'file3-id')
1137
1175
        self.tree1.commit('rev2')
1138
1176
        # Updating file2 should not cause an attempt to add to file1's vf
1139
 
        target = self.tree1.bzrdir.sprout('target').open_workingtree()
1140
 
        self.build_tree_contents([('tree/file2', 'contents3')])
1141
 
        self.tree1.commit('rev3', rev_id='rev3')
 
1177
        target = self.tree1.controldir.sprout('target').open_workingtree()
 
1178
        self.build_tree_contents([('tree/file2', b'contents3')])
 
1179
        self.tree1.commit('rev3', rev_id=b'rev3')
1142
1180
        bundle = self.get_valid_bundle('reva', 'rev3')
1143
1181
        if getattr(bundle, 'get_bundle_reader', None) is None:
1144
1182
            raise tests.TestSkipped('Bundle format cannot provide reader')
1145
1183
        # be sure that file1 comes before file2
1146
1184
        for b, m, k, r, f in bundle.get_bundle_reader().iter_records():
1147
 
            if f == 'file3-id':
 
1185
            if f == b'file3-id':
1148
1186
                break
1149
 
            self.assertNotEqual(f, 'file2-id')
 
1187
            self.assertNotEqual(f, b'file2-id')
1150
1188
        bundle.install_revisions(target.branch.repository)
1151
1189
 
1152
1190
 
1160
1198
        tree.lock_write()
1161
1199
        self.addCleanup(tree.unlock)
1162
1200
        tree.add([''], ['TREE_ROOT'])
1163
 
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1201
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id=b'rev1')
1164
1202
        self.b1 = tree.branch
1165
1203
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1166
1204
        self.assertContainsRe(bundle_sio.getvalue(),
1192
1230
        tree.lock_write()
1193
1231
        self.addCleanup(tree.unlock)
1194
1232
        tree.add([''], ['TREE_ROOT'])
1195
 
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1233
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id=b'rev1')
1196
1234
        self.b1 = tree.branch
1197
1235
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1198
1236
        txt = bundle_sio.getvalue()
1199
1237
        loc = txt.find('#   empty: ') + len('#   empty:')
1200
1238
        # Create a new bundle, which strips the trailing space after empty
1201
 
        bundle_sio = StringIO(txt[:loc] + txt[loc+1:])
 
1239
        bundle_sio = BytesIO(txt[:loc] + txt[loc+1:])
1202
1240
 
1203
1241
        self.assertContainsRe(bundle_sio.getvalue(),
1204
1242
                              '# properties:\n'
1220
1258
        self.addCleanup(tree.unlock)
1221
1259
 
1222
1260
        tree.add([''], ['TREE_ROOT'])
1223
 
        tree.commit('One', rev_id='rev1',
 
1261
        tree.commit('One', rev_id=b'rev1',
1224
1262
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
1225
1263
        self.b1 = tree.branch
1226
1264
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1251
1289
        # whitespace.
1252
1290
        # However, Testaments assert than they are str(), and thus should not
1253
1291
        # be Unicode.
1254
 
        tree.commit('One', rev_id='rev1',
 
1292
        tree.commit('One', rev_id=b'rev1',
1255
1293
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
1256
1294
        self.b1 = tree.branch
1257
1295
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
1319
1357
            self.assertEqual(len(branch_rev.parent_ids),
1320
1358
                             len(bundle_rev.parent_ids))
1321
1359
        self.assertEqual(set(rev_ids),
1322
 
                         set([r.revision_id for r in bundle.real_revisions]))
 
1360
                         {r.revision_id for r in bundle.real_revisions})
1323
1361
        self.valid_apply_bundle(base_rev_id, bundle,
1324
1362
                                   checkout_dir=checkout_dir)
1325
1363
 
1331
1369
 
1332
1370
        :return: The in-memory bundle
1333
1371
        """
1334
 
        from bzrlib.bundle import serializer
 
1372
        from ..bundle import serializer
1335
1373
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1336
 
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1374
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
1337
1375
        new_text = new_text.replace('<file file_id="exe-1"',
1338
1376
                                    '<file executable="y" file_id="exe-1"')
1339
1377
        new_text = new_text.replace('B260', 'B275')
1340
 
        bundle_txt = StringIO()
 
1378
        bundle_txt = BytesIO()
1341
1379
        bundle_txt.write(serializer._get_bundle_header('4'))
1342
1380
        bundle_txt.write('\n')
1343
1381
        bundle_txt.write(new_text.encode('bz2'))
1347
1385
        return bundle
1348
1386
 
1349
1387
    def create_bundle_text(self, base_rev_id, rev_id):
1350
 
        bundle_txt = StringIO()
 
1388
        bundle_txt = BytesIO()
1351
1389
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id,
1352
1390
                               bundle_txt, format=self.format)
1353
1391
        bundle_txt.seek(0)
1365
1403
 
1366
1404
    def test_creation(self):
1367
1405
        tree = self.make_branch_and_tree('tree')
1368
 
        self.build_tree_contents([('tree/file', 'contents1\nstatic\n')])
 
1406
        self.build_tree_contents([('tree/file', b'contents1\nstatic\n')])
1369
1407
        tree.add('file', 'fileid-2')
1370
 
        tree.commit('added file', rev_id='rev1')
1371
 
        self.build_tree_contents([('tree/file', 'contents2\nstatic\n')])
1372
 
        tree.commit('changed file', rev_id='rev2')
1373
 
        s = StringIO()
 
1408
        tree.commit('added file', rev_id=b'rev1')
 
1409
        self.build_tree_contents([('tree/file', b'contents2\nstatic\n')])
 
1410
        tree.commit('changed file', rev_id=b'rev2')
 
1411
        s = BytesIO()
1374
1412
        serializer = BundleSerializerV4('1.0')
1375
1413
        serializer.write(tree.branch.repository, ['rev1', 'rev2'], {}, s)
1376
1414
        s.seek(0)
1406
1444
 
1407
1445
    def test_copy_signatures(self):
1408
1446
        tree_a = self.make_branch_and_tree('tree_a')
1409
 
        import bzrlib.gpg
1410
 
        import bzrlib.commit as commit
1411
 
        oldstrategy = bzrlib.gpg.GPGStrategy
 
1447
        import breezy.gpg
 
1448
        import breezy.commit as commit
 
1449
        oldstrategy = breezy.gpg.GPGStrategy
1412
1450
        branch = tree_a.branch
1413
1451
        repo_a = branch.repository
1414
 
        tree_a.commit("base", allow_pointless=True, rev_id='A')
1415
 
        self.failIf(branch.repository.has_signature_for_revision_id('A'))
 
1452
        tree_a.commit("base", allow_pointless=True, rev_id=b'A')
 
1453
        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
1416
1454
        try:
1417
 
            from bzrlib.testament import Testament
 
1455
            from ..testament import Testament
1418
1456
            # monkey patch gpg signing mechanism
1419
 
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
1420
 
            new_config = test_commit.MustSignConfig(branch)
1421
 
            commit.Commit(config=new_config).commit(message="base",
 
1457
            breezy.gpg.GPGStrategy = breezy.gpg.LoopbackGPGStrategy
 
1458
            new_config = test_commit.MustSignConfig()
 
1459
            commit.Commit(config_stack=new_config).commit(message="base",
1422
1460
                                                    allow_pointless=True,
1423
 
                                                    rev_id='B',
 
1461
                                                    rev_id=b'B',
1424
1462
                                                    working_tree=tree_a)
1425
1463
            def sign(text):
1426
 
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
 
1464
                return breezy.gpg.LoopbackGPGStrategy(None).sign(text)
1427
1465
            self.assertTrue(repo_a.has_signature_for_revision_id('B'))
1428
1466
        finally:
1429
 
            bzrlib.gpg.GPGStrategy = oldstrategy
 
1467
            breezy.gpg.GPGStrategy = oldstrategy
1430
1468
        tree_b = self.make_branch_and_tree('tree_b')
1431
1469
        repo_b = tree_b.branch.repository
1432
 
        s = StringIO()
 
1470
        s = BytesIO()
1433
1471
        serializer = BundleSerializerV4('4')
1434
1472
        serializer.write(tree_a.branch.repository, ['A', 'B'], {}, s)
1435
1473
        s.seek(0)
1442
1480
        install_bundle(repo_b, serializer.read(s))
1443
1481
 
1444
1482
 
1445
 
class V4WeaveBundleTester(V4BundleTester):
1446
 
 
1447
 
    def bzrdir_format(self):
1448
 
        return 'metaweave'
1449
 
 
1450
 
 
1451
1483
class V4_2aBundleTester(V4BundleTester):
1452
1484
 
1453
1485
    def bzrdir_format(self):
1459
1491
 
1460
1492
        :return: The in-memory bundle
1461
1493
        """
1462
 
        from bzrlib.bundle import serializer
 
1494
        from ..bundle import serializer
1463
1495
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1464
 
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1496
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
1465
1497
        # We are going to be replacing some text to set the executable bit on a
1466
1498
        # file. Make sure the text replacement actually works correctly.
1467
1499
        self.assertContainsRe(new_text, '(?m)B244\n\ni 1\n<inventory')
1468
1500
        new_text = new_text.replace('<file file_id="exe-1"',
1469
1501
                                    '<file executable="y" file_id="exe-1"')
1470
1502
        new_text = new_text.replace('B244', 'B259')
1471
 
        bundle_txt = StringIO()
 
1503
        bundle_txt = BytesIO()
1472
1504
        bundle_txt.write(serializer._get_bundle_header('4'))
1473
1505
        bundle_txt.write('\n')
1474
1506
        bundle_txt.write(new_text.encode('bz2'))
1480
1512
    def make_merged_branch(self):
1481
1513
        builder = self.make_branch_builder('source')
1482
1514
        builder.start_series()
1483
 
        builder.build_snapshot('a@cset-0-1', None, [
 
1515
        builder.build_snapshot(None, [
1484
1516
            ('add', ('', 'root-id', 'directory', None)),
1485
1517
            ('add', ('file', 'file-id', 'file', 'original content\n')),
1486
 
            ])
1487
 
        builder.build_snapshot('a@cset-0-2a', ['a@cset-0-1'], [
1488
 
            ('modify', ('file-id', 'new-content\n')),
1489
 
            ])
1490
 
        builder.build_snapshot('a@cset-0-2b', ['a@cset-0-1'], [
1491
 
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
1492
 
            ])
1493
 
        builder.build_snapshot('a@cset-0-3', ['a@cset-0-2a', 'a@cset-0-2b'], [
1494
 
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
1495
 
            ])
 
1518
            ], revision_id='a@cset-0-1')
 
1519
        builder.build_snapshot(['a@cset-0-1'], [
 
1520
            ('modify', ('file', 'new-content\n')),
 
1521
            ], revision_id='a@cset-0-2a')
 
1522
        builder.build_snapshot(['a@cset-0-1'], [
 
1523
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
 
1524
            ], revision_id='a@cset-0-2b')
 
1525
        builder.build_snapshot(['a@cset-0-2a', 'a@cset-0-2b'], [
 
1526
            ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
 
1527
            ], revision_id='a@cset-0-3')
1496
1528
        builder.finish_series()
1497
1529
        self.b1 = builder.get_branch()
1498
1530
        self.b1.lock_read()
1501
1533
    def make_bundle_just_inventories(self, base_revision_id,
1502
1534
                                     target_revision_id,
1503
1535
                                     revision_ids):
1504
 
        sio = StringIO()
 
1536
        sio = BytesIO()
1505
1537
        writer = v4.BundleWriteOperation(base_revision_id, target_revision_id,
1506
1538
                                         self.b1.repository, sio)
1507
1539
        writer.bundle.begin()
1624
1656
 
1625
1657
    def test_creating_bundle_preserves_chk_pages(self):
1626
1658
        self.make_merged_branch()
1627
 
        target = self.b1.bzrdir.sprout('target',
 
1659
        target = self.b1.controldir.sprout('target',
1628
1660
                                       revision_id='a@cset-0-2a').open_branch()
1629
1661
        bundle_txt, rev_ids = self.create_bundle_text('a@cset-0-2a',
1630
1662
                                                      'a@cset-0-3')
1649
1681
 
1650
1682
        self.build_tree(['b1/one'])
1651
1683
        wt.add('one')
1652
 
        wt.commit('add one', rev_id='a@cset-0-1')
 
1684
        wt.commit('add one', rev_id=b'a@cset-0-1')
1653
1685
        self.build_tree(['b1/two'])
1654
1686
        wt.add('two')
1655
 
        wt.commit('add two', rev_id='a@cset-0-2',
 
1687
        wt.commit('add two', rev_id=b'a@cset-0-2',
1656
1688
                  revprops={'branch-nick':'test'})
1657
1689
 
1658
 
        bundle_txt = StringIO()
 
1690
        bundle_txt = BytesIO()
1659
1691
        rev_ids = write_bundle(wt.branch.repository, 'a@cset-0-2',
1660
1692
                               'a@cset-0-1', bundle_txt, self.format)
1661
 
        self.assertEqual(set(['a@cset-0-2']), set(rev_ids))
 
1693
        self.assertEqual({'a@cset-0-2'}, set(rev_ids))
1662
1694
        bundle_txt.seek(0, 0)
1663
1695
        return bundle_txt
1664
1696
 
1708
1740
        # creates a blank line at the end, and fails if that
1709
1741
        # line is stripped
1710
1742
        self.assertEqual('\n\n', raw[-2:])
1711
 
        bundle_txt = StringIO(raw[:-1])
 
1743
        bundle_txt = BytesIO(raw[:-1])
1712
1744
 
1713
1745
        bundle = read_bundle(bundle_txt)
1714
1746
        self.check_valid(bundle)
1716
1748
    def test_opening_text(self):
1717
1749
        bundle_txt = self.build_test_bundle()
1718
1750
 
1719
 
        bundle_txt = StringIO("Some random\nemail comments\n"
1720
 
                              + bundle_txt.getvalue())
 
1751
        bundle_txt = BytesIO(
 
1752
            b"Some random\nemail comments\n" + bundle_txt.getvalue())
1721
1753
 
1722
1754
        bundle = read_bundle(bundle_txt)
1723
1755
        self.check_valid(bundle)
1725
1757
    def test_trailing_text(self):
1726
1758
        bundle_txt = self.build_test_bundle()
1727
1759
 
1728
 
        bundle_txt = StringIO(bundle_txt.getvalue() +
1729
 
                              "Some trailing\nrandom\ntext\n")
 
1760
        bundle_txt = BytesIO(
 
1761
            bundle_txt.getvalue() + b"Some trailing\nrandom\ntext\n")
1730
1762
 
1731
1763
        bundle = read_bundle(bundle_txt)
1732
1764
        self.check_valid(bundle)
1740
1772
class TestBundleWriterReader(tests.TestCase):
1741
1773
 
1742
1774
    def test_roundtrip_record(self):
1743
 
        fileobj = StringIO()
 
1775
        fileobj = BytesIO()
1744
1776
        writer = v4.BundleWriter(fileobj)
1745
1777
        writer.begin()
1746
1778
        writer.add_info_record(foo='bar')
1750
1782
        fileobj.seek(0)
1751
1783
        reader = v4.BundleReader(fileobj, stream_input=True)
1752
1784
        record_iter = reader.iter_records()
1753
 
        record = record_iter.next()
 
1785
        record = next(record_iter)
1754
1786
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
1755
1787
            'info', None, None), record)
1756
 
        record = record_iter.next()
 
1788
        record = next(record_iter)
1757
1789
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
1758
1790
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
1759
1791
                          record)
1760
1792
 
1761
1793
    def test_roundtrip_record_memory_hungry(self):
1762
 
        fileobj = StringIO()
 
1794
        fileobj = BytesIO()
1763
1795
        writer = v4.BundleWriter(fileobj)
1764
1796
        writer.begin()
1765
1797
        writer.add_info_record(foo='bar')
1769
1801
        fileobj.seek(0)
1770
1802
        reader = v4.BundleReader(fileobj, stream_input=False)
1771
1803
        record_iter = reader.iter_records()
1772
 
        record = record_iter.next()
 
1804
        record = next(record_iter)
1773
1805
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
1774
1806
            'info', None, None), record)
1775
 
        record = record_iter.next()
 
1807
        record = next(record_iter)
1776
1808
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
1777
1809
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
1778
1810
                          record)
1794
1826
                         v4.BundleReader.decode_name('info'))
1795
1827
 
1796
1828
    def test_too_many_names(self):
1797
 
        fileobj = StringIO()
 
1829
        fileobj = BytesIO()
1798
1830
        writer = v4.BundleWriter(fileobj)
1799
1831
        writer.begin()
1800
1832
        writer.add_info_record(foo='bar')
1802
1834
        writer.end()
1803
1835
        fileobj.seek(0)
1804
1836
        record_iter = v4.BundleReader(fileobj).iter_records()
1805
 
        record = record_iter.next()
 
1837
        record = next(record_iter)
1806
1838
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
1807
1839
            'info', None, None), record)
1808
 
        self.assertRaises(errors.BadBundle, record_iter.next)
 
1840
        self.assertRaises(errors.BadBundle, next, record_iter)
1809
1841
 
1810
1842
 
1811
1843
class TestReadMergeableFromUrl(tests.TestCaseWithTransport):
1828
1860
    def test_infinite_redirects_are_not_a_bundle(self):
1829
1861
        """If a URL causes TooManyRedirections then NotABundle is raised.
1830
1862
        """
1831
 
        from bzrlib.tests.blackbox.test_push import RedirectingMemoryServer
 
1863
        from .blackbox.test_push import RedirectingMemoryServer
1832
1864
        server = RedirectingMemoryServer()
1833
1865
        self.start_server(server)
1834
1866
        url = server.get_url() + 'infinite-loop'
1839
1871
        bundle, then the ConnectionReset error should be propagated.
1840
1872
        """
1841
1873
        # Instantiate a server that will provoke a ConnectionReset
1842
 
        sock_server = _DisconnectingTCPServer()
 
1874
        sock_server = DisconnectingServer()
1843
1875
        self.start_server(sock_server)
1844
1876
        # We don't really care what the url is since the server will close the
1845
1877
        # connection without interpreting it
1847
1879
        self.assertRaises(errors.ConnectionReset, read_mergeable_from_url, url)
1848
1880
 
1849
1881
 
1850
 
class _DisconnectingTCPServer(object):
1851
 
    """A TCP server that immediately closes any connection made to it."""
1852
 
 
1853
 
    def start_server(self):
1854
 
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1855
 
        self.sock.bind(('127.0.0.1', 0))
1856
 
        self.sock.listen(1)
1857
 
        self.port = self.sock.getsockname()[1]
1858
 
        self.thread = threading.Thread(
1859
 
            name='%s (port %d)' % (self.__class__.__name__, self.port),
1860
 
            target=self.accept_and_close)
1861
 
        self.thread.start()
1862
 
 
1863
 
    def accept_and_close(self):
1864
 
        conn, addr = self.sock.accept()
1865
 
        conn.shutdown(socket.SHUT_RDWR)
1866
 
        conn.close()
 
1882
class DisconnectingHandler(socketserver.BaseRequestHandler):
 
1883
    """A request handler that immediately closes any connection made to it."""
 
1884
 
 
1885
    def handle(self):
 
1886
        self.request.close()
 
1887
 
 
1888
 
 
1889
class DisconnectingServer(test_server.TestingTCPServerInAThread):
 
1890
 
 
1891
    def __init__(self):
 
1892
        super(DisconnectingServer, self).__init__(
 
1893
            ('127.0.0.1', 0),
 
1894
            test_server.TestingTCPServer,
 
1895
            DisconnectingHandler)
1867
1896
 
1868
1897
    def get_url(self):
1869
 
        return 'bzr://127.0.0.1:%d/' % (self.port,)
1870
 
 
1871
 
    def stop_server(self):
1872
 
        try:
1873
 
            # make sure the thread dies by connecting to the listening socket,
1874
 
            # just in case the test failed to do so.
1875
 
            conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1876
 
            conn.connect(self.sock.getsockname())
1877
 
            conn.close()
1878
 
        except socket.error:
1879
 
            pass
1880
 
        self.sock.close()
1881
 
        self.thread.join()
 
1898
        """Return the url of the server"""
 
1899
        return "bzr://%s:%d/" % self.server.server_address