/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-11-16 18:15:40 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181116181540-7y2wbhqzjk067mqy
Fix repo acquisition.

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
 
17
import bz2
 
18
from io import BytesIO
18
19
import os
19
 
import socket
 
20
try:
 
21
    import socketserver
 
22
except ImportError:
 
23
    import SocketServer as socketserver
20
24
import sys
21
 
import threading
22
25
 
23
 
from bzrlib import (
24
 
    bzrdir,
 
26
from .. import (
25
27
    diff,
26
28
    errors,
27
 
    inventory,
28
29
    merge,
29
30
    osutils,
30
 
    repository,
31
31
    revision as _mod_revision,
32
32
    tests,
33
33
    treebuilder,
34
34
    )
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 (
 
35
from ..bzr import (
 
36
    bzrdir,
 
37
    inventory,
 
38
    )
 
39
from ..bundle import read_mergeable_from_url
 
40
from ..bundle.apply_bundle import install_bundle, merge_bundle
 
41
from ..bundle.bundle_data import BundleTree
 
42
from ..directory_service import directories
 
43
from ..bundle.serializer import write_bundle, read_bundle, v09, v4
 
44
from ..bundle.serializer.v08 import BundleSerializerV08
 
45
from ..bundle.serializer.v09 import BundleSerializerV09
 
46
from ..bundle.serializer.v4 import BundleSerializerV4
 
47
from ..bzr import knitrepo
 
48
from . import (
 
49
    features,
 
50
    test_commit,
47
51
    test_read_bundle,
48
 
    test_commit,
 
52
    test_server,
49
53
    )
50
 
from bzrlib.transform import TreeTransform
 
54
from ..transform import TreeTransform
51
55
 
52
56
 
53
57
def get_text(vf, key):
54
58
    """Get the fulltext for a given revision id that is present in the vf"""
55
59
    stream = vf.get_record_stream([key], 'unordered', True)
56
 
    record = stream.next()
 
60
    record = next(stream)
57
61
    return record.get_bytes_as('fulltext')
58
62
 
59
63
 
67
71
 
68
72
 
69
73
class MockTree(object):
 
74
 
70
75
    def __init__(self):
71
 
        from bzrlib.inventory import InventoryDirectory, ROOT_ID
 
76
        from ..bzr.inventory import InventoryDirectory, ROOT_ID
72
77
        object.__init__(self)
73
78
        self.paths = {ROOT_ID: ""}
74
79
        self.ids = {"": ROOT_ID}
75
80
        self.contents = {}
76
81
        self.root = InventoryDirectory(ROOT_ID, '', None)
77
82
 
78
 
    inventory = property(lambda x:x)
79
 
 
80
 
    def __iter__(self):
81
 
        return self.paths.iterkeys()
 
83
    inventory = property(lambda x: x)
 
84
    root_inventory = property(lambda x: x)
 
85
 
 
86
    def get_root_id(self):
 
87
        return self.root.file_id
 
88
 
 
89
    def all_file_ids(self):
 
90
        return set(self.paths.keys())
 
91
 
 
92
    def all_versioned_paths(self):
 
93
        return set(self.paths.values())
 
94
 
 
95
    def is_executable(self, path, file_id):
 
96
        # Not all the files are executable.
 
97
        return False
82
98
 
83
99
    def __getitem__(self, file_id):
84
100
        if file_id == self.root.file_id:
93
109
        return self.ids[parent_dir]
94
110
 
95
111
    def iter_entries(self):
96
 
        for path, file_id in self.ids.iteritems():
 
112
        for path, file_id in self.ids.items():
97
113
            yield path, self[file_id]
98
114
 
99
 
    def get_file_kind(self, file_id):
 
115
    def kind(self, path, file_id=None):
 
116
        if file_id is None:
 
117
            file_id = self.path2id(path)
100
118
        if file_id in self.contents:
101
119
            kind = 'file'
102
120
        else:
104
122
        return kind
105
123
 
106
124
    def make_entry(self, file_id, path):
107
 
        from bzrlib.inventory import (InventoryEntry, InventoryFile
108
 
                                    , InventoryDirectory, InventoryLink)
 
125
        from ..bzr.inventory import (InventoryFile, InventoryDirectory,
 
126
                                     InventoryLink)
 
127
        if not isinstance(file_id, bytes):
 
128
            raise TypeError(file_id)
109
129
        name = os.path.basename(path)
110
 
        kind = self.get_file_kind(file_id)
 
130
        kind = self.kind(path, file_id)
111
131
        parent_id = self.parent_id(file_id)
112
 
        text_sha_1, text_size = self.contents_stats(file_id)
 
132
        text_sha_1, text_size = self.contents_stats(path, file_id)
113
133
        if kind == 'directory':
114
134
            ie = InventoryDirectory(file_id, name, parent_id)
115
135
        elif kind == 'file':
116
136
            ie = InventoryFile(file_id, name, parent_id)
 
137
            ie.text_sha1 = text_sha_1
 
138
            ie.text_size = text_size
117
139
        elif kind == 'symlink':
118
140
            ie = InventoryLink(file_id, name, parent_id)
119
141
        else:
120
142
            raise errors.BzrError('unknown kind %r' % kind)
121
 
        ie.text_sha1 = text_sha_1
122
 
        ie.text_size = text_size
123
143
        return ie
124
144
 
125
145
    def add_dir(self, file_id, path):
 
146
        if not isinstance(file_id, bytes):
 
147
            raise TypeError(file_id)
126
148
        self.paths[file_id] = path
127
149
        self.ids[path] = file_id
128
150
 
129
151
    def add_file(self, file_id, path, contents):
 
152
        if not isinstance(file_id, bytes):
 
153
            raise TypeError(file_id)
130
154
        self.add_dir(file_id, path)
131
155
        self.contents[file_id] = contents
132
156
 
139
163
    def has_id(self, file_id):
140
164
        return self.id2path(file_id) is not None
141
165
 
142
 
    def get_file(self, file_id):
143
 
        result = StringIO()
144
 
        result.write(self.contents[file_id])
145
 
        result.seek(0,0)
 
166
    def get_file(self, path, file_id=None):
 
167
        if file_id is None:
 
168
            file_id = self.path2id(path)
 
169
        result = BytesIO()
 
170
        try:
 
171
            result.write(self.contents[file_id])
 
172
        except KeyError:
 
173
            raise errors.NoSuchFile(path)
 
174
        result.seek(0, 0)
146
175
        return result
147
176
 
148
 
    def contents_stats(self, file_id):
 
177
    def get_file_revision(self, path, file_id=None):
 
178
        if file_id is None:
 
179
            file_id = self.path2id(path)
 
180
        return self.inventory[file_id].revision
 
181
 
 
182
    def get_file_size(self, path, file_id=None):
 
183
        if file_id is None:
 
184
            file_id = self.path2id(path)
 
185
        return self.inventory[file_id].text_size
 
186
 
 
187
    def get_file_sha1(self, path, file_id=None):
 
188
        if file_id is None:
 
189
            file_id = self.path2id(path)
 
190
        return self.inventory[file_id].text_sha1
 
191
 
 
192
    def contents_stats(self, path, file_id):
149
193
        if file_id not in self.contents:
150
194
            return None, None
151
 
        text_sha1 = osutils.sha_file(self.get_file(file_id))
 
195
        text_sha1 = osutils.sha_file(self.get_file(path, file_id))
152
196
        return text_sha1, len(self.contents[file_id])
153
197
 
154
198
 
157
201
 
158
202
    def make_tree_1(self):
159
203
        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")
 
204
        mtree.add_dir(b"a", "grandparent")
 
205
        mtree.add_dir(b"b", "grandparent/parent")
 
206
        mtree.add_file(b"c", "grandparent/parent/file", b"Hello\n")
 
207
        mtree.add_dir(b"d", "grandparent/alt_parent")
164
208
        return BundleTree(mtree, ''), mtree
165
209
 
166
210
    def test_renames(self):
172
216
        self.assertEqual(btree.old_path("grandparent/parent/file"),
173
217
                         "grandparent/parent/file")
174
218
 
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)
 
219
        self.assertEqual(btree.id2path(b"a"), "grandparent")
 
220
        self.assertEqual(btree.id2path(b"b"), "grandparent/parent")
 
221
        self.assertEqual(btree.id2path(b"c"), "grandparent/parent/file")
 
222
 
 
223
        self.assertEqual(btree.path2id("grandparent"), b"a")
 
224
        self.assertEqual(btree.path2id("grandparent/parent"), b"b")
 
225
        self.assertEqual(btree.path2id("grandparent/parent/file"), b"c")
 
226
 
 
227
        self.assertIs(btree.path2id("grandparent2"), None)
 
228
        self.assertIs(btree.path2id("grandparent2/parent"), None)
 
229
        self.assertIs(btree.path2id("grandparent2/parent/file"), None)
186
230
 
187
231
        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")
 
232
        self.assertIs(btree.old_path("grandparent"), None)
 
233
        self.assertIs(btree.old_path("grandparent/parent"), None)
 
234
        self.assertIs(btree.old_path("grandparent/parent/file"), None)
 
235
 
 
236
        self.assertEqual(btree.id2path(b"a"), "grandparent2")
 
237
        self.assertEqual(btree.id2path(b"b"), "grandparent2/parent")
 
238
        self.assertEqual(btree.id2path(b"c"), "grandparent2/parent/file")
 
239
 
 
240
        self.assertEqual(btree.path2id("grandparent2"), b"a")
 
241
        self.assertEqual(btree.path2id("grandparent2/parent"), b"b")
 
242
        self.assertEqual(btree.path2id("grandparent2/parent/file"), b"c")
199
243
 
200
244
        self.assertTrue(btree.path2id("grandparent") is None)
201
245
        self.assertTrue(btree.path2id("grandparent/parent") is None)
202
246
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
203
247
 
204
248
        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")
 
249
        self.assertEqual(btree.id2path(b"a"), "grandparent2")
 
250
        self.assertEqual(btree.id2path(b"b"), "grandparent2/parent2")
 
251
        self.assertEqual(btree.id2path(b"c"), "grandparent2/parent2/file")
208
252
 
209
 
        self.assertEqual(btree.path2id("grandparent2"), "a")
210
 
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
211
 
        self.assertEqual(btree.path2id("grandparent2/parent2/file"), "c")
 
253
        self.assertEqual(btree.path2id("grandparent2"), b"a")
 
254
        self.assertEqual(btree.path2id("grandparent2/parent2"), b"b")
 
255
        self.assertEqual(btree.path2id("grandparent2/parent2/file"), b"c")
212
256
 
213
257
        self.assertTrue(btree.path2id("grandparent2/parent") is None)
214
258
        self.assertTrue(btree.path2id("grandparent2/parent/file") is None)
215
259
 
216
260
        btree.note_rename("grandparent/parent/file",
217
261
                          "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")
 
262
        self.assertEqual(btree.id2path(b"a"), "grandparent2")
 
263
        self.assertEqual(btree.id2path(b"b"), "grandparent2/parent2")
 
264
        self.assertEqual(btree.id2path(b"c"), "grandparent2/parent2/file2")
221
265
 
222
 
        self.assertEqual(btree.path2id("grandparent2"), "a")
223
 
        self.assertEqual(btree.path2id("grandparent2/parent2"), "b")
224
 
        self.assertEqual(btree.path2id("grandparent2/parent2/file2"), "c")
 
266
        self.assertEqual(btree.path2id("grandparent2"), b"a")
 
267
        self.assertEqual(btree.path2id("grandparent2/parent2"), b"b")
 
268
        self.assertEqual(btree.path2id("grandparent2/parent2/file2"), b"c")
225
269
 
226
270
        self.assertTrue(btree.path2id("grandparent2/parent2/file") is None)
227
271
 
230
274
        btree = self.make_tree_1()[0]
231
275
        btree.note_rename("grandparent/parent/file",
232
276
                          "grandparent/alt_parent/file")
233
 
        self.assertEqual(btree.id2path("c"), "grandparent/alt_parent/file")
234
 
        self.assertEqual(btree.path2id("grandparent/alt_parent/file"), "c")
 
277
        self.assertEqual(btree.id2path(b"c"), "grandparent/alt_parent/file")
 
278
        self.assertEqual(btree.path2id("grandparent/alt_parent/file"), b"c")
235
279
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
236
280
 
237
281
    def unified_diff(self, old, new):
238
 
        out = StringIO()
 
282
        out = BytesIO()
239
283
        diff.internal_diff("old", old, "new", new, out)
240
 
        out.seek(0,0)
 
284
        out.seek(0, 0)
241
285
        return out.read()
242
286
 
243
287
    def make_tree_2(self):
244
288
        btree = self.make_tree_1()[0]
245
289
        btree.note_rename("grandparent/parent/file",
246
290
                          "grandparent/alt_parent/file")
247
 
        self.assertTrue(btree.id2path("e") is None)
248
 
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
249
 
        btree.note_id("e", "grandparent/parent/file")
 
291
        self.assertTrue(btree.id2path(b"e") is None)
 
292
        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
 
293
        btree.note_id(b"e", "grandparent/parent/file")
250
294
        return btree
251
295
 
252
296
    def test_adds(self):
253
297
        """File/inventory adds"""
254
298
        btree = self.make_tree_2()
255
 
        add_patch = self.unified_diff([], ["Extra cheese\n"])
 
299
        add_patch = self.unified_diff([], [b"Extra cheese\n"])
256
300
        btree.note_patch("grandparent/parent/file", add_patch)
257
 
        btree.note_id('f', 'grandparent/parent/symlink', kind='symlink')
 
301
        btree.note_id(b'f', 'grandparent/parent/symlink', kind='symlink')
258
302
        btree.note_target('grandparent/parent/symlink', 'venus')
259
303
        self.adds_test(btree)
260
304
 
261
305
    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')
 
306
        self.assertEqual(btree.id2path(b"e"), "grandparent/parent/file")
 
307
        self.assertEqual(btree.path2id("grandparent/parent/file"), b"e")
 
308
        with btree.get_file("grandparent/parent/file") as f:
 
309
            self.assertEqual(f.read(), b"Extra cheese\n")
 
310
        self.assertEqual(
 
311
            btree.get_symlink_target('grandparent/parent/symlink'), 'venus')
266
312
 
267
313
    def test_adds2(self):
268
314
        """File/inventory adds, with patch-compatibile renames"""
269
315
        btree = self.make_tree_2()
270
316
        btree.contents_by_id = False
271
 
        add_patch = self.unified_diff(["Hello\n"], ["Extra cheese\n"])
 
317
        add_patch = self.unified_diff([b"Hello\n"], [b"Extra cheese\n"])
272
318
        btree.note_patch("grandparent/parent/file", add_patch)
273
 
        btree.note_id('f', 'grandparent/parent/symlink', kind='symlink')
 
319
        btree.note_id(b'f', 'grandparent/parent/symlink', kind='symlink')
274
320
        btree.note_target('grandparent/parent/symlink', 'venus')
275
321
        self.adds_test(btree)
276
322
 
277
323
    def make_tree_3(self):
278
324
        btree, mtree = self.make_tree_1()
279
 
        mtree.add_file("e", "grandparent/parent/topping", "Anchovies\n")
 
325
        mtree.add_file(b"e", "grandparent/parent/topping", b"Anchovies\n")
280
326
        btree.note_rename("grandparent/parent/file",
281
327
                          "grandparent/alt_parent/file")
282
328
        btree.note_rename("grandparent/parent/topping",
284
330
        return btree
285
331
 
286
332
    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")
 
333
        with btree.get_file(btree.id2path(b"e")) as f:
 
334
            self.assertEqual(f.read(), b"Lemon\n")
 
335
        with btree.get_file(btree.id2path(b"c")) as f:
 
336
            self.assertEqual(f.read(), b"Hello\n")
289
337
 
290
338
    def test_get_file(self):
291
339
        """Get file contents"""
292
340
        btree = self.make_tree_3()
293
 
        mod_patch = self.unified_diff(["Anchovies\n"], ["Lemon\n"])
 
341
        mod_patch = self.unified_diff([b"Anchovies\n"], [b"Lemon\n"])
294
342
        btree.note_patch("grandparent/alt_parent/stopping", mod_patch)
295
343
        self.get_file_test(btree)
296
344
 
297
345
    def test_get_file2(self):
298
 
        """Get file contents, with patch-compatibile renames"""
 
346
        """Get file contents, with patch-compatible renames"""
299
347
        btree = self.make_tree_3()
300
348
        btree.contents_by_id = False
301
 
        mod_patch = self.unified_diff([], ["Lemon\n"])
 
349
        mod_patch = self.unified_diff([], [b"Lemon\n"])
302
350
        btree.note_patch("grandparent/alt_parent/stopping", mod_patch)
303
 
        mod_patch = self.unified_diff([], ["Hello\n"])
 
351
        mod_patch = self.unified_diff([], [b"Hello\n"])
304
352
        btree.note_patch("grandparent/alt_parent/file", mod_patch)
305
353
        self.get_file_test(btree)
306
354
 
307
355
    def test_delete(self):
308
356
        "Deletion by bundle"
309
357
        btree = self.make_tree_1()[0]
310
 
        self.assertEqual(btree.get_file("c").read(), "Hello\n")
 
358
        with btree.get_file(btree.id2path(b"c")) as f:
 
359
            self.assertEqual(f.read(), b"Hello\n")
311
360
        btree.note_deletion("grandparent/parent/file")
312
 
        self.assertTrue(btree.id2path("c") is None)
313
 
        self.assertTrue(btree.path2id("grandparent/parent/file") is None)
 
361
        self.assertTrue(btree.id2path(b"c") is None)
 
362
        self.assertFalse(btree.is_versioned("grandparent/parent/file"))
314
363
 
315
364
    def sorted_ids(self, tree):
316
 
        ids = list(tree)
317
 
        ids.sort()
 
365
        ids = sorted(tree.all_file_ids())
318
366
        return ids
319
367
 
320
368
    def test_iteration(self):
321
369
        """Ensure that iteration through ids works properly"""
322
370
        btree = self.make_tree_1()[0]
323
371
        self.assertEqual(self.sorted_ids(btree),
324
 
            [inventory.ROOT_ID, 'a', 'b', 'c', 'd'])
 
372
                         [inventory.ROOT_ID, b'a', b'b', b'c', b'd'])
325
373
        btree.note_deletion("grandparent/parent/file")
326
 
        btree.note_id("e", "grandparent/alt_parent/fool", kind="directory")
 
374
        btree.note_id(b"e", "grandparent/alt_parent/fool", kind="directory")
327
375
        btree.note_last_changed("grandparent/alt_parent/fool",
328
376
                                "revisionidiguess")
329
377
        self.assertEqual(self.sorted_ids(btree),
330
 
            [inventory.ROOT_ID, 'a', 'b', 'd', 'e'])
 
378
                         [inventory.ROOT_ID, b'a', b'b', b'd', b'e'])
331
379
 
332
380
 
333
381
class BundleTester1(tests.TestCaseWithTransport):
338
386
        serializer = BundleSerializerV08('0.8')
339
387
        b = self.make_branch('.', format=format)
340
388
        self.assertRaises(errors.IncompatibleBundleFormat, serializer.write,
341
 
                          b.repository, [], {}, StringIO())
 
389
                          b.repository, [], {}, BytesIO())
342
390
 
343
391
    def test_matched_bundle(self):
344
392
        """Don't raise IncompatibleBundleFormat for knit2 and bundle0.9"""
346
394
        format.repository_format = knitrepo.RepositoryFormatKnit3()
347
395
        serializer = BundleSerializerV09('0.9')
348
396
        b = self.make_branch('.', format=format)
349
 
        serializer.write(b.repository, [], {}, StringIO())
 
397
        serializer.write(b.repository, [], {}, BytesIO())
350
398
 
351
399
    def test_mismatched_model(self):
352
400
        """Try copying a bundle from knit2 to knit1"""
353
401
        format = bzrdir.BzrDirMetaFormat1()
354
402
        format.repository_format = knitrepo.RepositoryFormatKnit3()
355
403
        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()
359
 
        write_bundle(source.branch.repository, 'two-id', 'null:', text,
 
404
        source.commit('one', rev_id=b'one-id')
 
405
        source.commit('two', rev_id=b'two-id')
 
406
        text = BytesIO()
 
407
        write_bundle(source.branch.repository, b'two-id', b'null:', text,
360
408
                     format='0.9')
361
409
        text.seek(0)
362
410
 
386
434
        return tests.TestCaseWithTransport.make_branch(self, path, format)
387
435
 
388
436
    def create_bundle_text(self, base_rev_id, rev_id):
389
 
        bundle_txt = StringIO()
 
437
        bundle_txt = BytesIO()
390
438
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id,
391
439
                               bundle_txt, format=self.format)
392
440
        bundle_txt.seek(0)
393
441
        self.assertEqual(bundle_txt.readline(),
394
 
                         '# Bazaar revision bundle v%s\n' % self.format)
395
 
        self.assertEqual(bundle_txt.readline(), '#\n')
 
442
                         b'# Bazaar revision bundle v%s\n' % self.format.encode('ascii'))
 
443
        self.assertEqual(bundle_txt.readline(), b'#\n')
396
444
 
397
445
        rev = self.b1.repository.get_revision(rev_id)
398
446
        self.assertEqual(bundle_txt.readline().decode('utf-8'),
427
475
                             len(bundle_rev.parent_ids))
428
476
        self.assertEqual(rev_ids,
429
477
                         [r.revision_id for r in bundle.real_revisions])
430
 
        self.valid_apply_bundle(base_rev_id, bundle,
431
 
                                   checkout_dir=checkout_dir)
 
478
        self.valid_apply_bundle(base_rev_id, bundle, checkout_dir=checkout_dir)
432
479
 
433
480
        return bundle
434
481
 
439
486
        :return: The in-memory bundle
440
487
        """
441
488
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
442
 
        new_text = bundle_txt.getvalue().replace('executable:no',
443
 
                                               'executable:yes')
444
 
        bundle_txt = StringIO(new_text)
 
489
        new_text = bundle_txt.getvalue().replace(b'executable:no',
 
490
                                                 b'executable:yes')
 
491
        bundle_txt = BytesIO(new_text)
445
492
        bundle = read_bundle(bundle_txt)
446
493
        self.valid_apply_bundle(base_rev_id, bundle)
447
494
        return bundle
448
495
 
449
496
    def test_non_bundle(self):
450
497
        self.assertRaises(errors.NotABundle,
451
 
                          read_bundle, StringIO('#!/bin/sh\n'))
 
498
                          read_bundle, BytesIO(b'#!/bin/sh\n'))
452
499
 
453
500
    def test_malformed(self):
454
501
        self.assertRaises(errors.BadBundle, read_bundle,
455
 
                          StringIO('# Bazaar revision bundle v'))
 
502
                          BytesIO(b'# Bazaar revision bundle v'))
456
503
 
457
504
    def test_crlf_bundle(self):
458
505
        try:
459
 
            read_bundle(StringIO('# Bazaar revision bundle v0.8\r\n'))
 
506
            read_bundle(BytesIO(b'# Bazaar revision bundle v0.8\r\n'))
460
507
        except errors.BadBundle:
461
508
            # It is currently permitted for bundles with crlf line endings to
462
509
            # make read_bundle raise a BadBundle, but this should be fixed.
473
520
            if not os.path.exists(checkout_dir):
474
521
                os.mkdir(checkout_dir)
475
522
        tree = self.make_branch_and_tree(checkout_dir)
476
 
        s = StringIO()
477
 
        ancestors = write_bundle(self.b1.repository, rev_id, 'null:', s,
 
523
        s = BytesIO()
 
524
        ancestors = write_bundle(self.b1.repository, rev_id, b'null:', s,
478
525
                                 format=self.format)
479
526
        s.seek(0)
480
 
        self.assertIsInstance(s.getvalue(), str)
 
527
        self.assertIsInstance(s.getvalue(), bytes)
481
528
        install_bundle(tree.branch.repository, read_bundle(s))
482
529
        for ancestor in ancestors:
483
530
            old = self.b1.repository.revision_tree(ancestor)
492
539
                                 % (ancestor,))
493
540
 
494
541
                # Now check that the file contents are all correct
495
 
                for inventory_id in old:
 
542
                for path in old.all_versioned_paths():
496
543
                    try:
497
 
                        old_file = old.get_file(inventory_id)
 
544
                        old_file = old.get_file(path)
498
545
                    except errors.NoSuchFile:
499
546
                        continue
500
 
                    if old_file is None:
501
 
                        continue
502
 
                    self.assertEqual(old_file.read(),
503
 
                                     new.get_file(inventory_id).read())
 
547
                    self.assertEqual(
 
548
                        old_file.read(), new.get_file(path).read())
504
549
            finally:
505
550
                new.unlock()
506
551
                old.unlock()
507
552
        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])
 
553
            tree.branch.generate_revision_history(rev_id)
510
554
            tree.update()
511
555
            delta = tree.changes_from(self.b1.repository.revision_tree(rev_id))
512
556
            self.assertFalse(delta.has_changed(),
530
574
        original_parents = to_tree.get_parent_ids()
531
575
        self.assertIs(repository.has_revision(base_rev_id), True)
532
576
        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)
 
577
            self.assertTrue(not repository.has_revision(rev.revision_id),
 
578
                            'Revision {%s} present before applying bundle'
 
579
                            % rev.revision_id)
536
580
        merge_bundle(info, to_tree, True, merge.Merge3Merger, False, False)
537
581
 
538
582
        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)
 
583
            self.assertTrue(repository.has_revision(rev.revision_id),
 
584
                            'Missing revision {%s} after applying bundle'
 
585
                            % rev.revision_id)
542
586
 
543
 
        self.assert_(to_tree.branch.repository.has_revision(info.target))
 
587
        self.assertTrue(to_tree.branch.repository.has_revision(info.target))
544
588
        # Do we also want to verify that all the texts have been added?
545
589
 
546
590
        self.assertEqual(original_parents + [info.target],
547
 
            to_tree.get_parent_ids())
 
591
                         to_tree.get_parent_ids())
548
592
 
549
593
        rev = info.real_revisions[-1]
550
594
        base_tree = self.b1.repository.revision_tree(rev.revision_id)
561
605
 
562
606
        for path, status, kind, fileid, entry in base_files:
563
607
            # 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))
 
608
            self.assertEqual(base_tree.get_file_size(path, fileid),
 
609
                             to_tree.get_file_size(to_tree.id2path(fileid)))
 
610
            self.assertEqual(base_tree.get_file_sha1(path, fileid),
 
611
                             to_tree.get_file_sha1(to_tree.id2path(fileid)))
568
612
            # Check that the contents are the same
569
613
            # This is pretty expensive
570
614
            # self.assertEqual(base_tree.get_file(fileid).read(),
574
618
        self.tree1 = self.make_branch_and_tree('b1')
575
619
        self.b1 = self.tree1.branch
576
620
 
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')
 
621
        self.build_tree_contents([('b1/one', b'one\n')])
 
622
        self.tree1.add('one', b'one-id')
 
623
        self.tree1.set_root_id(b'root-id')
 
624
        self.tree1.commit('add one', rev_id=b'a@cset-0-1')
581
625
 
582
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-1')
 
626
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-1')
583
627
 
584
628
        # Make sure we can handle files with spaces, tabs, other
585
629
        # bogus characters
586
630
        self.build_tree([
587
 
                'b1/with space.txt'
588
 
                , 'b1/dir/'
589
 
                , 'b1/dir/filein subdir.c'
590
 
                , 'b1/dir/WithCaps.txt'
591
 
                , 'b1/dir/ pre space'
592
 
                , 'b1/sub/'
593
 
                , 'b1/sub/sub/'
594
 
                , 'b1/sub/sub/nonempty.txt'
595
 
                ])
596
 
        self.build_tree_contents([('b1/sub/sub/emptyfile.txt', ''),
597
 
                                  ('b1/dir/nolastnewline.txt', 'bloop')])
 
631
            'b1/with space.txt', 'b1/dir/', 'b1/dir/filein subdir.c', 'b1/dir/WithCaps.txt', 'b1/dir/ pre space', 'b1/sub/', 'b1/sub/sub/', 'b1/sub/sub/nonempty.txt'
 
632
            ])
 
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
 
        tt.new_file('executable', tt.root, '#!/bin/sh\n', 'exe-1', True)
 
636
        tt.new_file('executable', tt.root, [b'#!/bin/sh\n'], b'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
 
                  'dir'
606
 
                , 'dir/filein subdir.c'
607
 
                , 'dir/WithCaps.txt'
608
 
                , 'dir/ pre space'
609
 
                , 'dir/nolastnewline.txt'
610
 
                , 'sub'
611
 
                , 'sub/sub'
612
 
                , 'sub/sub/nonempty.txt'
613
 
                , 'sub/sub/emptyfile.txt'
614
 
                ])
615
 
        self.tree1.commit('add whitespace', rev_id='a@cset-0-2')
 
642
            'dir', 'dir/filein subdir.c', 'dir/WithCaps.txt', 'dir/ pre space', 'dir/nolastnewline.txt', 'sub', 'sub/sub', 'sub/sub/nonempty.txt', 'sub/sub/emptyfile.txt'
 
643
            ])
 
644
        self.tree1.commit('add whitespace', rev_id=b'a@cset-0-2')
616
645
 
617
 
        bundle = self.get_valid_bundle('a@cset-0-1', 'a@cset-0-2')
 
646
        bundle = self.get_valid_bundle(b'a@cset-0-1', b'a@cset-0-2')
618
647
 
619
648
        # Check a rollup bundle
620
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-2')
 
649
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-2')
621
650
 
622
651
        # Now delete entries
623
652
        self.tree1.remove(
624
 
                ['sub/sub/nonempty.txt'
625
 
                , 'sub/sub/emptyfile.txt'
626
 
                , 'sub/sub'
627
 
                ])
 
653
            ['sub/sub/nonempty.txt', 'sub/sub/emptyfile.txt', 'sub/sub'
 
654
             ])
628
655
        tt = TreeTransform(self.tree1)
629
 
        trans_id = tt.trans_id_tree_file_id('exe-1')
 
656
        trans_id = tt.trans_id_tree_path('executable')
630
657
        tt.set_executability(False, trans_id)
631
658
        tt.apply()
632
 
        self.tree1.commit('removed', rev_id='a@cset-0-3')
 
659
        self.tree1.commit('removed', rev_id=b'a@cset-0-3')
633
660
 
634
 
        bundle = self.get_valid_bundle('a@cset-0-2', 'a@cset-0-3')
 
661
        bundle = self.get_valid_bundle(b'a@cset-0-2', b'a@cset-0-3')
635
662
        self.assertRaises((errors.TestamentMismatch,
636
 
            errors.VersionedFileInvalidChecksum,
637
 
            errors.BadBundle), self.get_invalid_bundle,
638
 
            'a@cset-0-2', 'a@cset-0-3')
 
663
                           errors.VersionedFileInvalidChecksum,
 
664
                           errors.BadBundle), self.get_invalid_bundle,
 
665
                          b'a@cset-0-2', b'a@cset-0-3')
639
666
        # Check a rollup bundle
640
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-3')
 
667
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-3')
641
668
 
642
669
        # Now move the directory
643
670
        self.tree1.rename_one('dir', 'sub/dir')
644
 
        self.tree1.commit('rename dir', rev_id='a@cset-0-4')
 
671
        self.tree1.commit('rename dir', rev_id=b'a@cset-0-4')
645
672
 
646
 
        bundle = self.get_valid_bundle('a@cset-0-3', 'a@cset-0-4')
 
673
        bundle = self.get_valid_bundle(b'a@cset-0-3', b'a@cset-0-4')
647
674
        # Check a rollup bundle
648
 
        bundle = self.get_valid_bundle('null:', 'a@cset-0-4')
 
675
        bundle = self.get_valid_bundle(b'null:', b'a@cset-0-4')
649
676
 
650
677
        # Modified files
651
 
        open('b1/sub/dir/WithCaps.txt', 'ab').write('\nAdding some text\n')
652
 
        open('b1/sub/dir/ pre space', 'ab').write(
653
 
             '\r\nAdding some\r\nDOS format lines\r\n')
654
 
        open('b1/sub/dir/nolastnewline.txt', 'ab').write('\n')
 
678
        with open('b1/sub/dir/WithCaps.txt', 'ab') as f:
 
679
            f.write(b'\nAdding some text\n')
 
680
        with open('b1/sub/dir/ pre space', 'ab') as f:
 
681
            f.write(
 
682
                b'\r\nAdding some\r\nDOS format lines\r\n')
 
683
        with open('b1/sub/dir/nolastnewline.txt', 'ab') as f:
 
684
            f.write(b'\n')
655
685
        self.tree1.rename_one('sub/dir/ pre space',
656
686
                              'sub/ start space')
657
 
        self.tree1.commit('Modified files', rev_id='a@cset-0-5')
658
 
        bundle = self.get_valid_bundle('a@cset-0-4', 'a@cset-0-5')
 
687
        self.tree1.commit('Modified files', rev_id=b'a@cset-0-5')
 
688
        bundle = self.get_valid_bundle(b'a@cset-0-4', b'a@cset-0-5')
659
689
 
660
690
        self.tree1.rename_one('sub/dir/WithCaps.txt', 'temp')
661
691
        self.tree1.rename_one('with space.txt', 'WithCaps.txt')
662
692
        self.tree1.rename_one('temp', 'with space.txt')
663
 
        self.tree1.commit(u'swap filenames', rev_id='a@cset-0-6',
 
693
        self.tree1.commit(u'swap filenames', rev_id=b'a@cset-0-6',
664
694
                          verbose=False)
665
 
        bundle = self.get_valid_bundle('a@cset-0-5', 'a@cset-0-6')
666
 
        other = self.get_checkout('a@cset-0-5')
 
695
        bundle = self.get_valid_bundle(b'a@cset-0-5', b'a@cset-0-6')
 
696
        other = self.get_checkout(b'a@cset-0-5')
667
697
        tree1_inv = get_inventory_text(self.tree1.branch.repository,
668
 
                                       'a@cset-0-5')
 
698
                                       b'a@cset-0-5')
669
699
        tree2_inv = get_inventory_text(other.branch.repository,
670
 
                                       'a@cset-0-5')
 
700
                                       b'a@cset-0-5')
671
701
        self.assertEqualDiff(tree1_inv, tree2_inv)
672
702
        other.rename_one('sub/dir/nolastnewline.txt', 'sub/nolastnewline.txt')
673
 
        other.commit('rename file', rev_id='a@cset-0-6b')
 
703
        other.commit('rename file', rev_id=b'a@cset-0-6b')
674
704
        self.tree1.merge_from_branch(other.branch)
675
 
        self.tree1.commit(u'Merge', rev_id='a@cset-0-7',
 
705
        self.tree1.commit(u'Merge', rev_id=b'a@cset-0-7',
676
706
                          verbose=False)
677
 
        bundle = self.get_valid_bundle('a@cset-0-6', 'a@cset-0-7')
 
707
        bundle = self.get_valid_bundle(b'a@cset-0-6', b'a@cset-0-7')
678
708
 
679
709
    def _test_symlink_bundle(self, link_name, link_target, new_link_target):
680
 
        link_id = 'link-1'
 
710
        link_id = b'link-1'
681
711
 
682
 
        self.requireFeature(tests.SymlinkFeature)
 
712
        self.requireFeature(features.SymlinkFeature)
683
713
        self.tree1 = self.make_branch_and_tree('b1')
684
714
        self.b1 = self.tree1.branch
685
715
 
686
716
        tt = TreeTransform(self.tree1)
687
717
        tt.new_symlink(link_name, tt.root, link_target, link_id)
688
718
        tt.apply()
689
 
        self.tree1.commit('add symlink', rev_id='l@cset-0-1')
690
 
        bundle = self.get_valid_bundle('null:', 'l@cset-0-1')
691
 
        if getattr(bundle ,'revision_tree', None) is not None:
 
719
        self.tree1.commit('add symlink', rev_id=b'l@cset-0-1')
 
720
        bundle = self.get_valid_bundle(b'null:', b'l@cset-0-1')
 
721
        if getattr(bundle, 'revision_tree', None) is not None:
692
722
            # Not all bundle formats supports revision_tree
693
 
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-1')
694
 
            self.assertEqual(link_target, bund_tree.get_symlink_target(link_id))
 
723
            bund_tree = bundle.revision_tree(self.b1.repository, b'l@cset-0-1')
 
724
            self.assertEqual(
 
725
                link_target, bund_tree.get_symlink_target(link_name))
695
726
 
696
727
        tt = TreeTransform(self.tree1)
697
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
728
        trans_id = tt.trans_id_tree_path(link_name)
698
729
        tt.adjust_path('link2', tt.root, trans_id)
699
730
        tt.delete_contents(trans_id)
700
731
        tt.create_symlink(new_link_target, trans_id)
701
732
        tt.apply()
702
 
        self.tree1.commit('rename and change symlink', rev_id='l@cset-0-2')
703
 
        bundle = self.get_valid_bundle('l@cset-0-1', 'l@cset-0-2')
704
 
        if getattr(bundle ,'revision_tree', None) is not None:
 
733
        self.tree1.commit('rename and change symlink', rev_id=b'l@cset-0-2')
 
734
        bundle = self.get_valid_bundle(b'l@cset-0-1', b'l@cset-0-2')
 
735
        if getattr(bundle, 'revision_tree', None) is not None:
705
736
            # Not all bundle formats supports revision_tree
706
 
            bund_tree = bundle.revision_tree(self.b1.repository, 'l@cset-0-2')
 
737
            bund_tree = bundle.revision_tree(self.b1.repository, b'l@cset-0-2')
707
738
            self.assertEqual(new_link_target,
708
 
                             bund_tree.get_symlink_target(link_id))
 
739
                             bund_tree.get_symlink_target('link2'))
709
740
 
710
741
        tt = TreeTransform(self.tree1)
711
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
742
        trans_id = tt.trans_id_tree_path('link2')
712
743
        tt.delete_contents(trans_id)
713
744
        tt.create_symlink('jupiter', trans_id)
714
745
        tt.apply()
715
 
        self.tree1.commit('just change symlink target', rev_id='l@cset-0-3')
716
 
        bundle = self.get_valid_bundle('l@cset-0-2', 'l@cset-0-3')
 
746
        self.tree1.commit('just change symlink target', rev_id=b'l@cset-0-3')
 
747
        bundle = self.get_valid_bundle(b'l@cset-0-2', b'l@cset-0-3')
717
748
 
718
749
        tt = TreeTransform(self.tree1)
719
 
        trans_id = tt.trans_id_tree_file_id(link_id)
 
750
        trans_id = tt.trans_id_tree_path('link2')
720
751
        tt.delete_contents(trans_id)
721
752
        tt.apply()
722
 
        self.tree1.commit('Delete symlink', rev_id='l@cset-0-4')
723
 
        bundle = self.get_valid_bundle('l@cset-0-3', 'l@cset-0-4')
 
753
        self.tree1.commit('Delete symlink', rev_id=b'l@cset-0-4')
 
754
        bundle = self.get_valid_bundle(b'l@cset-0-3', b'l@cset-0-4')
724
755
 
725
756
    def test_symlink_bundle(self):
726
757
        self._test_symlink_bundle('link', 'bar/foo', 'mars')
727
758
 
728
759
    def test_unicode_symlink_bundle(self):
729
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
760
        self.requireFeature(features.UnicodeFilenameFeature)
730
761
        self._test_symlink_bundle(u'\N{Euro Sign}link',
731
762
                                  u'bar/\N{Euro Sign}foo',
732
763
                                  u'mars\N{Euro Sign}')
737
768
        tt = TreeTransform(self.tree1)
738
769
 
739
770
        # Add
740
 
        tt.new_file('file', tt.root, '\x00\n\x00\r\x01\n\x02\r\xff', 'binary-1')
741
 
        tt.new_file('file2', tt.root, '\x01\n\x02\r\x03\n\x04\r\xff',
742
 
            'binary-2')
 
771
        tt.new_file('file', tt.root, [
 
772
                    b'\x00\n\x00\r\x01\n\x02\r\xff'], b'binary-1')
 
773
        tt.new_file('file2', tt.root, [b'\x01\n\x02\r\x03\n\x04\r\xff'],
 
774
                    b'binary-2')
743
775
        tt.apply()
744
 
        self.tree1.commit('add binary', rev_id='b@cset-0-1')
745
 
        self.get_valid_bundle('null:', 'b@cset-0-1')
 
776
        self.tree1.commit('add binary', rev_id=b'b@cset-0-1')
 
777
        self.get_valid_bundle(b'null:', b'b@cset-0-1')
746
778
 
747
779
        # Delete
748
780
        tt = TreeTransform(self.tree1)
749
 
        trans_id = tt.trans_id_tree_file_id('binary-1')
 
781
        trans_id = tt.trans_id_tree_path('file')
750
782
        tt.delete_contents(trans_id)
751
783
        tt.apply()
752
 
        self.tree1.commit('delete binary', rev_id='b@cset-0-2')
753
 
        self.get_valid_bundle('b@cset-0-1', 'b@cset-0-2')
 
784
        self.tree1.commit('delete binary', rev_id=b'b@cset-0-2')
 
785
        self.get_valid_bundle(b'b@cset-0-1', b'b@cset-0-2')
754
786
 
755
787
        # Rename & modify
756
788
        tt = TreeTransform(self.tree1)
757
 
        trans_id = tt.trans_id_tree_file_id('binary-2')
 
789
        trans_id = tt.trans_id_tree_path('file2')
758
790
        tt.adjust_path('file3', tt.root, trans_id)
759
791
        tt.delete_contents(trans_id)
760
 
        tt.create_file('file\rcontents\x00\n\x00', trans_id)
 
792
        tt.create_file([b'file\rcontents\x00\n\x00'], trans_id)
761
793
        tt.apply()
762
 
        self.tree1.commit('rename and modify binary', rev_id='b@cset-0-3')
763
 
        self.get_valid_bundle('b@cset-0-2', 'b@cset-0-3')
 
794
        self.tree1.commit('rename and modify binary', rev_id=b'b@cset-0-3')
 
795
        self.get_valid_bundle(b'b@cset-0-2', b'b@cset-0-3')
764
796
 
765
797
        # Modify
766
798
        tt = TreeTransform(self.tree1)
767
 
        trans_id = tt.trans_id_tree_file_id('binary-2')
 
799
        trans_id = tt.trans_id_tree_path('file3')
768
800
        tt.delete_contents(trans_id)
769
 
        tt.create_file('\x00file\rcontents', trans_id)
 
801
        tt.create_file([b'\x00file\rcontents'], trans_id)
770
802
        tt.apply()
771
 
        self.tree1.commit('just modify binary', rev_id='b@cset-0-4')
772
 
        self.get_valid_bundle('b@cset-0-3', 'b@cset-0-4')
 
803
        self.tree1.commit('just modify binary', rev_id=b'b@cset-0-4')
 
804
        self.get_valid_bundle(b'b@cset-0-3', b'b@cset-0-4')
773
805
 
774
806
        # Rollup
775
 
        self.get_valid_bundle('null:', 'b@cset-0-4')
 
807
        self.get_valid_bundle(b'null:', b'b@cset-0-4')
776
808
 
777
809
    def test_last_modified(self):
778
810
        self.tree1 = self.make_branch_and_tree('b1')
779
811
        self.b1 = self.tree1.branch
780
812
        tt = TreeTransform(self.tree1)
781
 
        tt.new_file('file', tt.root, 'file', 'file')
 
813
        tt.new_file('file', tt.root, [b'file'], b'file')
782
814
        tt.apply()
783
 
        self.tree1.commit('create file', rev_id='a@lmod-0-1')
 
815
        self.tree1.commit('create file', rev_id=b'a@lmod-0-1')
784
816
 
785
817
        tt = TreeTransform(self.tree1)
786
 
        trans_id = tt.trans_id_tree_file_id('file')
 
818
        trans_id = tt.trans_id_tree_path('file')
787
819
        tt.delete_contents(trans_id)
788
 
        tt.create_file('file2', trans_id)
 
820
        tt.create_file([b'file2'], trans_id)
789
821
        tt.apply()
790
 
        self.tree1.commit('modify text', rev_id='a@lmod-0-2a')
 
822
        self.tree1.commit('modify text', rev_id=b'a@lmod-0-2a')
791
823
 
792
 
        other = self.get_checkout('a@lmod-0-1')
 
824
        other = self.get_checkout(b'a@lmod-0-1')
793
825
        tt = TreeTransform(other)
794
 
        trans_id = tt.trans_id_tree_file_id('file')
 
826
        trans_id = tt.trans_id_tree_path('file2')
795
827
        tt.delete_contents(trans_id)
796
 
        tt.create_file('file2', trans_id)
 
828
        tt.create_file([b'file2'], trans_id)
797
829
        tt.apply()
798
 
        other.commit('modify text in another tree', rev_id='a@lmod-0-2b')
 
830
        other.commit('modify text in another tree', rev_id=b'a@lmod-0-2b')
799
831
        self.tree1.merge_from_branch(other.branch)
800
 
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-3',
 
832
        self.tree1.commit(u'Merge', rev_id=b'a@lmod-0-3',
801
833
                          verbose=False)
802
 
        self.tree1.commit(u'Merge', rev_id='a@lmod-0-4')
803
 
        bundle = self.get_valid_bundle('a@lmod-0-2a', 'a@lmod-0-4')
 
834
        self.tree1.commit(u'Merge', rev_id=b'a@lmod-0-4')
 
835
        bundle = self.get_valid_bundle(b'a@lmod-0-2a', b'a@lmod-0-4')
804
836
 
805
837
    def test_hide_history(self):
806
838
        self.tree1 = self.make_branch_and_tree('b1')
807
839
        self.b1 = self.tree1.branch
808
840
 
809
 
        open('b1/one', 'wb').write('one\n')
 
841
        with open('b1/one', 'wb') as f:
 
842
            f.write(b'one\n')
810
843
        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()
817
 
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-3',
818
 
                               'a@cset-0-1', bundle_file, format=self.format)
819
 
        self.assertNotContainsRe(bundle_file.getvalue(), '\btwo\b')
820
 
        self.assertContainsRe(self.get_raw(bundle_file), 'one')
821
 
        self.assertContainsRe(self.get_raw(bundle_file), 'three')
 
844
        self.tree1.commit('add file', rev_id=b'a@cset-0-1')
 
845
        with open('b1/one', 'wb') as f:
 
846
            f.write(b'two\n')
 
847
        self.tree1.commit('modify', rev_id=b'a@cset-0-2')
 
848
        with open('b1/one', 'wb') as f:
 
849
            f.write(b'three\n')
 
850
        self.tree1.commit('modify', rev_id=b'a@cset-0-3')
 
851
        bundle_file = BytesIO()
 
852
        rev_ids = write_bundle(self.tree1.branch.repository, b'a@cset-0-3',
 
853
                               b'a@cset-0-1', bundle_file, format=self.format)
 
854
        self.assertNotContainsRe(bundle_file.getvalue(), b'\btwo\b')
 
855
        self.assertContainsRe(self.get_raw(bundle_file), b'one')
 
856
        self.assertContainsRe(self.get_raw(bundle_file), b'three')
822
857
 
823
858
    def test_bundle_same_basis(self):
824
859
        """Ensure using the basis as the target doesn't cause an error"""
825
860
        self.tree1 = self.make_branch_and_tree('b1')
826
 
        self.tree1.commit('add file', rev_id='a@cset-0-1')
827
 
        bundle_file = StringIO()
828
 
        rev_ids = write_bundle(self.tree1.branch.repository, 'a@cset-0-1',
829
 
                               'a@cset-0-1', bundle_file)
 
861
        self.tree1.commit('add file', rev_id=b'a@cset-0-1')
 
862
        bundle_file = BytesIO()
 
863
        rev_ids = write_bundle(self.tree1.branch.repository, b'a@cset-0-1',
 
864
                               b'a@cset-0-1', bundle_file)
830
865
 
831
866
    @staticmethod
832
867
    def get_raw(bundle_file):
833
868
        return bundle_file.getvalue()
834
869
 
835
870
    def test_unicode_bundle(self):
836
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
871
        self.requireFeature(features.UnicodeFilenameFeature)
837
872
        # Handle international characters
838
873
        os.mkdir('b1')
839
874
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
842
877
        self.b1 = self.tree1.branch
843
878
 
844
879
        f.write((u'A file\n'
845
 
            u'With international man of mystery\n'
846
 
            u'William Dod\xe9\n').encode('utf-8'))
 
880
                 u'With international man of mystery\n'
 
881
                 u'William Dod\xe9\n').encode('utf-8'))
847
882
        f.close()
848
883
 
849
 
        self.tree1.add([u'with Dod\N{Euro Sign}'], ['withdod-id'])
 
884
        self.tree1.add([u'with Dod\N{Euro Sign}'], [b'withdod-id'])
850
885
        self.tree1.commit(u'i18n commit from William Dod\xe9',
851
 
                          rev_id='i18n-1', committer=u'William Dod\xe9')
 
886
                          rev_id=b'i18n-1', committer=u'William Dod\xe9')
852
887
 
853
888
        # Add
854
 
        bundle = self.get_valid_bundle('null:', 'i18n-1')
 
889
        bundle = self.get_valid_bundle(b'null:', b'i18n-1')
855
890
 
856
891
        # Modified
857
892
        f = open(u'b1/with Dod\N{Euro Sign}', 'wb')
858
893
        f.write(u'Modified \xb5\n'.encode('utf8'))
859
894
        f.close()
860
 
        self.tree1.commit(u'modified', rev_id='i18n-2')
 
895
        self.tree1.commit(u'modified', rev_id=b'i18n-2')
861
896
 
862
 
        bundle = self.get_valid_bundle('i18n-1', 'i18n-2')
 
897
        bundle = self.get_valid_bundle(b'i18n-1', b'i18n-2')
863
898
 
864
899
        # Renamed
865
900
        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',
 
901
        self.tree1.commit(u'renamed, the new i18n man', rev_id=b'i18n-3',
867
902
                          committer=u'Erik B\xe5gfors')
868
903
 
869
 
        bundle = self.get_valid_bundle('i18n-2', 'i18n-3')
 
904
        bundle = self.get_valid_bundle(b'i18n-2', b'i18n-3')
870
905
 
871
906
        # Removed
872
907
        self.tree1.remove([u'B\N{Euro Sign}gfors'])
873
 
        self.tree1.commit(u'removed', rev_id='i18n-4')
 
908
        self.tree1.commit(u'removed', rev_id=b'i18n-4')
874
909
 
875
 
        bundle = self.get_valid_bundle('i18n-3', 'i18n-4')
 
910
        bundle = self.get_valid_bundle(b'i18n-3', b'i18n-4')
876
911
 
877
912
        # Rollup
878
 
        bundle = self.get_valid_bundle('null:', 'i18n-4')
879
 
 
 
913
        bundle = self.get_valid_bundle(b'null:', b'i18n-4')
880
914
 
881
915
    def test_whitespace_bundle(self):
882
916
        if sys.platform in ('win32', 'cygwin'):
891
925
        #       once we actually support them
892
926
 
893
927
        # Added
894
 
        self.tree1.commit('funky whitespace', rev_id='white-1')
 
928
        self.tree1.commit('funky whitespace', rev_id=b'white-1')
895
929
 
896
 
        bundle = self.get_valid_bundle('null:', 'white-1')
 
930
        bundle = self.get_valid_bundle(b'null:', b'white-1')
897
931
 
898
932
        # Modified
899
 
        open('b1/trailing space ', 'ab').write('add some text\n')
900
 
        self.tree1.commit('add text', rev_id='white-2')
 
933
        with open('b1/trailing space ', 'ab') as f:
 
934
            f.write(b'add some text\n')
 
935
        self.tree1.commit('add text', rev_id=b'white-2')
901
936
 
902
 
        bundle = self.get_valid_bundle('white-1', 'white-2')
 
937
        bundle = self.get_valid_bundle(b'white-1', b'white-2')
903
938
 
904
939
        # Renamed
905
940
        self.tree1.rename_one('trailing space ', ' start and end space ')
906
 
        self.tree1.commit('rename', rev_id='white-3')
 
941
        self.tree1.commit('rename', rev_id=b'white-3')
907
942
 
908
 
        bundle = self.get_valid_bundle('white-2', 'white-3')
 
943
        bundle = self.get_valid_bundle(b'white-2', b'white-3')
909
944
 
910
945
        # Removed
911
946
        self.tree1.remove([' start and end space '])
912
 
        self.tree1.commit('removed', rev_id='white-4')
 
947
        self.tree1.commit('removed', rev_id=b'white-4')
913
948
 
914
 
        bundle = self.get_valid_bundle('white-3', 'white-4')
 
949
        bundle = self.get_valid_bundle(b'white-3', b'white-4')
915
950
 
916
951
        # Now test a complet roll-up
917
 
        bundle = self.get_valid_bundle('null:', 'white-4')
 
952
        bundle = self.get_valid_bundle(b'null:', b'white-4')
918
953
 
919
954
    def test_alt_timezone_bundle(self):
920
955
        self.tree1 = self.make_branch_and_memory_tree('b1')
927
962
        builder.finish_tree()
928
963
 
929
964
        # Asia/Colombo offset = 5 hours 30 minutes
930
 
        self.tree1.commit('non-hour offset timezone', rev_id='tz-1',
 
965
        self.tree1.commit('non-hour offset timezone', rev_id=b'tz-1',
931
966
                          timezone=19800, timestamp=1152544886.0)
932
967
 
933
 
        bundle = self.get_valid_bundle('null:', 'tz-1')
 
968
        bundle = self.get_valid_bundle(b'null:', b'tz-1')
934
969
 
935
970
        rev = bundle.revisions[0]
936
971
        self.assertEqual('Mon 2006-07-10 20:51:26.000000000 +0530', rev.date)
941
976
    def test_bundle_root_id(self):
942
977
        self.tree1 = self.make_branch_and_tree('b1')
943
978
        self.b1 = self.tree1.branch
944
 
        self.tree1.commit('message', rev_id='revid1')
945
 
        bundle = self.get_valid_bundle('null:', 'revid1')
946
 
        tree = self.get_bundle_tree(bundle, 'revid1')
947
 
        self.assertEqual('revid1', tree.inventory.root.revision)
 
979
        self.tree1.commit('message', rev_id=b'revid1')
 
980
        bundle = self.get_valid_bundle(b'null:', b'revid1')
 
981
        tree = self.get_bundle_tree(bundle, b'revid1')
 
982
        root_revision = tree.get_file_revision(u'', tree.get_root_id())
 
983
        self.assertEqual(b'revid1', root_revision)
948
984
 
949
985
    def test_install_revisions(self):
950
986
        self.tree1 = self.make_branch_and_tree('b1')
951
987
        self.b1 = self.tree1.branch
952
 
        self.tree1.commit('message', rev_id='rev2a')
953
 
        bundle = self.get_valid_bundle('null:', 'rev2a')
 
988
        self.tree1.commit('message', rev_id=b'rev2a')
 
989
        bundle = self.get_valid_bundle(b'null:', b'rev2a')
954
990
        branch2 = self.make_branch('b2')
955
 
        self.assertFalse(branch2.repository.has_revision('rev2a'))
 
991
        self.assertFalse(branch2.repository.has_revision(b'rev2a'))
956
992
        target_revision = bundle.install_revisions(branch2.repository)
957
 
        self.assertTrue(branch2.repository.has_revision('rev2a'))
958
 
        self.assertEqual('rev2a', target_revision)
 
993
        self.assertTrue(branch2.repository.has_revision(b'rev2a'))
 
994
        self.assertEqual(b'rev2a', target_revision)
959
995
 
960
996
    def test_bundle_empty_property(self):
961
997
        """Test serializing revision properties with an empty value."""
962
998
        tree = self.make_branch_and_memory_tree('tree')
963
999
        tree.lock_write()
964
1000
        self.addCleanup(tree.unlock)
965
 
        tree.add([''], ['TREE_ROOT'])
966
 
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1001
        tree.add([''], [b'TREE_ROOT'])
 
1002
        tree.commit('One', revprops={u'one': 'two',
 
1003
                                     u'empty': ''}, rev_id=b'rev1')
967
1004
        self.b1 = tree.branch
968
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1005
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
969
1006
        bundle = read_bundle(bundle_sio)
970
1007
        revision_info = bundle.revisions[0]
971
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1008
        self.assertEqual(b'rev1', revision_info.revision_id)
972
1009
        rev = revision_info.as_revision()
973
 
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
1010
        self.assertEqual({'branch-nick': 'tree', 'empty': '', 'one': 'two'},
974
1011
                         rev.properties)
975
1012
 
976
1013
    def test_bundle_sorted_properties(self):
979
1016
        tree.lock_write()
980
1017
        self.addCleanup(tree.unlock)
981
1018
 
982
 
        tree.add([''], ['TREE_ROOT'])
983
 
        tree.commit('One', rev_id='rev1',
984
 
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
 
1019
        tree.add([''], [b'TREE_ROOT'])
 
1020
        tree.commit('One', rev_id=b'rev1',
 
1021
                    revprops={u'a': '4', u'b': '3', u'c': '2', u'd': '1'})
985
1022
        self.b1 = tree.branch
986
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1023
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
987
1024
        bundle = read_bundle(bundle_sio)
988
1025
        revision_info = bundle.revisions[0]
989
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1026
        self.assertEqual(b'rev1', revision_info.revision_id)
990
1027
        rev = revision_info.as_revision()
991
 
        self.assertEqual({'branch-nick':'tree', 'a':'4', 'b':'3', 'c':'2',
992
 
                          'd':'1'}, rev.properties)
 
1028
        self.assertEqual({'branch-nick': 'tree', 'a': '4', 'b': '3', 'c': '2',
 
1029
                          'd': '1'}, rev.properties)
993
1030
 
994
1031
    def test_bundle_unicode_properties(self):
995
1032
        """We should be able to round trip a non-ascii property."""
997
1034
        tree.lock_write()
998
1035
        self.addCleanup(tree.unlock)
999
1036
 
1000
 
        tree.add([''], ['TREE_ROOT'])
 
1037
        tree.add([''], [b'TREE_ROOT'])
1001
1038
        # Revisions themselves do not require anything about revision property
1002
1039
        # keys, other than that they are a basestring, and do not contain
1003
1040
        # whitespace.
1004
1041
        # However, Testaments assert than they are str(), and thus should not
1005
1042
        # be Unicode.
1006
 
        tree.commit('One', rev_id='rev1',
1007
 
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
 
1043
        tree.commit('One', rev_id=b'rev1',
 
1044
                    revprops={u'omega': u'\u03a9', u'alpha': u'\u03b1'})
1008
1045
        self.b1 = tree.branch
1009
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1046
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1010
1047
        bundle = read_bundle(bundle_sio)
1011
1048
        revision_info = bundle.revisions[0]
1012
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1049
        self.assertEqual(b'rev1', revision_info.revision_id)
1013
1050
        rev = revision_info.as_revision()
1014
 
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
1015
 
                          'alpha':u'\u03b1'}, rev.properties)
 
1051
        self.assertEqual({'branch-nick': 'tree', 'omega': u'\u03a9',
 
1052
                          'alpha': u'\u03b1'}, rev.properties)
1016
1053
 
1017
1054
    def test_bundle_with_ghosts(self):
1018
1055
        tree = self.make_branch_and_tree('tree')
1019
1056
        self.b1 = tree.branch
1020
 
        self.build_tree_contents([('tree/file', 'content1')])
 
1057
        self.build_tree_contents([('tree/file', b'content1')])
1021
1058
        tree.add(['file'])
1022
1059
        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')
 
1060
        self.build_tree_contents([('tree/file', b'content2')])
 
1061
        tree.add_parent_tree_id(b'ghost')
 
1062
        tree.commit('rev2', rev_id=b'rev2')
 
1063
        bundle = self.get_valid_bundle(b'null:', b'rev2')
1027
1064
 
1028
1065
    def make_simple_tree(self, format=None):
1029
1066
        tree = self.make_branch_and_tree('b1', format=format)
1034
1071
 
1035
1072
    def test_across_serializers(self):
1036
1073
        tree = self.make_simple_tree('knit')
1037
 
        tree.commit('hello', rev_id='rev1')
1038
 
        tree.commit('hello', rev_id='rev2')
1039
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1074
        tree.commit('hello', rev_id=b'rev1')
 
1075
        tree.commit('hello', rev_id=b'rev2')
 
1076
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
1040
1077
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1041
1078
        bundle.install_revisions(repo)
1042
 
        inv_text = repo._get_inventory_xml('rev2')
1043
 
        self.assertNotContainsRe(inv_text, 'format="5"')
1044
 
        self.assertContainsRe(inv_text, 'format="7"')
 
1079
        inv_text = repo._get_inventory_xml(b'rev2')
 
1080
        self.assertNotContainsRe(inv_text, b'format="5"')
 
1081
        self.assertContainsRe(inv_text, b'format="7"')
1045
1082
 
1046
1083
    def make_repo_with_installed_revisions(self):
1047
1084
        tree = self.make_simple_tree('knit')
1048
 
        tree.commit('hello', rev_id='rev1')
1049
 
        tree.commit('hello', rev_id='rev2')
1050
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1085
        tree.commit('hello', rev_id=b'rev1')
 
1086
        tree.commit('hello', rev_id=b'rev2')
 
1087
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
1051
1088
        repo = self.make_repository('repo', format='dirstate-with-subtree')
1052
1089
        bundle.install_revisions(repo)
1053
1090
        return repo
1054
1091
 
1055
1092
    def test_across_models(self):
1056
1093
        repo = self.make_repo_with_installed_revisions()
1057
 
        inv = repo.get_inventory('rev2')
1058
 
        self.assertEqual('rev2', inv.root.revision)
 
1094
        inv = repo.get_inventory(b'rev2')
 
1095
        self.assertEqual(b'rev2', inv.root.revision)
1059
1096
        root_id = inv.root.file_id
1060
1097
        repo.lock_read()
1061
1098
        self.addCleanup(repo.unlock)
1062
 
        self.assertEqual({(root_id, 'rev1'):(),
1063
 
            (root_id, 'rev2'):((root_id, 'rev1'),)},
1064
 
            repo.texts.get_parent_map([(root_id, 'rev1'), (root_id, 'rev2')]))
 
1099
        self.assertEqual({(root_id, b'rev1'): (),
 
1100
                          (root_id, b'rev2'): ((root_id, b'rev1'),)},
 
1101
                         repo.texts.get_parent_map([(root_id, b'rev1'), (root_id, b'rev2')]))
1065
1102
 
1066
1103
    def test_inv_hash_across_serializers(self):
1067
1104
        repo = self.make_repo_with_installed_revisions()
1068
 
        recorded_inv_sha1 = repo.get_revision('rev2').inventory_sha1
1069
 
        xml = repo._get_inventory_xml('rev2')
 
1105
        recorded_inv_sha1 = repo.get_revision(b'rev2').inventory_sha1
 
1106
        xml = repo._get_inventory_xml(b'rev2')
1070
1107
        self.assertEqual(osutils.sha_string(xml), recorded_inv_sha1)
1071
1108
 
1072
1109
    def test_across_models_incompatible(self):
1073
1110
        tree = self.make_simple_tree('dirstate-with-subtree')
1074
 
        tree.commit('hello', rev_id='rev1')
1075
 
        tree.commit('hello', rev_id='rev2')
 
1111
        tree.commit('hello', rev_id=b'rev1')
 
1112
        tree.commit('hello', rev_id=b'rev2')
1076
1113
        try:
1077
 
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1114
            bundle = read_bundle(self.create_bundle_text(b'null:', b'rev1')[0])
1078
1115
        except errors.IncompatibleBundleFormat:
1079
1116
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
1080
1117
        repo = self.make_repository('repo', format='knit')
1081
1118
        bundle.install_revisions(repo)
1082
1119
 
1083
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
 
1120
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
1084
1121
        self.assertRaises(errors.IncompatibleRevision,
1085
1122
                          bundle.install_revisions, repo)
1086
1123
 
1087
1124
    def test_get_merge_request(self):
1088
1125
        tree = self.make_simple_tree()
1089
 
        tree.commit('hello', rev_id='rev1')
1090
 
        tree.commit('hello', rev_id='rev2')
1091
 
        bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1126
        tree.commit('hello', rev_id=b'rev1')
 
1127
        tree.commit('hello', rev_id=b'rev2')
 
1128
        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev1')[0])
1092
1129
        result = bundle.get_merge_request(tree.branch.repository)
1093
 
        self.assertEqual((None, 'rev1', 'inapplicable'), result)
 
1130
        self.assertEqual((None, b'rev1', 'inapplicable'), result)
1094
1131
 
1095
1132
    def test_with_subtree(self):
1096
1133
        tree = self.make_branch_and_tree('tree',
1099
1136
        subtree = self.make_branch_and_tree('tree/subtree',
1100
1137
                                            format='dirstate-with-subtree')
1101
1138
        tree.add('subtree')
1102
 
        tree.commit('hello', rev_id='rev1')
 
1139
        tree.commit('hello', rev_id=b'rev1')
1103
1140
        try:
1104
 
            bundle = read_bundle(self.create_bundle_text('null:', 'rev1')[0])
 
1141
            bundle = read_bundle(self.create_bundle_text(b'null:', b'rev1')[0])
1105
1142
        except errors.IncompatibleBundleFormat:
1106
1143
            raise tests.TestSkipped("Format 0.8 doesn't work with knit3")
1107
1144
        if isinstance(bundle, v09.BundleInfo09):
1116
1153
        self.tree1 = self.make_branch_and_tree('tree')
1117
1154
        self.b1 = self.tree1.branch
1118
1155
        try:
1119
 
            self.tree1.commit('Revision/id/with/slashes', rev_id='rev/id')
 
1156
            self.tree1.commit('Revision/id/with/slashes', rev_id=b'rev/id')
1120
1157
        except ValueError:
1121
1158
            raise tests.TestSkipped(
1122
1159
                "Repository doesn't support revision ids with slashes")
1123
 
        bundle = self.get_valid_bundle('null:', 'rev/id')
 
1160
        bundle = self.get_valid_bundle(b'null:', b'rev/id')
1124
1161
 
1125
1162
    def test_skip_file(self):
1126
1163
        """Make sure we don't accidentally write to the wrong versionedfile"""
1127
1164
        self.tree1 = self.make_branch_and_tree('tree')
1128
1165
        self.b1 = self.tree1.branch
1129
1166
        # 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')])
 
1167
        self.build_tree_contents([('tree/file2', b'contents1')])
 
1168
        self.tree1.add('file2', b'file2-id')
 
1169
        self.tree1.commit('rev1', rev_id=b'reva')
 
1170
        self.build_tree_contents([('tree/file3', b'contents2')])
1134
1171
        # rev2 is present in bundle, and done by fetch
1135
1172
        # having file1 in the bunle causes file1's versionedfile to be opened.
1136
 
        self.tree1.add('file3', 'file3-id')
1137
 
        self.tree1.commit('rev2')
 
1173
        self.tree1.add('file3', b'file3-id')
 
1174
        rev2 = self.tree1.commit('rev2')
1138
1175
        # 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')
1142
 
        bundle = self.get_valid_bundle('reva', 'rev3')
 
1176
        target = self.tree1.controldir.sprout('target').open_workingtree()
 
1177
        self.build_tree_contents([('tree/file2', b'contents3')])
 
1178
        self.tree1.commit('rev3', rev_id=b'rev3')
 
1179
        bundle = self.get_valid_bundle(b'reva', b'rev3')
1143
1180
        if getattr(bundle, 'get_bundle_reader', None) is None:
1144
1181
            raise tests.TestSkipped('Bundle format cannot provide reader')
1145
 
        # be sure that file1 comes before file2
1146
 
        for b, m, k, r, f in bundle.get_bundle_reader().iter_records():
1147
 
            if f == 'file3-id':
1148
 
                break
1149
 
            self.assertNotEqual(f, 'file2-id')
 
1182
        file_ids = set(
 
1183
            (f, r) for b, m, k, r, f in bundle.get_bundle_reader().iter_records()
 
1184
            if f is not None)
 
1185
        self.assertEqual(
 
1186
            {(b'file2-id', b'rev3'), (b'file3-id', rev2)}, file_ids)
1150
1187
        bundle.install_revisions(target.branch.repository)
1151
1188
 
1152
1189
 
1159
1196
        tree = self.make_branch_and_memory_tree('tree')
1160
1197
        tree.lock_write()
1161
1198
        self.addCleanup(tree.unlock)
1162
 
        tree.add([''], ['TREE_ROOT'])
1163
 
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1199
        tree.add([''], [b'TREE_ROOT'])
 
1200
        tree.commit('One', revprops={u'one': 'two',
 
1201
                                     u'empty': ''}, rev_id=b'rev1')
1164
1202
        self.b1 = tree.branch
1165
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1203
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1166
1204
        self.assertContainsRe(bundle_sio.getvalue(),
1167
 
                              '# properties:\n'
1168
 
                              '#   branch-nick: tree\n'
1169
 
                              '#   empty: \n'
1170
 
                              '#   one: two\n'
1171
 
                             )
 
1205
                              b'# properties:\n'
 
1206
                              b'#   branch-nick: tree\n'
 
1207
                              b'#   empty: \n'
 
1208
                              b'#   one: two\n'
 
1209
                              )
1172
1210
        bundle = read_bundle(bundle_sio)
1173
1211
        revision_info = bundle.revisions[0]
1174
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1212
        self.assertEqual(b'rev1', revision_info.revision_id)
1175
1213
        rev = revision_info.as_revision()
1176
 
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
1214
        self.assertEqual({'branch-nick': 'tree', 'empty': '', 'one': 'two'},
1177
1215
                         rev.properties)
1178
1216
 
1179
1217
    def get_bundle_tree(self, bundle, revision_id):
1180
1218
        repository = self.make_repository('repo')
1181
 
        return bundle.revision_tree(repository, 'revid1')
 
1219
        return bundle.revision_tree(repository, b'revid1')
1182
1220
 
1183
1221
    def test_bundle_empty_property_alt(self):
1184
1222
        """Test serializing revision properties with an empty value.
1191
1229
        tree = self.make_branch_and_memory_tree('tree')
1192
1230
        tree.lock_write()
1193
1231
        self.addCleanup(tree.unlock)
1194
 
        tree.add([''], ['TREE_ROOT'])
1195
 
        tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id='rev1')
 
1232
        tree.add([''], [b'TREE_ROOT'])
 
1233
        tree.commit('One', revprops={u'one': 'two',
 
1234
                                     u'empty': ''}, rev_id=b'rev1')
1196
1235
        self.b1 = tree.branch
1197
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1236
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1198
1237
        txt = bundle_sio.getvalue()
1199
 
        loc = txt.find('#   empty: ') + len('#   empty:')
 
1238
        loc = txt.find(b'#   empty: ') + len(b'#   empty:')
1200
1239
        # Create a new bundle, which strips the trailing space after empty
1201
 
        bundle_sio = StringIO(txt[:loc] + txt[loc+1:])
 
1240
        bundle_sio = BytesIO(txt[:loc] + txt[loc + 1:])
1202
1241
 
1203
1242
        self.assertContainsRe(bundle_sio.getvalue(),
1204
 
                              '# properties:\n'
1205
 
                              '#   branch-nick: tree\n'
1206
 
                              '#   empty:\n'
1207
 
                              '#   one: two\n'
1208
 
                             )
 
1243
                              b'# properties:\n'
 
1244
                              b'#   branch-nick: tree\n'
 
1245
                              b'#   empty:\n'
 
1246
                              b'#   one: two\n'
 
1247
                              )
1209
1248
        bundle = read_bundle(bundle_sio)
1210
1249
        revision_info = bundle.revisions[0]
1211
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1250
        self.assertEqual(b'rev1', revision_info.revision_id)
1212
1251
        rev = revision_info.as_revision()
1213
 
        self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
 
1252
        self.assertEqual({'branch-nick': 'tree', 'empty': '', 'one': 'two'},
1214
1253
                         rev.properties)
1215
1254
 
1216
1255
    def test_bundle_sorted_properties(self):
1219
1258
        tree.lock_write()
1220
1259
        self.addCleanup(tree.unlock)
1221
1260
 
1222
 
        tree.add([''], ['TREE_ROOT'])
1223
 
        tree.commit('One', rev_id='rev1',
1224
 
                    revprops={'a':'4', 'b':'3', 'c':'2', 'd':'1'})
 
1261
        tree.add([''], [b'TREE_ROOT'])
 
1262
        tree.commit('One', rev_id=b'rev1',
 
1263
                    revprops={u'a': '4', u'b': '3', u'c': '2', u'd': '1'})
1225
1264
        self.b1 = tree.branch
1226
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1265
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1227
1266
        self.assertContainsRe(bundle_sio.getvalue(),
1228
 
                              '# properties:\n'
1229
 
                              '#   a: 4\n'
1230
 
                              '#   b: 3\n'
1231
 
                              '#   branch-nick: tree\n'
1232
 
                              '#   c: 2\n'
1233
 
                              '#   d: 1\n'
1234
 
                             )
 
1267
                              b'# properties:\n'
 
1268
                              b'#   a: 4\n'
 
1269
                              b'#   b: 3\n'
 
1270
                              b'#   branch-nick: tree\n'
 
1271
                              b'#   c: 2\n'
 
1272
                              b'#   d: 1\n'
 
1273
                              )
1235
1274
        bundle = read_bundle(bundle_sio)
1236
1275
        revision_info = bundle.revisions[0]
1237
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1276
        self.assertEqual(b'rev1', revision_info.revision_id)
1238
1277
        rev = revision_info.as_revision()
1239
 
        self.assertEqual({'branch-nick':'tree', 'a':'4', 'b':'3', 'c':'2',
1240
 
                          'd':'1'}, rev.properties)
 
1278
        self.assertEqual({'branch-nick': 'tree', 'a': '4', 'b': '3', 'c': '2',
 
1279
                          'd': '1'}, rev.properties)
1241
1280
 
1242
1281
    def test_bundle_unicode_properties(self):
1243
1282
        """We should be able to round trip a non-ascii property."""
1245
1284
        tree.lock_write()
1246
1285
        self.addCleanup(tree.unlock)
1247
1286
 
1248
 
        tree.add([''], ['TREE_ROOT'])
 
1287
        tree.add([''], [b'TREE_ROOT'])
1249
1288
        # Revisions themselves do not require anything about revision property
1250
1289
        # keys, other than that they are a basestring, and do not contain
1251
1290
        # whitespace.
1252
1291
        # However, Testaments assert than they are str(), and thus should not
1253
1292
        # be Unicode.
1254
 
        tree.commit('One', rev_id='rev1',
1255
 
                    revprops={'omega':u'\u03a9', 'alpha':u'\u03b1'})
 
1293
        tree.commit('One', rev_id=b'rev1',
 
1294
                    revprops={u'omega': u'\u03a9', u'alpha': u'\u03b1'})
1256
1295
        self.b1 = tree.branch
1257
 
        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
 
1296
        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
1258
1297
        self.assertContainsRe(bundle_sio.getvalue(),
1259
 
                              '# properties:\n'
1260
 
                              '#   alpha: \xce\xb1\n'
1261
 
                              '#   branch-nick: tree\n'
1262
 
                              '#   omega: \xce\xa9\n'
1263
 
                             )
 
1298
                              b'# properties:\n'
 
1299
                              b'#   alpha: \xce\xb1\n'
 
1300
                              b'#   branch-nick: tree\n'
 
1301
                              b'#   omega: \xce\xa9\n'
 
1302
                              )
1264
1303
        bundle = read_bundle(bundle_sio)
1265
1304
        revision_info = bundle.revisions[0]
1266
 
        self.assertEqual('rev1', revision_info.revision_id)
 
1305
        self.assertEqual(b'rev1', revision_info.revision_id)
1267
1306
        rev = revision_info.as_revision()
1268
 
        self.assertEqual({'branch-nick':'tree', 'omega':u'\u03a9',
1269
 
                          'alpha':u'\u03b1'}, rev.properties)
 
1307
        self.assertEqual({'branch-nick': 'tree', 'omega': u'\u03a9',
 
1308
                          'alpha': u'\u03b1'}, rev.properties)
1270
1309
 
1271
1310
 
1272
1311
class V09BundleKnit2Tester(V08BundleTester):
1319
1358
            self.assertEqual(len(branch_rev.parent_ids),
1320
1359
                             len(bundle_rev.parent_ids))
1321
1360
        self.assertEqual(set(rev_ids),
1322
 
                         set([r.revision_id for r in bundle.real_revisions]))
 
1361
                         {r.revision_id for r in bundle.real_revisions})
1323
1362
        self.valid_apply_bundle(base_rev_id, bundle,
1324
 
                                   checkout_dir=checkout_dir)
 
1363
                                checkout_dir=checkout_dir)
1325
1364
 
1326
1365
        return bundle
1327
1366
 
1331
1370
 
1332
1371
        :return: The in-memory bundle
1333
1372
        """
1334
 
        from bzrlib.bundle import serializer
 
1373
        from ..bundle import serializer
1335
1374
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1336
 
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
1337
 
        new_text = new_text.replace('<file file_id="exe-1"',
1338
 
                                    '<file executable="y" file_id="exe-1"')
1339
 
        new_text = new_text.replace('B260', 'B275')
1340
 
        bundle_txt = StringIO()
 
1375
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
 
1376
        new_text = new_text.replace(b'<file file_id="exe-1"',
 
1377
                                    b'<file executable="y" file_id="exe-1"')
 
1378
        new_text = new_text.replace(b'B260', b'B275')
 
1379
        bundle_txt = BytesIO()
1341
1380
        bundle_txt.write(serializer._get_bundle_header('4'))
1342
 
        bundle_txt.write('\n')
1343
 
        bundle_txt.write(new_text.encode('bz2'))
 
1381
        bundle_txt.write(b'\n')
 
1382
        bundle_txt.write(bz2.compress(new_text))
1344
1383
        bundle_txt.seek(0)
1345
1384
        bundle = read_bundle(bundle_txt)
1346
1385
        self.valid_apply_bundle(base_rev_id, bundle)
1347
1386
        return bundle
1348
1387
 
1349
1388
    def create_bundle_text(self, base_rev_id, rev_id):
1350
 
        bundle_txt = StringIO()
 
1389
        bundle_txt = BytesIO()
1351
1390
        rev_ids = write_bundle(self.b1.repository, rev_id, base_rev_id,
1352
1391
                               bundle_txt, format=self.format)
1353
1392
        bundle_txt.seek(0)
1354
1393
        self.assertEqual(bundle_txt.readline(),
1355
 
                         '# Bazaar revision bundle v%s\n' % self.format)
1356
 
        self.assertEqual(bundle_txt.readline(), '#\n')
 
1394
                         b'# Bazaar revision bundle v%s\n' % self.format.encode('ascii'))
 
1395
        self.assertEqual(bundle_txt.readline(), b'#\n')
1357
1396
        rev = self.b1.repository.get_revision(rev_id)
1358
1397
        bundle_txt.seek(0)
1359
1398
        return bundle_txt, rev_ids
1365
1404
 
1366
1405
    def test_creation(self):
1367
1406
        tree = self.make_branch_and_tree('tree')
1368
 
        self.build_tree_contents([('tree/file', 'contents1\nstatic\n')])
1369
 
        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()
 
1407
        self.build_tree_contents([('tree/file', b'contents1\nstatic\n')])
 
1408
        tree.add('file', b'fileid-2')
 
1409
        tree.commit('added file', rev_id=b'rev1')
 
1410
        self.build_tree_contents([('tree/file', b'contents2\nstatic\n')])
 
1411
        tree.commit('changed file', rev_id=b'rev2')
 
1412
        s = BytesIO()
1374
1413
        serializer = BundleSerializerV4('1.0')
1375
 
        serializer.write(tree.branch.repository, ['rev1', 'rev2'], {}, s)
 
1414
        with tree.lock_read():
 
1415
            serializer.write_bundle(
 
1416
                tree.branch.repository, b'rev2', b'null:', s)
1376
1417
        s.seek(0)
1377
1418
        tree2 = self.make_branch_and_tree('target')
1378
1419
        target_repo = tree2.branch.repository
1380
1421
        target_repo.lock_read()
1381
1422
        self.addCleanup(target_repo.unlock)
1382
1423
        # Turn the 'iterators_of_bytes' back into simple strings for comparison
1383
 
        repo_texts = dict((i, ''.join(content)) for i, content
 
1424
        repo_texts = dict((i, b''.join(content)) for i, content
1384
1425
                          in target_repo.iter_files_bytes(
1385
 
                                [('fileid-2', 'rev1', '1'),
1386
 
                                 ('fileid-2', 'rev2', '2')]))
1387
 
        self.assertEqual({'1':'contents1\nstatic\n',
1388
 
                          '2':'contents2\nstatic\n'},
 
1426
            [(b'fileid-2', b'rev1', '1'),
 
1427
             (b'fileid-2', b'rev2', '2')]))
 
1428
        self.assertEqual({'1': b'contents1\nstatic\n',
 
1429
                          '2': b'contents2\nstatic\n'},
1389
1430
                         repo_texts)
1390
 
        rtree = target_repo.revision_tree('rev2')
 
1431
        rtree = target_repo.revision_tree(b'rev2')
1391
1432
        inventory_vf = target_repo.inventories
1392
1433
        # If the inventory store has a graph, it must match the revision graph.
1393
1434
        self.assertSubset(
1394
 
            [inventory_vf.get_parent_map([('rev2',)])[('rev2',)]],
1395
 
            [None, (('rev1',),)])
 
1435
            [inventory_vf.get_parent_map([(b'rev2',)])[(b'rev2',)]],
 
1436
            [None, ((b'rev1',),)])
1396
1437
        self.assertEqual('changed file',
1397
 
                         target_repo.get_revision('rev2').message)
 
1438
                         target_repo.get_revision(b'rev2').message)
1398
1439
 
1399
1440
    @staticmethod
1400
1441
    def get_raw(bundle_file):
1402
1443
        line = bundle_file.readline()
1403
1444
        line = bundle_file.readline()
1404
1445
        lines = bundle_file.readlines()
1405
 
        return ''.join(lines).decode('bz2')
 
1446
        return bz2.decompress(b''.join(lines))
1406
1447
 
1407
1448
    def test_copy_signatures(self):
1408
1449
        tree_a = self.make_branch_and_tree('tree_a')
1409
 
        import bzrlib.gpg
1410
 
        import bzrlib.commit as commit
1411
 
        oldstrategy = bzrlib.gpg.GPGStrategy
 
1450
        import breezy.gpg
 
1451
        import breezy.commit as commit
 
1452
        oldstrategy = breezy.gpg.GPGStrategy
1412
1453
        branch = tree_a.branch
1413
1454
        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'))
 
1455
        tree_a.commit("base", allow_pointless=True, rev_id=b'A')
 
1456
        self.assertFalse(branch.repository.has_signature_for_revision_id(b'A'))
1416
1457
        try:
1417
 
            from bzrlib.testament import Testament
 
1458
            from ..testament import Testament
1418
1459
            # 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",
1422
 
                                                    allow_pointless=True,
1423
 
                                                    rev_id='B',
1424
 
                                                    working_tree=tree_a)
 
1460
            breezy.gpg.GPGStrategy = breezy.gpg.LoopbackGPGStrategy
 
1461
            new_config = test_commit.MustSignConfig()
 
1462
            commit.Commit(config_stack=new_config).commit(message="base",
 
1463
                                                          allow_pointless=True,
 
1464
                                                          rev_id=b'B',
 
1465
                                                          working_tree=tree_a)
 
1466
 
1425
1467
            def sign(text):
1426
 
                return bzrlib.gpg.LoopbackGPGStrategy(None).sign(text)
1427
 
            self.assertTrue(repo_a.has_signature_for_revision_id('B'))
 
1468
                return breezy.gpg.LoopbackGPGStrategy(None).sign(text)
 
1469
            self.assertTrue(repo_a.has_signature_for_revision_id(b'B'))
1428
1470
        finally:
1429
 
            bzrlib.gpg.GPGStrategy = oldstrategy
 
1471
            breezy.gpg.GPGStrategy = oldstrategy
1430
1472
        tree_b = self.make_branch_and_tree('tree_b')
1431
1473
        repo_b = tree_b.branch.repository
1432
 
        s = StringIO()
 
1474
        s = BytesIO()
1433
1475
        serializer = BundleSerializerV4('4')
1434
 
        serializer.write(tree_a.branch.repository, ['A', 'B'], {}, s)
 
1476
        with tree_a.lock_read():
 
1477
            serializer.write_bundle(
 
1478
                tree_a.branch.repository, b'B', b'null:', s)
1435
1479
        s.seek(0)
1436
1480
        install_bundle(repo_b, serializer.read(s))
1437
 
        self.assertTrue(repo_b.has_signature_for_revision_id('B'))
1438
 
        self.assertEqual(repo_b.get_signature_text('B'),
1439
 
                         repo_a.get_signature_text('B'))
 
1481
        self.assertTrue(repo_b.has_signature_for_revision_id(b'B'))
 
1482
        self.assertEqual(repo_b.get_signature_text(b'B'),
 
1483
                         repo_a.get_signature_text(b'B'))
1440
1484
        s.seek(0)
1441
1485
        # ensure repeat installs are harmless
1442
1486
        install_bundle(repo_b, serializer.read(s))
1443
1487
 
1444
1488
 
1445
 
class V4WeaveBundleTester(V4BundleTester):
1446
 
 
1447
 
    def bzrdir_format(self):
1448
 
        return 'metaweave'
1449
 
 
1450
 
 
1451
1489
class V4_2aBundleTester(V4BundleTester):
1452
1490
 
1453
1491
    def bzrdir_format(self):
1459
1497
 
1460
1498
        :return: The in-memory bundle
1461
1499
        """
1462
 
        from bzrlib.bundle import serializer
 
1500
        from ..bundle import serializer
1463
1501
        bundle_txt, rev_ids = self.create_bundle_text(base_rev_id, rev_id)
1464
 
        new_text = self.get_raw(StringIO(''.join(bundle_txt)))
 
1502
        new_text = self.get_raw(BytesIO(b''.join(bundle_txt)))
1465
1503
        # We are going to be replacing some text to set the executable bit on a
1466
1504
        # file. Make sure the text replacement actually works correctly.
1467
 
        self.assertContainsRe(new_text, '(?m)B244\n\ni 1\n<inventory')
1468
 
        new_text = new_text.replace('<file file_id="exe-1"',
1469
 
                                    '<file executable="y" file_id="exe-1"')
1470
 
        new_text = new_text.replace('B244', 'B259')
1471
 
        bundle_txt = StringIO()
 
1505
        self.assertContainsRe(new_text, b'(?m)B244\n\ni 1\n<inventory')
 
1506
        new_text = new_text.replace(b'<file file_id="exe-1"',
 
1507
                                    b'<file executable="y" file_id="exe-1"')
 
1508
        new_text = new_text.replace(b'B244', b'B259')
 
1509
        bundle_txt = BytesIO()
1472
1510
        bundle_txt.write(serializer._get_bundle_header('4'))
1473
 
        bundle_txt.write('\n')
1474
 
        bundle_txt.write(new_text.encode('bz2'))
 
1511
        bundle_txt.write(b'\n')
 
1512
        bundle_txt.write(bz2.compress(new_text))
1475
1513
        bundle_txt.seek(0)
1476
1514
        bundle = read_bundle(bundle_txt)
1477
1515
        self.valid_apply_bundle(base_rev_id, bundle)
1480
1518
    def make_merged_branch(self):
1481
1519
        builder = self.make_branch_builder('source')
1482
1520
        builder.start_series()
1483
 
        builder.build_snapshot('a@cset-0-1', None, [
1484
 
            ('add', ('', 'root-id', 'directory', None)),
1485
 
            ('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
 
            ])
 
1521
        builder.build_snapshot(None, [
 
1522
            ('add', ('', b'root-id', 'directory', None)),
 
1523
            ('add', ('file', b'file-id', 'file', b'original content\n')),
 
1524
            ], revision_id=b'a@cset-0-1')
 
1525
        builder.build_snapshot([b'a@cset-0-1'], [
 
1526
            ('modify', ('file', b'new-content\n')),
 
1527
            ], revision_id=b'a@cset-0-2a')
 
1528
        builder.build_snapshot([b'a@cset-0-1'], [
 
1529
            ('add', ('other-file', b'file2-id', 'file', b'file2-content\n')),
 
1530
            ], revision_id=b'a@cset-0-2b')
 
1531
        builder.build_snapshot([b'a@cset-0-2a', b'a@cset-0-2b'], [
 
1532
            ('add', ('other-file', b'file2-id', 'file', b'file2-content\n')),
 
1533
            ], revision_id=b'a@cset-0-3')
1496
1534
        builder.finish_series()
1497
1535
        self.b1 = builder.get_branch()
1498
1536
        self.b1.lock_read()
1501
1539
    def make_bundle_just_inventories(self, base_revision_id,
1502
1540
                                     target_revision_id,
1503
1541
                                     revision_ids):
1504
 
        sio = StringIO()
 
1542
        sio = BytesIO()
1505
1543
        writer = v4.BundleWriteOperation(base_revision_id, target_revision_id,
1506
1544
                                         self.b1.repository, sio)
1507
1545
        writer.bundle.begin()
1512
1550
 
1513
1551
    def test_single_inventory_multiple_parents_as_xml(self):
1514
1552
        self.make_merged_branch()
1515
 
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
1516
 
                                                ['a@cset-0-3'])
 
1553
        sio = self.make_bundle_just_inventories(b'a@cset-0-1', b'a@cset-0-3',
 
1554
                                                [b'a@cset-0-3'])
1517
1555
        reader = v4.BundleReader(sio, stream_input=False)
1518
1556
        records = list(reader.iter_records())
1519
1557
        self.assertEqual(1, len(records))
1520
1558
        (bytes, metadata, repo_kind, revision_id,
1521
1559
         file_id) = records[0]
1522
1560
        self.assertIs(None, file_id)
1523
 
        self.assertEqual('a@cset-0-3', revision_id)
 
1561
        self.assertEqual(b'a@cset-0-3', revision_id)
1524
1562
        self.assertEqual('inventory', repo_kind)
1525
 
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
1526
 
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
1527
 
                          'storage_kind': 'mpdiff',
1528
 
                         }, metadata)
 
1563
        self.assertEqual({b'parents': [b'a@cset-0-2a', b'a@cset-0-2b'],
 
1564
                          b'sha1': b'09c53b0c4de0895e11a2aacc34fef60a6e70865c',
 
1565
                          b'storage_kind': b'mpdiff',
 
1566
                          }, metadata)
1529
1567
        # We should have an mpdiff that takes some lines from both parents.
1530
1568
        self.assertEqualDiff(
1531
 
            'i 1\n'
1532
 
            '<inventory format="10" revision_id="a@cset-0-3">\n'
1533
 
            '\n'
1534
 
            'c 0 1 1 2\n'
1535
 
            'c 1 3 3 2\n', bytes)
 
1569
            b'i 1\n'
 
1570
            b'<inventory format="10" revision_id="a@cset-0-3">\n'
 
1571
            b'\n'
 
1572
            b'c 0 1 1 2\n'
 
1573
            b'c 1 3 3 2\n', bytes)
1536
1574
 
1537
1575
    def test_single_inv_no_parents_as_xml(self):
1538
1576
        self.make_merged_branch()
1539
 
        sio = self.make_bundle_just_inventories('null:', 'a@cset-0-1',
1540
 
                                                ['a@cset-0-1'])
 
1577
        sio = self.make_bundle_just_inventories(b'null:', b'a@cset-0-1',
 
1578
                                                [b'a@cset-0-1'])
1541
1579
        reader = v4.BundleReader(sio, stream_input=False)
1542
1580
        records = list(reader.iter_records())
1543
1581
        self.assertEqual(1, len(records))
1544
1582
        (bytes, metadata, repo_kind, revision_id,
1545
1583
         file_id) = records[0]
1546
1584
        self.assertIs(None, file_id)
1547
 
        self.assertEqual('a@cset-0-1', revision_id)
 
1585
        self.assertEqual(b'a@cset-0-1', revision_id)
1548
1586
        self.assertEqual('inventory', repo_kind)
1549
 
        self.assertEqual({'parents': [],
1550
 
                          'sha1': 'a13f42b142d544aac9b085c42595d304150e31a2',
1551
 
                          'storage_kind': 'mpdiff',
1552
 
                         }, metadata)
 
1587
        self.assertEqual({b'parents': [],
 
1588
                          b'sha1': b'a13f42b142d544aac9b085c42595d304150e31a2',
 
1589
                          b'storage_kind': b'mpdiff',
 
1590
                          }, metadata)
1553
1591
        # We should have an mpdiff that takes some lines from both parents.
1554
1592
        self.assertEqualDiff(
1555
 
            'i 4\n'
1556
 
            '<inventory format="10" revision_id="a@cset-0-1">\n'
1557
 
            '<directory file_id="root-id" name=""'
1558
 
                ' revision="a@cset-0-1" />\n'
1559
 
            '<file file_id="file-id" name="file" parent_id="root-id"'
1560
 
                ' revision="a@cset-0-1"'
1561
 
                ' text_sha1="09c2f8647e14e49e922b955c194102070597c2d1"'
1562
 
                ' text_size="17" />\n'
1563
 
            '</inventory>\n'
1564
 
            '\n', bytes)
 
1593
            b'i 4\n'
 
1594
            b'<inventory format="10" revision_id="a@cset-0-1">\n'
 
1595
            b'<directory file_id="root-id" name=""'
 
1596
            b' revision="a@cset-0-1" />\n'
 
1597
            b'<file file_id="file-id" name="file" parent_id="root-id"'
 
1598
            b' revision="a@cset-0-1"'
 
1599
            b' text_sha1="09c2f8647e14e49e922b955c194102070597c2d1"'
 
1600
            b' text_size="17" />\n'
 
1601
            b'</inventory>\n'
 
1602
            b'\n', bytes)
1565
1603
 
1566
1604
    def test_multiple_inventories_as_xml(self):
1567
1605
        self.make_merged_branch()
1568
 
        sio = self.make_bundle_just_inventories('a@cset-0-1', 'a@cset-0-3',
1569
 
            ['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'])
 
1606
        sio = self.make_bundle_just_inventories(b'a@cset-0-1', b'a@cset-0-3',
 
1607
                                                [b'a@cset-0-2a', b'a@cset-0-2b', b'a@cset-0-3'])
1570
1608
        reader = v4.BundleReader(sio, stream_input=False)
1571
1609
        records = list(reader.iter_records())
1572
1610
        self.assertEqual(3, len(records))
1573
1611
        revision_ids = [rev_id for b, m, k, rev_id, f in records]
1574
 
        self.assertEqual(['a@cset-0-2a', 'a@cset-0-2b', 'a@cset-0-3'],
 
1612
        self.assertEqual([b'a@cset-0-2a', b'a@cset-0-2b', b'a@cset-0-3'],
1575
1613
                         revision_ids)
1576
1614
        metadata_2a = records[0][1]
1577
 
        self.assertEqual({'parents': ['a@cset-0-1'],
1578
 
                          'sha1': '1e105886d62d510763e22885eec733b66f5f09bf',
1579
 
                          'storage_kind': 'mpdiff',
1580
 
                         }, metadata_2a)
 
1615
        self.assertEqual({b'parents': [b'a@cset-0-1'],
 
1616
                          b'sha1': b'1e105886d62d510763e22885eec733b66f5f09bf',
 
1617
                          b'storage_kind': b'mpdiff',
 
1618
                          }, metadata_2a)
1581
1619
        metadata_2b = records[1][1]
1582
 
        self.assertEqual({'parents': ['a@cset-0-1'],
1583
 
                          'sha1': 'f03f12574bdb5ed2204c28636c98a8547544ccd8',
1584
 
                          'storage_kind': 'mpdiff',
1585
 
                         }, metadata_2b)
 
1620
        self.assertEqual({b'parents': [b'a@cset-0-1'],
 
1621
                          b'sha1': b'f03f12574bdb5ed2204c28636c98a8547544ccd8',
 
1622
                          b'storage_kind': b'mpdiff',
 
1623
                          }, metadata_2b)
1586
1624
        metadata_3 = records[2][1]
1587
 
        self.assertEqual({'parents': ['a@cset-0-2a', 'a@cset-0-2b'],
1588
 
                          'sha1': '09c53b0c4de0895e11a2aacc34fef60a6e70865c',
1589
 
                          'storage_kind': 'mpdiff',
1590
 
                         }, metadata_3)
 
1625
        self.assertEqual({b'parents': [b'a@cset-0-2a', b'a@cset-0-2b'],
 
1626
                          b'sha1': b'09c53b0c4de0895e11a2aacc34fef60a6e70865c',
 
1627
                          b'storage_kind': b'mpdiff',
 
1628
                          }, metadata_3)
1591
1629
        bytes_2a = records[0][0]
1592
1630
        self.assertEqualDiff(
1593
 
            'i 1\n'
1594
 
            '<inventory format="10" revision_id="a@cset-0-2a">\n'
1595
 
            '\n'
1596
 
            'c 0 1 1 1\n'
1597
 
            'i 1\n'
1598
 
            '<file file_id="file-id" name="file" parent_id="root-id"'
1599
 
                ' revision="a@cset-0-2a"'
1600
 
                ' text_sha1="50f545ff40e57b6924b1f3174b267ffc4576e9a9"'
1601
 
                ' text_size="12" />\n'
1602
 
            '\n'
1603
 
            'c 0 3 3 1\n', bytes_2a)
 
1631
            b'i 1\n'
 
1632
            b'<inventory format="10" revision_id="a@cset-0-2a">\n'
 
1633
            b'\n'
 
1634
            b'c 0 1 1 1\n'
 
1635
            b'i 1\n'
 
1636
            b'<file file_id="file-id" name="file" parent_id="root-id"'
 
1637
            b' revision="a@cset-0-2a"'
 
1638
            b' text_sha1="50f545ff40e57b6924b1f3174b267ffc4576e9a9"'
 
1639
            b' text_size="12" />\n'
 
1640
            b'\n'
 
1641
            b'c 0 3 3 1\n', bytes_2a)
1604
1642
        bytes_2b = records[1][0]
1605
1643
        self.assertEqualDiff(
1606
 
            'i 1\n'
1607
 
            '<inventory format="10" revision_id="a@cset-0-2b">\n'
1608
 
            '\n'
1609
 
            'c 0 1 1 2\n'
1610
 
            'i 1\n'
1611
 
            '<file file_id="file2-id" name="other-file" parent_id="root-id"'
1612
 
                ' revision="a@cset-0-2b"'
1613
 
                ' text_sha1="b46c0c8ea1e5ef8e46fc8894bfd4752a88ec939e"'
1614
 
                ' text_size="14" />\n'
1615
 
            '\n'
1616
 
            'c 0 3 4 1\n', bytes_2b)
 
1644
            b'i 1\n'
 
1645
            b'<inventory format="10" revision_id="a@cset-0-2b">\n'
 
1646
            b'\n'
 
1647
            b'c 0 1 1 2\n'
 
1648
            b'i 1\n'
 
1649
            b'<file file_id="file2-id" name="other-file" parent_id="root-id"'
 
1650
            b' revision="a@cset-0-2b"'
 
1651
            b' text_sha1="b46c0c8ea1e5ef8e46fc8894bfd4752a88ec939e"'
 
1652
            b' text_size="14" />\n'
 
1653
            b'\n'
 
1654
            b'c 0 3 4 1\n', bytes_2b)
1617
1655
        bytes_3 = records[2][0]
1618
1656
        self.assertEqualDiff(
1619
 
            'i 1\n'
1620
 
            '<inventory format="10" revision_id="a@cset-0-3">\n'
1621
 
            '\n'
1622
 
            'c 0 1 1 2\n'
1623
 
            'c 1 3 3 2\n', bytes_3)
 
1657
            b'i 1\n'
 
1658
            b'<inventory format="10" revision_id="a@cset-0-3">\n'
 
1659
            b'\n'
 
1660
            b'c 0 1 1 2\n'
 
1661
            b'c 1 3 3 2\n', bytes_3)
1624
1662
 
1625
1663
    def test_creating_bundle_preserves_chk_pages(self):
1626
1664
        self.make_merged_branch()
1627
 
        target = self.b1.bzrdir.sprout('target',
1628
 
                                       revision_id='a@cset-0-2a').open_branch()
1629
 
        bundle_txt, rev_ids = self.create_bundle_text('a@cset-0-2a',
1630
 
                                                      'a@cset-0-3')
1631
 
        self.assertEqual(['a@cset-0-2b', 'a@cset-0-3'], rev_ids)
 
1665
        target = self.b1.controldir.sprout('target',
 
1666
                                           revision_id=b'a@cset-0-2a').open_branch()
 
1667
        bundle_txt, rev_ids = self.create_bundle_text(b'a@cset-0-2a',
 
1668
                                                      b'a@cset-0-3')
 
1669
        self.assertEqual(set([b'a@cset-0-2b', b'a@cset-0-3']), set(rev_ids))
1632
1670
        bundle = read_bundle(bundle_txt)
1633
1671
        target.lock_write()
1634
1672
        self.addCleanup(target.unlock)
1635
1673
        install_bundle(target.repository, bundle)
1636
 
        inv1 = self.b1.repository.inventories.get_record_stream([
1637
 
            ('a@cset-0-3',)], 'unordered',
1638
 
            True).next().get_bytes_as('fulltext')
1639
 
        inv2 = target.repository.inventories.get_record_stream([
1640
 
            ('a@cset-0-3',)], 'unordered',
1641
 
            True).next().get_bytes_as('fulltext')
 
1674
        inv1 = next(self.b1.repository.inventories.get_record_stream([
 
1675
            (b'a@cset-0-3',)], 'unordered',
 
1676
            True)).get_bytes_as('fulltext')
 
1677
        inv2 = next(target.repository.inventories.get_record_stream([
 
1678
            (b'a@cset-0-3',)], 'unordered',
 
1679
            True)).get_bytes_as('fulltext')
1642
1680
        self.assertEqualDiff(inv1, inv2)
1643
1681
 
1644
1682
 
1649
1687
 
1650
1688
        self.build_tree(['b1/one'])
1651
1689
        wt.add('one')
1652
 
        wt.commit('add one', rev_id='a@cset-0-1')
 
1690
        wt.commit('add one', rev_id=b'a@cset-0-1')
1653
1691
        self.build_tree(['b1/two'])
1654
1692
        wt.add('two')
1655
 
        wt.commit('add two', rev_id='a@cset-0-2',
1656
 
                  revprops={'branch-nick':'test'})
 
1693
        wt.commit('add two', rev_id=b'a@cset-0-2',
 
1694
                  revprops={u'branch-nick': 'test'})
1657
1695
 
1658
 
        bundle_txt = StringIO()
1659
 
        rev_ids = write_bundle(wt.branch.repository, 'a@cset-0-2',
1660
 
                               'a@cset-0-1', bundle_txt, self.format)
1661
 
        self.assertEqual(set(['a@cset-0-2']), set(rev_ids))
 
1696
        bundle_txt = BytesIO()
 
1697
        rev_ids = write_bundle(wt.branch.repository, b'a@cset-0-2',
 
1698
                               b'a@cset-0-1', bundle_txt, self.format)
 
1699
        self.assertEqual({b'a@cset-0-2'}, set(rev_ids))
1662
1700
        bundle_txt.seek(0, 0)
1663
1701
        return bundle_txt
1664
1702
 
1665
1703
    def check_valid(self, bundle):
1666
1704
        """Check that after whatever munging, the final object is valid."""
1667
 
        self.assertEqual(['a@cset-0-2'],
1668
 
            [r.revision_id for r in bundle.real_revisions])
 
1705
        self.assertEqual([b'a@cset-0-2'],
 
1706
                         [r.revision_id for r in bundle.real_revisions])
1669
1707
 
1670
1708
    def test_extra_whitespace(self):
1671
1709
        bundle_txt = self.build_test_bundle()
1674
1712
        # Adding one extra newline used to give us
1675
1713
        # TypeError: float() argument must be a string or a number
1676
1714
        bundle_txt.seek(0, 2)
1677
 
        bundle_txt.write('\n')
 
1715
        bundle_txt.write(b'\n')
1678
1716
        bundle_txt.seek(0)
1679
1717
 
1680
1718
        bundle = read_bundle(bundle_txt)
1687
1725
        # Adding two extra newlines used to give us
1688
1726
        # MalformedPatches: The first line of all patches should be ...
1689
1727
        bundle_txt.seek(0, 2)
1690
 
        bundle_txt.write('\n\n')
 
1728
        bundle_txt.write(b'\n\n')
1691
1729
        bundle_txt.seek(0)
1692
1730
 
1693
1731
        bundle = read_bundle(bundle_txt)
1707
1745
        # test is concerned with the exact case where the serializer
1708
1746
        # creates a blank line at the end, and fails if that
1709
1747
        # line is stripped
1710
 
        self.assertEqual('\n\n', raw[-2:])
1711
 
        bundle_txt = StringIO(raw[:-1])
 
1748
        self.assertEqual(b'\n\n', raw[-2:])
 
1749
        bundle_txt = BytesIO(raw[:-1])
1712
1750
 
1713
1751
        bundle = read_bundle(bundle_txt)
1714
1752
        self.check_valid(bundle)
1716
1754
    def test_opening_text(self):
1717
1755
        bundle_txt = self.build_test_bundle()
1718
1756
 
1719
 
        bundle_txt = StringIO("Some random\nemail comments\n"
1720
 
                              + bundle_txt.getvalue())
 
1757
        bundle_txt = BytesIO(
 
1758
            b"Some random\nemail comments\n" + bundle_txt.getvalue())
1721
1759
 
1722
1760
        bundle = read_bundle(bundle_txt)
1723
1761
        self.check_valid(bundle)
1725
1763
    def test_trailing_text(self):
1726
1764
        bundle_txt = self.build_test_bundle()
1727
1765
 
1728
 
        bundle_txt = StringIO(bundle_txt.getvalue() +
1729
 
                              "Some trailing\nrandom\ntext\n")
 
1766
        bundle_txt = BytesIO(
 
1767
            bundle_txt.getvalue() + b"Some trailing\nrandom\ntext\n")
1730
1768
 
1731
1769
        bundle = read_bundle(bundle_txt)
1732
1770
        self.check_valid(bundle)
1740
1778
class TestBundleWriterReader(tests.TestCase):
1741
1779
 
1742
1780
    def test_roundtrip_record(self):
1743
 
        fileobj = StringIO()
 
1781
        fileobj = BytesIO()
1744
1782
        writer = v4.BundleWriter(fileobj)
1745
1783
        writer.begin()
1746
 
        writer.add_info_record(foo='bar')
1747
 
        writer._add_record("Record body", {'parents': ['1', '3'],
1748
 
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1784
        writer.add_info_record({b'foo': b'bar'})
 
1785
        writer._add_record(b"Record body", {b'parents': [b'1', b'3'],
 
1786
                                            b'storage_kind': b'fulltext'}, 'file', b'revid', b'fileid')
1749
1787
        writer.end()
1750
1788
        fileobj.seek(0)
1751
1789
        reader = v4.BundleReader(fileobj, stream_input=True)
1752
1790
        record_iter = reader.iter_records()
1753
 
        record = record_iter.next()
1754
 
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
1755
 
            'info', None, None), record)
1756
 
        record = record_iter.next()
1757
 
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
1758
 
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
1759
 
                          record)
 
1791
        record = next(record_iter)
 
1792
        self.assertEqual((None, {b'foo': b'bar', b'storage_kind': b'header'},
 
1793
                          'info', None, None), record)
 
1794
        record = next(record_iter)
 
1795
        self.assertEqual((b"Record body", {b'storage_kind': b'fulltext',
 
1796
                                           b'parents': [b'1', b'3']}, 'file', b'revid', b'fileid'),
 
1797
                         record)
1760
1798
 
1761
1799
    def test_roundtrip_record_memory_hungry(self):
1762
 
        fileobj = StringIO()
 
1800
        fileobj = BytesIO()
1763
1801
        writer = v4.BundleWriter(fileobj)
1764
1802
        writer.begin()
1765
 
        writer.add_info_record(foo='bar')
1766
 
        writer._add_record("Record body", {'parents': ['1', '3'],
1767
 
            'storage_kind':'fulltext'}, 'file', 'revid', 'fileid')
 
1803
        writer.add_info_record({b'foo': b'bar'})
 
1804
        writer._add_record(b"Record body", {b'parents': [b'1', b'3'],
 
1805
                                            b'storage_kind': b'fulltext'}, 'file', b'revid', b'fileid')
1768
1806
        writer.end()
1769
1807
        fileobj.seek(0)
1770
1808
        reader = v4.BundleReader(fileobj, stream_input=False)
1771
1809
        record_iter = reader.iter_records()
1772
 
        record = record_iter.next()
1773
 
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
1774
 
            'info', None, None), record)
1775
 
        record = record_iter.next()
1776
 
        self.assertEqual(("Record body", {'storage_kind': 'fulltext',
1777
 
                          'parents': ['1', '3']}, 'file', 'revid', 'fileid'),
1778
 
                          record)
 
1810
        record = next(record_iter)
 
1811
        self.assertEqual((None, {b'foo': b'bar', b'storage_kind': b'header'},
 
1812
                          'info', None, None), record)
 
1813
        record = next(record_iter)
 
1814
        self.assertEqual((b"Record body", {b'storage_kind': b'fulltext',
 
1815
                                           b'parents': [b'1', b'3']}, 'file', b'revid', b'fileid'),
 
1816
                         record)
1779
1817
 
1780
1818
    def test_encode_name(self):
1781
 
        self.assertEqual('revision/rev1',
1782
 
            v4.BundleWriter.encode_name('revision', 'rev1'))
1783
 
        self.assertEqual('file/rev//1/file-id-1',
1784
 
            v4.BundleWriter.encode_name('file', 'rev/1', 'file-id-1'))
1785
 
        self.assertEqual('info',
1786
 
            v4.BundleWriter.encode_name('info', None, None))
 
1819
        self.assertEqual(b'revision/rev1',
 
1820
                         v4.BundleWriter.encode_name('revision', b'rev1'))
 
1821
        self.assertEqual(b'file/rev//1/file-id-1',
 
1822
                         v4.BundleWriter.encode_name('file', b'rev/1', b'file-id-1'))
 
1823
        self.assertEqual(b'info',
 
1824
                         v4.BundleWriter.encode_name('info', None, None))
1787
1825
 
1788
1826
    def test_decode_name(self):
1789
 
        self.assertEqual(('revision', 'rev1', None),
1790
 
            v4.BundleReader.decode_name('revision/rev1'))
1791
 
        self.assertEqual(('file', 'rev/1', 'file-id-1'),
1792
 
            v4.BundleReader.decode_name('file/rev//1/file-id-1'))
 
1827
        self.assertEqual(('revision', b'rev1', None),
 
1828
                         v4.BundleReader.decode_name(b'revision/rev1'))
 
1829
        self.assertEqual(('file', b'rev/1', b'file-id-1'),
 
1830
                         v4.BundleReader.decode_name(b'file/rev//1/file-id-1'))
1793
1831
        self.assertEqual(('info', None, None),
1794
 
                         v4.BundleReader.decode_name('info'))
 
1832
                         v4.BundleReader.decode_name(b'info'))
1795
1833
 
1796
1834
    def test_too_many_names(self):
1797
 
        fileobj = StringIO()
 
1835
        fileobj = BytesIO()
1798
1836
        writer = v4.BundleWriter(fileobj)
1799
1837
        writer.begin()
1800
 
        writer.add_info_record(foo='bar')
1801
 
        writer._container.add_bytes_record('blah', ['two', 'names'])
 
1838
        writer.add_info_record({b'foo': b'bar'})
 
1839
        writer._container.add_bytes_record(b'blah', [(b'two', ), (b'names', )])
1802
1840
        writer.end()
1803
1841
        fileobj.seek(0)
1804
1842
        record_iter = v4.BundleReader(fileobj).iter_records()
1805
 
        record = record_iter.next()
1806
 
        self.assertEqual((None, {'foo': 'bar', 'storage_kind': 'header'},
1807
 
            'info', None, None), record)
1808
 
        self.assertRaises(errors.BadBundle, record_iter.next)
 
1843
        record = next(record_iter)
 
1844
        self.assertEqual((None, {b'foo': b'bar', b'storage_kind': b'header'},
 
1845
                          'info', None, None), record)
 
1846
        self.assertRaises(errors.BadBundle, next, record_iter)
1809
1847
 
1810
1848
 
1811
1849
class TestReadMergeableFromUrl(tests.TestCaseWithTransport):
1814
1852
        """A local bundle named like the URL should not be read.
1815
1853
        """
1816
1854
        out, wt = test_read_bundle.create_bundle_file(self)
 
1855
 
1817
1856
        class FooService(object):
1818
1857
            """A directory service that always returns source"""
1819
1858
 
1828
1867
    def test_infinite_redirects_are_not_a_bundle(self):
1829
1868
        """If a URL causes TooManyRedirections then NotABundle is raised.
1830
1869
        """
1831
 
        from bzrlib.tests.blackbox.test_push import RedirectingMemoryServer
 
1870
        from .blackbox.test_push import RedirectingMemoryServer
1832
1871
        server = RedirectingMemoryServer()
1833
1872
        self.start_server(server)
1834
1873
        url = server.get_url() + 'infinite-loop'
1839
1878
        bundle, then the ConnectionReset error should be propagated.
1840
1879
        """
1841
1880
        # Instantiate a server that will provoke a ConnectionReset
1842
 
        sock_server = _DisconnectingTCPServer()
 
1881
        sock_server = DisconnectingServer()
1843
1882
        self.start_server(sock_server)
1844
1883
        # We don't really care what the url is since the server will close the
1845
1884
        # connection without interpreting it
1847
1886
        self.assertRaises(errors.ConnectionReset, read_mergeable_from_url, url)
1848
1887
 
1849
1888
 
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()
 
1889
class DisconnectingHandler(socketserver.BaseRequestHandler):
 
1890
    """A request handler that immediately closes any connection made to it."""
 
1891
 
 
1892
    def handle(self):
 
1893
        self.request.close()
 
1894
 
 
1895
 
 
1896
class DisconnectingServer(test_server.TestingTCPServerInAThread):
 
1897
 
 
1898
    def __init__(self):
 
1899
        super(DisconnectingServer, self).__init__(
 
1900
            ('127.0.0.1', 0),
 
1901
            test_server.TestingTCPServer,
 
1902
            DisconnectingHandler)
1867
1903
 
1868
1904
    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()
 
1905
        """Return the url of the server"""
 
1906
        return "bzr://%s:%d/" % self.server.server_address