/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: Robert Collins
  • Date: 2009-07-16 01:36:57 UTC
  • mto: This revision was merged to the branch mainline in revision 4543.
  • Revision ID: robertc@robertcollins.net-20090716013657-6f1046zvotn9shm3
https://launchpad.net/bugs/216541
Change cmd_mv not to take out branch locks. (Robert Collins, bug 216541)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_inv.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
17
17
 
18
18
from bzrlib import (
19
19
    chk_map,
20
 
    groupcompress,
21
20
    bzrdir,
22
21
    errors,
23
22
    inventory,
24
23
    osutils,
25
24
    repository,
26
25
    revision,
27
 
    tests,
28
26
    )
29
27
from bzrlib.inventory import (CHKInventory, Inventory, ROOT_ID, InventoryFile,
30
28
    InventoryDirectory, InventoryEntry, TreeReference)
56
54
            'apply_delta':apply_inventory_Repository_add_inventory_by_delta,
57
55
            'format':format}))
58
56
    for format in workingtree_formats():
59
 
        scenarios.append(
60
 
            (str(format.__class__.__name__) + ".update_basis_by_delta", {
 
57
        scenarios.append((str(format.__class__.__name__), {
61
58
            'apply_delta':apply_inventory_WT_basis,
62
59
            'format':format}))
63
 
        scenarios.append(
64
 
            (str(format.__class__.__name__) + ".apply_inventory_delta", {
65
 
            'apply_delta':apply_inventory_WT,
66
 
            'format':format}))
67
60
    return multiply_tests(to_adapt, scenarios, result)
68
61
 
69
62
 
70
 
def create_texts_for_inv(repo, inv):
71
 
    for path, ie in inv.iter_entries():
72
 
        if ie.text_size:
73
 
            lines = ['a' * ie.text_size]
74
 
        else:
75
 
            lines = []
76
 
        repo.texts.add_lines((ie.file_id, ie.revision), [], lines)
77
 
    
78
63
def apply_inventory_Inventory(self, basis, delta):
79
64
    """Apply delta to basis and return the result.
80
65
    
86
71
    return basis
87
72
 
88
73
 
89
 
def apply_inventory_WT(self, basis, delta):
90
 
    """Apply delta to basis and return the result.
91
 
 
92
 
    This sets the tree state to be basis, and then calls apply_inventory_delta.
93
 
    
94
 
    :param basis: An inventory to be used as the basis.
95
 
    :param delta: The inventory delta to apply:
96
 
    :return: An inventory resulting from the application.
97
 
    """
98
 
    control = self.make_bzrdir('tree', format=self.format._matchingbzrdir)
99
 
    control.create_repository()
100
 
    control.create_branch()
101
 
    tree = self.format.initialize(control)
102
 
    tree.lock_write()
103
 
    try:
104
 
        tree._write_inventory(basis)
105
 
    finally:
106
 
        tree.unlock()
107
 
    # Fresh object, reads disk again.
108
 
    tree = tree.bzrdir.open_workingtree()
109
 
    tree.lock_write()
110
 
    try:
111
 
        tree.apply_inventory_delta(delta)
112
 
    finally:
113
 
        tree.unlock()
114
 
    # reload tree - ensure we get what was written.
115
 
    tree = tree.bzrdir.open_workingtree()
116
 
    tree.lock_read()
117
 
    self.addCleanup(tree.unlock)
118
 
    # One could add 'tree._validate' here but that would cause 'early' failues 
119
 
    # as far as higher level code is concerned. Possibly adding an
120
 
    # expect_fail parameter to this function and if that is False then do a
121
 
    # validate call.
122
 
    return tree.inventory
123
 
 
124
 
 
125
74
def apply_inventory_WT_basis(self, basis, delta):
126
75
    """Apply delta to basis and return the result.
127
76
 
147
96
            rev = revision.Revision('basis', timestamp=0, timezone=None,
148
97
                message="", committer="foo@example.com")
149
98
            basis.revision_id = 'basis'
150
 
            create_texts_for_inv(tree.branch.repository, basis)
151
99
            repo.add_revision('basis', rev, basis)
152
100
            # Add a revision for the result, with the basis content - 
153
101
            # update_basis_by_delta doesn't check that the delta results in
157
105
                message="", committer="foo@example.com")
158
106
            basis.revision_id = 'result'
159
107
            repo.add_revision('result', rev, basis)
160
 
            repo.commit_write_group()
161
108
        except:
162
109
            repo.abort_write_group()
163
110
            raise
 
111
        else:
 
112
            repo.commit_write_group()
164
113
        # Set the basis state as the trees current state
165
114
        tree._write_inventory(basis)
166
115
        # This reads basis from the repo and puts it into the tree's local
169
118
        paths = {}
170
119
        parents = set()
171
120
        for old, new, id, entry in delta:
172
 
            if None in (new, entry):
 
121
            if entry is None:
173
122
                continue
174
123
            paths[new] = (entry.file_id, entry.kind)
175
124
            parents.add(osutils.dirname(new))
231
180
            rev = revision.Revision('basis', timestamp=0, timezone=None,
232
181
                message="", committer="foo@example.com")
233
182
            basis.revision_id = 'basis'
234
 
            create_texts_for_inv(repo, basis)
235
183
            repo.add_revision('basis', rev, basis)
236
 
            repo.commit_write_group()
237
184
        except:
238
185
            repo.abort_write_group()
239
186
            raise
 
187
        else:
 
188
            repo.commit_write_group()
240
189
    finally:
241
190
        repo.unlock()
242
191
    repo.lock_write()
259
208
    return repo.get_inventory('result')
260
209
 
261
210
 
262
 
class TestInventoryUpdates(TestCase):
263
 
 
264
 
    def test_creation_from_root_id(self):
265
 
        # iff a root id is passed to the constructor, a root directory is made
266
 
        inv = inventory.Inventory(root_id='tree-root')
267
 
        self.assertNotEqual(None, inv.root)
268
 
        self.assertEqual('tree-root', inv.root.file_id)
269
 
 
270
 
    def test_add_path_of_root(self):
271
 
        # if no root id is given at creation time, there is no root directory
272
 
        inv = inventory.Inventory(root_id=None)
273
 
        self.assertIs(None, inv.root)
274
 
        # add a root entry by adding its path
275
 
        ie = inv.add_path("", "directory", "my-root")
276
 
        ie.revision = 'test-rev'
277
 
        self.assertEqual("my-root", ie.file_id)
278
 
        self.assertIs(ie, inv.root)
279
 
 
280
 
    def test_add_path(self):
281
 
        inv = inventory.Inventory(root_id='tree_root')
282
 
        ie = inv.add_path('hello', 'file', 'hello-id')
283
 
        self.assertEqual('hello-id', ie.file_id)
284
 
        self.assertEqual('file', ie.kind)
285
 
 
286
 
    def test_copy(self):
287
 
        """Make sure copy() works and creates a deep copy."""
288
 
        inv = inventory.Inventory(root_id='some-tree-root')
289
 
        ie = inv.add_path('hello', 'file', 'hello-id')
290
 
        inv2 = inv.copy()
291
 
        inv.root.file_id = 'some-new-root'
292
 
        ie.name = 'file2'
293
 
        self.assertEqual('some-tree-root', inv2.root.file_id)
294
 
        self.assertEqual('hello', inv2['hello-id'].name)
295
 
 
296
 
    def test_copy_empty(self):
297
 
        """Make sure an empty inventory can be copied."""
298
 
        inv = inventory.Inventory(root_id=None)
299
 
        inv2 = inv.copy()
300
 
        self.assertIs(None, inv2.root)
301
 
 
302
 
    def test_copy_copies_root_revision(self):
303
 
        """Make sure the revision of the root gets copied."""
304
 
        inv = inventory.Inventory(root_id='someroot')
305
 
        inv.root.revision = 'therev'
306
 
        inv2 = inv.copy()
307
 
        self.assertEquals('someroot', inv2.root.file_id)
308
 
        self.assertEquals('therev', inv2.root.revision)
309
 
 
310
 
    def test_create_tree_reference(self):
311
 
        inv = inventory.Inventory('tree-root-123')
312
 
        inv.add(TreeReference('nested-id', 'nested', parent_id='tree-root-123',
313
 
                              revision='rev', reference_revision='rev2'))
314
 
 
315
 
    def test_error_encoding(self):
316
 
        inv = inventory.Inventory('tree-root')
317
 
        inv.add(InventoryFile('a-id', u'\u1234', 'tree-root'))
318
 
        e = self.assertRaises(errors.InconsistentDelta, inv.add,
319
 
            InventoryFile('b-id', u'\u1234', 'tree-root'))
320
 
        self.assertContainsRe(str(e), r'\\u1234')
321
 
 
322
 
    def test_add_recursive(self):
323
 
        parent = InventoryDirectory('src-id', 'src', 'tree-root')
324
 
        child = InventoryFile('hello-id', 'hello.c', 'src-id')
325
 
        parent.children[child.file_id] = child
326
 
        inv = inventory.Inventory('tree-root')
327
 
        inv.add(parent)
328
 
        self.assertEqual('src/hello.c', inv.id2path('hello-id'))
329
 
 
330
 
 
331
 
 
332
211
class TestDeltaApplication(TestCaseWithTransport):
333
212
 
334
213
    def get_empty_inventory(self, reference_inv=None):
357
236
        inv2 = self.get_empty_inventory(inv)
358
237
        self.assertEqual([], inv2._make_delta(inv))
359
238
 
360
 
    def test_None_file_id(self):
361
 
        inv = self.get_empty_inventory()
362
 
        dir1 = inventory.InventoryDirectory(None, 'dir1', inv.root.file_id)
363
 
        dir1.revision = 'result'
364
 
        delta = [(None, u'dir1', None, dir1)]
365
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
366
 
            inv, delta)
367
 
 
368
 
    def test_unicode_file_id(self):
369
 
        inv = self.get_empty_inventory()
370
 
        dir1 = inventory.InventoryDirectory(u'dirid', 'dir1', inv.root.file_id)
371
 
        dir1.revision = 'result'
372
 
        delta = [(None, u'dir1', dir1.file_id, dir1)]
373
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
374
 
            inv, delta)
375
 
 
376
239
    def test_repeated_file_id(self):
377
240
        inv = self.get_empty_inventory()
378
241
        file1 = inventory.InventoryFile('id', 'path1', inv.root.file_id)
433
296
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
434
297
            inv, delta)
435
298
 
436
 
    def test_mismatched_new_path_entry_None(self):
437
 
        inv = self.get_empty_inventory()
438
 
        delta = [(None, u'path', 'id', None)]
439
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
440
 
            inv, delta)
441
 
 
442
 
    def test_mismatched_new_path_None_entry(self):
443
 
        inv = self.get_empty_inventory()
444
 
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
445
 
        file1.revision = 'result'
446
 
        file1.text_size = 0
447
 
        file1.text_sha1 = ""
448
 
        delta = [(u"path", None, 'id1', file1)]
449
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
450
 
            inv, delta)
451
 
 
452
299
    def test_parent_is_not_directory(self):
453
300
        inv = self.get_empty_inventory()
454
301
        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
474
321
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
475
322
            inv, delta)
476
323
 
477
 
    def test_new_parent_path_has_wrong_id(self):
478
 
        inv = self.get_empty_inventory()
479
 
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
480
 
        parent1.revision = 'result'
481
 
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
482
 
        parent2.revision = 'result'
483
 
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
484
 
        file1.revision = 'result'
485
 
        file1.text_size = 0
486
 
        file1.text_sha1 = ""
487
 
        inv.add(parent1)
488
 
        inv.add(parent2)
489
 
        # This delta claims that file1 is at dir/path, but actually its at
490
 
        # dir2/path if you follow the inventory parent structure.
491
 
        delta = [(None, u'dir/path', 'id', file1)]
492
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
493
 
            inv, delta)
494
 
 
495
 
    def test_old_parent_path_is_wrong(self):
496
 
        inv = self.get_empty_inventory()
497
 
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
498
 
        parent1.revision = 'result'
499
 
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
500
 
        parent2.revision = 'result'
501
 
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
502
 
        file1.revision = 'result'
503
 
        file1.text_size = 0
504
 
        file1.text_sha1 = ""
505
 
        inv.add(parent1)
506
 
        inv.add(parent2)
507
 
        inv.add(file1)
508
 
        # This delta claims that file1 was at dir/path, but actually it was at
509
 
        # dir2/path if you follow the inventory parent structure.
510
 
        delta = [(u'dir/path', None, 'id', None)]
511
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
512
 
            inv, delta)
513
 
 
514
 
    def test_old_parent_path_is_for_other_id(self):
515
 
        inv = self.get_empty_inventory()
516
 
        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
517
 
        parent1.revision = 'result'
518
 
        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
519
 
        parent2.revision = 'result'
520
 
        file1 = inventory.InventoryFile('id', 'path', 'p-2')
521
 
        file1.revision = 'result'
522
 
        file1.text_size = 0
523
 
        file1.text_sha1 = ""
524
 
        file2 = inventory.InventoryFile('id2', 'path', 'p-1')
525
 
        file2.revision = 'result'
526
 
        file2.text_size = 0
527
 
        file2.text_sha1 = ""
528
 
        inv.add(parent1)
529
 
        inv.add(parent2)
530
 
        inv.add(file1)
531
 
        inv.add(file2)
532
 
        # This delta claims that file1 was at dir/path, but actually it was at
533
 
        # dir2/path if you follow the inventory parent structure. At dir/path
534
 
        # is another entry we should not delete.
535
 
        delta = [(u'dir/path', None, 'id', None)]
536
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
537
 
            inv, delta)
538
 
 
539
 
    def test_add_existing_id_new_path(self):
540
 
        inv = self.get_empty_inventory()
541
 
        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
542
 
        parent1.revision = 'result'
543
 
        parent2 = inventory.InventoryDirectory('p-1', 'dir2', inv.root.file_id)
544
 
        parent2.revision = 'result'
545
 
        inv.add(parent1)
546
 
        delta = [(None, u'dir2', 'p-1', parent2)]
547
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
548
 
            inv, delta)
549
 
 
550
 
    def test_add_new_id_existing_path(self):
551
 
        inv = self.get_empty_inventory()
552
 
        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
553
 
        parent1.revision = 'result'
554
 
        parent2 = inventory.InventoryDirectory('p-2', 'dir1', inv.root.file_id)
555
 
        parent2.revision = 'result'
556
 
        inv.add(parent1)
557
 
        delta = [(None, u'dir1', 'p-2', parent2)]
558
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
559
 
            inv, delta)
560
 
 
561
 
    def test_remove_dir_leaving_dangling_child(self):
562
 
        inv = self.get_empty_inventory()
563
 
        dir1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
564
 
        dir1.revision = 'result'
565
 
        dir2 = inventory.InventoryDirectory('p-2', 'child1', 'p-1')
566
 
        dir2.revision = 'result'
567
 
        dir3 = inventory.InventoryDirectory('p-3', 'child2', 'p-1')
568
 
        dir3.revision = 'result'
569
 
        inv.add(dir1)
570
 
        inv.add(dir2)
571
 
        inv.add(dir3)
572
 
        delta = [(u'dir1', None, 'p-1', None),
573
 
            (u'dir1/child2', None, 'p-3', None)]
574
 
        self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
575
 
            inv, delta)
576
 
 
577
 
 
578
 
class TestInventory(TestCase):
579
 
 
580
 
    def test_is_root(self):
581
 
        """Ensure our root-checking code is accurate."""
582
 
        inv = inventory.Inventory('TREE_ROOT')
583
 
        self.assertTrue(inv.is_root('TREE_ROOT'))
584
 
        self.assertFalse(inv.is_root('booga'))
585
 
        inv.root.file_id = 'booga'
586
 
        self.assertFalse(inv.is_root('TREE_ROOT'))
587
 
        self.assertTrue(inv.is_root('booga'))
588
 
        # works properly even if no root is set
589
 
        inv.root = None
590
 
        self.assertFalse(inv.is_root('TREE_ROOT'))
591
 
        self.assertFalse(inv.is_root('booga'))
592
 
 
593
324
 
594
325
class TestInventoryEntry(TestCase):
595
326
 
738
469
        self.assertEqual(expected_change, change)
739
470
 
740
471
 
741
 
class TestCHKInventory(tests.TestCaseWithMemoryTransport):
 
472
class TestCHKInventory(TestCaseWithTransport):
742
473
 
743
474
    def get_chk_bytes(self):
744
 
        factory = groupcompress.make_pack_factory(True, True, 1)
745
 
        trans = self.get_transport('')
746
 
        return factory(trans)
 
475
        # The easiest way to get a CHK store is a development6 repository and
 
476
        # then work with the chk_bytes attribute directly.
 
477
        repo = self.make_repository(".", format="development6-rich-root")
 
478
        repo.lock_write()
 
479
        self.addCleanup(repo.unlock)
 
480
        repo.start_write_group()
 
481
        self.addCleanup(repo.abort_write_group)
 
482
        return repo.chk_bytes
747
483
 
748
484
    def read_bytes(self, chk_bytes, key):
749
485
        stream = chk_bytes.get_record_stream([key], 'unordered', True)
1002
738
        inv.add_path("", "directory", "myrootid", None)
1003
739
        inv.revision_id = "expectedid"
1004
740
        reference_inv = CHKInventory.from_inventory(chk_bytes, inv)
1005
 
        delta = [("", None, base_inv.root.file_id, None),
1006
 
            (None, "",  "myrootid", inv.root)]
 
741
        delta = [(None, "",  "myrootid", inv.root)]
1007
742
        new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
1008
743
        self.assertEquals(reference_inv.root, new_inv.root)
1009
744
 
1214
949
        self.assertIsInstance(ie2.name, unicode)
1215
950
        self.assertEqual(('tree\xce\xa9name', 'tree-root-id', 'tree-rev-id'),
1216
951
                         inv._bytes_to_utf8name_key(bytes))
1217
 
 
1218
 
 
1219
 
class TestCHKInventoryExpand(tests.TestCaseWithMemoryTransport):
1220
 
 
1221
 
    def get_chk_bytes(self):
1222
 
        factory = groupcompress.make_pack_factory(True, True, 1)
1223
 
        trans = self.get_transport('')
1224
 
        return factory(trans)
1225
 
 
1226
 
    def make_dir(self, inv, name, parent_id):
1227
 
        inv.add(inv.make_entry('directory', name, parent_id, name + '-id'))
1228
 
 
1229
 
    def make_file(self, inv, name, parent_id, content='content\n'):
1230
 
        ie = inv.make_entry('file', name, parent_id, name + '-id')
1231
 
        ie.text_sha1 = osutils.sha_string(content)
1232
 
        ie.text_size = len(content)
1233
 
        inv.add(ie)
1234
 
 
1235
 
    def make_simple_inventory(self):
1236
 
        inv = Inventory('TREE_ROOT')
1237
 
        inv.revision_id = "revid"
1238
 
        inv.root.revision = "rootrev"
1239
 
        # /                 TREE_ROOT
1240
 
        # dir1/             dir1-id
1241
 
        #   sub-file1       sub-file1-id
1242
 
        #   sub-file2       sub-file2-id
1243
 
        #   sub-dir1/       sub-dir1-id
1244
 
        #     subsub-file1  subsub-file1-id
1245
 
        # dir2/             dir2-id
1246
 
        #   sub2-file1      sub2-file1-id
1247
 
        # top               top-id
1248
 
        self.make_dir(inv, 'dir1', 'TREE_ROOT')
1249
 
        self.make_dir(inv, 'dir2', 'TREE_ROOT')
1250
 
        self.make_dir(inv, 'sub-dir1', 'dir1-id')
1251
 
        self.make_file(inv, 'top', 'TREE_ROOT')
1252
 
        self.make_file(inv, 'sub-file1', 'dir1-id')
1253
 
        self.make_file(inv, 'sub-file2', 'dir1-id')
1254
 
        self.make_file(inv, 'subsub-file1', 'sub-dir1-id')
1255
 
        self.make_file(inv, 'sub2-file1', 'dir2-id')
1256
 
        chk_bytes = self.get_chk_bytes()
1257
 
        #  use a small maximum_size to force internal paging structures
1258
 
        chk_inv = CHKInventory.from_inventory(chk_bytes, inv,
1259
 
                        maximum_size=100,
1260
 
                        search_key_name='hash-255-way')
1261
 
        bytes = ''.join(chk_inv.to_lines())
1262
 
        return CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
1263
 
 
1264
 
    def assert_Getitems(self, expected_fileids, inv, file_ids):
1265
 
        self.assertEqual(sorted(expected_fileids),
1266
 
                         sorted([ie.file_id for ie in inv._getitems(file_ids)]))
1267
 
 
1268
 
    def assertExpand(self, all_ids, inv, file_ids):
1269
 
        (val_all_ids,
1270
 
         val_children) = inv._expand_fileids_to_parents_and_children(file_ids)
1271
 
        self.assertEqual(set(all_ids), val_all_ids)
1272
 
        entries = inv._getitems(val_all_ids)
1273
 
        expected_children = {}
1274
 
        for entry in entries:
1275
 
            s = expected_children.setdefault(entry.parent_id, [])
1276
 
            s.append(entry.file_id)
1277
 
        val_children = dict((k, sorted(v)) for k, v
1278
 
                            in val_children.iteritems())
1279
 
        expected_children = dict((k, sorted(v)) for k, v
1280
 
                            in expected_children.iteritems())
1281
 
        self.assertEqual(expected_children, val_children)
1282
 
 
1283
 
    def test_make_simple_inventory(self):
1284
 
        inv = self.make_simple_inventory()
1285
 
        layout = []
1286
 
        for path, entry in inv.iter_entries_by_dir():
1287
 
            layout.append((path, entry.file_id))
1288
 
        self.assertEqual([
1289
 
            ('', 'TREE_ROOT'),
1290
 
            ('dir1', 'dir1-id'),
1291
 
            ('dir2', 'dir2-id'),
1292
 
            ('top', 'top-id'),
1293
 
            ('dir1/sub-dir1', 'sub-dir1-id'),
1294
 
            ('dir1/sub-file1', 'sub-file1-id'),
1295
 
            ('dir1/sub-file2', 'sub-file2-id'),
1296
 
            ('dir1/sub-dir1/subsub-file1', 'subsub-file1-id'),
1297
 
            ('dir2/sub2-file1', 'sub2-file1-id'),
1298
 
            ], layout)
1299
 
 
1300
 
    def test__getitems(self):
1301
 
        inv = self.make_simple_inventory()
1302
 
        # Reading from disk
1303
 
        self.assert_Getitems(['dir1-id'], inv, ['dir1-id'])
1304
 
        self.assertTrue('dir1-id' in inv._fileid_to_entry_cache)
1305
 
        self.assertFalse('sub-file2-id' in inv._fileid_to_entry_cache)
1306
 
        # From cache
1307
 
        self.assert_Getitems(['dir1-id'], inv, ['dir1-id'])
1308
 
        # Mixed
1309
 
        self.assert_Getitems(['dir1-id', 'sub-file2-id'], inv,
1310
 
                             ['dir1-id', 'sub-file2-id'])
1311
 
        self.assertTrue('dir1-id' in inv._fileid_to_entry_cache)
1312
 
        self.assertTrue('sub-file2-id' in inv._fileid_to_entry_cache)
1313
 
 
1314
 
    def test_single_file(self):
1315
 
        inv = self.make_simple_inventory()
1316
 
        self.assertExpand(['TREE_ROOT', 'top-id'], inv, ['top-id'])
1317
 
 
1318
 
    def test_get_all_parents(self):
1319
 
        inv = self.make_simple_inventory()
1320
 
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id',
1321
 
                           'subsub-file1-id',
1322
 
                          ], inv, ['subsub-file1-id'])
1323
 
 
1324
 
    def test_get_children(self):
1325
 
        inv = self.make_simple_inventory()
1326
 
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id',
1327
 
                           'sub-file1-id', 'sub-file2-id', 'subsub-file1-id',
1328
 
                          ], inv, ['dir1-id'])
1329
 
 
1330
 
    def test_from_root(self):
1331
 
        inv = self.make_simple_inventory()
1332
 
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'dir2-id', 'sub-dir1-id',
1333
 
                           'sub-file1-id', 'sub-file2-id', 'sub2-file1-id',
1334
 
                           'subsub-file1-id', 'top-id'], inv, ['TREE_ROOT'])
1335
 
 
1336
 
    def test_top_level_file(self):
1337
 
        inv = self.make_simple_inventory()
1338
 
        self.assertExpand(['TREE_ROOT', 'top-id'], inv, ['top-id'])
1339
 
 
1340
 
    def test_subsub_file(self):
1341
 
        inv = self.make_simple_inventory()
1342
 
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id',
1343
 
                           'subsub-file1-id'], inv, ['subsub-file1-id'])
1344
 
 
1345
 
    def test_sub_and_root(self):
1346
 
        inv = self.make_simple_inventory()
1347
 
        self.assertExpand(['TREE_ROOT', 'dir1-id', 'sub-dir1-id', 'top-id',
1348
 
                           'subsub-file1-id'], inv, ['top-id', 'subsub-file1-id'])