← Back to branch summary

~isviridov/magnetodb/master

« back to all changes in this revision

Viewing changes to magnetodb/tests/storage/test_cassandra_impl.py

  • Committer: ikhudoshyn
  • Date: 2014-02-28 14:49:28 UTC
  • mfrom: (110.1.1)
  • Revision ID: git-v1:a44af23b923d02e182c4b9ca1e31bbc304ec059d
Merge pull request #106 from dukhlov/master

conditions support implemented, cassandra storage backend refactoring done

Show diffs side-by-side

added added

removed removed

Lines of Context:
magnetodb/tests/storage/test_cassandra_impl.py
12
12
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13
13
#    License for the specific language governing permissions and limitations
14
14
#    under the License.
 
15
import json
15
16
 
16
17
import unittest
17
18
import uuid
 
19
import binascii
18
20
 
19
21
from magnetodb.common.cassandra import cluster
20
22
from cassandra import decoder
65
67
    ]
66
68
 
67
69
    test_data_dynamic_fields = [
68
 
        ('fnum', 'decimal', '1', 1),
69
 
        ('fstr', 'text', '"fstr"', 'fstr'),
70
 
        ('fblb', 'blob', '"fblob"', 'fblob'),
71
 
        ('fsnum', 'set<decimal>', '[1,2,3]', {1, 2, 3}),
72
 
        ('fsstr', 'set<text>', '["fa","fb","fc"]', {'fa', 'fb', 'fc'}),
73
 
        ('fsblob', 'set<blob>', '["fblob1", "fblob2"]', {'fblob1', 'fblob2'})
 
70
        ('fnum', 'decimal', binascii.hexlify(json.dumps('1')), 1),
 
71
        ('fstr', 'text', binascii.hexlify(json.dumps('fstr')), 'fstr'),
 
72
        ('fblb', 'blob', binascii.hexlify(json.dumps('fblob')), 'fblob'),
 
73
        ('fsnum', 'set<decimal>',
 
74
         binascii.hexlify(json.dumps(['1', '2', '3'])), {1, 2, 3}),
 
75
        ('fsstr', 'set<text>',
 
76
         binascii.hexlify(json.dumps(['fa', 'fb', 'fc'])), {'fa', 'fb', 'fc'}),
 
77
        ('fsblob', 'set<blob>',
 
78
         binascii.hexlify(json.dumps(['fblob1', 'fblob2'])),
 
79
         {'fblob1', 'fblob2'})
74
80
    ]
75
81
 
76
82
    C2S_TYPES = impl.CassandraStorageImpl.CASSANDRA_TO_STORAGE_TYPES
187
193
        query = "SELECT * FROM {}.user_{}".format(keyspace, table_name)
188
194
        return self.SESSION.execute(query)
189
195
 
190
 
    def _insert_data(self, range_value=1, id_value=1):
 
196
    def _insert_data(self, id_value=1, range_value='1',
 
197
                     predefined_fields=None, dynamic_fields=None):
191
198
        query = "UPDATE {}.user_{} SET ".format(self.keyspace, self.table_name)
192
199
 
193
 
        for field in self.test_data_predefined_fields:
194
 
            name, typ, sval, _ = field
 
200
        predefined_fields = (
 
201
            predefined_fields or self.test_data_predefined_fields
 
202
        )
 
203
 
 
204
        dynamic_fields = dynamic_fields or self.test_data_dynamic_fields
 
205
        for field in predefined_fields:
 
206
            name, _, sval, _ = field
195
207
            query += 'user_{}={},'.format(name, sval)
196
208
 
197
 
        for field in self.test_data_dynamic_fields:
 
209
        for field in dynamic_fields:
198
210
            name, typ, sval, _ = field
199
211
            query += "system_attrs['{}'] = 0x{},".format(
200
 
                name, str(sval).encode('hex'))
 
212
                name, sval)
201
213
 
202
214
        for field in (self.test_data_keys +
203
 
                      self.test_data_dynamic_fields +
204
 
                      self.test_data_predefined_fields):
 
215
                      dynamic_fields +
 
216
                      predefined_fields):
205
217
            name, typ, _, _ = field
206
218
            query += "system_attr_types['{}'] ='{}',".format(name, typ)
207
219
            query += ("system_attr_exist = system_attr_exist + {{'{}'}},"
224
236
    def test_create_table(self):
225
237
        self.assertEqual([], self._get_table_names())
226
238
 
227
 
        attrs = {models.AttributeDefinition(name, self.C2S_TYPES[typ])
228
 
                 for name, typ, _, _
229
 
                 in (self.test_data_keys +
230
 
                     self.test_data_predefined_fields)}
 
239
        attrs = {
 
240
            name: self.C2S_TYPES[typ] for name, typ, _, _ in (
 
241
                self.test_data_keys + self.test_data_predefined_fields)
 
242
        }
231
243
 
232
 
        index_defs = {
233
 
            models.IndexDefinition('index_name', 'indexed')
 
244
        index_def_map = {
 
245
            'index_name': models.IndexDefinition('indexed')
234
246
        }
235
247
 
236
248
        schema = models.TableSchema(self.table_name, attrs, ['id', 'range'],
237
 
                                    index_defs)
 
249
                                    index_def_map)
238
250
 
239
251
        self.CASANDRA_STORAGE_IMPL.create_table(self.context, schema)
240
252
 
254
266
        self._create_table()
255
267
        self._create_index(index_name="index_name")
256
268
 
257
 
        attrs = {models.AttributeDefinition(name, self.C2S_TYPES[typ])
258
 
                 for name, typ, _, _
259
 
                 in (self.test_data_keys +
260
 
                     self.test_data_predefined_fields)}
 
269
        attrs = {
 
270
            name: self.C2S_TYPES[typ] for name, typ, _, _ in (
 
271
                self.test_data_keys + self.test_data_predefined_fields)
 
272
        }
261
273
 
262
 
        index_defs = {
263
 
            models.IndexDefinition('index_name', 'indexed')
 
274
        index_def_map = {
 
275
            'index_name': models.IndexDefinition('indexed')
264
276
        }
265
277
 
266
278
        schema = models.TableSchema(self.table_name, attrs, ['id', 'range'],
267
 
                                    index_defs)
 
279
                                    index_def_map)
268
280
 
269
281
        desc = self.CASANDRA_STORAGE_IMPL.describe_table(
270
282
            self.context, self.table_name)
287
299
        self._create_table()
288
300
        self._create_index()
289
301
        self._insert_data()
290
 
        self._insert_data(2)
 
302
        self._insert_data(range_value=2)
291
303
 
292
304
        del_req = models.DeleteItemRequest(
293
305
            self.table_name,
323
335
        self.assertEqual(1, len(all))
324
336
        self.assertEqual(1, all[0]['user_id'])
325
337
 
326
 
    @unittest.skip("conditional updates not yet implemented")
327
338
    def test_delete_item_if_exists(self):
328
339
        self._create_table()
329
340
        self._create_index()
330
 
 
331
 
        query = ("INSERT INTO {}.{} (user_id, user_range,"
332
 
                 " user_str, user_indexed)"
333
 
                 " VALUES (1, '1', '1', '1')").format(self.keyspace,
334
 
                                                      self.table_name)
335
 
 
336
 
        self.SESSION.execute(query)
 
341
        self._insert_data()
337
342
 
338
343
        all = self._select_all()
339
344
 
340
345
        self.assertEqual(1, len(all))
341
 
        self.assertEqual(1, all[0].user_id)
 
346
        self.assertEqual(1, all[0]["user_id"])
342
347
 
343
 
        expected = {'str': models.ExpectedCondition.exists()}
 
348
        expected = {'str': [models.ExpectedCondition.exists()]}
344
349
 
345
350
        del_req = models.DeleteItemRequest(
346
351
            self.table_name,
354
359
 
355
360
        self.assertEqual(0, len(all))
356
361
 
357
 
    @unittest.skip("conditional updates noy yet implemented")
358
362
    def test_delete_item_if_exists_negative(self):
359
363
        self._create_table()
360
364
        self._create_index()
361
365
 
362
 
        query = ("INSERT INTO {}.{} (user_id, user_range,"
363
 
                 " user_str, user_indexed)"
364
 
                 " VALUES (1, '1', null, '1')").format(self.keyspace,
365
 
                                                       self.table_name)
366
 
 
367
 
        self.SESSION.execute(query)
 
366
        self._insert_data()
368
367
 
369
368
        all = self._select_all()
370
369
 
371
370
        self.assertEqual(1, len(all))
372
 
        self.assertEqual(1, all[0].user_id)
 
371
        self.assertEqual(1, all[0]["user_id"])
373
372
 
374
 
        expected = {'str': models.ExpectedCondition.exists()}
 
373
        expected = {
 
374
            'not_existed_attr_name': [models.ExpectedCondition.exists()]
 
375
        }
375
376
 
376
377
        del_req = models.DeleteItemRequest(
377
378
            self.table_name,
378
379
            {'id': models.AttributeValue.number(1),
379
380
             'range': models.AttributeValue.str('1')})
380
381
 
381
 
        self.CASANDRA_STORAGE_IMPL.delete_item(
 
382
        result = self.CASANDRA_STORAGE_IMPL.delete_item(
382
383
            self.context, del_req, expected)
383
384
 
 
385
        self.assertFalse(result)
 
386
 
384
387
        all = self._select_all()
385
388
 
386
389
        self.assertEqual(1, len(all))
387
 
        self.assertEqual(1, all[0].user_id)
 
390
        self.assertEqual(1, all[0]["user_id"])
388
391
 
389
 
    @unittest.skip("conditional updates noy yet implemented")
390
392
    def test_delete_item_if_not_exists(self):
391
393
        self._create_table()
392
394
        self._create_index()
393
395
 
394
 
        query = ("INSERT INTO {}.{} (user_id, user_range,"
395
 
                 " user_str, user_indexed)"
396
 
                 " VALUES (1, '1', null, '1')").format(self.keyspace,
397
 
                                                       self.table_name)
398
 
 
399
 
        self.SESSION.execute(query)
 
396
        self._insert_data()
400
397
 
401
398
        all = self._select_all()
402
399
 
403
400
        self.assertEqual(1, len(all))
404
 
        self.assertEqual(1, all[0].user_id)
 
401
        self.assertEqual(1, all[0]["user_id"])
405
402
 
406
 
        expected = {'str': models.ExpectedCondition.not_exists()}
 
403
        expected = {
 
404
            'not_existed_attr_name': [models.ExpectedCondition.not_exists()]
 
405
        }
407
406
 
408
407
        del_req = models.DeleteItemRequest(
409
408
            self.table_name,
410
409
            {'id': models.AttributeValue.number(1),
411
410
             'range': models.AttributeValue.str('1')})
412
411
 
413
 
        self.CASANDRA_STORAGE_IMPL.delete_item(
 
412
        result = self.CASANDRA_STORAGE_IMPL.delete_item(
414
413
            self.context, del_req, expected)
415
414
 
 
415
        self.assertTrue(result)
 
416
 
416
417
        all = self._select_all()
417
418
 
418
419
        self.assertEqual(0, len(all))
419
420
 
420
 
    @unittest.skip("conditional updates noy yet implemented")
421
421
    def test_delete_item_if_not_exists_negative(self):
422
422
        self._create_table()
423
423
        self._create_index()
424
 
 
425
 
        query = ("INSERT INTO {}.{} (user_id, user_range,"
426
 
                 " user_str, user_indexed)"
427
 
                 " VALUES (1, '1', '1', '1')").format(self.keyspace,
428
 
                                                      self.table_name)
429
 
 
430
 
        self.SESSION.execute(query)
 
424
        self._insert_data()
431
425
 
432
426
        all = self._select_all()
433
427
 
434
428
        self.assertEqual(1, len(all))
435
 
        self.assertEqual(1, all[0].user_id)
 
429
        self.assertEqual(1, all[0]["user_id"])
436
430
 
437
 
        expected = {'str': models.ExpectedCondition.not_exists()}
 
431
        expected = {'str': [models.ExpectedCondition.not_exists()]}
438
432
 
439
433
        del_req = models.DeleteItemRequest(
440
434
            self.table_name,
441
435
            {'id': models.AttributeValue.number(1),
442
436
             'range': models.AttributeValue.str('1')})
443
437
 
444
 
        self.CASANDRA_STORAGE_IMPL.delete_item(
 
438
        result = self.CASANDRA_STORAGE_IMPL.delete_item(
445
439
            self.context, del_req, expected)
446
440
 
 
441
        self.assertFalse(result)
 
442
 
447
443
        all = self._select_all()
448
444
 
449
445
        self.assertEqual(1, len(all))
450
 
        self.assertEqual(1, all[0].user_id)
 
446
        self.assertEqual(1, all[0]["user_id"])
451
447
 
452
448
 
453
449
class TestCassandraSelectItem(TestCassandraBase):
459
455
        self._insert_data()
460
456
 
461
457
        indexed_cond = {
462
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
463
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
458
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
459
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
464
460
        }
465
461
 
466
462
        result = self.CASANDRA_STORAGE_IMPL.select_item(
488
484
        self._insert_data()
489
485
 
490
486
        indexed_cond = {
491
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
492
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
487
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
488
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
493
489
        }
494
490
 
495
491
        result = self.CASANDRA_STORAGE_IMPL.select_item(
510
506
        self._insert_data()
511
507
 
512
508
        indexed_cond = {
513
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
514
 
            'range': models.Condition.eq(models.AttributeValue.str('2'))
 
509
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
510
            'range': [models.Condition.eq(models.AttributeValue.str('2'))]
515
511
        }
516
512
 
517
513
        result = self.CASANDRA_STORAGE_IMPL.select_item(
526
522
        self._insert_data()
527
523
 
528
524
        indexed_cond = {
529
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
530
 
            'range': models.IndexedCondition.lt(models.AttributeValue.str('2'))
 
525
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
526
            'range': [
 
527
                models.IndexedCondition.lt(models.AttributeValue.str('2'))
 
528
            ]
531
529
        }
532
530
 
533
531
        result = self.CASANDRA_STORAGE_IMPL.select_item(
543
541
        self._insert_data()
544
542
 
545
543
        indexed_cond = {
546
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
547
 
            'range': models.IndexedCondition.lt(models.AttributeValue.str('1'))
 
544
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
545
            'range': [
 
546
                models.IndexedCondition.lt(models.AttributeValue.str('1'))
 
547
            ]
548
548
        }
549
549
 
550
550
        result = self.CASANDRA_STORAGE_IMPL.select_item(
559
559
        self._insert_data()
560
560
 
561
561
        indexed_cond = {
562
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
563
 
            'range': models.IndexedCondition.le(models.AttributeValue.str('1'))
 
562
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
563
            'range': [
 
564
                models.IndexedCondition.le(models.AttributeValue.str('1'))
 
565
            ]
564
566
        }
565
567
 
566
568
        result = self.CASANDRA_STORAGE_IMPL.select_item(
576
578
        self._insert_data()
577
579
 
578
580
        indexed_cond = {
579
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
580
 
            'range': models.IndexedCondition.le(models.AttributeValue.str('0'))
 
581
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
582
            'range': [
 
583
                models.IndexedCondition.le(models.AttributeValue.str('0'))
 
584
            ]
581
585
        }
582
586
 
583
587
        result = self.CASANDRA_STORAGE_IMPL.select_item(
592
596
        self._insert_data()
593
597
 
594
598
        indexed_cond = {
595
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
596
 
            'range': models.IndexedCondition.gt(models.AttributeValue.str('0'))
 
599
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
600
            'range': [
 
601
                models.IndexedCondition.gt(models.AttributeValue.str('0'))
 
602
            ]
597
603
        }
598
604
 
599
605
        result = self.CASANDRA_STORAGE_IMPL.select_item(
609
615
        self._insert_data()
610
616
 
611
617
        indexed_cond = {
612
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
613
 
            'range': models.IndexedCondition.gt(models.AttributeValue.str('1'))
 
618
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
619
            'range': [
 
620
                models.IndexedCondition.gt(models.AttributeValue.str('1'))
 
621
            ]
614
622
        }
615
623
 
616
624
        result = self.CASANDRA_STORAGE_IMPL.select_item(
625
633
        self._insert_data()
626
634
 
627
635
        indexed_cond = {
628
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
629
 
            'range': models.IndexedCondition.ge(models.AttributeValue.str('1'))
 
636
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
637
            'range': [
 
638
                models.IndexedCondition.ge(models.AttributeValue.str('1'))
 
639
            ]
630
640
        }
631
641
 
632
642
        result = self.CASANDRA_STORAGE_IMPL.select_item(
642
652
        self._insert_data()
643
653
 
644
654
        indexed_cond = {
645
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
646
 
            'range': models.IndexedCondition.ge(models.AttributeValue.str('2'))
 
655
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
656
            'range': [
 
657
                models.IndexedCondition.ge(models.AttributeValue.str('2'))
 
658
            ]
647
659
        }
648
660
 
649
661
        result = self.CASANDRA_STORAGE_IMPL.select_item(
658
670
        self._insert_data()
659
671
 
660
672
        indexed_cond = {
661
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
662
 
            'range': models.Condition.eq(models.AttributeValue.str('1')),
663
 
            'indexed': models.IndexedCondition.le(
664
 
                models.AttributeValue.str('ind')
665
 
            )
 
673
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
674
            'range': [models.Condition.eq(models.AttributeValue.str('1'))],
 
675
            'indexed': [
 
676
                models.IndexedCondition.le(models.AttributeValue.str('ind'))
 
677
            ]
666
678
        }
667
679
 
668
680
        result = self.CASANDRA_STORAGE_IMPL.select_item(
678
690
        self._insert_data()
679
691
 
680
692
        indexed_cond = {
681
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
682
 
            'range': models.Condition.eq(models.AttributeValue.str('1')),
683
 
            'indexed': models.IndexedCondition.lt(
684
 
                models.AttributeValue.str('ind')
685
 
            )
 
693
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
694
            'range': [models.Condition.eq(models.AttributeValue.str('1'))],
 
695
            'indexed': [
 
696
                models.IndexedCondition.lt(models.AttributeValue.str('ind'))
 
697
            ]
686
698
        }
687
699
 
688
700
        result = self.CASANDRA_STORAGE_IMPL.select_item(
694
706
        self._create_table()
695
707
        self._create_index()
696
708
 
697
 
        self._insert_data(0)
698
 
        self._insert_data(1)
699
 
        self._insert_data(3)
 
709
        self._insert_data(range_value='0')
 
710
        self._insert_data(range_value='1')
 
711
        self._insert_data(range_value='3')
700
712
 
701
713
        indexed_cond = {
702
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
703
 
            'range': models.IndexedCondition.btw(
704
 
                models.AttributeValue.str('1'),
705
 
                models.AttributeValue.str('2'))
 
714
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
715
            'range': [
 
716
                models.IndexedCondition.ge(models.AttributeValue.str('1')),
 
717
                models.IndexedCondition.le(models.AttributeValue.str('2'))
 
718
            ]
706
719
        }
707
720
 
708
721
        result = self.CASANDRA_STORAGE_IMPL.select_item(
715
728
        self._create_table()
716
729
        self._create_index()
717
730
 
718
 
        self._insert_data(-1)
719
 
        self._insert_data(1)
720
 
        self._insert_data(2)
 
731
        self._insert_data(range_value='-1')
 
732
        self._insert_data(range_value='1')
 
733
        self._insert_data(range_value='2')
721
734
 
722
735
        indexed_cond = {
723
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
724
 
            'range': models.IndexedCondition.btw(
725
 
                models.AttributeValue.str('0'),
726
 
                models.AttributeValue.str('1'))
 
736
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
737
            'range': [
 
738
                models.IndexedCondition.ge(models.AttributeValue.str('0')),
 
739
                models.IndexedCondition.le(models.AttributeValue.str('1'))
 
740
            ]
727
741
        }
728
742
 
729
743
        result = self.CASANDRA_STORAGE_IMPL.select_item(
736
750
        self._create_table()
737
751
        self._create_index()
738
752
 
739
 
        self._insert_data(1)
740
 
        self._insert_data(4)
 
753
        self._insert_data(range_value='1')
 
754
        self._insert_data(range_value='4')
741
755
 
742
756
        indexed_cond = {
743
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
744
 
            'range': models.IndexedCondition.btw(
745
 
                models.AttributeValue.str('2'),
746
 
                models.AttributeValue.str('3'))
 
757
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
758
            'range': [
 
759
                models.IndexedCondition.ge(models.AttributeValue.str('2')),
 
760
                models.IndexedCondition.le(models.AttributeValue.str('3'))
 
761
            ]
747
762
        }
748
763
 
749
764
        result = self.CASANDRA_STORAGE_IMPL.select_item(
755
770
        self._create_table()
756
771
        self._create_index()
757
772
 
758
 
        self._insert_data(0)
759
 
        self._insert_data(1)
760
 
        self._insert_data(2)
 
773
        self._insert_data(range_value='0')
 
774
        self._insert_data(range_value='1')
 
775
        self._insert_data(range_value='2')
761
776
 
762
777
        indexed_cond = {
763
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
764
 
            'range': models.IndexedCondition.begins_with(
765
 
                models.AttributeValue.str('1'))
 
778
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
779
            'range': [
 
780
                models.IndexedCondition.ge(models.AttributeValue.str('1')),
 
781
                models.IndexedCondition.lt(models.AttributeValue.str(
 
782
                    '1'[:-1] + chr(ord('1'[-1]) + 1))
 
783
                )
 
784
            ]
766
785
        }
767
786
 
768
787
        result = self.CASANDRA_STORAGE_IMPL.select_item(
775
794
        self._create_table()
776
795
        self._create_index()
777
796
 
778
 
        self._insert_data(0)
779
 
        self._insert_data(11)
780
 
        self._insert_data(2)
 
797
        self._insert_data(range_value='0')
 
798
        self._insert_data(range_value='11')
 
799
        self._insert_data(range_value='2')
781
800
 
782
801
        indexed_cond = {
783
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
784
 
            'range': models.IndexedCondition.begins_with(
785
 
                models.AttributeValue.str('1'))
 
802
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
803
            'range': [
 
804
                models.IndexedCondition.ge(models.AttributeValue.str('1')),
 
805
                models.IndexedCondition.lt(models.AttributeValue.str(
 
806
                    '1'[:-1] + chr(ord('1'[-1]) + 1))
 
807
                )
 
808
            ]
786
809
        }
787
810
 
788
811
        result = self.CASANDRA_STORAGE_IMPL.select_item(
795
818
        self._create_table()
796
819
        self._create_index()
797
820
 
798
 
        self._insert_data(0)
799
 
        self._insert_data(2)
 
821
        self._insert_data(range_value='0')
 
822
        self._insert_data(range_value='2')
800
823
 
801
824
        indexed_cond = {
802
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
803
 
            'range': models.IndexedCondition.begins_with(
804
 
                models.AttributeValue.str('1'))
 
825
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
826
            'range': [
 
827
                models.IndexedCondition.ge(models.AttributeValue.str('1')),
 
828
                models.IndexedCondition.lt(models.AttributeValue.str(
 
829
                    '1'[:-1] + chr(ord('1'[-1]) + 1))
 
830
                )
 
831
            ]
805
832
        }
806
833
 
807
834
        result = self.CASANDRA_STORAGE_IMPL.select_item(
813
840
        self._create_table()
814
841
        self._create_index()
815
842
        self._insert_data()
816
 
        self._insert_data(2)
 
843
        self._insert_data(range_value='2')
817
844
 
818
845
        indexed_cond = {
819
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
820
 
            'range': models.IndexedCondition.ge(
821
 
                models.AttributeValue.str('1')
822
 
            )
 
846
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
847
            'range': [
 
848
                models.IndexedCondition.ge(
 
849
                    models.AttributeValue.str('1')
 
850
                )
 
851
            ]
823
852
        }
824
853
 
825
854
        result = self.CASANDRA_STORAGE_IMPL.select_item(
839
868
        self._insert_data()
840
869
 
841
870
        indexed_cond = {
842
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
843
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
871
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
872
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
844
873
        }
845
874
 
846
875
        result = self.CASANDRA_STORAGE_IMPL.select_item(
915
944
        self._create_table()
916
945
        self._create_index()
917
946
 
918
 
        self._insert_data(1)
919
 
        self._insert_data(2)
920
 
        self._insert_data(3)
921
 
        self._insert_data(4)
922
 
        self._insert_data(5)
 
947
        self._insert_data(range_value='1')
 
948
        self._insert_data(range_value='2')
 
949
        self._insert_data(range_value='3')
 
950
        self._insert_data(range_value='4')
 
951
        self._insert_data(range_value='5')
923
952
 
924
953
        indexed_cond = {
925
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
926
 
            'range': models.IndexedCondition.gt(models.AttributeValue.str('1'))
 
954
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
955
            'range': [
 
956
                models.IndexedCondition.gt(models.AttributeValue.str('1'))
 
957
            ]
927
958
        }
928
959
 
929
960
        result = self.CASANDRA_STORAGE_IMPL.select_item(
977
1008
            models.ATTRIBUTE_TYPE_STRING, 'new')
978
1009
 
979
1010
        keys_condition = {
980
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
981
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1011
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1012
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
982
1013
        }
983
1014
 
984
1015
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1015
1046
            models.ATTRIBUTE_TYPE_NUMBER, 42)
1016
1047
 
1017
1048
        keys_condition = {
1018
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1019
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1049
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1050
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1020
1051
        }
1021
1052
 
1022
1053
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1053
1084
            models.ATTRIBUTE_TYPE_BLOB, 'new')
1054
1085
 
1055
1086
        keys_condition = {
1056
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1057
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1087
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1088
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1058
1089
        }
1059
1090
 
1060
1091
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1092
1123
            models.ATTRIBUTE_TYPE_STRING_SET, {'new'})
1093
1124
 
1094
1125
        keys_condition = {
1095
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1096
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1126
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1127
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1097
1128
        }
1098
1129
 
1099
1130
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1130
1161
            models.ATTRIBUTE_TYPE_NUMBER_SET, {42})
1131
1162
 
1132
1163
        keys_condition = {
1133
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1134
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1164
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1165
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1135
1166
        }
1136
1167
 
1137
1168
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1169
1200
            models.ATTRIBUTE_TYPE_BLOB_SET, {'new'})
1170
1201
 
1171
1202
        keys_condition = {
1172
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1173
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1203
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1204
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1174
1205
        }
1175
1206
 
1176
1207
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1207
1238
            models.ATTRIBUTE_TYPE_STRING, 'new')
1208
1239
 
1209
1240
        keys_condition = {
1210
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1211
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1241
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1242
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1212
1243
        }
1213
1244
 
1214
1245
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1245
1276
            models.ATTRIBUTE_TYPE_NUMBER, 42)
1246
1277
 
1247
1278
        keys_condition = {
1248
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1249
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1279
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1280
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1250
1281
        }
1251
1282
 
1252
1283
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1283
1314
            models.ATTRIBUTE_TYPE_BLOB, 'new')
1284
1315
 
1285
1316
        keys_condition = {
1286
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1287
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1317
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1318
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1288
1319
        }
1289
1320
 
1290
1321
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1322
1353
            models.ATTRIBUTE_TYPE_STRING_SET, {'new1', 'new2'})
1323
1354
 
1324
1355
        keys_condition = {
1325
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1326
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1356
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1357
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1327
1358
        }
1328
1359
 
1329
1360
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1361
1392
            models.ATTRIBUTE_TYPE_NUMBER_SET, {42, 43})
1362
1393
 
1363
1394
        keys_condition = {
1364
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1365
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1395
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1396
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1366
1397
        }
1367
1398
 
1368
1399
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1400
1431
            models.ATTRIBUTE_TYPE_BLOB_SET, {'new1', 'new2'})
1401
1432
 
1402
1433
        keys_condition = {
1403
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1404
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1434
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1435
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1405
1436
        }
1406
1437
 
1407
1438
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1439
1470
        del expected['fstr']
1440
1471
 
1441
1472
        keys_condition = {
1442
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1443
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1473
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1474
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1444
1475
        }
1445
1476
 
1446
1477
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1465
1496
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1466
1497
 
1467
1498
        key_condition = {
1468
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1469
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1499
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1500
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1470
1501
        }
1471
1502
 
1472
1503
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1489
1520
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1490
1521
 
1491
1522
        key_condition = {
1492
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1493
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1523
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1524
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1494
1525
        }
1495
1526
 
1496
1527
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1513
1544
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1514
1545
 
1515
1546
        key_condition = {
1516
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1517
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1547
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1548
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1518
1549
        }
1519
1550
 
1520
1551
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1538
1569
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1539
1570
 
1540
1571
        key_condition = {
1541
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1542
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1572
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1573
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1543
1574
        }
1544
1575
 
1545
1576
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1563
1594
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1564
1595
 
1565
1596
        key_condition = {
1566
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1567
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1597
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1598
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1568
1599
        }
1569
1600
 
1570
1601
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1588
1619
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1589
1620
 
1590
1621
        key_condition = {
1591
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1592
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1622
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1623
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1593
1624
        }
1594
1625
 
1595
1626
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1604
1635
        put = {
1605
1636
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1606
1637
            'range': models.AttributeValue(models.ATTRIBUTE_TYPE_STRING, '1'),
1607
 
            'fstr': models.AttributeValue(models.ATTRIBUTE_TYPE_STRING, 'str'),
 
1638
            'fstr': models.AttributeValue(models.ATTRIBUTE_TYPE_STRING, 'str')
1608
1639
        }
1609
1640
 
1610
1641
        put_request = models.PutItemRequest(self.table_name, put)
1612
1643
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1613
1644
 
1614
1645
        key_condition = {
1615
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1616
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1646
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1647
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1617
1648
        }
1618
1649
 
1619
1650
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1636
1667
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1637
1668
 
1638
1669
        key_condition = {
1639
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1640
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1670
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1671
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1641
1672
        }
1642
1673
 
1643
1674
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1660
1691
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1661
1692
 
1662
1693
        key_condition = {
1663
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1664
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1694
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1695
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1665
1696
        }
1666
1697
 
1667
1698
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1685
1716
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1686
1717
 
1687
1718
        key_condition = {
1688
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1689
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1719
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1720
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1690
1721
        }
1691
1722
 
1692
1723
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1701
1732
        put = {
1702
1733
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1703
1734
            'range': models.AttributeValue(models.ATTRIBUTE_TYPE_STRING, '1'),
1704
 
            'fsnum': models.AttributeValue(
1705
 
                models.ATTRIBUTE_TYPE_NUMBER_SET, {42, 43}),
 
1735
            'fsnum': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER_SET,
 
1736
                                           {42, 43})
1706
1737
        }
1707
1738
 
1708
1739
        put_request = models.PutItemRequest(self.table_name, put)
1710
1741
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1711
1742
 
1712
1743
        key_condition = {
1713
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1714
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1744
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1745
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1715
1746
        }
1716
1747
 
1717
1748
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1735
1766
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request)
1736
1767
 
1737
1768
        key_condition = {
1738
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1739
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1769
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1770
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1740
1771
        }
1741
1772
 
1742
1773
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1744
1775
 
1745
1776
        self.assertEquals([put], result.items)
1746
1777
 
1747
 
    @unittest.skip("conditional updates noy yet implemented")
1748
1778
    def test_put_item_expected_str(self):
1749
1779
        self._create_table()
1750
1780
        self._create_index()
 
1781
        self._insert_data()
1751
1782
 
1752
1783
        put = {
1753
1784
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1757
1788
 
1758
1789
        put_request = models.PutItemRequest(self.table_name, put)
1759
1790
 
1760
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1761
 
                                            expected_condition_map={1: 1})
 
1791
        expected = {
 
1792
            'str': [
 
1793
                models.ExpectedCondition.eq(models.AttributeValue.str('str'))
 
1794
            ]
 
1795
        }
 
1796
 
 
1797
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
1798
            self.context, put_request, expected_condition_map=expected
 
1799
        )
 
1800
        self.assertTrue(result)
1762
1801
 
1763
1802
        key_condition = {
1764
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1765
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1803
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1804
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1766
1805
        }
1767
1806
 
1768
1807
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1770
1809
 
1771
1810
        self.assertEquals([put], result.items)
1772
1811
 
1773
 
    @unittest.skip("conditional updates noy yet implemented")
1774
1812
    def test_put_item_expected_number(self):
1775
1813
        self._create_table()
1776
1814
        self._create_index()
 
1815
        self._insert_data()
1777
1816
 
1778
1817
        put = {
1779
1818
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1783
1822
 
1784
1823
        put_request = models.PutItemRequest(self.table_name, put)
1785
1824
 
1786
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1787
 
                                            expected_condition_map={1: 1})
 
1825
        expected = {
 
1826
            'numbr': [
 
1827
                models.ExpectedCondition.eq(models.AttributeValue.number(1))
 
1828
            ]
 
1829
        }
 
1830
 
 
1831
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
1832
            self.context, put_request, expected_condition_map=expected
 
1833
        )
 
1834
        self.assertTrue(result)
1788
1835
 
1789
1836
        key_condition = {
1790
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1791
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1837
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1838
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1792
1839
        }
1793
1840
 
1794
1841
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1796
1843
 
1797
1844
        self.assertEquals([put], result.items)
1798
1845
 
1799
 
    @unittest.skip("conditional updates noy yet implemented")
1800
1846
    def test_put_item_expected_blob(self):
1801
1847
        self._create_table()
1802
1848
        self._create_index()
 
1849
        self._insert_data()
1803
1850
 
1804
1851
        put = {
1805
1852
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1809
1856
 
1810
1857
        put_request = models.PutItemRequest(self.table_name, put)
1811
1858
 
1812
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1813
 
                                            expected_condition_map={1: 1})
 
1859
        expected = {
 
1860
            'blb': [
 
1861
                models.ExpectedCondition.eq(models.AttributeValue.blob('blob'))
 
1862
            ]
 
1863
        }
 
1864
 
 
1865
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
1866
            self.context, put_request, expected_condition_map=expected
 
1867
        )
 
1868
        self.assertTrue(result)
1814
1869
 
1815
1870
        key_condition = {
1816
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1817
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1871
            'id': [
 
1872
                models.Condition.eq(models.AttributeValue.number(1))
 
1873
            ],
 
1874
            'range': [
 
1875
                models.Condition.eq(models.AttributeValue.str('1'))
 
1876
            ]
1818
1877
        }
1819
1878
 
1820
1879
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1822
1881
 
1823
1882
        self.assertEquals([put], result.items)
1824
1883
 
1825
 
    @unittest.skip("conditional updates noy yet implemented")
1826
1884
    def test_put_item_expected_set_str(self):
1827
1885
        self._create_table()
1828
1886
        self._create_index()
 
1887
        self._insert_data()
1829
1888
 
1830
1889
        put = {
1831
1890
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1836
1895
 
1837
1896
        put_request = models.PutItemRequest(self.table_name, put)
1838
1897
 
1839
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1840
 
                                            expected_condition_map={1: 1})
 
1898
        expected = {
 
1899
            'set_string': [
 
1900
                models.ExpectedCondition.eq(models.AttributeValue.str_set(
 
1901
                    {'a', 'b', 'c'}))
 
1902
            ]
 
1903
        }
 
1904
 
 
1905
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
1906
            self.context, put_request, expected_condition_map=expected
 
1907
        )
 
1908
        self.assertTrue(result)
1841
1909
 
1842
1910
        key_condition = {
1843
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1844
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1911
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1912
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1845
1913
        }
1846
1914
 
1847
1915
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1849
1917
 
1850
1918
        self.assertEquals([put], result.items)
1851
1919
 
1852
 
    @unittest.skip("conditional updates noy yet implemented")
1853
1920
    def test_put_item_expected_set_number(self):
1854
1921
        self._create_table()
1855
1922
        self._create_index()
 
1923
        self._insert_data()
1856
1924
 
1857
1925
        put = {
1858
1926
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1863
1931
 
1864
1932
        put_request = models.PutItemRequest(self.table_name, put)
1865
1933
 
1866
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1867
 
                                            expected_condition_map={1: 1})
 
1934
        expected = {
 
1935
            'set_number': [
 
1936
                models.ExpectedCondition.eq(models.AttributeValue.number_set(
 
1937
                    {1, 2, 3}))
 
1938
            ]
 
1939
        }
 
1940
 
 
1941
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
1942
            self.context, put_request, expected_condition_map=expected
 
1943
        )
 
1944
        self.assertTrue(result)
1868
1945
 
1869
1946
        key_condition = {
1870
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1871
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1947
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
1948
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1872
1949
        }
1873
1950
 
1874
1951
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1876
1953
 
1877
1954
        self.assertEquals([put], result.items)
1878
1955
 
1879
 
    @unittest.skip("conditional updates noy yet implemented")
1880
1956
    def test_put_item_expected_set_blob(self):
1881
1957
        self._create_table()
1882
1958
        self._create_index()
 
1959
        self._insert_data()
1883
1960
 
1884
1961
        put = {
1885
1962
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1890
1967
 
1891
1968
        put_request = models.PutItemRequest(self.table_name, put)
1892
1969
 
1893
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1894
 
                                            expected_condition_map={1: 1})
 
1970
        expected = {
 
1971
            'set_blob': [
 
1972
                models.ExpectedCondition.eq(models.AttributeValue.blob_set(
 
1973
                    {'blob1', 'blob2'}))
 
1974
            ]
 
1975
        }
 
1976
 
 
1977
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
1978
            self.context, put_request, expected_condition_map=expected
 
1979
        )
 
1980
        self.assertTrue(result)
1895
1981
 
1896
1982
        key_condition = {
1897
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1898
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
1983
            'id': [
 
1984
                models.Condition.eq(models.AttributeValue.number(1))
 
1985
            ],
 
1986
            'range': [
 
1987
                models.Condition.eq(models.AttributeValue.str('1'))
 
1988
            ]
1899
1989
        }
1900
1990
 
1901
1991
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1903
1993
 
1904
1994
        self.assertEquals([put], result.items)
1905
1995
 
1906
 
    @unittest.skip("conditional updates noy yet implemented")
1907
1996
    def test_put_item_expected_dynamic_str(self):
1908
1997
        self._create_table()
1909
1998
        self._create_index()
 
1999
        self._insert_data()
1910
2000
 
1911
2001
        put = {
1912
2002
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1916
2006
 
1917
2007
        put_request = models.PutItemRequest(self.table_name, put)
1918
2008
 
1919
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1920
 
                                            expected_condition_map={1: 1})
 
2009
        expected = {
 
2010
            'fstr': [
 
2011
                models.ExpectedCondition.eq(models.AttributeValue.str('fstr'))
 
2012
            ]
 
2013
        }
 
2014
 
 
2015
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
2016
            self.context, put_request, expected_condition_map=expected
 
2017
        )
 
2018
        self.assertTrue(result)
1921
2019
 
1922
2020
        key_condition = {
1923
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1924
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
2021
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
2022
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1925
2023
        }
1926
2024
 
1927
2025
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1929
2027
 
1930
2028
        self.assertEquals([put], result.items)
1931
2029
 
1932
 
    @unittest.skip("conditional updates noy yet implemented")
1933
2030
    def test_put_item_expected_dynamic_number(self):
1934
2031
        self._create_table()
1935
2032
        self._create_index()
 
2033
        self._insert_data()
1936
2034
 
1937
2035
        put = {
1938
2036
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1942
2040
 
1943
2041
        put_request = models.PutItemRequest(self.table_name, put)
1944
2042
 
1945
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1946
 
                                            expected_condition_map={1: 1})
 
2043
        expected = {
 
2044
            'fnum': [
 
2045
                models.ExpectedCondition.eq(models.AttributeValue.number(1))
 
2046
            ]
 
2047
        }
 
2048
 
 
2049
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
2050
            self.context, put_request, expected_condition_map=expected
 
2051
        )
 
2052
        self.assertTrue(result)
1947
2053
 
1948
2054
        key_condition = {
1949
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1950
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
2055
            'id': [
 
2056
                models.Condition.eq(models.AttributeValue.number(1))
 
2057
            ],
 
2058
            'range': [
 
2059
                models.Condition.eq(models.AttributeValue.str('1'))
 
2060
            ]
1951
2061
        }
1952
2062
 
1953
2063
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1955
2065
 
1956
2066
        self.assertEquals([put], result.items)
1957
2067
 
1958
 
    @unittest.skip("conditional updates noy yet implemented")
1959
2068
    def test_put_item_expected_dynamic_blob(self):
1960
2069
        self._create_table()
1961
2070
        self._create_index()
 
2071
        self._insert_data()
1962
2072
 
1963
2073
        put = {
1964
2074
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1968
2078
 
1969
2079
        put_request = models.PutItemRequest(self.table_name, put)
1970
2080
 
1971
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1972
 
                                            expected_condition_map={1: 1})
 
2081
        expected = {
 
2082
            'fblb': [
 
2083
                models.ExpectedCondition.eq(
 
2084
                    models.AttributeValue.blob('fblob'))
 
2085
            ]
 
2086
        }
 
2087
 
 
2088
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
2089
            self.context, put_request, expected_condition_map=expected
 
2090
        )
 
2091
        self.assertTrue(result)
1973
2092
 
1974
2093
        key_condition = {
1975
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
1976
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
2094
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
2095
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
1977
2096
        }
1978
2097
 
1979
2098
        result = self.CASANDRA_STORAGE_IMPL.select_item(
1981
2100
 
1982
2101
        self.assertEquals([put], result.items)
1983
2102
 
1984
 
    @unittest.skip("conditional updates noy yet implemented")
1985
2103
    def test_put_item_expected_dynamic_set_str(self):
1986
2104
        self._create_table()
1987
2105
        self._create_index()
 
2106
        self._insert_data()
1988
2107
 
1989
2108
        put = {
1990
2109
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
1995
2114
 
1996
2115
        put_request = models.PutItemRequest(self.table_name, put)
1997
2116
 
1998
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
1999
 
                                            expected_condition_map={1: 1})
 
2117
        expected = {
 
2118
            'fsstr': [
 
2119
                models.ExpectedCondition.eq(
 
2120
                    models.AttributeValue.str_set({'fa', 'fb', 'fc'}))
 
2121
            ]
 
2122
        }
 
2123
 
 
2124
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
2125
            self.context, put_request, expected_condition_map=expected
 
2126
        )
 
2127
        self.assertTrue(result)
2000
2128
 
2001
2129
        key_condition = {
2002
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
2003
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
2130
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
2131
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
2004
2132
        }
2005
2133
 
2006
2134
        result = self.CASANDRA_STORAGE_IMPL.select_item(
2008
2136
 
2009
2137
        self.assertEquals([put], result.items)
2010
2138
 
2011
 
    @unittest.skip("conditional updates noy yet implemented")
2012
2139
    def test_put_item_expected_dynamic_set_number(self):
2013
2140
        self._create_table()
2014
2141
        self._create_index()
 
2142
        self._insert_data()
2015
2143
 
2016
2144
        put = {
2017
2145
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
2022
2150
 
2023
2151
        put_request = models.PutItemRequest(self.table_name, put)
2024
2152
 
2025
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
2026
 
                                            expected_condition_map={1: 1})
 
2153
        expected = {
 
2154
            'fsnum': [
 
2155
                models.ExpectedCondition.eq(
 
2156
                    models.AttributeValue.number_set({1, 2, 3}))
 
2157
            ]
 
2158
        }
 
2159
 
 
2160
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
2161
            self.context, put_request, expected_condition_map=expected
 
2162
        )
 
2163
        self.assertTrue(result)
2027
2164
 
2028
2165
        key_condition = {
2029
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
2030
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
2166
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
2167
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
2031
2168
        }
2032
2169
 
2033
2170
        result = self.CASANDRA_STORAGE_IMPL.select_item(
2035
2172
 
2036
2173
        self.assertEquals([put], result.items)
2037
2174
 
2038
 
    @unittest.skip("conditional updates noy yet implemented")
2039
2175
    def test_put_item_expected_dynamic_set_blob(self):
2040
2176
        self._create_table()
2041
2177
        self._create_index()
 
2178
        self._insert_data()
2042
2179
 
2043
2180
        put = {
2044
2181
            'id': models.AttributeValue(models.ATTRIBUTE_TYPE_NUMBER, 1),
2049
2186
 
2050
2187
        put_request = models.PutItemRequest(self.table_name, put)
2051
2188
 
2052
 
        self.CASANDRA_STORAGE_IMPL.put_item(self.context, put_request,
2053
 
                                            expected_condition_map={1: 1})
 
2189
        expected = {
 
2190
            'fsblob': [
 
2191
                models.ExpectedCondition.eq(
 
2192
                    models.AttributeValue.blob_set({'fblob1', 'fblob2'}))
 
2193
            ]
 
2194
        }
 
2195
 
 
2196
        result = self.CASANDRA_STORAGE_IMPL.put_item(
 
2197
            self.context, put_request, expected_condition_map=expected
 
2198
        )
 
2199
        self.assertTrue(result)
2054
2200
 
2055
2201
        key_condition = {
2056
 
            'id': models.Condition.eq(models.AttributeValue.number(1)),
2057
 
            'range': models.Condition.eq(models.AttributeValue.str('1'))
 
2202
            'id': [models.Condition.eq(models.AttributeValue.number(1))],
 
2203
            'range': [models.Condition.eq(models.AttributeValue.str('1'))]
2058
2204
        }
2059
2205
 
2060
2206
        result = self.CASANDRA_STORAGE_IMPL.select_item(
2080
2226
        self._create_table()
2081
2227
        self._create_index()
2082
2228
        self._insert_data()
2083
 
        self._insert_data(2)
 
2229
        self._insert_data(range_value='2')
2084
2230
 
2085
2231
        condition = {
2086
 
            'range': models.ScanCondition.neq(models.AttributeValue.str('2'))
 
2232
            'range': [models.ScanCondition.neq(models.AttributeValue.str('2'))]
2087
2233
        }
2088
2234
 
2089
2235
        result = self.CASANDRA_STORAGE_IMPL.scan(
2096
2242
        self._create_table()
2097
2243
        self._create_index()
2098
2244
        self._insert_data()
2099
 
        self._insert_data(121)
 
2245
        self._insert_data(range_value='121')
2100
2246
 
2101
2247
        condition = {
2102
 
            'range': models.ScanCondition.contains(
2103
 
                models.AttributeValue.str('2'))
 
2248
            'range': [models.ScanCondition.contains(
 
2249
                models.AttributeValue.str('2'))]
2104
2250
        }
2105
2251
 
2106
2252
        result = self.CASANDRA_STORAGE_IMPL.scan(
2113
2259
        self._create_table()
2114
2260
        self._create_index()
2115
2261
        self._insert_data()
2116
 
        self._insert_data(22)
 
2262
        self._insert_data(range_value='22')
2117
2263
 
2118
2264
        condition = {
2119
 
            'range': models.ScanCondition.not_contains(
2120
 
                models.AttributeValue.str('2'))
 
2265
            'range': [models.ScanCondition.not_contains(
 
2266
                models.AttributeValue.str('2'))]
2121
2267
        }
2122
2268
 
2123
2269
        result = self.CASANDRA_STORAGE_IMPL.scan(
2132
2278
        self._insert_data()
2133
2279
 
2134
2280
        condition = {
2135
 
            'set_number': models.ScanCondition.contains(
2136
 
                models.AttributeValue.number(2))
 
2281
            'set_number': [models.ScanCondition.contains(
 
2282
                models.AttributeValue.number(2))]
2137
2283
        }
2138
2284
 
2139
2285
        result = self.CASANDRA_STORAGE_IMPL.scan(
2148
2294
        self._insert_data()
2149
2295
 
2150
2296
        condition = {
2151
 
            'set_number': models.ScanCondition.contains(
2152
 
                models.AttributeValue.number(4))
 
2297
            'set_number': [models.ScanCondition.contains(
 
2298
                models.AttributeValue.number(4))]
2153
2299
        }
2154
2300
 
2155
2301
        result = self.CASANDRA_STORAGE_IMPL.scan(
2163
2309
        self._insert_data()
2164
2310
 
2165
2311
        condition = {
2166
 
            'set_number': models.ScanCondition.not_contains(
2167
 
                models.AttributeValue.number(4))
 
2312
            'set_number': [models.ScanCondition.not_contains(
 
2313
                models.AttributeValue.number(4))]
2168
2314
        }
2169
2315
 
2170
2316
        result = self.CASANDRA_STORAGE_IMPL.scan(
2179
2325
        self._insert_data()
2180
2326
 
2181
2327
        condition = {
2182
 
            'set_number': models.ScanCondition.not_contains(
2183
 
                models.AttributeValue.number(2))
 
2328
            'set_number': [models.ScanCondition.not_contains(
 
2329
                models.AttributeValue.number(2))]
2184
2330
        }
2185
2331
 
2186
2332
        result = self.CASANDRA_STORAGE_IMPL.scan(
2194
2340
        self._insert_data()
2195
2341
 
2196
2342
        condition = {
2197
 
            'range': models.ScanCondition.in_set({
 
2343
            'range': [models.ScanCondition.in_set({
2198
2344
                models.AttributeValue.str('1'),
2199
2345
                models.AttributeValue.str('2')
2200
 
            })
 
2346
            })]
2201
2347
        }
2202
2348
 
2203
2349
        result = self.CASANDRA_STORAGE_IMPL.scan(
2212
2358
        self._insert_data()
2213
2359
 
2214
2360
        condition = {
2215
 
            'range': models.ScanCondition.in_set({
 
2361
            'range': [models.ScanCondition.in_set({
2216
2362
                models.AttributeValue.str('2'),
2217
2363
                models.AttributeValue.str('3')
2218
 
            })
 
2364
            })]
2219
2365
        }
2220
2366
 
2221
2367
        result = self.CASANDRA_STORAGE_IMPL.scan(
2227
2373
        self._create_table()
2228
2374
        self._create_index()
2229
2375
        self._insert_data()
2230
 
        self._insert_data(2)
2231
 
        self._insert_data(3)
2232
 
        self._insert_data(1, 2)
2233
 
        self._insert_data(2, 2)
 
2376
        self._insert_data(range_value='2')
 
2377
        self._insert_data(range_value='3')
 
2378
        self._insert_data(id_value=2, range_value='1',)
 
2379
        self._insert_data(id_value=2, range_value='2')
2234
2380
 
2235
2381
        last_evaluated_key = {
2236
2382
            'id': models.AttributeValue.number(1),