/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_index.py

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

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