← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_index.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_index.py
16
16
 
17
17
"""Tests for indices."""
18
18
 
19
 
from bzrlib import errors
20
 
from bzrlib.index import *
21
 
from bzrlib.tests import TestCaseWithMemoryTransport
22
 
from bzrlib.transport import get_transport
23
 
 
24
 
 
25
 
class TestGraphIndexBuilder(TestCaseWithMemoryTransport):
 
19
from bzrlib import (
 
20
    errors,
 
21
    index,
 
22
    tests,
 
23
    transport,
 
24
    )
 
25
 
 
26
 
 
27
class TestGraphIndexBuilder(tests.TestCaseWithMemoryTransport):
26
28
 
27
29
    def test_build_index_empty(self):
28
 
        builder = GraphIndexBuilder()
 
30
        builder = index.GraphIndexBuilder()
29
31
        stream = builder.finish()
30
32
        contents = stream.read()
31
33
        self.assertEqual(
33
35
            contents)
34
36
 
35
37
    def test_build_index_empty_two_element_keys(self):
36
 
        builder = GraphIndexBuilder(key_elements=2)
 
38
        builder = index.GraphIndexBuilder(key_elements=2)
37
39
        stream = builder.finish()
38
40
        contents = stream.read()
39
41
        self.assertEqual(
41
43
            contents)
42
44
 
43
45
    def test_build_index_one_reference_list_empty(self):
44
 
        builder = GraphIndexBuilder(reference_lists=1)
 
46
        builder = index.GraphIndexBuilder(reference_lists=1)
45
47
        stream = builder.finish()
46
48
        contents = stream.read()
47
49
        self.assertEqual(
49
51
            contents)
50
52
 
51
53
    def test_build_index_two_reference_list_empty(self):
52
 
        builder = GraphIndexBuilder(reference_lists=2)
 
54
        builder = index.GraphIndexBuilder(reference_lists=2)
53
55
        stream = builder.finish()
54
56
        contents = stream.read()
55
57
        self.assertEqual(
57
59
            contents)
58
60
 
59
61
    def test_build_index_one_node_no_refs(self):
60
 
        builder = GraphIndexBuilder()
 
62
        builder = index.GraphIndexBuilder()
61
63
        builder.add_node(('akey', ), 'data')
62
64
        stream = builder.finish()
63
65
        contents = stream.read()
66
68
            "akey\x00\x00\x00data\n\n", contents)
67
69
 
68
70
    def test_build_index_one_node_no_refs_accepts_empty_reflist(self):
69
 
        builder = GraphIndexBuilder()
 
71
        builder = index.GraphIndexBuilder()
70
72
        builder.add_node(('akey', ), 'data', ())
71
73
        stream = builder.finish()
72
74
        contents = stream.read()
78
80
        # multipart keys are separated by \x00 - because they are fixed length,
79
81
        # not variable this does not cause any issues, and seems clearer to the
80
82
        # author.
81
 
        builder = GraphIndexBuilder(key_elements=2)
 
83
        builder = index.GraphIndexBuilder(key_elements=2)
82
84
        builder.add_node(('akey', 'secondpart'), 'data')
83
85
        stream = builder.finish()
84
86
        contents = stream.read()
87
89
            "akey\x00secondpart\x00\x00\x00data\n\n", contents)
88
90
 
89
91
    def test_add_node_empty_value(self):
90
 
        builder = GraphIndexBuilder()
 
92
        builder = index.GraphIndexBuilder()
91
93
        builder.add_node(('akey', ), '')
92
94
        stream = builder.finish()
93
95
        contents = stream.read()
97
99
 
98
100
    def test_build_index_nodes_sorted(self):
99
101
        # the highest sorted node comes first.
100
 
        builder = GraphIndexBuilder()
 
102
        builder = index.GraphIndexBuilder()
101
103
        # use three to have a good chance of glitching dictionary hash
102
104
        # lookups etc. Insert in randomish order that is not correct
103
105
        # and not the reverse of the correct order.
115
117
 
116
118
    def test_build_index_2_element_key_nodes_sorted(self):
117
119
        # multiple element keys are sorted first-key, second-key.
118
 
        builder = GraphIndexBuilder(key_elements=2)
 
120
        builder = index.GraphIndexBuilder(key_elements=2)
119
121
        # use three values of each key element, to have a good chance of
120
122
        # glitching dictionary hash lookups etc. Insert in randomish order that
121
123
        # is not correct and not the reverse of the correct order.
144
146
            "\n", contents)
145
147
 
146
148
    def test_build_index_reference_lists_are_included_one(self):
147
 
        builder = GraphIndexBuilder(reference_lists=1)
 
149
        builder = index.GraphIndexBuilder(reference_lists=1)
148
150
        builder.add_node(('key', ), 'data', ([], ))
149
151
        stream = builder.finish()
150
152
        contents = stream.read()
154
156
            "\n", contents)
155
157
 
156
158
    def test_build_index_reference_lists_with_2_element_keys(self):
157
 
        builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
 
159
        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
158
160
        builder.add_node(('key', 'key2'), 'data', ([], ))
159
161
        stream = builder.finish()
160
162
        contents = stream.read()
164
166
            "\n", contents)
165
167
 
166
168
    def test_build_index_reference_lists_are_included_two(self):
167
 
        builder = GraphIndexBuilder(reference_lists=2)
 
169
        builder = index.GraphIndexBuilder(reference_lists=2)
168
170
        builder.add_node(('key', ), 'data', ([], []))
169
171
        stream = builder.finish()
170
172
        contents = stream.read()
174
176
            "\n", contents)
175
177
 
176
178
    def test_clear_cache(self):
177
 
        builder = GraphIndexBuilder(reference_lists=2)
 
179
        builder = index.GraphIndexBuilder(reference_lists=2)
178
180
        # This is a no-op, but the api should exist
179
181
        builder.clear_cache()
180
182
 
181
183
    def test_node_references_are_byte_offsets(self):
182
 
        builder = GraphIndexBuilder(reference_lists=1)
 
184
        builder = index.GraphIndexBuilder(reference_lists=1)
183
185
        builder.add_node(('reference', ), 'data', ([], ))
184
186
        builder.add_node(('key', ), 'data', ([('reference', )], ))
185
187
        stream = builder.finish()
191
193
            "\n", contents)
192
194
 
193
195
    def test_node_references_are_cr_delimited(self):
194
 
        builder = GraphIndexBuilder(reference_lists=1)
 
196
        builder = index.GraphIndexBuilder(reference_lists=1)
195
197
        builder.add_node(('reference', ), 'data', ([], ))
196
198
        builder.add_node(('reference2', ), 'data', ([], ))
197
 
        builder.add_node(('key', ), 'data', ([('reference', ), ('reference2', )], ))
 
199
        builder.add_node(('key', ), 'data',
 
200
                         ([('reference', ), ('reference2', )], ))
198
201
        stream = builder.finish()
199
202
        contents = stream.read()
200
203
        self.assertEqual(
205
208
            "\n", contents)
206
209
 
207
210
    def test_multiple_reference_lists_are_tab_delimited(self):
208
 
        builder = GraphIndexBuilder(reference_lists=2)
 
211
        builder = index.GraphIndexBuilder(reference_lists=2)
209
212
        builder.add_node(('keference', ), 'data', ([], []))
210
 
        builder.add_node(('rey', ), 'data', ([('keference', )], [('keference', )]))
 
213
        builder.add_node(('rey', ), 'data',
 
214
                         ([('keference', )], [('keference', )]))
211
215
        stream = builder.finish()
212
216
        contents = stream.read()
213
217
        self.assertEqual(
217
221
            "\n", contents)
218
222
 
219
223
    def test_add_node_referencing_missing_key_makes_absent(self):
220
 
        builder = GraphIndexBuilder(reference_lists=1)
221
 
        builder.add_node(('rey', ), 'data', ([('beference', ), ('aeference2', )], ))
 
224
        builder = index.GraphIndexBuilder(reference_lists=1)
 
225
        builder.add_node(('rey', ), 'data',
 
226
                         ([('beference', ), ('aeference2', )], ))
222
227
        stream = builder.finish()
223
228
        contents = stream.read()
224
229
        self.assertEqual(
230
235
 
231
236
    def test_node_references_three_digits(self):
232
237
        # test the node digit expands as needed.
233
 
        builder = GraphIndexBuilder(reference_lists=1)
 
238
        builder = index.GraphIndexBuilder(reference_lists=1)
234
239
        references = [(str(val), ) for val in reversed(range(9))]
235
240
        builder.add_node(('2-key', ), '', (references, ))
236
241
        stream = builder.finish()
252
257
    def test_absent_has_no_reference_overhead(self):
253
258
        # the offsets after an absent record should be correct when there are
254
259
        # >1 reference lists.
255
 
        builder = GraphIndexBuilder(reference_lists=2)
 
260
        builder = index.GraphIndexBuilder(reference_lists=2)
256
261
        builder.add_node(('parent', ), '', ([('aail', ), ('zther', )], []))
257
262
        stream = builder.finish()
258
263
        contents = stream.read()
264
269
            "\n", contents)
265
270
 
266
271
    def test_add_node_bad_key(self):
267
 
        builder = GraphIndexBuilder()
 
272
        builder = index.GraphIndexBuilder()
268
273
        for bad_char in '\t\n\x0b\x0c\r\x00 ':
269
274
            self.assertRaises(errors.BadIndexKey, builder.add_node,
270
275
                ('a%skey' % bad_char, ), 'data')
279
284
        self.assertRaises(errors.BadIndexKey, builder.add_node,
280
285
                ('primary', 'secondary'), 'data')
281
286
        # secondary key elements get checked too:
282
 
        builder = GraphIndexBuilder(key_elements=2)
 
287
        builder = index.GraphIndexBuilder(key_elements=2)
283
288
        for bad_char in '\t\n\x0b\x0c\r\x00 ':
284
289
            self.assertRaises(errors.BadIndexKey, builder.add_node,
285
290
                ('prefix', 'a%skey' % bad_char), 'data')
286
291
 
287
292
    def test_add_node_bad_data(self):
288
 
        builder = GraphIndexBuilder()
 
293
        builder = index.GraphIndexBuilder()
289
294
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
290
295
            'data\naa')
291
296
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
292
297
            'data\x00aa')
293
298
 
294
299
    def test_add_node_bad_mismatched_ref_lists_length(self):
295
 
        builder = GraphIndexBuilder()
 
300
        builder = index.GraphIndexBuilder()
296
301
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
297
302
            'data aa', ([], ))
298
 
        builder = GraphIndexBuilder(reference_lists=1)
 
303
        builder = index.GraphIndexBuilder(reference_lists=1)
299
304
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
300
305
            'data aa')
301
306
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
302
307
            'data aa', (), )
303
308
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
304
309
            'data aa', ([], []))
305
 
        builder = GraphIndexBuilder(reference_lists=2)
 
310
        builder = index.GraphIndexBuilder(reference_lists=2)
306
311
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
307
312
            'data aa')
308
313
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
312
317
 
313
318
    def test_add_node_bad_key_in_reference_lists(self):
314
319
        # first list, first key - trivial
315
 
        builder = GraphIndexBuilder(reference_lists=1)
 
320
        builder = index.GraphIndexBuilder(reference_lists=1)
316
321
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
317
322
            'data aa', ([('a key', )], ))
318
323
        # references keys must be tuples too
329
334
            'data aa', ([('agoodkey', ), ('that is a bad key', )], ))
330
335
        # and if there is more than one list it should be getting checked
331
336
        # too
332
 
        builder = GraphIndexBuilder(reference_lists=2)
 
337
        builder = index.GraphIndexBuilder(reference_lists=2)
333
338
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
334
339
            'data aa', ([], ['a bad key']))
335
340
 
336
341
    def test_add_duplicate_key(self):
337
 
        builder = GraphIndexBuilder()
 
342
        builder = index.GraphIndexBuilder()
338
343
        builder.add_node(('key', ), 'data')
339
 
        self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node, ('key', ),
340
 
            'data')
 
344
        self.assertRaises(errors.BadIndexDuplicateKey,
 
345
                          builder.add_node, ('key', ), 'data')
341
346
 
342
347
    def test_add_duplicate_key_2_elements(self):
343
 
        builder = GraphIndexBuilder(key_elements=2)
 
348
        builder = index.GraphIndexBuilder(key_elements=2)
344
349
        builder.add_node(('key', 'key'), 'data')
345
350
        self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node,
346
351
            ('key', 'key'), 'data')
347
352
 
348
353
    def test_add_key_after_referencing_key(self):
349
 
        builder = GraphIndexBuilder(reference_lists=1)
 
354
        builder = index.GraphIndexBuilder(reference_lists=1)
350
355
        builder.add_node(('key', ), 'data', ([('reference', )], ))
351
356
        builder.add_node(('reference', ), 'data', ([],))
352
357
 
353
358
    def test_add_key_after_referencing_key_2_elements(self):
354
 
        builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
 
359
        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
355
360
        builder.add_node(('k', 'ey'), 'data', ([('reference', 'tokey')], ))
356
361
        builder.add_node(('reference', 'tokey'), 'data', ([],))
357
362
 
358
363
    def test_set_optimize(self):
359
 
        builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
 
364
        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
360
365
        builder.set_optimize(for_size=True)
361
366
        self.assertTrue(builder._optimize_for_size)
362
367
        builder.set_optimize(for_size=False)
363
368
        self.assertFalse(builder._optimize_for_size)
364
369
 
365
370
 
366
 
class TestGraphIndex(TestCaseWithMemoryTransport):
 
371
class TestGraphIndex(tests.TestCaseWithMemoryTransport):
367
372
 
368
373
    def make_key(self, number):
369
374
        return (str(number) + 'X'*100,)
380
385
        return nodes
381
386
 
382
387
    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
383
 
        builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
 
388
        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
384
389
        for key, value, references in nodes:
385
390
            builder.add_node(key, value, references)
386
391
        stream = builder.finish()
387
 
        trans = get_transport('trace+' + self.get_url())
 
392
        trans = transport.get_transport_from_url('trace+' + self.get_url())
388
393
        size = trans.put_file('index', stream)
389
 
        return GraphIndex(trans, 'index', size)
 
394
        return index.GraphIndex(trans, 'index', size)
 
395
 
 
396
    def make_index_with_offset(self, ref_lists=0, key_elements=1, nodes=[],
 
397
                               offset=0):
 
398
        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
 
399
        for key, value, references in nodes:
 
400
            builder.add_node(key, value, references)
 
401
        content = builder.finish().read()
 
402
        size = len(content)
 
403
        trans = self.get_transport()
 
404
        trans.put_bytes('index', (' '*offset) + content)
 
405
        return index.GraphIndex(trans, 'index', size, offset=offset)
390
406
 
391
407
    def test_clear_cache(self):
392
408
        index = self.make_index()
397
413
    def test_open_bad_index_no_error(self):
398
414
        trans = self.get_transport()
399
415
        trans.put_bytes('name', "not an index\n")
400
 
        index = GraphIndex(trans, 'name', 13)
 
416
        idx = index.GraphIndex(trans, 'name', 13)
 
417
 
 
418
    def test_with_offset(self):
 
419
        nodes = self.make_nodes(200)
 
420
        idx = self.make_index_with_offset(offset=1234567, nodes=nodes)
 
421
        self.assertEqual(200, idx.key_count())
 
422
 
 
423
    def test_buffer_all_with_offset(self):
 
424
        nodes = self.make_nodes(200)
 
425
        idx = self.make_index_with_offset(offset=1234567, nodes=nodes)
 
426
        idx._buffer_all()
 
427
        self.assertEqual(200, idx.key_count())
 
428
 
 
429
    def test_side_effect_buffering_with_offset(self):
 
430
        nodes = self.make_nodes(20)
 
431
        index = self.make_index_with_offset(offset=1234567, nodes=nodes)
 
432
        index._transport.recommended_page_size = lambda:64*1024
 
433
        subset_nodes = [nodes[0][0], nodes[10][0], nodes[19][0]]
 
434
        entries = [n[1] for n in index.iter_entries(subset_nodes)]
 
435
        self.assertEqual(sorted(subset_nodes), sorted(entries))
 
436
        self.assertEqual(20, index.key_count())
401
437
 
402
438
    def test_open_sets_parsed_map_empty(self):
403
439
        index = self.make_index()
799
835
        self.assertEqual([], list(index.iter_entries([('a', )])))
800
836
 
801
837
    def test_iter_missing_entry_empty_no_size(self):
802
 
        index = self.make_index()
803
 
        index = GraphIndex(index._transport, 'index', None)
804
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
838
        idx = self.make_index()
 
839
        idx = index.GraphIndex(idx._transport, 'index', None)
 
840
        self.assertEqual([], list(idx.iter_entries([('a', )])))
805
841
 
806
842
    def test_iter_key_prefix_1_element_key_None(self):
807
843
        index = self.make_index()
897
933
    def test_validate_bad_index_errors(self):
898
934
        trans = self.get_transport()
899
935
        trans.put_bytes('name', "not an index\n")
900
 
        index = GraphIndex(trans, 'name', 13)
901
 
        self.assertRaises(errors.BadIndexFormatSignature, index.validate)
 
936
        idx = index.GraphIndex(trans, 'name', 13)
 
937
        self.assertRaises(errors.BadIndexFormatSignature, idx.validate)
902
938
 
903
939
    def test_validate_bad_node_refs(self):
904
 
        index = self.make_index(2)
 
940
        idx = self.make_index(2)
905
941
        trans = self.get_transport()
906
942
        content = trans.get_bytes('index')
907
943
        # change the options line to end with a rather than a parseable number
908
944
        new_content = content[:-2] + 'a\n\n'
909
945
        trans.put_bytes('index', new_content)
910
 
        self.assertRaises(errors.BadIndexOptions, index.validate)
 
946
        self.assertRaises(errors.BadIndexOptions, idx.validate)
911
947
 
912
948
    def test_validate_missing_end_line_empty(self):
913
949
        index = self.make_index(2)
1018
1054
        self.assertEqual(set(), search_keys)
1019
1055
 
1020
1056
    def test_supports_unlimited_cache(self):
1021
 
        builder = GraphIndexBuilder(0, key_elements=1)
 
1057
        builder = index.GraphIndexBuilder(0, key_elements=1)
1022
1058
        stream = builder.finish()
1023
 
        trans = get_transport(self.get_url())
 
1059
        trans = self.get_transport()
1024
1060
        size = trans.put_file('index', stream)
1025
1061
        # It doesn't matter what unlimited_cache does here, just that it can be
1026
1062
        # passed
1027
 
        index = GraphIndex(trans, 'index', size, unlimited_cache=True)
1028
 
 
1029
 
 
1030
 
class TestCombinedGraphIndex(TestCaseWithMemoryTransport):
 
1063
        idx = index.GraphIndex(trans, 'index', size, unlimited_cache=True)
 
1064
 
 
1065
 
 
1066
class TestCombinedGraphIndex(tests.TestCaseWithMemoryTransport):
1031
1067
 
1032
1068
    def make_index(self, name, ref_lists=0, key_elements=1, nodes=[]):
1033
 
        builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
 
1069
        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
1034
1070
        for key, value, references in nodes:
1035
1071
            builder.add_node(key, value, references)
1036
1072
        stream = builder.finish()
1037
1073
        trans = self.get_transport()
1038
1074
        size = trans.put_file(name, stream)
1039
 
        return GraphIndex(trans, name, size)
 
1075
        return index.GraphIndex(trans, name, size)
1040
1076
 
1041
1077
    def make_combined_index_with_missing(self, missing=['1', '2']):
1042
1078
        """Create a CombinedGraphIndex which will have missing indexes.
1048
1084
        :param missing: The underlying indexes to delete
1049
1085
        :return: (CombinedGraphIndex, reload_counter)
1050
1086
        """
1051
 
        index1 = self.make_index('1', nodes=[(('1',), '', ())])
1052
 
        index2 = self.make_index('2', nodes=[(('2',), '', ())])
1053
 
        index3 = self.make_index('3', nodes=[
 
1087
        idx1 = self.make_index('1', nodes=[(('1',), '', ())])
 
1088
        idx2 = self.make_index('2', nodes=[(('2',), '', ())])
 
1089
        idx3 = self.make_index('3', nodes=[
1054
1090
            (('1',), '', ()),
1055
1091
            (('2',), '', ())])
1056
1092
 
1058
1094
        reload_counter = [0, 0, 0]
1059
1095
        def reload():
1060
1096
            reload_counter[0] += 1
1061
 
            new_indices = [index3]
1062
 
            if index._indices == new_indices:
 
1097
            new_indices = [idx3]
 
1098
            if idx._indices == new_indices:
1063
1099
                reload_counter[2] += 1
1064
1100
                return False
1065
1101
            reload_counter[1] += 1
1066
 
            index._indices[:] = new_indices
 
1102
            idx._indices[:] = new_indices
1067
1103
            return True
1068
 
        index = CombinedGraphIndex([index1, index2], reload_func=reload)
 
1104
        idx = index.CombinedGraphIndex([idx1, idx2], reload_func=reload)
1069
1105
        trans = self.get_transport()
1070
1106
        for fname in missing:
1071
1107
            trans.delete(fname)
1072
 
        return index, reload_counter
 
1108
        return idx, reload_counter
1073
1109
 
1074
1110
    def test_open_missing_index_no_error(self):
1075
1111
        trans = self.get_transport()
1076
 
        index1 = GraphIndex(trans, 'missing', 100)
1077
 
        index = CombinedGraphIndex([index1])
 
1112
        idx1 = index.GraphIndex(trans, 'missing', 100)
 
1113
        idx = index.CombinedGraphIndex([idx1])
1078
1114
 
1079
1115
    def test_add_index(self):
1080
 
        index = CombinedGraphIndex([])
1081
 
        index1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1082
 
        index.insert_index(0, index1)
1083
 
        self.assertEqual([(index1, ('key', ), '')], list(index.iter_all_entries()))
 
1116
        idx = index.CombinedGraphIndex([])
 
1117
        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
 
1118
        idx.insert_index(0, idx1)
 
1119
        self.assertEqual([(idx1, ('key', ), '')],
 
1120
                         list(idx.iter_all_entries()))
1084
1121
 
1085
1122
    def test_clear_cache(self):
1086
1123
        log = []
1097
1134
                log.append(self._index)
1098
1135
                return self._index.clear_cache()
1099
1136
 
1100
 
        index = CombinedGraphIndex([])
1101
 
        index1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1102
 
        index.insert_index(0, ClearCacheProxy(index1))
1103
 
        index2 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1104
 
        index.insert_index(1, ClearCacheProxy(index2))
 
1137
        idx = index.CombinedGraphIndex([])
 
1138
        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
 
1139
        idx.insert_index(0, ClearCacheProxy(idx1))
 
1140
        idx2 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
 
1141
        idx.insert_index(1, ClearCacheProxy(idx2))
1105
1142
        # CombinedGraphIndex should call 'clear_cache()' on all children
1106
 
        index.clear_cache()
1107
 
        self.assertEqual(sorted([index1, index2]), sorted(log))
 
1143
        idx.clear_cache()
 
1144
        self.assertEqual(sorted([idx1, idx2]), sorted(log))
1108
1145
 
1109
1146
    def test_iter_all_entries_empty(self):
1110
 
        index = CombinedGraphIndex([])
1111
 
        self.assertEqual([], list(index.iter_all_entries()))
 
1147
        idx = index.CombinedGraphIndex([])
 
1148
        self.assertEqual([], list(idx.iter_all_entries()))
1112
1149
 
1113
1150
    def test_iter_all_entries_children_empty(self):
1114
 
        index1 = self.make_index('name')
1115
 
        index = CombinedGraphIndex([index1])
1116
 
        self.assertEqual([], list(index.iter_all_entries()))
 
1151
        idx1 = self.make_index('name')
 
1152
        idx = index.CombinedGraphIndex([idx1])
 
1153
        self.assertEqual([], list(idx.iter_all_entries()))
1117
1154
 
1118
1155
    def test_iter_all_entries_simple(self):
1119
 
        index1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
1120
 
        index = CombinedGraphIndex([index1])
1121
 
        self.assertEqual([(index1, ('name', ), 'data')],
1122
 
            list(index.iter_all_entries()))
 
1156
        idx1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
 
1157
        idx = index.CombinedGraphIndex([idx1])
 
1158
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1159
            list(idx.iter_all_entries()))
1123
1160
 
1124
1161
    def test_iter_all_entries_two_indices(self):
1125
 
        index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
1126
 
        index2 = self.make_index('name2', nodes=[(('2', ), '', ())])
1127
 
        index = CombinedGraphIndex([index1, index2])
1128
 
        self.assertEqual([(index1, ('name', ), 'data'),
1129
 
            (index2, ('2', ), '')],
1130
 
            list(index.iter_all_entries()))
 
1162
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1163
        idx2 = self.make_index('name2', nodes=[(('2', ), '', ())])
 
1164
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1165
        self.assertEqual([(idx1, ('name', ), 'data'),
 
1166
                          (idx2, ('2', ), '')],
 
1167
                         list(idx.iter_all_entries()))
1131
1168
 
1132
1169
    def test_iter_entries_two_indices_dup_key(self):
1133
 
        index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
1134
 
        index2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
1135
 
        index = CombinedGraphIndex([index1, index2])
1136
 
        self.assertEqual([(index1, ('name', ), 'data')],
1137
 
            list(index.iter_entries([('name', )])))
 
1170
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1171
        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
 
1172
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1173
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1174
                         list(idx.iter_entries([('name', )])))
1138
1175
 
1139
1176
    def test_iter_all_entries_two_indices_dup_key(self):
1140
 
        index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
1141
 
        index2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
1142
 
        index = CombinedGraphIndex([index1, index2])
1143
 
        self.assertEqual([(index1, ('name', ), 'data')],
1144
 
            list(index.iter_all_entries()))
 
1177
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1178
        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
 
1179
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1180
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1181
                         list(idx.iter_all_entries()))
1145
1182
 
1146
1183
    def test_iter_key_prefix_2_key_element_refs(self):
1147
 
        index1 = self.make_index('1', 1, key_elements=2, nodes=[
1148
 
            (('name', 'fin1'), 'data', ([('ref', 'erence')], ))])
1149
 
        index2 = self.make_index('2', 1, key_elements=2, nodes=[
1150
 
            (('name', 'fin2'), 'beta', ([], )),
1151
 
            (('ref', 'erence'), 'refdata', ([], ))])
1152
 
        index = CombinedGraphIndex([index1, index2])
1153
 
        self.assertEqual(set([(index1, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1154
 
            (index2, ('ref', 'erence'), 'refdata', ((), ))]),
1155
 
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1156
 
        self.assertEqual(set([(index1, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1157
 
            (index2, ('name', 'fin2'), 'beta', ((), ))]),
1158
 
            set(index.iter_entries_prefix([('name', None)])))
 
1184
        idx1 = self.make_index('1', 1, key_elements=2, nodes=[
 
1185
                (('name', 'fin1'), 'data', ([('ref', 'erence')], ))])
 
1186
        idx2 = self.make_index('2', 1, key_elements=2, nodes=[
 
1187
                (('name', 'fin2'), 'beta', ([], )),
 
1188
                (('ref', 'erence'), 'refdata', ([], ))])
 
1189
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1190
        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',
 
1191
                               ((('ref', 'erence'),),)),
 
1192
                              (idx2, ('ref', 'erence'), 'refdata', ((), ))]),
 
1193
                         set(idx.iter_entries_prefix([('name', 'fin1'),
 
1194
                                                        ('ref', 'erence')])))
 
1195
        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',
 
1196
                               ((('ref', 'erence'),),)),
 
1197
                              (idx2, ('name', 'fin2'), 'beta', ((), ))]),
 
1198
                         set(idx.iter_entries_prefix([('name', None)])))
1159
1199
 
1160
1200
    def test_iter_nothing_empty(self):
1161
 
        index = CombinedGraphIndex([])
1162
 
        self.assertEqual([], list(index.iter_entries([])))
 
1201
        idx = index.CombinedGraphIndex([])
 
1202
        self.assertEqual([], list(idx.iter_entries([])))
1163
1203
 
1164
1204
    def test_iter_nothing_children_empty(self):
1165
 
        index1 = self.make_index('name')
1166
 
        index = CombinedGraphIndex([index1])
1167
 
        self.assertEqual([], list(index.iter_entries([])))
 
1205
        idx1 = self.make_index('name')
 
1206
        idx = index.CombinedGraphIndex([idx1])
 
1207
        self.assertEqual([], list(idx.iter_entries([])))
1168
1208
 
1169
1209
    def test_iter_all_keys(self):
1170
 
        index1 = self.make_index('1', 1, nodes=[
1171
 
            (('name', ), 'data', ([('ref', )], ))])
1172
 
        index2 = self.make_index('2', 1, nodes=[
1173
 
            (('ref', ), 'refdata', ((), ))])
1174
 
        index = CombinedGraphIndex([index1, index2])
1175
 
        self.assertEqual(set([(index1, ('name', ), 'data', ((('ref', ), ), )),
1176
 
            (index2, ('ref', ), 'refdata', ((), ))]),
1177
 
            set(index.iter_entries([('name', ), ('ref', )])))
 
1210
        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
 
1211
                                               ([('ref', )], ))])
 
1212
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ((), ))])
 
1213
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1214
        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref', ), ), )),
 
1215
                              (idx2, ('ref', ), 'refdata', ((), ))]),
 
1216
                         set(idx.iter_entries([('name', ), ('ref', )])))
1178
1217
 
1179
1218
    def test_iter_all_keys_dup_entry(self):
1180
 
        index1 = self.make_index('1', 1, nodes=[
1181
 
            (('name', ), 'data', ([('ref', )], )),
1182
 
            (('ref', ), 'refdata', ([], ))])
1183
 
        index2 = self.make_index('2', 1, nodes=[
1184
 
            (('ref', ), 'refdata', ([], ))])
1185
 
        index = CombinedGraphIndex([index1, index2])
1186
 
        self.assertEqual(set([(index1, ('name', ), 'data', ((('ref',),),)),
1187
 
            (index1, ('ref', ), 'refdata', ((), ))]),
1188
 
            set(index.iter_entries([('name', ), ('ref', )])))
 
1219
        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
 
1220
                                                 ([('ref', )], )),
 
1221
                                                (('ref', ), 'refdata', ([], ))])
 
1222
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ([], ))])
 
1223
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1224
        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref',),),)),
 
1225
                              (idx1, ('ref', ), 'refdata', ((), ))]),
 
1226
                         set(idx.iter_entries([('name', ), ('ref', )])))
1189
1227
 
1190
1228
    def test_iter_missing_entry_empty(self):
1191
 
        index = CombinedGraphIndex([])
1192
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
1229
        idx = index.CombinedGraphIndex([])
 
1230
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1193
1231
 
1194
1232
    def test_iter_missing_entry_one_index(self):
1195
 
        index1 = self.make_index('1')
1196
 
        index = CombinedGraphIndex([index1])
1197
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
1233
        idx1 = self.make_index('1')
 
1234
        idx = index.CombinedGraphIndex([idx1])
 
1235
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1198
1236
 
1199
1237
    def test_iter_missing_entry_two_index(self):
1200
 
        index1 = self.make_index('1')
1201
 
        index2 = self.make_index('2')
1202
 
        index = CombinedGraphIndex([index1, index2])
1203
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
1238
        idx1 = self.make_index('1')
 
1239
        idx2 = self.make_index('2')
 
1240
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1241
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1204
1242
 
1205
1243
    def test_iter_entry_present_one_index_only(self):
1206
 
        index1 = self.make_index('1', nodes=[(('key', ), '', ())])
1207
 
        index2 = self.make_index('2', nodes=[])
1208
 
        index = CombinedGraphIndex([index1, index2])
1209
 
        self.assertEqual([(index1, ('key', ), '')],
1210
 
            list(index.iter_entries([('key', )])))
 
1244
        idx1 = self.make_index('1', nodes=[(('key', ), '', ())])
 
1245
        idx2 = self.make_index('2', nodes=[])
 
1246
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1247
        self.assertEqual([(idx1, ('key', ), '')],
 
1248
                         list(idx.iter_entries([('key', )])))
1211
1249
        # and in the other direction
1212
 
        index = CombinedGraphIndex([index2, index1])
1213
 
        self.assertEqual([(index1, ('key', ), '')],
1214
 
            list(index.iter_entries([('key', )])))
 
1250
        idx = index.CombinedGraphIndex([idx2, idx1])
 
1251
        self.assertEqual([(idx1, ('key', ), '')],
 
1252
                         list(idx.iter_entries([('key', )])))
1215
1253
 
1216
1254
    def test_key_count_empty(self):
1217
 
        index1 = self.make_index('1', nodes=[])
1218
 
        index2 = self.make_index('2', nodes=[])
1219
 
        index = CombinedGraphIndex([index1, index2])
1220
 
        self.assertEqual(0, index.key_count())
 
1255
        idx1 = self.make_index('1', nodes=[])
 
1256
        idx2 = self.make_index('2', nodes=[])
 
1257
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1258
        self.assertEqual(0, idx.key_count())
1221
1259
 
1222
1260
    def test_key_count_sums_index_keys(self):
1223
 
        index1 = self.make_index('1', nodes=[
 
1261
        idx1 = self.make_index('1', nodes=[
1224
1262
            (('1',), '', ()),
1225
1263
            (('2',), '', ())])
1226
 
        index2 = self.make_index('2', nodes=[(('1',), '', ())])
1227
 
        index = CombinedGraphIndex([index1, index2])
1228
 
        self.assertEqual(3, index.key_count())
 
1264
        idx2 = self.make_index('2', nodes=[(('1',), '', ())])
 
1265
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1266
        self.assertEqual(3, idx.key_count())
1229
1267
 
1230
1268
    def test_validate_bad_child_index_errors(self):
1231
1269
        trans = self.get_transport()
1232
1270
        trans.put_bytes('name', "not an index\n")
1233
 
        index1 = GraphIndex(trans, 'name', 13)
1234
 
        index = CombinedGraphIndex([index1])
1235
 
        self.assertRaises(errors.BadIndexFormatSignature, index.validate)
 
1271
        idx1 = index.GraphIndex(trans, 'name', 13)
 
1272
        idx = index.CombinedGraphIndex([idx1])
 
1273
        self.assertRaises(errors.BadIndexFormatSignature, idx.validate)
1236
1274
 
1237
1275
    def test_validate_empty(self):
1238
 
        index = CombinedGraphIndex([])
1239
 
        index.validate()
 
1276
        idx = index.CombinedGraphIndex([])
 
1277
        idx.validate()
1240
1278
 
1241
1279
    def test_key_count_reloads(self):
1242
 
        index, reload_counter = self.make_combined_index_with_missing()
1243
 
        self.assertEqual(2, index.key_count())
 
1280
        idx, reload_counter = self.make_combined_index_with_missing()
 
1281
        self.assertEqual(2, idx.key_count())
1244
1282
        self.assertEqual([1, 1, 0], reload_counter)
1245
1283
 
1246
1284
    def test_key_count_no_reload(self):
1247
 
        index, reload_counter = self.make_combined_index_with_missing()
1248
 
        index._reload_func = None
 
1285
        idx, reload_counter = self.make_combined_index_with_missing()
 
1286
        idx._reload_func = None
1249
1287
        # Without a _reload_func we just raise the exception
1250
 
        self.assertRaises(errors.NoSuchFile, index.key_count)
 
1288
        self.assertRaises(errors.NoSuchFile, idx.key_count)
1251
1289
 
1252
1290
    def test_key_count_reloads_and_fails(self):
1253
1291
        # We have deleted all underlying indexes, so we will try to reload, but
1254
1292
        # still fail. This is mostly to test we don't get stuck in an infinite
1255
1293
        # loop trying to reload
1256
 
        index, reload_counter = self.make_combined_index_with_missing(
1257
 
                                    ['1', '2', '3'])
1258
 
        self.assertRaises(errors.NoSuchFile, index.key_count)
 
1294
        idx, reload_counter = self.make_combined_index_with_missing(
 
1295
            ['1', '2', '3'])
 
1296
        self.assertRaises(errors.NoSuchFile, idx.key_count)
1259
1297
        self.assertEqual([2, 1, 1], reload_counter)
1260
1298
 
1261
1299
    def test_iter_entries_reloads(self):
1349
1387
        self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,
1350
1388
                                                 [('1',)])
1351
1389
 
 
1390
 
 
1391
    def make_index_with_simple_nodes(self, name, num_nodes=1):
 
1392
        """Make an index named after 'name', with keys named after 'name' too.
 
1393
 
 
1394
        Nodes will have a value of '' and no references.
 
1395
        """
 
1396
        nodes = [
 
1397
            (('index-%s-key-%s' % (name, n),), '', ())
 
1398
            for n in range(1, num_nodes+1)]
 
1399
        return self.make_index('index-%s' % name, 0, nodes=nodes)
 
1400
 
 
1401
    def test_reorder_after_iter_entries(self):
 
1402
        # Four indices: [key1] in idx1, [key2,key3] in idx2, [] in idx3,
 
1403
        # [key4] in idx4.
 
1404
        idx = index.CombinedGraphIndex([])
 
1405
        idx.insert_index(0, self.make_index_with_simple_nodes('1'), '1')
 
1406
        idx.insert_index(1, self.make_index_with_simple_nodes('2'), '2')
 
1407
        idx.insert_index(2, self.make_index_with_simple_nodes('3'), '3')
 
1408
        idx.insert_index(3, self.make_index_with_simple_nodes('4'), '4')
 
1409
        idx1, idx2, idx3, idx4 = idx._indices
 
1410
        # Query a key from idx4 and idx2.
 
1411
        self.assertLength(2, list(idx.iter_entries(
 
1412
            [('index-4-key-1',), ('index-2-key-1',)])))
 
1413
        # Now idx2 and idx4 should be moved to the front (and idx1 should
 
1414
        # still be before idx3).
 
1415
        self.assertEqual([idx2, idx4, idx1, idx3], idx._indices)
 
1416
        self.assertEqual(['2', '4', '1', '3'], idx._index_names)
 
1417
 
 
1418
    def test_reorder_propagates_to_siblings(self):
 
1419
        # Two CombinedGraphIndex objects, with the same number of indicies with
 
1420
        # matching names.
 
1421
        cgi1 = index.CombinedGraphIndex([])
 
1422
        cgi2 = index.CombinedGraphIndex([])
 
1423
        cgi1.insert_index(0, self.make_index_with_simple_nodes('1-1'), 'one')
 
1424
        cgi1.insert_index(1, self.make_index_with_simple_nodes('1-2'), 'two')
 
1425
        cgi2.insert_index(0, self.make_index_with_simple_nodes('2-1'), 'one')
 
1426
        cgi2.insert_index(1, self.make_index_with_simple_nodes('2-2'), 'two')
 
1427
        index2_1, index2_2 = cgi2._indices
 
1428
        cgi1.set_sibling_indices([cgi2])
 
1429
        # Trigger a reordering in cgi1.  cgi2 will be reordered as well.
 
1430
        list(cgi1.iter_entries([('index-1-2-key-1',)]))
 
1431
        self.assertEqual([index2_2, index2_1], cgi2._indices)
 
1432
        self.assertEqual(['two', 'one'], cgi2._index_names)
 
1433
 
1352
1434
    def test_validate_reloads(self):
1353
 
        index, reload_counter = self.make_combined_index_with_missing()
1354
 
        index.validate()
 
1435
        idx, reload_counter = self.make_combined_index_with_missing()
 
1436
        idx.validate()
1355
1437
        self.assertEqual([1, 1, 0], reload_counter)
1356
1438
 
1357
1439
    def test_validate_reloads_midway(self):
1358
 
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1359
 
        index.validate()
 
1440
        idx, reload_counter = self.make_combined_index_with_missing(['2'])
 
1441
        idx.validate()
1360
1442
 
1361
1443
    def test_validate_no_reload(self):
1362
 
        index, reload_counter = self.make_combined_index_with_missing()
1363
 
        index._reload_func = None
1364
 
        self.assertRaises(errors.NoSuchFile, index.validate)
 
1444
        idx, reload_counter = self.make_combined_index_with_missing()
 
1445
        idx._reload_func = None
 
1446
        self.assertRaises(errors.NoSuchFile, idx.validate)
1365
1447
 
1366
1448
    def test_validate_reloads_and_fails(self):
1367
 
        index, reload_counter = self.make_combined_index_with_missing(
1368
 
                                    ['1', '2', '3'])
1369
 
        self.assertRaises(errors.NoSuchFile, index.validate)
 
1449
        idx, reload_counter = self.make_combined_index_with_missing(
 
1450
            ['1', '2', '3'])
 
1451
        self.assertRaises(errors.NoSuchFile, idx.validate)
1370
1452
 
1371
1453
    def test_find_ancestors_across_indexes(self):
1372
1454
        key1 = ('key-1',)
1381
1463
            (key3, 'value', ([key2],)),
1382
1464
            (key4, 'value', ([key3],)),
1383
1465
            ])
1384
 
        c_index = CombinedGraphIndex([index1, index2])
 
1466
        c_index = index.CombinedGraphIndex([index1, index2])
1385
1467
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1386
1468
        self.assertEqual({key1: ()}, parent_map)
1387
1469
        self.assertEqual(set(), missing_keys)
1404
1486
        index2 = self.make_index('34', ref_lists=1, nodes=[
1405
1487
            (key3, 'value', ([key2],)),
1406
1488
            ])
1407
 
        c_index = CombinedGraphIndex([index1, index2])
 
1489
        c_index = index.CombinedGraphIndex([index1, index2])
1408
1490
        # Searching for a key which is actually not present at all should
1409
1491
        # eventually converge
1410
1492
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1412
1494
        self.assertEqual(set([key4]), missing_keys)
1413
1495
 
1414
1496
    def test_find_ancestors_no_indexes(self):
1415
 
        c_index = CombinedGraphIndex([])
 
1497
        c_index = index.CombinedGraphIndex([])
1416
1498
        key1 = ('key-1',)
1417
1499
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1418
1500
        self.assertEqual({}, parent_map)
1430
1512
        index2 = self.make_index('34', ref_lists=1, nodes=[
1431
1513
            (key4, 'value', ([key2, key3],)),
1432
1514
            ])
1433
 
        c_index = CombinedGraphIndex([index1, index2])
 
1515
        c_index = index.CombinedGraphIndex([index1, index2])
1434
1516
        # Searching for a key which is actually not present at all should
1435
1517
        # eventually converge
1436
1518
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1439
1521
        self.assertEqual(set([key3]), missing_keys)
1440
1522
 
1441
1523
    def test__find_ancestors_empty_index(self):
1442
 
        index = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
 
1524
        idx = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
1443
1525
        parent_map = {}
1444
1526
        missing_keys = set()
1445
 
        search_keys = index._find_ancestors([('one',), ('two',)], 0, parent_map,
1446
 
                                            missing_keys)
 
1527
        search_keys = idx._find_ancestors([('one',), ('two',)], 0, parent_map,
 
1528
                                          missing_keys)
1447
1529
        self.assertEqual(set(), search_keys)
1448
1530
        self.assertEqual({}, parent_map)
1449
1531
        self.assertEqual(set([('one',), ('two',)]), missing_keys)
1450
1532
 
1451
1533
 
1452
 
class TestInMemoryGraphIndex(TestCaseWithMemoryTransport):
 
1534
class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):
1453
1535
 
1454
1536
    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
1455
 
        result = InMemoryGraphIndex(ref_lists, key_elements=key_elements)
 
1537
        result = index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1456
1538
        result.add_nodes(nodes)
1457
1539
        return result
1458
1540
 
1579
1661
        index.validate()
1580
1662
 
1581
1663
 
1582
 
class TestGraphIndexPrefixAdapter(TestCaseWithMemoryTransport):
 
1664
class TestGraphIndexPrefixAdapter(tests.TestCaseWithMemoryTransport):
1583
1665
 
1584
 
    def make_index(self, ref_lists=1, key_elements=2, nodes=[], add_callback=False):
1585
 
        result = InMemoryGraphIndex(ref_lists, key_elements=key_elements)
 
1666
    def make_index(self, ref_lists=1, key_elements=2, nodes=[],
 
1667
                   add_callback=False):
 
1668
        result = index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1586
1669
        result.add_nodes(nodes)
1587
1670
        if add_callback:
1588
1671
            add_nodes_callback = result.add_nodes
1589
1672
        else:
1590
1673
            add_nodes_callback = None
1591
 
        adapter = GraphIndexPrefixAdapter(result, ('prefix', ), key_elements - 1,
 
1674
        adapter = index.GraphIndexPrefixAdapter(
 
1675
            result, ('prefix', ), key_elements - 1,
1592
1676
            add_nodes_callback=add_nodes_callback)
1593
1677
        return result, adapter
1594
1678
 
1595
1679
    def test_add_node(self):
1596
1680
        index, adapter = self.make_index(add_callback=True)
1597
1681
        adapter.add_node(('key',), 'value', ((('ref',),),))
1598
 
        self.assertEqual(set([(index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))]),
 
1682
        self.assertEqual(set([(index, ('prefix', 'key'), 'value',
 
1683
                               ((('prefix', 'ref'),),))]),
1599
1684
            set(index.iter_all_entries()))
1600
1685
 
1601
1686
    def test_add_nodes(self):
1611
1696
            set(index.iter_all_entries()))
1612
1697
 
1613
1698
    def test_construct(self):
1614
 
        index = InMemoryGraphIndex()
1615
 
        adapter = GraphIndexPrefixAdapter(index, ('prefix', ), 1)
 
1699
        idx = index.InMemoryGraphIndex()
 
1700
        adapter = index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1)
1616
1701
 
1617
1702
    def test_construct_with_callback(self):
1618
 
        index = InMemoryGraphIndex()
1619
 
        adapter = GraphIndexPrefixAdapter(index, ('prefix', ), 1, index.add_nodes)
 
1703
        idx = index.InMemoryGraphIndex()
 
1704
        adapter = index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1,
 
1705
                                                idx.add_nodes)
1620
1706
 
1621
1707
    def test_iter_all_entries_cross_prefix_map_errors(self):
1622
1708
        index, adapter = self.make_index(nodes=[