def test_undefined_incr(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.increment(key, "a", 1)
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {'a': 1}, {'gen': 1, 'ttl': 0}),
                      asm.get(key))
 def test_exists(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals((True, {'gen': 1, 'ttl': 0}), asm.exists(key))
     # test if not changing gen
     self.assertEquals((True, {'gen': 1, 'ttl': 0}), asm.exists(key))
 def test_put(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {'a': 1}, {'gen': 1, 'ttl': 0}),
                      asm.get(key))
 def test_get(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual((('a', 'b', 'c'), {'gen': 1, 'ttl': 0}, {'a': 1}),
                      asm.get(key))
     # test if not changing gen
     self.assertEqual((('a', 'b', 'c'), {'gen': 1, 'ttl': 0}, {'a': 1}),
                      asm.get(key))
 def test_exists(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals((True, {'gen': 1, 'ttl': self.get_time(default_ttl)}),
                       asm.exists(key))
     # test if not changing gen
     self.assertEquals((True, {'gen': 1, 'ttl': self.get_time(default_ttl)}),
                       asm.exists(key))
 def test_select(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1, "b": 2, "c": 3})
     self.assertEqual(
         (('a', 'b', 'c'), {'gen': 1, 'ttl': 0}, {'a': 1, 'c': 3}),
         asm.select(key, ["a", "c"]))
     # test if not changing gen
     self.assertEqual(
         (('a', 'b', 'c'), {'gen': 1, 'ttl': 0}, {'a': 1, 'd': None}),
         asm.select(key, ["a", "d"]))
Example #7
0
 def test_remove(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     asm.remove(key)
     self.assertEquals({}, asm.dump())
     self.assertEquals((False, None), asm.exists(key))
 def test_remove(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     asm.remove(key)
     self.assertEquals({}, asm.dump())
     self.assertEquals((False, None), asm.exists(key))
 def test_get(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 1},
             {'gen': 1, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
     # test whether not changing gen
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 1},
             {'gen': 1, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
 def test_incr(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     asm.increment(key, "a", 2)
     self.assertEqual({('a', 'b', 'c'): {'a': 3}}, asm.dump())
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 3},
             {'gen': 2, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
     asm.increment(key, "a", 1, meta={"ttl": 1})
     self.assertEqual(
         (('a', 'b', 'c'), {'a': 4}, {'gen': 3, 'ttl': self.get_time(1)}),
         asm.get(key))
 def test_exists_many(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual([(('a', 'b', 1), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }), (('a', 'b', 2), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }), (('a', 'b', 3), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }), (('a', 'b', 4), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }), (('a', 'b', 5), None)], asm.exists_many(keys))
Example #12
0
 def test_exists_many(self):
     asm = AerospikeClientMock()
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual([
         (("a", "b", 1), {
             'gen': 1,
             'ttl': 0
         }),
         (("a", "b", 2), {
             'gen': 1,
             'ttl': 0
         }),
         (("a", "b", 3), {
             'gen': 1,
             'ttl': 0
         }),
         (("a", "b", 4), {
             'gen': 1,
             'ttl': 0
         }),
         (("a", "b", 5), None),
     ], asm.exists_many(keys))
 def test_incr_value(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     asm.increment(key, "a", 2)
     self.assertEqual({('a', 'b', 'c'): {'a': 3}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {'gen': 2, 'ttl': 0}, {'a': 3}),
                      asm.get(key))
 def test_select_many(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     asm.put(("a", "b", 1), {"a": 1, "b": 1})
     asm.put(("a", "b", 2), {"a": 2, "b": 2})
     asm.put(("a", "b", 3), {"a": 3, "b": 3})
     asm.put(("a", "b", 4), {"a": 4, "b": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual(
         {
             ('a', 'b', 3): {'a': 3, 'b': 3},
             ('a', 'b', 2): {'a': 2, 'b': 2},
             ('a', 'b', 4): {'a': 4, 'b': 4},
             ('a', 'b', 1): {'a': 1, 'b': 1},
         },
         asm.dump())
     self.assertEqual(
         {
             1: (('a', 'b', 1), {'a': 1, 'b': 1},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             2: (('a', 'b', 2), {'a': 2, 'b': 2},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             3: (('a', 'b', 3), {'a': 3, 'b': 3},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             4: (('a', 'b', 4), {'a': 4, 'b': 4},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             5: None
         }, asm.select_many(keys, ["a", "b"]))
     self.assertEqual(
         {
             1: (
                 ('a', 'b', 1), {'b': 1},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             2: (
                 ('a', 'b', 2), {'b': 2},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             3: (
                 ('a', 'b', 3), {'b': 3},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             4: (
                 ('a', 'b', 4), {'b': 4},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             5: None}, asm.select_many(keys, ["b"]))
Example #15
0
 def test_append(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"word": "ello"})
     asm.prepend(key, "word", "h")
     self.assertEqual({('a', 'b', 'c'): {'word': 'hello'}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': 0
     }, {
         'word': 'hello'
     }), asm.get(key))
Example #16
0
 def test_incr_value(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     asm.increment(key, "a", 2)
     self.assertEqual({('a', 'b', 'c'): {'a': 3}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': 0
     }, {
         'a': 3
     }), asm.get(key))
 def test_prepend(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"word": "hell"})
     asm.append(key, "word", "o")
     self.assertEqual({('a', 'b', 'c'): {'word': 'hello'}}, asm.dump())
     self.assertEqual(
         (('a', 'b', 'c'), {'gen': 2, 'ttl': 0}, {'word': 'hello'}),
         asm.get(key))
 def test_prepend(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"word": "hell"})
     asm.append(key, "word", "o")
     self.assertEqual({('a', 'b', 'c'): {'word': 'hello'}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': self.get_time(default_ttl)
     }, {
         'word': 'hello'
     }), asm.get(key))
Example #19
0
 def test_undefined_incr(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.increment(key, "a", 1)
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': 0
     }, {
         'a': 1
     }), asm.get(key))
     asm.increment(key, "b", 1)
     self.assertEqual({('a', 'b', 'c'): {'a': 1, 'b': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': 0
     }, {
         'a': 1,
         'b': 1
     }), asm.get(key))
Example #20
0
 def test_put(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': 0
     }, {
         'a': 1
     }), asm.get(key))
     asm.put(key, {"b": 1})
     self.assertEqual({('a', 'b', 'c'): {'a': 1, 'b': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': 0
     }, {
         'a': 1,
         'b': 1
     }), asm.get(key))
 def test_touch(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals(
         (
             ('a', 'b', 'c'), {'a': 1},
             {'gen': 1, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
     time.sleep(1)
     asm.touch(key)
     self.assertEquals(
         (
             ('a', 'b', 'c'), {'a': 1},
             {'gen': 2, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
     asm.touch(key, 4)
     self.assertEquals(
         (('a', 'b', 'c'), {'a': 1}, {'gen': 3, 'ttl': self.get_time(4)}),
         asm.get(key))
Example #22
0
 def test_exists(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals((True, {'gen': 1, 'ttl': 0}), asm.exists(key))
     # test if not changing gen
     self.assertEquals((True, {'gen': 1, 'ttl': 0}), asm.exists(key))
 def test_get_many(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual(
         {
             1: (
                 ('a', 'b', 1), {'a': 1},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             2: (
                 ('a', 'b', 2), {'a': 2},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             3: (
                 ('a', 'b', 3), {'a': 3},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             4: (
                 ('a', 'b', 4), {'a': 4},
                 {'gen': 1, 'ttl': self.get_time(default_ttl)}
             ),
             5: None
         }, asm.get_many(keys))
 def test_append(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"word": "ello"})
     asm.prepend(key, "word", "h")
     self.assertEqual({('a', 'b', 'c'): {'word': 'hello'}}, asm.dump())
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'word': 'hello'},
             {'gen': 2, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
Example #25
0
 def test_get_many(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual([
         (('a', 'b', 1,
           bytearray(b'u\x98t\x11La\x84\x9d\x94\xe3\xcdcSbn\xd7')), {
               'gen': 1,
               'ttl': self.get_time(default_ttl)
           }, {
               'a': 1
           }),
         (('a', 'b', 2,
           bytearray(
               b'\xe7HY\x1f\x1f\xb8z\x8f\xf3\x0c\xf3\x04\xcc9\x14\xdc')), {
                   'gen': 1,
                   'ttl': self.get_time(default_ttl)
               }, {
                   'a': 2
               }),
         (('a', 'b', 3,
           bytearray(b'\xeb\x1a\x99(V\xd49\x01\xeeQ[\x92\x06-O\x08')), {
               'gen': 1,
               'ttl': self.get_time(default_ttl)
           }, {
               'a': 3
           }),
         (('a', 'b', 4,
           bytearray(
               b'\xf3G\x1b\xba\xe2\xec\x11S\xc3\xc2\xab\x15\xb4\x1b\x96q')),
          {
              'gen': 1,
              'ttl': self.get_time(default_ttl)
          }, {
              'a': 4
          }),
         (('a', 'b', 5,
           bytearray(b'd\t}\xc6`\xee\xe2\xf0)\x1f7\x9c\xfa\x8d\xa6\xd6')),
          None, None),
     ], asm.get_many(keys))
 def test_undefined_incr(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.increment(key, "a", 1)
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
class TestAerospikeScanMock(unittest.TestCase):
    def setUp(self):
        self.asm = AerospikeClientMock()
        self.asm.put(("a", "b", 1), {"a": 1, "b": 1})
        self.asm.put(("a", "b", 2), {"a": 2, "b": 2})
        self.asm.put(("a", "b", 3), {"a": 3, "b": 3})
        self.asm.put(("a", "c", 4), {"a": 4, "b": 4})

    def test_scan(self):
        scan = self.asm.scan('a', 'b')
        scan.select('a', 'c')
        self.assertEqual(
            [
                (('a', 'b', 1), {'a': 1, 'c': None}, {'gen': 1, 'ttl': 0}),
                (('a', 'b', 2), {'a': 2, 'c': None}, {'gen': 1, 'ttl': 0}),
                (('a', 'b', 3), {'a': 3, 'c': None}, {'gen': 1, 'ttl': 0})
            ], scan.results())

    def test_scan_namespace(self):
        scan = self.asm.scan('a')
        scan.select('a', 'b')
        self.assertEqual(
            [
                (('a', 'b', 1), {'a': 1, 'b': 1}, {'gen': 1, 'ttl': 0}),
                (('a', 'b', 2), {'a': 2, 'b': 2}, {'gen': 1, 'ttl': 0}),
                (('a', 'b', 3), {'a': 3, 'b': 3}, {'gen': 1, 'ttl': 0}),
                (('a', 'c', 4), {'a': 4, 'b': 4}, {'gen': 1, 'ttl': 0}),
            ], scan.results())

    def test_scan_callback(self):
        result = []

        def callback(data):
            (key, meta, bins) = data
            result.append((key, meta, bins))

        scan = self.asm.scan('a', 'b')
        scan.select('a', 'c')
        scan.foreach(callback)
        self.assertEqual(
            [
                ((('a', 'b', 1), {'a': 1, 'c': None}, {'gen': 1, 'ttl': 0}),
                 (('a', 'b', 2), {'a': 2, 'c': None}, {'gen': 1, 'ttl': 0}),
                 (('a', 'b', 3), {'a': 3, 'c': None}, {'gen': 1, 'ttl': 0}))
            ],
            result)
 def test_exists(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals((True, {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }), asm.exists(key))
     # test if not changing gen
     self.assertEquals((True, {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }), asm.exists(key))
 def test_select_many(self):
     asm = AerospikeClientMock()
     asm.put(("a", "b", 1), {"a": 1, "b": 1})
     asm.put(("a", "b", 2), {"a": 2, "b": 2})
     asm.put(("a", "b", 3), {"a": 3, "b": 3})
     asm.put(("a", "b", 4), {"a": 4, "b": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual(
         {
             ('a', 'b', 3): {'a': 3, 'b': 3},
             ('a', 'b', 2): {'a': 2, 'b': 2},
             ('a', 'b', 4): {'a': 4, 'b': 4},
             ('a', 'b', 1): {'a': 1, 'b': 1}
         },
         asm.dump())
     self.assertEqual(
         [
             (('a', 'b', 1), {'gen': 1, 'ttl': 0}, {'a': 1, 'b': 1}),
             (('a', 'b', 2), {'gen': 1, 'ttl': 0}, {'a': 2, 'b': 2}),
             (('a', 'b', 3), {'gen': 1, 'ttl': 0}, {'a': 3, 'b': 3}),
             (('a', 'b', 4), {'gen': 1, 'ttl': 0}, {'a': 4, 'b': 4}),
             None,
         ]
         , asm.select_many(keys, ["a", "b"]))
     self.assertEqual(
         [
             (('a', 'b', 1), {'gen': 1, 'ttl': 0}, {'b': 1}),
             (('a', 'b', 2), {'gen': 1, 'ttl': 0}, {'b': 2}),
             (('a', 'b', 3), {'gen': 1, 'ttl': 0}, {'b': 3}),
             (('a', 'b', 4), {'gen': 1, 'ttl': 0}, {'b': 4}),
             None,
         ]
         , asm.select_many(keys, ["b"]))
Example #30
0
 def test_get(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': 0
     }, {
         'a': 1
     }), asm.get(key))
     # test if not changing gen
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': 0
     }, {
         'a': 1
     }), asm.get(key))
Example #31
0
 def test_get_many(self):
     asm = AerospikeClientMock()
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual([
         (('a', 'b', 1), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 1
         }),
         (('a', 'b', 2), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 2
         }),
         (('a', 'b', 3), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 3
         }),
         (('a', 'b', 4), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 4
         }),
         (('a', 'b', 5), None, None),
     ], asm.get_many(keys))
 def test_get(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
     # test whether not changing gen
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
 def test_exists_many(self):
     asm = AerospikeClientMock()
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual(
         {
             1: {'gen': 1, 'ttl': 0}, 2: {'gen': 1, 'ttl': 0},
             3: {'gen': 1, 'ttl': 0}, 4: {'gen': 1, 'ttl': 0},
             5: None
         }, asm.exists_many(keys))
Example #34
0
 def test_select(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1, "b": 2, "c": 3})
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': 0
     }, {
         'a': 1,
         'c': 3
     }), asm.select(key, ["a", "c"]))
     # test if not changing gen
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': 0
     }, {
         'a': 1,
         'd': None
     }), asm.select(key, ["a", "d"]))
 def test_get_many(self):
     asm = AerospikeClientMock()
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual(
         [
             (('a', 'b', 1), {'gen': 1, 'ttl': 0}, {'a': 1}),
             (('a', 'b', 2), {'gen': 1, 'ttl': 0}, {'a': 2}),
             (('a', 'b', 3), {'gen': 1, 'ttl': 0}, {'a': 3}),
             (('a', 'b', 4), {'gen': 1, 'ttl': 0}, {'a': 4}),
             (('a', 'b', 5), None, None),
         ]
         , asm.get_many(keys))
 def test_exists_many(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     asm.put(("a", "b", 1), {"a": 1})
     asm.put(("a", "b", 2), {"a": 2})
     asm.put(("a", "b", 3), {"a": 3})
     asm.put(("a", "b", 4), {"a": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual(
         [
             (('a', 'b', 1), {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             (('a', 'b', 2), {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             (('a', 'b', 3), {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             (('a', 'b', 4), {'gen': 1, 'ttl': self.get_time(default_ttl)}),
             (('a', 'b', 5), None)
         ]
         , asm.exists_many(keys))
Example #37
0
 def test_blank_init(self):
     asm = AerospikeClientMock()
     self.assertEqual({}, asm.dump())
 def test_remove_bin(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1, "b": 1, "c": 1, "d": 1})
     self.assertEquals({('a', 'b', 'c'): {'a': 1, 'c': 1, 'b': 1, 'd': 1}},
                       asm.dump())
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 1, 'c': 1, 'b': 1, 'd': 1},
             {'gen': 1, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
     asm.remove_bin(key, ["b", "d"], meta={"ttl": 4})
     self.assertEquals({('a', 'b', 'c'): {'a': 1, 'c': 1}}, asm.dump())
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 1, 'c': 1},
             {'gen': 2, 'ttl': self.get_time(4)}
         ), asm.get(key))
     asm.remove_bin(key, ["c"])
     self.assertEquals({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 1},
             {'gen': 3, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
Example #39
0
 def test_select_many(self):
     asm = AerospikeClientMock()
     asm.put(("a", "b", 1), {"a": 1, "b": 1})
     asm.put(("a", "b", 2), {"a": 2, "b": 2})
     asm.put(("a", "b", 3), {"a": 3, "b": 3})
     asm.put(("a", "b", 4), {"a": 4, "b": 4})
     keys = [
         ("a", "b", 1),
         ("a", "b", 2),
         ("a", "b", 3),
         ("a", "b", 4),
         ("a", "b", 5),
     ]
     self.assertEqual(
         {
             ('a', 'b', 3): {
                 'a': 3,
                 'b': 3
             },
             ('a', 'b', 2): {
                 'a': 2,
                 'b': 2
             },
             ('a', 'b', 4): {
                 'a': 4,
                 'b': 4
             },
             ('a', 'b', 1): {
                 'a': 1,
                 'b': 1
             }
         }, asm.dump())
     self.assertEqual([
         (('a', 'b', 1), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 1,
             'b': 1
         }),
         (('a', 'b', 2), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 2,
             'b': 2
         }),
         (('a', 'b', 3), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 3,
             'b': 3
         }),
         (('a', 'b', 4), {
             'gen': 1,
             'ttl': 0
         }, {
             'a': 4,
             'b': 4
         }),
         None,
     ], asm.select_many(keys, ["a", "b"]))
     self.assertEqual([
         (('a', 'b', 1), {
             'gen': 1,
             'ttl': 0
         }, {
             'b': 1
         }),
         (('a', 'b', 2), {
             'gen': 1,
             'ttl': 0
         }, {
             'b': 2
         }),
         (('a', 'b', 3), {
             'gen': 1,
             'ttl': 0
         }, {
             'b': 3
         }),
         (('a', 'b', 4), {
             'gen': 1,
             'ttl': 0
         }, {
             'b': 4
         }),
         None,
     ], asm.select_many(keys, ["b"]))
 def test_not_exists(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     self.assertEquals((False, None), asm.exists(key))
 def test_incr(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     asm.increment(key, "a", 2)
     self.assertEqual({('a', 'b', 'c'): {'a': 3}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 3
     }), asm.get(key))
     asm.increment(key, "a", 1, meta={"ttl": 1})
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 3,
         'ttl': self.get_time(1)
     }, {
         'a': 4
     }), asm.get(key))
 def test_dump(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
 def test_put(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
     time.sleep(1)
     asm.put(key, {"a": 1})
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
     asm.put(key, {"a": 1}, meta={"ttl": 1})
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 3,
         'ttl': self.get_time(1)
     }, {
         'a': 1
     }), asm.get(key))
 def test_remove_bin(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1, "b": 1, "c": 1, "d": 1})
     self.assertEquals({('a', 'b', 'c'): {
                            'a': 1,
                            'c': 1,
                            'b': 1,
                            'd': 1
                        }}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1,
         'c': 1,
         'b': 1,
         'd': 1
     }), asm.get(key))
     asm.remove_bin(key, ["b", "d"], meta={"ttl": 4})
     self.assertEquals({('a', 'b', 'c'): {'a': 1, 'c': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': self.get_time(4)
     }, {
         'a': 1,
         'c': 1
     }), asm.get(key))
     asm.remove_bin(key, ["c"])
     self.assertEquals({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 3,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
 def test_touch(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEquals((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
     time.sleep(1)
     asm.touch(key)
     self.assertEquals((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': self.get_time(default_ttl)
     }, {
         'a': 1
     }), asm.get(key))
     asm.touch(key, 4)
     self.assertEquals((('a', 'b', 'c'), {
         'gen': 3,
         'ttl': self.get_time(4)
     }, {
         'a': 1
     }), asm.get(key))
 def test_expire_exist(self):
     asm = AerospikeClientMock(default_ttl=1)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     time.sleep(2)
     self.assertEquals((False, None), asm.exists(key))
 def test_connected(self):
     asm = AerospikeClientMock()
     self.assertTrue(asm.is_connected())
 def test_remove_bin(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1, "b": 1, "c": 1, "d": 1})
     self.assertEquals({('a', 'b', 'c'): {'a': 1, 'c': 1, 'b': 1, 'd': 1}},
                       asm.dump())
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'gen': 1, 'ttl': 0},
             {'a': 1, 'c': 1, 'b': 1, 'd': 1}
         ), asm.get(key))
     asm.remove_bin(key, ["b", "d"])
     self.assertEquals({('a', 'b', 'c'): {'a': 1, 'c': 1}}, asm.dump())
     self.assertEqual(
         (('a', 'b', 'c'), {'gen': 2, 'ttl': 0}, {'a': 1, 'c': 1}),
         asm.get(key))
     asm.remove_bin(key, ["c"])
     self.assertEquals({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {'gen': 3, 'ttl': 0}, {'a': 1}),
                      asm.get(key))
Example #49
0
 def test_not_exists(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     self.assertEquals((False, None), asm.exists(key))
 def setUp(self):
     self.asm = AerospikeClientMock()
     self.asm.put(("a", "b", 1), {"a": 1, "b": 1})
     self.asm.put(("a", "b", 2), {"a": 2, "b": 2})
     self.asm.put(("a", "b", 3), {"a": 3, "b": 3})
     self.asm.put(("a", "c", 4), {"a": 4, "b": 4})
Example #51
0
 def test_remove_bin(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1, "b": 1, "c": 1, "d": 1})
     self.assertEquals({('a', 'b', 'c'): {
                            'a': 1,
                            'c': 1,
                            'b': 1,
                            'd': 1
                        }}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 1,
         'ttl': 0
     }, {
         'a': 1,
         'c': 1,
         'b': 1,
         'd': 1
     }), asm.get(key))
     asm.remove_bin(key, ["b", "d"])
     self.assertEquals({('a', 'b', 'c'): {'a': 1, 'c': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 2,
         'ttl': 0
     }, {
         'a': 1,
         'c': 1
     }), asm.get(key))
     asm.remove_bin(key, ["c"])
     self.assertEquals({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual((('a', 'b', 'c'), {
         'gen': 3,
         'ttl': 0
     }, {
         'a': 1
     }), asm.get(key))
Example #52
0
class TestAerospikeScanMock(unittest.TestCase):
    def setUp(self):
        self.asm = AerospikeClientMock()
        self.asm.put(("a", "b", 1), {"a": 1, "b": 1})
        self.asm.put(("a", "b", 2), {"a": 2, "b": 2})
        self.asm.put(("a", "b", 3), {"a": 3, "b": 3})
        self.asm.put(("a", "c", 4), {"a": 4, "b": 4})

    def test_scan(self):
        scan = self.asm.scan('a', 'b')
        scan.select('a', 'c')
        self.assertEqual([(('a', 'b', 1), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 1,
            'c': None
        }), (('a', 'b', 2), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 2,
            'c': None
        }), (('a', 'b', 3), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 3,
            'c': None
        })], scan.results())

    def test_scan_namespace(self):
        scan = self.asm.scan('a')
        scan.select('a', 'b')
        self.assertEqual([
            (('a', 'b', 1), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 1,
                'b': 1
            }),
            (('a', 'b', 2), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 2,
                'b': 2
            }),
            (('a', 'b', 3), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 3,
                'b': 3
            }),
            (('a', 'c', 4), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 4,
                'b': 4
            }),
        ], scan.results())

    def test_scan_callback(self):
        result = []

        def callback(data):
            (key, meta, bins) = data
            result.append((key, meta, bins))

        scan = self.asm.scan('a', 'b')
        scan.select('a', 'c')
        scan.foreach(callback)
        self.assertEqual([((('a', 'b', 1), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 1,
            'c': None
        }), (('a', 'b', 2), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 2,
            'c': None
        }), (('a', 'b', 3), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 3,
            'c': None
        }))], result)
 def test_put(self):
     default_ttl = 2
     asm = AerospikeClientMock(default_ttl=2)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 1},
             {'gen': 1, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
     time.sleep(1)
     asm.put(key, {"a": 1})
     self.assertEqual(
         (
             ('a', 'b', 'c'), {'a': 1},
             {'gen': 1, 'ttl': self.get_time(default_ttl)}
         ), asm.get(key))
     asm.put(key, {"a": 1}, meta={"ttl": 1})
     self.assertEqual(
         (('a', 'b', 'c'), {'a': 1}, {'gen': 1, 'ttl': self.get_time(1)}),
         asm.get(key))
class TestAerospikeQueryMock(unittest.TestCase):
    def setUp(self):
        self.asm = AerospikeClientMock()
        self.asm.put(("a", "b", 1), {"a": 1, "b": 1})
        self.asm.put(("a", "b", 2), {"a": 2, "b": 2})
        self.asm.put(("a", "b", 3), {"a": 3, "b": 3})
        self.asm.put(("a", "c", 4), {"a": 4, "b": 4})

    def test_query(self):
        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        self.assertEqual([
            (('a', 'b', 1), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 1,
                'c': None
            }),
            (('a', 'b', 2), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 2,
                'c': None
            }),
            (('a', 'b', 3), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 3,
                'c': None
            }),
        ], query.results())

    def test_query_namespace(self):
        query = self.asm.query('a')
        query.select('a', 'b')
        self.assertEqual([
            (('a', 'b', 1), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 1,
                'b': 1
            }),
            (('a', 'b', 2), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 2,
                'b': 2
            }),
            (('a', 'b', 3), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 3,
                'b': 3
            }),
            (('a', 'c', 4), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 4,
                'b': 4
            }),
        ], query.results())

    def test_query_callback(self):
        result = []

        def callback(data):
            (key, meta, bins) = data
            result.append((key, meta, bins))

        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        query.foreach(callback)
        self.assertEqual([(
            (('a', 'b', 1), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 1,
                'c': None
            }),
            (('a', 'b', 2), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 2,
                'c': None
            }),
            (('a', 'b', 3), {
                'gen': 1,
                'ttl': 0
            }, {
                'a': 3,
                'c': None
            }),
        )], result)

    def test_query_equals(self):
        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        query.where(AerospikePredicatesMock().equals("a", 1))
        self.assertEqual([(('a', 'b', 1), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 1,
            'c': None
        })], query.results())

    def test_query_between(self):
        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        query.where(AerospikePredicatesMock().between("a", 1, 4))
        self.assertEqual([(('a', 'b', 2), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 2,
            'c': None
        }), (('a', 'b', 3), {
            'gen': 1,
            'ttl': 0
        }, {
            'a': 3,
            'c': None
        })], query.results())

    def test_query_contains(self):
        self.asm.put(("a", "l", 1), {"list": [1, 2, 3, 4, 5]})
        self.asm.put(("a", "l", 2), {"list": [1, 3, 4, 5]})
        query = self.asm.query('a', 'l')
        query.select('list')
        query.where(AerospikePredicatesMock().contains("list", list, 2))
        self.assertEqual([(('a', 'l', 1), {
            'gen': 1,
            'ttl': 0
        }, {
            'list': [1, 2, 3, 4, 5]
        })], query.results())

    def test_query_range(self):
        self.asm.put(("a", "l", 1), {"list": [1, 2, 3, 4, 5]})
        self.asm.put(("a", "l", 2), {"list": [4, 5]})
        query = self.asm.query('a', 'l')
        query.select('list')
        query.where(AerospikePredicatesMock().range("list", list, 1, 3))
        self.assertEqual([(('a', 'l', 1), {
            'gen': 1,
            'ttl': 0
        }, {
            'list': [1, 2, 3, 4, 5]
        })], query.results())
Example #55
0
 def test_dump(self):
     asm = AerospikeClientMock()
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     self.assertEqual({('a', 'b', 'c'): {'a': 1}}, asm.dump())
 def setUp(self):
     self.asm = AerospikeClientMock()
     self.asm.put(("a", "b", 1), {"a": 1, "b": 1})
     self.asm.put(("a", "b", 2), {"a": 2, "b": 2})
     self.asm.put(("a", "b", 3), {"a": 3, "b": 3})
     self.asm.put(("a", "c", 4), {"a": 4, "b": 4})
 def test_expire_exist(self):
     asm = AerospikeClientMock(default_ttl=1)
     key = ("a", "b", "c")
     asm.put(key, {"a": 1})
     time.sleep(2)
     self.assertEquals((False, None), asm.exists(key))
Example #58
0
 def test_connected(self):
     asm = AerospikeClientMock()
     self.assertTrue(asm.is_connected())
class TestAerospikeQueryMock(unittest.TestCase):
    def setUp(self):
        self.asm = AerospikeClientMock()
        self.asm.put(("a", "b", 1), {"a": 1, "b": 1})
        self.asm.put(("a", "b", 2), {"a": 2, "b": 2})
        self.asm.put(("a", "b", 3), {"a": 3, "b": 3})
        self.asm.put(("a", "c", 4), {"a": 4, "b": 4})

    def test_query(self):
        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        self.assertEqual(
            [
                (('a', 'b', 1), {'gen': 1, 'ttl': 0}, {'a': 1, 'c': None}),
                (('a', 'b', 2), {'gen': 1, 'ttl': 0}, {'a': 2, 'c': None}),
                (('a', 'b', 3), {'gen': 1, 'ttl': 0}, {'a': 3, 'c': None}),
            ],
            query.results())

    def test_query_namespace(self):
        query = self.asm.query('a')
        query.select('a', 'b')
        self.assertEqual(
            [
                (('a', 'b', 1), {'gen': 1, 'ttl': 0}, {'a': 1, 'b': 1}),
                (('a', 'b', 2), {'gen': 1, 'ttl': 0}, {'a': 2, 'b': 2}),
                (('a', 'b', 3), {'gen': 1, 'ttl': 0}, {'a': 3, 'b': 3}),
                (('a', 'c', 4), {'gen': 1, 'ttl': 0}, {'a': 4, 'b': 4}),
            ],
            query.results())

    def test_query_callback(self):
        result = []

        def callback(data):
            (key, meta, bins) = data
            result.append((key, meta, bins))

        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        query.foreach(callback)
        self.assertEqual(
            [
                (
                    (('a', 'b', 1), {'gen': 1, 'ttl': 0}, {'a': 1, 'c': None}),
                    (('a', 'b', 2), {'gen': 1, 'ttl': 0}, {'a': 2, 'c': None}),
                    (('a', 'b', 3), {'gen': 1, 'ttl': 0}, {'a': 3, 'c': None}),
                )
            ],
            result)

    def test_query_equals(self):
        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        query.where(AerospikePredicatesMock().equals("a", 1))
        self.assertEqual(
            [(('a', 'b', 1), {'gen': 1, 'ttl': 0}, {'a': 1, 'c': None})],
            query.results())

    def test_query_between(self):
        query = self.asm.query('a', 'b')
        query.select('a', 'c')
        query.where(AerospikePredicatesMock().between("a", 1, 4))
        self.assertEqual(
            [(('a', 'b', 2), {'gen': 1, 'ttl': 0}, {'a': 2, 'c': None}),
             (('a', 'b', 3), {'gen': 1, 'ttl': 0}, {'a': 3, 'c': None})],
            query.results())

    def test_query_contains(self):
        self.asm.put(("a", "l", 1), {"list": [1, 2, 3, 4, 5]})
        self.asm.put(("a", "l", 2), {"list": [1, 3, 4, 5]})
        query = self.asm.query('a', 'l')
        query.select('list')
        query.where(AerospikePredicatesMock().contains("list", list, 2))
        self.assertEqual(
            [(('a', 'l', 1), {'gen': 1, 'ttl': 0}, {'list': [1, 2, 3, 4, 5]})],
            query.results())

    def test_query_range(self):
        self.asm.put(("a", "l", 1), {"list": [1, 2, 3, 4, 5]})
        self.asm.put(("a", "l", 2), {"list": [4, 5]})
        query = self.asm.query('a', 'l')
        query.select('list')
        query.where(AerospikePredicatesMock().range("list", list, 1, 3))
        self.assertEqual(
            [(('a', 'l', 1), {'gen': 1, 'ttl': 0}, {'list': [1, 2, 3, 4, 5]})],
            query.results())
 def test_blank_init(self):
     asm = AerospikeClientMock()
     self.assertEqual({}, asm.dump())