/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: 2017-07-23 22:06:41 UTC
  • mfrom: (6738 trunk)
  • mto: This revision was merged to the branch mainline in revision 6739.
  • Revision ID: jelmer@jelmer.uk-20170723220641-69eczax9bmv8d6kk
Merge trunk, address review comments.

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