17
17
"""Tests for indices."""
19
from bzrlib import errors
20
from bzrlib.index import *
21
from bzrlib.tests import TestCaseWithMemoryTransport
22
from bzrlib.transport import get_transport
25
class TestGraphIndexBuilder(TestCaseWithMemoryTransport):
29
class ErrorTests(tests.TestCase):
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.",
36
def test_bad_index_data(self):
37
error = _mod_index.BadIndexData("foo")
38
self.assertEqual("Error in data for index foo.",
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'.",
46
def test_bad_index_key(self):
47
error = _mod_index.BadIndexKey("foo")
48
self.assertEqual("The key 'foo' is not a valid key.",
51
def test_bad_index_options(self):
52
error = _mod_index.BadIndexOptions("foo")
53
self.assertEqual("Could not parse options for index foo.",
56
def test_bad_index_value(self):
57
error = _mod_index.BadIndexValue("foo")
58
self.assertEqual("The value 'foo' is not a valid value.",
62
class TestGraphIndexBuilder(tests.TestCaseWithMemoryTransport):
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()
32
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=0\n\n",
69
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=0\n\n",
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()
40
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=0\n\n",
77
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=0\n\n",
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()
48
"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=0\n\n",
85
b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=0\n\n",
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()
56
"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=0\n\n",
93
b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=0\n\n",
59
96
def test_build_index_one_node_no_refs(self):
60
builder = GraphIndexBuilder()
61
builder.add_node(('akey', ), 'data')
97
builder = _mod_index.GraphIndexBuilder()
98
builder.add_node((b'akey', ), b'data')
62
99
stream = builder.finish()
63
100
contents = stream.read()
65
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
66
"akey\x00\x00\x00data\n\n", contents)
102
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
103
b"akey\x00\x00\x00data\n\n", contents)
68
105
def test_build_index_one_node_no_refs_accepts_empty_reflist(self):
69
builder = GraphIndexBuilder()
70
builder.add_node(('akey', ), 'data', ())
106
builder = _mod_index.GraphIndexBuilder()
107
builder.add_node((b'akey', ), b'data', ())
71
108
stream = builder.finish()
72
109
contents = stream.read()
74
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
75
"akey\x00\x00\x00data\n\n", contents)
111
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
112
b"akey\x00\x00\x00data\n\n", contents)
77
114
def test_build_index_one_node_2_element_keys(self):
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
81
builder = GraphIndexBuilder(key_elements=2)
82
builder.add_node(('akey', 'secondpart'), 'data')
118
builder = _mod_index.GraphIndexBuilder(key_elements=2)
119
builder.add_node((b'akey', b'secondpart'), b'data')
83
120
stream = builder.finish()
84
121
contents = stream.read()
86
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=1\n"
87
"akey\x00secondpart\x00\x00\x00data\n\n", contents)
123
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=1\n"
124
b"akey\x00secondpart\x00\x00\x00data\n\n", contents)
89
126
def test_add_node_empty_value(self):
90
builder = GraphIndexBuilder()
91
builder.add_node(('akey', ), '')
127
builder = _mod_index.GraphIndexBuilder()
128
builder.add_node((b'akey', ), b'')
92
129
stream = builder.finish()
93
130
contents = stream.read()
95
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
96
"akey\x00\x00\x00\n\n", contents)
132
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
133
b"akey\x00\x00\x00\n\n", contents)
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.
104
builder.add_node(('2002', ), 'data')
105
builder.add_node(('2000', ), 'data')
106
builder.add_node(('2001', ), 'data')
141
builder.add_node((b'2002', ), b'data')
142
builder.add_node((b'2000', ), b'data')
143
builder.add_node((b'2001', ), b'data')
107
144
stream = builder.finish()
108
145
contents = stream.read()
109
146
self.assertEqual(
110
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=3\n"
111
"2000\x00\x00\x00data\n"
112
"2001\x00\x00\x00data\n"
113
"2002\x00\x00\x00data\n"
147
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=3\n"
148
b"2000\x00\x00\x00data\n"
149
b"2001\x00\x00\x00data\n"
150
b"2002\x00\x00\x00data\n"
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.
122
builder.add_node(('2002', '2002'), 'data')
123
builder.add_node(('2002', '2000'), 'data')
124
builder.add_node(('2002', '2001'), 'data')
125
builder.add_node(('2000', '2002'), 'data')
126
builder.add_node(('2000', '2000'), 'data')
127
builder.add_node(('2000', '2001'), 'data')
128
builder.add_node(('2001', '2002'), 'data')
129
builder.add_node(('2001', '2000'), 'data')
130
builder.add_node(('2001', '2001'), 'data')
159
builder.add_node((b'2002', b'2002'), b'data')
160
builder.add_node((b'2002', b'2000'), b'data')
161
builder.add_node((b'2002', b'2001'), b'data')
162
builder.add_node((b'2000', b'2002'), b'data')
163
builder.add_node((b'2000', b'2000'), b'data')
164
builder.add_node((b'2000', b'2001'), b'data')
165
builder.add_node((b'2001', b'2002'), b'data')
166
builder.add_node((b'2001', b'2000'), b'data')
167
builder.add_node((b'2001', b'2001'), b'data')
131
168
stream = builder.finish()
132
169
contents = stream.read()
133
170
self.assertEqual(
134
"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=9\n"
135
"2000\x002000\x00\x00\x00data\n"
136
"2000\x002001\x00\x00\x00data\n"
137
"2000\x002002\x00\x00\x00data\n"
138
"2001\x002000\x00\x00\x00data\n"
139
"2001\x002001\x00\x00\x00data\n"
140
"2001\x002002\x00\x00\x00data\n"
141
"2002\x002000\x00\x00\x00data\n"
142
"2002\x002001\x00\x00\x00data\n"
143
"2002\x002002\x00\x00\x00data\n"
171
b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=9\n"
172
b"2000\x002000\x00\x00\x00data\n"
173
b"2000\x002001\x00\x00\x00data\n"
174
b"2000\x002002\x00\x00\x00data\n"
175
b"2001\x002000\x00\x00\x00data\n"
176
b"2001\x002001\x00\x00\x00data\n"
177
b"2001\x002002\x00\x00\x00data\n"
178
b"2002\x002000\x00\x00\x00data\n"
179
b"2002\x002001\x00\x00\x00data\n"
180
b"2002\x002002\x00\x00\x00data\n"
146
183
def test_build_index_reference_lists_are_included_one(self):
147
builder = GraphIndexBuilder(reference_lists=1)
148
builder.add_node(('key', ), 'data', ([], ))
184
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
185
builder.add_node((b'key', ), b'data', ([], ))
149
186
stream = builder.finish()
150
187
contents = stream.read()
151
188
self.assertEqual(
152
"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
153
"key\x00\x00\x00data\n"
189
b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
190
b"key\x00\x00\x00data\n"
156
193
def test_build_index_reference_lists_with_2_element_keys(self):
157
builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
158
builder.add_node(('key', 'key2'), 'data', ([], ))
194
builder = _mod_index.GraphIndexBuilder(
195
reference_lists=1, key_elements=2)
196
builder.add_node((b'key', b'key2'), b'data', ([], ))
159
197
stream = builder.finish()
160
198
contents = stream.read()
161
199
self.assertEqual(
162
"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=2\nlen=1\n"
163
"key\x00key2\x00\x00\x00data\n"
200
b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=2\nlen=1\n"
201
b"key\x00key2\x00\x00\x00data\n"
166
204
def test_build_index_reference_lists_are_included_two(self):
167
builder = GraphIndexBuilder(reference_lists=2)
168
builder.add_node(('key', ), 'data', ([], []))
205
builder = _mod_index.GraphIndexBuilder(reference_lists=2)
206
builder.add_node((b'key', ), b'data', ([], []))
169
207
stream = builder.finish()
170
208
contents = stream.read()
171
209
self.assertEqual(
172
"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
173
"key\x00\x00\t\x00data\n"
210
b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
211
b"key\x00\x00\t\x00data\n"
176
214
def test_clear_cache(self):
177
builder = GraphIndexBuilder(reference_lists=2)
215
builder = _mod_index.GraphIndexBuilder(reference_lists=2)
178
216
# This is a no-op, but the api should exist
179
217
builder.clear_cache()
181
219
def test_node_references_are_byte_offsets(self):
182
builder = GraphIndexBuilder(reference_lists=1)
183
builder.add_node(('reference', ), 'data', ([], ))
184
builder.add_node(('key', ), 'data', ([('reference', )], ))
220
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
221
builder.add_node((b'reference', ), b'data', ([], ))
222
builder.add_node((b'key', ), b'data', ([(b'reference', )], ))
185
223
stream = builder.finish()
186
224
contents = stream.read()
187
225
self.assertEqual(
188
"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=2\n"
189
"key\x00\x0072\x00data\n"
190
"reference\x00\x00\x00data\n"
226
b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=2\n"
227
b"key\x00\x0072\x00data\n"
228
b"reference\x00\x00\x00data\n"
193
231
def test_node_references_are_cr_delimited(self):
194
builder = GraphIndexBuilder(reference_lists=1)
195
builder.add_node(('reference', ), 'data', ([], ))
196
builder.add_node(('reference2', ), 'data', ([], ))
197
builder.add_node(('key', ), 'data', ([('reference', ), ('reference2', )], ))
232
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
233
builder.add_node((b'reference', ), b'data', ([], ))
234
builder.add_node((b'reference2', ), b'data', ([], ))
235
builder.add_node((b'key', ), b'data',
236
([(b'reference', ), (b'reference2', )], ))
198
237
stream = builder.finish()
199
238
contents = stream.read()
200
239
self.assertEqual(
201
"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=3\n"
202
"key\x00\x00077\r094\x00data\n"
203
"reference\x00\x00\x00data\n"
204
"reference2\x00\x00\x00data\n"
240
b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=3\n"
241
b"key\x00\x00077\r094\x00data\n"
242
b"reference\x00\x00\x00data\n"
243
b"reference2\x00\x00\x00data\n"
207
246
def test_multiple_reference_lists_are_tab_delimited(self):
208
builder = GraphIndexBuilder(reference_lists=2)
209
builder.add_node(('keference', ), 'data', ([], []))
210
builder.add_node(('rey', ), 'data', ([('keference', )], [('keference', )]))
247
builder = _mod_index.GraphIndexBuilder(reference_lists=2)
248
builder.add_node((b'keference', ), b'data', ([], []))
249
builder.add_node((b'rey', ), b'data',
250
([(b'keference', )], [(b'keference', )]))
211
251
stream = builder.finish()
212
252
contents = stream.read()
213
253
self.assertEqual(
214
"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=2\n"
215
"keference\x00\x00\t\x00data\n"
216
"rey\x00\x0059\t59\x00data\n"
254
b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=2\n"
255
b"keference\x00\x00\t\x00data\n"
256
b"rey\x00\x0059\t59\x00data\n"
219
259
def test_add_node_referencing_missing_key_makes_absent(self):
220
builder = GraphIndexBuilder(reference_lists=1)
221
builder.add_node(('rey', ), 'data', ([('beference', ), ('aeference2', )], ))
260
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
261
builder.add_node((b'rey', ), b'data',
262
([(b'beference', ), (b'aeference2', )], ))
222
263
stream = builder.finish()
223
264
contents = stream.read()
224
265
self.assertEqual(
225
"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
226
"aeference2\x00a\x00\x00\n"
227
"beference\x00a\x00\x00\n"
228
"rey\x00\x00074\r059\x00data\n"
266
b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
267
b"aeference2\x00a\x00\x00\n"
268
b"beference\x00a\x00\x00\n"
269
b"rey\x00\x00074\r059\x00data\n"
231
272
def test_node_references_three_digits(self):
232
273
# test the node digit expands as needed.
233
builder = GraphIndexBuilder(reference_lists=1)
234
references = [(str(val), ) for val in reversed(range(9))]
235
builder.add_node(('2-key', ), '', (references, ))
274
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
275
references = [((b"%d" % val), ) for val in range(8, -1, -1)]
276
builder.add_node((b'2-key', ), b'', (references, ))
236
277
stream = builder.finish()
237
278
contents = stream.read()
238
279
self.assertEqualDiff(
239
"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
243
"2-key\x00\x00151\r145\r139\r133\r127\r121\r071\r065\r059\x00\n"
280
b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
284
b"2-key\x00\x00151\r145\r139\r133\r127\r121\r071\r065\r059\x00\n"
252
293
def test_absent_has_no_reference_overhead(self):
253
294
# the offsets after an absent record should be correct when there are
254
295
# >1 reference lists.
255
builder = GraphIndexBuilder(reference_lists=2)
256
builder.add_node(('parent', ), '', ([('aail', ), ('zther', )], []))
296
builder = _mod_index.GraphIndexBuilder(reference_lists=2)
297
builder.add_node((b'parent', ), b'', ([(b'aail', ), (b'zther', )], []))
257
298
stream = builder.finish()
258
299
contents = stream.read()
259
300
self.assertEqual(
260
"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
261
"aail\x00a\x00\x00\n"
262
"parent\x00\x0059\r84\t\x00\n"
263
"zther\x00a\x00\x00\n"
301
b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
302
b"aail\x00a\x00\x00\n"
303
b"parent\x00\x0059\r84\t\x00\n"
304
b"zther\x00a\x00\x00\n"
266
307
def test_add_node_bad_key(self):
267
builder = GraphIndexBuilder()
268
for bad_char in '\t\n\x0b\x0c\r\x00 ':
269
self.assertRaises(errors.BadIndexKey, builder.add_node,
270
('a%skey' % bad_char, ), 'data')
271
self.assertRaises(errors.BadIndexKey, builder.add_node,
273
self.assertRaises(errors.BadIndexKey, builder.add_node,
274
'not-a-tuple', 'data')
308
builder = _mod_index.GraphIndexBuilder()
309
for bad_char in bytearray(b'\t\n\x0b\x0c\r\x00 '):
310
self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
311
(b'a%skey' % bytes([bad_char]), ), b'data')
312
self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
314
self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
315
b'not-a-tuple', b'data')
275
316
# not enough length
276
self.assertRaises(errors.BadIndexKey, builder.add_node,
317
self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
279
self.assertRaises(errors.BadIndexKey, builder.add_node,
280
('primary', 'secondary'), 'data')
320
self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
321
(b'primary', b'secondary'), b'data')
281
322
# secondary key elements get checked too:
282
builder = GraphIndexBuilder(key_elements=2)
283
for bad_char in '\t\n\x0b\x0c\r\x00 ':
284
self.assertRaises(errors.BadIndexKey, builder.add_node,
285
('prefix', 'a%skey' % bad_char), 'data')
323
builder = _mod_index.GraphIndexBuilder(key_elements=2)
324
for bad_char in bytearray(b'\t\n\x0b\x0c\r\x00 '):
325
self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
326
(b'prefix', b'a%skey' % bytes([bad_char])), b'data')
287
328
def test_add_node_bad_data(self):
288
builder = GraphIndexBuilder()
289
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
291
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
329
builder = _mod_index.GraphIndexBuilder()
330
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
332
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
294
335
def test_add_node_bad_mismatched_ref_lists_length(self):
295
builder = GraphIndexBuilder()
296
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
298
builder = GraphIndexBuilder(reference_lists=1)
299
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
301
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
303
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
305
builder = GraphIndexBuilder(reference_lists=2)
306
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
308
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
310
self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
311
'data aa', ([], [], []))
336
builder = _mod_index.GraphIndexBuilder()
337
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
339
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
340
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
342
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
344
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
345
b'data aa', ([], []))
346
builder = _mod_index.GraphIndexBuilder(reference_lists=2)
347
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
349
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
351
self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
352
b'data aa', ([], [], []))
313
354
def test_add_node_bad_key_in_reference_lists(self):
314
355
# first list, first key - trivial
315
builder = GraphIndexBuilder(reference_lists=1)
316
self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
317
'data aa', ([('a key', )], ))
356
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
357
self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
358
b'data aa', ([(b'a key', )], ))
318
359
# references keys must be tuples too
319
self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
320
'data aa', (['not-a-tuple'], ))
360
self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
361
b'data aa', (['not-a-tuple'], ))
321
362
# not enough length
322
self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
363
self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
364
b'data aa', ([()], ))
325
self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
326
'data aa', ([('primary', 'secondary')], ))
366
self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
367
b'data aa', ([(b'primary', b'secondary')], ))
327
368
# need to check more than the first key in the list
328
self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
329
'data aa', ([('agoodkey', ), ('that is a bad key', )], ))
369
self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
370
b'data aa', ([(b'agoodkey', ), (b'that is a bad key', )], ))
330
371
# and if there is more than one list it should be getting checked
332
builder = GraphIndexBuilder(reference_lists=2)
333
self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
334
'data aa', ([], ['a bad key']))
373
builder = _mod_index.GraphIndexBuilder(reference_lists=2)
374
self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
375
b'data aa', ([], ['a bad key']))
336
377
def test_add_duplicate_key(self):
337
builder = GraphIndexBuilder()
338
builder.add_node(('key', ), 'data')
339
self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node, ('key', ),
378
builder = _mod_index.GraphIndexBuilder()
379
builder.add_node((b'key', ), b'data')
380
self.assertRaises(_mod_index.BadIndexDuplicateKey,
381
builder.add_node, (b'key', ), b'data')
342
383
def test_add_duplicate_key_2_elements(self):
343
builder = GraphIndexBuilder(key_elements=2)
344
builder.add_node(('key', 'key'), 'data')
345
self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node,
346
('key', 'key'), 'data')
384
builder = _mod_index.GraphIndexBuilder(key_elements=2)
385
builder.add_node((b'key', b'key'), b'data')
386
self.assertRaises(_mod_index.BadIndexDuplicateKey, builder.add_node,
387
(b'key', b'key'), b'data')
348
389
def test_add_key_after_referencing_key(self):
349
builder = GraphIndexBuilder(reference_lists=1)
350
builder.add_node(('key', ), 'data', ([('reference', )], ))
351
builder.add_node(('reference', ), 'data', ([],))
390
builder = _mod_index.GraphIndexBuilder(reference_lists=1)
391
builder.add_node((b'key', ), b'data', ([(b'reference', )], ))
392
builder.add_node((b'reference', ), b'data', ([],))
353
394
def test_add_key_after_referencing_key_2_elements(self):
354
builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
355
builder.add_node(('k', 'ey'), 'data', ([('reference', 'tokey')], ))
356
builder.add_node(('reference', 'tokey'), 'data', ([],))
395
builder = _mod_index.GraphIndexBuilder(
396
reference_lists=1, key_elements=2)
397
builder.add_node((b'k', b'ey'), b'data',
398
([(b'reference', b'tokey')], ))
399
builder.add_node((b'reference', b'tokey'), b'data', ([],))
358
401
def test_set_optimize(self):
359
builder = GraphIndexBuilder(reference_lists=1, key_elements=2)
402
builder = _mod_index.GraphIndexBuilder(
403
reference_lists=1, key_elements=2)
360
404
builder.set_optimize(for_size=True)
361
405
self.assertTrue(builder._optimize_for_size)
362
406
builder.set_optimize(for_size=False)
363
407
self.assertFalse(builder._optimize_for_size)
366
class TestGraphIndex(TestCaseWithMemoryTransport):
410
class TestGraphIndex(tests.TestCaseWithMemoryTransport):
368
412
def make_key(self, number):
369
return (str(number) + 'X'*100,)
413
return ((b'%d' % number) + b'X' * 100,)
371
415
def make_value(self, number):
372
return str(number) + 'Y'*100
416
return (b'%d' % number) + b'Y' * 100
374
418
def make_nodes(self, count=64):
375
419
# generate a big enough index that we only read some of it on a typical
376
420
# bisection lookup.
378
422
for counter in range(count):
379
nodes.append((self.make_key(counter), self.make_value(counter), ()))
424
(self.make_key(counter), self.make_value(counter), ()))
382
427
def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
383
builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
428
builder = _mod_index.GraphIndexBuilder(
429
ref_lists, key_elements=key_elements)
384
430
for key, value, references in nodes:
385
431
builder.add_node(key, value, references)
386
432
stream = builder.finish()
387
trans = get_transport('trace+' + self.get_url())
433
trans = transport.get_transport_from_url('trace+' + self.get_url())
388
434
size = trans.put_file('index', stream)
389
return GraphIndex(trans, 'index', size)
435
return _mod_index.GraphIndex(trans, 'index', size)
391
437
def make_index_with_offset(self, ref_lists=0, key_elements=1, nodes=[],
393
builder = GraphIndexBuilder(ref_lists, key_elements=key_elements)
439
builder = _mod_index.GraphIndexBuilder(
440
ref_lists, key_elements=key_elements)
394
441
for key, value, references in nodes:
395
442
builder.add_node(key, value, references)
396
443
content = builder.finish().read()
397
444
size = len(content)
398
445
trans = self.get_transport()
399
trans.put_bytes('index', (' '*offset) + content)
400
return GraphIndex(trans, 'index', size, offset=offset)
446
trans.put_bytes('index', (b' ' * offset) + content)
447
return _mod_index.GraphIndex(trans, 'index', size, offset=offset)
402
449
def test_clear_cache(self):
403
450
index = self.make_index()
782
829
def test_iter_entries_references_resolved(self):
783
830
index = self.make_index(1, nodes=[
784
(('name', ), 'data', ([('ref', ), ('ref', )], )),
785
(('ref', ), 'refdata', ([], ))])
786
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),('ref',)),)),
787
(index, ('ref', ), 'refdata', ((), ))]),
788
set(index.iter_entries([('name',), ('ref',)])))
831
((b'name', ), b'data', ([(b'ref', ), (b'ref', )], )),
832
((b'ref', ), b'refdata', ([], ))])
833
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',), (b'ref',)),)),
834
(index, (b'ref', ), b'refdata', ((), ))},
835
set(index.iter_entries([(b'name',), (b'ref',)])))
790
837
def test_iter_entries_references_2_refs_resolved(self):
791
838
index = self.make_index(2, nodes=[
792
(('name', ), 'data', ([('ref', )], [('ref', )])),
793
(('ref', ), 'refdata', ([], []))])
794
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),), (('ref',),))),
795
(index, ('ref', ), 'refdata', ((), ()))]),
796
set(index.iter_entries([('name',), ('ref',)])))
839
((b'name', ), b'data', ([(b'ref', )], [(b'ref', )])),
840
((b'ref', ), b'refdata', ([], []))])
841
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),), ((b'ref',),))),
842
(index, (b'ref', ), b'refdata', ((), ()))},
843
set(index.iter_entries([(b'name',), (b'ref',)])))
798
845
def test_iteration_absent_skipped(self):
799
846
index = self.make_index(1, nodes=[
800
(('name', ), 'data', ([('ref', )], ))])
801
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
802
set(index.iter_all_entries()))
803
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
804
set(index.iter_entries([('name', )])))
805
self.assertEqual([], list(index.iter_entries([('ref', )])))
847
((b'name', ), b'data', ([(b'ref', )], ))])
848
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
849
set(index.iter_all_entries()))
850
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
851
set(index.iter_entries([(b'name', )])))
852
self.assertEqual([], list(index.iter_entries([(b'ref', )])))
807
854
def test_iteration_absent_skipped_2_element_keys(self):
808
855
index = self.make_index(1, key_elements=2, nodes=[
809
(('name', 'fin'), 'data', ([('ref', 'erence')], ))])
810
self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
811
set(index.iter_all_entries()))
812
self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
813
set(index.iter_entries([('name', 'fin')])))
814
self.assertEqual([], list(index.iter_entries([('ref', 'erence')])))
856
((b'name', b'fin'), b'data', ([(b'ref', b'erence')], ))])
857
self.assertEqual([(index, (b'name', b'fin'), b'data', (((b'ref', b'erence'),),))],
858
list(index.iter_all_entries()))
859
self.assertEqual([(index, (b'name', b'fin'), b'data', (((b'ref', b'erence'),),))],
860
list(index.iter_entries([(b'name', b'fin')])))
861
self.assertEqual([], list(index.iter_entries([(b'ref', b'erence')])))
816
863
def test_iter_all_keys(self):
817
864
index = self.make_index(1, nodes=[
818
(('name', ), 'data', ([('ref', )], )),
819
(('ref', ), 'refdata', ([], ))])
820
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
821
(index, ('ref', ), 'refdata', ((), ))]),
822
set(index.iter_entries([('name', ), ('ref', )])))
865
((b'name', ), b'data', ([(b'ref', )], )),
866
((b'ref', ), b'refdata', ([], ))])
867
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
868
(index, (b'ref', ), b'refdata', ((), ))},
869
set(index.iter_entries([(b'name', ), (b'ref', )])))
824
871
def test_iter_nothing_empty(self):
825
872
index = self.make_index()
828
875
def test_iter_missing_entry_empty(self):
829
876
index = self.make_index()
830
self.assertEqual([], list(index.iter_entries([('a', )])))
877
self.assertEqual([], list(index.iter_entries([(b'a', )])))
832
879
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', )])))
880
idx = self.make_index()
881
idx = _mod_index.GraphIndex(idx._transport, 'index', None)
882
self.assertEqual([], list(idx.iter_entries([(b'a', )])))
837
884
def test_iter_key_prefix_1_element_key_None(self):
838
885
index = self.make_index()
839
self.assertRaises(errors.BadIndexKey, list,
840
index.iter_entries_prefix([(None, )]))
886
self.assertRaises(_mod_index.BadIndexKey, list,
887
index.iter_entries_prefix([(None, )]))
842
889
def test_iter_key_prefix_wrong_length(self):
843
890
index = self.make_index()
844
self.assertRaises(errors.BadIndexKey, list,
845
index.iter_entries_prefix([('foo', None)]))
891
self.assertRaises(_mod_index.BadIndexKey, list,
892
index.iter_entries_prefix([(b'foo', None)]))
846
893
index = self.make_index(key_elements=2)
847
self.assertRaises(errors.BadIndexKey, list,
848
index.iter_entries_prefix([('foo', )]))
849
self.assertRaises(errors.BadIndexKey, list,
850
index.iter_entries_prefix([('foo', None, None)]))
894
self.assertRaises(_mod_index.BadIndexKey, list,
895
index.iter_entries_prefix([(b'foo', )]))
896
self.assertRaises(_mod_index.BadIndexKey, list,
897
index.iter_entries_prefix([(b'foo', None, None)]))
852
899
def test_iter_key_prefix_1_key_element_no_refs(self):
853
index = self.make_index( nodes=[
854
(('name', ), 'data', ()),
855
(('ref', ), 'refdata', ())])
856
self.assertEqual(set([(index, ('name', ), 'data'),
857
(index, ('ref', ), 'refdata')]),
858
set(index.iter_entries_prefix([('name', ), ('ref', )])))
900
index = self.make_index(nodes=[
901
((b'name', ), b'data', ()),
902
((b'ref', ), b'refdata', ())])
903
self.assertEqual({(index, (b'name', ), b'data'),
904
(index, (b'ref', ), b'refdata')},
905
set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
860
907
def test_iter_key_prefix_1_key_element_refs(self):
861
908
index = self.make_index(1, nodes=[
862
(('name', ), 'data', ([('ref', )], )),
863
(('ref', ), 'refdata', ([], ))])
864
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
865
(index, ('ref', ), 'refdata', ((), ))]),
866
set(index.iter_entries_prefix([('name', ), ('ref', )])))
909
((b'name', ), b'data', ([(b'ref', )], )),
910
((b'ref', ), b'refdata', ([], ))])
911
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
912
(index, (b'ref', ), b'refdata', ((), ))},
913
set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
868
915
def test_iter_key_prefix_2_key_element_no_refs(self):
869
916
index = self.make_index(key_elements=2, nodes=[
870
(('name', 'fin1'), 'data', ()),
871
(('name', 'fin2'), 'beta', ()),
872
(('ref', 'erence'), 'refdata', ())])
873
self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
874
(index, ('ref', 'erence'), 'refdata')]),
875
set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
876
self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
877
(index, ('name', 'fin2'), 'beta')]),
878
set(index.iter_entries_prefix([('name', None)])))
917
((b'name', b'fin1'), b'data', ()),
918
((b'name', b'fin2'), b'beta', ()),
919
((b'ref', b'erence'), b'refdata', ())])
920
self.assertEqual({(index, (b'name', b'fin1'), b'data'),
921
(index, (b'ref', b'erence'), b'refdata')},
922
set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
923
self.assertEqual({(index, (b'name', b'fin1'), b'data'),
924
(index, (b'name', b'fin2'), b'beta')},
925
set(index.iter_entries_prefix([(b'name', None)])))
880
927
def test_iter_key_prefix_2_key_element_refs(self):
881
928
index = self.make_index(1, key_elements=2, nodes=[
882
(('name', 'fin1'), 'data', ([('ref', 'erence')], )),
883
(('name', 'fin2'), 'beta', ([], )),
884
(('ref', 'erence'), 'refdata', ([], ))])
885
self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
886
(index, ('ref', 'erence'), 'refdata', ((), ))]),
887
set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
888
self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
889
(index, ('name', 'fin2'), 'beta', ((), ))]),
890
set(index.iter_entries_prefix([('name', None)])))
929
((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], )),
930
((b'name', b'fin2'), b'beta', ([], )),
931
((b'ref', b'erence'), b'refdata', ([], ))])
932
self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
933
(index, (b'ref', b'erence'), b'refdata', ((), ))},
934
set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
935
self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
936
(index, (b'name', b'fin2'), b'beta', ((), ))},
937
set(index.iter_entries_prefix([(b'name', None)])))
892
939
def test_key_count_empty(self):
893
940
index = self.make_index()
894
941
self.assertEqual(0, index.key_count())
896
943
def test_key_count_one(self):
897
index = self.make_index(nodes=[(('name', ), '', ())])
944
index = self.make_index(nodes=[((b'name', ), b'', ())])
898
945
self.assertEqual(1, index.key_count())
900
947
def test_key_count_two(self):
901
948
index = self.make_index(nodes=[
902
(('name', ), '', ()), (('foo', ), '', ())])
949
((b'name', ), b'', ()), ((b'foo', ), b'', ())])
903
950
self.assertEqual(2, index.key_count())
905
952
def test_read_and_parse_tracks_real_read_value(self):
1128
1179
log.append(self._index)
1129
1180
return self._index.clear_cache()
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))
1182
idx = _mod_index.CombinedGraphIndex([])
1183
idx1 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
1184
idx.insert_index(0, ClearCacheProxy(idx1))
1185
idx2 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
1186
idx.insert_index(1, ClearCacheProxy(idx2))
1136
1187
# CombinedGraphIndex should call 'clear_cache()' on all children
1138
self.assertEqual(sorted([index1, index2]), sorted(log))
1189
self.assertEqual(sorted([idx1, idx2]), sorted(log))
1140
1191
def test_iter_all_entries_empty(self):
1141
index = CombinedGraphIndex([])
1142
self.assertEqual([], list(index.iter_all_entries()))
1192
idx = _mod_index.CombinedGraphIndex([])
1193
self.assertEqual([], list(idx.iter_all_entries()))
1144
1195
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()))
1196
idx1 = self.make_index('name')
1197
idx = _mod_index.CombinedGraphIndex([idx1])
1198
self.assertEqual([], list(idx.iter_all_entries()))
1149
1200
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()))
1201
idx1 = self.make_index('name', nodes=[((b'name', ), b'data', ())])
1202
idx = _mod_index.CombinedGraphIndex([idx1])
1203
self.assertEqual([(idx1, (b'name', ), b'data')],
1204
list(idx.iter_all_entries()))
1155
1206
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()))
1207
idx1 = self.make_index('name1', nodes=[((b'name', ), b'data', ())])
1208
idx2 = self.make_index('name2', nodes=[((b'2', ), b'', ())])
1209
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1210
self.assertEqual([(idx1, (b'name', ), b'data'),
1211
(idx2, (b'2', ), b'')],
1212
list(idx.iter_all_entries()))
1163
1214
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', )])))
1215
idx1 = self.make_index('name1', nodes=[((b'name', ), b'data', ())])
1216
idx2 = self.make_index('name2', nodes=[((b'name', ), b'data', ())])
1217
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1218
self.assertEqual([(idx1, (b'name', ), b'data')],
1219
list(idx.iter_entries([(b'name', )])))
1170
1221
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()))
1222
idx1 = self.make_index('name1', nodes=[((b'name', ), b'data', ())])
1223
idx2 = self.make_index('name2', nodes=[((b'name', ), b'data', ())])
1224
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1225
self.assertEqual([(idx1, (b'name', ), b'data')],
1226
list(idx.iter_all_entries()))
1177
1228
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)])))
1229
idx1 = self.make_index('1', 1, key_elements=2, nodes=[
1230
((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], ))])
1231
idx2 = self.make_index('2', 1, key_elements=2, nodes=[
1232
((b'name', b'fin2'), b'beta', ([], )),
1233
((b'ref', b'erence'), b'refdata', ([], ))])
1234
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1235
self.assertEqual({(idx1, (b'name', b'fin1'), b'data',
1236
(((b'ref', b'erence'),),)),
1237
(idx2, (b'ref', b'erence'), b'refdata', ((), ))},
1238
set(idx.iter_entries_prefix([(b'name', b'fin1'),
1239
(b'ref', b'erence')])))
1240
self.assertEqual({(idx1, (b'name', b'fin1'), b'data',
1241
(((b'ref', b'erence'),),)),
1242
(idx2, (b'name', b'fin2'), b'beta', ((), ))},
1243
set(idx.iter_entries_prefix([(b'name', None)])))
1191
1245
def test_iter_nothing_empty(self):
1192
index = CombinedGraphIndex([])
1193
self.assertEqual([], list(index.iter_entries([])))
1246
idx = _mod_index.CombinedGraphIndex([])
1247
self.assertEqual([], list(idx.iter_entries([])))
1195
1249
def test_iter_nothing_children_empty(self):
1196
index1 = self.make_index('name')
1197
index = CombinedGraphIndex([index1])
1198
self.assertEqual([], list(index.iter_entries([])))
1250
idx1 = self.make_index('name')
1251
idx = _mod_index.CombinedGraphIndex([idx1])
1252
self.assertEqual([], list(idx.iter_entries([])))
1200
1254
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', )])))
1255
idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',
1257
idx2 = self.make_index(
1258
'2', 1, nodes=[((b'ref', ), b'refdata', ((), ))])
1259
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1260
self.assertEqual({(idx1, (b'name', ), b'data', (((b'ref', ), ), )),
1261
(idx2, (b'ref', ), b'refdata', ((), ))},
1262
set(idx.iter_entries([(b'name', ), (b'ref', )])))
1210
1264
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', )])))
1265
idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',
1267
((b'ref', ), b'refdata', ([], ))])
1268
idx2 = self.make_index(
1269
'2', 1, nodes=[((b'ref', ), b'refdata', ([], ))])
1270
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1271
self.assertEqual({(idx1, (b'name', ), b'data', (((b'ref',),),)),
1272
(idx1, (b'ref', ), b'refdata', ((), ))},
1273
set(idx.iter_entries([(b'name', ), (b'ref', )])))
1221
1275
def test_iter_missing_entry_empty(self):
1222
index = CombinedGraphIndex([])
1223
self.assertEqual([], list(index.iter_entries([('a', )])))
1276
idx = _mod_index.CombinedGraphIndex([])
1277
self.assertEqual([], list(idx.iter_entries([('a', )])))
1225
1279
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', )])))
1280
idx1 = self.make_index('1')
1281
idx = _mod_index.CombinedGraphIndex([idx1])
1282
self.assertEqual([], list(idx.iter_entries([(b'a', )])))
1230
1284
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', )])))
1285
idx1 = self.make_index('1')
1286
idx2 = self.make_index('2')
1287
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1288
self.assertEqual([], list(idx.iter_entries([('a', )])))
1236
1290
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', )])))
1291
idx1 = self.make_index('1', nodes=[((b'key', ), b'', ())])
1292
idx2 = self.make_index('2', nodes=[])
1293
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1294
self.assertEqual([(idx1, (b'key', ), b'')],
1295
list(idx.iter_entries([(b'key', )])))
1242
1296
# and in the other direction
1243
index = CombinedGraphIndex([index2, index1])
1244
self.assertEqual([(index1, ('key', ), '')],
1245
list(index.iter_entries([('key', )])))
1297
idx = _mod_index.CombinedGraphIndex([idx2, idx1])
1298
self.assertEqual([(idx1, (b'key', ), b'')],
1299
list(idx.iter_entries([(b'key', )])))
1247
1301
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())
1302
idx1 = self.make_index('1', nodes=[])
1303
idx2 = self.make_index('2', nodes=[])
1304
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1305
self.assertEqual(0, idx.key_count())
1253
1307
def test_key_count_sums_index_keys(self):
1254
index1 = self.make_index('1', nodes=[
1257
index2 = self.make_index('2', nodes=[(('1',), '', ())])
1258
index = CombinedGraphIndex([index1, index2])
1259
self.assertEqual(3, index.key_count())
1308
idx1 = self.make_index('1', nodes=[
1310
((b'2',), b'', ())])
1311
idx2 = self.make_index('2', nodes=[((b'1',), b'', ())])
1312
idx = _mod_index.CombinedGraphIndex([idx1, idx2])
1313
self.assertEqual(3, idx.key_count())
1261
1315
def test_validate_bad_child_index_errors(self):
1262
1316
trans = self.get_transport()
1263
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)
1317
trans.put_bytes('name', b"not an index\n")
1318
idx1 = _mod_index.GraphIndex(trans, 'name', 13)
1319
idx = _mod_index.CombinedGraphIndex([idx1])
1320
self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
1268
1322
def test_validate_empty(self):
1269
index = CombinedGraphIndex([])
1323
idx = _mod_index.CombinedGraphIndex([])
1272
1326
def test_key_count_reloads(self):
1273
index, reload_counter = self.make_combined_index_with_missing()
1274
self.assertEqual(2, index.key_count())
1327
idx, reload_counter = self.make_combined_index_with_missing()
1328
self.assertEqual(2, idx.key_count())
1275
1329
self.assertEqual([1, 1, 0], reload_counter)
1277
1331
def test_key_count_no_reload(self):
1278
index, reload_counter = self.make_combined_index_with_missing()
1279
index._reload_func = None
1332
idx, reload_counter = self.make_combined_index_with_missing()
1333
idx._reload_func = None
1280
1334
# Without a _reload_func we just raise the exception
1281
self.assertRaises(errors.NoSuchFile, index.key_count)
1335
self.assertRaises(errors.NoSuchFile, idx.key_count)
1283
1337
def test_key_count_reloads_and_fails(self):
1284
1338
# We have deleted all underlying indexes, so we will try to reload, but
1285
1339
# still fail. This is mostly to test we don't get stuck in an infinite
1286
1340
# loop trying to reload
1287
index, reload_counter = self.make_combined_index_with_missing(
1289
self.assertRaises(errors.NoSuchFile, index.key_count)
1341
idx, reload_counter = self.make_combined_index_with_missing(
1343
self.assertRaises(errors.NoSuchFile, idx.key_count)
1290
1344
self.assertEqual([2, 1, 1], reload_counter)
1292
1346
def test_iter_entries_reloads(self):
1293
1347
index, reload_counter = self.make_combined_index_with_missing()
1294
result = list(index.iter_entries([('1',), ('2',), ('3',)]))
1348
result = list(index.iter_entries([(b'1',), (b'2',), (b'3',)]))
1295
1349
index3 = index._indices[0]
1296
self.assertEqual([(index3, ('1',), ''), (index3, ('2',), '')],
1350
self.assertEqual({(index3, (b'1',), b''), (index3, (b'2',), b'')},
1298
1352
self.assertEqual([1, 1, 0], reload_counter)
1300
1354
def test_iter_entries_reloads_midway(self):
1468
1521
self.assertEqual(set(), missing_keys)
1470
1523
def test_find_ancestors_missing_keys(self):
1475
1528
index1 = self.make_index('12', ref_lists=1, nodes=[
1476
(key1, 'value', ([],)),
1477
(key2, 'value', ([key1],)),
1529
(key1, b'value', ([],)),
1530
(key2, b'value', ([key1],)),
1479
1532
index2 = self.make_index('34', ref_lists=1, nodes=[
1480
(key3, 'value', ([key2],)),
1533
(key3, b'value', ([key2],)),
1482
c_index = CombinedGraphIndex([index1, index2])
1535
c_index = _mod_index.CombinedGraphIndex([index1, index2])
1483
1536
# Searching for a key which is actually not present at all should
1484
1537
# eventually converge
1485
1538
parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1486
1539
self.assertEqual({}, parent_map)
1487
self.assertEqual(set([key4]), missing_keys)
1540
self.assertEqual({key4}, missing_keys)
1489
1542
def test_find_ancestors_no_indexes(self):
1490
c_index = CombinedGraphIndex([])
1543
c_index = _mod_index.CombinedGraphIndex([])
1492
1545
parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1493
1546
self.assertEqual({}, parent_map)
1494
self.assertEqual(set([key1]), missing_keys)
1547
self.assertEqual({key1}, missing_keys)
1496
1549
def test_find_ancestors_ghost_parent(self):
1501
1554
index1 = self.make_index('12', ref_lists=1, nodes=[
1502
(key1, 'value', ([],)),
1503
(key2, 'value', ([key1],)),
1555
(key1, b'value', ([],)),
1556
(key2, b'value', ([key1],)),
1505
1558
index2 = self.make_index('34', ref_lists=1, nodes=[
1506
(key4, 'value', ([key2, key3],)),
1559
(key4, b'value', ([key2, key3],)),
1508
c_index = CombinedGraphIndex([index1, index2])
1561
c_index = _mod_index.CombinedGraphIndex([index1, index2])
1509
1562
# Searching for a key which is actually not present at all should
1510
1563
# eventually converge
1511
1564
parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1512
1565
self.assertEqual({key4: (key2, key3), key2: (key1,), key1: ()},
1514
self.assertEqual(set([key3]), missing_keys)
1567
self.assertEqual({key3}, missing_keys)
1516
1569
def test__find_ancestors_empty_index(self):
1517
index = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
1570
idx = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
1518
1571
parent_map = {}
1519
1572
missing_keys = set()
1520
search_keys = index._find_ancestors([('one',), ('two',)], 0, parent_map,
1573
search_keys = idx._find_ancestors([(b'one',), (b'two',)], 0, parent_map,
1522
1575
self.assertEqual(set(), search_keys)
1523
1576
self.assertEqual({}, parent_map)
1524
self.assertEqual(set([('one',), ('two',)]), missing_keys)
1527
class TestInMemoryGraphIndex(TestCaseWithMemoryTransport):
1577
self.assertEqual({(b'one',), (b'two',)}, missing_keys)
1580
class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):
1529
1582
def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
1530
result = InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1583
result = _mod_index.InMemoryGraphIndex(
1584
ref_lists, key_elements=key_elements)
1531
1585
result.add_nodes(nodes)
1534
1588
def test_add_nodes_no_refs(self):
1535
1589
index = self.make_index(0)
1536
index.add_nodes([(('name', ), 'data')])
1537
index.add_nodes([(('name2', ), ''), (('name3', ), '')])
1538
self.assertEqual(set([
1539
(index, ('name', ), 'data'),
1540
(index, ('name2', ), ''),
1541
(index, ('name3', ), ''),
1542
]), set(index.iter_all_entries()))
1590
index.add_nodes([((b'name', ), b'data')])
1591
index.add_nodes([((b'name2', ), b''), ((b'name3', ), b'')])
1593
(index, (b'name', ), b'data'),
1594
(index, (b'name2', ), b''),
1595
(index, (b'name3', ), b''),
1596
}, set(index.iter_all_entries()))
1544
1598
def test_add_nodes(self):
1545
1599
index = self.make_index(1)
1546
index.add_nodes([(('name', ), 'data', ([],))])
1547
index.add_nodes([(('name2', ), '', ([],)), (('name3', ), '', ([('r', )],))])
1548
self.assertEqual(set([
1549
(index, ('name', ), 'data', ((),)),
1550
(index, ('name2', ), '', ((),)),
1551
(index, ('name3', ), '', ((('r', ), ), )),
1552
]), set(index.iter_all_entries()))
1600
index.add_nodes([((b'name', ), b'data', ([],))])
1601
index.add_nodes([((b'name2', ), b'', ([],)),
1602
((b'name3', ), b'', ([(b'r', )],))])
1604
(index, (b'name', ), b'data', ((),)),
1605
(index, (b'name2', ), b'', ((),)),
1606
(index, (b'name3', ), b'', (((b'r', ), ), )),
1607
}, set(index.iter_all_entries()))
1554
1609
def test_iter_all_entries_empty(self):
1555
1610
index = self.make_index()
1556
1611
self.assertEqual([], list(index.iter_all_entries()))
1558
1613
def test_iter_all_entries_simple(self):
1559
index = self.make_index(nodes=[(('name', ), 'data')])
1560
self.assertEqual([(index, ('name', ), 'data')],
1561
list(index.iter_all_entries()))
1614
index = self.make_index(nodes=[((b'name', ), b'data')])
1615
self.assertEqual([(index, (b'name', ), b'data')],
1616
list(index.iter_all_entries()))
1563
1618
def test_iter_all_entries_references(self):
1564
1619
index = self.make_index(1, nodes=[
1565
(('name', ), 'data', ([('ref', )], )),
1566
(('ref', ), 'refdata', ([], ))])
1567
self.assertEqual(set([(index, ('name', ), 'data', ((('ref', ),),)),
1568
(index, ('ref', ), 'refdata', ((), ))]),
1569
set(index.iter_all_entries()))
1620
((b'name', ), b'data', ([(b'ref', )], )),
1621
((b'ref', ), b'refdata', ([], ))])
1622
self.assertEqual({(index, (b'name', ), b'data', (((b'ref', ),),)),
1623
(index, (b'ref', ), b'refdata', ((), ))},
1624
set(index.iter_all_entries()))
1571
1626
def test_iteration_absent_skipped(self):
1572
1627
index = self.make_index(1, nodes=[
1573
(('name', ), 'data', ([('ref', )], ))])
1574
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
1575
set(index.iter_all_entries()))
1576
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
1577
set(index.iter_entries([('name', )])))
1578
self.assertEqual([], list(index.iter_entries([('ref', )])))
1628
((b'name', ), b'data', ([(b'ref', )], ))])
1629
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
1630
set(index.iter_all_entries()))
1631
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
1632
set(index.iter_entries([(b'name', )])))
1633
self.assertEqual([], list(index.iter_entries([(b'ref', )])))
1580
1635
def test_iter_all_keys(self):
1581
1636
index = self.make_index(1, nodes=[
1582
(('name', ), 'data', ([('ref', )], )),
1583
(('ref', ), 'refdata', ([], ))])
1584
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
1585
(index, ('ref', ), 'refdata', ((), ))]),
1586
set(index.iter_entries([('name', ), ('ref', )])))
1637
((b'name', ), b'data', ([(b'ref', )], )),
1638
((b'ref', ), b'refdata', ([], ))])
1639
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
1640
(index, (b'ref', ), b'refdata', ((), ))},
1641
set(index.iter_entries([(b'name', ), (b'ref', )])))
1588
1643
def test_iter_key_prefix_1_key_element_no_refs(self):
1589
index = self.make_index( nodes=[
1590
(('name', ), 'data'),
1591
(('ref', ), 'refdata')])
1592
self.assertEqual(set([(index, ('name', ), 'data'),
1593
(index, ('ref', ), 'refdata')]),
1594
set(index.iter_entries_prefix([('name', ), ('ref', )])))
1644
index = self.make_index(nodes=[
1645
((b'name', ), b'data'),
1646
((b'ref', ), b'refdata')])
1647
self.assertEqual({(index, (b'name', ), b'data'),
1648
(index, (b'ref', ), b'refdata')},
1649
set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
1596
1651
def test_iter_key_prefix_1_key_element_refs(self):
1597
1652
index = self.make_index(1, nodes=[
1598
(('name', ), 'data', ([('ref', )], )),
1599
(('ref', ), 'refdata', ([], ))])
1600
self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
1601
(index, ('ref', ), 'refdata', ((), ))]),
1602
set(index.iter_entries_prefix([('name', ), ('ref', )])))
1653
((b'name', ), b'data', ([(b'ref', )], )),
1654
((b'ref', ), b'refdata', ([], ))])
1655
self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
1656
(index, (b'ref', ), b'refdata', ((), ))},
1657
set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
1604
1659
def test_iter_key_prefix_2_key_element_no_refs(self):
1605
1660
index = self.make_index(key_elements=2, nodes=[
1606
(('name', 'fin1'), 'data'),
1607
(('name', 'fin2'), 'beta'),
1608
(('ref', 'erence'), 'refdata')])
1609
self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
1610
(index, ('ref', 'erence'), 'refdata')]),
1611
set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1612
self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
1613
(index, ('name', 'fin2'), 'beta')]),
1614
set(index.iter_entries_prefix([('name', None)])))
1661
((b'name', b'fin1'), b'data'),
1662
((b'name', b'fin2'), b'beta'),
1663
((b'ref', b'erence'), b'refdata')])
1664
self.assertEqual({(index, (b'name', b'fin1'), b'data'),
1665
(index, (b'ref', b'erence'), b'refdata')},
1666
set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
1667
self.assertEqual({(index, (b'name', b'fin1'), b'data'),
1668
(index, (b'name', b'fin2'), b'beta')},
1669
set(index.iter_entries_prefix([(b'name', None)])))
1616
1671
def test_iter_key_prefix_2_key_element_refs(self):
1617
1672
index = self.make_index(1, key_elements=2, nodes=[
1618
(('name', 'fin1'), 'data', ([('ref', 'erence')], )),
1619
(('name', 'fin2'), 'beta', ([], )),
1620
(('ref', 'erence'), 'refdata', ([], ))])
1621
self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1622
(index, ('ref', 'erence'), 'refdata', ((), ))]),
1623
set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
1624
self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
1625
(index, ('name', 'fin2'), 'beta', ((), ))]),
1626
set(index.iter_entries_prefix([('name', None)])))
1673
((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], )),
1674
((b'name', b'fin2'), b'beta', ([], )),
1675
((b'ref', b'erence'), b'refdata', ([], ))])
1676
self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
1677
(index, (b'ref', b'erence'), b'refdata', ((), ))},
1678
set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
1679
self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
1680
(index, (b'name', b'fin2'), b'beta', ((), ))},
1681
set(index.iter_entries_prefix([(b'name', None)])))
1628
1683
def test_iter_nothing_empty(self):
1629
1684
index = self.make_index()
1650
1705
index.validate()
1652
1707
def test_validate_no_refs_content(self):
1653
index = self.make_index(nodes=[(('key', ), 'value')])
1708
index = self.make_index(nodes=[((b'key', ), b'value')])
1654
1709
index.validate()
1657
class TestGraphIndexPrefixAdapter(TestCaseWithMemoryTransport):
1712
class TestGraphIndexPrefixAdapter(tests.TestCaseWithMemoryTransport):
1659
def make_index(self, ref_lists=1, key_elements=2, nodes=[], add_callback=False):
1660
result = InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1714
def make_index(self, ref_lists=1, key_elements=2, nodes=[],
1715
add_callback=False):
1716
result = _mod_index.InMemoryGraphIndex(
1717
ref_lists, key_elements=key_elements)
1661
1718
result.add_nodes(nodes)
1662
1719
if add_callback:
1663
1720
add_nodes_callback = result.add_nodes
1665
1722
add_nodes_callback = None
1666
adapter = GraphIndexPrefixAdapter(result, ('prefix', ), key_elements - 1,
1723
adapter = _mod_index.GraphIndexPrefixAdapter(
1724
result, (b'prefix', ), key_elements - 1,
1667
1725
add_nodes_callback=add_nodes_callback)
1668
1726
return result, adapter
1670
1728
def test_add_node(self):
1671
1729
index, adapter = self.make_index(add_callback=True)
1672
adapter.add_node(('key',), 'value', ((('ref',),),))
1673
self.assertEqual(set([(index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))]),
1674
set(index.iter_all_entries()))
1730
adapter.add_node((b'key',), b'value', (((b'ref',),),))
1731
self.assertEqual({(index, (b'prefix', b'key'), b'value',
1732
(((b'prefix', b'ref'),),))},
1733
set(index.iter_all_entries()))
1676
1735
def test_add_nodes(self):
1677
1736
index, adapter = self.make_index(add_callback=True)
1678
1737
adapter.add_nodes((
1679
(('key',), 'value', ((('ref',),),)),
1680
(('key2',), 'value2', ((),)),
1738
((b'key',), b'value', (((b'ref',),),)),
1739
((b'key2',), b'value2', ((),)),
1682
self.assertEqual(set([
1683
(index, ('prefix', 'key2'), 'value2', ((),)),
1684
(index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))
1742
(index, (b'prefix', b'key2'), b'value2', ((),)),
1743
(index, (b'prefix', b'key'), b'value', (((b'prefix', b'ref'),),))
1686
1745
set(index.iter_all_entries()))
1688
1747
def test_construct(self):
1689
index = InMemoryGraphIndex()
1690
adapter = GraphIndexPrefixAdapter(index, ('prefix', ), 1)
1748
idx = _mod_index.InMemoryGraphIndex()
1749
adapter = _mod_index.GraphIndexPrefixAdapter(idx, (b'prefix', ), 1)
1692
1751
def test_construct_with_callback(self):
1693
index = InMemoryGraphIndex()
1694
adapter = GraphIndexPrefixAdapter(index, ('prefix', ), 1, index.add_nodes)
1752
idx = _mod_index.InMemoryGraphIndex()
1753
adapter = _mod_index.GraphIndexPrefixAdapter(idx, (b'prefix', ), 1,
1696
1756
def test_iter_all_entries_cross_prefix_map_errors(self):
1697
1757
index, adapter = self.make_index(nodes=[
1698
(('prefix', 'key1'), 'data1', ((('prefixaltered', 'key2'),),))])
1699
self.assertRaises(errors.BadIndexData, list, adapter.iter_all_entries())
1758
((b'prefix', b'key1'), b'data1', (((b'prefixaltered', b'key2'),),))])
1759
self.assertRaises(_mod_index.BadIndexData, list,
1760
adapter.iter_all_entries())
1701
1762
def test_iter_all_entries(self):
1702
1763
index, adapter = self.make_index(nodes=[
1703
(('notprefix', 'key1'), 'data', ((), )),
1704
(('prefix', 'key1'), 'data1', ((), )),
1705
(('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1706
self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
1707
(index, ('key2', ), 'data2', ((('key1',),),))]),
1708
set(adapter.iter_all_entries()))
1764
((b'notprefix', b'key1'), b'data', ((), )),
1765
((b'prefix', b'key1'), b'data1', ((), )),
1766
((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])
1767
self.assertEqual({(index, (b'key1', ), b'data1', ((),)),
1768
(index, (b'key2', ), b'data2', (((b'key1',),),))},
1769
set(adapter.iter_all_entries()))
1710
1771
def test_iter_entries(self):
1711
1772
index, adapter = self.make_index(nodes=[
1712
(('notprefix', 'key1'), 'data', ((), )),
1713
(('prefix', 'key1'), 'data1', ((), )),
1714
(('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1773
((b'notprefix', b'key1'), b'data', ((), )),
1774
((b'prefix', b'key1'), b'data1', ((), )),
1775
((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])
1715
1776
# ask for many - get all
1716
self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
1717
(index, ('key2', ), 'data2', ((('key1', ),),))]),
1718
set(adapter.iter_entries([('key1', ), ('key2', )])))
1777
self.assertEqual({(index, (b'key1', ), b'data1', ((),)),
1778
(index, (b'key2', ), b'data2', (((b'key1', ),),))},
1779
set(adapter.iter_entries([(b'key1', ), (b'key2', )])))
1719
1780
# ask for one, get one
1720
self.assertEqual(set([(index, ('key1', ), 'data1', ((),))]),
1721
set(adapter.iter_entries([('key1', )])))
1781
self.assertEqual({(index, (b'key1', ), b'data1', ((),))},
1782
set(adapter.iter_entries([(b'key1', )])))
1722
1783
# ask for missing, get none
1723
1784
self.assertEqual(set(),
1724
set(adapter.iter_entries([('key3', )])))
1785
set(adapter.iter_entries([(b'key3', )])))
1726
1787
def test_iter_entries_prefix(self):
1727
1788
index, adapter = self.make_index(key_elements=3, nodes=[
1728
(('notprefix', 'foo', 'key1'), 'data', ((), )),
1729
(('prefix', 'prefix2', 'key1'), 'data1', ((), )),
1730
(('prefix', 'prefix2', 'key2'), 'data2', ((('prefix', 'prefix2', 'key1'),),))])
1789
((b'notprefix', b'foo', b'key1'), b'data', ((), )),
1790
((b'prefix', b'prefix2', b'key1'), b'data1', ((), )),
1791
((b'prefix', b'prefix2', b'key2'), b'data2', (((b'prefix', b'prefix2', b'key1'),),))])
1731
1792
# 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', ),),))]),
1734
set(adapter.iter_entries_prefix([('prefix2', None)])))
1793
self.assertEqual({(index, (b'prefix2', b'key1', ), b'data1', ((),)),
1794
(index, (b'prefix2', b'key2', ), b'data2', (((b'prefix2', b'key1', ),),))},
1795
set(adapter.iter_entries_prefix([(b'prefix2', None)])))
1736
1797
def test_key_count_no_matching_keys(self):
1737
1798
index, adapter = self.make_index(nodes=[
1738
(('notprefix', 'key1'), 'data', ((), ))])
1799
((b'notprefix', b'key1'), b'data', ((), ))])
1739
1800
self.assertEqual(0, adapter.key_count())
1741
1802
def test_key_count_some_keys(self):
1742
1803
index, adapter = self.make_index(nodes=[
1743
(('notprefix', 'key1'), 'data', ((), )),
1744
(('prefix', 'key1'), 'data1', ((), )),
1745
(('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1804
((b'notprefix', b'key1'), b'data', ((), )),
1805
((b'prefix', b'key1'), b'data1', ((), )),
1806
((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])
1746
1807
self.assertEqual(2, adapter.key_count())
1748
1809
def test_validate(self):
1749
1810
index, adapter = self.make_index()
1751
1813
def validate():
1752
1814
calls.append('called')
1753
1815
index.validate = validate
added
removed
breezy/bzr/tests/test_index.py
