/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_inv.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_inv.py
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
from ... import (
 
18
from .. import (
19
19
    errors,
20
20
    osutils,
21
21
    repository,
23
23
    tests,
24
24
    workingtree,
25
25
    )
26
 
from .. import (
 
26
from ..bzr import (
27
27
    chk_map,
28
28
    groupcompress,
29
29
    inventory,
30
30
    )
31
 
from ..inventory import (
 
31
from ..bzr.inventory import (
32
32
    CHKInventory,
33
 
    DuplicateFileId,
34
33
    Inventory,
35
34
    ROOT_ID,
36
35
    InventoryFile,
37
36
    InventoryDirectory,
38
37
    InventoryEntry,
39
 
    InvalidEntryName,
40
38
    TreeReference,
41
39
    mutable_inventory_from_tree,
42
40
    )
44
42
    TestCase,
45
43
    TestCaseWithTransport,
46
44
    )
47
 
from ...tests.scenarios import load_tests_apply_scenarios
 
45
from .scenarios import load_tests_apply_scenarios
48
46
 
49
47
 
50
48
load_tests = load_tests_apply_scenarios
52
50
 
53
51
def delta_application_scenarios():
54
52
    scenarios = [
55
 
        ('Inventory', {'apply_delta': apply_inventory_Inventory}),
 
53
        ('Inventory', {'apply_delta':apply_inventory_Inventory}),
56
54
        ]
57
55
    # Working tree basis delta application
58
56
    # Repository add_inv_by_delta.
63
61
    for _, format in repository.format_registry.iteritems():
64
62
        if format.supports_full_versioned_files:
65
63
            scenarios.append((str(format.__name__), {
66
 
                'apply_delta': apply_inventory_Repository_add_inventory_by_delta,
67
 
                'format': format}))
68
 
    for getter in workingtree.format_registry._get_all_lazy():
69
 
        try:
70
 
            format = getter()
71
 
            if callable(format):
72
 
                format = format()
73
 
        except ImportError:
74
 
            pass  # Format with unmet dependency
75
 
        repo_fmt = format._matchingcontroldir.repository_format
 
64
                'apply_delta':apply_inventory_Repository_add_inventory_by_delta,
 
65
                'format':format}))
 
66
    for format in workingtree.format_registry._get_all():
 
67
        repo_fmt = format._matchingbzrdir.repository_format
76
68
        if not repo_fmt.supports_full_versioned_files:
77
69
            continue
78
70
        scenarios.append(
79
71
            (str(format.__class__.__name__) + ".update_basis_by_delta", {
80
 
                'apply_delta': apply_inventory_WT_basis,
81
 
                'format': format}))
 
72
            'apply_delta':apply_inventory_WT_basis,
 
73
            'format':format}))
82
74
        scenarios.append(
83
75
            (str(format.__class__.__name__) + ".apply_inventory_delta", {
84
 
                'apply_delta': apply_inventory_WT,
85
 
                'format': format}))
 
76
            'apply_delta':apply_inventory_WT,
 
77
            'format':format}))
86
78
    return scenarios
87
79
 
88
80
 
89
81
def create_texts_for_inv(repo, inv):
90
82
    for path, ie in inv.iter_entries():
91
83
        if ie.text_size:
92
 
            lines = [b'a' * ie.text_size]
 
84
            lines = ['a' * ie.text_size]
93
85
        else:
94
86
            lines = []
95
87
        repo.texts.add_lines((ie.file_id, ie.revision), [], lines)
115
107
    :param delta: The inventory delta to apply:
116
108
    :return: An inventory resulting from the application.
117
109
    """
118
 
    control = self.make_controldir(
119
 
        'tree', format=self.format._matchingcontroldir)
 
110
    control = self.make_controldir('tree', format=self.format._matchingbzrdir)
120
111
    control.create_repository()
121
112
    control.create_branch()
122
113
    tree = self.format.initialize(control)
142
133
 
143
134
 
144
135
def _create_repo_revisions(repo, basis, delta, invalid_delta):
145
 
    with repository.WriteGroup(repo):
146
 
        rev = revision.Revision(b'basis', timestamp=0, timezone=None,
147
 
                                message="", committer="foo@example.com")
148
 
        basis.revision_id = b'basis'
 
136
    repo.start_write_group()
 
137
    try:
 
138
        rev = revision.Revision('basis', timestamp=0, timezone=None,
 
139
            message="", committer="foo@example.com")
 
140
        basis.revision_id = 'basis'
149
141
        create_texts_for_inv(repo, basis)
150
 
        repo.add_revision(b'basis', rev, basis)
 
142
        repo.add_revision('basis', rev, basis)
151
143
        if invalid_delta:
152
144
            # We don't want to apply the delta to the basis, because we expect
153
145
            # the delta is invalid.
154
146
            result_inv = basis
155
 
            result_inv.revision_id = b'result'
 
147
            result_inv.revision_id = 'result'
156
148
            target_entries = None
157
149
        else:
158
 
            result_inv = basis.create_by_apply_delta(delta, b'result')
 
150
            result_inv = basis.create_by_apply_delta(delta, 'result')
159
151
            create_texts_for_inv(repo, result_inv)
160
152
            target_entries = list(result_inv.iter_entries_by_dir())
161
 
        rev = revision.Revision(b'result', timestamp=0, timezone=None,
162
 
                                message="", committer="foo@example.com")
163
 
        repo.add_revision(b'result', rev, result_inv)
 
153
        rev = revision.Revision('result', timestamp=0, timezone=None,
 
154
            message="", committer="foo@example.com")
 
155
        repo.add_revision('result', rev, result_inv)
 
156
        repo.commit_write_group()
 
157
    except:
 
158
        repo.abort_write_group()
 
159
        raise
164
160
    return target_entries
165
161
 
166
162
 
167
163
def _get_basis_entries(tree):
168
164
    basis_tree = tree.basis_tree()
169
 
    with basis_tree.lock_read():
170
 
        return list(basis_tree.inventory.iter_entries_by_dir())
 
165
    basis_tree.lock_read()
 
166
    basis_tree_entries = list(basis_tree.inventory.iter_entries_by_dir())
 
167
    basis_tree.unlock()
 
168
    return basis_tree_entries
171
169
 
172
170
 
173
171
def _populate_different_tree(tree, basis, delta):
174
172
    """Put all entries into tree, but at a unique location."""
175
173
    added_ids = set()
176
174
    added_paths = set()
177
 
    tree.add(['unique-dir'], [b'unique-dir-id'], ['directory'])
 
175
    tree.add(['unique-dir'], ['unique-dir-id'], ['directory'])
178
176
    for path, ie in basis.iter_entries_by_dir():
179
177
        if ie.file_id in added_ids:
180
178
            continue
200
198
    :param delta: The inventory delta to apply:
201
199
    :return: An inventory resulting from the application.
202
200
    """
203
 
    control = test.make_controldir(
204
 
        'tree', format=test.format._matchingcontroldir)
 
201
    control = test.make_controldir('tree', format=test.format._matchingbzrdir)
205
202
    control.create_repository()
206
203
    control.create_branch()
207
204
    tree = test.format.initialize(control)
213
210
        tree._write_inventory(basis)
214
211
        # This reads basis from the repo and puts it into the tree's local
215
212
        # cache, if it has one.
216
 
        tree.set_parent_ids([b'basis'])
 
213
        tree.set_parent_ids(['basis'])
217
214
    finally:
218
215
        tree.unlock()
219
216
    # Fresh lock, reads disk again.
220
 
    with tree.lock_write():
221
 
        tree.update_basis_by_delta(b'result', delta)
 
217
    tree.lock_write()
 
218
    try:
 
219
        tree.update_basis_by_delta('result', delta)
222
220
        if not invalid_delta:
223
221
            tree._validate()
 
222
    finally:
 
223
        tree.unlock()
224
224
    # reload tree - ensure we get what was written.
225
225
    tree = tree.controldir.open_workingtree()
226
226
    basis_tree = tree.basis_tree()
236
236
def apply_inventory_Repository_add_inventory_by_delta(self, basis, delta,
237
237
                                                      invalid_delta=True):
238
238
    """Apply delta to basis and return the result.
239
 
 
 
239
    
240
240
    This inserts basis as a whole inventory and then uses
241
241
    add_inventory_by_delta to add delta.
242
242
 
245
245
    :return: An inventory resulting from the application.
246
246
    """
247
247
    format = self.format()
248
 
    control = self.make_controldir('tree', format=format._matchingcontroldir)
 
248
    control = self.make_controldir('tree', format=format._matchingbzrdir)
249
249
    repo = format.initialize(control)
250
 
    with repo.lock_write(), repository.WriteGroup(repo):
251
 
        rev = revision.Revision(
252
 
            b'basis', timestamp=0, timezone=None, message="",
253
 
            committer="foo@example.com")
254
 
        basis.revision_id = b'basis'
255
 
        create_texts_for_inv(repo, basis)
256
 
        repo.add_revision(b'basis', rev, basis)
257
 
    with repo.lock_write(), repository.WriteGroup(repo):
258
 
        inv_sha1 = repo.add_inventory_by_delta(
259
 
            b'basis', delta, b'result', [b'basis'])
 
250
    repo.lock_write()
 
251
    try:
 
252
        repo.start_write_group()
 
253
        try:
 
254
            rev = revision.Revision('basis', timestamp=0, timezone=None,
 
255
                message="", committer="foo@example.com")
 
256
            basis.revision_id = 'basis'
 
257
            create_texts_for_inv(repo, basis)
 
258
            repo.add_revision('basis', rev, basis)
 
259
            repo.commit_write_group()
 
260
        except:
 
261
            repo.abort_write_group()
 
262
            raise
 
263
    finally:
 
264
        repo.unlock()
 
265
    repo.lock_write()
 
266
    try:
 
267
        repo.start_write_group()
 
268
        try:
 
269
            inv_sha1 = repo.add_inventory_by_delta('basis', delta,
 
270
                'result', ['basis'])
 
271
        except:
 
272
            repo.abort_write_group()
 
273
            raise
 
274
        else:
 
275
            repo.commit_write_group()
 
276
    finally:
 
277
        repo.unlock()
260
278
    # Fresh lock, reads disk again.
261
279
    repo = repo.controldir.open_repository()
262
280
    repo.lock_read()
263
281
    self.addCleanup(repo.unlock)
264
 
    return repo.get_inventory(b'result')
 
282
    return repo.get_inventory('result')
265
283
 
266
284
 
267
285
class TestInventoryUpdates(TestCase):
296
314
        inv.root.file_id = b'some-new-root'
297
315
        ie.name = u'file2'
298
316
        self.assertEqual(b'some-tree-root', inv2.root.file_id)
299
 
        self.assertEqual(u'hello', inv2.get_entry(b'hello-id').name)
 
317
        self.assertEqual(u'hello', inv2[b'hello-id'].name)
300
318
 
301
319
    def test_copy_empty(self):
302
320
        """Make sure an empty inventory can be copied."""
319
337
            revision=b'rev', reference_revision=b'rev2'))
320
338
 
321
339
    def test_error_encoding(self):
322
 
        inv = inventory.Inventory(b'tree-root')
323
 
        inv.add(InventoryFile(b'a-id', u'\u1234', b'tree-root'))
 
340
        inv = inventory.Inventory('tree-root')
 
341
        inv.add(InventoryFile('a-id', u'\u1234', 'tree-root'))
324
342
        e = self.assertRaises(errors.InconsistentDelta, inv.add,
325
 
                              InventoryFile(b'b-id', u'\u1234', b'tree-root'))
326
 
        self.assertContainsRe(str(e), '\\u1234')
 
343
            InventoryFile('b-id', u'\u1234', 'tree-root'))
 
344
        self.assertContainsRe(str(e), r'\\u1234')
327
345
 
328
346
    def test_add_recursive(self):
329
 
        parent = InventoryDirectory(b'src-id', 'src', b'tree-root')
330
 
        child = InventoryFile(b'hello-id', 'hello.c', b'src-id')
 
347
        parent = InventoryDirectory('src-id', 'src', 'tree-root')
 
348
        child = InventoryFile('hello-id', 'hello.c', 'src-id')
331
349
        parent.children[child.file_id] = child
332
 
        inv = inventory.Inventory(b'tree-root')
 
350
        inv = inventory.Inventory('tree-root')
333
351
        inv.add(parent)
334
 
        self.assertEqual('src/hello.c', inv.id2path(b'hello-id'))
 
352
        self.assertEqual('src/hello.c', inv.id2path('hello-id'))
 
353
 
335
354
 
336
355
 
337
356
class TestDeltaApplication(TestCaseWithTransport):
338
357
 
339
358
    scenarios = delta_application_scenarios()
340
 
 
 
359
 
341
360
    def get_empty_inventory(self, reference_inv=None):
342
361
        """Get an empty inventory.
343
362
 
354
373
        if reference_inv is not None:
355
374
            inv.root.revision = reference_inv.root.revision
356
375
        else:
357
 
            inv.root.revision = b'basis'
 
376
            inv.root.revision = 'basis'
358
377
        return inv
359
378
 
360
 
    def make_file_ie(self, file_id=b'file-id', name='name', parent_id=None):
 
379
    def make_file_ie(self, file_id='file-id', name='name', parent_id=None):
361
380
        ie_file = inventory.InventoryFile(file_id, name, parent_id)
362
 
        ie_file.revision = b'result'
 
381
        ie_file.revision = 'result'
363
382
        ie_file.text_size = 0
364
 
        ie_file.text_sha1 = b''
 
383
        ie_file.text_sha1 = ''
365
384
        return ie_file
366
385
 
367
386
    def test_empty_delta(self):
373
392
 
374
393
    def test_None_file_id(self):
375
394
        inv = self.get_empty_inventory()
376
 
        dir1 = inventory.InventoryDirectory(b'dirid', 'dir1', inv.root.file_id)
377
 
        dir1.file_id = None
378
 
        dir1.revision = b'result'
 
395
        dir1 = inventory.InventoryDirectory(None, 'dir1', inv.root.file_id)
 
396
        dir1.revision = 'result'
379
397
        delta = [(None, u'dir1', None, dir1)]
380
398
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
381
 
                          inv, delta)
 
399
            inv, delta)
382
400
 
383
401
    def test_unicode_file_id(self):
384
402
        inv = self.get_empty_inventory()
385
 
        dir1 = inventory.InventoryDirectory(b'dirid', 'dir1', inv.root.file_id)
386
 
        dir1.file_id = u'dirid'
387
 
        dir1.revision = b'result'
 
403
        dir1 = inventory.InventoryDirectory(u'dirid', 'dir1', inv.root.file_id)
 
404
        dir1.revision = 'result'
388
405
        delta = [(None, u'dir1', dir1.file_id, dir1)]
389
406
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
390
 
                          inv, delta)
 
407
            inv, delta)
391
408
 
392
409
    def test_repeated_file_id(self):
393
410
        inv = self.get_empty_inventory()
394
 
        file1 = inventory.InventoryFile(b'id', 'path1', inv.root.file_id)
395
 
        file1.revision = b'result'
 
411
        file1 = inventory.InventoryFile('id', 'path1', inv.root.file_id)
 
412
        file1.revision = 'result'
396
413
        file1.text_size = 0
397
 
        file1.text_sha1 = b""
 
414
        file1.text_sha1 = ""
398
415
        file2 = file1.copy()
399
416
        file2.name = 'path2'
400
 
        delta = [(None, u'path1', b'id', file1),
401
 
                 (None, u'path2', b'id', file2)]
 
417
        delta = [(None, u'path1', 'id', file1), (None, u'path2', 'id', file2)]
402
418
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
403
 
                          inv, delta)
 
419
            inv, delta)
404
420
 
405
421
    def test_repeated_new_path(self):
406
422
        inv = self.get_empty_inventory()
407
 
        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
408
 
        file1.revision = b'result'
 
423
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
 
424
        file1.revision = 'result'
409
425
        file1.text_size = 0
410
 
        file1.text_sha1 = b""
 
426
        file1.text_sha1 = ""
411
427
        file2 = file1.copy()
412
 
        file2.file_id = b'id2'
413
 
        delta = [(None, u'path', b'id1', file1),
414
 
                 (None, u'path', b'id2', file2)]
 
428
        file2.file_id = 'id2'
 
429
        delta = [(None, u'path', 'id1', file1), (None, u'path', 'id2', file2)]
415
430
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
416
 
                          inv, delta)
 
431
            inv, delta)
417
432
 
418
433
    def test_repeated_old_path(self):
419
434
        inv = self.get_empty_inventory()
420
 
        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
421
 
        file1.revision = b'result'
 
435
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
 
436
        file1.revision = 'result'
422
437
        file1.text_size = 0
423
 
        file1.text_sha1 = b""
 
438
        file1.text_sha1 = ""
424
439
        # We can't *create* a source inventory with the same path, but
425
440
        # a badly generated partial delta might claim the same source twice.
426
441
        # This would be buggy in two ways: the path is repeated in the delta,
427
442
        # And the path for one of the file ids doesn't match the source
428
443
        # location. Alternatively, we could have a repeated fileid, but that
429
444
        # is separately checked for.
430
 
        file2 = inventory.InventoryFile(b'id2', 'path2', inv.root.file_id)
431
 
        file2.revision = b'result'
 
445
        file2 = inventory.InventoryFile('id2', 'path2', inv.root.file_id)
 
446
        file2.revision = 'result'
432
447
        file2.text_size = 0
433
 
        file2.text_sha1 = b""
 
448
        file2.text_sha1 = ""
434
449
        inv.add(file1)
435
450
        inv.add(file2)
436
 
        delta = [(u'path', None, b'id1', None), (u'path', None, b'id2', None)]
 
451
        delta = [(u'path', None, 'id1', None), (u'path', None, 'id2', None)]
437
452
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
438
 
                          inv, delta)
 
453
            inv, delta)
439
454
 
440
455
    def test_mismatched_id_entry_id(self):
441
456
        inv = self.get_empty_inventory()
442
 
        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
443
 
        file1.revision = b'result'
 
457
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
 
458
        file1.revision = 'result'
444
459
        file1.text_size = 0
445
 
        file1.text_sha1 = b""
446
 
        delta = [(None, u'path', b'id', file1)]
 
460
        file1.text_sha1 = ""
 
461
        delta = [(None, u'path', 'id', file1)]
447
462
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
448
 
                          inv, delta)
 
463
            inv, delta)
449
464
 
450
465
    def test_mismatched_new_path_entry_None(self):
451
466
        inv = self.get_empty_inventory()
452
 
        delta = [(None, u'path', b'id', None)]
 
467
        delta = [(None, u'path', 'id', None)]
453
468
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
454
 
                          inv, delta)
 
469
            inv, delta)
455
470
 
456
471
    def test_mismatched_new_path_None_entry(self):
457
472
        inv = self.get_empty_inventory()
458
 
        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
459
 
        file1.revision = b'result'
 
473
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
 
474
        file1.revision = 'result'
460
475
        file1.text_size = 0
461
 
        file1.text_sha1 = b""
462
 
        delta = [(u"path", None, b'id1', file1)]
 
476
        file1.text_sha1 = ""
 
477
        delta = [(u"path", None, 'id1', file1)]
463
478
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
464
 
                          inv, delta)
 
479
            inv, delta)
465
480
 
466
481
    def test_parent_is_not_directory(self):
467
482
        inv = self.get_empty_inventory()
468
 
        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
469
 
        file1.revision = b'result'
 
483
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
 
484
        file1.revision = 'result'
470
485
        file1.text_size = 0
471
 
        file1.text_sha1 = b""
472
 
        file2 = inventory.InventoryFile(b'id2', 'path2', b'id1')
473
 
        file2.revision = b'result'
 
486
        file1.text_sha1 = ""
 
487
        file2 = inventory.InventoryFile('id2', 'path2', 'id1')
 
488
        file2.revision = 'result'
474
489
        file2.text_size = 0
475
 
        file2.text_sha1 = b""
 
490
        file2.text_sha1 = ""
476
491
        inv.add(file1)
477
 
        delta = [(None, u'path/path2', b'id2', file2)]
 
492
        delta = [(None, u'path/path2', 'id2', file2)]
478
493
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
479
 
                          inv, delta)
 
494
            inv, delta)
480
495
 
481
496
    def test_parent_is_missing(self):
482
497
        inv = self.get_empty_inventory()
483
 
        file2 = inventory.InventoryFile(b'id2', 'path2', b'missingparent')
484
 
        file2.revision = b'result'
 
498
        file2 = inventory.InventoryFile('id2', 'path2', 'missingparent')
 
499
        file2.revision = 'result'
485
500
        file2.text_size = 0
486
 
        file2.text_sha1 = b""
487
 
        delta = [(None, u'path/path2', b'id2', file2)]
 
501
        file2.text_sha1 = ""
 
502
        delta = [(None, u'path/path2', 'id2', file2)]
488
503
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
489
 
                          inv, delta)
 
504
            inv, delta)
490
505
 
491
506
    def test_new_parent_path_has_wrong_id(self):
492
507
        inv = self.get_empty_inventory()
493
 
        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)
494
 
        parent1.revision = b'result'
495
 
        parent2 = inventory.InventoryDirectory(
496
 
            b'p-2', 'dir2', inv.root.file_id)
497
 
        parent2.revision = b'result'
498
 
        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')
499
 
        file1.revision = b'result'
 
508
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
 
509
        parent1.revision = 'result'
 
510
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
 
511
        parent2.revision = 'result'
 
512
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
 
513
        file1.revision = 'result'
500
514
        file1.text_size = 0
501
 
        file1.text_sha1 = b""
 
515
        file1.text_sha1 = ""
502
516
        inv.add(parent1)
503
517
        inv.add(parent2)
504
518
        # This delta claims that file1 is at dir/path, but actually its at
505
519
        # dir2/path if you follow the inventory parent structure.
506
 
        delta = [(None, u'dir/path', b'id', file1)]
 
520
        delta = [(None, u'dir/path', 'id', file1)]
507
521
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
508
 
                          inv, delta)
 
522
            inv, delta)
509
523
 
510
524
    def test_old_parent_path_is_wrong(self):
511
525
        inv = self.get_empty_inventory()
512
 
        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)
513
 
        parent1.revision = b'result'
514
 
        parent2 = inventory.InventoryDirectory(
515
 
            b'p-2', 'dir2', inv.root.file_id)
516
 
        parent2.revision = b'result'
517
 
        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')
518
 
        file1.revision = b'result'
 
526
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
 
527
        parent1.revision = 'result'
 
528
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
 
529
        parent2.revision = 'result'
 
530
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
 
531
        file1.revision = 'result'
519
532
        file1.text_size = 0
520
 
        file1.text_sha1 = b""
 
533
        file1.text_sha1 = ""
521
534
        inv.add(parent1)
522
535
        inv.add(parent2)
523
536
        inv.add(file1)
524
537
        # This delta claims that file1 was at dir/path, but actually it was at
525
538
        # dir2/path if you follow the inventory parent structure.
526
 
        delta = [(u'dir/path', None, b'id', None)]
 
539
        delta = [(u'dir/path', None, 'id', None)]
527
540
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
528
 
                          inv, delta)
 
541
            inv, delta)
529
542
 
530
543
    def test_old_parent_path_is_for_other_id(self):
531
544
        inv = self.get_empty_inventory()
532
 
        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)
533
 
        parent1.revision = b'result'
534
 
        parent2 = inventory.InventoryDirectory(
535
 
            b'p-2', 'dir2', inv.root.file_id)
536
 
        parent2.revision = b'result'
537
 
        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')
538
 
        file1.revision = b'result'
 
545
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
 
546
        parent1.revision = 'result'
 
547
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
 
548
        parent2.revision = 'result'
 
549
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
 
550
        file1.revision = 'result'
539
551
        file1.text_size = 0
540
 
        file1.text_sha1 = b""
541
 
        file2 = inventory.InventoryFile(b'id2', 'path', b'p-1')
542
 
        file2.revision = b'result'
 
552
        file1.text_sha1 = ""
 
553
        file2 = inventory.InventoryFile('id2', 'path', 'p-1')
 
554
        file2.revision = 'result'
543
555
        file2.text_size = 0
544
 
        file2.text_sha1 = b""
 
556
        file2.text_sha1 = ""
545
557
        inv.add(parent1)
546
558
        inv.add(parent2)
547
559
        inv.add(file1)
549
561
        # This delta claims that file1 was at dir/path, but actually it was at
550
562
        # dir2/path if you follow the inventory parent structure. At dir/path
551
563
        # is another entry we should not delete.
552
 
        delta = [(u'dir/path', None, b'id', None)]
 
564
        delta = [(u'dir/path', None, 'id', None)]
553
565
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
554
 
                          inv, delta)
 
566
            inv, delta)
555
567
 
556
568
    def test_add_existing_id_new_path(self):
557
569
        inv = self.get_empty_inventory()
558
 
        parent1 = inventory.InventoryDirectory(
559
 
            b'p-1', 'dir1', inv.root.file_id)
560
 
        parent1.revision = b'result'
561
 
        parent2 = inventory.InventoryDirectory(
562
 
            b'p-1', 'dir2', inv.root.file_id)
563
 
        parent2.revision = b'result'
 
570
        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
 
571
        parent1.revision = 'result'
 
572
        parent2 = inventory.InventoryDirectory('p-1', 'dir2', inv.root.file_id)
 
573
        parent2.revision = 'result'
564
574
        inv.add(parent1)
565
 
        delta = [(None, u'dir2', b'p-1', parent2)]
 
575
        delta = [(None, u'dir2', 'p-1', parent2)]
566
576
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
567
 
                          inv, delta)
 
577
            inv, delta)
568
578
 
569
579
    def test_add_new_id_existing_path(self):
570
580
        inv = self.get_empty_inventory()
571
 
        parent1 = inventory.InventoryDirectory(
572
 
            b'p-1', 'dir1', inv.root.file_id)
573
 
        parent1.revision = b'result'
574
 
        parent2 = inventory.InventoryDirectory(
575
 
            b'p-2', 'dir1', inv.root.file_id)
576
 
        parent2.revision = b'result'
 
581
        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
 
582
        parent1.revision = 'result'
 
583
        parent2 = inventory.InventoryDirectory('p-2', 'dir1', inv.root.file_id)
 
584
        parent2.revision = 'result'
577
585
        inv.add(parent1)
578
 
        delta = [(None, u'dir1', b'p-2', parent2)]
 
586
        delta = [(None, u'dir1', 'p-2', parent2)]
579
587
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
580
 
                          inv, delta)
 
588
            inv, delta)
581
589
 
582
590
    def test_remove_dir_leaving_dangling_child(self):
583
591
        inv = self.get_empty_inventory()
584
 
        dir1 = inventory.InventoryDirectory(b'p-1', 'dir1', inv.root.file_id)
585
 
        dir1.revision = b'result'
586
 
        dir2 = inventory.InventoryDirectory(b'p-2', 'child1', b'p-1')
587
 
        dir2.revision = b'result'
588
 
        dir3 = inventory.InventoryDirectory(b'p-3', 'child2', b'p-1')
589
 
        dir3.revision = b'result'
 
592
        dir1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
 
593
        dir1.revision = 'result'
 
594
        dir2 = inventory.InventoryDirectory('p-2', 'child1', 'p-1')
 
595
        dir2.revision = 'result'
 
596
        dir3 = inventory.InventoryDirectory('p-3', 'child2', 'p-1')
 
597
        dir3.revision = 'result'
590
598
        inv.add(dir1)
591
599
        inv.add(dir2)
592
600
        inv.add(dir3)
593
 
        delta = [(u'dir1', None, b'p-1', None),
594
 
                 (u'dir1/child2', None, b'p-3', None)]
 
601
        delta = [(u'dir1', None, 'p-1', None),
 
602
            (u'dir1/child2', None, 'p-3', None)]
595
603
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
596
 
                          inv, delta)
 
604
            inv, delta)
597
605
 
598
606
    def test_add_file(self):
599
607
        inv = self.get_empty_inventory()
600
 
        file1 = inventory.InventoryFile(b'file-id', 'path', inv.root.file_id)
601
 
        file1.revision = b'result'
 
608
        file1 = inventory.InventoryFile('file-id', 'path', inv.root.file_id)
 
609
        file1.revision = 'result'
602
610
        file1.text_size = 0
603
 
        file1.text_sha1 = b''
604
 
        delta = [(None, u'path', b'file-id', file1)]
 
611
        file1.text_sha1 = ''
 
612
        delta = [(None, u'path', 'file-id', file1)]
605
613
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
606
 
        self.assertEqual(b'file-id', res_inv.get_entry(b'file-id').file_id)
 
614
        self.assertEqual('file-id', res_inv['file-id'].file_id)
607
615
 
608
616
    def test_remove_file(self):
609
617
        inv = self.get_empty_inventory()
610
 
        file1 = inventory.InventoryFile(b'file-id', 'path', inv.root.file_id)
611
 
        file1.revision = b'result'
 
618
        file1 = inventory.InventoryFile('file-id', 'path', inv.root.file_id)
 
619
        file1.revision = 'result'
612
620
        file1.text_size = 0
613
 
        file1.text_sha1 = b''
 
621
        file1.text_sha1 = ''
614
622
        inv.add(file1)
615
 
        delta = [(u'path', None, b'file-id', None)]
 
623
        delta = [(u'path', None, 'file-id', None)]
616
624
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
617
625
        self.assertEqual(None, res_inv.path2id('path'))
618
 
        self.assertRaises(errors.NoSuchId, res_inv.id2path, b'file-id')
 
626
        self.assertRaises(errors.NoSuchId, res_inv.id2path, 'file-id')
619
627
 
620
628
    def test_rename_file(self):
621
629
        inv = self.get_empty_inventory()
622
630
        file1 = self.make_file_ie(name='path', parent_id=inv.root.file_id)
623
631
        inv.add(file1)
624
632
        file2 = self.make_file_ie(name='path2', parent_id=inv.root.file_id)
625
 
        delta = [(u'path', 'path2', b'file-id', file2)]
 
633
        delta = [(u'path', 'path2', 'file-id', file2)]
626
634
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
627
635
        self.assertEqual(None, res_inv.path2id('path'))
628
 
        self.assertEqual(b'file-id', res_inv.path2id('path2'))
 
636
        self.assertEqual('file-id', res_inv.path2id('path2'))
629
637
 
630
638
    def test_replaced_at_new_path(self):
631
639
        inv = self.get_empty_inventory()
632
 
        file1 = self.make_file_ie(file_id=b'id1', parent_id=inv.root.file_id)
 
640
        file1 = self.make_file_ie(file_id='id1', parent_id=inv.root.file_id)
633
641
        inv.add(file1)
634
 
        file2 = self.make_file_ie(file_id=b'id2', parent_id=inv.root.file_id)
635
 
        delta = [(u'name', None, b'id1', None),
636
 
                 (None, u'name', b'id2', file2)]
 
642
        file2 = self.make_file_ie(file_id='id2', parent_id=inv.root.file_id)
 
643
        delta = [(u'name', None, 'id1', None),
 
644
                 (None, u'name', 'id2', file2)]
637
645
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
638
 
        self.assertEqual(b'id2', res_inv.path2id('name'))
 
646
        self.assertEqual('id2', res_inv.path2id('name'))
639
647
 
640
648
    def test_rename_dir(self):
641
649
        inv = self.get_empty_inventory()
642
 
        dir1 = inventory.InventoryDirectory(
643
 
            b'dir-id', 'dir1', inv.root.file_id)
644
 
        dir1.revision = b'basis'
645
 
        file1 = self.make_file_ie(parent_id=b'dir-id')
 
650
        dir1 = inventory.InventoryDirectory('dir-id', 'dir1', inv.root.file_id)
 
651
        dir1.revision = 'basis'
 
652
        file1 = self.make_file_ie(parent_id='dir-id')
646
653
        inv.add(dir1)
647
654
        inv.add(file1)
648
 
        dir2 = inventory.InventoryDirectory(
649
 
            b'dir-id', 'dir2', inv.root.file_id)
650
 
        dir2.revision = b'result'
651
 
        delta = [('dir1', 'dir2', b'dir-id', dir2)]
 
655
        dir2 = inventory.InventoryDirectory('dir-id', 'dir2', inv.root.file_id)
 
656
        dir2.revision = 'result'
 
657
        delta = [('dir1', 'dir2', 'dir-id', dir2)]
652
658
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
653
659
        # The file should be accessible under the new path
654
 
        self.assertEqual(b'file-id', res_inv.path2id('dir2/name'))
 
660
        self.assertEqual('file-id', res_inv.path2id('dir2/name'))
655
661
 
656
662
    def test_renamed_dir_with_renamed_child(self):
657
663
        inv = self.get_empty_inventory()
658
 
        dir1 = inventory.InventoryDirectory(
659
 
            b'dir-id', 'dir1', inv.root.file_id)
660
 
        dir1.revision = b'basis'
661
 
        file1 = self.make_file_ie(b'file-id-1', 'name1', parent_id=b'dir-id')
662
 
        file2 = self.make_file_ie(b'file-id-2', 'name2', parent_id=b'dir-id')
 
664
        dir1 = inventory.InventoryDirectory('dir-id', 'dir1', inv.root.file_id)
 
665
        dir1.revision = 'basis'
 
666
        file1 = self.make_file_ie('file-id-1', 'name1', parent_id='dir-id')
 
667
        file2 = self.make_file_ie('file-id-2', 'name2', parent_id='dir-id')
663
668
        inv.add(dir1)
664
669
        inv.add(file1)
665
670
        inv.add(file2)
666
 
        dir2 = inventory.InventoryDirectory(
667
 
            b'dir-id', 'dir2', inv.root.file_id)
668
 
        dir2.revision = b'result'
669
 
        file2b = self.make_file_ie(b'file-id-2', 'name2', inv.root.file_id)
670
 
        delta = [('dir1', 'dir2', b'dir-id', dir2),
671
 
                 ('dir1/name2', 'name2', b'file-id-2', file2b)]
 
671
        dir2 = inventory.InventoryDirectory('dir-id', 'dir2', inv.root.file_id)
 
672
        dir2.revision = 'result'
 
673
        file2b = self.make_file_ie('file-id-2', 'name2', inv.root.file_id)
 
674
        delta = [('dir1', 'dir2', 'dir-id', dir2),
 
675
                 ('dir1/name2', 'name2', 'file-id-2', file2b)]
672
676
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
673
677
        # The file should be accessible under the new path
674
 
        self.assertEqual(b'file-id-1', res_inv.path2id('dir2/name1'))
 
678
        self.assertEqual('file-id-1', res_inv.path2id('dir2/name1'))
675
679
        self.assertEqual(None, res_inv.path2id('dir2/name2'))
676
 
        self.assertEqual(b'file-id-2', res_inv.path2id('name2'))
 
680
        self.assertEqual('file-id-2', res_inv.path2id('name2'))
677
681
 
678
682
    def test_is_root(self):
679
683
        """Ensure our root-checking code is accurate."""
680
 
        inv = inventory.Inventory(b'TREE_ROOT')
681
 
        self.assertTrue(inv.is_root(b'TREE_ROOT'))
682
 
        self.assertFalse(inv.is_root(b'booga'))
683
 
        inv.root.file_id = b'booga'
684
 
        self.assertFalse(inv.is_root(b'TREE_ROOT'))
685
 
        self.assertTrue(inv.is_root(b'booga'))
 
684
        inv = inventory.Inventory('TREE_ROOT')
 
685
        self.assertTrue(inv.is_root('TREE_ROOT'))
 
686
        self.assertFalse(inv.is_root('booga'))
 
687
        inv.root.file_id = 'booga'
 
688
        self.assertFalse(inv.is_root('TREE_ROOT'))
 
689
        self.assertTrue(inv.is_root('booga'))
686
690
        # works properly even if no root is set
687
691
        inv.root = None
688
 
        self.assertFalse(inv.is_root(b'TREE_ROOT'))
689
 
        self.assertFalse(inv.is_root(b'booga'))
 
692
        self.assertFalse(inv.is_root('TREE_ROOT'))
 
693
        self.assertFalse(inv.is_root('booga'))
690
694
 
691
695
    def test_entries_for_empty_inventory(self):
692
696
        """Test that entries() will not fail for an empty inventory"""
696
700
 
697
701
class TestInventoryEntry(TestCase):
698
702
 
699
 
    def test_file_invalid_entry_name(self):
700
 
        self.assertRaises(InvalidEntryName, inventory.InventoryFile,
701
 
                          b'123', 'a/hello.c', ROOT_ID)
702
 
 
703
 
    def test_file_backslash(self):
704
 
        file = inventory.InventoryFile(b'123', 'h\\ello.c', ROOT_ID)
705
 
        self.assertEquals(file.name, 'h\\ello.c')
706
 
 
707
703
    def test_file_kind_character(self):
708
 
        file = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
 
704
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
709
705
        self.assertEqual(file.kind_character(), '')
710
706
 
711
707
    def test_dir_kind_character(self):
712
 
        dir = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
 
708
        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
713
709
        self.assertEqual(dir.kind_character(), '/')
714
710
 
715
711
    def test_link_kind_character(self):
716
 
        dir = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
 
712
        dir = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
717
713
        self.assertEqual(dir.kind_character(), '')
718
714
 
719
 
    def test_link_kind_character(self):
720
 
        dir = TreeReference(b'123', 'hello.c', ROOT_ID)
721
 
        self.assertEqual(dir.kind_character(), '+')
722
 
 
723
715
    def test_dir_detect_changes(self):
724
 
        left = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
725
 
        right = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
 
716
        left = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
 
717
        right = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
726
718
        self.assertEqual((False, False), left.detect_changes(right))
727
719
        self.assertEqual((False, False), right.detect_changes(left))
728
720
 
729
721
    def test_file_detect_changes(self):
730
 
        left = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
 
722
        left = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
731
723
        left.text_sha1 = 123
732
 
        right = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
 
724
        right = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
733
725
        right.text_sha1 = 123
734
726
        self.assertEqual((False, False), left.detect_changes(right))
735
727
        self.assertEqual((False, False), right.detect_changes(left))
741
733
        self.assertEqual((True, True), right.detect_changes(left))
742
734
 
743
735
    def test_symlink_detect_changes(self):
744
 
        left = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
745
 
        left.symlink_target = 'foo'
746
 
        right = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
747
 
        right.symlink_target = 'foo'
 
736
        left = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
737
        left.symlink_target='foo'
 
738
        right = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
 
739
        right.symlink_target='foo'
748
740
        self.assertEqual((False, False), left.detect_changes(right))
749
741
        self.assertEqual((False, False), right.detect_changes(left))
750
742
        left.symlink_target = 'different'
752
744
        self.assertEqual((True, False), right.detect_changes(left))
753
745
 
754
746
    def test_file_has_text(self):
755
 
        file = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
 
747
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
756
748
        self.assertTrue(file.has_text())
757
749
 
758
750
    def test_directory_has_text(self):
759
 
        dir = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
 
751
        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
760
752
        self.assertFalse(dir.has_text())
761
753
 
762
754
    def test_link_has_text(self):
763
 
        link = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
 
755
        link = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
764
756
        self.assertFalse(link.has_text())
765
757
 
766
758
    def test_make_entry(self):
767
759
        self.assertIsInstance(inventory.make_entry("file", "name", ROOT_ID),
768
 
                              inventory.InventoryFile)
 
760
            inventory.InventoryFile)
769
761
        self.assertIsInstance(inventory.make_entry("symlink", "name", ROOT_ID),
770
 
                              inventory.InventoryLink)
 
762
            inventory.InventoryLink)
771
763
        self.assertIsInstance(inventory.make_entry("directory", "name", ROOT_ID),
772
 
                              inventory.InventoryDirectory)
 
764
            inventory.InventoryDirectory)
773
765
 
774
766
    def test_make_entry_non_normalized(self):
775
767
        orig_normalized_filename = osutils.normalized_filename
782
774
 
783
775
            osutils.normalized_filename = osutils._inaccessible_normalized_filename
784
776
            self.assertRaises(errors.InvalidNormalization,
785
 
                              inventory.make_entry, 'file', u'a\u030a', ROOT_ID)
 
777
                    inventory.make_entry, 'file', u'a\u030a', ROOT_ID)
786
778
        finally:
787
779
            osutils.normalized_filename = orig_normalized_filename
788
780
 
799
791
        # renamed/reparented and modified
800
792
        # change kind (perhaps can't be done yet?)
801
793
        # also, merged in combination with all of these?
802
 
        old_a = InventoryFile(b'a-id', 'a_file', ROOT_ID)
803
 
        old_a.text_sha1 = b'123132'
 
794
        old_a = InventoryFile('a-id', 'a_file', ROOT_ID)
 
795
        old_a.text_sha1 = '123132'
804
796
        old_a.text_size = 0
805
 
        new_a = InventoryFile(b'a-id', 'a_file', ROOT_ID)
806
 
        new_a.text_sha1 = b'123132'
 
797
        new_a = InventoryFile('a-id', 'a_file', ROOT_ID)
 
798
        new_a.text_sha1 = '123132'
807
799
        new_a.text_size = 0
808
800
 
809
801
        self.assertChangeDescription('unchanged', old_a, new_a)
810
802
 
811
803
        new_a.text_size = 10
812
 
        new_a.text_sha1 = b'abcabc'
 
804
        new_a.text_sha1 = 'abcabc'
813
805
        self.assertChangeDescription('modified', old_a, new_a)
814
806
 
815
807
        self.assertChangeDescription('added', None, new_a)
824
816
 
825
817
        # reparenting is 'renaming'
826
818
        new_a.name = old_a.name
827
 
        new_a.parent_id = b'somedir-id'
 
819
        new_a.parent_id = 'somedir-id'
828
820
        self.assertChangeDescription('modified and renamed', old_a, new_a)
829
821
 
830
822
        # reset the content values so its not modified
837
829
 
838
830
        # reparenting is 'renaming'
839
831
        new_a.name = old_a.name
840
 
        new_a.parent_id = b'somedir-id'
 
832
        new_a.parent_id = 'somedir-id'
841
833
        self.assertChangeDescription('renamed', old_a, new_a)
842
834
 
843
835
    def assertChangeDescription(self, expected_change, old_ie, new_ie):
854
846
 
855
847
    def read_bytes(self, chk_bytes, key):
856
848
        stream = chk_bytes.get_record_stream([key], 'unordered', True)
857
 
        return next(stream).get_bytes_as("fulltext")
 
849
        return stream.next().get_bytes_as("fulltext")
858
850
 
859
851
    def test_deserialise_gives_CHKInventory(self):
860
852
        inv = Inventory()
861
 
        inv.revision_id = b"revid"
862
 
        inv.root.revision = b"rootrev"
 
853
        inv.revision_id = "revid"
 
854
        inv.root.revision = "rootrev"
863
855
        chk_bytes = self.get_chk_bytes()
864
856
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
865
 
        lines = chk_inv.to_lines()
866
 
        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
867
 
        self.assertEqual(b"revid", new_inv.revision_id)
 
857
        bytes = ''.join(chk_inv.to_lines())
 
858
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
 
859
        self.assertEqual("revid", new_inv.revision_id)
868
860
        self.assertEqual("directory", new_inv.root.kind)
869
861
        self.assertEqual(inv.root.file_id, new_inv.root.file_id)
870
862
        self.assertEqual(inv.root.parent_id, new_inv.root.parent_id)
871
863
        self.assertEqual(inv.root.name, new_inv.root.name)
872
 
        self.assertEqual(b"rootrev", new_inv.root.revision)
873
 
        self.assertEqual(b'plain', new_inv._search_key_name)
 
864
        self.assertEqual("rootrev", new_inv.root.revision)
 
865
        self.assertEqual('plain', new_inv._search_key_name)
874
866
 
875
867
    def test_deserialise_wrong_revid(self):
876
868
        inv = Inventory()
877
 
        inv.revision_id = b"revid"
878
 
        inv.root.revision = b"rootrev"
 
869
        inv.revision_id = "revid"
 
870
        inv.root.revision = "rootrev"
879
871
        chk_bytes = self.get_chk_bytes()
880
872
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
881
 
        lines = chk_inv.to_lines()
 
873
        bytes = ''.join(chk_inv.to_lines())
882
874
        self.assertRaises(ValueError, CHKInventory.deserialise, chk_bytes,
883
 
                          lines, (b"revid2",))
 
875
            bytes, ("revid2",))
884
876
 
885
877
    def test_captures_rev_root_byid(self):
886
878
        inv = Inventory()
887
 
        inv.revision_id = b"foo"
888
 
        inv.root.revision = b"bar"
 
879
        inv.revision_id = "foo"
 
880
        inv.root.revision = "bar"
889
881
        chk_bytes = self.get_chk_bytes()
890
882
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
891
883
        lines = chk_inv.to_lines()
892
884
        self.assertEqual([
893
 
            b'chkinventory:\n',
894
 
            b'revision_id: foo\n',
895
 
            b'root_id: TREE_ROOT\n',
896
 
            b'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
897
 
            b'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
 
885
            'chkinventory:\n',
 
886
            'revision_id: foo\n',
 
887
            'root_id: TREE_ROOT\n',
 
888
            'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
 
889
            'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
898
890
            ], lines)
899
 
        chk_inv = CHKInventory.deserialise(
900
 
            chk_bytes, lines, (b'foo',))
901
 
        self.assertEqual(b'plain', chk_inv._search_key_name)
 
891
        chk_inv = CHKInventory.deserialise(chk_bytes, ''.join(lines), ('foo',))
 
892
        self.assertEqual('plain', chk_inv._search_key_name)
902
893
 
903
894
    def test_captures_parent_id_basename_index(self):
904
895
        inv = Inventory()
905
 
        inv.revision_id = b"foo"
906
 
        inv.root.revision = b"bar"
 
896
        inv.revision_id = "foo"
 
897
        inv.root.revision = "bar"
907
898
        chk_bytes = self.get_chk_bytes()
908
899
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
909
900
        lines = chk_inv.to_lines()
910
901
        self.assertEqual([
911
 
            b'chkinventory:\n',
912
 
            b'revision_id: foo\n',
913
 
            b'root_id: TREE_ROOT\n',
914
 
            b'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
915
 
            b'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
 
902
            'chkinventory:\n',
 
903
            'revision_id: foo\n',
 
904
            'root_id: TREE_ROOT\n',
 
905
            'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
 
906
            'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
916
907
            ], lines)
917
 
        chk_inv = CHKInventory.deserialise(
918
 
            chk_bytes, lines, (b'foo',))
919
 
        self.assertEqual(b'plain', chk_inv._search_key_name)
 
908
        chk_inv = CHKInventory.deserialise(chk_bytes, ''.join(lines), ('foo',))
 
909
        self.assertEqual('plain', chk_inv._search_key_name)
920
910
 
921
911
    def test_captures_search_key_name(self):
922
912
        inv = Inventory()
923
 
        inv.revision_id = b"foo"
924
 
        inv.root.revision = b"bar"
 
913
        inv.revision_id = "foo"
 
914
        inv.root.revision = "bar"
925
915
        chk_bytes = self.get_chk_bytes()
926
916
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv,
927
 
                                              search_key_name=b'hash-16-way')
 
917
                                              search_key_name='hash-16-way')
928
918
        lines = chk_inv.to_lines()
929
919
        self.assertEqual([
930
 
            b'chkinventory:\n',
931
 
            b'search_key_name: hash-16-way\n',
932
 
            b'root_id: TREE_ROOT\n',
933
 
            b'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
934
 
            b'revision_id: foo\n',
935
 
            b'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
 
920
            'chkinventory:\n',
 
921
            'search_key_name: hash-16-way\n',
 
922
            'root_id: TREE_ROOT\n',
 
923
            'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
 
924
            'revision_id: foo\n',
 
925
            'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
936
926
            ], lines)
937
 
        chk_inv = CHKInventory.deserialise(
938
 
            chk_bytes, lines, (b'foo',))
939
 
        self.assertEqual(b'hash-16-way', chk_inv._search_key_name)
 
927
        chk_inv = CHKInventory.deserialise(chk_bytes, ''.join(lines), ('foo',))
 
928
        self.assertEqual('hash-16-way', chk_inv._search_key_name)
940
929
 
941
930
    def test_directory_children_on_demand(self):
942
931
        inv = Inventory()
943
 
        inv.revision_id = b"revid"
944
 
        inv.root.revision = b"rootrev"
945
 
        inv.add(InventoryFile(b"fileid", "file", inv.root.file_id))
946
 
        inv.get_entry(b"fileid").revision = b"filerev"
947
 
        inv.get_entry(b"fileid").executable = True
948
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
949
 
        inv.get_entry(b"fileid").text_size = 1
 
932
        inv.revision_id = "revid"
 
933
        inv.root.revision = "rootrev"
 
934
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
 
935
        inv["fileid"].revision = "filerev"
 
936
        inv["fileid"].executable = True
 
937
        inv["fileid"].text_sha1 = "ffff"
 
938
        inv["fileid"].text_size = 1
950
939
        chk_bytes = self.get_chk_bytes()
951
940
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
952
 
        lines = chk_inv.to_lines()
953
 
        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
954
 
        root_entry = new_inv.get_entry(inv.root.file_id)
 
941
        bytes = ''.join(chk_inv.to_lines())
 
942
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
 
943
        root_entry = new_inv[inv.root.file_id]
955
944
        self.assertEqual(None, root_entry._children)
956
945
        self.assertEqual({'file'}, set(root_entry.children))
957
 
        file_direct = new_inv.get_entry(b"fileid")
 
946
        file_direct = new_inv["fileid"]
958
947
        file_found = root_entry.children['file']
959
948
        self.assertEqual(file_direct.kind, file_found.kind)
960
949
        self.assertEqual(file_direct.file_id, file_found.file_id)
968
957
    def test_from_inventory_maximum_size(self):
969
958
        # from_inventory supports the maximum_size parameter.
970
959
        inv = Inventory()
971
 
        inv.revision_id = b"revid"
972
 
        inv.root.revision = b"rootrev"
 
960
        inv.revision_id = "revid"
 
961
        inv.root.revision = "rootrev"
973
962
        chk_bytes = self.get_chk_bytes()
974
963
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv, 120)
975
964
        chk_inv.id_to_entry._ensure_root()
980
969
        self.assertEqual(120, p_id_basename._root_node.maximum_size)
981
970
        self.assertEqual(2, p_id_basename._root_node._key_width)
982
971
 
983
 
    def test_iter_all_ids(self):
 
972
    def test___iter__(self):
984
973
        inv = Inventory()
985
 
        inv.revision_id = b"revid"
986
 
        inv.root.revision = b"rootrev"
987
 
        inv.add(InventoryFile(b"fileid", "file", inv.root.file_id))
988
 
        inv.get_entry(b"fileid").revision = b"filerev"
989
 
        inv.get_entry(b"fileid").executable = True
990
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
991
 
        inv.get_entry(b"fileid").text_size = 1
 
974
        inv.revision_id = "revid"
 
975
        inv.root.revision = "rootrev"
 
976
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
 
977
        inv["fileid"].revision = "filerev"
 
978
        inv["fileid"].executable = True
 
979
        inv["fileid"].text_sha1 = "ffff"
 
980
        inv["fileid"].text_size = 1
992
981
        chk_bytes = self.get_chk_bytes()
993
982
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
994
 
        lines = chk_inv.to_lines()
995
 
        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
996
 
        fileids = sorted(new_inv.iter_all_ids())
997
 
        self.assertEqual([inv.root.file_id, b"fileid"], fileids)
 
983
        bytes = ''.join(chk_inv.to_lines())
 
984
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
 
985
        fileids = sorted(new_inv.__iter__())
 
986
        self.assertEqual([inv.root.file_id, "fileid"], fileids)
998
987
 
999
988
    def test__len__(self):
1000
989
        inv = Inventory()
1001
 
        inv.revision_id = b"revid"
1002
 
        inv.root.revision = b"rootrev"
1003
 
        inv.add(InventoryFile(b"fileid", "file", inv.root.file_id))
1004
 
        inv.get_entry(b"fileid").revision = b"filerev"
1005
 
        inv.get_entry(b"fileid").executable = True
1006
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1007
 
        inv.get_entry(b"fileid").text_size = 1
 
990
        inv.revision_id = "revid"
 
991
        inv.root.revision = "rootrev"
 
992
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
 
993
        inv["fileid"].revision = "filerev"
 
994
        inv["fileid"].executable = True
 
995
        inv["fileid"].text_sha1 = "ffff"
 
996
        inv["fileid"].text_size = 1
1008
997
        chk_bytes = self.get_chk_bytes()
1009
998
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1010
999
        self.assertEqual(2, len(chk_inv))
1011
1000
 
1012
 
    def test_get_entry(self):
 
1001
    def test___getitem__(self):
1013
1002
        inv = Inventory()
1014
1003
        inv.revision_id = b"revid"
1015
1004
        inv.root.revision = b"rootrev"
1016
1005
        inv.add(InventoryFile(b"fileid", u"file", inv.root.file_id))
1017
 
        inv.get_entry(b"fileid").revision = b"filerev"
1018
 
        inv.get_entry(b"fileid").executable = True
1019
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1020
 
        inv.get_entry(b"fileid").text_size = 1
 
1006
        inv[b"fileid"].revision = b"filerev"
 
1007
        inv[b"fileid"].executable = True
 
1008
        inv[b"fileid"].text_sha1 = b"ffff"
 
1009
        inv[b"fileid"].text_size = 1
1021
1010
        chk_bytes = self.get_chk_bytes()
1022
1011
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1023
 
        lines = chk_inv.to_lines()
1024
 
        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
1025
 
        root_entry = new_inv.get_entry(inv.root.file_id)
1026
 
        file_entry = new_inv.get_entry(b"fileid")
 
1012
        data = b''.join(chk_inv.to_lines())
 
1013
        new_inv = CHKInventory.deserialise(chk_bytes, data, (b"revid",))
 
1014
        root_entry = new_inv[inv.root.file_id]
 
1015
        file_entry = new_inv[b"fileid"]
1027
1016
        self.assertEqual("directory", root_entry.kind)
1028
1017
        self.assertEqual(inv.root.file_id, root_entry.file_id)
1029
1018
        self.assertEqual(inv.root.parent_id, root_entry.parent_id)
1037
1026
        self.assertEqual(b"ffff", file_entry.text_sha1)
1038
1027
        self.assertEqual(1, file_entry.text_size)
1039
1028
        self.assertEqual(True, file_entry.executable)
1040
 
        self.assertRaises(errors.NoSuchId, new_inv.get_entry, 'missing')
 
1029
        self.assertRaises(errors.NoSuchId, new_inv.__getitem__, 'missing')
1041
1030
 
1042
1031
    def test_has_id_true(self):
1043
1032
        inv = Inventory()
1044
 
        inv.revision_id = b"revid"
1045
 
        inv.root.revision = b"rootrev"
1046
 
        inv.add(InventoryFile(b"fileid", "file", inv.root.file_id))
1047
 
        inv.get_entry(b"fileid").revision = b"filerev"
1048
 
        inv.get_entry(b"fileid").executable = True
1049
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1050
 
        inv.get_entry(b"fileid").text_size = 1
 
1033
        inv.revision_id = "revid"
 
1034
        inv.root.revision = "rootrev"
 
1035
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
 
1036
        inv["fileid"].revision = "filerev"
 
1037
        inv["fileid"].executable = True
 
1038
        inv["fileid"].text_sha1 = "ffff"
 
1039
        inv["fileid"].text_size = 1
1051
1040
        chk_bytes = self.get_chk_bytes()
1052
1041
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1053
 
        self.assertTrue(chk_inv.has_id(b'fileid'))
 
1042
        self.assertTrue(chk_inv.has_id('fileid'))
1054
1043
        self.assertTrue(chk_inv.has_id(inv.root.file_id))
1055
1044
 
1056
1045
    def test_has_id_not(self):
1057
1046
        inv = Inventory()
1058
 
        inv.revision_id = b"revid"
1059
 
        inv.root.revision = b"rootrev"
 
1047
        inv.revision_id = "revid"
 
1048
        inv.root.revision = "rootrev"
1060
1049
        chk_bytes = self.get_chk_bytes()
1061
1050
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1062
 
        self.assertFalse(chk_inv.has_id(b'fileid'))
 
1051
        self.assertFalse(chk_inv.has_id('fileid'))
1063
1052
 
1064
1053
    def test_id2path(self):
1065
1054
        inv = Inventory()
1066
 
        inv.revision_id = b"revid"
1067
 
        inv.root.revision = b"rootrev"
1068
 
        direntry = InventoryDirectory(b"dirid", "dir", inv.root.file_id)
1069
 
        fileentry = InventoryFile(b"fileid", "file", b"dirid")
 
1055
        inv.revision_id = "revid"
 
1056
        inv.root.revision = "rootrev"
 
1057
        direntry = InventoryDirectory("dirid", "dir", inv.root.file_id)
 
1058
        fileentry = InventoryFile("fileid", "file", "dirid")
1070
1059
        inv.add(direntry)
1071
1060
        inv.add(fileentry)
1072
 
        inv.get_entry(b"fileid").revision = b"filerev"
1073
 
        inv.get_entry(b"fileid").executable = True
1074
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1075
 
        inv.get_entry(b"fileid").text_size = 1
1076
 
        inv.get_entry(b"dirid").revision = b"filerev"
 
1061
        inv["fileid"].revision = "filerev"
 
1062
        inv["fileid"].executable = True
 
1063
        inv["fileid"].text_sha1 = "ffff"
 
1064
        inv["fileid"].text_size = 1
 
1065
        inv["dirid"].revision = "filerev"
1077
1066
        chk_bytes = self.get_chk_bytes()
1078
1067
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1079
 
        lines = chk_inv.to_lines()
1080
 
        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
1068
        bytes = ''.join(chk_inv.to_lines())
 
1069
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1081
1070
        self.assertEqual('', new_inv.id2path(inv.root.file_id))
1082
 
        self.assertEqual('dir', new_inv.id2path(b'dirid'))
1083
 
        self.assertEqual('dir/file', new_inv.id2path(b'fileid'))
 
1071
        self.assertEqual('dir', new_inv.id2path('dirid'))
 
1072
        self.assertEqual('dir/file', new_inv.id2path('fileid'))
1084
1073
 
1085
1074
    def test_path2id(self):
1086
1075
        inv = Inventory()
1087
 
        inv.revision_id = b"revid"
1088
 
        inv.root.revision = b"rootrev"
1089
 
        direntry = InventoryDirectory(b"dirid", "dir", inv.root.file_id)
1090
 
        fileentry = InventoryFile(b"fileid", "file", b"dirid")
 
1076
        inv.revision_id = "revid"
 
1077
        inv.root.revision = "rootrev"
 
1078
        direntry = InventoryDirectory("dirid", "dir", inv.root.file_id)
 
1079
        fileentry = InventoryFile("fileid", "file", "dirid")
1091
1080
        inv.add(direntry)
1092
1081
        inv.add(fileentry)
1093
 
        inv.get_entry(b"fileid").revision = b"filerev"
1094
 
        inv.get_entry(b"fileid").executable = True
1095
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1096
 
        inv.get_entry(b"fileid").text_size = 1
1097
 
        inv.get_entry(b"dirid").revision = b"filerev"
 
1082
        inv["fileid"].revision = "filerev"
 
1083
        inv["fileid"].executable = True
 
1084
        inv["fileid"].text_sha1 = "ffff"
 
1085
        inv["fileid"].text_size = 1
 
1086
        inv["dirid"].revision = "filerev"
1098
1087
        chk_bytes = self.get_chk_bytes()
1099
1088
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1100
 
        lines = chk_inv.to_lines()
1101
 
        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
1089
        bytes = ''.join(chk_inv.to_lines())
 
1090
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1102
1091
        self.assertEqual(inv.root.file_id, new_inv.path2id(''))
1103
 
        self.assertEqual(b'dirid', new_inv.path2id('dir'))
1104
 
        self.assertEqual(b'fileid', new_inv.path2id('dir/file'))
 
1092
        self.assertEqual('dirid', new_inv.path2id('dir'))
 
1093
        self.assertEqual('fileid', new_inv.path2id('dir/file'))
1105
1094
 
1106
1095
    def test_create_by_apply_delta_sets_root(self):
1107
1096
        inv = Inventory()
1108
 
        inv.root.revision = b"myrootrev"
1109
 
        inv.revision_id = b"revid"
 
1097
        inv.revision_id = "revid"
1110
1098
        chk_bytes = self.get_chk_bytes()
1111
1099
        base_inv = CHKInventory.from_inventory(chk_bytes, inv)
1112
 
        inv.add_path("", "directory", b"myrootid", None)
1113
 
        inv.revision_id = b"expectedid"
1114
 
        inv.root.revision = b"myrootrev"
 
1100
        inv.add_path("", "directory", "myrootid", None)
 
1101
        inv.revision_id = "expectedid"
1115
1102
        reference_inv = CHKInventory.from_inventory(chk_bytes, inv)
1116
1103
        delta = [("", None, base_inv.root.file_id, None),
1117
 
                 (None, "", b"myrootid", inv.root)]
1118
 
        new_inv = base_inv.create_by_apply_delta(delta, b"expectedid")
 
1104
            (None, "",  "myrootid", inv.root)]
 
1105
        new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
1119
1106
        self.assertEqual(reference_inv.root, new_inv.root)
1120
1107
 
1121
1108
    def test_create_by_apply_delta_empty_add_child(self):
1122
1109
        inv = Inventory()
1123
 
        inv.revision_id = b"revid"
1124
 
        inv.root.revision = b"rootrev"
 
1110
        inv.revision_id = "revid"
 
1111
        inv.root.revision = "rootrev"
1125
1112
        chk_bytes = self.get_chk_bytes()
1126
1113
        base_inv = CHKInventory.from_inventory(chk_bytes, inv)
1127
 
        a_entry = InventoryFile(b"A-id", "A", inv.root.file_id)
1128
 
        a_entry.revision = b"filerev"
 
1114
        a_entry = InventoryFile("A-id", "A", inv.root.file_id)
 
1115
        a_entry.revision = "filerev"
1129
1116
        a_entry.executable = True
1130
 
        a_entry.text_sha1 = b"ffff"
 
1117
        a_entry.text_sha1 = "ffff"
1131
1118
        a_entry.text_size = 1
1132
1119
        inv.add(a_entry)
1133
 
        inv.revision_id = b"expectedid"
 
1120
        inv.revision_id = "expectedid"
1134
1121
        reference_inv = CHKInventory.from_inventory(chk_bytes, inv)
1135
 
        delta = [(None, "A", b"A-id", a_entry)]
1136
 
        new_inv = base_inv.create_by_apply_delta(delta, b"expectedid")
 
1122
        delta = [(None, "A",  "A-id", a_entry)]
 
1123
        new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
1137
1124
        # new_inv should be the same as reference_inv.
1138
1125
        self.assertEqual(reference_inv.revision_id, new_inv.revision_id)
1139
1126
        self.assertEqual(reference_inv.root_id, new_inv.root_id)
1140
1127
        reference_inv.id_to_entry._ensure_root()
1141
1128
        new_inv.id_to_entry._ensure_root()
1142
1129
        self.assertEqual(reference_inv.id_to_entry._root_node._key,
1143
 
                         new_inv.id_to_entry._root_node._key)
 
1130
            new_inv.id_to_entry._root_node._key)
1144
1131
 
1145
1132
    def test_create_by_apply_delta_empty_add_child_updates_parent_id(self):
1146
1133
        inv = Inventory()
1147
 
        inv.revision_id = b"revid"
1148
 
        inv.root.revision = b"rootrev"
 
1134
        inv.revision_id = "revid"
 
1135
        inv.root.revision = "rootrev"
1149
1136
        chk_bytes = self.get_chk_bytes()
1150
1137
        base_inv = CHKInventory.from_inventory(chk_bytes, inv)
1151
 
        a_entry = InventoryFile(b"A-id", "A", inv.root.file_id)
1152
 
        a_entry.revision = b"filerev"
 
1138
        a_entry = InventoryFile("A-id", "A", inv.root.file_id)
 
1139
        a_entry.revision = "filerev"
1153
1140
        a_entry.executable = True
1154
 
        a_entry.text_sha1 = b"ffff"
 
1141
        a_entry.text_sha1 = "ffff"
1155
1142
        a_entry.text_size = 1
1156
1143
        inv.add(a_entry)
1157
 
        inv.revision_id = b"expectedid"
 
1144
        inv.revision_id = "expectedid"
1158
1145
        reference_inv = CHKInventory.from_inventory(chk_bytes, inv)
1159
 
        delta = [(None, "A", b"A-id", a_entry)]
1160
 
        new_inv = base_inv.create_by_apply_delta(delta, b"expectedid")
 
1146
        delta = [(None, "A",  "A-id", a_entry)]
 
1147
        new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
1161
1148
        reference_inv.id_to_entry._ensure_root()
1162
1149
        reference_inv.parent_id_basename_to_file_id._ensure_root()
1163
1150
        new_inv.id_to_entry._ensure_root()
1166
1153
        self.assertEqual(reference_inv.revision_id, new_inv.revision_id)
1167
1154
        self.assertEqual(reference_inv.root_id, new_inv.root_id)
1168
1155
        self.assertEqual(reference_inv.id_to_entry._root_node._key,
1169
 
                         new_inv.id_to_entry._root_node._key)
 
1156
            new_inv.id_to_entry._root_node._key)
1170
1157
        self.assertEqual(reference_inv.parent_id_basename_to_file_id._root_node._key,
1171
 
                         new_inv.parent_id_basename_to_file_id._root_node._key)
 
1158
            new_inv.parent_id_basename_to_file_id._root_node._key)
1172
1159
 
1173
1160
    def test_iter_changes(self):
1174
1161
        # Low level bootstrapping smoke test; comprehensive generic tests via
1175
1162
        # InterTree are coming.
1176
1163
        inv = Inventory()
1177
 
        inv.revision_id = b"revid"
1178
 
        inv.root.revision = b"rootrev"
1179
 
        inv.add(InventoryFile(b"fileid", "file", inv.root.file_id))
1180
 
        inv.get_entry(b"fileid").revision = b"filerev"
1181
 
        inv.get_entry(b"fileid").executable = True
1182
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1183
 
        inv.get_entry(b"fileid").text_size = 1
 
1164
        inv.revision_id = "revid"
 
1165
        inv.root.revision = "rootrev"
 
1166
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
 
1167
        inv["fileid"].revision = "filerev"
 
1168
        inv["fileid"].executable = True
 
1169
        inv["fileid"].text_sha1 = "ffff"
 
1170
        inv["fileid"].text_size = 1
1184
1171
        inv2 = Inventory()
1185
 
        inv2.revision_id = b"revid2"
1186
 
        inv2.root.revision = b"rootrev"
1187
 
        inv2.add(InventoryFile(b"fileid", "file", inv.root.file_id))
1188
 
        inv2.get_entry(b"fileid").revision = b"filerev2"
1189
 
        inv2.get_entry(b"fileid").executable = False
1190
 
        inv2.get_entry(b"fileid").text_sha1 = b"bbbb"
1191
 
        inv2.get_entry(b"fileid").text_size = 2
 
1172
        inv2.revision_id = "revid2"
 
1173
        inv2.root.revision = "rootrev"
 
1174
        inv2.add(InventoryFile("fileid", "file", inv.root.file_id))
 
1175
        inv2["fileid"].revision = "filerev2"
 
1176
        inv2["fileid"].executable = False
 
1177
        inv2["fileid"].text_sha1 = "bbbb"
 
1178
        inv2["fileid"].text_size = 2
1192
1179
        # get fresh objects.
1193
1180
        chk_bytes = self.get_chk_bytes()
1194
1181
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1195
 
        lines = chk_inv.to_lines()
1196
 
        inv_1 = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
1182
        bytes = ''.join(chk_inv.to_lines())
 
1183
        inv_1 = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1197
1184
        chk_inv2 = CHKInventory.from_inventory(chk_bytes, inv2)
1198
 
        lines = chk_inv2.to_lines()
1199
 
        inv_2 = CHKInventory.deserialise(chk_bytes, lines, (b"revid2",))
1200
 
        self.assertEqual([(b'fileid', (u'file', u'file'), True, (True, True),
1201
 
                           (b'TREE_ROOT', b'TREE_ROOT'), (u'file',
1202
 
                                                          u'file'), ('file', 'file'),
1203
 
                           (False, True))],
1204
 
                         list(inv_1.iter_changes(inv_2)))
 
1185
        bytes = ''.join(chk_inv2.to_lines())
 
1186
        inv_2 = CHKInventory.deserialise(chk_bytes, bytes, ("revid2",))
 
1187
        self.assertEqual([('fileid', (u'file', u'file'), True, (True, True),
 
1188
            ('TREE_ROOT', 'TREE_ROOT'), (u'file', u'file'), ('file', 'file'),
 
1189
            (False, True))],
 
1190
            list(inv_1.iter_changes(inv_2)))
1205
1191
 
1206
1192
    def test_parent_id_basename_to_file_id_index_enabled(self):
1207
1193
        inv = Inventory()
1208
 
        inv.revision_id = b"revid"
1209
 
        inv.root.revision = b"rootrev"
1210
 
        inv.add(InventoryFile(b"fileid", "file", inv.root.file_id))
1211
 
        inv.get_entry(b"fileid").revision = b"filerev"
1212
 
        inv.get_entry(b"fileid").executable = True
1213
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1214
 
        inv.get_entry(b"fileid").text_size = 1
 
1194
        inv.revision_id = "revid"
 
1195
        inv.root.revision = "rootrev"
 
1196
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
 
1197
        inv["fileid"].revision = "filerev"
 
1198
        inv["fileid"].executable = True
 
1199
        inv["fileid"].text_sha1 = "ffff"
 
1200
        inv["fileid"].text_size = 1
1215
1201
        # get fresh objects.
1216
1202
        chk_bytes = self.get_chk_bytes()
1217
1203
        tmp_inv = CHKInventory.from_inventory(chk_bytes, inv)
1218
 
        lines = tmp_inv.to_lines()
1219
 
        chk_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
1220
 
        self.assertIsInstance(
1221
 
            chk_inv.parent_id_basename_to_file_id, chk_map.CHKMap)
 
1204
        bytes = ''.join(tmp_inv.to_lines())
 
1205
        chk_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
 
1206
        self.assertIsInstance(chk_inv.parent_id_basename_to_file_id, chk_map.CHKMap)
1222
1207
        self.assertEqual(
1223
 
            {(b'', b''): b'TREE_ROOT', (b'TREE_ROOT', b'file'): b'fileid'},
 
1208
            {('', ''): 'TREE_ROOT', ('TREE_ROOT', 'file'): 'fileid'},
1224
1209
            dict(chk_inv.parent_id_basename_to_file_id.iteritems()))
1225
1210
 
1226
1211
    def test_file_entry_to_bytes(self):
1227
1212
        inv = CHKInventory(None)
1228
 
        ie = inventory.InventoryFile(b'file-id', 'filename', b'parent-id')
 
1213
        ie = inventory.InventoryFile('file-id', 'filename', 'parent-id')
1229
1214
        ie.executable = True
1230
 
        ie.revision = b'file-rev-id'
1231
 
        ie.text_sha1 = b'abcdefgh'
 
1215
        ie.revision = 'file-rev-id'
 
1216
        ie.text_sha1 = 'abcdefgh'
1232
1217
        ie.text_size = 100
1233
1218
        bytes = inv._entry_to_bytes(ie)
1234
 
        self.assertEqual(b'file: file-id\nparent-id\nfilename\n'
1235
 
                         b'file-rev-id\nabcdefgh\n100\nY', bytes)
 
1219
        self.assertEqual('file: file-id\nparent-id\nfilename\n'
 
1220
                         'file-rev-id\nabcdefgh\n100\nY', bytes)
1236
1221
        ie2 = inv._bytes_to_entry(bytes)
1237
1222
        self.assertEqual(ie, ie2)
1238
 
        self.assertIsInstance(ie2.name, str)
1239
 
        self.assertEqual((b'filename', b'file-id', b'file-rev-id'),
 
1223
        self.assertIsInstance(ie2.name, unicode)
 
1224
        self.assertEqual(('filename', 'file-id', 'file-rev-id'),
1240
1225
                         inv._bytes_to_utf8name_key(bytes))
1241
1226
 
1242
1227
    def test_file2_entry_to_bytes(self):
1243
1228
        inv = CHKInventory(None)
1244
1229
        # \u30a9 == 'omega'
1245
 
        ie = inventory.InventoryFile(b'file-id', u'\u03a9name', b'parent-id')
 
1230
        ie = inventory.InventoryFile('file-id', u'\u03a9name', 'parent-id')
1246
1231
        ie.executable = False
1247
 
        ie.revision = b'file-rev-id'
1248
 
        ie.text_sha1 = b'123456'
 
1232
        ie.revision = 'file-rev-id'
 
1233
        ie.text_sha1 = '123456'
1249
1234
        ie.text_size = 25
1250
1235
        bytes = inv._entry_to_bytes(ie)
1251
 
        self.assertEqual(b'file: file-id\nparent-id\n\xce\xa9name\n'
1252
 
                         b'file-rev-id\n123456\n25\nN', bytes)
 
1236
        self.assertEqual('file: file-id\nparent-id\n\xce\xa9name\n'
 
1237
                         'file-rev-id\n123456\n25\nN', bytes)
1253
1238
        ie2 = inv._bytes_to_entry(bytes)
1254
1239
        self.assertEqual(ie, ie2)
1255
 
        self.assertIsInstance(ie2.name, str)
1256
 
        self.assertEqual((b'\xce\xa9name', b'file-id', b'file-rev-id'),
 
1240
        self.assertIsInstance(ie2.name, unicode)
 
1241
        self.assertEqual(('\xce\xa9name', 'file-id', 'file-rev-id'),
1257
1242
                         inv._bytes_to_utf8name_key(bytes))
1258
1243
 
1259
1244
    def test_dir_entry_to_bytes(self):
1260
1245
        inv = CHKInventory(None)
1261
 
        ie = inventory.InventoryDirectory(b'dir-id', 'dirname', b'parent-id')
1262
 
        ie.revision = b'dir-rev-id'
 
1246
        ie = inventory.InventoryDirectory('dir-id', 'dirname', 'parent-id')
 
1247
        ie.revision = 'dir-rev-id'
1263
1248
        bytes = inv._entry_to_bytes(ie)
1264
 
        self.assertEqual(b'dir: dir-id\nparent-id\ndirname\ndir-rev-id', bytes)
 
1249
        self.assertEqual('dir: dir-id\nparent-id\ndirname\ndir-rev-id', bytes)
1265
1250
        ie2 = inv._bytes_to_entry(bytes)
1266
1251
        self.assertEqual(ie, ie2)
1267
 
        self.assertIsInstance(ie2.name, str)
1268
 
        self.assertEqual((b'dirname', b'dir-id', b'dir-rev-id'),
 
1252
        self.assertIsInstance(ie2.name, unicode)
 
1253
        self.assertEqual(('dirname', 'dir-id', 'dir-rev-id'),
1269
1254
                         inv._bytes_to_utf8name_key(bytes))
1270
1255
 
1271
1256
    def test_dir2_entry_to_bytes(self):
1272
1257
        inv = CHKInventory(None)
1273
 
        ie = inventory.InventoryDirectory(b'dir-id', u'dir\u03a9name',
 
1258
        ie = inventory.InventoryDirectory('dir-id', u'dir\u03a9name',
1274
1259
                                          None)
1275
 
        ie.revision = b'dir-rev-id'
 
1260
        ie.revision = 'dir-rev-id'
1276
1261
        bytes = inv._entry_to_bytes(ie)
1277
 
        self.assertEqual(b'dir: dir-id\n\ndir\xce\xa9name\n'
1278
 
                         b'dir-rev-id', bytes)
 
1262
        self.assertEqual('dir: dir-id\n\ndir\xce\xa9name\n'
 
1263
                         'dir-rev-id', bytes)
1279
1264
        ie2 = inv._bytes_to_entry(bytes)
1280
1265
        self.assertEqual(ie, ie2)
1281
 
        self.assertIsInstance(ie2.name, str)
 
1266
        self.assertIsInstance(ie2.name, unicode)
1282
1267
        self.assertIs(ie2.parent_id, None)
1283
 
        self.assertEqual((b'dir\xce\xa9name', b'dir-id', b'dir-rev-id'),
 
1268
        self.assertEqual(('dir\xce\xa9name', 'dir-id', 'dir-rev-id'),
1284
1269
                         inv._bytes_to_utf8name_key(bytes))
1285
1270
 
1286
1271
    def test_symlink_entry_to_bytes(self):
1287
1272
        inv = CHKInventory(None)
1288
 
        ie = inventory.InventoryLink(b'link-id', 'linkname', b'parent-id')
1289
 
        ie.revision = b'link-rev-id'
 
1273
        ie = inventory.InventoryLink('link-id', 'linkname', 'parent-id')
 
1274
        ie.revision = 'link-rev-id'
1290
1275
        ie.symlink_target = u'target/path'
1291
1276
        bytes = inv._entry_to_bytes(ie)
1292
 
        self.assertEqual(b'symlink: link-id\nparent-id\nlinkname\n'
1293
 
                         b'link-rev-id\ntarget/path', bytes)
 
1277
        self.assertEqual('symlink: link-id\nparent-id\nlinkname\n'
 
1278
                         'link-rev-id\ntarget/path', bytes)
1294
1279
        ie2 = inv._bytes_to_entry(bytes)
1295
1280
        self.assertEqual(ie, ie2)
1296
 
        self.assertIsInstance(ie2.name, str)
1297
 
        self.assertIsInstance(ie2.symlink_target, str)
1298
 
        self.assertEqual((b'linkname', b'link-id', b'link-rev-id'),
 
1281
        self.assertIsInstance(ie2.name, unicode)
 
1282
        self.assertIsInstance(ie2.symlink_target, unicode)
 
1283
        self.assertEqual(('linkname', 'link-id', 'link-rev-id'),
1299
1284
                         inv._bytes_to_utf8name_key(bytes))
1300
1285
 
1301
1286
    def test_symlink2_entry_to_bytes(self):
1302
1287
        inv = CHKInventory(None)
1303
 
        ie = inventory.InventoryLink(
1304
 
            b'link-id', u'link\u03a9name', b'parent-id')
1305
 
        ie.revision = b'link-rev-id'
 
1288
        ie = inventory.InventoryLink('link-id', u'link\u03a9name', 'parent-id')
 
1289
        ie.revision = 'link-rev-id'
1306
1290
        ie.symlink_target = u'target/\u03a9path'
1307
1291
        bytes = inv._entry_to_bytes(ie)
1308
 
        self.assertEqual(b'symlink: link-id\nparent-id\nlink\xce\xa9name\n'
1309
 
                         b'link-rev-id\ntarget/\xce\xa9path', bytes)
 
1292
        self.assertEqual('symlink: link-id\nparent-id\nlink\xce\xa9name\n'
 
1293
                         'link-rev-id\ntarget/\xce\xa9path', bytes)
1310
1294
        ie2 = inv._bytes_to_entry(bytes)
1311
1295
        self.assertEqual(ie, ie2)
1312
 
        self.assertIsInstance(ie2.name, str)
1313
 
        self.assertIsInstance(ie2.symlink_target, str)
1314
 
        self.assertEqual((b'link\xce\xa9name', b'link-id', b'link-rev-id'),
 
1296
        self.assertIsInstance(ie2.name, unicode)
 
1297
        self.assertIsInstance(ie2.symlink_target, unicode)
 
1298
        self.assertEqual(('link\xce\xa9name', 'link-id', 'link-rev-id'),
1315
1299
                         inv._bytes_to_utf8name_key(bytes))
1316
1300
 
1317
1301
    def test_tree_reference_entry_to_bytes(self):
1318
1302
        inv = CHKInventory(None)
1319
 
        ie = inventory.TreeReference(b'tree-root-id', u'tree\u03a9name',
1320
 
                                     b'parent-id')
1321
 
        ie.revision = b'tree-rev-id'
1322
 
        ie.reference_revision = b'ref-rev-id'
 
1303
        ie = inventory.TreeReference('tree-root-id', u'tree\u03a9name',
 
1304
                                     'parent-id')
 
1305
        ie.revision = 'tree-rev-id'
 
1306
        ie.reference_revision = 'ref-rev-id'
1323
1307
        bytes = inv._entry_to_bytes(ie)
1324
 
        self.assertEqual(b'tree: tree-root-id\nparent-id\ntree\xce\xa9name\n'
1325
 
                         b'tree-rev-id\nref-rev-id', bytes)
 
1308
        self.assertEqual('tree: tree-root-id\nparent-id\ntree\xce\xa9name\n'
 
1309
                         'tree-rev-id\nref-rev-id', bytes)
1326
1310
        ie2 = inv._bytes_to_entry(bytes)
1327
1311
        self.assertEqual(ie, ie2)
1328
 
        self.assertIsInstance(ie2.name, str)
1329
 
        self.assertEqual((b'tree\xce\xa9name', b'tree-root-id', b'tree-rev-id'),
 
1312
        self.assertIsInstance(ie2.name, unicode)
 
1313
        self.assertEqual(('tree\xce\xa9name', 'tree-root-id', 'tree-rev-id'),
1330
1314
                         inv._bytes_to_utf8name_key(bytes))
1331
1315
 
1332
1316
    def make_basic_utf8_inventory(self):
1333
1317
        inv = Inventory()
1334
 
        inv.revision_id = b"revid"
1335
 
        inv.root.revision = b"rootrev"
 
1318
        inv.revision_id = "revid"
 
1319
        inv.root.revision = "rootrev"
1336
1320
        root_id = inv.root.file_id
1337
 
        inv.add(InventoryFile(b"fileid", u'f\xefle', root_id))
1338
 
        inv.get_entry(b"fileid").revision = b"filerev"
1339
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1340
 
        inv.get_entry(b"fileid").text_size = 0
1341
 
        inv.add(InventoryDirectory(b"dirid", u'dir-\N{EURO SIGN}', root_id))
1342
 
        inv.get_entry(b"dirid").revision = b"dirrev"
1343
 
        inv.add(InventoryFile(b"childid", u'ch\xefld', b"dirid"))
1344
 
        inv.get_entry(b"childid").revision = b"filerev"
1345
 
        inv.get_entry(b"childid").text_sha1 = b"ffff"
1346
 
        inv.get_entry(b"childid").text_size = 0
 
1321
        inv.add(InventoryFile("fileid", u'f\xefle', root_id))
 
1322
        inv["fileid"].revision = "filerev"
 
1323
        inv["fileid"].text_sha1 = "ffff"
 
1324
        inv["fileid"].text_size = 0
 
1325
        inv.add(InventoryDirectory("dirid", u'dir-\N{EURO SIGN}', root_id))
 
1326
        inv.add(InventoryFile("childid", u'ch\xefld', "dirid"))
 
1327
        inv["childid"].revision = "filerev"
 
1328
        inv["childid"].text_sha1 = "ffff"
 
1329
        inv["childid"].text_size = 0
1347
1330
        chk_bytes = self.get_chk_bytes()
1348
1331
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1349
 
        lines = chk_inv.to_lines()
1350
 
        return CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
1332
        bytes = ''.join(chk_inv.to_lines())
 
1333
        return CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1351
1334
 
1352
1335
    def test__preload_handles_utf8(self):
1353
1336
        new_inv = self.make_basic_utf8_inventory()
1355
1338
        self.assertFalse(new_inv._fully_cached)
1356
1339
        new_inv._preload_cache()
1357
1340
        self.assertEqual(
1358
 
            sorted([new_inv.root_id, b"fileid", b"dirid", b"childid"]),
 
1341
            sorted([new_inv.root_id, "fileid", "dirid", "childid"]),
1359
1342
            sorted(new_inv._fileid_to_entry_cache.keys()))
1360
1343
        ie_root = new_inv._fileid_to_entry_cache[new_inv.root_id]
1361
1344
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1362
1345
                         sorted(ie_root._children.keys()))
1363
 
        ie_dir = new_inv._fileid_to_entry_cache[b'dirid']
 
1346
        ie_dir = new_inv._fileid_to_entry_cache['dirid']
1364
1347
        self.assertEqual([u'ch\xefld'], sorted(ie_dir._children.keys()))
1365
1348
 
1366
1349
    def test__preload_populates_cache(self):
1367
1350
        inv = Inventory()
1368
 
        inv.revision_id = b"revid"
1369
 
        inv.root.revision = b"rootrev"
 
1351
        inv.revision_id = "revid"
 
1352
        inv.root.revision = "rootrev"
1370
1353
        root_id = inv.root.file_id
1371
 
        inv.add(InventoryFile(b"fileid", "file", root_id))
1372
 
        inv.get_entry(b"fileid").revision = b"filerev"
1373
 
        inv.get_entry(b"fileid").executable = True
1374
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1375
 
        inv.get_entry(b"fileid").text_size = 1
1376
 
        inv.add(InventoryDirectory(b"dirid", "dir", root_id))
1377
 
        inv.get_entry(b"dirid").revision = b"dirrev"
1378
 
        inv.add(InventoryFile(b"childid", "child", b"dirid"))
1379
 
        inv.get_entry(b"childid").revision = b"filerev"
1380
 
        inv.get_entry(b"childid").executable = False
1381
 
        inv.get_entry(b"childid").text_sha1 = b"dddd"
1382
 
        inv.get_entry(b"childid").text_size = 1
 
1354
        inv.add(InventoryFile("fileid", "file", root_id))
 
1355
        inv["fileid"].revision = "filerev"
 
1356
        inv["fileid"].executable = True
 
1357
        inv["fileid"].text_sha1 = "ffff"
 
1358
        inv["fileid"].text_size = 1
 
1359
        inv.add(InventoryDirectory("dirid", "dir", root_id))
 
1360
        inv.add(InventoryFile("childid", "child", "dirid"))
 
1361
        inv["childid"].revision = "filerev"
 
1362
        inv["childid"].executable = False
 
1363
        inv["childid"].text_sha1 = "dddd"
 
1364
        inv["childid"].text_size = 1
1383
1365
        chk_bytes = self.get_chk_bytes()
1384
1366
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1385
 
        lines = chk_inv.to_lines()
1386
 
        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
1367
        bytes = ''.join(chk_inv.to_lines())
 
1368
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1387
1369
        self.assertEqual({}, new_inv._fileid_to_entry_cache)
1388
1370
        self.assertFalse(new_inv._fully_cached)
1389
1371
        new_inv._preload_cache()
1390
1372
        self.assertEqual(
1391
 
            sorted([root_id, b"fileid", b"dirid", b"childid"]),
 
1373
            sorted([root_id, "fileid", "dirid", "childid"]),
1392
1374
            sorted(new_inv._fileid_to_entry_cache.keys()))
1393
1375
        self.assertTrue(new_inv._fully_cached)
1394
1376
        ie_root = new_inv._fileid_to_entry_cache[root_id]
1395
1377
        self.assertEqual(['dir', 'file'], sorted(ie_root._children.keys()))
1396
 
        ie_dir = new_inv._fileid_to_entry_cache[b'dirid']
 
1378
        ie_dir = new_inv._fileid_to_entry_cache['dirid']
1397
1379
        self.assertEqual(['child'], sorted(ie_dir._children.keys()))
1398
1380
 
1399
1381
    def test__preload_handles_partially_evaluated_inventory(self):
1400
1382
        new_inv = self.make_basic_utf8_inventory()
1401
 
        ie = new_inv.get_entry(new_inv.root_id)
 
1383
        ie = new_inv[new_inv.root_id]
1402
1384
        self.assertIs(None, ie._children)
1403
1385
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1404
1386
                         sorted(ie.children.keys()))
1409
1391
        # No change
1410
1392
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1411
1393
                         sorted(ie._children.keys()))
1412
 
        ie_dir = new_inv.get_entry(b"dirid")
 
1394
        ie_dir = new_inv["dirid"]
1413
1395
        self.assertEqual([u'ch\xefld'],
1414
1396
                         sorted(ie_dir._children.keys()))
1415
1397
 
1416
1398
    def test_filter_change_in_renamed_subfolder(self):
1417
 
        inv = Inventory(b'tree-root')
1418
 
        inv.root.revision = b'rootrev'
1419
 
        src_ie = inv.add_path('src', 'directory', b'src-id')
1420
 
        src_ie.revision = b'srcrev'
1421
 
        sub_ie = inv.add_path('src/sub/', 'directory', b'sub-id')
1422
 
        sub_ie.revision = b'subrev'
1423
 
        a_ie = inv.add_path('src/sub/a', 'file', b'a-id')
1424
 
        a_ie.revision = b'filerev'
1425
 
        a_ie.text_sha1 = osutils.sha_string(b'content\n')
1426
 
        a_ie.text_size = len(b'content\n')
 
1399
        inv = Inventory('tree-root')
 
1400
        src_ie = inv.add_path('src', 'directory', 'src-id')
 
1401
        inv.add_path('src/sub/', 'directory', 'sub-id')
 
1402
        a_ie = inv.add_path('src/sub/a', 'file', 'a-id')
 
1403
        a_ie.text_sha1 = osutils.sha_string('content\n')
 
1404
        a_ie.text_size = len('content\n')
1427
1405
        chk_bytes = self.get_chk_bytes()
1428
1406
        inv = CHKInventory.from_inventory(chk_bytes, inv)
1429
1407
        inv = inv.create_by_apply_delta([
1430
 
            ("src/sub/a", "src/sub/a", b"a-id", a_ie),
1431
 
            ("src", "src2", b"src-id", src_ie),
1432
 
            ], b'new-rev-2')
1433
 
        new_inv = inv.filter([b'a-id', b'src-id'])
 
1408
            ("src/sub/a", "src/sub/a", "a-id", a_ie),
 
1409
            ("src", "src2", "src-id", src_ie),
 
1410
            ], 'new-rev-2')
 
1411
        new_inv = inv.filter(['a-id', 'src-id'])
1434
1412
        self.assertEqual([
1435
 
            ('', b'tree-root'),
1436
 
            ('src', b'src-id'),
1437
 
            ('src/sub', b'sub-id'),
1438
 
            ('src/sub/a', b'a-id'),
 
1413
            ('', 'tree-root'),
 
1414
            ('src', 'src-id'),
 
1415
            ('src/sub', 'sub-id'),
 
1416
            ('src/sub/a', 'a-id'),
1439
1417
            ], [(path, ie.file_id) for path, ie in new_inv.iter_entries()])
1440
1418
 
1441
 
 
1442
1419
class TestCHKInventoryExpand(tests.TestCaseWithMemoryTransport):
1443
1420
 
1444
1421
    def get_chk_bytes(self):
1446
1423
        trans = self.get_transport('')
1447
1424
        return factory(trans)
1448
1425
 
1449
 
    def make_dir(self, inv, name, parent_id, revision):
1450
 
        ie = inv.make_entry('directory', name, parent_id,
1451
 
                            name.encode('utf-8') + b'-id')
1452
 
        ie.revision = revision
1453
 
        inv.add(ie)
 
1426
    def make_dir(self, inv, name, parent_id):
 
1427
        inv.add(inv.make_entry('directory', name, parent_id, name + '-id'))
1454
1428
 
1455
 
    def make_file(self, inv, name, parent_id, revision, content=b'content\n'):
1456
 
        ie = inv.make_entry('file', name, parent_id,
1457
 
                            name.encode('utf-8') + b'-id')
 
1429
    def make_file(self, inv, name, parent_id, content='content\n'):
 
1430
        ie = inv.make_entry('file', name, parent_id, name + '-id')
1458
1431
        ie.text_sha1 = osutils.sha_string(content)
1459
1432
        ie.text_size = len(content)
1460
 
        ie.revision = revision
1461
1433
        inv.add(ie)
1462
1434
 
1463
1435
    def make_simple_inventory(self):
1464
 
        inv = Inventory(b'TREE_ROOT')
1465
 
        inv.revision_id = b"revid"
1466
 
        inv.root.revision = b"rootrev"
 
1436
        inv = Inventory('TREE_ROOT')
 
1437
        inv.revision_id = "revid"
 
1438
        inv.root.revision = "rootrev"
1467
1439
        # /                 TREE_ROOT
1468
1440
        # dir1/             dir1-id
1469
1441
        #   sub-file1       sub-file1-id
1473
1445
        # dir2/             dir2-id
1474
1446
        #   sub2-file1      sub2-file1-id
1475
1447
        # top               top-id
1476
 
        self.make_dir(inv, 'dir1', b'TREE_ROOT', b'dirrev')
1477
 
        self.make_dir(inv, 'dir2', b'TREE_ROOT', b'dirrev')
1478
 
        self.make_dir(inv, 'sub-dir1', b'dir1-id', b'dirrev')
1479
 
        self.make_file(inv, 'top', b'TREE_ROOT', b'filerev')
1480
 
        self.make_file(inv, 'sub-file1', b'dir1-id', b'filerev')
1481
 
        self.make_file(inv, 'sub-file2', b'dir1-id', b'filerev')
1482
 
        self.make_file(inv, 'subsub-file1', b'sub-dir1-id', b'filerev')
1483
 
        self.make_file(inv, 'sub2-file1', b'dir2-id', b'filerev')
 
1448
        self.make_dir(inv, 'dir1', 'TREE_ROOT')
 
1449
        self.make_dir(inv, 'dir2', 'TREE_ROOT')
 
1450
        self.make_dir(inv, 'sub-dir1', 'dir1-id')
 
1451
        self.make_file(inv, 'top', 'TREE_ROOT')
 
1452
        self.make_file(inv, 'sub-file1', 'dir1-id')
 
1453
        self.make_file(inv, 'sub-file2', 'dir1-id')
 
1454
        self.make_file(inv, 'subsub-file1', 'sub-dir1-id')
 
1455
        self.make_file(inv, 'sub2-file1', 'dir2-id')
1484
1456
        chk_bytes = self.get_chk_bytes()
1485
1457
        #  use a small maximum_size to force internal paging structures
1486
1458
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv,
1487
 
                                              maximum_size=100,
1488
 
                                              search_key_name=b'hash-255-way')
1489
 
        lines = chk_inv.to_lines()
1490
 
        return CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
1459
                        maximum_size=100,
 
1460
                        search_key_name='hash-255-way')
 
1461
        bytes = ''.join(chk_inv.to_lines())
 
1462
        return CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1491
1463
 
1492
1464
    def assert_Getitems(self, expected_fileids, inv, file_ids):
1493
1465
        self.assertEqual(sorted(expected_fileids),
1502
1474
        for entry in entries:
1503
1475
            s = expected_children.setdefault(entry.parent_id, [])
1504
1476
            s.append(entry.file_id)
1505
 
        val_children = {
1506
 
            k: sorted(v) for k, v in val_children.items()}
1507
 
        expected_children = {
1508
 
            k: sorted(v) for k, v in expected_children.items()}
 
1477
        val_children = dict((k, sorted(v)) for k, v
 
1478
                            in val_children.items())
 
1479
        expected_children = dict((k, sorted(v)) for k, v
 
1480
                            in expected_children.items())
1509
1481
        self.assertEqual(expected_children, val_children)
1510
1482
 
1511
1483
    def test_make_simple_inventory(self):
1514
1486
        for path, entry in inv.iter_entries_by_dir():
1515
1487
            layout.append((path, entry.file_id))
1516
1488
        self.assertEqual([
1517
 
            ('', b'TREE_ROOT'),
1518
 
            ('dir1', b'dir1-id'),
1519
 
            ('dir2', b'dir2-id'),
1520
 
            ('top', b'top-id'),
1521
 
            ('dir1/sub-dir1', b'sub-dir1-id'),
1522
 
            ('dir1/sub-file1', b'sub-file1-id'),
1523
 
            ('dir1/sub-file2', b'sub-file2-id'),
1524
 
            ('dir1/sub-dir1/subsub-file1', b'subsub-file1-id'),
1525
 
            ('dir2/sub2-file1', b'sub2-file1-id'),
 
1489
            ('', 'TREE_ROOT'),
 
1490
            ('dir1', 'dir1-id'),
 
1491
            ('dir2', 'dir2-id'),
 
1492
            ('top', 'top-id'),
 
1493
            ('dir1/sub-dir1', 'sub-dir1-id'),
 
1494
            ('dir1/sub-file1', 'sub-file1-id'),
 
1495
            ('dir1/sub-file2', 'sub-file2-id'),
 
1496
            ('dir1/sub-dir1/subsub-file1', 'subsub-file1-id'),
 
1497
            ('dir2/sub2-file1', 'sub2-file1-id'),
1526
1498
            ], layout)
1527
1499
 
1528
1500
    def test__getitems(self):
1529
1501
        inv = self.make_simple_inventory()
1530
1502
        # Reading from disk
1531
 
        self.assert_Getitems([b'dir1-id'], inv, [b'dir1-id'])
1532
 
        self.assertTrue(b'dir1-id' in inv._fileid_to_entry_cache)
1533
 
        self.assertFalse(b'sub-file2-id' in inv._fileid_to_entry_cache)
 
1503
        self.assert_Getitems(['dir1-id'], inv, ['dir1-id'])
 
1504
        self.assertTrue('dir1-id' in inv._fileid_to_entry_cache)
 
1505
        self.assertFalse('sub-file2-id' in inv._fileid_to_entry_cache)
1534
1506
        # From cache
1535
 
        self.assert_Getitems([b'dir1-id'], inv, [b'dir1-id'])
 
1507
        self.assert_Getitems(['dir1-id'], inv, ['dir1-id'])
1536
1508
        # Mixed
1537
 
        self.assert_Getitems([b'dir1-id', b'sub-file2-id'], inv,
1538
 
                             [b'dir1-id', b'sub-file2-id'])
1539
 
        self.assertTrue(b'dir1-id' in inv._fileid_to_entry_cache)
1540
 
        self.assertTrue(b'sub-file2-id' in inv._fileid_to_entry_cache)
 
1509
        self.assert_Getitems(['dir1-id', 'sub-file2-id'], inv,
 
1510
                             ['dir1-id', 'sub-file2-id'])
 
1511
        self.assertTrue('dir1-id' in inv._fileid_to_entry_cache)
 
1512
        self.assertTrue('sub-file2-id' in inv._fileid_to_entry_cache)
1541
1513
 
1542
1514
    def test_single_file(self):
1543
1515
        inv = self.make_simple_inventory()
1544
 
        self.assertExpand([b'TREE_ROOT', b'top-id'], inv, [b'top-id'])
 
1516
        self.assertExpand(['TREE_ROOT', 'top-id'], inv, ['top-id'])
1545
1517
 
1546
1518
    def test_get_all_parents(self):
1547
1519
        inv = self.make_simple_inventory()
1548
 
        self.assertExpand([b'TREE_ROOT', b'dir1-id', b'sub-dir1-id',
1549
 
                           b'subsub-file1-id',
1550
 
                           ], inv, [b'subsub-file1-id'])
 
1520
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id',
 
1521
                           'subsub-file1-id',
 
1522
                          ], inv, ['subsub-file1-id'])
1551
1523
 
1552
1524
    def test_get_children(self):
1553
1525
        inv = self.make_simple_inventory()
1554
 
        self.assertExpand([b'TREE_ROOT', b'dir1-id', b'sub-dir1-id',
1555
 
                           b'sub-file1-id', b'sub-file2-id', b'subsub-file1-id',
1556
 
                           ], inv, [b'dir1-id'])
 
1526
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id',
 
1527
                           'sub-file1-id', 'sub-file2-id', 'subsub-file1-id',
 
1528
                          ], inv, ['dir1-id'])
1557
1529
 
1558
1530
    def test_from_root(self):
1559
1531
        inv = self.make_simple_inventory()
1560
 
        self.assertExpand([b'TREE_ROOT', b'dir1-id', b'dir2-id', b'sub-dir1-id',
1561
 
                           b'sub-file1-id', b'sub-file2-id', b'sub2-file1-id',
1562
 
                           b'subsub-file1-id', b'top-id'], inv, [b'TREE_ROOT'])
 
1532
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'dir2-id', 'sub-dir1-id',
 
1533
                           'sub-file1-id', 'sub-file2-id', 'sub2-file1-id',
 
1534
                           'subsub-file1-id', 'top-id'], inv, ['TREE_ROOT'])
1563
1535
 
1564
1536
    def test_top_level_file(self):
1565
1537
        inv = self.make_simple_inventory()
1566
 
        self.assertExpand([b'TREE_ROOT', b'top-id'], inv, [b'top-id'])
 
1538
        self.assertExpand(['TREE_ROOT', 'top-id'], inv, ['top-id'])
1567
1539
 
1568
1540
    def test_subsub_file(self):
1569
1541
        inv = self.make_simple_inventory()
1570
 
        self.assertExpand([b'TREE_ROOT', b'dir1-id', b'sub-dir1-id',
1571
 
                           b'subsub-file1-id'], inv, [b'subsub-file1-id'])
 
1542
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id',
 
1543
                           'subsub-file1-id'], inv, ['subsub-file1-id'])
1572
1544
 
1573
1545
    def test_sub_and_root(self):
1574
1546
        inv = self.make_simple_inventory()
1575
 
        self.assertExpand([b'TREE_ROOT', b'dir1-id', b'sub-dir1-id', b'top-id',
1576
 
                           b'subsub-file1-id'], inv, [b'top-id', b'subsub-file1-id'])
 
1547
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id', 'top-id',
 
1548
                           'subsub-file1-id'], inv, ['top-id', 'subsub-file1-id'])
1577
1549
 
1578
1550
 
1579
1551
class TestMutableInventoryFromTree(TestCaseWithTransport):
1588
1560
    def test_some_files(self):
1589
1561
        wt = self.make_branch_and_tree('.')
1590
1562
        self.build_tree(['a'])
1591
 
        wt.add(['a'], [b'thefileid'])
 
1563
        wt.add(['a'], ['thefileid'])
1592
1564
        revid = wt.commit("commit")
1593
1565
        tree = wt.branch.repository.revision_tree(revid)
1594
1566
        inv = mutable_inventory_from_tree(tree)
1595
1567
        self.assertEqual(revid, inv.revision_id)
1596
1568
        self.assertEqual(2, len(inv))
1597
 
        self.assertEqual("a", inv.get_entry(b'thefileid').name)
 
1569
        self.assertEqual("a", inv['thefileid'].name)
1598
1570
        # The inventory should be mutable and independent of
1599
1571
        # the original tree
1600
 
        self.assertFalse(tree.root_inventory.get_entry(
1601
 
            b'thefileid').executable)
1602
 
        inv.get_entry(b'thefileid').executable = True
1603
 
        self.assertFalse(tree.root_inventory.get_entry(
1604
 
            b'thefileid').executable)
1605
 
 
1606
 
 
1607
 
class ErrorTests(TestCase):
1608
 
 
1609
 
    def test_duplicate_file_id(self):
1610
 
        error = DuplicateFileId('a_file_id', 'foo')
1611
 
        self.assertEqualDiff(
1612
 
            'File id {a_file_id} already exists in inventory as foo',
1613
 
            str(error))
 
1572
        self.assertFalse(tree.root_inventory['thefileid'].executable)
 
1573
        inv['thefileid'].executable = True
 
1574
        self.assertFalse(tree.root_inventory['thefileid'].executable)