/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to breezy/tests/test_bundle.py

  • Committer: Jelmer Vernooij
  • Date: 2020-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

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