← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_inv.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-09-25 22:33:36 UTC
  • mfrom: (4715.1.1 jam-integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090925223336-1thhoyfhq5hpr6bh
(jam) Merge the 2.0 stable series to bzr.dev,
        including 2.0.0 and CHKInventory.filter()

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_inv.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 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,
20
21
    bzrdir,
21
22
    errors,
22
23
    inventory,
23
24
    osutils,
24
25
    repository,
25
26
    revision,
 
27
    tests,
26
28
    )
27
29
from bzrlib.inventory import (CHKInventory, Inventory, ROOT_ID, InventoryFile,
28
30
    InventoryDirectory, InventoryEntry, TreeReference)
257
259
    return repo.get_inventory('result')
258
260
 
259
261
 
 
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
 
260
332
class TestDeltaApplication(TestCaseWithTransport):
261
333
 
262
334
    def get_empty_inventory(self, reference_inv=None):
503
575
            inv, delta)
504
576
 
505
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
 
506
594
class TestInventoryEntry(TestCase):
507
595
 
508
596
    def test_file_kind_character(self):
650
738
        self.assertEqual(expected_change, change)
651
739
 
652
740
 
653
 
class TestCHKInventory(TestCaseWithTransport):
 
741
class TestCHKInventory(tests.TestCaseWithMemoryTransport):
654
742
 
655
743
    def get_chk_bytes(self):
656
 
        # The easiest way to get a CHK store is a development6 repository and
657
 
        # then work with the chk_bytes attribute directly.
658
 
        repo = self.make_repository(".", format="development6-rich-root")
659
 
        repo.lock_write()
660
 
        self.addCleanup(repo.unlock)
661
 
        repo.start_write_group()
662
 
        self.addCleanup(repo.abort_write_group)
663
 
        return repo.chk_bytes
 
744
        factory = groupcompress.make_pack_factory(True, True, 1)
 
745
        trans = self.get_transport('')
 
746
        return factory(trans)
664
747
 
665
748
    def read_bytes(self, chk_bytes, key):
666
749
        stream = chk_bytes.get_record_stream([key], 'unordered', True)
1131
1214
        self.assertIsInstance(ie2.name, unicode)
1132
1215
        self.assertEqual(('tree\xce\xa9name', 'tree-root-id', 'tree-rev-id'),
1133
1216
                         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'])