/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-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

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