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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
brzlib/tests/test_index.py
16
16
 
17
17
"""Tests for indices."""
18
18
 
19
 
from .. import (
 
19
from brzlib import (
20
20
    errors,
 
21
    index,
21
22
    tests,
22
23
    transport,
23
24
    )
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
25
 
61
26
 
62
27
class TestGraphIndexBuilder(tests.TestCaseWithMemoryTransport):
63
28
 
64
29
    def test_build_index_empty(self):
65
 
        builder = _mod_index.GraphIndexBuilder()
 
30
        builder = index.GraphIndexBuilder()
66
31
        stream = builder.finish()
67
32
        contents = stream.read()
68
33
        self.assertEqual(
69
 
            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=0\n\n",
 
34
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=0\n\n",
70
35
            contents)
71
36
 
72
37
    def test_build_index_empty_two_element_keys(self):
73
 
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
 
38
        builder = index.GraphIndexBuilder(key_elements=2)
74
39
        stream = builder.finish()
75
40
        contents = stream.read()
76
41
        self.assertEqual(
77
 
            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=0\n\n",
 
42
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=0\n\n",
78
43
            contents)
79
44
 
80
45
    def test_build_index_one_reference_list_empty(self):
81
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
 
46
        builder = index.GraphIndexBuilder(reference_lists=1)
82
47
        stream = builder.finish()
83
48
        contents = stream.read()
84
49
        self.assertEqual(
85
 
            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=0\n\n",
 
50
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=0\n\n",
86
51
            contents)
87
52
 
88
53
    def test_build_index_two_reference_list_empty(self):
89
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
 
54
        builder = index.GraphIndexBuilder(reference_lists=2)
90
55
        stream = builder.finish()
91
56
        contents = stream.read()
92
57
        self.assertEqual(
93
 
            b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=0\n\n",
 
58
            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=0\n\n",
94
59
            contents)
95
60
 
96
61
    def test_build_index_one_node_no_refs(self):
97
 
        builder = _mod_index.GraphIndexBuilder()
98
 
        builder.add_node((b'akey', ), b'data')
 
62
        builder = index.GraphIndexBuilder()
 
63
        builder.add_node(('akey', ), 'data')
99
64
        stream = builder.finish()
100
65
        contents = stream.read()
101
66
        self.assertEqual(
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)
 
67
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
 
68
            "akey\x00\x00\x00data\n\n", contents)
104
69
 
105
70
    def test_build_index_one_node_no_refs_accepts_empty_reflist(self):
106
 
        builder = _mod_index.GraphIndexBuilder()
107
 
        builder.add_node((b'akey', ), b'data', ())
 
71
        builder = index.GraphIndexBuilder()
 
72
        builder.add_node(('akey', ), 'data', ())
108
73
        stream = builder.finish()
109
74
        contents = stream.read()
110
75
        self.assertEqual(
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)
 
76
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
 
77
            "akey\x00\x00\x00data\n\n", contents)
113
78
 
114
79
    def test_build_index_one_node_2_element_keys(self):
115
80
        # multipart keys are separated by \x00 - because they are fixed length,
116
81
        # not variable this does not cause any issues, and seems clearer to the
117
82
        # author.
118
 
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
119
 
        builder.add_node((b'akey', b'secondpart'), b'data')
 
83
        builder = index.GraphIndexBuilder(key_elements=2)
 
84
        builder.add_node(('akey', 'secondpart'), 'data')
120
85
        stream = builder.finish()
121
86
        contents = stream.read()
122
87
        self.assertEqual(
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)
 
88
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=1\n"
 
89
            "akey\x00secondpart\x00\x00\x00data\n\n", contents)
125
90
 
126
91
    def test_add_node_empty_value(self):
127
 
        builder = _mod_index.GraphIndexBuilder()
128
 
        builder.add_node((b'akey', ), b'')
 
92
        builder = index.GraphIndexBuilder()
 
93
        builder.add_node(('akey', ), '')
129
94
        stream = builder.finish()
130
95
        contents = stream.read()
131
96
        self.assertEqual(
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)
 
97
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
 
98
            "akey\x00\x00\x00\n\n", contents)
134
99
 
135
100
    def test_build_index_nodes_sorted(self):
136
101
        # the highest sorted node comes first.
137
 
        builder = _mod_index.GraphIndexBuilder()
 
102
        builder = index.GraphIndexBuilder()
138
103
        # use three to have a good chance of glitching dictionary hash
139
104
        # lookups etc. Insert in randomish order that is not correct
140
105
        # and not the reverse of the correct order.
141
 
        builder.add_node((b'2002', ), b'data')
142
 
        builder.add_node((b'2000', ), b'data')
143
 
        builder.add_node((b'2001', ), b'data')
 
106
        builder.add_node(('2002', ), 'data')
 
107
        builder.add_node(('2000', ), 'data')
 
108
        builder.add_node(('2001', ), 'data')
144
109
        stream = builder.finish()
145
110
        contents = stream.read()
146
111
        self.assertEqual(
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"
151
 
            b"\n", contents)
 
112
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=3\n"
 
113
            "2000\x00\x00\x00data\n"
 
114
            "2001\x00\x00\x00data\n"
 
115
            "2002\x00\x00\x00data\n"
 
116
            "\n", contents)
152
117
 
153
118
    def test_build_index_2_element_key_nodes_sorted(self):
154
119
        # multiple element keys are sorted first-key, second-key.
155
 
        builder = _mod_index.GraphIndexBuilder(key_elements=2)
 
120
        builder = index.GraphIndexBuilder(key_elements=2)
156
121
        # use three values of each key element, to have a good chance of
157
122
        # glitching dictionary hash lookups etc. Insert in randomish order that
158
123
        # is not correct and not the reverse of the correct order.
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')
 
124
        builder.add_node(('2002', '2002'), 'data')
 
125
        builder.add_node(('2002', '2000'), 'data')
 
126
        builder.add_node(('2002', '2001'), 'data')
 
127
        builder.add_node(('2000', '2002'), 'data')
 
128
        builder.add_node(('2000', '2000'), 'data')
 
129
        builder.add_node(('2000', '2001'), 'data')
 
130
        builder.add_node(('2001', '2002'), 'data')
 
131
        builder.add_node(('2001', '2000'), 'data')
 
132
        builder.add_node(('2001', '2001'), 'data')
168
133
        stream = builder.finish()
169
134
        contents = stream.read()
170
135
        self.assertEqual(
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"
181
 
            b"\n", contents)
 
136
            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=9\n"
 
137
            "2000\x002000\x00\x00\x00data\n"
 
138
            "2000\x002001\x00\x00\x00data\n"
 
139
            "2000\x002002\x00\x00\x00data\n"
 
140
            "2001\x002000\x00\x00\x00data\n"
 
141
            "2001\x002001\x00\x00\x00data\n"
 
142
            "2001\x002002\x00\x00\x00data\n"
 
143
            "2002\x002000\x00\x00\x00data\n"
 
144
            "2002\x002001\x00\x00\x00data\n"
 
145
            "2002\x002002\x00\x00\x00data\n"
 
146
            "\n", contents)
182
147
 
183
148
    def test_build_index_reference_lists_are_included_one(self):
184
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
185
 
        builder.add_node((b'key', ), b'data', ([], ))
 
149
        builder = index.GraphIndexBuilder(reference_lists=1)
 
150
        builder.add_node(('key', ), 'data', ([], ))
186
151
        stream = builder.finish()
187
152
        contents = stream.read()
188
153
        self.assertEqual(
189
 
            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
190
 
            b"key\x00\x00\x00data\n"
191
 
            b"\n", contents)
 
154
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
 
155
            "key\x00\x00\x00data\n"
 
156
            "\n", contents)
192
157
 
193
158
    def test_build_index_reference_lists_with_2_element_keys(self):
194
 
        builder = _mod_index.GraphIndexBuilder(
195
 
            reference_lists=1, key_elements=2)
196
 
        builder.add_node((b'key', b'key2'), b'data', ([], ))
 
159
        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
 
160
        builder.add_node(('key', 'key2'), 'data', ([], ))
197
161
        stream = builder.finish()
198
162
        contents = stream.read()
199
163
        self.assertEqual(
200
 
            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=2\nlen=1\n"
201
 
            b"key\x00key2\x00\x00\x00data\n"
202
 
            b"\n", contents)
 
164
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=2\nlen=1\n"
 
165
            "key\x00key2\x00\x00\x00data\n"
 
166
            "\n", contents)
203
167
 
204
168
    def test_build_index_reference_lists_are_included_two(self):
205
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
206
 
        builder.add_node((b'key', ), b'data', ([], []))
 
169
        builder = index.GraphIndexBuilder(reference_lists=2)
 
170
        builder.add_node(('key', ), 'data', ([], []))
207
171
        stream = builder.finish()
208
172
        contents = stream.read()
209
173
        self.assertEqual(
210
 
            b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
211
 
            b"key\x00\x00\t\x00data\n"
212
 
            b"\n", contents)
 
174
            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
 
175
            "key\x00\x00\t\x00data\n"
 
176
            "\n", contents)
213
177
 
214
178
    def test_clear_cache(self):
215
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
 
179
        builder = index.GraphIndexBuilder(reference_lists=2)
216
180
        # This is a no-op, but the api should exist
217
181
        builder.clear_cache()
218
182
 
219
183
    def test_node_references_are_byte_offsets(self):
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', )], ))
 
184
        builder = index.GraphIndexBuilder(reference_lists=1)
 
185
        builder.add_node(('reference', ), 'data', ([], ))
 
186
        builder.add_node(('key', ), 'data', ([('reference', )], ))
223
187
        stream = builder.finish()
224
188
        contents = stream.read()
225
189
        self.assertEqual(
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"
229
 
            b"\n", contents)
 
190
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=2\n"
 
191
            "key\x00\x0072\x00data\n"
 
192
            "reference\x00\x00\x00data\n"
 
193
            "\n", contents)
230
194
 
231
195
    def test_node_references_are_cr_delimited(self):
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', )], ))
 
196
        builder = index.GraphIndexBuilder(reference_lists=1)
 
197
        builder.add_node(('reference', ), 'data', ([], ))
 
198
        builder.add_node(('reference2', ), 'data', ([], ))
 
199
        builder.add_node(('key', ), 'data',
 
200
                         ([('reference', ), ('reference2', )], ))
237
201
        stream = builder.finish()
238
202
        contents = stream.read()
239
203
        self.assertEqual(
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"
244
 
            b"\n", contents)
 
204
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=3\n"
 
205
            "key\x00\x00077\r094\x00data\n"
 
206
            "reference\x00\x00\x00data\n"
 
207
            "reference2\x00\x00\x00data\n"
 
208
            "\n", contents)
245
209
 
246
210
    def test_multiple_reference_lists_are_tab_delimited(self):
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
        builder = index.GraphIndexBuilder(reference_lists=2)
 
212
        builder.add_node(('keference', ), 'data', ([], []))
 
213
        builder.add_node(('rey', ), 'data',
 
214
                         ([('keference', )], [('keference', )]))
251
215
        stream = builder.finish()
252
216
        contents = stream.read()
253
217
        self.assertEqual(
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"
257
 
            b"\n", contents)
 
218
            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=2\n"
 
219
            "keference\x00\x00\t\x00data\n"
 
220
            "rey\x00\x0059\t59\x00data\n"
 
221
            "\n", contents)
258
222
 
259
223
    def test_add_node_referencing_missing_key_makes_absent(self):
260
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
261
 
        builder.add_node((b'rey', ), b'data',
262
 
                         ([(b'beference', ), (b'aeference2', )], ))
 
224
        builder = index.GraphIndexBuilder(reference_lists=1)
 
225
        builder.add_node(('rey', ), 'data',
 
226
                         ([('beference', ), ('aeference2', )], ))
263
227
        stream = builder.finish()
264
228
        contents = stream.read()
265
229
        self.assertEqual(
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"
270
 
            b"\n", contents)
 
230
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
 
231
            "aeference2\x00a\x00\x00\n"
 
232
            "beference\x00a\x00\x00\n"
 
233
            "rey\x00\x00074\r059\x00data\n"
 
234
            "\n", contents)
271
235
 
272
236
    def test_node_references_three_digits(self):
273
237
        # test the node digit expands as needed.
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, ))
 
238
        builder = index.GraphIndexBuilder(reference_lists=1)
 
239
        references = [(str(val), ) for val in reversed(range(9))]
 
240
        builder.add_node(('2-key', ), '', (references, ))
277
241
        stream = builder.finish()
278
242
        contents = stream.read()
279
243
        self.assertEqualDiff(
280
 
            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
281
 
            b"0\x00a\x00\x00\n"
282
 
            b"1\x00a\x00\x00\n"
283
 
            b"2\x00a\x00\x00\n"
284
 
            b"2-key\x00\x00151\r145\r139\r133\r127\r121\r071\r065\r059\x00\n"
285
 
            b"3\x00a\x00\x00\n"
286
 
            b"4\x00a\x00\x00\n"
287
 
            b"5\x00a\x00\x00\n"
288
 
            b"6\x00a\x00\x00\n"
289
 
            b"7\x00a\x00\x00\n"
290
 
            b"8\x00a\x00\x00\n"
291
 
            b"\n", contents)
 
244
            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
 
245
            "0\x00a\x00\x00\n"
 
246
            "1\x00a\x00\x00\n"
 
247
            "2\x00a\x00\x00\n"
 
248
            "2-key\x00\x00151\r145\r139\r133\r127\r121\r071\r065\r059\x00\n"
 
249
            "3\x00a\x00\x00\n"
 
250
            "4\x00a\x00\x00\n"
 
251
            "5\x00a\x00\x00\n"
 
252
            "6\x00a\x00\x00\n"
 
253
            "7\x00a\x00\x00\n"
 
254
            "8\x00a\x00\x00\n"
 
255
            "\n", contents)
292
256
 
293
257
    def test_absent_has_no_reference_overhead(self):
294
258
        # the offsets after an absent record should be correct when there are
295
259
        # >1 reference lists.
296
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=2)
297
 
        builder.add_node((b'parent', ), b'', ([(b'aail', ), (b'zther', )], []))
 
260
        builder = index.GraphIndexBuilder(reference_lists=2)
 
261
        builder.add_node(('parent', ), '', ([('aail', ), ('zther', )], []))
298
262
        stream = builder.finish()
299
263
        contents = stream.read()
300
264
        self.assertEqual(
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"
305
 
            b"\n", contents)
 
265
            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
 
266
            "aail\x00a\x00\x00\n"
 
267
            "parent\x00\x0059\r84\t\x00\n"
 
268
            "zther\x00a\x00\x00\n"
 
269
            "\n", contents)
306
270
 
307
271
    def test_add_node_bad_key(self):
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,
313
 
                          (), b'data')
314
 
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
315
 
                          b'not-a-tuple', b'data')
 
272
        builder = index.GraphIndexBuilder()
 
273
        for bad_char in '\t\n\x0b\x0c\r\x00 ':
 
274
            self.assertRaises(errors.BadIndexKey, builder.add_node,
 
275
                ('a%skey' % bad_char, ), 'data')
 
276
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
277
                ('', ), 'data')
 
278
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
279
                'not-a-tuple', 'data')
316
280
        # not enough length
317
 
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
318
 
                          (), b'data')
 
281
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
282
                (), 'data')
319
283
        # too long
320
 
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
321
 
                          (b'primary', b'secondary'), b'data')
 
284
        self.assertRaises(errors.BadIndexKey, builder.add_node,
 
285
                ('primary', 'secondary'), 'data')
322
286
        # secondary key elements get checked too:
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
        builder = index.GraphIndexBuilder(key_elements=2)
 
288
        for bad_char in '\t\n\x0b\x0c\r\x00 ':
 
289
            self.assertRaises(errors.BadIndexKey, builder.add_node,
 
290
                ('prefix', 'a%skey' % bad_char), 'data')
327
291
 
328
292
    def test_add_node_bad_data(self):
329
 
        builder = _mod_index.GraphIndexBuilder()
330
 
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
331
 
                          b'data\naa')
332
 
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
333
 
                          b'data\x00aa')
 
293
        builder = index.GraphIndexBuilder()
 
294
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
295
            'data\naa')
 
296
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
297
            'data\x00aa')
334
298
 
335
299
    def test_add_node_bad_mismatched_ref_lists_length(self):
336
 
        builder = _mod_index.GraphIndexBuilder()
337
 
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
338
 
                          b'data aa', ([], ))
339
 
        builder = _mod_index.GraphIndexBuilder(reference_lists=1)
340
 
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
341
 
                          b'data aa')
342
 
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
343
 
                          b'data aa', (), )
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', ),
348
 
                          b'data aa')
349
 
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
350
 
                          b'data aa', ([], ))
351
 
        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
352
 
                          b'data aa', ([], [], []))
 
300
        builder = index.GraphIndexBuilder()
 
301
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
302
            'data aa', ([], ))
 
303
        builder = index.GraphIndexBuilder(reference_lists=1)
 
304
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
305
            'data aa')
 
306
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
307
            'data aa', (), )
 
308
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
309
            'data aa', ([], []))
 
310
        builder = index.GraphIndexBuilder(reference_lists=2)
 
311
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
312
            'data aa')
 
313
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
314
            'data aa', ([], ))
 
315
        self.assertRaises(errors.BadIndexValue, builder.add_node, ('akey', ),
 
316
            'data aa', ([], [], []))
353
317
 
354
318
    def test_add_node_bad_key_in_reference_lists(self):
355
319
        # first list, first key - trivial
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', )], ))
 
320
        builder = index.GraphIndexBuilder(reference_lists=1)
 
321
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
322
            'data aa', ([('a key', )], ))
359
323
        # references keys must be tuples too
360
 
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
361
 
                          b'data aa', (['not-a-tuple'], ))
 
324
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
325
            'data aa', (['not-a-tuple'], ))
362
326
        # not enough length
363
 
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
364
 
                          b'data aa', ([()], ))
 
327
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
328
            'data aa', ([()], ))
365
329
        # too long
366
 
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
367
 
                          b'data aa', ([(b'primary', b'secondary')], ))
 
330
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
331
            'data aa', ([('primary', 'secondary')], ))
368
332
        # need to check more than the first key in the list
369
 
        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
370
 
                          b'data aa', ([(b'agoodkey', ), (b'that is a bad key', )], ))
 
333
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
334
            'data aa', ([('agoodkey', ), ('that is a bad key', )], ))
371
335
        # and if there is more than one list it should be getting checked
372
336
        # too
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']))
 
337
        builder = index.GraphIndexBuilder(reference_lists=2)
 
338
        self.assertRaises(errors.BadIndexKey, builder.add_node, ('akey', ),
 
339
            'data aa', ([], ['a bad key']))
376
340
 
377
341
    def test_add_duplicate_key(self):
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
        builder = index.GraphIndexBuilder()
 
343
        builder.add_node(('key', ), 'data')
 
344
        self.assertRaises(errors.BadIndexDuplicateKey,
 
345
                          builder.add_node, ('key', ), 'data')
382
346
 
383
347
    def test_add_duplicate_key_2_elements(self):
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
        builder = index.GraphIndexBuilder(key_elements=2)
 
349
        builder.add_node(('key', 'key'), 'data')
 
350
        self.assertRaises(errors.BadIndexDuplicateKey, builder.add_node,
 
351
            ('key', 'key'), 'data')
388
352
 
389
353
    def test_add_key_after_referencing_key(self):
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', ([],))
 
354
        builder = index.GraphIndexBuilder(reference_lists=1)
 
355
        builder.add_node(('key', ), 'data', ([('reference', )], ))
 
356
        builder.add_node(('reference', ), 'data', ([],))
393
357
 
394
358
    def test_add_key_after_referencing_key_2_elements(self):
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', ([],))
 
359
        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
 
360
        builder.add_node(('k', 'ey'), 'data', ([('reference', 'tokey')], ))
 
361
        builder.add_node(('reference', 'tokey'), 'data', ([],))
400
362
 
401
363
    def test_set_optimize(self):
402
 
        builder = _mod_index.GraphIndexBuilder(
403
 
            reference_lists=1, key_elements=2)
 
364
        builder = index.GraphIndexBuilder(reference_lists=1, key_elements=2)
404
365
        builder.set_optimize(for_size=True)
405
366
        self.assertTrue(builder._optimize_for_size)
406
367
        builder.set_optimize(for_size=False)
410
371
class TestGraphIndex(tests.TestCaseWithMemoryTransport):
411
372
 
412
373
    def make_key(self, number):
413
 
        return ((b'%d' % number) + b'X' * 100,)
 
374
        return (str(number) + 'X'*100,)
414
375
 
415
376
    def make_value(self, number):
416
 
        return (b'%d' % number) + b'Y' * 100
 
377
            return str(number) + 'Y'*100
417
378
 
418
379
    def make_nodes(self, count=64):
419
380
        # generate a big enough index that we only read some of it on a typical
420
381
        # bisection lookup.
421
382
        nodes = []
422
383
        for counter in range(count):
423
 
            nodes.append(
424
 
                (self.make_key(counter), self.make_value(counter), ()))
 
384
            nodes.append((self.make_key(counter), self.make_value(counter), ()))
425
385
        return nodes
426
386
 
427
387
    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
428
 
        builder = _mod_index.GraphIndexBuilder(
429
 
            ref_lists, key_elements=key_elements)
 
388
        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
430
389
        for key, value, references in nodes:
431
390
            builder.add_node(key, value, references)
432
391
        stream = builder.finish()
433
392
        trans = transport.get_transport_from_url('trace+' + self.get_url())
434
393
        size = trans.put_file('index', stream)
435
 
        return _mod_index.GraphIndex(trans, 'index', size)
 
394
        return index.GraphIndex(trans, 'index', size)
436
395
 
437
396
    def make_index_with_offset(self, ref_lists=0, key_elements=1, nodes=[],
438
397
                               offset=0):
439
 
        builder = _mod_index.GraphIndexBuilder(
440
 
            ref_lists, key_elements=key_elements)
 
398
        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
441
399
        for key, value, references in nodes:
442
400
            builder.add_node(key, value, references)
443
401
        content = builder.finish().read()
444
402
        size = len(content)
445
403
        trans = self.get_transport()
446
 
        trans.put_bytes('index', (b' ' * offset) + content)
447
 
        return _mod_index.GraphIndex(trans, 'index', size, offset=offset)
 
404
        trans.put_bytes('index', (' '*offset) + content)
 
405
        return index.GraphIndex(trans, 'index', size, offset=offset)
448
406
 
449
407
    def test_clear_cache(self):
450
408
        index = self.make_index()
454
412
 
455
413
    def test_open_bad_index_no_error(self):
456
414
        trans = self.get_transport()
457
 
        trans.put_bytes('name', b"not an index\n")
458
 
        idx = _mod_index.GraphIndex(trans, 'name', 13)
 
415
        trans.put_bytes('name', "not an index\n")
 
416
        idx = index.GraphIndex(trans, 'name', 13)
459
417
 
460
418
    def test_with_offset(self):
461
419
        nodes = self.make_nodes(200)
471
429
    def test_side_effect_buffering_with_offset(self):
472
430
        nodes = self.make_nodes(20)
473
431
        index = self.make_index_with_offset(offset=1234567, nodes=nodes)
474
 
        index._transport.recommended_page_size = lambda: 64 * 1024
 
432
        index._transport.recommended_page_size = lambda:64*1024
475
433
        subset_nodes = [nodes[0][0], nodes[10][0], nodes[19][0]]
476
434
        entries = [n[1] for n in index.iter_entries(subset_nodes)]
477
435
        self.assertEqual(sorted(subset_nodes), sorted(entries))
503
461
        # do a _lookup_keys_via_location call for the middle of the file, which
504
462
        # is what bisection uses.
505
463
        result = index._lookup_keys_via_location(
506
 
            [(index._size // 2, (b'missing', ))])
 
464
            [(index._size // 2, ('missing', ))])
507
465
        # this should have asked for a readv request, with adjust_for_latency,
508
466
        # and two regions: the header, and half-way into the file.
509
467
        self.assertEqual([
512
470
            index._transport._activity)
513
471
        # and the result should be that the key cannot be present, because this
514
472
        # is a trivial index.
515
 
        self.assertEqual([((index._size // 2, (b'missing', )), False)],
516
 
                         result)
 
473
        self.assertEqual([((index._size // 2, ('missing', )), False)],
 
474
            result)
517
475
        # And this should have caused the file to be fully buffered
518
476
        self.assertIsNot(None, index._nodes)
519
477
        self.assertEqual([], index._parsed_byte_map)
533
491
        # is what bisection uses.
534
492
        start_lookup = index._size // 2
535
493
        result = index._lookup_keys_via_location(
536
 
            [(start_lookup, (b'40missing', ))])
 
494
            [(start_lookup, ('40missing', ))])
537
495
        # this should have asked for a readv request, with adjust_for_latency,
538
496
        # and two regions: the header, and half-way into the file.
539
497
        self.assertEqual([
543
501
            index._transport._activity)
544
502
        # and the result should be that the key cannot be present, because this
545
503
        # is a trivial index.
546
 
        self.assertEqual([((start_lookup, (b'40missing', )), False)],
547
 
                         result)
 
504
        self.assertEqual([((start_lookup, ('40missing', )), False)],
 
505
            result)
548
506
        # And this should not have caused the file to be fully buffered
549
507
        self.assertIs(None, index._nodes)
550
508
        # And the regions of the file that have been parsed should be in the
551
509
        # parsed_byte_map and the parsed_key_map
552
510
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
553
 
        self.assertEqual([((), self.make_key(26)),
 
511
        self.assertEqual([(None, self.make_key(26)),
554
512
                          (self.make_key(31), self.make_key(48))],
555
513
                         index._parsed_key_map)
556
514
 
557
515
    def test_parsing_non_adjacent_data_trims(self):
558
516
        index = self.make_index(nodes=self.make_nodes(64))
559
517
        result = index._lookup_keys_via_location(
560
 
            [(index._size // 2, (b'40', ))])
 
518
            [(index._size // 2, ('40', ))])
561
519
        # and the result should be that the key cannot be present, because key is
562
520
        # in the middle of the observed data from a 4K read - the smallest transport
563
521
        # will do today with this api.
564
 
        self.assertEqual([((index._size // 2, (b'40', )), False)],
565
 
                         result)
 
522
        self.assertEqual([((index._size // 2, ('40', )), False)],
 
523
            result)
566
524
        # and we should have a parse map that includes the header and the
567
525
        # region that was parsed after trimming.
568
526
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
569
 
        self.assertEqual([((), self.make_key(26)),
 
527
        self.assertEqual([(None, self.make_key(26)),
570
528
                          (self.make_key(31), self.make_key(48))],
571
 
                         index._parsed_key_map)
 
529
            index._parsed_key_map)
572
530
 
573
531
    def test_parsing_data_handles_parsed_contained_regions(self):
574
532
        # the following patten creates a parsed region that is wholly within a
586
544
        # locations of both keys.
587
545
        index = self.make_index(nodes=self.make_nodes(128))
588
546
        result = index._lookup_keys_via_location(
589
 
            [(index._size // 2, (b'40', ))])
 
547
            [(index._size // 2, ('40', ))])
590
548
        # and we should have a parse map that includes the header and the
591
549
        # region that was parsed after trimming.
592
550
        self.assertEqual([(0, 4045), (11759, 15707)], index._parsed_byte_map)
593
 
        self.assertEqual([((), self.make_key(116)),
 
551
        self.assertEqual([(None, self.make_key(116)),
594
552
                          (self.make_key(35), self.make_key(51))],
595
 
                         index._parsed_key_map)
 
553
            index._parsed_key_map)
596
554
        # now ask for two keys, right before and after the parsed region
597
555
        result = index._lookup_keys_via_location(
598
556
            [(11450, self.make_key(34)), (15707, self.make_key(52))])
610
568
        # bisection lookup.
611
569
        index = self.make_index(nodes=self.make_nodes(64))
612
570
        # lookup the keys in the middle of the file
613
 
        result = index._lookup_keys_via_location(
614
 
            [(index._size // 2, (b'40', ))])
 
571
        result =index._lookup_keys_via_location(
 
572
            [(index._size // 2, ('40', ))])
615
573
        # check the parse map, this determines the test validity
616
574
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
617
 
        self.assertEqual([((), self.make_key(26)),
 
575
        self.assertEqual([(None, self.make_key(26)),
618
576
                          (self.make_key(31), self.make_key(48))],
619
 
                         index._parsed_key_map)
 
577
            index._parsed_key_map)
620
578
        # reset the transport log
621
579
        del index._transport._activity[:]
622
580
        # now looking up a key in the portion of the file already parsed should
624
582
        # be in the index) - even when the byte location we ask for is outside
625
583
        # the parsed region
626
584
        result = index._lookup_keys_via_location(
627
 
            [(4000, (b'40', ))])
628
 
        self.assertEqual([((4000, (b'40', )), False)],
629
 
                         result)
 
585
            [(4000, ('40', ))])
 
586
        self.assertEqual([((4000, ('40', )), False)],
 
587
            result)
630
588
        self.assertEqual([], index._transport._activity)
631
589
 
632
590
    def test_lookup_present_key_answers_without_io_when_map_permits(self):
634
592
        # bisection lookup.
635
593
        index = self.make_index(nodes=self.make_nodes(64))
636
594
        # lookup the keys in the middle of the file
637
 
        result = index._lookup_keys_via_location(
638
 
            [(index._size // 2, (b'40', ))])
 
595
        result =index._lookup_keys_via_location(
 
596
            [(index._size // 2, ('40', ))])
639
597
        # check the parse map, this determines the test validity
640
598
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
641
 
        self.assertEqual([((), self.make_key(26)),
 
599
        self.assertEqual([(None, self.make_key(26)),
642
600
                          (self.make_key(31), self.make_key(48))],
643
 
                         index._parsed_key_map)
 
601
            index._parsed_key_map)
644
602
        # reset the transport log
645
603
        del index._transport._activity[:]
646
604
        # now looking up a key in the portion of the file already parsed should
661
619
        index = self.make_index(nodes=self.make_nodes(64))
662
620
        # ask for the key in the middle, but a key that is located in the
663
621
        # unparsed region before the middle.
664
 
        result = index._lookup_keys_via_location(
665
 
            [(index._size // 2, (b'30', ))])
 
622
        result =index._lookup_keys_via_location(
 
623
            [(index._size // 2, ('30', ))])
666
624
        # check the parse map, this determines the test validity
667
625
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
668
 
        self.assertEqual([((), self.make_key(26)),
 
626
        self.assertEqual([(None, self.make_key(26)),
669
627
                          (self.make_key(31), self.make_key(48))],
670
 
                         index._parsed_key_map)
671
 
        self.assertEqual([((index._size // 2, (b'30', )), -1)],
672
 
                         result)
 
628
            index._parsed_key_map)
 
629
        self.assertEqual([((index._size // 2, ('30', )), -1)],
 
630
            result)
673
631
 
674
632
    def test_lookup_key_above_probed_area(self):
675
633
        # generate a big enough index that we only read some of it on a typical
677
635
        index = self.make_index(nodes=self.make_nodes(64))
678
636
        # ask for the key in the middle, but a key that is located in the
679
637
        # unparsed region after the middle.
680
 
        result = index._lookup_keys_via_location(
681
 
            [(index._size // 2, (b'50', ))])
 
638
        result =index._lookup_keys_via_location(
 
639
            [(index._size // 2, ('50', ))])
682
640
        # check the parse map, this determines the test validity
683
641
        self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
684
 
        self.assertEqual([((), self.make_key(26)),
 
642
        self.assertEqual([(None, self.make_key(26)),
685
643
                          (self.make_key(31), self.make_key(48))],
686
 
                         index._parsed_key_map)
687
 
        self.assertEqual([((index._size // 2, (b'50', )), +1)],
688
 
                         result)
 
644
            index._parsed_key_map)
 
645
        self.assertEqual([((index._size // 2, ('50', )), +1)],
 
646
            result)
689
647
 
690
648
    def test_lookup_key_resolves_references(self):
691
649
        # generate a big enough index that we only read some of it on a typical
693
651
        nodes = []
694
652
        for counter in range(99):
695
653
            nodes.append((self.make_key(counter), self.make_value(counter),
696
 
                          ((self.make_key(counter + 20),),)))
 
654
                ((self.make_key(counter + 20),),)  ))
697
655
        index = self.make_index(ref_lists=1, nodes=nodes)
698
656
        # lookup a key in the middle that does not exist, so that when we can
699
657
        # check that the referred-to-keys are not accessed automatically.
700
658
        index_size = index._size
701
659
        index_center = index_size // 2
702
660
        result = index._lookup_keys_via_location(
703
 
            [(index_center, (b'40', ))])
 
661
            [(index_center, ('40', ))])
704
662
        # check the parse map - only the start and middle should have been
705
663
        # parsed.
706
664
        self.assertEqual([(0, 4027), (10198, 14028)], index._parsed_byte_map)
707
 
        self.assertEqual([((), self.make_key(17)),
 
665
        self.assertEqual([(None, self.make_key(17)),
708
666
                          (self.make_key(44), self.make_key(5))],
709
 
                         index._parsed_key_map)
 
667
            index._parsed_key_map)
710
668
        # and check the transport activity likewise.
711
669
        self.assertEqual(
712
670
            [('readv', 'index', [(index_center, 800), (0, 200)], True,
713
 
              index_size)],
 
671
                                  index_size)],
714
672
            index._transport._activity)
715
673
        # reset the transport log for testing the reference lookup
716
674
        del index._transport._activity[:]
723
681
               ((self.make_key(65),),)))],
724
682
            result)
725
683
        self.assertEqual([('readv', 'index', [(15093, 800)], True, index_size)],
726
 
                         index._transport._activity)
 
684
            index._transport._activity)
727
685
 
728
686
    def test_lookup_key_can_buffer_all(self):
729
687
        nodes = []
730
688
        for counter in range(64):
731
689
            nodes.append((self.make_key(counter), self.make_value(counter),
732
 
                          ((self.make_key(counter + 20),),)))
 
690
                ((self.make_key(counter + 20),),)  ))
733
691
        index = self.make_index(ref_lists=1, nodes=nodes)
734
692
        # lookup a key in the middle that does not exist, so that when we can
735
693
        # check that the referred-to-keys are not accessed automatically.
736
694
        index_size = index._size
737
695
        index_center = index_size // 2
738
 
        result = index._lookup_keys_via_location([(index_center, (b'40', ))])
 
696
        result = index._lookup_keys_via_location([(index_center, ('40', ))])
739
697
        # check the parse map - only the start and middle should have been
740
698
        # parsed.
741
699
        self.assertEqual([(0, 3890), (6444, 10274)], index._parsed_byte_map)
742
 
        self.assertEqual([((), self.make_key(25)),
 
700
        self.assertEqual([(None, self.make_key(25)),
743
701
                          (self.make_key(37), self.make_key(52))],
744
 
                         index._parsed_key_map)
 
702
            index._parsed_key_map)
745
703
        # and check the transport activity likewise.
746
704
        self.assertEqual(
747
705
            [('readv', 'index', [(index_center, 800), (0, 200)], True,
748
 
              index_size)],
 
706
                                  index_size)],
749
707
            index._transport._activity)
750
708
        # reset the transport log for testing the reference lookup
751
709
        del index._transport._activity[:]
766
724
        self.assertEqual([], list(index.iter_all_entries()))
767
725
 
768
726
    def test_iter_all_entries_simple(self):
769
 
        index = self.make_index(nodes=[((b'name', ), b'data', ())])
770
 
        self.assertEqual([(index, (b'name', ), b'data')],
771
 
                         list(index.iter_all_entries()))
 
727
        index = self.make_index(nodes=[(('name', ), 'data', ())])
 
728
        self.assertEqual([(index, ('name', ), 'data')],
 
729
            list(index.iter_all_entries()))
772
730
 
773
731
    def test_iter_all_entries_simple_2_elements(self):
774
732
        index = self.make_index(key_elements=2,
775
 
                                nodes=[((b'name', b'surname'), b'data', ())])
776
 
        self.assertEqual([(index, (b'name', b'surname'), b'data')],
777
 
                         list(index.iter_all_entries()))
 
733
            nodes=[(('name', 'surname'), 'data', ())])
 
734
        self.assertEqual([(index, ('name', 'surname'), 'data')],
 
735
            list(index.iter_all_entries()))
778
736
 
779
737
    def test_iter_all_entries_references_resolved(self):
780
738
        index = self.make_index(1, nodes=[
781
 
            ((b'name', ), b'data', ([(b'ref', )], )),
782
 
            ((b'ref', ), b'refdata', ([], ))])
783
 
        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
784
 
                          (index, (b'ref', ), b'refdata', ((), ))},
785
 
                         set(index.iter_all_entries()))
 
739
            (('name', ), 'data', ([('ref', )], )),
 
740
            (('ref', ), 'refdata', ([], ))])
 
741
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
 
742
            (index, ('ref', ), 'refdata', ((), ))]),
 
743
            set(index.iter_all_entries()))
786
744
 
787
745
    def test_iter_entries_buffers_once(self):
788
746
        index = self.make_index(nodes=self.make_nodes(2))
789
747
        # reset the transport log
790
748
        del index._transport._activity[:]
791
 
        self.assertEqual({(index, self.make_key(1), self.make_value(1))},
 
749
        self.assertEqual(set([(index, self.make_key(1), self.make_value(1))]),
792
750
                         set(index.iter_entries([self.make_key(1)])))
793
751
        # We should have requested reading the header bytes
794
752
        # But not needed any more than that because it would have triggered a
828
786
 
829
787
    def test_iter_entries_references_resolved(self):
830
788
        index = self.make_index(1, nodes=[
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',)])))
 
789
            (('name', ), 'data', ([('ref', ), ('ref', )], )),
 
790
            (('ref', ), 'refdata', ([], ))])
 
791
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),('ref',)),)),
 
792
            (index, ('ref', ), 'refdata', ((), ))]),
 
793
            set(index.iter_entries([('name',), ('ref',)])))
836
794
 
837
795
    def test_iter_entries_references_2_refs_resolved(self):
838
796
        index = self.make_index(2, nodes=[
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',)])))
 
797
            (('name', ), 'data', ([('ref', )], [('ref', )])),
 
798
            (('ref', ), 'refdata', ([], []))])
 
799
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),), (('ref',),))),
 
800
            (index, ('ref', ), 'refdata', ((), ()))]),
 
801
            set(index.iter_entries([('name',), ('ref',)])))
844
802
 
845
803
    def test_iteration_absent_skipped(self):
846
804
        index = self.make_index(1, nodes=[
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', )])))
 
805
            (('name', ), 'data', ([('ref', )], ))])
 
806
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
807
            set(index.iter_all_entries()))
 
808
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
809
            set(index.iter_entries([('name', )])))
 
810
        self.assertEqual([], list(index.iter_entries([('ref', )])))
853
811
 
854
812
    def test_iteration_absent_skipped_2_element_keys(self):
855
813
        index = self.make_index(1, key_elements=2, nodes=[
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')])))
 
814
            (('name', 'fin'), 'data', ([('ref', 'erence')], ))])
 
815
        self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
 
816
            set(index.iter_all_entries()))
 
817
        self.assertEqual(set([(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))]),
 
818
            set(index.iter_entries([('name', 'fin')])))
 
819
        self.assertEqual([], list(index.iter_entries([('ref', 'erence')])))
862
820
 
863
821
    def test_iter_all_keys(self):
864
822
        index = self.make_index(1, nodes=[
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', )])))
 
823
            (('name', ), 'data', ([('ref', )], )),
 
824
            (('ref', ), 'refdata', ([], ))])
 
825
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
 
826
            (index, ('ref', ), 'refdata', ((), ))]),
 
827
            set(index.iter_entries([('name', ), ('ref', )])))
870
828
 
871
829
    def test_iter_nothing_empty(self):
872
830
        index = self.make_index()
874
832
 
875
833
    def test_iter_missing_entry_empty(self):
876
834
        index = self.make_index()
877
 
        self.assertEqual([], list(index.iter_entries([(b'a', )])))
 
835
        self.assertEqual([], list(index.iter_entries([('a', )])))
878
836
 
879
837
    def test_iter_missing_entry_empty_no_size(self):
880
838
        idx = self.make_index()
881
 
        idx = _mod_index.GraphIndex(idx._transport, 'index', None)
882
 
        self.assertEqual([], list(idx.iter_entries([(b'a', )])))
 
839
        idx = index.GraphIndex(idx._transport, 'index', None)
 
840
        self.assertEqual([], list(idx.iter_entries([('a', )])))
883
841
 
884
842
    def test_iter_key_prefix_1_element_key_None(self):
885
843
        index = self.make_index()
886
 
        self.assertRaises(_mod_index.BadIndexKey, list,
887
 
                          index.iter_entries_prefix([(None, )]))
 
844
        self.assertRaises(errors.BadIndexKey, list,
 
845
            index.iter_entries_prefix([(None, )]))
888
846
 
889
847
    def test_iter_key_prefix_wrong_length(self):
890
848
        index = self.make_index()
891
 
        self.assertRaises(_mod_index.BadIndexKey, list,
892
 
                          index.iter_entries_prefix([(b'foo', None)]))
 
849
        self.assertRaises(errors.BadIndexKey, list,
 
850
            index.iter_entries_prefix([('foo', None)]))
893
851
        index = self.make_index(key_elements=2)
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
        self.assertRaises(errors.BadIndexKey, list,
 
853
            index.iter_entries_prefix([('foo', )]))
 
854
        self.assertRaises(errors.BadIndexKey, list,
 
855
            index.iter_entries_prefix([('foo', None, None)]))
898
856
 
899
857
    def test_iter_key_prefix_1_key_element_no_refs(self):
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', )])))
 
858
        index = self.make_index( nodes=[
 
859
            (('name', ), 'data', ()),
 
860
            (('ref', ), 'refdata', ())])
 
861
        self.assertEqual(set([(index, ('name', ), 'data'),
 
862
            (index, ('ref', ), 'refdata')]),
 
863
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
906
864
 
907
865
    def test_iter_key_prefix_1_key_element_refs(self):
908
866
        index = self.make_index(1, nodes=[
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', )])))
 
867
            (('name', ), 'data', ([('ref', )], )),
 
868
            (('ref', ), 'refdata', ([], ))])
 
869
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
 
870
            (index, ('ref', ), 'refdata', ((), ))]),
 
871
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
914
872
 
915
873
    def test_iter_key_prefix_2_key_element_no_refs(self):
916
874
        index = self.make_index(key_elements=2, nodes=[
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)])))
 
875
            (('name', 'fin1'), 'data', ()),
 
876
            (('name', 'fin2'), 'beta', ()),
 
877
            (('ref', 'erence'), 'refdata', ())])
 
878
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
 
879
            (index, ('ref', 'erence'), 'refdata')]),
 
880
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
 
881
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
 
882
            (index, ('name', 'fin2'), 'beta')]),
 
883
            set(index.iter_entries_prefix([('name', None)])))
926
884
 
927
885
    def test_iter_key_prefix_2_key_element_refs(self):
928
886
        index = self.make_index(1, key_elements=2, nodes=[
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)])))
 
887
            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
 
888
            (('name', 'fin2'), 'beta', ([], )),
 
889
            (('ref', 'erence'), 'refdata', ([], ))])
 
890
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
891
            (index, ('ref', 'erence'), 'refdata', ((), ))]),
 
892
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
 
893
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
894
            (index, ('name', 'fin2'), 'beta', ((), ))]),
 
895
            set(index.iter_entries_prefix([('name', None)])))
938
896
 
939
897
    def test_key_count_empty(self):
940
898
        index = self.make_index()
941
899
        self.assertEqual(0, index.key_count())
942
900
 
943
901
    def test_key_count_one(self):
944
 
        index = self.make_index(nodes=[((b'name', ), b'', ())])
 
902
        index = self.make_index(nodes=[(('name', ), '', ())])
945
903
        self.assertEqual(1, index.key_count())
946
904
 
947
905
    def test_key_count_two(self):
948
906
        index = self.make_index(nodes=[
949
 
            ((b'name', ), b'', ()), ((b'foo', ), b'', ())])
 
907
            (('name', ), '', ()), (('foo', ), '', ())])
950
908
        self.assertEqual(2, index.key_count())
951
909
 
952
910
    def test_read_and_parse_tracks_real_read_value(self):
964
922
 
965
923
    def test_read_and_parse_triggers_buffer_all(self):
966
924
        index = self.make_index(key_elements=2, nodes=[
967
 
            ((b'name', b'fin1'), b'data', ()),
968
 
            ((b'name', b'fin2'), b'beta', ()),
969
 
            ((b'ref', b'erence'), b'refdata', ())])
 
925
            (('name', 'fin1'), 'data', ()),
 
926
            (('name', 'fin2'), 'beta', ()),
 
927
            (('ref', 'erence'), 'refdata', ())])
970
928
        self.assertTrue(index._size > 0)
971
929
        self.assertIs(None, index._nodes)
972
930
        index._read_and_parse([(0, index._size)])
974
932
 
975
933
    def test_validate_bad_index_errors(self):
976
934
        trans = self.get_transport()
977
 
        trans.put_bytes('name', b"not an index\n")
978
 
        idx = _mod_index.GraphIndex(trans, 'name', 13)
979
 
        self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
 
935
        trans.put_bytes('name', "not an index\n")
 
936
        idx = index.GraphIndex(trans, 'name', 13)
 
937
        self.assertRaises(errors.BadIndexFormatSignature, idx.validate)
980
938
 
981
939
    def test_validate_bad_node_refs(self):
982
940
        idx = self.make_index(2)
983
941
        trans = self.get_transport()
984
942
        content = trans.get_bytes('index')
985
943
        # change the options line to end with a rather than a parseable number
986
 
        new_content = content[:-2] + b'a\n\n'
 
944
        new_content = content[:-2] + 'a\n\n'
987
945
        trans.put_bytes('index', new_content)
988
 
        self.assertRaises(_mod_index.BadIndexOptions, idx.validate)
 
946
        self.assertRaises(errors.BadIndexOptions, idx.validate)
989
947
 
990
948
    def test_validate_missing_end_line_empty(self):
991
949
        index = self.make_index(2)
993
951
        content = trans.get_bytes('index')
994
952
        # truncate the last byte
995
953
        trans.put_bytes('index', content[:-1])
996
 
        self.assertRaises(_mod_index.BadIndexData, index.validate)
 
954
        self.assertRaises(errors.BadIndexData, index.validate)
997
955
 
998
956
    def test_validate_missing_end_line_nonempty(self):
999
 
        index = self.make_index(2, nodes=[((b'key', ), b'', ([], []))])
 
957
        index = self.make_index(2, nodes=[(('key', ), '', ([], []))])
1000
958
        trans = self.get_transport()
1001
959
        content = trans.get_bytes('index')
1002
960
        # truncate the last byte
1003
961
        trans.put_bytes('index', content[:-1])
1004
 
        self.assertRaises(_mod_index.BadIndexData, index.validate)
 
962
        self.assertRaises(errors.BadIndexData, index.validate)
1005
963
 
1006
964
    def test_validate_empty(self):
1007
965
        index = self.make_index()
1008
966
        index.validate()
1009
967
 
1010
968
    def test_validate_no_refs_content(self):
1011
 
        index = self.make_index(nodes=[((b'key', ), b'value', ())])
 
969
        index = self.make_index(nodes=[(('key', ), 'value', ())])
1012
970
        index.validate()
1013
971
 
1014
972
    # XXX: external_references tests are duplicated in test_btree_index.  We
1019
977
 
1020
978
    def test_external_references_no_results(self):
1021
979
        index = self.make_index(ref_lists=1, nodes=[
1022
 
            ((b'key',), b'value', ([],))])
 
980
            (('key',), 'value', ([],))])
1023
981
        self.assertEqual(set(), index.external_references(0))
1024
982
 
1025
983
    def test_external_references_missing_ref(self):
1026
 
        missing_key = (b'missing',)
 
984
        missing_key = ('missing',)
1027
985
        index = self.make_index(ref_lists=1, nodes=[
1028
 
            ((b'key',), b'value', ([missing_key],))])
1029
 
        self.assertEqual({missing_key}, index.external_references(0))
 
986
            (('key',), 'value', ([missing_key],))])
 
987
        self.assertEqual(set([missing_key]), index.external_references(0))
1030
988
 
1031
989
    def test_external_references_multiple_ref_lists(self):
1032
 
        missing_key = (b'missing',)
 
990
        missing_key = ('missing',)
1033
991
        index = self.make_index(ref_lists=2, nodes=[
1034
 
            ((b'key',), b'value', ([], [missing_key]))])
 
992
            (('key',), 'value', ([], [missing_key]))])
1035
993
        self.assertEqual(set([]), index.external_references(0))
1036
 
        self.assertEqual({missing_key}, index.external_references(1))
 
994
        self.assertEqual(set([missing_key]), index.external_references(1))
1037
995
 
1038
996
    def test_external_references_two_records(self):
1039
997
        index = self.make_index(ref_lists=1, nodes=[
1040
 
            ((b'key-1',), b'value', ([(b'key-2',)],)),
1041
 
            ((b'key-2',), b'value', ([],)),
 
998
            (('key-1',), 'value', ([('key-2',)],)),
 
999
            (('key-2',), 'value', ([],)),
1042
1000
            ])
1043
1001
        self.assertEqual(set([]), index.external_references(0))
1044
1002
 
1045
1003
    def test__find_ancestors(self):
1046
 
        key1 = (b'key-1',)
1047
 
        key2 = (b'key-2',)
 
1004
        key1 = ('key-1',)
 
1005
        key2 = ('key-2',)
1048
1006
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
1049
 
            (key1, b'value', ([key2],)),
1050
 
            (key2, b'value', ([],)),
 
1007
            (key1, 'value', ([key2],)),
 
1008
            (key2, 'value', ([],)),
1051
1009
            ])
1052
1010
        parent_map = {}
1053
1011
        missing_keys = set()
1054
 
        search_keys = index._find_ancestors(
1055
 
            [key1], 0, parent_map, missing_keys)
 
1012
        search_keys = index._find_ancestors([key1], 0, parent_map, missing_keys)
1056
1013
        self.assertEqual({key1: (key2,)}, parent_map)
1057
1014
        self.assertEqual(set(), missing_keys)
1058
 
        self.assertEqual({key2}, search_keys)
 
1015
        self.assertEqual(set([key2]), search_keys)
1059
1016
        search_keys = index._find_ancestors(search_keys, 0, parent_map,
1060
1017
                                            missing_keys)
1061
1018
        self.assertEqual({key1: (key2,), key2: ()}, parent_map)
1063
1020
        self.assertEqual(set(), search_keys)
1064
1021
 
1065
1022
    def test__find_ancestors_w_missing(self):
1066
 
        key1 = (b'key-1',)
1067
 
        key2 = (b'key-2',)
1068
 
        key3 = (b'key-3',)
 
1023
        key1 = ('key-1',)
 
1024
        key2 = ('key-2',)
 
1025
        key3 = ('key-3',)
1069
1026
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
1070
 
            (key1, b'value', ([key2],)),
1071
 
            (key2, b'value', ([],)),
 
1027
            (key1, 'value', ([key2],)),
 
1028
            (key2, 'value', ([],)),
1072
1029
            ])
1073
1030
        parent_map = {}
1074
1031
        missing_keys = set()
1075
1032
        search_keys = index._find_ancestors([key2, key3], 0, parent_map,
1076
1033
                                            missing_keys)
1077
1034
        self.assertEqual({key2: ()}, parent_map)
1078
 
        self.assertEqual({key3}, missing_keys)
 
1035
        self.assertEqual(set([key3]), missing_keys)
1079
1036
        self.assertEqual(set(), search_keys)
1080
1037
 
1081
1038
    def test__find_ancestors_dont_search_known(self):
1082
 
        key1 = (b'key-1',)
1083
 
        key2 = (b'key-2',)
1084
 
        key3 = (b'key-3',)
 
1039
        key1 = ('key-1',)
 
1040
        key2 = ('key-2',)
 
1041
        key3 = ('key-3',)
1085
1042
        index = self.make_index(ref_lists=1, key_elements=1, nodes=[
1086
 
            (key1, b'value', ([key2],)),
1087
 
            (key2, b'value', ([key3],)),
1088
 
            (key3, b'value', ([],)),
 
1043
            (key1, 'value', ([key2],)),
 
1044
            (key2, 'value', ([key3],)),
 
1045
            (key3, 'value', ([],)),
1089
1046
            ])
1090
1047
        # We already know about key2, so we won't try to search for key3
1091
1048
        parent_map = {key2: (key3,)}
1097
1054
        self.assertEqual(set(), search_keys)
1098
1055
 
1099
1056
    def test_supports_unlimited_cache(self):
1100
 
        builder = _mod_index.GraphIndexBuilder(0, key_elements=1)
 
1057
        builder = index.GraphIndexBuilder(0, key_elements=1)
1101
1058
        stream = builder.finish()
1102
1059
        trans = self.get_transport()
1103
1060
        size = trans.put_file('index', stream)
1104
1061
        # It doesn't matter what unlimited_cache does here, just that it can be
1105
1062
        # passed
1106
 
        idx = _mod_index.GraphIndex(trans, 'index', size, unlimited_cache=True)
 
1063
        idx = index.GraphIndex(trans, 'index', size, unlimited_cache=True)
1107
1064
 
1108
1065
 
1109
1066
class TestCombinedGraphIndex(tests.TestCaseWithMemoryTransport):
1110
1067
 
1111
1068
    def make_index(self, name, ref_lists=0, key_elements=1, nodes=[]):
1112
 
        builder = _mod_index.GraphIndexBuilder(
1113
 
            ref_lists, key_elements=key_elements)
 
1069
        builder = index.GraphIndexBuilder(ref_lists, key_elements=key_elements)
1114
1070
        for key, value, references in nodes:
1115
1071
            builder.add_node(key, value, references)
1116
1072
        stream = builder.finish()
1117
1073
        trans = self.get_transport()
1118
1074
        size = trans.put_file(name, stream)
1119
 
        return _mod_index.GraphIndex(trans, name, size)
 
1075
        return index.GraphIndex(trans, name, size)
1120
1076
 
1121
1077
    def make_combined_index_with_missing(self, missing=['1', '2']):
1122
1078
        """Create a CombinedGraphIndex which will have missing indexes.
1128
1084
        :param missing: The underlying indexes to delete
1129
1085
        :return: (CombinedGraphIndex, reload_counter)
1130
1086
        """
1131
 
        idx1 = self.make_index('1', nodes=[((b'1',), b'', ())])
1132
 
        idx2 = self.make_index('2', nodes=[((b'2',), b'', ())])
 
1087
        idx1 = self.make_index('1', nodes=[(('1',), '', ())])
 
1088
        idx2 = self.make_index('2', nodes=[(('2',), '', ())])
1133
1089
        idx3 = self.make_index('3', nodes=[
1134
 
            ((b'1',), b'', ()),
1135
 
            ((b'2',), b'', ())])
 
1090
            (('1',), '', ()),
 
1091
            (('2',), '', ())])
1136
1092
 
1137
1093
        # total_reloads, num_changed, num_unchanged
1138
1094
        reload_counter = [0, 0, 0]
1139
 
 
1140
1095
        def reload():
1141
1096
            reload_counter[0] += 1
1142
1097
            new_indices = [idx3]
1146
1101
            reload_counter[1] += 1
1147
1102
            idx._indices[:] = new_indices
1148
1103
            return True
1149
 
        idx = _mod_index.CombinedGraphIndex([idx1, idx2], reload_func=reload)
 
1104
        idx = index.CombinedGraphIndex([idx1, idx2], reload_func=reload)
1150
1105
        trans = self.get_transport()
1151
1106
        for fname in missing:
1152
1107
            trans.delete(fname)
1154
1109
 
1155
1110
    def test_open_missing_index_no_error(self):
1156
1111
        trans = self.get_transport()
1157
 
        idx1 = _mod_index.GraphIndex(trans, 'missing', 100)
1158
 
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1112
        idx1 = index.GraphIndex(trans, 'missing', 100)
 
1113
        idx = index.CombinedGraphIndex([idx1])
1159
1114
 
1160
1115
    def test_add_index(self):
1161
 
        idx = _mod_index.CombinedGraphIndex([])
1162
 
        idx1 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
 
1116
        idx = index.CombinedGraphIndex([])
 
1117
        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1163
1118
        idx.insert_index(0, idx1)
1164
 
        self.assertEqual([(idx1, (b'key', ), b'')],
 
1119
        self.assertEqual([(idx1, ('key', ), '')],
1165
1120
                         list(idx.iter_all_entries()))
1166
1121
 
1167
1122
    def test_clear_cache(self):
1179
1134
                log.append(self._index)
1180
1135
                return self._index.clear_cache()
1181
1136
 
1182
 
        idx = _mod_index.CombinedGraphIndex([])
1183
 
        idx1 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
 
1137
        idx = index.CombinedGraphIndex([])
 
1138
        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1184
1139
        idx.insert_index(0, ClearCacheProxy(idx1))
1185
 
        idx2 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
 
1140
        idx2 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
1186
1141
        idx.insert_index(1, ClearCacheProxy(idx2))
1187
1142
        # CombinedGraphIndex should call 'clear_cache()' on all children
1188
1143
        idx.clear_cache()
1189
1144
        self.assertEqual(sorted([idx1, idx2]), sorted(log))
1190
1145
 
1191
1146
    def test_iter_all_entries_empty(self):
1192
 
        idx = _mod_index.CombinedGraphIndex([])
 
1147
        idx = index.CombinedGraphIndex([])
1193
1148
        self.assertEqual([], list(idx.iter_all_entries()))
1194
1149
 
1195
1150
    def test_iter_all_entries_children_empty(self):
1196
1151
        idx1 = self.make_index('name')
1197
 
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1152
        idx = index.CombinedGraphIndex([idx1])
1198
1153
        self.assertEqual([], list(idx.iter_all_entries()))
1199
1154
 
1200
1155
    def test_iter_all_entries_simple(self):
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()))
 
1156
        idx1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
 
1157
        idx = index.CombinedGraphIndex([idx1])
 
1158
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1159
            list(idx.iter_all_entries()))
1205
1160
 
1206
1161
    def test_iter_all_entries_two_indices(self):
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'')],
 
1162
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1163
        idx2 = self.make_index('name2', nodes=[(('2', ), '', ())])
 
1164
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1165
        self.assertEqual([(idx1, ('name', ), 'data'),
 
1166
                          (idx2, ('2', ), '')],
1212
1167
                         list(idx.iter_all_entries()))
1213
1168
 
1214
1169
    def test_iter_entries_two_indices_dup_key(self):
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
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1171
        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
 
1172
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1173
        self.assertEqual([(idx1, ('name', ), 'data')],
 
1174
                         list(idx.iter_entries([('name', )])))
1220
1175
 
1221
1176
    def test_iter_all_entries_two_indices_dup_key(self):
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')],
 
1177
        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
 
1178
        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
 
1179
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1180
        self.assertEqual([(idx1, ('name', ), 'data')],
1226
1181
                         list(idx.iter_all_entries()))
1227
1182
 
1228
1183
    def test_iter_key_prefix_2_key_element_refs(self):
1229
1184
        idx1 = self.make_index('1', 1, key_elements=2, nodes=[
1230
 
            ((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], ))])
 
1185
                (('name', 'fin1'), 'data', ([('ref', 'erence')], ))])
1231
1186
        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)])))
 
1187
                (('name', 'fin2'), 'beta', ([], )),
 
1188
                (('ref', 'erence'), 'refdata', ([], ))])
 
1189
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1190
        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',
 
1191
                               ((('ref', 'erence'),),)),
 
1192
                              (idx2, ('ref', 'erence'), 'refdata', ((), ))]),
 
1193
                         set(idx.iter_entries_prefix([('name', 'fin1'),
 
1194
                                                        ('ref', 'erence')])))
 
1195
        self.assertEqual(set([(idx1, ('name', 'fin1'), 'data',
 
1196
                               ((('ref', 'erence'),),)),
 
1197
                              (idx2, ('name', 'fin2'), 'beta', ((), ))]),
 
1198
                         set(idx.iter_entries_prefix([('name', None)])))
1244
1199
 
1245
1200
    def test_iter_nothing_empty(self):
1246
 
        idx = _mod_index.CombinedGraphIndex([])
 
1201
        idx = index.CombinedGraphIndex([])
1247
1202
        self.assertEqual([], list(idx.iter_entries([])))
1248
1203
 
1249
1204
    def test_iter_nothing_children_empty(self):
1250
1205
        idx1 = self.make_index('name')
1251
 
        idx = _mod_index.CombinedGraphIndex([idx1])
 
1206
        idx = index.CombinedGraphIndex([idx1])
1252
1207
        self.assertEqual([], list(idx.iter_entries([])))
1253
1208
 
1254
1209
    def test_iter_all_keys(self):
1255
 
        idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',
1256
 
                                               ([(b'ref', )], ))])
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
        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
 
1211
                                               ([('ref', )], ))])
 
1212
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ((), ))])
 
1213
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1214
        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref', ), ), )),
 
1215
                              (idx2, ('ref', ), 'refdata', ((), ))]),
 
1216
                         set(idx.iter_entries([('name', ), ('ref', )])))
1263
1217
 
1264
1218
    def test_iter_all_keys_dup_entry(self):
1265
 
        idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',
1266
 
                                               ([(b'ref', )], )),
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', )])))
 
1219
        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
 
1220
                                                 ([('ref', )], )),
 
1221
                                                (('ref', ), 'refdata', ([], ))])
 
1222
        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ([], ))])
 
1223
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1224
        self.assertEqual(set([(idx1, ('name', ), 'data', ((('ref',),),)),
 
1225
                              (idx1, ('ref', ), 'refdata', ((), ))]),
 
1226
                         set(idx.iter_entries([('name', ), ('ref', )])))
1274
1227
 
1275
1228
    def test_iter_missing_entry_empty(self):
1276
 
        idx = _mod_index.CombinedGraphIndex([])
 
1229
        idx = index.CombinedGraphIndex([])
1277
1230
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1278
1231
 
1279
1232
    def test_iter_missing_entry_one_index(self):
1280
1233
        idx1 = self.make_index('1')
1281
 
        idx = _mod_index.CombinedGraphIndex([idx1])
1282
 
        self.assertEqual([], list(idx.iter_entries([(b'a', )])))
 
1234
        idx = index.CombinedGraphIndex([idx1])
 
1235
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1283
1236
 
1284
1237
    def test_iter_missing_entry_two_index(self):
1285
1238
        idx1 = self.make_index('1')
1286
1239
        idx2 = self.make_index('2')
1287
 
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1240
        idx = index.CombinedGraphIndex([idx1, idx2])
1288
1241
        self.assertEqual([], list(idx.iter_entries([('a', )])))
1289
1242
 
1290
1243
    def test_iter_entry_present_one_index_only(self):
1291
 
        idx1 = self.make_index('1', nodes=[((b'key', ), b'', ())])
 
1244
        idx1 = self.make_index('1', nodes=[(('key', ), '', ())])
1292
1245
        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', )])))
 
1246
        idx = index.CombinedGraphIndex([idx1, idx2])
 
1247
        self.assertEqual([(idx1, ('key', ), '')],
 
1248
                         list(idx.iter_entries([('key', )])))
1296
1249
        # and in the other direction
1297
 
        idx = _mod_index.CombinedGraphIndex([idx2, idx1])
1298
 
        self.assertEqual([(idx1, (b'key', ), b'')],
1299
 
                         list(idx.iter_entries([(b'key', )])))
 
1250
        idx = index.CombinedGraphIndex([idx2, idx1])
 
1251
        self.assertEqual([(idx1, ('key', ), '')],
 
1252
                         list(idx.iter_entries([('key', )])))
1300
1253
 
1301
1254
    def test_key_count_empty(self):
1302
1255
        idx1 = self.make_index('1', nodes=[])
1303
1256
        idx2 = self.make_index('2', nodes=[])
1304
 
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1257
        idx = index.CombinedGraphIndex([idx1, idx2])
1305
1258
        self.assertEqual(0, idx.key_count())
1306
1259
 
1307
1260
    def test_key_count_sums_index_keys(self):
1308
1261
        idx1 = self.make_index('1', nodes=[
1309
 
            ((b'1',), b'', ()),
1310
 
            ((b'2',), b'', ())])
1311
 
        idx2 = self.make_index('2', nodes=[((b'1',), b'', ())])
1312
 
        idx = _mod_index.CombinedGraphIndex([idx1, idx2])
 
1262
            (('1',), '', ()),
 
1263
            (('2',), '', ())])
 
1264
        idx2 = self.make_index('2', nodes=[(('1',), '', ())])
 
1265
        idx = index.CombinedGraphIndex([idx1, idx2])
1313
1266
        self.assertEqual(3, idx.key_count())
1314
1267
 
1315
1268
    def test_validate_bad_child_index_errors(self):
1316
1269
        trans = self.get_transport()
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)
 
1270
        trans.put_bytes('name', "not an index\n")
 
1271
        idx1 = index.GraphIndex(trans, 'name', 13)
 
1272
        idx = index.CombinedGraphIndex([idx1])
 
1273
        self.assertRaises(errors.BadIndexFormatSignature, idx.validate)
1321
1274
 
1322
1275
    def test_validate_empty(self):
1323
 
        idx = _mod_index.CombinedGraphIndex([])
 
1276
        idx = index.CombinedGraphIndex([])
1324
1277
        idx.validate()
1325
1278
 
1326
1279
    def test_key_count_reloads(self):
1345
1298
 
1346
1299
    def test_iter_entries_reloads(self):
1347
1300
        index, reload_counter = self.make_combined_index_with_missing()
1348
 
        result = list(index.iter_entries([(b'1',), (b'2',), (b'3',)]))
 
1301
        result = list(index.iter_entries([('1',), ('2',), ('3',)]))
1349
1302
        index3 = index._indices[0]
1350
 
        self.assertEqual({(index3, (b'1',), b''), (index3, (b'2',), b'')},
1351
 
                         set(result))
 
1303
        self.assertEqual([(index3, ('1',), ''), (index3, ('2',), '')],
 
1304
                         result)
1352
1305
        self.assertEqual([1, 1, 0], reload_counter)
1353
1306
 
1354
1307
    def test_iter_entries_reloads_midway(self):
1356
1309
        # through
1357
1310
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1358
1311
        index1, index2 = index._indices
1359
 
        result = list(index.iter_entries([(b'1',), (b'2',), (b'3',)]))
 
1312
        result = list(index.iter_entries([('1',), ('2',), ('3',)]))
1360
1313
        index3 = index._indices[0]
1361
 
        # We had already yielded b'1', so we just go on to the next, we should
1362
 
        # not yield b'1' twice.
1363
 
        self.assertEqual([(index1, (b'1',), b''), (index3, (b'2',), b'')],
 
1314
        # We had already yielded '1', so we just go on to the next, we should
 
1315
        # not yield '1' twice.
 
1316
        self.assertEqual([(index1, ('1',), ''), (index3, ('2',), '')],
1364
1317
                         result)
1365
1318
        self.assertEqual([1, 1, 0], reload_counter)
1366
1319
 
1372
1325
 
1373
1326
    def test_iter_entries_reloads_and_fails(self):
1374
1327
        index, reload_counter = self.make_combined_index_with_missing(
1375
 
            ['1', '2', '3'])
 
1328
                                    ['1', '2', '3'])
1376
1329
        self.assertListRaises(errors.NoSuchFile, index.iter_entries, [('3',)])
1377
1330
        self.assertEqual([2, 1, 1], reload_counter)
1378
1331
 
1380
1333
        index, reload_counter = self.make_combined_index_with_missing()
1381
1334
        result = list(index.iter_all_entries())
1382
1335
        index3 = index._indices[0]
1383
 
        self.assertEqual({(index3, (b'1',), b''), (index3, (b'2',), b'')},
1384
 
                         set(result))
 
1336
        self.assertEqual([(index3, ('1',), ''), (index3, ('2',), '')],
 
1337
                         result)
1385
1338
        self.assertEqual([1, 1, 0], reload_counter)
1386
1339
 
1387
1340
    def test_iter_all_entries_reloads_midway(self):
1391
1344
        index3 = index._indices[0]
1392
1345
        # We had already yielded '1', so we just go on to the next, we should
1393
1346
        # not yield '1' twice.
1394
 
        self.assertEqual([(index1, (b'1',), b''), (index3, (b'2',), b'')],
 
1347
        self.assertEqual([(index1, ('1',), ''), (index3, ('2',), '')],
1395
1348
                         result)
1396
1349
        self.assertEqual([1, 1, 0], reload_counter)
1397
1350
 
1402
1355
 
1403
1356
    def test_iter_all_entries_reloads_and_fails(self):
1404
1357
        index, reload_counter = self.make_combined_index_with_missing(
1405
 
            ['1', '2', '3'])
 
1358
                                    ['1', '2', '3'])
1406
1359
        self.assertListRaises(errors.NoSuchFile, index.iter_all_entries)
1407
1360
 
1408
1361
    def test_iter_entries_prefix_reloads(self):
1409
1362
        index, reload_counter = self.make_combined_index_with_missing()
1410
 
        result = list(index.iter_entries_prefix([(b'1',)]))
 
1363
        result = list(index.iter_entries_prefix([('1',)]))
1411
1364
        index3 = index._indices[0]
1412
 
        self.assertEqual([(index3, (b'1',), b'')], result)
 
1365
        self.assertEqual([(index3, ('1',), '')], result)
1413
1366
        self.assertEqual([1, 1, 0], reload_counter)
1414
1367
 
1415
1368
    def test_iter_entries_prefix_reloads_midway(self):
1416
1369
        index, reload_counter = self.make_combined_index_with_missing(['2'])
1417
1370
        index1, index2 = index._indices
1418
 
        result = list(index.iter_entries_prefix([(b'1',)]))
 
1371
        result = list(index.iter_entries_prefix([('1',)]))
1419
1372
        index3 = index._indices[0]
1420
 
        # We had already yielded b'1', so we just go on to the next, we should
1421
 
        # not yield b'1' twice.
1422
 
        self.assertEqual([(index1, (b'1',), b'')], result)
 
1373
        # We had already yielded '1', so we just go on to the next, we should
 
1374
        # not yield '1' twice.
 
1375
        self.assertEqual([(index1, ('1',), '')], result)
1423
1376
        self.assertEqual([1, 1, 0], reload_counter)
1424
1377
 
1425
1378
    def test_iter_entries_prefix_no_reload(self):
1426
1379
        index, reload_counter = self.make_combined_index_with_missing()
1427
1380
        index._reload_func = None
1428
1381
        self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,
1429
 
                              [(b'1',)])
 
1382
                                                 [('1',)])
1430
1383
 
1431
1384
    def test_iter_entries_prefix_reloads_and_fails(self):
1432
1385
        index, reload_counter = self.make_combined_index_with_missing(
1433
 
            ['1', '2', '3'])
 
1386
                                    ['1', '2', '3'])
1434
1387
        self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,
1435
 
                              [(b'1',)])
 
1388
                                                 [('1',)])
 
1389
 
1436
1390
 
1437
1391
    def make_index_with_simple_nodes(self, name, num_nodes=1):
1438
1392
        """Make an index named after 'name', with keys named after 'name' too.
1440
1394
        Nodes will have a value of '' and no references.
1441
1395
        """
1442
1396
        nodes = [
1443
 
            ((('index-%s-key-%s' % (name, n)).encode('ascii'),), b'', ())
1444
 
            for n in range(1, num_nodes + 1)]
 
1397
            (('index-%s-key-%s' % (name, n),), '', ())
 
1398
            for n in range(1, num_nodes+1)]
1445
1399
        return self.make_index('index-%s' % name, 0, nodes=nodes)
1446
1400
 
1447
1401
    def test_reorder_after_iter_entries(self):
1448
1402
        # Four indices: [key1] in idx1, [key2,key3] in idx2, [] in idx3,
1449
1403
        # [key4] in idx4.
1450
 
        idx = _mod_index.CombinedGraphIndex([])
1451
 
        idx.insert_index(0, self.make_index_with_simple_nodes('1'), b'1')
1452
 
        idx.insert_index(1, self.make_index_with_simple_nodes('2'), b'2')
1453
 
        idx.insert_index(2, self.make_index_with_simple_nodes('3'), b'3')
1454
 
        idx.insert_index(3, self.make_index_with_simple_nodes('4'), b'4')
 
1404
        idx = index.CombinedGraphIndex([])
 
1405
        idx.insert_index(0, self.make_index_with_simple_nodes('1'), '1')
 
1406
        idx.insert_index(1, self.make_index_with_simple_nodes('2'), '2')
 
1407
        idx.insert_index(2, self.make_index_with_simple_nodes('3'), '3')
 
1408
        idx.insert_index(3, self.make_index_with_simple_nodes('4'), '4')
1455
1409
        idx1, idx2, idx3, idx4 = idx._indices
1456
1410
        # Query a key from idx4 and idx2.
1457
1411
        self.assertLength(2, list(idx.iter_entries(
1458
 
            [(b'index-4-key-1',), (b'index-2-key-1',)])))
 
1412
            [('index-4-key-1',), ('index-2-key-1',)])))
1459
1413
        # Now idx2 and idx4 should be moved to the front (and idx1 should
1460
1414
        # still be before idx3).
1461
1415
        self.assertEqual([idx2, idx4, idx1, idx3], idx._indices)
1462
 
        self.assertEqual([b'2', b'4', b'1', b'3'], idx._index_names)
 
1416
        self.assertEqual(['2', '4', '1', '3'], idx._index_names)
1463
1417
 
1464
1418
    def test_reorder_propagates_to_siblings(self):
1465
1419
        # Two CombinedGraphIndex objects, with the same number of indicies with
1466
1420
        # matching names.
1467
 
        cgi1 = _mod_index.CombinedGraphIndex([])
1468
 
        cgi2 = _mod_index.CombinedGraphIndex([])
 
1421
        cgi1 = index.CombinedGraphIndex([])
 
1422
        cgi2 = index.CombinedGraphIndex([])
1469
1423
        cgi1.insert_index(0, self.make_index_with_simple_nodes('1-1'), 'one')
1470
1424
        cgi1.insert_index(1, self.make_index_with_simple_nodes('1-2'), 'two')
1471
1425
        cgi2.insert_index(0, self.make_index_with_simple_nodes('2-1'), 'one')
1473
1427
        index2_1, index2_2 = cgi2._indices
1474
1428
        cgi1.set_sibling_indices([cgi2])
1475
1429
        # Trigger a reordering in cgi1.  cgi2 will be reordered as well.
1476
 
        list(cgi1.iter_entries([(b'index-1-2-key-1',)]))
 
1430
        list(cgi1.iter_entries([('index-1-2-key-1',)]))
1477
1431
        self.assertEqual([index2_2, index2_1], cgi2._indices)
1478
1432
        self.assertEqual(['two', 'one'], cgi2._index_names)
1479
1433
 
1497
1451
        self.assertRaises(errors.NoSuchFile, idx.validate)
1498
1452
 
1499
1453
    def test_find_ancestors_across_indexes(self):
1500
 
        key1 = (b'key-1',)
1501
 
        key2 = (b'key-2',)
1502
 
        key3 = (b'key-3',)
1503
 
        key4 = (b'key-4',)
 
1454
        key1 = ('key-1',)
 
1455
        key2 = ('key-2',)
 
1456
        key3 = ('key-3',)
 
1457
        key4 = ('key-4',)
1504
1458
        index1 = self.make_index('12', ref_lists=1, nodes=[
1505
 
            (key1, b'value', ([],)),
1506
 
            (key2, b'value', ([key1],)),
 
1459
            (key1, 'value', ([],)),
 
1460
            (key2, 'value', ([key1],)),
1507
1461
            ])
1508
1462
        index2 = self.make_index('34', ref_lists=1, nodes=[
1509
 
            (key3, b'value', ([key2],)),
1510
 
            (key4, b'value', ([key3],)),
 
1463
            (key3, 'value', ([key2],)),
 
1464
            (key4, 'value', ([key3],)),
1511
1465
            ])
1512
 
        c_index = _mod_index.CombinedGraphIndex([index1, index2])
 
1466
        c_index = index.CombinedGraphIndex([index1, index2])
1513
1467
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1514
1468
        self.assertEqual({key1: ()}, parent_map)
1515
1469
        self.assertEqual(set(), missing_keys)
1521
1475
        self.assertEqual(set(), missing_keys)
1522
1476
 
1523
1477
    def test_find_ancestors_missing_keys(self):
1524
 
        key1 = (b'key-1',)
1525
 
        key2 = (b'key-2',)
1526
 
        key3 = (b'key-3',)
1527
 
        key4 = (b'key-4',)
 
1478
        key1 = ('key-1',)
 
1479
        key2 = ('key-2',)
 
1480
        key3 = ('key-3',)
 
1481
        key4 = ('key-4',)
1528
1482
        index1 = self.make_index('12', ref_lists=1, nodes=[
1529
 
            (key1, b'value', ([],)),
1530
 
            (key2, b'value', ([key1],)),
 
1483
            (key1, 'value', ([],)),
 
1484
            (key2, 'value', ([key1],)),
1531
1485
            ])
1532
1486
        index2 = self.make_index('34', ref_lists=1, nodes=[
1533
 
            (key3, b'value', ([key2],)),
 
1487
            (key3, 'value', ([key2],)),
1534
1488
            ])
1535
 
        c_index = _mod_index.CombinedGraphIndex([index1, index2])
 
1489
        c_index = index.CombinedGraphIndex([index1, index2])
1536
1490
        # Searching for a key which is actually not present at all should
1537
1491
        # eventually converge
1538
1492
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1539
1493
        self.assertEqual({}, parent_map)
1540
 
        self.assertEqual({key4}, missing_keys)
 
1494
        self.assertEqual(set([key4]), missing_keys)
1541
1495
 
1542
1496
    def test_find_ancestors_no_indexes(self):
1543
 
        c_index = _mod_index.CombinedGraphIndex([])
1544
 
        key1 = (b'key-1',)
 
1497
        c_index = index.CombinedGraphIndex([])
 
1498
        key1 = ('key-1',)
1545
1499
        parent_map, missing_keys = c_index.find_ancestry([key1], 0)
1546
1500
        self.assertEqual({}, parent_map)
1547
 
        self.assertEqual({key1}, missing_keys)
 
1501
        self.assertEqual(set([key1]), missing_keys)
1548
1502
 
1549
1503
    def test_find_ancestors_ghost_parent(self):
1550
 
        key1 = (b'key-1',)
1551
 
        key2 = (b'key-2',)
1552
 
        key3 = (b'key-3',)
1553
 
        key4 = (b'key-4',)
 
1504
        key1 = ('key-1',)
 
1505
        key2 = ('key-2',)
 
1506
        key3 = ('key-3',)
 
1507
        key4 = ('key-4',)
1554
1508
        index1 = self.make_index('12', ref_lists=1, nodes=[
1555
 
            (key1, b'value', ([],)),
1556
 
            (key2, b'value', ([key1],)),
 
1509
            (key1, 'value', ([],)),
 
1510
            (key2, 'value', ([key1],)),
1557
1511
            ])
1558
1512
        index2 = self.make_index('34', ref_lists=1, nodes=[
1559
 
            (key4, b'value', ([key2, key3],)),
 
1513
            (key4, 'value', ([key2, key3],)),
1560
1514
            ])
1561
 
        c_index = _mod_index.CombinedGraphIndex([index1, index2])
 
1515
        c_index = index.CombinedGraphIndex([index1, index2])
1562
1516
        # Searching for a key which is actually not present at all should
1563
1517
        # eventually converge
1564
1518
        parent_map, missing_keys = c_index.find_ancestry([key4], 0)
1565
1519
        self.assertEqual({key4: (key2, key3), key2: (key1,), key1: ()},
1566
1520
                         parent_map)
1567
 
        self.assertEqual({key3}, missing_keys)
 
1521
        self.assertEqual(set([key3]), missing_keys)
1568
1522
 
1569
1523
    def test__find_ancestors_empty_index(self):
1570
1524
        idx = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
1571
1525
        parent_map = {}
1572
1526
        missing_keys = set()
1573
 
        search_keys = idx._find_ancestors([(b'one',), (b'two',)], 0, parent_map,
 
1527
        search_keys = idx._find_ancestors([('one',), ('two',)], 0, parent_map,
1574
1528
                                          missing_keys)
1575
1529
        self.assertEqual(set(), search_keys)
1576
1530
        self.assertEqual({}, parent_map)
1577
 
        self.assertEqual({(b'one',), (b'two',)}, missing_keys)
 
1531
        self.assertEqual(set([('one',), ('two',)]), missing_keys)
1578
1532
 
1579
1533
 
1580
1534
class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):
1581
1535
 
1582
1536
    def make_index(self, ref_lists=0, key_elements=1, nodes=[]):
1583
 
        result = _mod_index.InMemoryGraphIndex(
1584
 
            ref_lists, key_elements=key_elements)
 
1537
        result = index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1585
1538
        result.add_nodes(nodes)
1586
1539
        return result
1587
1540
 
1588
1541
    def test_add_nodes_no_refs(self):
1589
1542
        index = self.make_index(0)
1590
 
        index.add_nodes([((b'name', ), b'data')])
1591
 
        index.add_nodes([((b'name2', ), b''), ((b'name3', ), b'')])
1592
 
        self.assertEqual({
1593
 
            (index, (b'name', ), b'data'),
1594
 
            (index, (b'name2', ), b''),
1595
 
            (index, (b'name3', ), b''),
1596
 
            }, set(index.iter_all_entries()))
 
1543
        index.add_nodes([(('name', ), 'data')])
 
1544
        index.add_nodes([(('name2', ), ''), (('name3', ), '')])
 
1545
        self.assertEqual(set([
 
1546
            (index, ('name', ), 'data'),
 
1547
            (index, ('name2', ), ''),
 
1548
            (index, ('name3', ), ''),
 
1549
            ]), set(index.iter_all_entries()))
1597
1550
 
1598
1551
    def test_add_nodes(self):
1599
1552
        index = self.make_index(1)
1600
 
        index.add_nodes([((b'name', ), b'data', ([],))])
1601
 
        index.add_nodes([((b'name2', ), b'', ([],)),
1602
 
                         ((b'name3', ), b'', ([(b'r', )],))])
1603
 
        self.assertEqual({
1604
 
            (index, (b'name', ), b'data', ((),)),
1605
 
            (index, (b'name2', ), b'', ((),)),
1606
 
            (index, (b'name3', ), b'', (((b'r', ), ), )),
1607
 
            }, set(index.iter_all_entries()))
 
1553
        index.add_nodes([(('name', ), 'data', ([],))])
 
1554
        index.add_nodes([(('name2', ), '', ([],)), (('name3', ), '', ([('r', )],))])
 
1555
        self.assertEqual(set([
 
1556
            (index, ('name', ), 'data', ((),)),
 
1557
            (index, ('name2', ), '', ((),)),
 
1558
            (index, ('name3', ), '', ((('r', ), ), )),
 
1559
            ]), set(index.iter_all_entries()))
1608
1560
 
1609
1561
    def test_iter_all_entries_empty(self):
1610
1562
        index = self.make_index()
1611
1563
        self.assertEqual([], list(index.iter_all_entries()))
1612
1564
 
1613
1565
    def test_iter_all_entries_simple(self):
1614
 
        index = self.make_index(nodes=[((b'name', ), b'data')])
1615
 
        self.assertEqual([(index, (b'name', ), b'data')],
1616
 
                         list(index.iter_all_entries()))
 
1566
        index = self.make_index(nodes=[(('name', ), 'data')])
 
1567
        self.assertEqual([(index, ('name', ), 'data')],
 
1568
            list(index.iter_all_entries()))
1617
1569
 
1618
1570
    def test_iter_all_entries_references(self):
1619
1571
        index = self.make_index(1, nodes=[
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()))
 
1572
            (('name', ), 'data', ([('ref', )], )),
 
1573
            (('ref', ), 'refdata', ([], ))])
 
1574
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref', ),),)),
 
1575
            (index, ('ref', ), 'refdata', ((), ))]),
 
1576
            set(index.iter_all_entries()))
1625
1577
 
1626
1578
    def test_iteration_absent_skipped(self):
1627
1579
        index = self.make_index(1, nodes=[
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
            (('name', ), 'data', ([('ref', )], ))])
 
1581
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
1582
            set(index.iter_all_entries()))
 
1583
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),))]),
 
1584
            set(index.iter_entries([('name', )])))
 
1585
        self.assertEqual([], list(index.iter_entries([('ref', )])))
1634
1586
 
1635
1587
    def test_iter_all_keys(self):
1636
1588
        index = self.make_index(1, nodes=[
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', )])))
 
1589
            (('name', ), 'data', ([('ref', )], )),
 
1590
            (('ref', ), 'refdata', ([], ))])
 
1591
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
 
1592
            (index, ('ref', ), 'refdata', ((), ))]),
 
1593
            set(index.iter_entries([('name', ), ('ref', )])))
1642
1594
 
1643
1595
    def test_iter_key_prefix_1_key_element_no_refs(self):
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
        index = self.make_index( nodes=[
 
1597
            (('name', ), 'data'),
 
1598
            (('ref', ), 'refdata')])
 
1599
        self.assertEqual(set([(index, ('name', ), 'data'),
 
1600
            (index, ('ref', ), 'refdata')]),
 
1601
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
1650
1602
 
1651
1603
    def test_iter_key_prefix_1_key_element_refs(self):
1652
1604
        index = self.make_index(1, nodes=[
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', )])))
 
1605
            (('name', ), 'data', ([('ref', )], )),
 
1606
            (('ref', ), 'refdata', ([], ))])
 
1607
        self.assertEqual(set([(index, ('name', ), 'data', ((('ref',),),)),
 
1608
            (index, ('ref', ), 'refdata', ((), ))]),
 
1609
            set(index.iter_entries_prefix([('name', ), ('ref', )])))
1658
1610
 
1659
1611
    def test_iter_key_prefix_2_key_element_no_refs(self):
1660
1612
        index = self.make_index(key_elements=2, nodes=[
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)])))
 
1613
            (('name', 'fin1'), 'data'),
 
1614
            (('name', 'fin2'), 'beta'),
 
1615
            (('ref', 'erence'), 'refdata')])
 
1616
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
 
1617
            (index, ('ref', 'erence'), 'refdata')]),
 
1618
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
 
1619
        self.assertEqual(set([(index, ('name', 'fin1'), 'data'),
 
1620
            (index, ('name', 'fin2'), 'beta')]),
 
1621
            set(index.iter_entries_prefix([('name', None)])))
1670
1622
 
1671
1623
    def test_iter_key_prefix_2_key_element_refs(self):
1672
1624
        index = self.make_index(1, key_elements=2, nodes=[
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)])))
 
1625
            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
 
1626
            (('name', 'fin2'), 'beta', ([], )),
 
1627
            (('ref', 'erence'), 'refdata', ([], ))])
 
1628
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
1629
            (index, ('ref', 'erence'), 'refdata', ((), ))]),
 
1630
            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
 
1631
        self.assertEqual(set([(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
 
1632
            (index, ('name', 'fin2'), 'beta', ((), ))]),
 
1633
            set(index.iter_entries_prefix([('name', None)])))
1682
1634
 
1683
1635
    def test_iter_nothing_empty(self):
1684
1636
        index = self.make_index()
1686
1638
 
1687
1639
    def test_iter_missing_entry_empty(self):
1688
1640
        index = self.make_index()
1689
 
        self.assertEqual([], list(index.iter_entries([b'a'])))
 
1641
        self.assertEqual([], list(index.iter_entries(['a'])))
1690
1642
 
1691
1643
    def test_key_count_empty(self):
1692
1644
        index = self.make_index()
1693
1645
        self.assertEqual(0, index.key_count())
1694
1646
 
1695
1647
    def test_key_count_one(self):
1696
 
        index = self.make_index(nodes=[((b'name', ), b'')])
 
1648
        index = self.make_index(nodes=[(('name', ), '')])
1697
1649
        self.assertEqual(1, index.key_count())
1698
1650
 
1699
1651
    def test_key_count_two(self):
1700
 
        index = self.make_index(nodes=[((b'name', ), b''), ((b'foo', ), b'')])
 
1652
        index = self.make_index(nodes=[(('name', ), ''), (('foo', ), '')])
1701
1653
        self.assertEqual(2, index.key_count())
1702
1654
 
1703
1655
    def test_validate_empty(self):
1705
1657
        index.validate()
1706
1658
 
1707
1659
    def test_validate_no_refs_content(self):
1708
 
        index = self.make_index(nodes=[((b'key', ), b'value')])
 
1660
        index = self.make_index(nodes=[(('key', ), 'value')])
1709
1661
        index.validate()
1710
1662
 
1711
1663
 
1713
1665
 
1714
1666
    def make_index(self, ref_lists=1, key_elements=2, nodes=[],
1715
1667
                   add_callback=False):
1716
 
        result = _mod_index.InMemoryGraphIndex(
1717
 
            ref_lists, key_elements=key_elements)
 
1668
        result = index.InMemoryGraphIndex(ref_lists, key_elements=key_elements)
1718
1669
        result.add_nodes(nodes)
1719
1670
        if add_callback:
1720
1671
            add_nodes_callback = result.add_nodes
1721
1672
        else:
1722
1673
            add_nodes_callback = None
1723
 
        adapter = _mod_index.GraphIndexPrefixAdapter(
1724
 
            result, (b'prefix', ), key_elements - 1,
 
1674
        adapter = index.GraphIndexPrefixAdapter(
 
1675
            result, ('prefix', ), key_elements - 1,
1725
1676
            add_nodes_callback=add_nodes_callback)
1726
1677
        return result, adapter
1727
1678
 
1728
1679
    def test_add_node(self):
1729
1680
        index, adapter = self.make_index(add_callback=True)
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()))
 
1681
        adapter.add_node(('key',), 'value', ((('ref',),),))
 
1682
        self.assertEqual(set([(index, ('prefix', 'key'), 'value',
 
1683
                               ((('prefix', 'ref'),),))]),
 
1684
            set(index.iter_all_entries()))
1734
1685
 
1735
1686
    def test_add_nodes(self):
1736
1687
        index, adapter = self.make_index(add_callback=True)
1737
1688
        adapter.add_nodes((
1738
 
            ((b'key',), b'value', (((b'ref',),),)),
1739
 
            ((b'key2',), b'value2', ((),)),
 
1689
            (('key',), 'value', ((('ref',),),)),
 
1690
            (('key2',), 'value2', ((),)),
1740
1691
            ))
1741
 
        self.assertEqual({
1742
 
            (index, (b'prefix', b'key2'), b'value2', ((),)),
1743
 
            (index, (b'prefix', b'key'), b'value', (((b'prefix', b'ref'),),))
1744
 
            },
 
1692
        self.assertEqual(set([
 
1693
            (index, ('prefix', 'key2'), 'value2', ((),)),
 
1694
            (index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))
 
1695
            ]),
1745
1696
            set(index.iter_all_entries()))
1746
1697
 
1747
1698
    def test_construct(self):
1748
 
        idx = _mod_index.InMemoryGraphIndex()
1749
 
        adapter = _mod_index.GraphIndexPrefixAdapter(idx, (b'prefix', ), 1)
 
1699
        idx = index.InMemoryGraphIndex()
 
1700
        adapter = index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1)
1750
1701
 
1751
1702
    def test_construct_with_callback(self):
1752
 
        idx = _mod_index.InMemoryGraphIndex()
1753
 
        adapter = _mod_index.GraphIndexPrefixAdapter(idx, (b'prefix', ), 1,
1754
 
                                                     idx.add_nodes)
 
1703
        idx = index.InMemoryGraphIndex()
 
1704
        adapter = index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1,
 
1705
                                                idx.add_nodes)
1755
1706
 
1756
1707
    def test_iter_all_entries_cross_prefix_map_errors(self):
1757
1708
        index, adapter = self.make_index(nodes=[
1758
 
            ((b'prefix', b'key1'), b'data1', (((b'prefixaltered', b'key2'),),))])
1759
 
        self.assertRaises(_mod_index.BadIndexData, list,
1760
 
                          adapter.iter_all_entries())
 
1709
            (('prefix', 'key1'), 'data1', ((('prefixaltered', 'key2'),),))])
 
1710
        self.assertRaises(errors.BadIndexData, list, adapter.iter_all_entries())
1761
1711
 
1762
1712
    def test_iter_all_entries(self):
1763
1713
        index, adapter = self.make_index(nodes=[
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()))
 
1714
            (('notprefix', 'key1'), 'data', ((), )),
 
1715
            (('prefix', 'key1'), 'data1', ((), )),
 
1716
            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
 
1717
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
 
1718
            (index, ('key2', ), 'data2', ((('key1',),),))]),
 
1719
            set(adapter.iter_all_entries()))
1770
1720
 
1771
1721
    def test_iter_entries(self):
1772
1722
        index, adapter = self.make_index(nodes=[
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'),),))])
 
1723
            (('notprefix', 'key1'), 'data', ((), )),
 
1724
            (('prefix', 'key1'), 'data1', ((), )),
 
1725
            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1776
1726
        # ask for many - get all
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', )])))
 
1727
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),)),
 
1728
            (index, ('key2', ), 'data2', ((('key1', ),),))]),
 
1729
            set(adapter.iter_entries([('key1', ), ('key2', )])))
1780
1730
        # ask for one, get one
1781
 
        self.assertEqual({(index, (b'key1', ), b'data1', ((),))},
1782
 
                         set(adapter.iter_entries([(b'key1', )])))
 
1731
        self.assertEqual(set([(index, ('key1', ), 'data1', ((),))]),
 
1732
            set(adapter.iter_entries([('key1', )])))
1783
1733
        # ask for missing, get none
1784
1734
        self.assertEqual(set(),
1785
 
                         set(adapter.iter_entries([(b'key3', )])))
 
1735
            set(adapter.iter_entries([('key3', )])))
1786
1736
 
1787
1737
    def test_iter_entries_prefix(self):
1788
1738
        index, adapter = self.make_index(key_elements=3, nodes=[
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'),),))])
 
1739
            (('notprefix', 'foo', 'key1'), 'data', ((), )),
 
1740
            (('prefix', 'prefix2', 'key1'), 'data1', ((), )),
 
1741
            (('prefix', 'prefix2', 'key2'), 'data2', ((('prefix', 'prefix2', 'key1'),),))])
1792
1742
        # ask for a prefix, get the results for just that prefix, adjusted.
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)])))
 
1743
        self.assertEqual(set([(index, ('prefix2', 'key1', ), 'data1', ((),)),
 
1744
            (index, ('prefix2', 'key2', ), 'data2', ((('prefix2', 'key1', ),),))]),
 
1745
            set(adapter.iter_entries_prefix([('prefix2', None)])))
1796
1746
 
1797
1747
    def test_key_count_no_matching_keys(self):
1798
1748
        index, adapter = self.make_index(nodes=[
1799
 
            ((b'notprefix', b'key1'), b'data', ((), ))])
 
1749
            (('notprefix', 'key1'), 'data', ((), ))])
1800
1750
        self.assertEqual(0, adapter.key_count())
1801
1751
 
1802
1752
    def test_key_count_some_keys(self):
1803
1753
        index, adapter = self.make_index(nodes=[
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'),),))])
 
1754
            (('notprefix', 'key1'), 'data', ((), )),
 
1755
            (('prefix', 'key1'), 'data1', ((), )),
 
1756
            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
1807
1757
        self.assertEqual(2, adapter.key_count())
1808
1758
 
1809
1759
    def test_validate(self):
1810
1760
        index, adapter = self.make_index()
1811
1761
        calls = []
1812
 
 
1813
1762
        def validate():
1814
1763
            calls.append('called')
1815
1764
        index.validate = validate