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

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_inv.py
1
 
# Copyright (C) 2005-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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 .. import (
 
18
from bzrlib import (
 
19
    chk_map,
 
20
    groupcompress,
19
21
    errors,
 
22
    inventory,
20
23
    osutils,
21
24
    repository,
22
25
    revision,
23
26
    tests,
24
27
    workingtree,
25
28
    )
26
 
from ..bzr import (
27
 
    chk_map,
28
 
    groupcompress,
29
 
    inventory,
30
 
    )
31
 
from ..bzr.inventory import (
 
29
from bzrlib.inventory import (
32
30
    CHKInventory,
33
31
    Inventory,
34
32
    ROOT_ID,
38
36
    TreeReference,
39
37
    mutable_inventory_from_tree,
40
38
    )
41
 
from . import (
 
39
from bzrlib.tests import (
42
40
    TestCase,
43
41
    TestCaseWithTransport,
44
42
    )
45
 
from .scenarios import load_tests_apply_scenarios
 
43
from bzrlib.tests.scenarios import load_tests_apply_scenarios
46
44
 
47
45
 
48
46
load_tests = load_tests_apply_scenarios
64
62
                'apply_delta':apply_inventory_Repository_add_inventory_by_delta,
65
63
                'format':format}))
66
64
    for format in workingtree.format_registry._get_all():
67
 
        repo_fmt = format._matchingcontroldir.repository_format
 
65
        repo_fmt = format._matchingbzrdir.repository_format
68
66
        if not repo_fmt.supports_full_versioned_files:
69
67
            continue
70
68
        scenarios.append(
107
105
    :param delta: The inventory delta to apply:
108
106
    :return: An inventory resulting from the application.
109
107
    """
110
 
    control = self.make_controldir('tree', format=self.format._matchingcontroldir)
 
108
    control = self.make_bzrdir('tree', format=self.format._matchingbzrdir)
111
109
    control.create_repository()
112
110
    control.create_branch()
113
111
    tree = self.format.initialize(control)
117
115
    finally:
118
116
        tree.unlock()
119
117
    # Fresh object, reads disk again.
120
 
    tree = tree.controldir.open_workingtree()
 
118
    tree = tree.bzrdir.open_workingtree()
121
119
    tree.lock_write()
122
120
    try:
123
121
        tree.apply_inventory_delta(delta)
124
122
    finally:
125
123
        tree.unlock()
126
124
    # reload tree - ensure we get what was written.
127
 
    tree = tree.controldir.open_workingtree()
 
125
    tree = tree.bzrdir.open_workingtree()
128
126
    tree.lock_read()
129
127
    self.addCleanup(tree.unlock)
130
128
    if not invalid_delta:
144
142
            # We don't want to apply the delta to the basis, because we expect
145
143
            # the delta is invalid.
146
144
            result_inv = basis
147
 
            result_inv.revision_id = b'result'
 
145
            result_inv.revision_id = 'result'
148
146
            target_entries = None
149
147
        else:
150
148
            result_inv = basis.create_by_apply_delta(delta, 'result')
172
170
    """Put all entries into tree, but at a unique location."""
173
171
    added_ids = set()
174
172
    added_paths = set()
175
 
    tree.add(['unique-dir'], [b'unique-dir-id'], ['directory'])
 
173
    tree.add(['unique-dir'], ['unique-dir-id'], ['directory'])
176
174
    for path, ie in basis.iter_entries_by_dir():
177
175
        if ie.file_id in added_ids:
178
176
            continue
198
196
    :param delta: The inventory delta to apply:
199
197
    :return: An inventory resulting from the application.
200
198
    """
201
 
    control = test.make_controldir('tree', format=test.format._matchingcontroldir)
 
199
    control = test.make_bzrdir('tree', format=test.format._matchingbzrdir)
202
200
    control.create_repository()
203
201
    control.create_branch()
204
202
    tree = test.format.initialize(control)
222
220
    finally:
223
221
        tree.unlock()
224
222
    # reload tree - ensure we get what was written.
225
 
    tree = tree.controldir.open_workingtree()
 
223
    tree = tree.bzrdir.open_workingtree()
226
224
    basis_tree = tree.basis_tree()
227
225
    basis_tree.lock_read()
228
226
    test.addCleanup(basis_tree.unlock)
245
243
    :return: An inventory resulting from the application.
246
244
    """
247
245
    format = self.format()
248
 
    control = self.make_controldir('tree', format=format._matchingcontroldir)
 
246
    control = self.make_bzrdir('tree', format=format._matchingbzrdir)
249
247
    repo = format.initialize(control)
250
248
    repo.lock_write()
251
249
    try:
276
274
    finally:
277
275
        repo.unlock()
278
276
    # Fresh lock, reads disk again.
279
 
    repo = repo.controldir.open_repository()
 
277
    repo = repo.bzrdir.open_repository()
280
278
    repo.lock_read()
281
279
    self.addCleanup(repo.unlock)
282
280
    return repo.get_inventory('result')
286
284
 
287
285
    def test_creation_from_root_id(self):
288
286
        # iff a root id is passed to the constructor, a root directory is made
289
 
        inv = inventory.Inventory(root_id=b'tree-root')
 
287
        inv = inventory.Inventory(root_id='tree-root')
290
288
        self.assertNotEqual(None, inv.root)
291
 
        self.assertEqual(b'tree-root', inv.root.file_id)
 
289
        self.assertEqual('tree-root', inv.root.file_id)
292
290
 
293
291
    def test_add_path_of_root(self):
294
292
        # if no root id is given at creation time, there is no root directory
295
293
        inv = inventory.Inventory(root_id=None)
296
294
        self.assertIs(None, inv.root)
297
295
        # add a root entry by adding its path
298
 
        ie = inv.add_path(u"", "directory", b"my-root")
299
 
        ie.revision = b'test-rev'
300
 
        self.assertEqual(b"my-root", ie.file_id)
 
296
        ie = inv.add_path("", "directory", "my-root")
 
297
        ie.revision = 'test-rev'
 
298
        self.assertEqual("my-root", ie.file_id)
301
299
        self.assertIs(ie, inv.root)
302
300
 
303
301
    def test_add_path(self):
304
 
        inv = inventory.Inventory(root_id=b'tree_root')
305
 
        ie = inv.add_path(u'hello', 'file', b'hello-id')
306
 
        self.assertEqual(b'hello-id', ie.file_id)
 
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)
307
305
        self.assertEqual('file', ie.kind)
308
306
 
309
307
    def test_copy(self):
310
308
        """Make sure copy() works and creates a deep copy."""
311
 
        inv = inventory.Inventory(root_id=b'some-tree-root')
312
 
        ie = inv.add_path(u'hello', 'file', b'hello-id')
 
309
        inv = inventory.Inventory(root_id='some-tree-root')
 
310
        ie = inv.add_path('hello', 'file', 'hello-id')
313
311
        inv2 = inv.copy()
314
 
        inv.root.file_id = b'some-new-root'
315
 
        ie.name = u'file2'
316
 
        self.assertEqual(b'some-tree-root', inv2.root.file_id)
317
 
        self.assertEqual(u'hello', inv2.get_entry(b'hello-id').name)
 
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)
318
316
 
319
317
    def test_copy_empty(self):
320
318
        """Make sure an empty inventory can be copied."""
324
322
 
325
323
    def test_copy_copies_root_revision(self):
326
324
        """Make sure the revision of the root gets copied."""
327
 
        inv = inventory.Inventory(root_id=b'someroot')
328
 
        inv.root.revision = b'therev'
 
325
        inv = inventory.Inventory(root_id='someroot')
 
326
        inv.root.revision = 'therev'
329
327
        inv2 = inv.copy()
330
 
        self.assertEqual(b'someroot', inv2.root.file_id)
331
 
        self.assertEqual(b'therev', inv2.root.revision)
 
328
        self.assertEquals('someroot', inv2.root.file_id)
 
329
        self.assertEquals('therev', inv2.root.revision)
332
330
 
333
331
    def test_create_tree_reference(self):
334
 
        inv = inventory.Inventory(b'tree-root-123')
335
 
        inv.add(TreeReference(
336
 
            b'nested-id', 'nested', parent_id=b'tree-root-123',
337
 
            revision=b'rev', reference_revision=b'rev2'))
 
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'))
338
335
 
339
336
    def test_error_encoding(self):
340
 
        inv = inventory.Inventory(b'tree-root')
341
 
        inv.add(InventoryFile(b'a-id', u'\u1234', b'tree-root'))
 
337
        inv = inventory.Inventory('tree-root')
 
338
        inv.add(InventoryFile('a-id', u'\u1234', 'tree-root'))
342
339
        e = self.assertRaises(errors.InconsistentDelta, inv.add,
343
 
            InventoryFile(b'b-id', u'\u1234', b'tree-root'))
 
340
            InventoryFile('b-id', u'\u1234', 'tree-root'))
344
341
        self.assertContainsRe(str(e), r'\\u1234')
345
342
 
346
343
    def test_add_recursive(self):
347
 
        parent = InventoryDirectory(b'src-id', 'src', b'tree-root')
348
 
        child = InventoryFile(b'hello-id', 'hello.c', b'src-id')
 
344
        parent = InventoryDirectory('src-id', 'src', 'tree-root')
 
345
        child = InventoryFile('hello-id', 'hello.c', 'src-id')
349
346
        parent.children[child.file_id] = child
350
 
        inv = inventory.Inventory(b'tree-root')
 
347
        inv = inventory.Inventory('tree-root')
351
348
        inv.add(parent)
352
 
        self.assertEqual('src/hello.c', inv.id2path(b'hello-id'))
 
349
        self.assertEqual('src/hello.c', inv.id2path('hello-id'))
353
350
 
354
351
 
355
352
 
376
373
            inv.root.revision = 'basis'
377
374
        return inv
378
375
 
379
 
    def make_file_ie(self, file_id=b'file-id', name='name', parent_id=None):
 
376
    def make_file_ie(self, file_id='file-id', name='name', parent_id=None):
380
377
        ie_file = inventory.InventoryFile(file_id, name, parent_id)
381
 
        ie_file.revision = b'result'
 
378
        ie_file.revision = 'result'
382
379
        ie_file.text_size = 0
383
380
        ie_file.text_sha1 = ''
384
381
        return ie_file
393
390
    def test_None_file_id(self):
394
391
        inv = self.get_empty_inventory()
395
392
        dir1 = inventory.InventoryDirectory(None, 'dir1', inv.root.file_id)
396
 
        dir1.revision = b'result'
 
393
        dir1.revision = 'result'
397
394
        delta = [(None, u'dir1', None, dir1)]
398
395
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
399
396
            inv, delta)
401
398
    def test_unicode_file_id(self):
402
399
        inv = self.get_empty_inventory()
403
400
        dir1 = inventory.InventoryDirectory(u'dirid', 'dir1', inv.root.file_id)
404
 
        dir1.revision = b'result'
 
401
        dir1.revision = 'result'
405
402
        delta = [(None, u'dir1', dir1.file_id, dir1)]
406
403
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
407
404
            inv, delta)
409
406
    def test_repeated_file_id(self):
410
407
        inv = self.get_empty_inventory()
411
408
        file1 = inventory.InventoryFile('id', 'path1', inv.root.file_id)
412
 
        file1.revision = b'result'
 
409
        file1.revision = 'result'
413
410
        file1.text_size = 0
414
411
        file1.text_sha1 = ""
415
412
        file2 = file1.copy()
421
418
    def test_repeated_new_path(self):
422
419
        inv = self.get_empty_inventory()
423
420
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
424
 
        file1.revision = b'result'
 
421
        file1.revision = 'result'
425
422
        file1.text_size = 0
426
423
        file1.text_sha1 = ""
427
424
        file2 = file1.copy()
433
430
    def test_repeated_old_path(self):
434
431
        inv = self.get_empty_inventory()
435
432
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
436
 
        file1.revision = b'result'
 
433
        file1.revision = 'result'
437
434
        file1.text_size = 0
438
435
        file1.text_sha1 = ""
439
436
        # We can't *create* a source inventory with the same path, but
443
440
        # location. Alternatively, we could have a repeated fileid, but that
444
441
        # is separately checked for.
445
442
        file2 = inventory.InventoryFile('id2', 'path2', inv.root.file_id)
446
 
        file2.revision = b'result'
 
443
        file2.revision = 'result'
447
444
        file2.text_size = 0
448
445
        file2.text_sha1 = ""
449
446
        inv.add(file1)
455
452
    def test_mismatched_id_entry_id(self):
456
453
        inv = self.get_empty_inventory()
457
454
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
458
 
        file1.revision = b'result'
 
455
        file1.revision = 'result'
459
456
        file1.text_size = 0
460
457
        file1.text_sha1 = ""
461
458
        delta = [(None, u'path', 'id', file1)]
471
468
    def test_mismatched_new_path_None_entry(self):
472
469
        inv = self.get_empty_inventory()
473
470
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
474
 
        file1.revision = b'result'
 
471
        file1.revision = 'result'
475
472
        file1.text_size = 0
476
473
        file1.text_sha1 = ""
477
474
        delta = [(u"path", None, 'id1', file1)]
481
478
    def test_parent_is_not_directory(self):
482
479
        inv = self.get_empty_inventory()
483
480
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
484
 
        file1.revision = b'result'
 
481
        file1.revision = 'result'
485
482
        file1.text_size = 0
486
483
        file1.text_sha1 = ""
487
484
        file2 = inventory.InventoryFile('id2', 'path2', 'id1')
488
 
        file2.revision = b'result'
 
485
        file2.revision = 'result'
489
486
        file2.text_size = 0
490
487
        file2.text_sha1 = ""
491
488
        inv.add(file1)
496
493
    def test_parent_is_missing(self):
497
494
        inv = self.get_empty_inventory()
498
495
        file2 = inventory.InventoryFile('id2', 'path2', 'missingparent')
499
 
        file2.revision = b'result'
 
496
        file2.revision = 'result'
500
497
        file2.text_size = 0
501
498
        file2.text_sha1 = ""
502
499
        delta = [(None, u'path/path2', 'id2', file2)]
506
503
    def test_new_parent_path_has_wrong_id(self):
507
504
        inv = self.get_empty_inventory()
508
505
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
509
 
        parent1.revision = b'result'
 
506
        parent1.revision = 'result'
510
507
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
511
 
        parent2.revision = b'result'
 
508
        parent2.revision = 'result'
512
509
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
513
 
        file1.revision = b'result'
 
510
        file1.revision = 'result'
514
511
        file1.text_size = 0
515
512
        file1.text_sha1 = ""
516
513
        inv.add(parent1)
524
521
    def test_old_parent_path_is_wrong(self):
525
522
        inv = self.get_empty_inventory()
526
523
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
527
 
        parent1.revision = b'result'
 
524
        parent1.revision = 'result'
528
525
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
529
 
        parent2.revision = b'result'
 
526
        parent2.revision = 'result'
530
527
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
531
 
        file1.revision = b'result'
 
528
        file1.revision = 'result'
532
529
        file1.text_size = 0
533
530
        file1.text_sha1 = ""
534
531
        inv.add(parent1)
543
540
    def test_old_parent_path_is_for_other_id(self):
544
541
        inv = self.get_empty_inventory()
545
542
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
546
 
        parent1.revision = b'result'
 
543
        parent1.revision = 'result'
547
544
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
548
 
        parent2.revision = b'result'
 
545
        parent2.revision = 'result'
549
546
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
550
 
        file1.revision = b'result'
 
547
        file1.revision = 'result'
551
548
        file1.text_size = 0
552
549
        file1.text_sha1 = ""
553
550
        file2 = inventory.InventoryFile('id2', 'path', 'p-1')
554
 
        file2.revision = b'result'
 
551
        file2.revision = 'result'
555
552
        file2.text_size = 0
556
553
        file2.text_sha1 = ""
557
554
        inv.add(parent1)
568
565
    def test_add_existing_id_new_path(self):
569
566
        inv = self.get_empty_inventory()
570
567
        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
571
 
        parent1.revision = b'result'
 
568
        parent1.revision = 'result'
572
569
        parent2 = inventory.InventoryDirectory('p-1', 'dir2', inv.root.file_id)
573
 
        parent2.revision = b'result'
 
570
        parent2.revision = 'result'
574
571
        inv.add(parent1)
575
572
        delta = [(None, u'dir2', 'p-1', parent2)]
576
573
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
579
576
    def test_add_new_id_existing_path(self):
580
577
        inv = self.get_empty_inventory()
581
578
        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
582
 
        parent1.revision = b'result'
 
579
        parent1.revision = 'result'
583
580
        parent2 = inventory.InventoryDirectory('p-2', 'dir1', inv.root.file_id)
584
 
        parent2.revision = b'result'
 
581
        parent2.revision = 'result'
585
582
        inv.add(parent1)
586
583
        delta = [(None, u'dir1', 'p-2', parent2)]
587
584
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
590
587
    def test_remove_dir_leaving_dangling_child(self):
591
588
        inv = self.get_empty_inventory()
592
589
        dir1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
593
 
        dir1.revision = b'result'
 
590
        dir1.revision = 'result'
594
591
        dir2 = inventory.InventoryDirectory('p-2', 'child1', 'p-1')
595
 
        dir2.revision = b'result'
 
592
        dir2.revision = 'result'
596
593
        dir3 = inventory.InventoryDirectory('p-3', 'child2', 'p-1')
597
 
        dir3.revision = b'result'
 
594
        dir3.revision = 'result'
598
595
        inv.add(dir1)
599
596
        inv.add(dir2)
600
597
        inv.add(dir3)
605
602
 
606
603
    def test_add_file(self):
607
604
        inv = self.get_empty_inventory()
608
 
        file1 = inventory.InventoryFile(b'file-id', 'path', inv.root.file_id)
609
 
        file1.revision = b'result'
 
605
        file1 = inventory.InventoryFile('file-id', 'path', inv.root.file_id)
 
606
        file1.revision = 'result'
610
607
        file1.text_size = 0
611
608
        file1.text_sha1 = ''
612
 
        delta = [(None, u'path', b'file-id', file1)]
 
609
        delta = [(None, u'path', 'file-id', file1)]
613
610
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
614
 
        self.assertEqual(b'file-id', res_inv.get_entry(b'file-id').file_id)
 
611
        self.assertEqual('file-id', res_inv['file-id'].file_id)
615
612
 
616
613
    def test_remove_file(self):
617
614
        inv = self.get_empty_inventory()
618
 
        file1 = inventory.InventoryFile(b'file-id', 'path', inv.root.file_id)
619
 
        file1.revision = b'result'
 
615
        file1 = inventory.InventoryFile('file-id', 'path', inv.root.file_id)
 
616
        file1.revision = 'result'
620
617
        file1.text_size = 0
621
618
        file1.text_sha1 = ''
622
619
        inv.add(file1)
623
 
        delta = [(u'path', None, b'file-id', None)]
 
620
        delta = [(u'path', None, 'file-id', None)]
624
621
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
625
622
        self.assertEqual(None, res_inv.path2id('path'))
626
 
        self.assertRaises(errors.NoSuchId, res_inv.id2path, b'file-id')
 
623
        self.assertRaises(errors.NoSuchId, res_inv.id2path, 'file-id')
627
624
 
628
625
    def test_rename_file(self):
629
626
        inv = self.get_empty_inventory()
630
627
        file1 = self.make_file_ie(name='path', parent_id=inv.root.file_id)
631
628
        inv.add(file1)
632
629
        file2 = self.make_file_ie(name='path2', parent_id=inv.root.file_id)
633
 
        delta = [(u'path', 'path2', b'file-id', file2)]
 
630
        delta = [(u'path', 'path2', 'file-id', file2)]
634
631
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
635
632
        self.assertEqual(None, res_inv.path2id('path'))
636
 
        self.assertEqual(b'file-id', res_inv.path2id('path2'))
 
633
        self.assertEqual('file-id', res_inv.path2id('path2'))
637
634
 
638
635
    def test_replaced_at_new_path(self):
639
636
        inv = self.get_empty_inventory()
640
 
        file1 = self.make_file_ie(file_id=b'id1', parent_id=inv.root.file_id)
 
637
        file1 = self.make_file_ie(file_id='id1', parent_id=inv.root.file_id)
641
638
        inv.add(file1)
642
 
        file2 = self.make_file_ie(file_id=b'id2', parent_id=inv.root.file_id)
643
 
        delta = [(u'name', None, b'id1', None),
644
 
                 (None, u'name', b'id2', file2)]
 
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)]
645
642
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
646
 
        self.assertEqual(b'id2', res_inv.path2id('name'))
 
643
        self.assertEqual('id2', res_inv.path2id('name'))
647
644
 
648
645
    def test_rename_dir(self):
649
646
        inv = self.get_empty_inventory()
650
 
        dir1 = inventory.InventoryDirectory(b'dir-id', 'dir1', inv.root.file_id)
651
 
        dir1.revision = b'basis'
652
 
        file1 = self.make_file_ie(parent_id=b'dir-id')
 
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')
653
650
        inv.add(dir1)
654
651
        inv.add(file1)
655
 
        dir2 = inventory.InventoryDirectory(b'dir-id', 'dir2', inv.root.file_id)
656
 
        dir2.revision = b'result'
657
 
        delta = [('dir1', 'dir2', b'dir-id', dir2)]
 
652
        dir2 = inventory.InventoryDirectory('dir-id', 'dir2', inv.root.file_id)
 
653
        dir2.revision = 'result'
 
654
        delta = [('dir1', 'dir2', 'dir-id', dir2)]
658
655
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
659
656
        # The file should be accessible under the new path
660
 
        self.assertEqual(b'file-id', res_inv.path2id('dir2/name'))
 
657
        self.assertEqual('file-id', res_inv.path2id('dir2/name'))
661
658
 
662
659
    def test_renamed_dir_with_renamed_child(self):
663
660
        inv = self.get_empty_inventory()
664
 
        dir1 = inventory.InventoryDirectory(b'dir-id', 'dir1', inv.root.file_id)
665
 
        dir1.revision = b'basis'
666
 
        file1 = self.make_file_ie(b'file-id-1', 'name1', parent_id=b'dir-id')
667
 
        file2 = self.make_file_ie(b'file-id-2', 'name2', parent_id=b'dir-id')
 
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')
668
665
        inv.add(dir1)
669
666
        inv.add(file1)
670
667
        inv.add(file2)
671
 
        dir2 = inventory.InventoryDirectory(b'dir-id', 'dir2', inv.root.file_id)
672
 
        dir2.revision = b'result'
673
 
        file2b = self.make_file_ie(b'file-id-2', 'name2', inv.root.file_id)
674
 
        delta = [('dir1', 'dir2', b'dir-id', dir2),
675
 
                 ('dir1/name2', 'name2', b'file-id-2', file2b)]
 
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)]
676
673
        res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
677
674
        # The file should be accessible under the new path
678
 
        self.assertEqual(b'file-id-1', res_inv.path2id('dir2/name1'))
 
675
        self.assertEqual('file-id-1', res_inv.path2id('dir2/name1'))
679
676
        self.assertEqual(None, res_inv.path2id('dir2/name2'))
680
 
        self.assertEqual(b'file-id-2', res_inv.path2id('name2'))
 
677
        self.assertEqual('file-id-2', res_inv.path2id('name2'))
681
678
 
682
679
    def test_is_root(self):
683
680
        """Ensure our root-checking code is accurate."""
700
697
 
701
698
class TestInventoryEntry(TestCase):
702
699
 
703
 
    def test_file_invalid_entry_name(self):
704
 
        self.assertRaises(errors.InvalidEntryName, inventory.InventoryFile,
705
 
            '123', 'a/hello.c', ROOT_ID)
706
 
 
707
 
    def test_file_backslash(self):
708
 
        file = inventory.InventoryFile('123', 'h\\ello.c', ROOT_ID)
709
 
        self.assertEquals(file.name, 'h\\ello.c')
710
 
 
711
700
    def test_file_kind_character(self):
712
701
        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
713
702
        self.assertEqual(file.kind_character(), '')
940
929
        inv.revision_id = "revid"
941
930
        inv.root.revision = "rootrev"
942
931
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
943
 
        inv.get_entry("fileid").revision = "filerev"
944
 
        inv.get_entry("fileid").executable = True
945
 
        inv.get_entry("fileid").text_sha1 = "ffff"
946
 
        inv.get_entry("fileid").text_size = 1
 
932
        inv["fileid"].revision = "filerev"
 
933
        inv["fileid"].executable = True
 
934
        inv["fileid"].text_sha1 = "ffff"
 
935
        inv["fileid"].text_size = 1
947
936
        chk_bytes = self.get_chk_bytes()
948
937
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
949
938
        bytes = ''.join(chk_inv.to_lines())
950
939
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
951
 
        root_entry = new_inv.get_entry(inv.root.file_id)
 
940
        root_entry = new_inv[inv.root.file_id]
952
941
        self.assertEqual(None, root_entry._children)
953
 
        self.assertEqual({'file'}, set(root_entry.children))
954
 
        file_direct = new_inv.get_entry("fileid")
 
942
        self.assertEqual(['file'], root_entry.children.keys())
 
943
        file_direct = new_inv["fileid"]
955
944
        file_found = root_entry.children['file']
956
945
        self.assertEqual(file_direct.kind, file_found.kind)
957
946
        self.assertEqual(file_direct.file_id, file_found.file_id)
977
966
        self.assertEqual(120, p_id_basename._root_node.maximum_size)
978
967
        self.assertEqual(2, p_id_basename._root_node._key_width)
979
968
 
980
 
    def test_iter_all_ids(self):
 
969
    def test___iter__(self):
981
970
        inv = Inventory()
982
971
        inv.revision_id = "revid"
983
972
        inv.root.revision = "rootrev"
984
973
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
985
 
        inv.get_entry("fileid").revision = "filerev"
986
 
        inv.get_entry("fileid").executable = True
987
 
        inv.get_entry("fileid").text_sha1 = "ffff"
988
 
        inv.get_entry("fileid").text_size = 1
 
974
        inv["fileid"].revision = "filerev"
 
975
        inv["fileid"].executable = True
 
976
        inv["fileid"].text_sha1 = "ffff"
 
977
        inv["fileid"].text_size = 1
989
978
        chk_bytes = self.get_chk_bytes()
990
979
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
991
980
        bytes = ''.join(chk_inv.to_lines())
992
981
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
993
 
        fileids = sorted(new_inv.iter_all_ids())
 
982
        fileids = list(new_inv.__iter__())
 
983
        fileids.sort()
994
984
        self.assertEqual([inv.root.file_id, "fileid"], fileids)
995
985
 
996
986
    def test__len__(self):
998
988
        inv.revision_id = "revid"
999
989
        inv.root.revision = "rootrev"
1000
990
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
1001
 
        inv.get_entry("fileid").revision = "filerev"
1002
 
        inv.get_entry("fileid").executable = True
1003
 
        inv.get_entry("fileid").text_sha1 = "ffff"
1004
 
        inv.get_entry("fileid").text_size = 1
 
991
        inv["fileid"].revision = "filerev"
 
992
        inv["fileid"].executable = True
 
993
        inv["fileid"].text_sha1 = "ffff"
 
994
        inv["fileid"].text_size = 1
1005
995
        chk_bytes = self.get_chk_bytes()
1006
996
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1007
997
        self.assertEqual(2, len(chk_inv))
1008
998
 
1009
 
    def test_get_entry(self):
 
999
    def test___getitem__(self):
1010
1000
        inv = Inventory()
1011
 
        inv.revision_id = b"revid"
1012
 
        inv.root.revision = b"rootrev"
1013
 
        inv.add(InventoryFile(b"fileid", u"file", inv.root.file_id))
1014
 
        inv.get_entry(b"fileid").revision = b"filerev"
1015
 
        inv.get_entry(b"fileid").executable = True
1016
 
        inv.get_entry(b"fileid").text_sha1 = b"ffff"
1017
 
        inv.get_entry(b"fileid").text_size = 1
 
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
1018
1008
        chk_bytes = self.get_chk_bytes()
1019
1009
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1020
 
        data = b''.join(chk_inv.to_lines())
1021
 
        new_inv = CHKInventory.deserialise(chk_bytes, data, (b"revid",))
1022
 
        root_entry = new_inv.get_entry(inv.root.file_id)
1023
 
        file_entry = new_inv.get_entry(b"fileid")
 
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"]
1024
1014
        self.assertEqual("directory", root_entry.kind)
1025
1015
        self.assertEqual(inv.root.file_id, root_entry.file_id)
1026
1016
        self.assertEqual(inv.root.parent_id, root_entry.parent_id)
1027
1017
        self.assertEqual(inv.root.name, root_entry.name)
1028
 
        self.assertEqual(b"rootrev", root_entry.revision)
 
1018
        self.assertEqual("rootrev", root_entry.revision)
1029
1019
        self.assertEqual("file", file_entry.kind)
1030
 
        self.assertEqual(b"fileid", file_entry.file_id)
 
1020
        self.assertEqual("fileid", file_entry.file_id)
1031
1021
        self.assertEqual(inv.root.file_id, file_entry.parent_id)
1032
 
        self.assertEqual(u"file", file_entry.name)
1033
 
        self.assertEqual(b"filerev", file_entry.revision)
1034
 
        self.assertEqual(b"ffff", file_entry.text_sha1)
 
1022
        self.assertEqual("file", file_entry.name)
 
1023
        self.assertEqual("filerev", file_entry.revision)
 
1024
        self.assertEqual("ffff", file_entry.text_sha1)
1035
1025
        self.assertEqual(1, file_entry.text_size)
1036
1026
        self.assertEqual(True, file_entry.executable)
1037
 
        self.assertRaises(errors.NoSuchId, new_inv.get_entry, 'missing')
 
1027
        self.assertRaises(errors.NoSuchId, new_inv.__getitem__, 'missing')
1038
1028
 
1039
1029
    def test_has_id_true(self):
1040
1030
        inv = Inventory()
1041
 
        inv.revision_id = b"revid"
1042
 
        inv.root.revision = b"rootrev"
1043
 
        inv.add(InventoryFile(b"fileid", "file", inv.root.file_id))
1044
 
        inv.get_entry(b"fileid").revision = b"filerev"
1045
 
        inv.get_entry(b"fileid").executable = True
1046
 
        inv.get_entry(b"fileid").text_sha1 = "ffff"
1047
 
        inv.get_entry(b"fileid").text_size = 1
 
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
1048
1038
        chk_bytes = self.get_chk_bytes()
1049
1039
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1050
 
        self.assertTrue(chk_inv.has_id(b'fileid'))
 
1040
        self.assertTrue(chk_inv.has_id('fileid'))
1051
1041
        self.assertTrue(chk_inv.has_id(inv.root.file_id))
1052
1042
 
1053
1043
    def test_has_id_not(self):
1054
1044
        inv = Inventory()
1055
 
        inv.revision_id = b"revid"
1056
 
        inv.root.revision = b"rootrev"
 
1045
        inv.revision_id = "revid"
 
1046
        inv.root.revision = "rootrev"
1057
1047
        chk_bytes = self.get_chk_bytes()
1058
1048
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1059
 
        self.assertFalse(chk_inv.has_id(b'fileid'))
 
1049
        self.assertFalse(chk_inv.has_id('fileid'))
1060
1050
 
1061
1051
    def test_id2path(self):
1062
1052
        inv = Inventory()
1063
 
        inv.revision_id = b"revid"
1064
 
        inv.root.revision = b"rootrev"
1065
 
        direntry = InventoryDirectory(b"dirid", "dir", inv.root.file_id)
 
1053
        inv.revision_id = "revid"
 
1054
        inv.root.revision = "rootrev"
 
1055
        direntry = InventoryDirectory("dirid", "dir", inv.root.file_id)
1066
1056
        fileentry = InventoryFile("fileid", "file", "dirid")
1067
1057
        inv.add(direntry)
1068
1058
        inv.add(fileentry)
1069
 
        inv.get_entry(b"fileid").revision = b"filerev"
1070
 
        inv.get_entry(b"fileid").executable = True
1071
 
        inv.get_entry(b"fileid").text_sha1 = "ffff"
1072
 
        inv.get_entry(b"fileid").text_size = 1
1073
 
        inv.get_entry(b"dirid").revision = b"filerev"
 
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"
1074
1064
        chk_bytes = self.get_chk_bytes()
1075
1065
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1076
1066
        bytes = ''.join(chk_inv.to_lines())
1077
 
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
 
1067
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1078
1068
        self.assertEqual('', new_inv.id2path(inv.root.file_id))
1079
 
        self.assertEqual('dir', new_inv.id2path(b'dirid'))
1080
 
        self.assertEqual('dir/file', new_inv.id2path(b'fileid'))
 
1069
        self.assertEqual('dir', new_inv.id2path('dirid'))
 
1070
        self.assertEqual('dir/file', new_inv.id2path('fileid'))
1081
1071
 
1082
1072
    def test_path2id(self):
1083
1073
        inv = Inventory()
1084
 
        inv.revision_id = b"revid"
1085
 
        inv.root.revision = b"rootrev"
1086
 
        direntry = InventoryDirectory(b"dirid", "dir", inv.root.file_id)
1087
 
        fileentry = InventoryFile(b"fileid", "file", b"dirid")
 
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")
1088
1078
        inv.add(direntry)
1089
1079
        inv.add(fileentry)
1090
 
        inv.get_entry(b"fileid").revision = b"filerev"
1091
 
        inv.get_entry(b"fileid").executable = True
1092
 
        inv.get_entry(b"fileid").text_sha1 = "ffff"
1093
 
        inv.get_entry(b"fileid").text_size = 1
1094
 
        inv.get_entry(b"dirid").revision = b"filerev"
 
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"
1095
1085
        chk_bytes = self.get_chk_bytes()
1096
1086
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1097
1087
        bytes = ''.join(chk_inv.to_lines())
1098
 
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
 
1088
        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1099
1089
        self.assertEqual(inv.root.file_id, new_inv.path2id(''))
1100
 
        self.assertEqual(b'dirid', new_inv.path2id('dir'))
1101
 
        self.assertEqual(b'fileid', new_inv.path2id('dir/file'))
 
1090
        self.assertEqual('dirid', new_inv.path2id('dir'))
 
1091
        self.assertEqual('fileid', new_inv.path2id('dir/file'))
1102
1092
 
1103
1093
    def test_create_by_apply_delta_sets_root(self):
1104
1094
        inv = Inventory()
1111
1101
        delta = [("", None, base_inv.root.file_id, None),
1112
1102
            (None, "",  "myrootid", inv.root)]
1113
1103
        new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
1114
 
        self.assertEqual(reference_inv.root, new_inv.root)
 
1104
        self.assertEquals(reference_inv.root, new_inv.root)
1115
1105
 
1116
1106
    def test_create_by_apply_delta_empty_add_child(self):
1117
1107
        inv = Inventory()
1172
1162
        inv.revision_id = "revid"
1173
1163
        inv.root.revision = "rootrev"
1174
1164
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
1175
 
        inv.get_entry("fileid").revision = "filerev"
1176
 
        inv.get_entry("fileid").executable = True
1177
 
        inv.get_entry("fileid").text_sha1 = "ffff"
1178
 
        inv.get_entry("fileid").text_size = 1
 
1165
        inv["fileid"].revision = "filerev"
 
1166
        inv["fileid"].executable = True
 
1167
        inv["fileid"].text_sha1 = "ffff"
 
1168
        inv["fileid"].text_size = 1
1179
1169
        inv2 = Inventory()
1180
1170
        inv2.revision_id = "revid2"
1181
1171
        inv2.root.revision = "rootrev"
1182
1172
        inv2.add(InventoryFile("fileid", "file", inv.root.file_id))
1183
 
        inv2.get_entry("fileid").revision = "filerev2"
1184
 
        inv2.get_entry("fileid").executable = False
1185
 
        inv2.get_entry("fileid").text_sha1 = "bbbb"
1186
 
        inv2.get_entry("fileid").text_size = 2
 
1173
        inv2["fileid"].revision = "filerev2"
 
1174
        inv2["fileid"].executable = False
 
1175
        inv2["fileid"].text_sha1 = "bbbb"
 
1176
        inv2["fileid"].text_size = 2
1187
1177
        # get fresh objects.
1188
1178
        chk_bytes = self.get_chk_bytes()
1189
1179
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1202
1192
        inv.revision_id = "revid"
1203
1193
        inv.root.revision = "rootrev"
1204
1194
        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
1205
 
        inv.get_entry("fileid").revision = "filerev"
1206
 
        inv.get_entry("fileid").executable = True
1207
 
        inv.get_entry("fileid").text_sha1 = "ffff"
1208
 
        inv.get_entry("fileid").text_size = 1
 
1195
        inv["fileid"].revision = "filerev"
 
1196
        inv["fileid"].executable = True
 
1197
        inv["fileid"].text_sha1 = "ffff"
 
1198
        inv["fileid"].text_size = 1
1209
1199
        # get fresh objects.
1210
1200
        chk_bytes = self.get_chk_bytes()
1211
1201
        tmp_inv = CHKInventory.from_inventory(chk_bytes, inv)
1218
1208
 
1219
1209
    def test_file_entry_to_bytes(self):
1220
1210
        inv = CHKInventory(None)
1221
 
        ie = inventory.InventoryFile(b'file-id', 'filename', 'parent-id')
 
1211
        ie = inventory.InventoryFile('file-id', 'filename', 'parent-id')
1222
1212
        ie.executable = True
1223
 
        ie.revision = b'file-rev-id'
 
1213
        ie.revision = 'file-rev-id'
1224
1214
        ie.text_sha1 = 'abcdefgh'
1225
1215
        ie.text_size = 100
1226
1216
        bytes = inv._entry_to_bytes(ie)
1227
 
        self.assertEqual(b'file: file-id\nparent-id\nfilename\n'
1228
 
                         b'file-rev-id\nabcdefgh\n100\nY', bytes)
 
1217
        self.assertEqual('file: file-id\nparent-id\nfilename\n'
 
1218
                         'file-rev-id\nabcdefgh\n100\nY', bytes)
1229
1219
        ie2 = inv._bytes_to_entry(bytes)
1230
1220
        self.assertEqual(ie, ie2)
1231
1221
        self.assertIsInstance(ie2.name, unicode)
1232
 
        self.assertEqual(('filename', b'file-id', b'file-rev-id'),
 
1222
        self.assertEqual(('filename', 'file-id', 'file-rev-id'),
1233
1223
                         inv._bytes_to_utf8name_key(bytes))
1234
1224
 
1235
1225
    def test_file2_entry_to_bytes(self):
1236
1226
        inv = CHKInventory(None)
1237
1227
        # \u30a9 == 'omega'
1238
 
        ie = inventory.InventoryFile(b'file-id', u'\u03a9name', b'parent-id')
 
1228
        ie = inventory.InventoryFile('file-id', u'\u03a9name', 'parent-id')
1239
1229
        ie.executable = False
1240
 
        ie.revision = b'file-rev-id'
 
1230
        ie.revision = 'file-rev-id'
1241
1231
        ie.text_sha1 = '123456'
1242
1232
        ie.text_size = 25
1243
1233
        bytes = inv._entry_to_bytes(ie)
1244
 
        self.assertEqual(b'file: file-id\nparent-id\n\xce\xa9name\n'
1245
 
                         b'file-rev-id\n123456\n25\nN', bytes)
 
1234
        self.assertEqual('file: file-id\nparent-id\n\xce\xa9name\n'
 
1235
                         'file-rev-id\n123456\n25\nN', bytes)
1246
1236
        ie2 = inv._bytes_to_entry(bytes)
1247
1237
        self.assertEqual(ie, ie2)
1248
1238
        self.assertIsInstance(ie2.name, unicode)
1249
 
        self.assertEqual((b'\xce\xa9name', b'file-id', b'file-rev-id'),
 
1239
        self.assertEqual(('\xce\xa9name', 'file-id', 'file-rev-id'),
1250
1240
                         inv._bytes_to_utf8name_key(bytes))
1251
1241
 
1252
1242
    def test_dir_entry_to_bytes(self):
1253
1243
        inv = CHKInventory(None)
1254
 
        ie = inventory.InventoryDirectory(b'dir-id', 'dirname', b'parent-id')
1255
 
        ie.revision = b'dir-rev-id'
 
1244
        ie = inventory.InventoryDirectory('dir-id', 'dirname', 'parent-id')
 
1245
        ie.revision = 'dir-rev-id'
1256
1246
        bytes = inv._entry_to_bytes(ie)
1257
 
        self.assertEqual(b'dir: dir-id\nparent-id\ndirname\ndir-rev-id', bytes)
 
1247
        self.assertEqual('dir: dir-id\nparent-id\ndirname\ndir-rev-id', bytes)
1258
1248
        ie2 = inv._bytes_to_entry(bytes)
1259
1249
        self.assertEqual(ie, ie2)
1260
1250
        self.assertIsInstance(ie2.name, unicode)
1261
 
        self.assertEqual(('dirname', b'dir-id', b'dir-rev-id'),
 
1251
        self.assertEqual(('dirname', 'dir-id', 'dir-rev-id'),
1262
1252
                         inv._bytes_to_utf8name_key(bytes))
1263
1253
 
1264
1254
    def test_dir2_entry_to_bytes(self):
1265
1255
        inv = CHKInventory(None)
1266
 
        ie = inventory.InventoryDirectory(b'dir-id', u'dir\u03a9name',
 
1256
        ie = inventory.InventoryDirectory('dir-id', u'dir\u03a9name',
1267
1257
                                          None)
1268
 
        ie.revision = b'dir-rev-id'
 
1258
        ie.revision = 'dir-rev-id'
1269
1259
        bytes = inv._entry_to_bytes(ie)
1270
 
        self.assertEqual(b'dir: dir-id\n\ndir\xce\xa9name\n'
1271
 
                         b'dir-rev-id', bytes)
 
1260
        self.assertEqual('dir: dir-id\n\ndir\xce\xa9name\n'
 
1261
                         'dir-rev-id', bytes)
1272
1262
        ie2 = inv._bytes_to_entry(bytes)
1273
1263
        self.assertEqual(ie, ie2)
1274
1264
        self.assertIsInstance(ie2.name, unicode)
1275
1265
        self.assertIs(ie2.parent_id, None)
1276
 
        self.assertEqual(('dir\xce\xa9name', b'dir-id', b'dir-rev-id'),
 
1266
        self.assertEqual(('dir\xce\xa9name', 'dir-id', 'dir-rev-id'),
1277
1267
                         inv._bytes_to_utf8name_key(bytes))
1278
1268
 
1279
1269
    def test_symlink_entry_to_bytes(self):
1311
1301
        ie = inventory.TreeReference('tree-root-id', u'tree\u03a9name',
1312
1302
                                     'parent-id')
1313
1303
        ie.revision = 'tree-rev-id'
1314
 
        ie.reference_revision = b'ref-rev-id'
 
1304
        ie.reference_revision = 'ref-rev-id'
1315
1305
        bytes = inv._entry_to_bytes(ie)
1316
1306
        self.assertEqual('tree: tree-root-id\nparent-id\ntree\xce\xa9name\n'
1317
1307
                         'tree-rev-id\nref-rev-id', bytes)
1327
1317
        inv.root.revision = "rootrev"
1328
1318
        root_id = inv.root.file_id
1329
1319
        inv.add(InventoryFile("fileid", u'f\xefle', root_id))
1330
 
        inv.get_entry("fileid").revision = "filerev"
1331
 
        inv.get_entry("fileid").text_sha1 = "ffff"
1332
 
        inv.get_entry("fileid").text_size = 0
 
1320
        inv["fileid"].revision = "filerev"
 
1321
        inv["fileid"].text_sha1 = "ffff"
 
1322
        inv["fileid"].text_size = 0
1333
1323
        inv.add(InventoryDirectory("dirid", u'dir-\N{EURO SIGN}', root_id))
1334
1324
        inv.add(InventoryFile("childid", u'ch\xefld', "dirid"))
1335
 
        inv.get_entry("childid").revision = "filerev"
1336
 
        inv.get_entry("childid").text_sha1 = "ffff"
1337
 
        inv.get_entry("childid").text_size = 0
 
1325
        inv["childid"].revision = "filerev"
 
1326
        inv["childid"].text_sha1 = "ffff"
 
1327
        inv["childid"].text_size = 0
1338
1328
        chk_bytes = self.get_chk_bytes()
1339
1329
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1340
1330
        bytes = ''.join(chk_inv.to_lines())
1360
1350
        inv.root.revision = "rootrev"
1361
1351
        root_id = inv.root.file_id
1362
1352
        inv.add(InventoryFile("fileid", "file", root_id))
1363
 
        inv.get_entry("fileid").revision = "filerev"
1364
 
        inv.get_entry("fileid").executable = True
1365
 
        inv.get_entry("fileid").text_sha1 = "ffff"
1366
 
        inv.get_entry("fileid").text_size = 1
 
1353
        inv["fileid"].revision = "filerev"
 
1354
        inv["fileid"].executable = True
 
1355
        inv["fileid"].text_sha1 = "ffff"
 
1356
        inv["fileid"].text_size = 1
1367
1357
        inv.add(InventoryDirectory("dirid", "dir", root_id))
1368
1358
        inv.add(InventoryFile("childid", "child", "dirid"))
1369
 
        inv.get_entry("childid").revision = "filerev"
1370
 
        inv.get_entry("childid").executable = False
1371
 
        inv.get_entry("childid").text_sha1 = "dddd"
1372
 
        inv.get_entry("childid").text_size = 1
 
1359
        inv["childid"].revision = "filerev"
 
1360
        inv["childid"].executable = False
 
1361
        inv["childid"].text_sha1 = "dddd"
 
1362
        inv["childid"].text_size = 1
1373
1363
        chk_bytes = self.get_chk_bytes()
1374
1364
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
1375
1365
        bytes = ''.join(chk_inv.to_lines())
1388
1378
 
1389
1379
    def test__preload_handles_partially_evaluated_inventory(self):
1390
1380
        new_inv = self.make_basic_utf8_inventory()
1391
 
        ie = new_inv.get_entry(new_inv.root_id)
 
1381
        ie = new_inv[new_inv.root_id]
1392
1382
        self.assertIs(None, ie._children)
1393
1383
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1394
1384
                         sorted(ie.children.keys()))
1399
1389
        # No change
1400
1390
        self.assertEqual([u'dir-\N{EURO SIGN}', u'f\xefle'],
1401
1391
                         sorted(ie._children.keys()))
1402
 
        ie_dir = new_inv.get_entry("dirid")
 
1392
        ie_dir = new_inv["dirid"]
1403
1393
        self.assertEqual([u'ch\xefld'],
1404
1394
                         sorted(ie_dir._children.keys()))
1405
1395
 
1432
1422
        return factory(trans)
1433
1423
 
1434
1424
    def make_dir(self, inv, name, parent_id):
1435
 
        inv.add(inv.make_entry('directory', name, parent_id, name.encode('utf-8') + b'-id'))
 
1425
        inv.add(inv.make_entry('directory', name, parent_id, name + '-id'))
1436
1426
 
1437
1427
    def make_file(self, inv, name, parent_id, content='content\n'):
1438
1428
        ie = inv.make_entry('file', name, parent_id, name + '-id')
1483
1473
            s = expected_children.setdefault(entry.parent_id, [])
1484
1474
            s.append(entry.file_id)
1485
1475
        val_children = dict((k, sorted(v)) for k, v
1486
 
                            in val_children.items())
 
1476
                            in val_children.iteritems())
1487
1477
        expected_children = dict((k, sorted(v)) for k, v
1488
 
                            in expected_children.items())
 
1478
                            in expected_children.iteritems())
1489
1479
        self.assertEqual(expected_children, val_children)
1490
1480
 
1491
1481
    def test_make_simple_inventory(self):
1562
1552
        repository = self.make_repository('.')
1563
1553
        tree = repository.revision_tree(revision.NULL_REVISION)
1564
1554
        inv = mutable_inventory_from_tree(tree)
1565
 
        self.assertEqual(revision.NULL_REVISION, inv.revision_id)
1566
 
        self.assertEqual(0, len(inv))
 
1555
        self.assertEquals(revision.NULL_REVISION, inv.revision_id)
 
1556
        self.assertEquals(0, len(inv))
1567
1557
 
1568
1558
    def test_some_files(self):
1569
1559
        wt = self.make_branch_and_tree('.')
1572
1562
        revid = wt.commit("commit")
1573
1563
        tree = wt.branch.repository.revision_tree(revid)
1574
1564
        inv = mutable_inventory_from_tree(tree)
1575
 
        self.assertEqual(revid, inv.revision_id)
1576
 
        self.assertEqual(2, len(inv))
1577
 
        self.assertEqual("a", inv.get_entry('thefileid').name)
 
1565
        self.assertEquals(revid, inv.revision_id)
 
1566
        self.assertEquals(2, len(inv))
 
1567
        self.assertEquals("a", inv['thefileid'].name)
1578
1568
        # The inventory should be mutable and independent of
1579
1569
        # the original tree
1580
 
        self.assertFalse(tree.root_inventory.get_entry('thefileid').executable)
1581
 
        inv.get_entry('thefileid').executable = True
1582
 
        self.assertFalse(tree.root_inventory.get_entry('thefileid').executable)
 
1570
        self.assertFalse(tree.root_inventory['thefileid'].executable)
 
1571
        inv['thefileid'].executable = True
 
1572
        self.assertFalse(tree.root_inventory['thefileid'].executable)