Skip to content

Commit 508e2a4

Browse files
chemelnucfinchemelnucfin
committed
Spanner: extra tests
1 parent 2edd612 commit 508e2a4

File tree

1 file changed

+360
-0
lines changed

1 file changed

+360
-0
lines changed

‎spanner/tests/unit/test_keyset.py‎

Lines changed: 360 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -119,6 +119,366 @@ def test_to_pb_w_start_open_and_end_closed(self):
119119
self.assertEqual(len(krange_pb.end_closed), 1)
120120
self.assertEqual(krange_pb.end_closed.values[0].string_value, KEY_2[0])
121121

122+
def test_ctor_empty_list_start_closed_and_key_end_closed(self):
123+
KEY_1 = [u'key_1']
124+
key_types = {'start_closed': [], 'end_closed': KEY_1}
125+
krange = self._make_one(**key_types)
126+
krange_pb = krange.to_pb()
127+
used_keys = []
128+
for key_type in six.iterkeys(key_types):
129+
used_keys.append(key_type)
130+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
131+
self._check_unused_keys(krange, used_keys)
132+
133+
def test_ctor_empty_list_start_closed_and_key_end_open(self):
134+
KEY_1 = [u'key_1']
135+
key_types = {'start_closed': [], 'end_open': KEY_1}
136+
krange = self._make_one(**key_types)
137+
krange_pb = krange.to_pb()
138+
used_keys = []
139+
for key_type in six.iterkeys(key_types):
140+
used_keys.append(key_type)
141+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
142+
self._check_unused_keys(krange, used_keys)
143+
144+
def test_ctor_empty_list_end_closed_and_key_start_closed(self):
145+
KEY_1 = [u'key_1']
146+
key_types = {'start_closed': KEY_1, 'end_closed': []}
147+
krange = self._make_one(**key_types)
148+
krange_pb = krange.to_pb()
149+
used_keys = []
150+
for key_type in six.iterkeys(key_types):
151+
used_keys.append(key_type)
152+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
153+
self._check_unused_keys(krange, used_keys)
154+
155+
def test_ctor_empty_list_end_open_and_key_start_closed(self):
156+
KEY_1 = [u'key_1']
157+
key_types = {'start_closed': KEY_1, 'end_open': []}
158+
krange = self._make_one(**key_types)
159+
krange_pb = krange.to_pb()
160+
used_keys = []
161+
for key_type in six.iterkeys(key_types):
162+
used_keys.append(key_type)
163+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
164+
self._check_unused_keys(krange, used_keys)
165+
166+
def test_ctor_empty_list_start_open_and_key_end_closed(self):
167+
KEY_1 = [u'key_1']
168+
key_types = {'start_open': [], 'end_closed': KEY_1}
169+
krange = self._make_one(**key_types)
170+
krange_pb = krange.to_pb()
171+
used_keys = []
172+
for key_type in six.iterkeys(key_types):
173+
used_keys.append(key_type)
174+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
175+
self._check_unused_keys(krange, used_keys)
176+
177+
def test_ctor_empty_list_start_open_and_key_end_open(self):
178+
KEY_1 = [u'key_1']
179+
key_types = {'start_open': [], 'end_open': KEY_1}
180+
krange = self._make_one(**key_types)
181+
krange_pb = krange.to_pb()
182+
used_keys = []
183+
for key_type in six.iterkeys(key_types):
184+
used_keys.append(key_type)
185+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
186+
self._check_unused_keys(krange, used_keys)
187+
188+
def test_ctor_empty_list_end_closed_and_key_start_open(self):
189+
KEY_1 = [u'key_1']
190+
key_types = {'start_open': KEY_1, 'end_closed': []}
191+
krange = self._make_one(**key_types)
192+
krange_pb = krange.to_pb()
193+
used_keys = []
194+
for key_type in six.iterkeys(key_types):
195+
used_keys.append(key_type)
196+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
197+
self._check_unused_keys(krange, used_keys)
198+
199+
def test_ctor_empty_list_end_open_and_key_start_open(self):
200+
KEY_1 = [u'key_1']
201+
key_types = {'start_open': KEY_1, 'end_open': []}
202+
krange = self._make_one(**key_types)
203+
krange_pb = krange.to_pb()
204+
used_keys = []
205+
for key_type in six.iterkeys(key_types):
206+
used_keys.append(key_type)
207+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
208+
self._check_unused_keys(krange, used_keys)
209+
210+
def test_to_pb_empty_list_start_closed_and_key_end_closed(self):
211+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
212+
213+
KEY_1 = [u'key_1']
214+
KEY_2 = [u'key_2']
215+
key_types = {'start_closed': [], 'end_closed': KEY_1}
216+
krange = self._make_one(**key_types)
217+
krange_pb = krange.to_pb()
218+
self.assertIsInstance(krange_pb, KeyRange)
219+
used_keys = []
220+
for key_type in six.iterkeys(key_types):
221+
used_keys.append(key_type)
222+
if key_types[key_type] == KEY_1:
223+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
224+
key1 = getattr(krange_pb, key_type).values[0].string_value
225+
self.assertEqual(key1, KEY_1[0])
226+
else:
227+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
228+
self._check_unused_keys(krange, used_keys)
229+
230+
def test_to_pb_empty_list_start_closed_and_key_end_open(self):
231+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
232+
233+
KEY_1 = [u'key_1']
234+
KEY_2 = [u'key_2']
235+
key_types = {'start_closed': [], 'end_open': KEY_1}
236+
krange = self._make_one(**key_types)
237+
krange_pb = krange.to_pb()
238+
self.assertIsInstance(krange_pb, KeyRange)
239+
used_keys = []
240+
for key_type in six.iterkeys(key_types):
241+
used_keys.append(key_type)
242+
if key_types[key_type] == KEY_1:
243+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
244+
key1 = getattr(krange_pb, key_type).values[0].string_value
245+
self.assertEqual(key1, KEY_1[0])
246+
else:
247+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
248+
self._check_unused_keys(krange, used_keys)
249+
250+
def test_to_pb_empty_list_end_closed_and_key_start_closed(self):
251+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
252+
253+
KEY_1 = [u'key_1']
254+
KEY_2 = [u'key_2']
255+
key_types = {'start_closed': KEY_1, 'end_closed': []}
256+
krange = self._make_one(**key_types)
257+
krange_pb = krange.to_pb()
258+
self.assertIsInstance(krange_pb, KeyRange)
259+
used_keys = []
260+
for key_type in six.iterkeys(key_types):
261+
used_keys.append(key_type)
262+
if key_types[key_type] == KEY_1:
263+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
264+
key1 = getattr(krange_pb, key_type).values[0].string_value
265+
self.assertEqual(key1, KEY_1[0])
266+
else:
267+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
268+
self._check_unused_keys(krange, used_keys)
269+
270+
def test_to_pb_empty_list_end_open_and_key_start_closed(self):
271+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
272+
273+
KEY_1 = [u'key_1']
274+
KEY_2 = [u'key_2']
275+
key_types = {'start_closed': KEY_1, 'end_open': []}
276+
krange = self._make_one(**key_types)
277+
krange_pb = krange.to_pb()
278+
self.assertIsInstance(krange_pb, KeyRange)
279+
used_keys = []
280+
for key_type in six.iterkeys(key_types):
281+
used_keys.append(key_type)
282+
if key_types[key_type] == KEY_1:
283+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
284+
key1 = getattr(krange_pb, key_type).values[0].string_value
285+
self.assertEqual(key1, KEY_1[0])
286+
else:
287+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
288+
self._check_unused_keys(krange, used_keys)
289+
290+
def test_to_pb_empty_list_start_open_and_key_end_closed(self):
291+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
292+
293+
KEY_1 = [u'key_1']
294+
KEY_2 = [u'key_2']
295+
key_types = {'start_open': [], 'end_closed': KEY_1}
296+
krange = self._make_one(**key_types)
297+
krange_pb = krange.to_pb()
298+
self.assertIsInstance(krange_pb, KeyRange)
299+
used_keys = []
300+
for key_type in six.iterkeys(key_types):
301+
used_keys.append(key_type)
302+
if key_types[key_type] == KEY_1:
303+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
304+
key1 = getattr(krange_pb, key_type).values[0].string_value
305+
self.assertEqual(key1, KEY_1[0])
306+
else:
307+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
308+
self._check_unused_keys(krange, used_keys)
309+
310+
def test_to_pb_empty_list_start_open_and_key_end_open(self):
311+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
312+
313+
KEY_1 = [u'key_1']
314+
KEY_2 = [u'key_2']
315+
key_types = {'start_open': [], 'end_open': KEY_1}
316+
krange = self._make_one(**key_types)
317+
krange_pb = krange.to_pb()
318+
self.assertIsInstance(krange_pb, KeyRange)
319+
used_keys = []
320+
for key_type in six.iterkeys(key_types):
321+
used_keys.append(key_type)
322+
if key_types[key_type] == KEY_1:
323+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
324+
key1 = getattr(krange_pb, key_type).values[0].string_value
325+
self.assertEqual(key1, KEY_1[0])
326+
else:
327+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
328+
self._check_unused_keys(krange, used_keys)
329+
330+
def test_to_pb_empty_list_end_closed_and_key_start_open(self):
331+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
332+
333+
KEY_1 = [u'key_1']
334+
KEY_2 = [u'key_2']
335+
key_types = {'start_open': KEY_1, 'end_closed': []}
336+
krange = self._make_one(**key_types)
337+
krange_pb = krange.to_pb()
338+
self.assertIsInstance(krange_pb, KeyRange)
339+
used_keys = []
340+
for key_type in six.iterkeys(key_types):
341+
used_keys.append(key_type)
342+
if key_types[key_type] == KEY_1:
343+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
344+
key1 = getattr(krange_pb, key_type).values[0].string_value
345+
self.assertEqual(key1, KEY_1[0])
346+
else:
347+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
348+
self._check_unused_keys(krange, used_keys)
349+
350+
def test_to_pb_empty_list_end_open_and_key_start_open(self):
351+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
352+
353+
KEY_1 = [u'key_1']
354+
KEY_2 = [u'key_2']
355+
key_types = {'start_open': KEY_1, 'end_open': []}
356+
krange = self._make_one(**key_types)
357+
krange_pb = krange.to_pb()
358+
self.assertIsInstance(krange_pb, KeyRange)
359+
used_keys = []
360+
for key_type in six.iterkeys(key_types):
361+
used_keys.append(key_type)
362+
if key_types[key_type] == KEY_1:
363+
self.assertEqual(len(getattr(krange_pb, key_type)), 1)
364+
key1 = getattr(krange_pb, key_type).values[0].string_value
365+
self.assertEqual(key1, KEY_1[0])
366+
else:
367+
self.assertEqual(len(getattr(krange_pb, key_type)), 0)
368+
self._check_unused_keys(krange, used_keys)
369+
370+
def test_ctor_keys_start_closed_end_closed(self):
371+
KEY_1 = [u'key_1']
372+
KEY_2 = [u'key_2']
373+
key_types = {'start_closed': KEY_1, 'end_closed': KEY_2}
374+
krange = self._make_one(**key_types)
375+
used_keys = []
376+
for key_type in six.iterkeys(key_types):
377+
used_keys.append(key_type)
378+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
379+
self._check_unused_keys(krange, used_keys)
380+
381+
def test_ctor_keys_start_closed_end_open(self):
382+
KEY_1 = [u'key_1']
383+
KEY_2 = [u'key_2']
384+
key_types = {'start_closed': KEY_1, 'end_open': KEY_2}
385+
krange = self._make_one(**key_types)
386+
used_keys = []
387+
for key_type in six.iterkeys(key_types):
388+
used_keys.append(key_type)
389+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
390+
self._check_unused_keys(krange, used_keys)
391+
392+
def test_ctor_keys_start_open_end_closed(self):
393+
KEY_1 = [u'key_1']
394+
KEY_2 = [u'key_2']
395+
key_types = {'start_open': KEY_1, 'end_closed': KEY_2}
396+
krange = self._make_one(**key_types)
397+
used_keys = []
398+
for key_type in six.iterkeys(key_types):
399+
used_keys.append(key_type)
400+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
401+
self._check_unused_keys(krange, used_keys)
402+
403+
def test_ctor_keys_start_open_end_open(self):
404+
KEY_1 = [u'key_1']
405+
KEY_2 = [u'key_2']
406+
key_types = {'start_open': KEY_1, 'end_open': KEY_2}
407+
krange = self._make_one(**key_types)
408+
used_keys = []
409+
for key_type in six.iterkeys(key_types):
410+
used_keys.append(key_type)
411+
self.assertEqual(getattr(krange, key_type), key_types[key_type])
412+
self._check_unused_keys(krange, used_keys)
413+
414+
def test_to_pb_keys_start_closed_end_closed(self):
415+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
416+
KEY_1 = [u'key_1']
417+
KEY_2 = [u'key_2']
418+
key_types = {'start_closed': KEY_1, 'end_closed': KEY_2}
419+
krange = self._make_one(**key_types)
420+
krange_pb = krange.to_pb()
421+
self.assertIsInstance(krange_pb, KeyRange)
422+
used_keys = []
423+
for key_type in six.iterkeys(key_types):
424+
used_keys.append(key_type)
425+
pb_key_type = getattr(krange_pb, key_type)
426+
self.assertEqual(len(pb_key_type), 1)
427+
self.assertEqual(pb_key_type.values[0].string_value,
428+
key_types[key_type][0])
429+
self._check_unused_keys(krange, used_keys)
430+
431+
def test_to_pb_keys_start_closed_end_open(self):
432+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
433+
KEY_1 = [u'key_1']
434+
KEY_2 = [u'key_2']
435+
key_types = {'start_closed': KEY_1, 'end_open': KEY_2}
436+
krange = self._make_one(**key_types)
437+
krange_pb = krange.to_pb()
438+
self.assertIsInstance(krange_pb, KeyRange)
439+
used_keys = []
440+
for key_type in six.iterkeys(key_types):
441+
used_keys.append(key_type)
442+
pb_key_type = getattr(krange_pb, key_type)
443+
self.assertEqual(len(pb_key_type), 1)
444+
self.assertEqual(pb_key_type.values[0].string_value,
445+
key_types[key_type][0])
446+
self._check_unused_keys(krange, used_keys)
447+
448+
def test_to_pb_keys_start_open_end_closed(self):
449+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
450+
KEY_1 = [u'key_1']
451+
KEY_2 = [u'key_2']
452+
key_types = {'start_open': KEY_1, 'end_closed': KEY_2}
453+
krange = self._make_one(**key_types)
454+
krange_pb = krange.to_pb()
455+
self.assertIsInstance(krange_pb, KeyRange)
456+
used_keys = []
457+
for key_type in six.iterkeys(key_types):
458+
used_keys.append(key_type)
459+
pb_key_type = getattr(krange_pb, key_type)
460+
self.assertEqual(len(pb_key_type), 1)
461+
self.assertEqual(pb_key_type.values[0].string_value,
462+
key_types[key_type][0])
463+
self._check_unused_keys(krange, used_keys)
464+
465+
def test_to_pb_keys_start_open_end_open(self):
466+
from google.cloud.spanner_v1.proto.keys_pb2 import KeyRange
467+
KEY_1 = [u'key_1']
468+
KEY_2 = [u'key_2']
469+
key_types = {'start_open': KEY_1, 'end_open': KEY_2}
470+
krange = self._make_one(**key_types)
471+
krange_pb = krange.to_pb()
472+
self.assertIsInstance(krange_pb, KeyRange)
473+
used_keys = []
474+
for key_type in six.iterkeys(key_types):
475+
used_keys.append(key_type)
476+
pb_key_type = getattr(krange_pb, key_type)
477+
self.assertEqual(len(pb_key_type), 1)
478+
self.assertEqual(pb_key_type.values[0].string_value,
479+
key_types[key_type][0])
480+
self._check_unused_keys(krange, used_keys)
481+
122482

123483
class TestKeySet(unittest.TestCase):
124484

0 commit comments

Comments
 (0)