/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/bzr/tests/test_inv.py

  • Committer: Breezy landing bot
  • Author(s): Colin Watson
  • Date: 2020-11-16 21:47:08 UTC
  • mfrom: (7521.1.1 remove-lp-workaround)
  • Revision ID: breezy.the.bot@gmail.com-20201116214708-jos209mgxi41oy15
Remove breezy.git workaround for bazaar.launchpad.net.

Merged from https://code.launchpad.net/~cjwatson/brz/remove-lp-workaround/+merge/393710

Show diffs side-by-side

added added

removed removed

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