/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-07-04 12:50:55 UTC
  • mfrom: (7027.2.8 git-fixes)
  • Revision ID: breezy.the.bot@gmail.com-20180704125055-8nni25pn2439p48v
Fix eol handling in knits on Python 3, port fastimport plugin to Python 3.

Merged from https://code.launchpad.net/~jelmer/brz/fastimport-fixes/+merge/348924

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