/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 breezy/tests/test_index.py

  • Committer: Jelmer Vernooij
  • Date: 2018-06-18 02:13:57 UTC
  • mto: (6973.12.2 python3-k)
  • mto: This revision was merged to the branch mainline in revision 7004.
  • Revision ID: jelmer@jelmer.uk-20180618021357-xz802zqfmrf7zv1z
More test fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/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 .. import (
 
20
    errors,
 
21
    tests,
 
22
    transport,
 
23
    )
 
24
from ..bzr import (
 
25
    index as _mod_index,
 
26
    )
 
27
 
 
28
 
 
29
class ErrorTests(tests.TestCase):
 
30
 
 
31
    def test_bad_index_format_signature(self):
 
32
        error = _mod_index.BadIndexFormatSignature("foo", "bar")
 
33
        self.assertEqual("foo is not an index of type bar.",
 
34
            str(error))
 
35
 
 
36
    def test_bad_index_data(self):
 
37
        error = _mod_index.BadIndexData("foo")
 
38
        self.assertEqual("Error in data for index foo.",
 
39
            str(error))
 
40
 
 
41
    def test_bad_index_duplicate_key(self):
 
42
        error = _mod_index.BadIndexDuplicateKey("foo", "bar")
 
43
        self.assertEqual("The key 'foo' is already in index 'bar'.",
 
44
            str(error))
 
45
 
 
46
    def test_bad_index_key(self):
 
47
        error = _mod_index.BadIndexKey("foo")
 
48
        self.assertEqual("The key 'foo' is not a valid key.",
 
49
            str(error))
 
50
 
 
51
    def test_bad_index_options(self):
 
52
        error = _mod_index.BadIndexOptions("foo")
 
53
        self.assertEqual("Could not parse options for index foo.",
 
54
            str(error))
 
55
 
 
56
    def test_bad_index_value(self):
 
57
        error = _mod_index.BadIndexValue("foo")
 
58
        self.assertEqual("The value 'foo' is not a valid value.",
 
59
            str(error))
 
60
 
 
61
 
 
62
class TestGraphIndexBuilder(tests.TestCaseWithMemoryTransport):
26
63
 
27
64
    def test_build_index_empty(self):
28
 
        builder = GraphIndexBuilder()
 
65
        builder = _mod_index.GraphIndexBuilder()
29
66
        stream = builder.finish()
30
67
        contents = stream.read()
31
68
        self.assertEqual(
33
70
            contents)
34
71
 
35
72
    def test_build_index_empty_two_element_keys(self):
36
 
        builder = GraphIndexBuilder(key_elements=2)
 
73
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
37
74
        stream = builder.finish()
38
75
        contents = stream.read()
39
76
        self.assertEqual(
41
78
            contents)
42
79
 
43
80
    def test_build_index_one_reference_list_empty(self):
44
 
        builder = GraphIndexBuilder(reference_lists=1)
 
81
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
45
82
        stream = builder.finish()
46
83
        contents = stream.read()
47
84
        self.assertEqual(
49
86
            contents)
50
87
 
51
88
    def test_build_index_two_reference_list_empty(self):
52
 
        builder = GraphIndexBuilder(reference_lists=2)
 
89
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
53
90
        stream = builder.finish()
54
91
        contents = stream.read()
55
92
        self.assertEqual(
57
94
            contents)
58
95
 
59
96
    def test_build_index_one_node_no_refs(self):
60
 
        builder = GraphIndexBuilder()
 
97
        builder = _mod_index.GraphIndexBuilder()
61
98
        builder.add_node(('akey', ), 'data')
62
99
        stream = builder.finish()
63
100
        contents = stream.read()
66
103
            "akey\x00\x00\x00data\n\n", contents)
67
104
 
68
105
    def test_build_index_one_node_no_refs_accepts_empty_reflist(self):
69
 
        builder = GraphIndexBuilder()
 
106
        builder = _mod_index.GraphIndexBuilder()
70
107
        builder.add_node(('akey', ), 'data', ())
71
108
        stream = builder.finish()
72
109
        contents = stream.read()
78
115
        # multipart keys are separated by \x00 - because they are fixed length,
79
116
        # not variable this does not cause any issues, and seems clearer to the
80
117
        # author.
81
 
        builder = GraphIndexBuilder(key_elements=2)
 
118
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
82
119
        builder.add_node(('akey', 'secondpart'), 'data')
83
120
        stream = builder.finish()
84
121
        contents = stream.read()
87
124
            "akey\x00secondpart\x00\x00\x00data\n\n", contents)
88
125
 
89
126
    def test_add_node_empty_value(self):
90
 
        builder = GraphIndexBuilder()
 
127
        builder = _mod_index.GraphIndexBuilder()
91
128
        builder.add_node(('akey', ), '')
92
129
        stream = builder.finish()
93
130
        contents = stream.read()
97
134
 
98
135
    def test_build_index_nodes_sorted(self):
99
136
        # the highest sorted node comes first.
100
 
        builder = GraphIndexBuilder()
 
137
        builder = _mod_index.GraphIndexBuilder()
101
138
        # use three to have a good chance of glitching dictionary hash
102
139
        # lookups etc. Insert in randomish order that is not correct
103
140
        # and not the reverse of the correct order.
115
152
 
116
153
    def test_build_index_2_element_key_nodes_sorted(self):
117
154
        # multiple element keys are sorted first-key, second-key.
118
 
        builder = GraphIndexBuilder(key_elements=2)
 
155
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
119
156
        # use three values of each key element, to have a good chance of
120
157
        # glitching dictionary hash lookups etc. Insert in randomish order that
121
158
        # is not correct and not the reverse of the correct order.
144
181
            "\n", contents)
145
182
 
146
183
    def test_build_index_reference_lists_are_included_one(self):
147
 
        builder = GraphIndexBuilder(reference_lists=1)
 
184
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
148
185
        builder.add_node(('key', ), 'data', ([], ))
149
186
        stream = builder.finish()
150
187
        contents = stream.read()
154
191
            "\n", contents)
155
192
 
156
193
    def test_build_index_reference_lists_with_2_element_keys(self):
157
 
        builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
 
194
        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
158
195
        builder.add_node(('key', 'key2'), 'data', ([], ))
159
196
        stream = builder.finish()
160
197
        contents = stream.read()
164
201
            "\n", contents)
165
202
 
166
203
    def test_build_index_reference_lists_are_included_two(self):
167
 
        builder = GraphIndexBuilder(reference_lists=2)
 
204
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
168
205
        builder.add_node(('key', ), 'data', ([], []))
169
206
        stream = builder.finish()
170
207
        contents = stream.read()
174
211
            "\n", contents)
175
212
 
176
213
    def test_clear_cache(self):
177
 
        builder = GraphIndexBuilder(reference_lists=2)
 
214
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
178
215
        # This is a no-op, but the api should exist
179
216
        builder.clear_cache()
180
217
 
181
218
    def test_node_references_are_byte_offsets(self):
182
 
        builder = GraphIndexBuilder(reference_lists=1)
 
219
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
183
220
        builder.add_node(('reference', ), 'data', ([], ))
184
221
        builder.add_node(('key', ), 'data', ([('reference', )], ))
185
222
        stream = builder.finish()
191
228
            "\n", contents)
192
229
 
193
230
    def test_node_references_are_cr_delimited(self):
194
 
        builder = GraphIndexBuilder(reference_lists=1)
 
231
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
195
232
        builder.add_node(('reference', ), 'data', ([], ))
196
233
        builder.add_node(('reference2', ), 'data', ([], ))
197
 
        builder.add_node(('key', ), 'data', ([('reference', ), ('reference2', )], ))
 
234
        builder.add_node(('key', ), 'data',
 
235
                         ([('reference', ), ('reference2', )], ))
198
236
        stream = builder.finish()
199
237
        contents = stream.read()
200
238
        self.assertEqual(
205
243
            "\n", contents)
206
244
 
207
245
    def test_multiple_reference_lists_are_tab_delimited(self):
208
 
        builder = GraphIndexBuilder(reference_lists=2)
 
246
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
209
247
        builder.add_node(('keference', ), 'data', ([], []))
210
 
        builder.add_node(('rey', ), 'data', ([('keference', )], [('keference', )]))
 
248
        builder.add_node(('rey', ), 'data',
 
249
                         ([('keference', )], [('keference', )]))
211
250
        stream = builder.finish()
212
251
        contents = stream.read()
213
252
        self.assertEqual(
217
256
            "\n", contents)
218
257
 
219
258
    def test_add_node_referencing_missing_key_makes_absent(self):
220
 
        builder = GraphIndexBuilder(reference_lists=1)
221
 
        builder.add_node(('rey', ), 'data', ([('beference', ), ('aeference2', )], ))
 
259
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
 
260
        builder.add_node(('rey', ), 'data',
 
261
                         ([('beference', ), ('aeference2', )], ))
222
262
        stream = builder.finish()
223
263
        contents = stream.read()
224
264
        self.assertEqual(
230
270
 
231
271
    def test_node_references_three_digits(self):
232
272
        # test the node digit expands as needed.
233
 
        builder = GraphIndexBuilder(reference_lists=1)
234
 
        references = [(str(val), ) for val in reversed(range(9))]
 
273
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
 
274
        references = [(str(val), ) for val in range(8, -1, -1)]
235
275
        builder.add_node(('2-key', ), '', (references, ))
236
276
        stream = builder.finish()
237
277
        contents = stream.read()
252
292
    def test_absent_has_no_reference_overhead(self):
253
293
        # the offsets after an absent record should be correct when there are
254
294
        # >1 reference lists.
255
 
        builder = GraphIndexBuilder(reference_lists=2)
 
295
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
256
296
        builder.add_node(('parent', ), '', ([('aail', ), ('zther', )], []))
257
297
        stream = builder.finish()
258
298
        contents = stream.read()
264
304
            "\n", contents)
265
305
 
266
306
    def test_add_node_bad_key(self):
267
 
        builder = GraphIndexBuilder()
 
307
        builder = _mod_index.GraphIndexBuilder()
268
308
        for bad_char in '\t\n\x0b\x0c\r\x00 ':
269
 
            self.assertRaises(errors.BadIndexKey, builder.add_node,
 
309
            self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
270
310
                ('a%skey' % bad_char, ), 'data')
271
 
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
311
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
272
312
                ('', ), 'data')
273
 
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
313
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
274
314
                'not-a-tuple', 'data')
275
315
        # not enough length
276
 
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
316
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
277
317
                (), 'data')
278
318
        # too long
279
 
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
319
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
280
320
                ('primary', 'secondary'), 'data')
281
321
        # secondary key elements get checked too:
282
 
        builder = GraphIndexBuilder(key_elements=2)
 
322
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
283
323
        for bad_char in '\t\n\x0b\x0c\r\x00 ':
284
 
            self.assertRaises(errors.BadIndexKey, builder.add_node,
 
324
            self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
285
325
                ('prefix', 'a%skey' % bad_char), 'data')
286
326
 
287
327
    def test_add_node_bad_data(self):
288
 
        builder = GraphIndexBuilder()
289
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
328
        builder = _mod_index.GraphIndexBuilder()
 
329
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
290
330
            'data\naa')
291
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
331
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
292
332
            'data\x00aa')
293
333
 
294
334
    def test_add_node_bad_mismatched_ref_lists_length(self):
295
 
        builder = GraphIndexBuilder()
296
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
335
        builder = _mod_index.GraphIndexBuilder()
 
336
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
297
337
            'data aa', ([], ))
298
 
        builder = GraphIndexBuilder(reference_lists=1)
299
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
338
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
 
339
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
300
340
            'data aa')
301
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
341
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
302
342
            'data aa', (), )
303
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
343
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
304
344
            'data aa', ([], []))
305
 
        builder = GraphIndexBuilder(reference_lists=2)
306
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
345
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
 
346
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
307
347
            'data aa')
308
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
348
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
309
349
            'data aa', ([], ))
310
 
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
350
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
311
351
            'data aa', ([], [], []))
312
352
 
313
353
    def test_add_node_bad_key_in_reference_lists(self):
314
354
        # first list, first key - trivial
315
 
        builder = GraphIndexBuilder(reference_lists=1)
316
 
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
355
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
 
356
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
317
357
            'data aa', ([('a key', )], ))
318
358
        # references keys must be tuples too
319
 
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
359
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
320
360
            'data aa', (['not-a-tuple'], ))
321
361
        # not enough length
322
 
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
362
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
323
363
            'data aa', ([()], ))
324
364
        # too long
325
 
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
365
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
326
366
            'data aa', ([('primary', 'secondary')], ))
327
367
        # need to check more than the first key in the list
328
 
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
368
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
329
369
            'data aa', ([('agoodkey', ), ('that is a bad key', )], ))
330
370
        # and if there is more than one list it should be getting checked
331
371
        # too
332
 
        builder = GraphIndexBuilder(reference_lists=2)
333
 
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
372
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
 
373
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
334
374
            'data aa', ([], ['a bad key']))
335
375
 
336
376
    def test_add_duplicate_key(self):
337
 
        builder = GraphIndexBuilder()
 
377
        builder = _mod_index.GraphIndexBuilder()
338
378
        builder.add_node(('key', ), 'data')
339
 
        self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node, ('key', ),
340
 
            'data')
 
379
        self.assertRaises(_mod_index.BadIndexDuplicateKey,
 
380
                          builder.add_node, ('key', ), 'data')
341
381
 
342
382
    def test_add_duplicate_key_2_elements(self):
343
 
        builder = GraphIndexBuilder(key_elements=2)
 
383
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
344
384
        builder.add_node(('key', 'key'), 'data')
345
 
        self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node,
 
385
        self.assertRaises(_mod_index.BadIndexDuplicateKey, builder.add_node,
346
386
            ('key', 'key'), 'data')
347
387
 
348
388
    def test_add_key_after_referencing_key(self):
349
 
        builder = GraphIndexBuilder(reference_lists=1)
 
389
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
350
390
        builder.add_node(('key', ), 'data', ([('reference', )], ))
351
391
        builder.add_node(('reference', ), 'data', ([],))
352
392
 
353
393
    def test_add_key_after_referencing_key_2_elements(self):
354
 
        builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
 
394
        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
355
395
        builder.add_node(('k', 'ey'), 'data', ([('reference', 'tokey')], ))
356
396
        builder.add_node(('reference', 'tokey'), 'data', ([],))
357
397
 
358
398
    def test_set_optimize(self):
359
 
        builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
 
399
        builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
360
400
        builder.set_optimize(for_size=True)
361
401
        self.assertTrue(builder._optimize_for_size)
362
402
        builder.set_optimize(for_size=False)
363
403
        self.assertFalse(builder._optimize_for_size)
364
404
 
365
405
 
366
 
class TestGraphIndex(TestCaseWithMemoryTransport):
 
406
class TestGraphIndex(tests.TestCaseWithMemoryTransport):
367
407
 
368
408
    def make_key(self, number):
369
409
        return (str(number) + 'X'*100,)
380
420
        return nodes
381
421
 
382
422
    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
383
 
        builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
 
423
        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
384
424
        for key, value, references in nodes:
385
425
            builder.add_node(key, value, references)
386
426
        stream = builder.finish()
387
 
        trans = get_transport('trace+' + self.get_url())
 
427
        trans = transport.get_transport_from_url('trace+' + self.get_url())
388
428
        size = trans.put_file('index', stream)
389
 
        return GraphIndex(trans, 'index', size)
 
429
        return _mod_index.GraphIndex(trans, 'index', size)
390
430
 
391
431
    def make_index_with_offset(self, ref_lists=0, key_elements=1, nodes=[],
392
432
                               offset=0):
393
 
        builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
 
433
        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
394
434
        for key, value, references in nodes:
395
435
            builder.add_node(key, value, references)
396
436
        content = builder.finish().read()
397
437
        size = len(content)
398
438
        trans = self.get_transport()
399
439
        trans.put_bytes('index', (' '*offset) + content)
400
 
        return GraphIndex(trans, 'index', size, offset=offset)
 
440
        return _mod_index.GraphIndex(trans, 'index', size, offset=offset)
401
441
 
402
442
    def test_clear_cache(self):
403
443
        index = self.make_index()
408
448
    def test_open_bad_index_no_error(self):
409
449
        trans = self.get_transport()
410
450
        trans.put_bytes('name', "not an index\n")
411
 
        index = GraphIndex(trans, 'name', 13)
 
451
        idx = _mod_index.GraphIndex(trans, 'name', 13)
412
452
 
413
453
    def test_with_offset(self):
414
454
        nodes = self.make_nodes(200)
415
 
        index = self.make_index_with_offset(offset=1234567, nodes=nodes)
416
 
        self.assertEqual(200, index.key_count())
 
455
        idx = self.make_index_with_offset(offset=1234567, nodes=nodes)
 
456
        self.assertEqual(200, idx.key_count())
417
457
 
418
458
    def test_buffer_all_with_offset(self):
419
459
        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())
 
460
        idx = self.make_index_with_offset(offset=1234567, nodes=nodes)
 
461
        idx._buffer_all()
 
462
        self.assertEqual(200, idx.key_count())
423
463
 
424
464
    def test_side_effect_buffering_with_offset(self):
425
465
        nodes = self.make_nodes(20)
733
773
        index = self.make_index(1, nodes=[
734
774
            (('name', ), 'data', ([('ref', )], )),
735
775
            (('ref', ), 'refdata', ([], ))])
736
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
737
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
776
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
777
            (index, ('ref', ), 'refdata', ((), ))},
738
778
            set(index.iter_all_entries()))
739
779
 
740
780
    def test_iter_entries_buffers_once(self):
741
781
        index = self.make_index(nodes=self.make_nodes(2))
742
782
        # reset the transport log
743
783
        del index._transport._activity[:]
744
 
        self.assertEqual(set([(index, self.make_key(1), self.make_value(1))]),
 
784
        self.assertEqual({(index, self.make_key(1), self.make_value(1))},
745
785
                         set(index.iter_entries([self.make_key(1)])))
746
786
        # We should have requested reading the header bytes
747
787
        # But not needed any more than that because it would have triggered a
783
823
        index = self.make_index(1, nodes=[
784
824
            (('name', ), 'data', ([('ref', ), ('ref', )], )),
785
825
            (('ref', ), 'refdata', ([], ))])
786
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),('ref',)),)),
787
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
826
        self.assertEqual({(index, ('name', ), 'data', ((('ref',), ('ref',)),)),
 
827
            (index, ('ref', ), 'refdata', ((), ))},
788
828
            set(index.iter_entries([('name',), ('ref',)])))
789
829
 
790
830
    def test_iter_entries_references_2_refs_resolved(self):
791
831
        index = self.make_index(2, nodes=[
792
832
            (('name', ), 'data', ([('ref', )], [('ref', )])),
793
833
            (('ref', ), 'refdata', ([], []))])
794
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),), (('ref',),))),
795
 
            (index, ('ref', ), 'refdata', ((), ()))]),
 
834
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),), (('ref',),))),
 
835
            (index, ('ref', ), 'refdata', ((), ()))},
796
836
            set(index.iter_entries([('name',), ('ref',)])))
797
837
 
798
838
    def test_iteration_absent_skipped(self):
799
839
        index = self.make_index(1, nodes=[
800
840
            (('name', ), 'data', ([('ref', )], ))])
801
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
841
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
802
842
            set(index.iter_all_entries()))
803
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
843
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
804
844
            set(index.iter_entries([('name', )])))
805
845
        self.assertEqual([], list(index.iter_entries([('ref', )])))
806
846
 
807
847
    def test_iteration_absent_skipped_2_element_keys(self):
808
848
        index = self.make_index(1, key_elements=2, nodes=[
809
849
            (('name', 'fin'), 'data', ([('ref', 'erence')], ))])
810
 
        self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
 
850
        self.assertEqual({(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))},
811
851
            set(index.iter_all_entries()))
812
 
        self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
 
852
        self.assertEqual({(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))},
813
853
            set(index.iter_entries([('name', 'fin')])))
814
854
        self.assertEqual([], list(index.iter_entries([('ref', 'erence')])))
815
855
 
817
857
        index = self.make_index(1, nodes=[
818
858
            (('name', ), 'data', ([('ref', )], )),
819
859
            (('ref', ), 'refdata', ([], ))])
820
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
821
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
860
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
861
            (index, ('ref', ), 'refdata', ((), ))},
822
862
            set(index.iter_entries([('name', ), ('ref', )])))
823
863
 
824
864
    def test_iter_nothing_empty(self):
830
870
        self.assertEqual([], list(index.iter_entries([('a', )])))
831
871
 
832
872
    def test_iter_missing_entry_empty_no_size(self):
833
 
        index = self.make_index()
834
 
        index = GraphIndex(index._transport, 'index', None)
835
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
873
        idx = self.make_index()
 
874
        idx = _mod_index.GraphIndex(idx._transport, 'index', None)
 
875
        self.assertEqual([], list(idx.iter_entries([('a', )])))
836
876
 
837
877
    def test_iter_key_prefix_1_element_key_None(self):
838
878
        index = self.make_index()
839
 
        self.assertRaises(errors.BadIndexKey, list,
 
879
        self.assertRaises(_mod_index.BadIndexKey, list,
840
880
            index.iter_entries_prefix([(None, )]))
841
881
 
842
882
    def test_iter_key_prefix_wrong_length(self):
843
883
        index = self.make_index()
844
 
        self.assertRaises(errors.BadIndexKey, list,
 
884
        self.assertRaises(_mod_index.BadIndexKey, list,
845
885
            index.iter_entries_prefix([('foo', None)]))
846
886
        index = self.make_index(key_elements=2)
847
 
        self.assertRaises(errors.BadIndexKey, list,
 
887
        self.assertRaises(_mod_index.BadIndexKey, list,
848
888
            index.iter_entries_prefix([('foo', )]))
849
 
        self.assertRaises(errors.BadIndexKey, list,
 
889
        self.assertRaises(_mod_index.BadIndexKey, list,
850
890
            index.iter_entries_prefix([('foo', None, None)]))
851
891
 
852
892
    def test_iter_key_prefix_1_key_element_no_refs(self):
853
893
        index = self.make_index( nodes=[
854
894
            (('name', ), 'data', ()),
855
895
            (('ref', ), 'refdata', ())])
856
 
        self.assertEqual(set([(index, ('name', ), 'data'),
857
 
            (index, ('ref', ), 'refdata')]),
 
896
        self.assertEqual({(index, ('name', ), 'data'),
 
897
            (index, ('ref', ), 'refdata')},
858
898
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
859
899
 
860
900
    def test_iter_key_prefix_1_key_element_refs(self):
861
901
        index = self.make_index(1, nodes=[
862
902
            (('name', ), 'data', ([('ref', )], )),
863
903
            (('ref', ), 'refdata', ([], ))])
864
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
865
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
904
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
905
            (index, ('ref', ), 'refdata', ((), ))},
866
906
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
867
907
 
868
908
    def test_iter_key_prefix_2_key_element_no_refs(self):
870
910
            (('name', 'fin1'), 'data', ()),
871
911
            (('name', 'fin2'), 'beta', ()),
872
912
            (('ref', 'erence'), 'refdata', ())])
873
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
874
 
            (index, ('ref', 'erence'), 'refdata')]),
 
913
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
914
            (index, ('ref', 'erence'), 'refdata')},
875
915
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
876
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
877
 
            (index, ('name', 'fin2'), 'beta')]),
 
916
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
917
            (index, ('name', 'fin2'), 'beta')},
878
918
            set(index.iter_entries_prefix([('name', None)])))
879
919
 
880
920
    def test_iter_key_prefix_2_key_element_refs(self):
882
922
            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
883
923
            (('name', 'fin2'), 'beta', ([], )),
884
924
            (('ref', 'erence'), 'refdata', ([], ))])
885
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
886
 
            (index, ('ref', 'erence'), 'refdata', ((), ))]),
 
925
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
926
            (index, ('ref', 'erence'), 'refdata', ((), ))},
887
927
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
888
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
889
 
            (index, ('name', 'fin2'), 'beta', ((), ))]),
 
928
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
929
            (index, ('name', 'fin2'), 'beta', ((), ))},
890
930
            set(index.iter_entries_prefix([('name', None)])))
891
931
 
892
932
    def test_key_count_empty(self):
928
968
    def test_validate_bad_index_errors(self):
929
969
        trans = self.get_transport()
930
970
        trans.put_bytes('name', "not an index\n")
931
 
        index = GraphIndex(trans, 'name', 13)
932
 
        self.assertRaises(errors.BadIndexFormatSignature, index.validate)
 
971
        idx = _mod_index.GraphIndex(trans, 'name', 13)
 
972
        self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
933
973
 
934
974
    def test_validate_bad_node_refs(self):
935
 
        index = self.make_index(2)
 
975
        idx = self.make_index(2)
936
976
        trans = self.get_transport()
937
977
        content = trans.get_bytes('index')
938
978
        # change the options line to end with a rather than a parseable number
939
979
        new_content = content[:-2] + 'a\n\n'
940
980
        trans.put_bytes('index', new_content)
941
 
        self.assertRaises(errors.BadIndexOptions, index.validate)
 
981
        self.assertRaises(_mod_index.BadIndexOptions, idx.validate)
942
982
 
943
983
    def test_validate_missing_end_line_empty(self):
944
984
        index = self.make_index(2)
946
986
        content = trans.get_bytes('index')
947
987
        # truncate the last byte
948
988
        trans.put_bytes('index', content[:-1])
949
 
        self.assertRaises(errors.BadIndexData, index.validate)
 
989
        self.assertRaises(_mod_index.BadIndexData, index.validate)
950
990
 
951
991
    def test_validate_missing_end_line_nonempty(self):
952
992
        index = self.make_index(2, nodes=[(('key', ), '', ([], []))])
954
994
        content = trans.get_bytes('index')
955
995
        # truncate the last byte
956
996
        trans.put_bytes('index', content[:-1])
957
 
        self.assertRaises(errors.BadIndexData, index.validate)
 
997
        self.assertRaises(_mod_index.BadIndexData, index.validate)
958
998
 
959
999
    def test_validate_empty(self):
960
1000
        index = self.make_index()
979
1019
        missing_key = ('missing',)
980
1020
        index = self.make_index(ref_lists=1, nodes=[
981
1021
            (('key',), 'value', ([missing_key],))])
982
 
        self.assertEqual(set([missing_key]), index.external_references(0))
 
1022
        self.assertEqual({missing_key}, index.external_references(0))
983
1023
 
984
1024
    def test_external_references_multiple_ref_lists(self):
985
1025
        missing_key = ('missing',)
986
1026
        index = self.make_index(ref_lists=2, nodes=[
987
1027
            (('key',), 'value', ([], [missing_key]))])
988
1028
        self.assertEqual(set([]), index.external_references(0))
989
 
        self.assertEqual(set([missing_key]), index.external_references(1))
 
1029
        self.assertEqual({missing_key}, index.external_references(1))
990
1030
 
991
1031
    def test_external_references_two_records(self):
992
1032
        index = self.make_index(ref_lists=1, nodes=[
1007
1047
        search_keys = index._find_ancestors([key1], 0, parent_map, missing_keys)
1008
1048
        self.assertEqual({key1: (key2,)}, parent_map)
1009
1049
        self.assertEqual(set(), missing_keys)
1010
 
        self.assertEqual(set([key2]), search_keys)
 
1050
        self.assertEqual({key2}, search_keys)
1011
1051
        search_keys = index._find_ancestors(search_keys, 0, parent_map,
1012
1052
                                            missing_keys)
1013
1053
        self.assertEqual({key1: (key2,), key2: ()}, parent_map)
1027
1067
        search_keys = index._find_ancestors([key2, key3], 0, parent_map,
1028
1068
                                            missing_keys)
1029
1069
        self.assertEqual({key2: ()}, parent_map)
1030
 
        self.assertEqual(set([key3]), missing_keys)
 
1070
        self.assertEqual({key3}, missing_keys)
1031
1071
        self.assertEqual(set(), search_keys)
1032
1072
 
1033
1073
    def test__find_ancestors_dont_search_known(self):
1049
1089
        self.assertEqual(set(), search_keys)
1050
1090
 
1051
1091
    def test_supports_unlimited_cache(self):
1052
 
        builder = GraphIndexBuilder(0, key_elements=1)
 
1092
        builder = _mod_index.GraphIndexBuilder(0, key_elements=1)
1053
1093
        stream = builder.finish()
1054
 
        trans = get_transport(self.get_url())
 
1094
        trans = self.get_transport()
1055
1095
        size = trans.put_file('index', stream)
1056
1096
        # It doesn't matter what unlimited_cache does here, just that it can be
1057
1097
        # passed
1058
 
        index = GraphIndex(trans, 'index', size, unlimited_cache=True)
1059
 
 
1060
 
 
1061
 
class TestCombinedGraphIndex(TestCaseWithMemoryTransport):
 
1098
        idx = _mod_index.GraphIndex(trans, 'index', size, unlimited_cache=True)
 
1099
 
 
1100
 
 
1101
class TestCombinedGraphIndex(tests.TestCaseWithMemoryTransport):
1062
1102
 
1063
1103
    def make_index(self, name, ref_lists=0, key_elements=1, nodes=[]):
1064
 
        builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
 
1104
        builder = _mod_index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
1065
1105
        for key, value, references in nodes:
1066
1106
            builder.add_node(key, value, references)
1067
1107
        stream = builder.finish()
1068
1108
        trans = self.get_transport()
1069
1109
        size = trans.put_file(name, stream)
1070
 
        return GraphIndex(trans, name, size)
 
1110
        return _mod_index.GraphIndex(trans, name, size)
1071
1111
 
1072
1112
    def make_combined_index_with_missing(self, missing=['1', '2']):
1073
1113
        """Create a CombinedGraphIndex which will have missing indexes.
1079
1119
        :param missing: The underlying indexes to delete
1080
1120
        :return: (CombinedGraphIndex, reload_counter)
1081
1121
        """
1082
 
        index1 = self.make_index('1', nodes=[(('1',), '', ())])
1083
 
        index2 = self.make_index('2', nodes=[(('2',), '', ())])
1084
 
        index3 = self.make_index('3', nodes=[
 
1122
        idx1 = self.make_index('1', nodes=[(('1',), '', ())])
 
1123
        idx2 = self.make_index('2', nodes=[(('2',), '', ())])
 
1124
        idx3 = self.make_index('3', nodes=[
1085
1125
            (('1',), '', ()),
1086
1126
            (('2',), '', ())])
1087
1127
 
1089
1129
        reload_counter = [0, 0, 0]
1090
1130
        def reload():
1091
1131
            reload_counter[0] += 1
1092
 
            new_indices = [index3]
1093
 
            if index._indices == new_indices:
 
1132
            new_indices = [idx3]
 
1133
            if idx._indices == new_indices:
1094
1134
                reload_counter[2] += 1
1095
1135
                return False
1096
1136
            reload_counter[1] += 1
1097
 
            index._indices[:] = new_indices
 
1137
            idx._indices[:] = new_indices
1098
1138
            return True
1099
 
        index = CombinedGraphIndex([index1, index2], reload_func=reload)
 
1139
        idx = _mod_index.CombinedGraphIndex([idx1, idx2], reload_func=reload)
1100
1140
        trans = self.get_transport()
1101
1141
        for fname in missing:
1102
1142
            trans.delete(fname)
1103
 
        return index, reload_counter
 
1143
        return idx, reload_counter
1104
1144
 
1105
1145
    def test_open_missing_index_no_error(self):
1106
1146
        trans = self.get_transport()
1107
 
        index1 = GraphIndex(trans, 'missing', 100)
1108
 
        index = CombinedGraphIndex([index1])
 
1147
        idx1 = _mod_index.GraphIndex(trans, 'missing', 100)
 
1148
        idx = _mod_index.CombinedGraphIndex([idx1])
1109
1149
 
1110
1150
    def test_add_index(self):
1111
 
        index = CombinedGraphIndex([])
1112
 
        index1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1113
 
        index.insert_index(0, index1)
1114
 
        self.assertEqual([(index1, ('key', ), '')], list(index.iter_all_entries()))
 
1151
        idx = _mod_index.CombinedGraphIndex([])
 
1152
        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
 
1153
        idx.insert_index(0, idx1)
 
1154
        self.assertEqual([(idx1, ('key', ), '')],
 
1155
                         list(idx.iter_all_entries()))
1115
1156
 
1116
1157
    def test_clear_cache(self):
1117
1158
        log = []
1128
1169
                log.append(self._index)
1129
1170
                return self._index.clear_cache()
1130
1171
 
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))
 
1172
        idx = _mod_index.CombinedGraphIndex([])
 
1173
        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
 
1174
        idx.insert_index(0, ClearCacheProxy(idx1))
 
1175
        idx2 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
 
1176
        idx.insert_index(1, ClearCacheProxy(idx2))
1136
1177
        # CombinedGraphIndex should call 'clear_cache()' on all children
1137
 
        index.clear_cache()
1138
 
        self.assertEqual(sorted([index1, index2]), sorted(log))
 
1178
        idx.clear_cache()
 
1179
        self.assertEqual(sorted([idx1, idx2]), sorted(log))
1139
1180
 
1140
1181
    def test_iter_all_entries_empty(self):
1141
 
        index = CombinedGraphIndex([])
1142
 
        self.assertEqual([], list(index.iter_all_entries()))
 
1182
        idx = _mod_index.CombinedGraphIndex([])
 
1183
        self.assertEqual([], list(idx.iter_all_entries()))
1143
1184
 
1144
1185
    def test_iter_all_entries_children_empty(self):
1145
 
        index1 = self.make_index('name')
1146
 
        index = CombinedGraphIndex([index1])
1147
 
        self.assertEqual([], list(index.iter_all_entries()))
 
1186
        idx1 = self.make_index('name')
 
1187
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1188
        self.assertEqual([], list(idx.iter_all_entries()))
1148
1189
 
1149
1190
    def test_iter_all_entries_simple(self):
1150
 
        index1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
1151
 
        index = CombinedGraphIndex([index1])
1152
 
        self.assertEqual([(index1, ('name', ), 'data')],
1153
 
            list(index.iter_all_entries()))
 
1191
        idx1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
 
1192
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1193
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1194
            list(idx.iter_all_entries()))
1154
1195
 
1155
1196
    def test_iter_all_entries_two_indices(self):
1156
 
        index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
1157
 
        index2 = self.make_index('name2', nodes=[(('2', ), '', ())])
1158
 
        index = CombinedGraphIndex([index1, index2])
1159
 
        self.assertEqual([(index1, ('name', ), 'data'),
1160
 
            (index2, ('2', ), '')],
1161
 
            list(index.iter_all_entries()))
 
1197
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1198
        idx2 = self.make_index('name2', nodes=[(('2', ), '', ())])
 
1199
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1200
        self.assertEqual([(idx1, ('name', ), 'data'),
 
1201
                          (idx2, ('2', ), '')],
 
1202
                         list(idx.iter_all_entries()))
1162
1203
 
1163
1204
    def test_iter_entries_two_indices_dup_key(self):
1164
 
        index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
1165
 
        index2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
1166
 
        index = CombinedGraphIndex([index1, index2])
1167
 
        self.assertEqual([(index1, ('name', ), 'data')],
1168
 
            list(index.iter_entries([('name', )])))
 
1205
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1206
        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
 
1207
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1208
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1209
                         list(idx.iter_entries([('name', )])))
1169
1210
 
1170
1211
    def test_iter_all_entries_two_indices_dup_key(self):
1171
 
        index1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
1172
 
        index2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
1173
 
        index = CombinedGraphIndex([index1, index2])
1174
 
        self.assertEqual([(index1, ('name', ), 'data')],
1175
 
            list(index.iter_all_entries()))
 
1212
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1213
        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
 
1214
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1215
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1216
                         list(idx.iter_all_entries()))
1176
1217
 
1177
1218
    def test_iter_key_prefix_2_key_element_refs(self):
1178
 
        index1 = self.make_index('1', 1, key_elements=2, nodes=[
1179
 
            (('name', 'fin1'), 'data', ([('ref', 'erence')], ))])
1180
 
        index2 = self.make_index('2', 1, key_elements=2, nodes=[
1181
 
            (('name', 'fin2'), 'beta', ([], )),
1182
 
            (('ref', 'erence'), 'refdata', ([], ))])
1183
 
        index = CombinedGraphIndex([index1, index2])
1184
 
        self.assertEqual(set([(index1, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1185
 
            (index2, ('ref', 'erence'), 'refdata', ((), ))]),
1186
 
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1187
 
        self.assertEqual(set([(index1, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1188
 
            (index2, ('name', 'fin2'), 'beta', ((), ))]),
1189
 
            set(index.iter_entries_prefix([('name', None)])))
 
1219
        idx1 = self.make_index('1', 1, key_elements=2, nodes=[
 
1220
                (('name', 'fin1'), 'data', ([('ref', 'erence')], ))])
 
1221
        idx2 = self.make_index('2', 1, key_elements=2, nodes=[
 
1222
                (('name', 'fin2'), 'beta', ([], )),
 
1223
                (('ref', 'erence'), 'refdata', ([], ))])
 
1224
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1225
        self.assertEqual({(idx1, ('name', 'fin1'), 'data',
 
1226
                               ((('ref', 'erence'),),)),
 
1227
                              (idx2, ('ref', 'erence'), 'refdata', ((), ))},
 
1228
                         set(idx.iter_entries_prefix([('name', 'fin1'),
 
1229
                                                        ('ref', 'erence')])))
 
1230
        self.assertEqual({(idx1, ('name', 'fin1'), 'data',
 
1231
                               ((('ref', 'erence'),),)),
 
1232
                              (idx2, ('name', 'fin2'), 'beta', ((), ))},
 
1233
                         set(idx.iter_entries_prefix([('name', None)])))
1190
1234
 
1191
1235
    def test_iter_nothing_empty(self):
1192
 
        index = CombinedGraphIndex([])
1193
 
        self.assertEqual([], list(index.iter_entries([])))
 
1236
        idx = _mod_index.CombinedGraphIndex([])
 
1237
        self.assertEqual([], list(idx.iter_entries([])))
1194
1238
 
1195
1239
    def test_iter_nothing_children_empty(self):
1196
 
        index1 = self.make_index('name')
1197
 
        index = CombinedGraphIndex([index1])
1198
 
        self.assertEqual([], list(index.iter_entries([])))
 
1240
        idx1 = self.make_index('name')
 
1241
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1242
        self.assertEqual([], list(idx.iter_entries([])))
1199
1243
 
1200
1244
    def test_iter_all_keys(self):
1201
 
        index1 = self.make_index('1', 1, nodes=[
1202
 
            (('name', ), 'data', ([('ref', )], ))])
1203
 
        index2 = self.make_index('2', 1, nodes=[
1204
 
            (('ref', ), 'refdata', ((), ))])
1205
 
        index = CombinedGraphIndex([index1, index2])
1206
 
        self.assertEqual(set([(index1, ('name', ), 'data', ((('ref', ), ), )),
1207
 
            (index2, ('ref', ), 'refdata', ((), ))]),
1208
 
            set(index.iter_entries([('name', ), ('ref', )])))
 
1245
        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
 
1246
                                               ([('ref', )], ))])
 
1247
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ((), ))])
 
1248
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1249
        self.assertEqual({(idx1, ('name', ), 'data', ((('ref', ), ), )),
 
1250
                              (idx2, ('ref', ), 'refdata', ((), ))},
 
1251
                         set(idx.iter_entries([('name', ), ('ref', )])))
1209
1252
 
1210
1253
    def test_iter_all_keys_dup_entry(self):
1211
 
        index1 = self.make_index('1', 1, nodes=[
1212
 
            (('name', ), 'data', ([('ref', )], )),
1213
 
            (('ref', ), 'refdata', ([], ))])
1214
 
        index2 = self.make_index('2', 1, nodes=[
1215
 
            (('ref', ), 'refdata', ([], ))])
1216
 
        index = CombinedGraphIndex([index1, index2])
1217
 
        self.assertEqual(set([(index1, ('name', ), 'data', ((('ref',),),)),
1218
 
            (index1, ('ref', ), 'refdata', ((), ))]),
1219
 
            set(index.iter_entries([('name', ), ('ref', )])))
 
1254
        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
 
1255
                                                 ([('ref', )], )),
 
1256
                                                (('ref', ), 'refdata', ([], ))])
 
1257
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ([], ))])
 
1258
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1259
        self.assertEqual({(idx1, ('name', ), 'data', ((('ref',),),)),
 
1260
                              (idx1, ('ref', ), 'refdata', ((), ))},
 
1261
                         set(idx.iter_entries([('name', ), ('ref', )])))
1220
1262
 
1221
1263
    def test_iter_missing_entry_empty(self):
1222
 
        index = CombinedGraphIndex([])
1223
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
1264
        idx = _mod_index.CombinedGraphIndex([])
 
1265
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1224
1266
 
1225
1267
    def test_iter_missing_entry_one_index(self):
1226
 
        index1 = self.make_index('1')
1227
 
        index = CombinedGraphIndex([index1])
1228
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
1268
        idx1 = self.make_index('1')
 
1269
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1270
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1229
1271
 
1230
1272
    def test_iter_missing_entry_two_index(self):
1231
 
        index1 = self.make_index('1')
1232
 
        index2 = self.make_index('2')
1233
 
        index = CombinedGraphIndex([index1, index2])
1234
 
        self.assertEqual([], list(index.iter_entries([('a', )])))
 
1273
        idx1 = self.make_index('1')
 
1274
        idx2 = self.make_index('2')
 
1275
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1276
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1235
1277
 
1236
1278
    def test_iter_entry_present_one_index_only(self):
1237
 
        index1 = self.make_index('1', nodes=[(('key', ), '', ())])
1238
 
        index2 = self.make_index('2', nodes=[])
1239
 
        index = CombinedGraphIndex([index1, index2])
1240
 
        self.assertEqual([(index1, ('key', ), '')],
1241
 
            list(index.iter_entries([('key', )])))
 
1279
        idx1 = self.make_index('1', nodes=[(('key', ), '', ())])
 
1280
        idx2 = self.make_index('2', nodes=[])
 
1281
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1282
        self.assertEqual([(idx1, ('key', ), '')],
 
1283
                         list(idx.iter_entries([('key', )])))
1242
1284
        # and in the other direction
1243
 
        index = CombinedGraphIndex([index2, index1])
1244
 
        self.assertEqual([(index1, ('key', ), '')],
1245
 
            list(index.iter_entries([('key', )])))
 
1285
        idx = _mod_index.CombinedGraphIndex([idx2, idx1])
 
1286
        self.assertEqual([(idx1, ('key', ), '')],
 
1287
                         list(idx.iter_entries([('key', )])))
1246
1288
 
1247
1289
    def test_key_count_empty(self):
1248
 
        index1 = self.make_index('1', nodes=[])
1249
 
        index2 = self.make_index('2', nodes=[])
1250
 
        index = CombinedGraphIndex([index1, index2])
1251
 
        self.assertEqual(0, index.key_count())
 
1290
        idx1 = self.make_index('1', nodes=[])
 
1291
        idx2 = self.make_index('2', nodes=[])
 
1292
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1293
        self.assertEqual(0, idx.key_count())
1252
1294
 
1253
1295
    def test_key_count_sums_index_keys(self):
1254
 
        index1 = self.make_index('1', nodes=[
 
1296
        idx1 = self.make_index('1', nodes=[
1255
1297
            (('1',), '', ()),
1256
1298
            (('2',), '', ())])
1257
 
        index2 = self.make_index('2', nodes=[(('1',), '', ())])
1258
 
        index = CombinedGraphIndex([index1, index2])
1259
 
        self.assertEqual(3, index.key_count())
 
1299
        idx2 = self.make_index('2', nodes=[(('1',), '', ())])
 
1300
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1301
        self.assertEqual(3, idx.key_count())
1260
1302
 
1261
1303
    def test_validate_bad_child_index_errors(self):
1262
1304
        trans = self.get_transport()
1263
1305
        trans.put_bytes('name', "not an index\n")
1264
 
        index1 = GraphIndex(trans, 'name', 13)
1265
 
        index = CombinedGraphIndex([index1])
1266
 
        self.assertRaises(errors.BadIndexFormatSignature, index.validate)
 
1306
        idx1 = _mod_index.GraphIndex(trans, 'name', 13)
 
1307
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1308
        self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
1267
1309
 
1268
1310
    def test_validate_empty(self):
1269
 
        index = CombinedGraphIndex([])
1270
 
        index.validate()
 
1311
        idx = _mod_index.CombinedGraphIndex([])
 
1312
        idx.validate()
1271
1313
 
1272
1314
    def test_key_count_reloads(self):
1273
 
        index, reload_counter = self.make_combined_index_with_missing()
1274
 
        self.assertEqual(2, index.key_count())
 
1315
        idx, reload_counter = self.make_combined_index_with_missing()
 
1316
        self.assertEqual(2, idx.key_count())
1275
1317
        self.assertEqual([1, 1, 0], reload_counter)
1276
1318
 
1277
1319
    def test_key_count_no_reload(self):
1278
 
        index, reload_counter = self.make_combined_index_with_missing()
1279
 
        index._reload_func = None
 
1320
        idx, reload_counter = self.make_combined_index_with_missing()
 
1321
        idx._reload_func = None
1280
1322
        # Without a _reload_func we just raise the exception
1281
 
        self.assertRaises(errors.NoSuchFile, index.key_count)
 
1323
        self.assertRaises(errors.NoSuchFile, idx.key_count)
1282
1324
 
1283
1325
    def test_key_count_reloads_and_fails(self):
1284
1326
        # We have deleted all underlying indexes, so we will try to reload, but
1285
1327
        # still fail. This is mostly to test we don't get stuck in an infinite
1286
1328
        # 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)
 
1329
        idx, reload_counter = self.make_combined_index_with_missing(
 
1330
            ['1', '2', '3'])
 
1331
        self.assertRaises(errors.NoSuchFile, idx.key_count)
1290
1332
        self.assertEqual([2, 1, 1], reload_counter)
1291
1333
 
1292
1334
    def test_iter_entries_reloads(self):
1392
1434
        return self.make_index('index-%s' % name, 0, nodes=nodes)
1393
1435
 
1394
1436
    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(
 
1437
        # Four indices: [key1] in idx1, [key2,key3] in idx2, [] in idx3,
 
1438
        # [key4] in idx4.
 
1439
        idx = _mod_index.CombinedGraphIndex([])
 
1440
        idx.insert_index(0, self.make_index_with_simple_nodes('1'), '1')
 
1441
        idx.insert_index(1, self.make_index_with_simple_nodes('2'), '2')
 
1442
        idx.insert_index(2, self.make_index_with_simple_nodes('3'), '3')
 
1443
        idx.insert_index(3, self.make_index_with_simple_nodes('4'), '4')
 
1444
        idx1, idx2, idx3, idx4 = idx._indices
 
1445
        # Query a key from idx4 and idx2.
 
1446
        self.assertLength(2, list(idx.iter_entries(
1405
1447
            [('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)
 
1448
        # Now idx2 and idx4 should be moved to the front (and idx1 should
 
1449
        # still be before idx3).
 
1450
        self.assertEqual([idx2, idx4, idx1, idx3], idx._indices)
 
1451
        self.assertEqual(['2', '4', '1', '3'], idx._index_names)
1410
1452
 
1411
1453
    def test_reorder_propagates_to_siblings(self):
1412
1454
        # Two CombinedGraphIndex objects, with the same number of indicies with
1413
1455
        # matching names.
1414
 
        cgi1 = CombinedGraphIndex([])
1415
 
        cgi2 = CombinedGraphIndex([])
 
1456
        cgi1 = _mod_index.CombinedGraphIndex([])
 
1457
        cgi2 = _mod_index.CombinedGraphIndex([])
1416
1458
        cgi1.insert_index(0, self.make_index_with_simple_nodes('1-1'), 'one')
1417
1459
        cgi1.insert_index(1, self.make_index_with_simple_nodes('1-2'), 'two')
1418
1460
        cgi2.insert_index(0, self.make_index_with_simple_nodes('2-1'), 'one')
1425
1467
        self.assertEqual(['two', 'one'], cgi2._index_names)
1426
1468
 
1427
1469
    def test_validate_reloads(self):
1428
 
        index, reload_counter = self.make_combined_index_with_missing()
1429
 
        index.validate()
 
1470
        idx, reload_counter = self.make_combined_index_with_missing()
 
1471
        idx.validate()
1430
1472
        self.assertEqual([1, 1, 0], reload_counter)
1431
1473
 
1432
1474
    def test_validate_reloads_midway(self):
1433
 
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1434
 
        index.validate()
 
1475
        idx, reload_counter = self.make_combined_index_with_missing(['2'])
 
1476
        idx.validate()
1435
1477
 
1436
1478
    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)
 
1479
        idx, reload_counter = self.make_combined_index_with_missing()
 
1480
        idx._reload_func = None
 
1481
        self.assertRaises(errors.NoSuchFile, idx.validate)
1440
1482
 
1441
1483
    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)
 
1484
        idx, reload_counter = self.make_combined_index_with_missing(
 
1485
            ['1', '2', '3'])
 
1486
        self.assertRaises(errors.NoSuchFile, idx.validate)
1445
1487
 
1446
1488
    def test_find_ancestors_across_indexes(self):
1447
1489
        key1 = ('key-1',)
1456
1498
            (key3, 'value', ([key2],)),
1457
1499
            (key4, 'value', ([key3],)),
1458
1500
            ])
1459
 
        c_index = CombinedGraphIndex([index1, index2])
 
1501
        c_index = _mod_index.CombinedGraphIndex([index1, index2])
1460
1502
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1461
1503
        self.assertEqual({key1: ()}, parent_map)
1462
1504
        self.assertEqual(set(), missing_keys)
1479
1521
        index2 = self.make_index('34', ref_lists=1, nodes=[
1480
1522
            (key3, 'value', ([key2],)),
1481
1523
            ])
1482
 
        c_index = CombinedGraphIndex([index1, index2])
 
1524
        c_index = _mod_index.CombinedGraphIndex([index1, index2])
1483
1525
        # Searching for a key which is actually not present at all should
1484
1526
        # eventually converge
1485
1527
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1486
1528
        self.assertEqual({}, parent_map)
1487
 
        self.assertEqual(set([key4]), missing_keys)
 
1529
        self.assertEqual({key4}, missing_keys)
1488
1530
 
1489
1531
    def test_find_ancestors_no_indexes(self):
1490
 
        c_index = CombinedGraphIndex([])
 
1532
        c_index = _mod_index.CombinedGraphIndex([])
1491
1533
        key1 = ('key-1',)
1492
1534
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1493
1535
        self.assertEqual({}, parent_map)
1494
 
        self.assertEqual(set([key1]), missing_keys)
 
1536
        self.assertEqual({key1}, missing_keys)
1495
1537
 
1496
1538
    def test_find_ancestors_ghost_parent(self):
1497
1539
        key1 = ('key-1',)
1505
1547
        index2 = self.make_index('34', ref_lists=1, nodes=[
1506
1548
            (key4, 'value', ([key2, key3],)),
1507
1549
            ])
1508
 
        c_index = CombinedGraphIndex([index1, index2])
 
1550
        c_index = _mod_index.CombinedGraphIndex([index1, index2])
1509
1551
        # Searching for a key which is actually not present at all should
1510
1552
        # eventually converge
1511
1553
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1512
1554
        self.assertEqual({key4: (key2, key3), key2: (key1,), key1: ()},
1513
1555
                         parent_map)
1514
 
        self.assertEqual(set([key3]), missing_keys)
 
1556
        self.assertEqual({key3}, missing_keys)
1515
1557
 
1516
1558
    def test__find_ancestors_empty_index(self):
1517
 
        index = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
 
1559
        idx = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
1518
1560
        parent_map = {}
1519
1561
        missing_keys = set()
1520
 
        search_keys = index._find_ancestors([('one',), ('two',)], 0, parent_map,
1521
 
                                            missing_keys)
 
1562
        search_keys = idx._find_ancestors([('one',), ('two',)], 0, parent_map,
 
1563
                                          missing_keys)
1522
1564
        self.assertEqual(set(), search_keys)
1523
1565
        self.assertEqual({}, parent_map)
1524
 
        self.assertEqual(set([('one',), ('two',)]), missing_keys)
1525
 
 
1526
 
 
1527
 
class TestInMemoryGraphIndex(TestCaseWithMemoryTransport):
 
1566
        self.assertEqual({('one',), ('two',)}, missing_keys)
 
1567
 
 
1568
 
 
1569
class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):
1528
1570
 
1529
1571
    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
1530
 
        result = InMemoryGraphIndex(ref_lists, key_elements=key_elements)
 
1572
        result = _mod_index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1531
1573
        result.add_nodes(nodes)
1532
1574
        return result
1533
1575
 
1535
1577
        index = self.make_index(0)
1536
1578
        index.add_nodes([(('name', ), 'data')])
1537
1579
        index.add_nodes([(('name2', ), ''), (('name3', ), '')])
1538
 
        self.assertEqual(set([
 
1580
        self.assertEqual({
1539
1581
            (index, ('name', ), 'data'),
1540
1582
            (index, ('name2', ), ''),
1541
1583
            (index, ('name3', ), ''),
1542
 
            ]), set(index.iter_all_entries()))
 
1584
            }, set(index.iter_all_entries()))
1543
1585
 
1544
1586
    def test_add_nodes(self):
1545
1587
        index = self.make_index(1)
1546
1588
        index.add_nodes([(('name', ), 'data', ([],))])
1547
1589
        index.add_nodes([(('name2', ), '', ([],)), (('name3', ), '', ([('r', )],))])
1548
 
        self.assertEqual(set([
 
1590
        self.assertEqual({
1549
1591
            (index, ('name', ), 'data', ((),)),
1550
1592
            (index, ('name2', ), '', ((),)),
1551
1593
            (index, ('name3', ), '', ((('r', ), ), )),
1552
 
            ]), set(index.iter_all_entries()))
 
1594
            }, set(index.iter_all_entries()))
1553
1595
 
1554
1596
    def test_iter_all_entries_empty(self):
1555
1597
        index = self.make_index()
1564
1606
        index = self.make_index(1, nodes=[
1565
1607
            (('name', ), 'data', ([('ref', )], )),
1566
1608
            (('ref', ), 'refdata', ([], ))])
1567
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref', ),),)),
1568
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
1609
        self.assertEqual({(index, ('name', ), 'data', ((('ref', ),),)),
 
1610
            (index, ('ref', ), 'refdata', ((), ))},
1569
1611
            set(index.iter_all_entries()))
1570
1612
 
1571
1613
    def test_iteration_absent_skipped(self):
1572
1614
        index = self.make_index(1, nodes=[
1573
1615
            (('name', ), 'data', ([('ref', )], ))])
1574
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
1616
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
1575
1617
            set(index.iter_all_entries()))
1576
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
1618
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
1577
1619
            set(index.iter_entries([('name', )])))
1578
1620
        self.assertEqual([], list(index.iter_entries([('ref', )])))
1579
1621
 
1581
1623
        index = self.make_index(1, nodes=[
1582
1624
            (('name', ), 'data', ([('ref', )], )),
1583
1625
            (('ref', ), 'refdata', ([], ))])
1584
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
1585
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
1626
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
1627
            (index, ('ref', ), 'refdata', ((), ))},
1586
1628
            set(index.iter_entries([('name', ), ('ref', )])))
1587
1629
 
1588
1630
    def test_iter_key_prefix_1_key_element_no_refs(self):
1589
1631
        index = self.make_index( nodes=[
1590
1632
            (('name', ), 'data'),
1591
1633
            (('ref', ), 'refdata')])
1592
 
        self.assertEqual(set([(index, ('name', ), 'data'),
1593
 
            (index, ('ref', ), 'refdata')]),
 
1634
        self.assertEqual({(index, ('name', ), 'data'),
 
1635
            (index, ('ref', ), 'refdata')},
1594
1636
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
1595
1637
 
1596
1638
    def test_iter_key_prefix_1_key_element_refs(self):
1597
1639
        index = self.make_index(1, nodes=[
1598
1640
            (('name', ), 'data', ([('ref', )], )),
1599
1641
            (('ref', ), 'refdata', ([], ))])
1600
 
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
1601
 
            (index, ('ref', ), 'refdata', ((), ))]),
 
1642
        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
 
1643
            (index, ('ref', ), 'refdata', ((), ))},
1602
1644
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
1603
1645
 
1604
1646
    def test_iter_key_prefix_2_key_element_no_refs(self):
1606
1648
            (('name', 'fin1'), 'data'),
1607
1649
            (('name', 'fin2'), 'beta'),
1608
1650
            (('ref', 'erence'), 'refdata')])
1609
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
1610
 
            (index, ('ref', 'erence'), 'refdata')]),
 
1651
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
1652
            (index, ('ref', 'erence'), 'refdata')},
1611
1653
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1612
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
1613
 
            (index, ('name', 'fin2'), 'beta')]),
 
1654
        self.assertEqual({(index, ('name', 'fin1'), 'data'),
 
1655
            (index, ('name', 'fin2'), 'beta')},
1614
1656
            set(index.iter_entries_prefix([('name', None)])))
1615
1657
 
1616
1658
    def test_iter_key_prefix_2_key_element_refs(self):
1618
1660
            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
1619
1661
            (('name', 'fin2'), 'beta', ([], )),
1620
1662
            (('ref', 'erence'), 'refdata', ([], ))])
1621
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1622
 
            (index, ('ref', 'erence'), 'refdata', ((), ))]),
 
1663
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
1664
            (index, ('ref', 'erence'), 'refdata', ((), ))},
1623
1665
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1624
 
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1625
 
            (index, ('name', 'fin2'), 'beta', ((), ))]),
 
1666
        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
1667
            (index, ('name', 'fin2'), 'beta', ((), ))},
1626
1668
            set(index.iter_entries_prefix([('name', None)])))
1627
1669
 
1628
1670
    def test_iter_nothing_empty(self):
1654
1696
        index.validate()
1655
1697
 
1656
1698
 
1657
 
class TestGraphIndexPrefixAdapter(TestCaseWithMemoryTransport):
 
1699
class TestGraphIndexPrefixAdapter(tests.TestCaseWithMemoryTransport):
1658
1700
 
1659
 
    def make_index(self, ref_lists=1, key_elements=2, nodes=[], add_callback=False):
1660
 
        result = InMemoryGraphIndex(ref_lists, key_elements=key_elements)
 
1701
    def make_index(self, ref_lists=1, key_elements=2, nodes=[],
 
1702
                   add_callback=False):
 
1703
        result = _mod_index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1661
1704
        result.add_nodes(nodes)
1662
1705
        if add_callback:
1663
1706
            add_nodes_callback = result.add_nodes
1664
1707
        else:
1665
1708
            add_nodes_callback = None
1666
 
        adapter = GraphIndexPrefixAdapter(result, ('prefix', ), key_elements - 1,
 
1709
        adapter = _mod_index.GraphIndexPrefixAdapter(
 
1710
            result, ('prefix', ), key_elements - 1,
1667
1711
            add_nodes_callback=add_nodes_callback)
1668
1712
        return result, adapter
1669
1713
 
1670
1714
    def test_add_node(self):
1671
1715
        index, adapter = self.make_index(add_callback=True)
1672
1716
        adapter.add_node(('key',), 'value', ((('ref',),),))
1673
 
        self.assertEqual(set([(index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))]),
 
1717
        self.assertEqual({(index, ('prefix', 'key'), 'value',
 
1718
                               ((('prefix', 'ref'),),))},
1674
1719
            set(index.iter_all_entries()))
1675
1720
 
1676
1721
    def test_add_nodes(self):
1679
1724
            (('key',), 'value', ((('ref',),),)),
1680
1725
            (('key2',), 'value2', ((),)),
1681
1726
            ))
1682
 
        self.assertEqual(set([
 
1727
        self.assertEqual({
1683
1728
            (index, ('prefix', 'key2'), 'value2', ((),)),
1684
1729
            (index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))
1685
 
            ]),
 
1730
            },
1686
1731
            set(index.iter_all_entries()))
1687
1732
 
1688
1733
    def test_construct(self):
1689
 
        index = InMemoryGraphIndex()
1690
 
        adapter = GraphIndexPrefixAdapter(index, ('prefix', ), 1)
 
1734
        idx = _mod_index.InMemoryGraphIndex()
 
1735
        adapter = _mod_index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1)
1691
1736
 
1692
1737
    def test_construct_with_callback(self):
1693
 
        index = InMemoryGraphIndex()
1694
 
        adapter = GraphIndexPrefixAdapter(index, ('prefix', ), 1, index.add_nodes)
 
1738
        idx = _mod_index.InMemoryGraphIndex()
 
1739
        adapter = _mod_index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1,
 
1740
                                                idx.add_nodes)
1695
1741
 
1696
1742
    def test_iter_all_entries_cross_prefix_map_errors(self):
1697
1743
        index, adapter = self.make_index(nodes=[
1698
1744
            (('prefix', 'key1'), 'data1', ((('prefixaltered', 'key2'),),))])
1699
 
        self.assertRaises(errors.BadIndexData, list, adapter.iter_all_entries())
 
1745
        self.assertRaises(_mod_index.BadIndexData, list, adapter.iter_all_entries())
1700
1746
 
1701
1747
    def test_iter_all_entries(self):
1702
1748
        index, adapter = self.make_index(nodes=[
1703
1749
            (('notprefix', 'key1'), 'data', ((), )),
1704
1750
            (('prefix', 'key1'), 'data1', ((), )),
1705
1751
            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1706
 
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
1707
 
            (index, ('key2', ), 'data2', ((('key1',),),))]),
 
1752
        self.assertEqual({(index, ('key1', ), 'data1', ((),)),
 
1753
            (index, ('key2', ), 'data2', ((('key1',),),))},
1708
1754
            set(adapter.iter_all_entries()))
1709
1755
 
1710
1756
    def test_iter_entries(self):
1713
1759
            (('prefix', 'key1'), 'data1', ((), )),
1714
1760
            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1715
1761
        # ask for many - get all
1716
 
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
1717
 
            (index, ('key2', ), 'data2', ((('key1', ),),))]),
 
1762
        self.assertEqual({(index, ('key1', ), 'data1', ((),)),
 
1763
            (index, ('key2', ), 'data2', ((('key1', ),),))},
1718
1764
            set(adapter.iter_entries([('key1', ), ('key2', )])))
1719
1765
        # ask for one, get one
1720
 
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),))]),
 
1766
        self.assertEqual({(index, ('key1', ), 'data1', ((),))},
1721
1767
            set(adapter.iter_entries([('key1', )])))
1722
1768
        # ask for missing, get none
1723
1769
        self.assertEqual(set(),
1729
1775
            (('prefix', 'prefix2', 'key1'), 'data1', ((), )),
1730
1776
            (('prefix', 'prefix2', 'key2'), 'data2', ((('prefix', 'prefix2', 'key1'),),))])
1731
1777
        # ask for a prefix, get the results for just that prefix, adjusted.
1732
 
        self.assertEqual(set([(index, ('prefix2', 'key1', ), 'data1', ((),)),
1733
 
            (index, ('prefix2', 'key2', ), 'data2', ((('prefix2', 'key1', ),),))]),
 
1778
        self.assertEqual({(index, ('prefix2', 'key1', ), 'data1', ((),)),
 
1779
            (index, ('prefix2', 'key2', ), 'data2', ((('prefix2', 'key1', ),),))},
1734
1780
            set(adapter.iter_entries_prefix([('prefix2', None)])))
1735
1781
 
1736
1782
    def test_key_count_no_matching_keys(self):