/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_index.py

  • Committer: John Arbash Meinel
  • Date: 2008-10-08 21:56:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3773.
  • Revision ID: john@arbash-meinel.com-20081008215612-y9v94tqxreqoangx
Simplify the --raw mode.

I didn't realize, but the only node that is special cased is the 'root' node,
and to read it, you actually have to parse it directly, because the
compressed bytes start immediately after the end of the header, rather than
having any padding before the zlib bytes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_index.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
 
1
# Copyright (C) 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for indices."""
18
18
 
173
173
            "key\x00\x00\t\x00data\n"
174
174
            "\n", contents)
175
175
 
176
 
    def test_clear_cache(self):
177
 
        builder = GraphIndexBuilder(reference_lists=2)
178
 
        # This is a no-op, but the api should exist
179
 
        builder.clear_cache()
180
 
 
181
176
    def test_node_references_are_byte_offsets(self):
182
177
        builder = GraphIndexBuilder(reference_lists=1)
183
178
        builder.add_node(('reference', ), 'data', ([], ))
235
230
        builder.add_node(('2-key', ), '', (references, ))
236
231
        stream = builder.finish()
237
232
        contents = stream.read()
238
 
        self.assertEqualDiff(
 
233
        self.assertEqual(
239
234
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
240
235
            "0\x00a\x00\x00\n"
241
236
            "1\x00a\x00\x00\n"
355
350
        builder.add_node(('k', 'ey'), 'data', ([('reference', 'tokey')], ))
356
351
        builder.add_node(('reference', 'tokey'), 'data', ([],))
357
352
 
358
 
    def test_set_optimize(self):
359
 
        builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
360
 
        builder.set_optimize(for_size=True)
361
 
        self.assertTrue(builder._optimize_for_size)
362
 
        builder.set_optimize(for_size=False)
363
 
        self.assertFalse(builder._optimize_for_size)
364
 
 
365
353
 
366
354
class TestGraphIndex(TestCaseWithMemoryTransport):
367
355
 
388
376
        size = trans.put_file('index', stream)
389
377
        return GraphIndex(trans, 'index', size)
390
378
 
391
 
    def make_index_with_offset(self, ref_lists=0, key_elements=1, nodes=[],
392
 
                               offset=0):
393
 
        builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
394
 
        for key, value, references in nodes:
395
 
            builder.add_node(key, value, references)
396
 
        content = builder.finish().read()
397
 
        size = len(content)
398
 
        trans = self.get_transport()
399
 
        trans.put_bytes('index', (' '*offset) + content)
400
 
        return GraphIndex(trans, 'index', size, offset=offset)
401
 
 
402
 
    def test_clear_cache(self):
403
 
        index = self.make_index()
404
 
        # For now, we just want to make sure the api is available. As this is
405
 
        # old code, we don't really worry if it *does* anything.
406
 
        index.clear_cache()
407
 
 
408
379
    def test_open_bad_index_no_error(self):
409
380
        trans = self.get_transport()
410
381
        trans.put_bytes('name', "not an index\n")
411
382
        index = GraphIndex(trans, 'name', 13)
412
383
 
413
 
    def test_with_offset(self):
414
 
        nodes = self.make_nodes(200)
415
 
        index = self.make_index_with_offset(offset=1234567, nodes=nodes)
416
 
        self.assertEqual(200, index.key_count())
417
 
 
418
 
    def test_buffer_all_with_offset(self):
419
 
        nodes = self.make_nodes(200)
420
 
        index = self.make_index_with_offset(offset=1234567, nodes=nodes)
421
 
        index._buffer_all()
422
 
        self.assertEqual(200, index.key_count())
423
 
 
424
 
    def test_side_effect_buffering_with_offset(self):
425
 
        nodes = self.make_nodes(20)
426
 
        index = self.make_index_with_offset(offset=1234567, nodes=nodes)
427
 
        index._transport.recommended_page_size = lambda:64*1024
428
 
        subset_nodes = [nodes[0][0], nodes[10][0], nodes[19][0]]
429
 
        entries = [n[1] for n in index.iter_entries(subset_nodes)]
430
 
        self.assertEqual(sorted(subset_nodes), sorted(entries))
431
 
        self.assertEqual(20, index.key_count())
432
 
 
433
384
    def test_open_sets_parsed_map_empty(self):
434
385
        index = self.make_index()
435
386
        self.assertEqual([], index._parsed_byte_map)
600
551
        # not create a new transport request, and should return False (cannot
601
552
        # be in the index) - even when the byte location we ask for is outside
602
553
        # the parsed region
603
 
        #
 
554
        # 
604
555
        result = index._lookup_keys_via_location([(4000, self.make_key(40))])
605
556
        self.assertEqual(
606
557
            [((4000, self.make_key(40)),
964
915
        index = self.make_index(nodes=[(('key', ), 'value', ())])
965
916
        index.validate()
966
917
 
967
 
    # XXX: external_references tests are duplicated in test_btree_index.  We
968
 
    # probably should have per_graph_index tests...
969
 
    def test_external_references_no_refs(self):
970
 
        index = self.make_index(ref_lists=0, nodes=[])
971
 
        self.assertRaises(ValueError, index.external_references, 0)
972
 
 
973
 
    def test_external_references_no_results(self):
974
 
        index = self.make_index(ref_lists=1, nodes=[
975
 
            (('key',), 'value', ([],))])
976
 
        self.assertEqual(set(), index.external_references(0))
977
 
 
978
 
    def test_external_references_missing_ref(self):
979
 
        missing_key = ('missing',)
980
 
        index = self.make_index(ref_lists=1, nodes=[
981
 
            (('key',), 'value', ([missing_key],))])
982
 
        self.assertEqual(set([missing_key]), index.external_references(0))
983
 
 
984
 
    def test_external_references_multiple_ref_lists(self):
985
 
        missing_key = ('missing',)
986
 
        index = self.make_index(ref_lists=2, nodes=[
987
 
            (('key',), 'value', ([], [missing_key]))])
988
 
        self.assertEqual(set([]), index.external_references(0))
989
 
        self.assertEqual(set([missing_key]), index.external_references(1))
990
 
 
991
 
    def test_external_references_two_records(self):
992
 
        index = self.make_index(ref_lists=1, nodes=[
993
 
            (('key-1',), 'value', ([('key-2',)],)),
994
 
            (('key-2',), 'value', ([],)),
995
 
            ])
996
 
        self.assertEqual(set([]), index.external_references(0))
997
 
 
998
 
    def test__find_ancestors(self):
999
 
        key1 = ('key-1',)
1000
 
        key2 = ('key-2',)
1001
 
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
1002
 
            (key1, 'value', ([key2],)),
1003
 
            (key2, 'value', ([],)),
1004
 
            ])
1005
 
        parent_map = {}
1006
 
        missing_keys = set()
1007
 
        search_keys = index._find_ancestors([key1], 0, parent_map, missing_keys)
1008
 
        self.assertEqual({key1: (key2,)}, parent_map)
1009
 
        self.assertEqual(set(), missing_keys)
1010
 
        self.assertEqual(set([key2]), search_keys)
1011
 
        search_keys = index._find_ancestors(search_keys, 0, parent_map,
1012
 
                                            missing_keys)
1013
 
        self.assertEqual({key1: (key2,), key2: ()}, parent_map)
1014
 
        self.assertEqual(set(), missing_keys)
1015
 
        self.assertEqual(set(), search_keys)
1016
 
 
1017
 
    def test__find_ancestors_w_missing(self):
1018
 
        key1 = ('key-1',)
1019
 
        key2 = ('key-2',)
1020
 
        key3 = ('key-3',)
1021
 
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
1022
 
            (key1, 'value', ([key2],)),
1023
 
            (key2, 'value', ([],)),
1024
 
            ])
1025
 
        parent_map = {}
1026
 
        missing_keys = set()
1027
 
        search_keys = index._find_ancestors([key2, key3], 0, parent_map,
1028
 
                                            missing_keys)
1029
 
        self.assertEqual({key2: ()}, parent_map)
1030
 
        self.assertEqual(set([key3]), missing_keys)
1031
 
        self.assertEqual(set(), search_keys)
1032
 
 
1033
 
    def test__find_ancestors_dont_search_known(self):
1034
 
        key1 = ('key-1',)
1035
 
        key2 = ('key-2',)
1036
 
        key3 = ('key-3',)
1037
 
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
1038
 
            (key1, 'value', ([key2],)),
1039
 
            (key2, 'value', ([key3],)),
1040
 
            (key3, 'value', ([],)),
1041
 
            ])
1042
 
        # We already know about key2, so we won't try to search for key3
1043
 
        parent_map = {key2: (key3,)}
1044
 
        missing_keys = set()
1045
 
        search_keys = index._find_ancestors([key1], 0, parent_map,
1046
 
                                            missing_keys)
1047
 
        self.assertEqual({key1: (key2,), key2: (key3,)}, parent_map)
1048
 
        self.assertEqual(set(), missing_keys)
1049
 
        self.assertEqual(set(), search_keys)
1050
 
 
1051
 
    def test_supports_unlimited_cache(self):
1052
 
        builder = GraphIndexBuilder(0, key_elements=1)
1053
 
        stream = builder.finish()
1054
 
        trans = get_transport(self.get_url())
1055
 
        size = trans.put_file('index', stream)
1056
 
        # It doesn't matter what unlimited_cache does here, just that it can be
1057
 
        # passed
1058
 
        index = GraphIndex(trans, 'index', size, unlimited_cache=True)
1059
 
 
1060
918
 
1061
919
class TestCombinedGraphIndex(TestCaseWithMemoryTransport):
1062
920
 
1069
927
        size = trans.put_file(name, stream)
1070
928
        return GraphIndex(trans, name, size)
1071
929
 
1072
 
    def make_combined_index_with_missing(self, missing=['1', '2']):
1073
 
        """Create a CombinedGraphIndex which will have missing indexes.
1074
 
 
1075
 
        This creates a CGI which thinks it has 2 indexes, however they have
1076
 
        been deleted. If CGI._reload_func() is called, then it will repopulate
1077
 
        with a new index.
1078
 
 
1079
 
        :param missing: The underlying indexes to delete
1080
 
        :return: (CombinedGraphIndex, reload_counter)
1081
 
        """
1082
 
        index1 = self.make_index('1', nodes=[(('1',), '', ())])
1083
 
        index2 = self.make_index('2', nodes=[(('2',), '', ())])
1084
 
        index3 = self.make_index('3', nodes=[
1085
 
            (('1',), '', ()),
1086
 
            (('2',), '', ())])
1087
 
 
1088
 
        # total_reloads, num_changed, num_unchanged
1089
 
        reload_counter = [0, 0, 0]
1090
 
        def reload():
1091
 
            reload_counter[0] += 1
1092
 
            new_indices = [index3]
1093
 
            if index._indices == new_indices:
1094
 
                reload_counter[2] += 1
1095
 
                return False
1096
 
            reload_counter[1] += 1
1097
 
            index._indices[:] = new_indices
1098
 
            return True
1099
 
        index = CombinedGraphIndex([index1, index2], reload_func=reload)
1100
 
        trans = self.get_transport()
1101
 
        for fname in missing:
1102
 
            trans.delete(fname)
1103
 
        return index, reload_counter
1104
 
 
1105
930
    def test_open_missing_index_no_error(self):
1106
931
        trans = self.get_transport()
1107
932
        index1 = GraphIndex(trans, 'missing', 100)
1113
938
        index.insert_index(0, index1)
1114
939
        self.assertEqual([(index1, ('key', ), '')], list(index.iter_all_entries()))
1115
940
 
1116
 
    def test_clear_cache(self):
1117
 
        log = []
1118
 
 
1119
 
        class ClearCacheProxy(object):
1120
 
 
1121
 
            def __init__(self, index):
1122
 
                self._index = index
1123
 
 
1124
 
            def __getattr__(self, name):
1125
 
                return getattr(self._index)
1126
 
 
1127
 
            def clear_cache(self):
1128
 
                log.append(self._index)
1129
 
                return self._index.clear_cache()
1130
 
 
1131
 
        index = CombinedGraphIndex([])
1132
 
        index1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1133
 
        index.insert_index(0, ClearCacheProxy(index1))
1134
 
        index2 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1135
 
        index.insert_index(1, ClearCacheProxy(index2))
1136
 
        # CombinedGraphIndex should call 'clear_cache()' on all children
1137
 
        index.clear_cache()
1138
 
        self.assertEqual(sorted([index1, index2]), sorted(log))
1139
 
 
1140
941
    def test_iter_all_entries_empty(self):
1141
942
        index = CombinedGraphIndex([])
1142
943
        self.assertEqual([], list(index.iter_all_entries()))
1206
1007
        self.assertEqual(set([(index1, ('name', ), 'data', ((('ref', ), ), )),
1207
1008
            (index2, ('ref', ), 'refdata', ((), ))]),
1208
1009
            set(index.iter_entries([('name', ), ('ref', )])))
1209
 
 
 
1010
 
1210
1011
    def test_iter_all_keys_dup_entry(self):
1211
1012
        index1 = self.make_index('1', 1, nodes=[
1212
1013
            (('name', ), 'data', ([('ref', )], )),
1217
1018
        self.assertEqual(set([(index1, ('name', ), 'data', ((('ref',),),)),
1218
1019
            (index1, ('ref', ), 'refdata', ((), ))]),
1219
1020
            set(index.iter_entries([('name', ), ('ref', )])))
1220
 
 
 
1021
 
1221
1022
    def test_iter_missing_entry_empty(self):
1222
1023
        index = CombinedGraphIndex([])
1223
1024
        self.assertEqual([], list(index.iter_entries([('a', )])))
1232
1033
        index2 = self.make_index('2')
1233
1034
        index = CombinedGraphIndex([index1, index2])
1234
1035
        self.assertEqual([], list(index.iter_entries([('a', )])))
1235
 
 
 
1036
 
1236
1037
    def test_iter_entry_present_one_index_only(self):
1237
1038
        index1 = self.make_index('1', nodes=[(('key', ), '', ())])
1238
1039
        index2 = self.make_index('2', nodes=[])
1269
1070
        index = CombinedGraphIndex([])
1270
1071
        index.validate()
1271
1072
 
1272
 
    def test_key_count_reloads(self):
1273
 
        index, reload_counter = self.make_combined_index_with_missing()
1274
 
        self.assertEqual(2, index.key_count())
1275
 
        self.assertEqual([1, 1, 0], reload_counter)
1276
 
 
1277
 
    def test_key_count_no_reload(self):
1278
 
        index, reload_counter = self.make_combined_index_with_missing()
1279
 
        index._reload_func = None
1280
 
        # Without a _reload_func we just raise the exception
1281
 
        self.assertRaises(errors.NoSuchFile, index.key_count)
1282
 
 
1283
 
    def test_key_count_reloads_and_fails(self):
1284
 
        # We have deleted all underlying indexes, so we will try to reload, but
1285
 
        # still fail. This is mostly to test we don't get stuck in an infinite
1286
 
        # loop trying to reload
1287
 
        index, reload_counter = self.make_combined_index_with_missing(
1288
 
                                    ['1', '2', '3'])
1289
 
        self.assertRaises(errors.NoSuchFile, index.key_count)
1290
 
        self.assertEqual([2, 1, 1], reload_counter)
1291
 
 
1292
 
    def test_iter_entries_reloads(self):
1293
 
        index, reload_counter = self.make_combined_index_with_missing()
1294
 
        result = list(index.iter_entries([('1',), ('2',), ('3',)]))
1295
 
        index3 = index._indices[0]
1296
 
        self.assertEqual([(index3, ('1',), ''), (index3, ('2',), '')],
1297
 
                         result)
1298
 
        self.assertEqual([1, 1, 0], reload_counter)
1299
 
 
1300
 
    def test_iter_entries_reloads_midway(self):
1301
 
        # The first index still looks present, so we get interrupted mid-way
1302
 
        # through
1303
 
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1304
 
        index1, index2 = index._indices
1305
 
        result = list(index.iter_entries([('1',), ('2',), ('3',)]))
1306
 
        index3 = index._indices[0]
1307
 
        # We had already yielded '1', so we just go on to the next, we should
1308
 
        # not yield '1' twice.
1309
 
        self.assertEqual([(index1, ('1',), ''), (index3, ('2',), '')],
1310
 
                         result)
1311
 
        self.assertEqual([1, 1, 0], reload_counter)
1312
 
 
1313
 
    def test_iter_entries_no_reload(self):
1314
 
        index, reload_counter = self.make_combined_index_with_missing()
1315
 
        index._reload_func = None
1316
 
        # Without a _reload_func we just raise the exception
1317
 
        self.assertListRaises(errors.NoSuchFile, index.iter_entries, [('3',)])
1318
 
 
1319
 
    def test_iter_entries_reloads_and_fails(self):
1320
 
        index, reload_counter = self.make_combined_index_with_missing(
1321
 
                                    ['1', '2', '3'])
1322
 
        self.assertListRaises(errors.NoSuchFile, index.iter_entries, [('3',)])
1323
 
        self.assertEqual([2, 1, 1], reload_counter)
1324
 
 
1325
 
    def test_iter_all_entries_reloads(self):
1326
 
        index, reload_counter = self.make_combined_index_with_missing()
1327
 
        result = list(index.iter_all_entries())
1328
 
        index3 = index._indices[0]
1329
 
        self.assertEqual([(index3, ('1',), ''), (index3, ('2',), '')],
1330
 
                         result)
1331
 
        self.assertEqual([1, 1, 0], reload_counter)
1332
 
 
1333
 
    def test_iter_all_entries_reloads_midway(self):
1334
 
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1335
 
        index1, index2 = index._indices
1336
 
        result = list(index.iter_all_entries())
1337
 
        index3 = index._indices[0]
1338
 
        # We had already yielded '1', so we just go on to the next, we should
1339
 
        # not yield '1' twice.
1340
 
        self.assertEqual([(index1, ('1',), ''), (index3, ('2',), '')],
1341
 
                         result)
1342
 
        self.assertEqual([1, 1, 0], reload_counter)
1343
 
 
1344
 
    def test_iter_all_entries_no_reload(self):
1345
 
        index, reload_counter = self.make_combined_index_with_missing()
1346
 
        index._reload_func = None
1347
 
        self.assertListRaises(errors.NoSuchFile, index.iter_all_entries)
1348
 
 
1349
 
    def test_iter_all_entries_reloads_and_fails(self):
1350
 
        index, reload_counter = self.make_combined_index_with_missing(
1351
 
                                    ['1', '2', '3'])
1352
 
        self.assertListRaises(errors.NoSuchFile, index.iter_all_entries)
1353
 
 
1354
 
    def test_iter_entries_prefix_reloads(self):
1355
 
        index, reload_counter = self.make_combined_index_with_missing()
1356
 
        result = list(index.iter_entries_prefix([('1',)]))
1357
 
        index3 = index._indices[0]
1358
 
        self.assertEqual([(index3, ('1',), '')], result)
1359
 
        self.assertEqual([1, 1, 0], reload_counter)
1360
 
 
1361
 
    def test_iter_entries_prefix_reloads_midway(self):
1362
 
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1363
 
        index1, index2 = index._indices
1364
 
        result = list(index.iter_entries_prefix([('1',)]))
1365
 
        index3 = index._indices[0]
1366
 
        # We had already yielded '1', so we just go on to the next, we should
1367
 
        # not yield '1' twice.
1368
 
        self.assertEqual([(index1, ('1',), '')], result)
1369
 
        self.assertEqual([1, 1, 0], reload_counter)
1370
 
 
1371
 
    def test_iter_entries_prefix_no_reload(self):
1372
 
        index, reload_counter = self.make_combined_index_with_missing()
1373
 
        index._reload_func = None
1374
 
        self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,
1375
 
                                                 [('1',)])
1376
 
 
1377
 
    def test_iter_entries_prefix_reloads_and_fails(self):
1378
 
        index, reload_counter = self.make_combined_index_with_missing(
1379
 
                                    ['1', '2', '3'])
1380
 
        self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,
1381
 
                                                 [('1',)])
1382
 
 
1383
 
 
1384
 
    def make_index_with_simple_nodes(self, name, num_nodes=1):
1385
 
        """Make an index named after 'name', with keys named after 'name' too.
1386
 
 
1387
 
        Nodes will have a value of '' and no references.
1388
 
        """
1389
 
        nodes = [
1390
 
            (('index-%s-key-%s' % (name, n),), '', ())
1391
 
            for n in range(1, num_nodes+1)]
1392
 
        return self.make_index('index-%s' % name, 0, nodes=nodes)
1393
 
 
1394
 
    def test_reorder_after_iter_entries(self):
1395
 
        # Four indices: [key1] in index1, [key2,key3] in index2, [] in index3,
1396
 
        # [key4] in index4.
1397
 
        index = CombinedGraphIndex([])
1398
 
        index.insert_index(0, self.make_index_with_simple_nodes('1'), '1')
1399
 
        index.insert_index(1, self.make_index_with_simple_nodes('2'), '2')
1400
 
        index.insert_index(2, self.make_index_with_simple_nodes('3'), '3')
1401
 
        index.insert_index(3, self.make_index_with_simple_nodes('4'), '4')
1402
 
        index1, index2, index3, index4 = index._indices
1403
 
        # Query a key from index4 and index2.
1404
 
        self.assertLength(2, list(index.iter_entries(
1405
 
            [('index-4-key-1',), ('index-2-key-1',)])))
1406
 
        # Now index2 and index4 should be moved to the front (and index1 should
1407
 
        # still be before index3).
1408
 
        self.assertEqual([index2, index4, index1, index3], index._indices)
1409
 
        self.assertEqual(['2', '4', '1', '3'], index._index_names)
1410
 
 
1411
 
    def test_reorder_propagates_to_siblings(self):
1412
 
        # Two CombinedGraphIndex objects, with the same number of indicies with
1413
 
        # matching names.
1414
 
        cgi1 = CombinedGraphIndex([])
1415
 
        cgi2 = CombinedGraphIndex([])
1416
 
        cgi1.insert_index(0, self.make_index_with_simple_nodes('1-1'), 'one')
1417
 
        cgi1.insert_index(1, self.make_index_with_simple_nodes('1-2'), 'two')
1418
 
        cgi2.insert_index(0, self.make_index_with_simple_nodes('2-1'), 'one')
1419
 
        cgi2.insert_index(1, self.make_index_with_simple_nodes('2-2'), 'two')
1420
 
        index2_1, index2_2 = cgi2._indices
1421
 
        cgi1.set_sibling_indices([cgi2])
1422
 
        # Trigger a reordering in cgi1.  cgi2 will be reordered as well.
1423
 
        list(cgi1.iter_entries([('index-1-2-key-1',)]))
1424
 
        self.assertEqual([index2_2, index2_1], cgi2._indices)
1425
 
        self.assertEqual(['two', 'one'], cgi2._index_names)
1426
 
 
1427
 
    def test_validate_reloads(self):
1428
 
        index, reload_counter = self.make_combined_index_with_missing()
1429
 
        index.validate()
1430
 
        self.assertEqual([1, 1, 0], reload_counter)
1431
 
 
1432
 
    def test_validate_reloads_midway(self):
1433
 
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1434
 
        index.validate()
1435
 
 
1436
 
    def test_validate_no_reload(self):
1437
 
        index, reload_counter = self.make_combined_index_with_missing()
1438
 
        index._reload_func = None
1439
 
        self.assertRaises(errors.NoSuchFile, index.validate)
1440
 
 
1441
 
    def test_validate_reloads_and_fails(self):
1442
 
        index, reload_counter = self.make_combined_index_with_missing(
1443
 
                                    ['1', '2', '3'])
1444
 
        self.assertRaises(errors.NoSuchFile, index.validate)
1445
 
 
1446
 
    def test_find_ancestors_across_indexes(self):
1447
 
        key1 = ('key-1',)
1448
 
        key2 = ('key-2',)
1449
 
        key3 = ('key-3',)
1450
 
        key4 = ('key-4',)
1451
 
        index1 = self.make_index('12', ref_lists=1, nodes=[
1452
 
            (key1, 'value', ([],)),
1453
 
            (key2, 'value', ([key1],)),
1454
 
            ])
1455
 
        index2 = self.make_index('34', ref_lists=1, nodes=[
1456
 
            (key3, 'value', ([key2],)),
1457
 
            (key4, 'value', ([key3],)),
1458
 
            ])
1459
 
        c_index = CombinedGraphIndex([index1, index2])
1460
 
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1461
 
        self.assertEqual({key1: ()}, parent_map)
1462
 
        self.assertEqual(set(), missing_keys)
1463
 
        # Now look for a key from index2 which requires us to find the key in
1464
 
        # the second index, and then continue searching for parents in the
1465
 
        # first index
1466
 
        parent_map, missing_keys = c_index.find_ancestry([key3], 0)
1467
 
        self.assertEqual({key1: (), key2: (key1,), key3: (key2,)}, parent_map)
1468
 
        self.assertEqual(set(), missing_keys)
1469
 
 
1470
 
    def test_find_ancestors_missing_keys(self):
1471
 
        key1 = ('key-1',)
1472
 
        key2 = ('key-2',)
1473
 
        key3 = ('key-3',)
1474
 
        key4 = ('key-4',)
1475
 
        index1 = self.make_index('12', ref_lists=1, nodes=[
1476
 
            (key1, 'value', ([],)),
1477
 
            (key2, 'value', ([key1],)),
1478
 
            ])
1479
 
        index2 = self.make_index('34', ref_lists=1, nodes=[
1480
 
            (key3, 'value', ([key2],)),
1481
 
            ])
1482
 
        c_index = CombinedGraphIndex([index1, index2])
1483
 
        # Searching for a key which is actually not present at all should
1484
 
        # eventually converge
1485
 
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1486
 
        self.assertEqual({}, parent_map)
1487
 
        self.assertEqual(set([key4]), missing_keys)
1488
 
 
1489
 
    def test_find_ancestors_no_indexes(self):
1490
 
        c_index = CombinedGraphIndex([])
1491
 
        key1 = ('key-1',)
1492
 
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1493
 
        self.assertEqual({}, parent_map)
1494
 
        self.assertEqual(set([key1]), missing_keys)
1495
 
 
1496
 
    def test_find_ancestors_ghost_parent(self):
1497
 
        key1 = ('key-1',)
1498
 
        key2 = ('key-2',)
1499
 
        key3 = ('key-3',)
1500
 
        key4 = ('key-4',)
1501
 
        index1 = self.make_index('12', ref_lists=1, nodes=[
1502
 
            (key1, 'value', ([],)),
1503
 
            (key2, 'value', ([key1],)),
1504
 
            ])
1505
 
        index2 = self.make_index('34', ref_lists=1, nodes=[
1506
 
            (key4, 'value', ([key2, key3],)),
1507
 
            ])
1508
 
        c_index = CombinedGraphIndex([index1, index2])
1509
 
        # Searching for a key which is actually not present at all should
1510
 
        # eventually converge
1511
 
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1512
 
        self.assertEqual({key4: (key2, key3), key2: (key1,), key1: ()},
1513
 
                         parent_map)
1514
 
        self.assertEqual(set([key3]), missing_keys)
1515
 
 
1516
 
    def test__find_ancestors_empty_index(self):
1517
 
        index = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
1518
 
        parent_map = {}
1519
 
        missing_keys = set()
1520
 
        search_keys = index._find_ancestors([('one',), ('two',)], 0, parent_map,
1521
 
                                            missing_keys)
1522
 
        self.assertEqual(set(), search_keys)
1523
 
        self.assertEqual({}, parent_map)
1524
 
        self.assertEqual(set([('one',), ('two',)]), missing_keys)
1525
 
 
1526
1073
 
1527
1074
class TestInMemoryGraphIndex(TestCaseWithMemoryTransport):
1528
1075