Пример #1
0
    def test_register_script_client(self):
        # lpush two values in LIST1 in first instance of redis
        self.redis.lpush(LIST1, VAL2, VAL1)

        # create script on first instance of redis
        script_content = LPOP_SCRIPT
        script = self.redis.register_script(script_content)

        # lpush two values in LIST1 in redis2 (second instance of redis)
        redis2 = MockRedis()
        redis2.lpush(LIST1, VAL4, VAL3)

        # execute LPOP script on redis2 instance
        list_item = script(keys=[LIST1], client=redis2)

        # validate lpop from LIST1 in redis2
        self.assertEquals(VAL3, list_item)
        self.assertEquals([VAL4], redis2.lrange(LIST1, 0, -1))
        self.assertEquals([VAL1, VAL2], self.redis.lrange(LIST1, 0, -1))
Пример #2
0
    def test_register_script_client(self):
        # lpush two values in LIST1 in first instance of redis
        self.redis.lpush(LIST1, VAL2, VAL1)

        # create script on first instance of redis
        script_content = LPOP_SCRIPT
        script = self.redis.register_script(script_content)

        # lpush two values in LIST1 in redis2 (second instance of redis)
        redis2 = MockRedis()
        redis2.lpush(LIST1, VAL4, VAL3)

        # execute LPOP script on redis2 instance
        list_item = script(keys=[LIST1], client=redis2)

        # validate lpop from LIST1 in redis2
        self.assertEquals(VAL3, list_item)
        self.assertEquals([VAL4], redis2.lrange(LIST1, 0, -1))
        self.assertEquals([VAL1, VAL2], self.redis.lrange(LIST1, 0, -1))
Пример #3
0
 def setUp(self):
     self.redis = MockRedis()
Пример #4
0
class TestRedisList(TestCase):
    """list tests"""
    def setUp(self):
        self.redis = MockRedis()

    def test_initially_empty(self):
        """
        List is created empty.
        """
        self.assertEqual(0, len(self.redis.redis[LIST1]))

    def test_llen(self):
        self.assertEquals(0, self.redis.llen(LIST1))
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(2, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(1, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(0, self.redis.llen(LIST1))

    def test_lpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL1, self.redis.lpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL2, self.redis.lpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_lpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.lpush(LIST1, VAL1)
        self.redis.lpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL2, VAL1], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.lpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL3, VAL1, VAL2, VAL1], self.redis.redis[LIST1])

    def test_rpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL2, self.redis.rpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL1, self.redis.rpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_rpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.rpush(LIST1, VAL1)
        self.redis.rpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.rpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2, VAL1, VAL3], self.redis.redis[LIST1])

    def test_lrem(self):
        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, 0, VAL1)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, 1, VAL2)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, 100, VAL1)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, -1, VAL3)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, -1, VAL2)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL3, VAL4],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, -2, VAL2)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4], self.redis.redis[LIST1])

    def test_rpoplpush(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.redis.redis[LIST2] = [VAL3, VAL4]
        transfer_item = self.redis.rpoplpush(LIST1, LIST2)
        self.assertEqual(VAL2, transfer_item)
        self.assertEqual([VAL1], self.redis.redis[LIST1])
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.redis[LIST2])
Пример #5
0
class TestList(TestCase):
    """
    Tests for MockRedis list operations
    """

    def setUp(self):
        self.redis = MockRedis()
        self.redis.flushdb()

    def test_initially_empty(self):
        """
        List is created empty.
        """
        self.assertEqual(0, len(self.redis.redis['test_list']))

    def test_llen(self):
        self.assertEquals(0, self.redis.llen('test_list'))
        self.redis.redis['test_list'] = ['val1', 'val2']
        self.assertEquals(2, self.redis.llen('test_list'))
        self.redis.redis['test_list'].pop(0)
        self.assertEquals(1, self.redis.llen('test_list'))
        self.redis.redis['test_list'].pop(0)
        self.assertEquals(0, self.redis.llen('test_list'))

    def test_lpop(self):
        self.redis.redis['test_list'] = ['val1', 'val2']
        self.assertEquals('val1', self.redis.lpop('test_list'))
        self.assertEquals(1, len(self.redis.redis['test_list']))
        self.assertEquals('val2', self.redis.lpop('test_list'))
        self.assertEquals(0, len(self.redis.redis['test_list']))
        self.assertIsNone(self.redis.lpop('test_list'))

    def test_lpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.lpush('test_list', 'val1')
        self.redis.lpush('test_list', 'val2')

        # validate insertion
        self.assertEquals(2, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val2', self.redis.redis['test_list'][0])
        self.assertEquals('val1', self.redis.redis['test_list'][1])

        # insert two more values with one repeated
        self.redis.lpush('test_list', 'val1', 'val3')

        # validate the update
        self.assertEquals(4, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val3', self.redis.redis['test_list'][0])
        self.assertEquals('val1', self.redis.redis['test_list'][1])
        self.assertEquals('val2', self.redis.redis['test_list'][2])
        self.assertEquals('val1', self.redis.redis['test_list'][3])

    def test_rpop(self):
        self.redis.redis['test_list'] = ['val1', 'val2']
        self.assertEquals('val2', self.redis.rpop('test_list'))
        self.assertEquals(1, len(self.redis.redis['test_list']))
        self.assertEquals('val1', self.redis.rpop('test_list'))
        self.assertEquals(0, len(self.redis.redis['test_list']))
        self.assertIsNone(self.redis.lpop('test_list'))

    def test_rpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.rpush('test_list', 'val1')
        self.redis.rpush('test_list', 'val2')

        # validate insertion
        self.assertEquals(2, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val1', self.redis.redis['test_list'][0])
        self.assertEquals('val2', self.redis.redis['test_list'][1])

        # insert two more values with one repeated
        self.redis.rpush('test_list', 'val1', 'val3')

        # validate the update
        self.assertEquals(4, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val1', self.redis.redis['test_list'][0])
        self.assertEquals('val2', self.redis.redis['test_list'][1])
        self.assertEquals('val1', self.redis.redis['test_list'][2])
        self.assertEquals('val3', self.redis.redis['test_list'][3])
Пример #6
0
class TestRedisString(object):
    """string tests"""
    def setUp(self):
        self.redis = MockRedis()
        self.redis.flushdb()

    def test_get(self):
        eq_(None, self.redis.get('key'))

        self.redis.redis['key'] = 'value'
        eq_('value', self.redis.get('key'))

    def test_set_no_options(self):
        self.redis.set('key', 'value')
        eq_('value', self.redis.redis['key'])

    def _assert_set_with_options(self, test_cases):
        """
        Assert conditions for setting a key on the set function.

        The set function can take px, ex, nx and xx kwargs, this function asserts various conditions
        on set depending on the combinations of kwargs: creation mode(nx,xx) and expiration(ex,px).
        E.g. verifying that a non-existent key does not get set if xx=True or gets set with nx=True
        iff it is absent.
        """

        category, existing_key, cases = test_cases
        msg = "Failed in: {}".format(category)
        if existing_key:
            self.redis.set('key', 'value')
        for (key, value, expected_result), config in cases:
            # set with creation mode and expiry options
            result = self.redis.set(key, value, **config)
            eq_(expected_result, result, msg)
            if expected_result is not None:
                # if the set was expected to happen
                self._assert_was_set(key, value, config, msg)
            else:
                # if the set was not expected to happen
                self._assert_not_set(key, value, msg)

    def _assert_not_set(self, key, value, msg):
        """Check that the key and its timeout were not set"""

        # check that the value wasn't updated
        ok_(value != self.redis.get(key), msg)
        # check that the expiration was not set
        ok_(self.redis.ttl(key) is None, msg)

    def _assert_was_set(self, key, value, config, msg):
        """Assert that the key was set along with timeout if applicable"""

        eq_(value, self.redis.get(key))
        if 'px' in config:
            # px should have been preferred over ex if it was specified
            ok_(int(config['px'] / 1000) == self.redis.ttl(key), msg)
        elif 'ex' in config:
            ok_(config['ex'] == self.redis.ttl(key), msg)

    def test_set_with_options(self):
        """Test the set function with various combinations of arguments"""

        test_cases = [(
            "1. px and ex are set, nx is always true & set on non-existing key",
            False, [(('key1', 'value1', None),
                     dict(ex=20, px=70000, xx=True, nx=True)),
                    (('key2', 'value1', True),
                     dict(ex=20, px=70000, xx=False, nx=True)),
                    (('key3', 'value2', True), dict(ex=20, px=70000,
                                                    nx=True))]),
                      ("2. px and ex are set, nx is always true & set on existing key",
                       True, [(('key', 'value1', None),
                               dict(ex=20, px=70000, xx=True, nx=True)),
                              (('key', 'value1', None),
                               dict(ex=20, px=7000, xx=False, nx=True)),
                              (('key', 'value1', None),
                               dict(ex=20, px=70000, nx=True))]),
                      ("3. px and ex are set, xx is always true & set on existing key",
                       True, [(('key', 'value1', None),
                               dict(ex=20, px=70000, xx=True, nx=True)),
                              (('key', 'value1', True),
                               dict(ex=20, px=70000, xx=True, nx=False)),
                              (('key', 'value4', True),
                               dict(ex=20, px=70000, xx=True))]),
                      ("4. px and ex are set, xx is always true & set on non-existing key",
                       False, [(('key1', 'value1', None),
                                dict(ex=20, px=70000, xx=True, nx=True)),
                               (('key2', 'value2', None),
                                dict(ex=20, px=70000, xx=True, nx=False)),
                               (('key3', 'value3', None),
                                dict(ex=20, px=70000, xx=True))]),
                      ("5. either nx or xx defined and set to false or none defined"
                       + " & set on existing key", True, [
                           (('key', 'value1', True),
                            dict(ex=20, px=70000, xx=False)),
                           (('key', 'value2', True),
                            dict(ex=20, px=70000, nx=False)),
                           (('key', 'value3', True), dict(ex=20, px=70000))
                       ]),
                      ("6. either nx or xx defined and set to false or none defined"
                       + " & set on non-existing key", False, [
                           (('key1', 'value1', True),
                            dict(ex=20, px=70000, xx=False)),
                           (('key2', 'value2', True),
                            dict(ex=20, px=70000, nx=False)),
                           (('key3', 'value3', True), dict(ex=20, px=70000))
                       ]),
                      ("7: where neither px nor ex defined + set on existing key",
                       True, [(('key', 'value2', None), dict(xx=True,
                                                             nx=True)),
                              (('key', 'value2', None), dict(xx=False,
                                                             nx=True)),
                              (('key', 'value2', True), dict(xx=True,
                                                             nx=False)),
                              (('key', 'value3', True), dict(xx=True)),
                              (('key', 'value4', None), dict(nx=True)),
                              (('key', 'value4', True), dict(xx=False)),
                              (('key', 'value5', True), dict(nx=False))]),
                      ("8: where neither px nor ex defined + set on non-existing key",
                       False, [
                           (('key1', 'value1', None), dict(xx=True, nx=True)),
                           (('key2', 'value1', True), dict(xx=False, nx=True)),
                           (('key3', 'value2', None), dict(xx=True, nx=False)),
                           (('key4', 'value3', None), dict(xx=True)),
                           (('key5', 'value4', True), dict(nx=True)),
                           (('key6', 'value4', True), dict(xx=False)),
                           (('key7', 'value5', True), dict(nx=False))
                       ]),
                      ("9: where neither nx nor xx defined + set on existing key",
                       True, [(('key', 'value1', True), dict(ex=20, px=70000)),
                              (('key1', 'value12', True), dict(ex=20)),
                              (('key1', 'value11', True), dict(px=20000))]),
                      ("10: where neither nx nor xx is defined + set on non-existing key",
                       False, [(('key1', 'value1', True), dict(ex=20,
                                                               px=70000)),
                               (('key2', 'value2', True), dict(ex=20)),
                               (('key3', 'value3', True), dict(px=20000))])]

        for cases in test_cases:
            yield self._assert_set_with_options, cases

    def _assert_set_with_timeout(self, seconds):
        """Assert that setex sets a key with a value along with a timeout"""

        eq_(None, self.redis.redis.get('key'))

        ok_(self.redis.setex('key', seconds, 'value'))
        eq_('value', self.redis.redis.get('key'))

        ok_(self.redis.ttl('key'), "expiration was not set correctly")
        if isinstance(seconds, timedelta):
            seconds = seconds.seconds + seconds.days * 24 * 3600
        ok_(0 < self.redis.ttl('key') <= seconds)

    def test_setex(self):
        test_cases = [20, timedelta(seconds=20)]
        for case in test_cases:
            yield self._assert_set_with_timeout, case

    def test_setnx(self):
        """Check whether setnx sets a key iff it does not already exist"""

        ok_(self.redis.setnx('key', 'value'))
        ok_(not self.redis.setnx('key', 'different_value'))
        eq_('value', self.redis.get('key'))

    def test_delete(self):
        """Test if delete works"""

        test_cases = [('1', '1'), (('1', '2'), ('1', '2')),
                      (('1', '2', '3'), ('1', '3')), (('1', '2'), '1'),
                      ('1', '2')]
        for case in test_cases:
            yield self._assert_delete, case

    def _assert_delete(self, data):
        """Asserts that key(s) deletion along with removing timeouts if any, succeeds as expected"""
        to_create, to_delete = data
        for key in to_create:
            self.redis.set(key, "value", ex=200)

        eq_(self.redis.delete(*to_delete),
            len(set(to_create) & set(to_delete)))

        # verify if the keys that were to be deleted, were deleted along with the timeouts.
        for key in set(to_create) & set(to_delete):
            ok_(key not in self.redis.redis and key not in self.redis.timeouts)

        # verify if the keys not to be deleted, were not deleted and their timeouts not removed.
        for key in set(to_create) - (set(to_create) & set(to_delete)):
            ok_(key in self.redis.redis and key in self.redis.timeouts)
Пример #7
0
 def setUp(self):
     self.redis = MockRedis()
     self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()
Пример #8
0
class TestRedisList(TestCase):
    """list tests"""

    def setUp(self):
        self.redis = MockRedis()

    def test_initially_empty(self):
        """
        List is created empty.
        """
        self.assertEqual(0, len(self.redis.redis[LIST1]))

    def test_llen(self):
        self.assertEquals(0, self.redis.llen(LIST1))
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(2, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(1, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(0, self.redis.llen(LIST1))

    def test_lpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL1, self.redis.lpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL2, self.redis.lpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_lpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.lpush(LIST1, VAL1)
        self.redis.lpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL2, VAL1], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.lpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL3, VAL1, VAL2, VAL1], self.redis.redis[LIST1])

    def test_rpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL2, self.redis.rpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL1, self.redis.rpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_rpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.rpush(LIST1, VAL1)
        self.redis.rpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.rpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2, VAL1, VAL3], self.redis.redis[LIST1])

    def test_lrem(self):
        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL1, 0)
        self.assertEqual(2, count)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL2, 1)
        self.assertEqual(1, count)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL1, 100)
        self.assertEqual(2, count)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL3, -1)
        self.assertEqual(1, count)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL2, -1)
        self.assertEqual(1, count)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL3, VAL4],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL2, -2)
        self.assertEqual(2, count)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4], self.redis.redis[LIST1])

        count = self.redis.lrem("NON_EXISTENT_LIST", VAL1, 0)
        self.assertEqual(0, count)

    def test_rpoplpush(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.redis.redis[LIST2] = [VAL3, VAL4]
        transfer_item = self.redis.rpoplpush(LIST1, LIST2)
        self.assertEqual(VAL2, transfer_item)
        self.assertEqual([VAL1], self.redis.redis[LIST1])
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.redis[LIST2])

    def test_lrange_get_all(self):
        """Cases for returning entire list"""
        values = [VAL4, VAL3, VAL2, VAL1]

        self.assertEqual([], self.redis.lrange(LIST1, 0, 6))
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))
        self.redis.lpush(LIST1, *reversed(values))

        # Check with exact range
        self.assertEqual(values, self.redis.lrange(LIST1, 0, 3))
        # Check with negative index
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))
        # Check with range larger than length of list
        self.assertEqual(values, self.redis.lrange(LIST1, 0, 6))

    def test_lrange_get_sublist(self):
        """Cases for returning partial list"""
        values = [VAL4, VAL3, VAL2, VAL1]

        self.assertEqual([], self.redis.lrange(LIST1, 0, 6))
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))
        self.redis.lpush(LIST1, *reversed(values))

        # Check from left end of the list
        self.assertEqual(values[:2], self.redis.lrange(LIST1, 0, 1))
        # Check from right end of the list
        self.assertEqual(values[2:4], self.redis.lrange(LIST1, 2, 3))
        # Check from right end of the list with negative range
        self.assertEqual(values[-2:], self.redis.lrange(LIST1, -2, -1))
        # Check from middle of the list
        self.assertEqual(values[1:3], self.redis.lrange(LIST1, 1, 2))

    def test_ltrim_retain_all(self):
        values = [VAL4, VAL3, VAL2, VAL1]
        self._reinitialize_list(LIST1, *values)

        self.redis.ltrim(LIST1, 0, -1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, 0, len(values) - 1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, 0, len(values) + 1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, -1 * len(values), -1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, -1 * (len(values) + 1), -1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

    def test_ltrim_remove_all(self):
        values = [VAL4, VAL3, VAL2, VAL1]
        self._reinitialize_list(LIST1, *values)

        self.redis.ltrim(LIST1, 2, 1)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -1, -2)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, 2, -3)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -1, 2)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

    def test_ltrim(self):
        values = [VAL4, VAL3, VAL2, VAL1]
        self._reinitialize_list(LIST1, *values)

        self.redis.ltrim(LIST1, 1, 2)
        self.assertEqual(values[1:3], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -3, -1)
        self.assertEqual(values[-3:], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, 1, 5)
        self.assertEqual(values[1:5], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -100, 2)
        self.assertEqual(values[-100:3], self.redis.lrange(LIST1, 0, -1))

    def test_lset(self):
        with self.assertRaises(Exception):
            self.redis.lset(LIST1, 1, VAL1)

        self.redis.lpush(LIST1, VAL2)
        self.assertEqual([VAL2], self.redis.lrange(LIST1, 0, -1))

        with self.assertRaises(Exception):
            self.redis.lset(LIST1, 1, VAL1)

        self.redis.lset(LIST1, 0, VAL1)
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))

    def _reinitialize_list(self, key, *values):
        """
        Re-initialize the list
        """
        self.redis.delete(LIST1)
        self.redis.lpush(LIST1, *reversed(values))
Пример #9
0
class TestRedisList(TestCase):
    """list tests"""

    def setUp(self):
        self.redis = MockRedis()

    def test_initially_empty(self):
        """
        List is created empty.
        """
        self.assertEqual(0, len(self.redis.redis[LIST1]))

    def test_llen(self):
        self.assertEquals(0, self.redis.llen(LIST1))
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(2, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(1, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(0, self.redis.llen(LIST1))

    def test_lpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL1, self.redis.lpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL2, self.redis.lpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_lpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.lpush(LIST1, VAL1)
        self.redis.lpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL2, VAL1], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.lpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL3, VAL1, VAL2, VAL1], self.redis.redis[LIST1])

    def test_rpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL2, self.redis.rpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL1, self.redis.rpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_rpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.rpush(LIST1, VAL1)
        self.redis.rpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.rpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2, VAL1, VAL3], self.redis.redis[LIST1])

    def test_lrem(self):
        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, 0, VAL1)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, 1, VAL2)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, 100, VAL1)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, -1, VAL3)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, -1, VAL2)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL3, VAL4],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        self.redis.lrem(LIST1, -2, VAL2)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4], self.redis.redis[LIST1])

    def test_rpoplpush(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.redis.redis[LIST2] = [VAL3, VAL4]
        transfer_item = self.redis.rpoplpush(LIST1, LIST2)
        self.assertEqual(VAL2, transfer_item)
        self.assertEqual([VAL1], self.redis.redis[LIST1])
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.redis[LIST2])
Пример #10
0
 def setUp(self):
     self.redis = MockRedis()
     self.redis.flushdb()
Пример #11
0
class TestRedisString(object):
    """string tests"""

    def setUp(self):
        self.redis = MockRedis()
        self.redis.flushdb()

    def test_get(self):
        eq_(None, self.redis.get('key'))

        self.redis.redis['key'] = 'value'
        eq_('value', self.redis.get('key'))

    def test_set_no_options(self):
        self.redis.set('key', 'value')
        eq_('value', self.redis.redis['key'])

    def _assert_set_with_options(self, test_cases):
        """
        Assert conditions for setting a key on the set function.

        The set function can take px, ex, nx and xx kwargs, this function asserts various conditions
        on set depending on the combinations of kwargs: creation mode(nx,xx) and expiration(ex,px).
        E.g. verifying that a non-existent key does not get set if xx=True or gets set with nx=True
        iff it is absent.
        """

        category, existing_key, cases = test_cases
        msg = "Failed in: {}".format(category)
        if existing_key:
            self.redis.set('key', 'value')
        for (key, value, expected_result), config in cases:
            # set with creation mode and expiry options
            result = self.redis.set(key, value, **config)
            eq_(expected_result, result, msg)
            if expected_result is not None:
                # if the set was expected to happen
                self._assert_was_set(key, value, config, msg)
            else:
                # if the set was not expected to happen
                self._assert_not_set(key, value, msg)

    def _assert_not_set(self, key, value, msg):
        """Check that the key and its timeout were not set"""

        # check that the value wasn't updated
        ok_(value != self.redis.get(key), msg)
        # check that the expiration was not set
        ok_(self.redis.ttl(key) is None, msg)

    def _assert_was_set(self, key, value, config, msg):
        """Assert that the key was set along with timeout if applicable"""

        eq_(value, self.redis.get(key))
        if 'px' in config:
            # px should have been preferred over ex if it was specified
            ok_(int(config['px'] / 1000) == self.redis.ttl(key), msg)
        elif 'ex' in config:
            ok_(config['ex'] == self.redis.ttl(key), msg)

    def test_set_with_options(self):
        """Test the set function with various combinations of arguments"""

        test_cases = [("1. px and ex are set, nx is always true & set on non-existing key",
                      False,
                      [(('key1', 'value1', None), dict(ex=20, px=70000, xx=True, nx=True)),
                      (('key2', 'value1', True), dict(ex=20, px=70000, xx=False, nx=True)),
                      (('key3', 'value2', True), dict(ex=20, px=70000, nx=True))]),

                      ("2. px and ex are set, nx is always true & set on existing key",
                      True,
                      [(('key', 'value1', None), dict(ex=20, px=70000, xx=True, nx=True)),
                      (('key', 'value1', None), dict(ex=20, px=7000, xx=False, nx=True)),
                      (('key', 'value1', None), dict(ex=20, px=70000, nx=True))]),

                      ("3. px and ex are set, xx is always true & set on existing key",
                      True,
                      [(('key', 'value1', None), dict(ex=20, px=70000, xx=True, nx=True)),
                      (('key', 'value1', True), dict(ex=20, px=70000, xx=True, nx=False)),
                      (('key', 'value4', True), dict(ex=20, px=70000, xx=True))]),

                      ("4. px and ex are set, xx is always true & set on non-existing key",
                      False,
                      [(('key1', 'value1', None), dict(ex=20, px=70000, xx=True, nx=True)),
                      (('key2', 'value2', None), dict(ex=20, px=70000, xx=True, nx=False)),
                      (('key3', 'value3', None), dict(ex=20, px=70000, xx=True))]),

                      ("5. either nx or xx defined and set to false or none defined" +
                       " & set on existing key",
                      True,
                      [(('key', 'value1', True), dict(ex=20, px=70000, xx=False)),
                      (('key', 'value2', True), dict(ex=20, px=70000, nx=False)),
                      (('key', 'value3', True), dict(ex=20, px=70000))]),

                      ("6. either nx or xx defined and set to false or none defined" +
                       " & set on non-existing key",
                      False,
                      [(('key1', 'value1', True), dict(ex=20, px=70000, xx=False)),
                      (('key2', 'value2', True), dict(ex=20, px=70000, nx=False)),
                      (('key3', 'value3', True), dict(ex=20, px=70000))]),

                      ("7: where neither px nor ex defined + set on existing key",
                      True,
                      [(('key', 'value2', None), dict(xx=True, nx=True)),
                      (('key', 'value2', None), dict(xx=False, nx=True)),
                      (('key', 'value2', True), dict(xx=True, nx=False)),
                      (('key', 'value3', True), dict(xx=True)),
                      (('key', 'value4', None), dict(nx=True)),
                      (('key', 'value4', True), dict(xx=False)),
                      (('key', 'value5', True), dict(nx=False))]),

                      ("8: where neither px nor ex defined + set on non-existing key",
                      False,
                      [(('key1', 'value1', None), dict(xx=True, nx=True)),
                      (('key2', 'value1', True), dict(xx=False, nx=True)),
                      (('key3', 'value2', None), dict(xx=True, nx=False)),
                      (('key4', 'value3', None), dict(xx=True)),
                      (('key5', 'value4', True), dict(nx=True)),
                      (('key6', 'value4', True), dict(xx=False)),
                      (('key7', 'value5', True), dict(nx=False))]),

                      ("9: where neither nx nor xx defined + set on existing key",
                      True,
                      [(('key', 'value1', True), dict(ex=20, px=70000)),
                      (('key1', 'value12', True), dict(ex=20)),
                      (('key1', 'value11', True), dict(px=20000))]),

                      ("10: where neither nx nor xx is defined + set on non-existing key",
                      False,
                      [(('key1', 'value1', True), dict(ex=20, px=70000)),
                      (('key2', 'value2', True), dict(ex=20)),
                      (('key3', 'value3', True), dict(px=20000))])]

        for cases in test_cases:
            yield self._assert_set_with_options, cases

    def _assert_set_with_timeout(self, seconds):
        """Assert that setex sets a key with a value along with a timeout"""

        eq_(None, self.redis.redis.get('key'))

        ok_(self.redis.setex('key', seconds, 'value'))
        eq_('value', self.redis.redis.get('key'))

        ok_(self.redis.ttl('key'), "expiration was not set correctly")
        if isinstance(seconds, timedelta):
            seconds = seconds.seconds + seconds.days * 24 * 3600
        ok_(0 < self.redis.ttl('key') <= seconds)

    def test_setex(self):
        test_cases = [20, timedelta(seconds=20)]
        for case in test_cases:
            yield self._assert_set_with_timeout, case

    def test_setnx(self):
        """Check whether setnx sets a key iff it does not already exist"""

        ok_(self.redis.setnx('key', 'value'))
        ok_(not self.redis.setnx('key', 'different_value'))
        eq_('value', self.redis.get('key'))
Пример #12
0
    def setup(self):
        self.redis = MockRedis()
        self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT.encode("utf-8")).hexdigest()

        try:
            lua, lua_globals = MockRedisScript._import_lua()
        except RuntimeError:
            raise SkipTest("mockredispy was not installed with lua support")

        self.lua = lua
        self.lua_globals = lua_globals

        assert_equal_list = """
        function compare_list(list1, list2)
            if #list1 ~= #list2 then
                return false
            end
            for i, item1 in ipairs(list1) do
                if item1 ~= list2[i] then
                    return false
                end
            end
            return true
        end

        function assert_equal_list(list1, list2)
            assert(compare_list(list1, list2))
        end
        return assert_equal_list
        """
        self.lua_assert_equal_list = self.lua.execute(assert_equal_list)

        assert_equal_list_with_pairs = """
        function pair_exists(list1, key, value)
            i = 1
            for i, item1 in ipairs(list1) do
                if i%2 == 1 then
                    if (list1[i] == key) and (list1[i + 1] == value) then
                        return true
                    end
                end
            end
            return false
        end

        function compare_list_with_pairs(list1, list2)
            if #list1 ~= #list2 or #list1 % 2 == 1 then
                return false
            end
            for i = 1, #list1, 2 do
                if not pair_exists(list2, list1[i], list1[i + 1]) then
                    return false
                end
            end
            return true
        end

        function assert_equal_list_with_pairs(list1, list2)
            assert(compare_list_with_pairs(list1, list2))
        end
        return assert_equal_list_with_pairs
        """
        self.lua_assert_equal_list_with_pairs = self.lua.execute(assert_equal_list_with_pairs)

        compare_val = """
        function compare_val(var1, var2)
            return var1 == var2
        end
        return compare_val
        """
        self.lua_compare_val = self.lua.execute(compare_val)
Пример #13
0
class TestScript(object):
    """
    Tests for MockRedis scripting operations
    """

    def setup(self):
        self.redis = MockRedis()
        self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT.encode("utf-8")).hexdigest()

        try:
            lua, lua_globals = MockRedisScript._import_lua()
        except RuntimeError:
            raise SkipTest("mockredispy was not installed with lua support")

        self.lua = lua
        self.lua_globals = lua_globals

        assert_equal_list = """
        function compare_list(list1, list2)
            if #list1 ~= #list2 then
                return false
            end
            for i, item1 in ipairs(list1) do
                if item1 ~= list2[i] then
                    return false
                end
            end
            return true
        end

        function assert_equal_list(list1, list2)
            assert(compare_list(list1, list2))
        end
        return assert_equal_list
        """
        self.lua_assert_equal_list = self.lua.execute(assert_equal_list)

        assert_equal_list_with_pairs = """
        function pair_exists(list1, key, value)
            i = 1
            for i, item1 in ipairs(list1) do
                if i%2 == 1 then
                    if (list1[i] == key) and (list1[i + 1] == value) then
                        return true
                    end
                end
            end
            return false
        end

        function compare_list_with_pairs(list1, list2)
            if #list1 ~= #list2 or #list1 % 2 == 1 then
                return false
            end
            for i = 1, #list1, 2 do
                if not pair_exists(list2, list1[i], list1[i + 1]) then
                    return false
                end
            end
            return true
        end

        function assert_equal_list_with_pairs(list1, list2)
            assert(compare_list_with_pairs(list1, list2))
        end
        return assert_equal_list_with_pairs
        """
        self.lua_assert_equal_list_with_pairs = self.lua.execute(assert_equal_list_with_pairs)

        compare_val = """
        function compare_val(var1, var2)
            return var1 == var2
        end
        return compare_val
        """
        self.lua_compare_val = self.lua.execute(compare_val)

    def test_register_script_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1], args=[VAL1, VAL2])

        # validate insertion
        eq_([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        script = self.redis.register_script(script_content)
        list_item = script(keys=[LIST1])

        # validate lpop
        eq_(VAL1, list_item)
        eq_([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_rpoplpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpoplpush
        script_content = "redis.call('RPOPLPUSH', KEYS[1], KEYS[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpoplpush
        eq_([VAL1], self.redis.lrange(LIST1, 0, -1))
        eq_([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_rpop_lpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpop from LIST1 and lpush the same value to LIST2
        script_content = """
        local tmp_item = redis.call('RPOP', KEYS[1])
        redis.call('LPUSH', KEYS[2], tmp_item)
        """
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpop and then lpush
        eq_([VAL1], self.redis.lrange(LIST1, 0, -1))
        eq_([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_client(self):
        # lpush two values in LIST1 in first instance of redis
        self.redis.lpush(LIST1, VAL2, VAL1)

        # create script on first instance of redis
        script_content = LPOP_SCRIPT
        script = self.redis.register_script(script_content)

        # lpush two values in LIST1 in redis2 (second instance of redis)
        redis2 = MockRedis()
        redis2.lpush(LIST1, VAL4, VAL3)

        # execute LPOP script on redis2 instance
        list_item = script(keys=[LIST1], client=redis2)

        # validate lpop from LIST1 in redis2
        eq_(VAL3, list_item)
        eq_([VAL4], redis2.lrange(LIST1, 0, -1))
        eq_([VAL1, VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        self.redis.eval(script_content, 1, LIST1, VAL1, VAL2)

        # validate insertion
        eq_([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        list_item = self.redis.eval(script_content, 1, LIST1)

        # validate lpop
        eq_(VAL1, list_item)
        eq_([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_eval_zadd(self):
        # The score and member are reversed when the client is not strict.
        self.redis.strict = False
        script_content = "return redis.call('zadd', KEYS[1], ARGV[1], ARGV[2])"
        self.redis.eval(script_content, 1, SET1, 42, VAL1)

        eq_(42, self.redis.zscore(SET1, VAL1))

    def test_eval_zrangebyscore(self):
        # Make sure the limit is removed.
        script = "return redis.call('zrangebyscore',KEYS[1],ARGV[1],ARGV[2])"
        self.eval_zrangebyscore(script)

    def test_eval_zrangebyscore_with_limit(self):
        # Make sure the limit is removed.
        script = ("return redis.call('zrangebyscore', "
                  "KEYS[1], ARGV[1], ARGV[2], 'LIMIT', 0, 2)")

        self.eval_zrangebyscore(script)

    def eval_zrangebyscore(self, script):
        self.redis.strict = False
        self.redis.zadd(SET1, VAL1, 1)
        self.redis.zadd(SET1, VAL2, 2)

        eq_([],           self.redis.eval(script, 1, SET1, 0, 0))
        eq_([VAL1],       self.redis.eval(script, 1, SET1, 0, 1))
        eq_([VAL1, VAL2], self.redis.eval(script, 1, SET1, 0, 2))
        eq_([VAL2],       self.redis.eval(script, 1, SET1, 2, 2))

    def test_table_type(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        script_content = """
        local items = redis.call('LRANGE', KEYS[1], ARGV[1], ARGV[2])
        return type(items)
        """
        script = self.redis.register_script(script_content)
        itemType = script(keys=[LIST1], args=[0, -1])
        eq_('table', itemType)

    def test_script_hgetall(self):
        myhash = {"k1": "v1"}
        self.redis.hmset("myhash", myhash)
        script_content = """
        return redis.call('HGETALL', KEYS[1])
        """
        script = self.redis.register_script(script_content)
        item = script(keys=["myhash"])
        ok_(isinstance(item, list))
        eq_(["k1", "v1"], item)

    def test_evalsha(self):
        self.redis.lpush(LIST1, VAL1)
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA

        # validator error when script not registered
        with assert_raises(RedisError) as redis_error:
            self.redis.evalsha(self.LPOP_SCRIPT_SHA, 1, LIST1)

        eq_("Sha not registered", str(redis_error.exception))

        with assert_raises(RedisError):
            self.redis.evalsha(self.LPOP_SCRIPT_SHA, 1, LIST1)

        # load script and then evalsha
        eq_(sha, self.redis.script_load(script))
        eq_(VAL1, self.redis.evalsha(sha, 1, LIST1))
        eq_(0, self.redis.llen(LIST1))

    def test_script_exists(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        eq_([False], self.redis.script_exists(sha))
        self.redis.register_script(script)
        eq_([True], self.redis.script_exists(sha))

    def test_script_flush(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.redis.register_script(script)
        eq_([True], self.redis.script_exists(sha))
        self.redis.script_flush()
        eq_([False], self.redis.script_exists(sha))

    def test_script_load(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        eq_([False], self.redis.script_exists(sha))
        eq_(sha, self.redis.script_load(script))
        eq_([True], self.redis.script_exists(sha))

    def test_lua_to_python_none(self):
        lval = self.lua.eval("")
        pval = MockRedisScript._lua_to_python(lval)
        ok_(pval is None)

    def test_lua_to_python_list(self):
        lval = self.lua.eval('{"val1", "val2"}')
        pval = MockRedisScript._lua_to_python(lval)
        ok_(isinstance(pval, list))
        eq_(["val1", "val2"], pval)

    def test_lua_to_python_long(self):
        lval = self.lua.eval('22')
        pval = MockRedisScript._lua_to_python(lval)
        ok_(isinstance(pval, long))
        eq_(22, pval)

    def test_lua_to_python_flota(self):
        lval = self.lua.eval('22.2')
        pval = MockRedisScript._lua_to_python(lval)
        ok_(isinstance(pval, float))
        eq_(22.2, pval)

    def test_lua_to_python_string(self):
        lval = self.lua.eval('"somestring"')
        pval = MockRedisScript._lua_to_python(lval)
        ok_(isinstance(pval, str))
        eq_("somestring", pval)

    def test_lua_to_python_bool(self):
        lval = self.lua.eval('true')
        pval = MockRedisScript._lua_to_python(lval)
        ok_(isinstance(pval, bool))
        eq_(True, pval)

    def test_python_to_lua_none(self):
        pval = None
        lval = MockRedisScript._python_to_lua(pval)
        is_null = """
        function is_null(var1)
            return var1 == nil
        end
        return is_null
        """
        lua_is_null = self.lua.execute(is_null)
        ok_(MockRedisScript._lua_to_python(lua_is_null(lval)))

    def test_python_to_lua_string(self):
        pval = "somestring"
        lval = MockRedisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('"somestring"')
        eq_("string", self.lua_globals.type(lval))
        eq_(lval_expected, lval)

    def test_python_to_lua_list(self):
        pval = ["abc", "xyz"]
        lval = MockRedisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('{"abc", "xyz"}')
        self.lua_assert_equal_list(lval_expected, lval)

    def test_python_to_lua_dict(self):
        pval = {"k1": "v1", "k2": "v2"}
        lval = MockRedisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('{"k1", "v1", "k2", "v2"}')
        self.lua_assert_equal_list_with_pairs(lval_expected, lval)

    def test_python_to_lua_long(self):
        pval = long(10)
        lval = MockRedisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('10')
        eq_("number", self.lua_globals.type(lval))
        ok_(MockRedisScript._lua_to_python(self.lua_compare_val(lval_expected, lval)))

    def test_python_to_lua_float(self):
        pval = 10.1
        lval = MockRedisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('10.1')
        eq_("number", self.lua_globals.type(lval))
        ok_(MockRedisScript._lua_to_python(self.lua_compare_val(lval_expected, lval)))

    def test_python_to_lua_boolean(self):
        pval = True
        lval = MockRedisScript._python_to_lua(pval)
        eq_("boolean", self.lua_globals.type(lval))
        ok_(MockRedisScript._lua_to_python(lval))
Пример #14
0
class TestList(TestCase):
    """
    Tests for MockRedis list operations
    """

    def setUp(self):
        self.redis = MockRedis()
        self.redis.flushdb()

    def test_initially_empty(self):
        """
        List is created empty.
        """
        self.assertEqual(0, len(self.redis.redis['test_list']))

    def test_llen(self):
        self.assertEquals(0, self.redis.llen('test_list'))
        self.redis.redis['test_list'] = ['val1', 'val2']
        self.assertEquals(2, self.redis.llen('test_list'))
        self.redis.redis['test_list'].pop(0)
        self.assertEquals(1, self.redis.llen('test_list'))
        self.redis.redis['test_list'].pop(0)
        self.assertEquals(0, self.redis.llen('test_list'))

    def test_lpop(self):
        self.redis.redis['test_list'] = ['val1', 'val2']
        self.assertEquals('val1', self.redis.lpop('test_list'))
        self.assertEquals(1, len(self.redis.redis['test_list']))
        self.assertEquals('val2', self.redis.lpop('test_list'))
        self.assertEquals(0, len(self.redis.redis['test_list']))
        self.assertIsNone(self.redis.lpop('test_list'))

    def test_lpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.lpush('test_list', 'val1')
        self.redis.lpush('test_list', 'val2')

        # validate insertion
        self.assertEquals(2, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val2', self.redis.redis['test_list'][0])
        self.assertEquals('val1', self.redis.redis['test_list'][1])

        # insert two more values with one repeated
        self.redis.lpush('test_list', 'val1', 'val3')

        # validate the update
        self.assertEquals(4, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val3', self.redis.redis['test_list'][0])
        self.assertEquals('val1', self.redis.redis['test_list'][1])
        self.assertEquals('val2', self.redis.redis['test_list'][2])
        self.assertEquals('val1', self.redis.redis['test_list'][3])

    def test_rpop(self):
        self.redis.redis['test_list'] = ['val1', 'val2']
        self.assertEquals('val2', self.redis.rpop('test_list'))
        self.assertEquals(1, len(self.redis.redis['test_list']))
        self.assertEquals('val1', self.redis.rpop('test_list'))
        self.assertEquals(0, len(self.redis.redis['test_list']))
        self.assertIsNone(self.redis.lpop('test_list'))

    def test_rpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.rpush('test_list', 'val1')
        self.redis.rpush('test_list', 'val2')

        # validate insertion
        self.assertEquals(2, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val1', self.redis.redis['test_list'][0])
        self.assertEquals('val2', self.redis.redis['test_list'][1])

        # insert two more values with one repeated
        self.redis.rpush('test_list', 'val1', 'val3')

        # validate the update
        self.assertEquals(4, len(self.redis.redis['test_list']))
        self.assertEquals('list', self.redis.type('test_list'))
        self.assertEquals('val1', self.redis.redis['test_list'][0])
        self.assertEquals('val2', self.redis.redis['test_list'][1])
        self.assertEquals('val1', self.redis.redis['test_list'][2])
        self.assertEquals('val3', self.redis.redis['test_list'][3])

    def test_lrem(self):
        self.redis.redis['test_list'] = ['val1', 'val2', 'val1', 'val3', 'val4', 'val2']
        self.redis.lrem('test_list', 0, 'val1')
        self.assertListEqual(['val2', 'val3', 'val4', 'val2'], self.redis.redis['test_list'])

        self.redis.redis['test_list'] = ['val1', 'val2', 'val1', 'val3', 'val4', 'val2']
        self.redis.lrem('test_list', 1, 'val2')
        self.assertListEqual(['val1', 'val1', 'val3', 'val4', 'val2'],
                             self.redis.redis['test_list'])

        self.redis.redis['test_list'] = ['val1', 'val2', 'val1', 'val3', 'val4', 'val2']
        self.redis.lrem('test_list', 100, 'val1')
        self.assertListEqual(['val2', 'val3', 'val4', 'val2'], self.redis.redis['test_list'])

        self.redis.redis['test_list'] = ['val1', 'val2', 'val1', 'val3', 'val4', 'val2']
        self.redis.lrem('test_list', -1, 'val3')
        self.assertListEqual(['val1', 'val2', 'val1', 'val4', 'val2'],
                             self.redis.redis['test_list'])

        self.redis.redis['test_list'] = ['val1', 'val2', 'val1', 'val3', 'val4', 'val2']
        self.redis.lrem('test_list', -1, 'val2')
        self.assertListEqual(['val1', 'val2', 'val1', 'val3', 'val4'],
                             self.redis.redis['test_list'])

        self.redis.redis['test_list'] = ['val1', 'val2', 'val1', 'val3', 'val4', 'val2']
        self.redis.lrem('test_list', -2, 'val2')
        self.assertListEqual(['val1', 'val1', 'val3', 'val4'], self.redis.redis['test_list'])
Пример #15
0
class TestRedisList(TestCase):
    """list tests"""

    def setUp(self):
        self.redis = MockRedis()

    def test_initially_empty(self):
        """
        List is created empty.
        """
        self.assertEqual(0, len(self.redis.redis[LIST1]))

    def test_llen(self):
        self.assertEquals(0, self.redis.llen(LIST1))
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(2, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(1, self.redis.llen(LIST1))
        self.redis.redis[LIST1].pop(0)
        self.assertEquals(0, self.redis.llen(LIST1))

    def test_lpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL1, self.redis.lpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL2, self.redis.lpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_lpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.lpush(LIST1, VAL1)
        self.redis.lpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL2, VAL1], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.lpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL3, VAL1, VAL2, VAL1], self.redis.redis[LIST1])

    def test_rpop(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.assertEquals(VAL2, self.redis.rpop(LIST1))
        self.assertEquals(1, len(self.redis.redis[LIST1]))
        self.assertEquals(VAL1, self.redis.rpop(LIST1))
        self.assertEquals(0, len(self.redis.redis[LIST1]))
        self.assertIsNone(self.redis.lpop(LIST1))

    def test_rpush(self):
        """
        Insertion maintains order but not uniqueness.
        """
        # lpush two values
        self.redis.rpush(LIST1, VAL1)
        self.redis.rpush(LIST1, VAL2)

        # validate insertion
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2], self.redis.redis[LIST1])

        # insert two more values with one repeated
        self.redis.rpush(LIST1, VAL1, VAL3)

        # validate the update
        self.assertEquals("list", self.redis.type(LIST1))
        self.assertEquals([VAL1, VAL2, VAL1, VAL3], self.redis.redis[LIST1])

    def test_lrem(self):
        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL1, 0)
        self.assertEqual(2, count)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL2, 1)
        self.assertEqual(1, count)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL1, 100)
        self.assertEqual(2, count)
        self.assertListEqual([VAL2, VAL3, VAL4, VAL2], self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL3, -1)
        self.assertEqual(1, count)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL4, VAL2],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL2, -1)
        self.assertEqual(1, count)
        self.assertListEqual([VAL1, VAL2, VAL1, VAL3, VAL4],
                             self.redis.redis[LIST1])

        self.redis.redis[LIST1] = [VAL1, VAL2, VAL1, VAL3, VAL4, VAL2]
        count = self.redis.lrem(LIST1, VAL2, -2)
        self.assertEqual(2, count)
        self.assertListEqual([VAL1, VAL1, VAL3, VAL4], self.redis.redis[LIST1])

        count = self.redis.lrem("NON_EXISTENT_LIST", VAL1, 0)
        self.assertEqual(0, count)

    def test_rpoplpush(self):
        self.redis.redis[LIST1] = [VAL1, VAL2]
        self.redis.redis[LIST2] = [VAL3, VAL4]
        transfer_item = self.redis.rpoplpush(LIST1, LIST2)
        self.assertEqual(VAL2, transfer_item)
        self.assertEqual([VAL1], self.redis.redis[LIST1])
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.redis[LIST2])

    def test_rpoplpush_with_empty_source(self):
        # source list is empty
        self.redis.redis[LIST1] = []
        self.redis.redis[LIST2] = [VAL3, VAL4]
        transfer_item = self.redis.rpoplpush(LIST1, LIST2)
        self.assertEqual(None, transfer_item)
        self.assertEqual([], self.redis.redis[LIST1])
        # nothing has been added to the destination queue
        self.assertEqual([VAL3, VAL4], self.redis.redis[LIST2])

    def test_rpoplpush_source_with_empty_string(self):
        # source list contains empty string
        self.redis.redis[LIST1] = ['']
        self.redis.redis[LIST2] = [VAL3, VAL4]
        self.assertEqual(1, self.redis.llen(LIST1))
        self.assertEqual(2, self.redis.llen(LIST2))
        
        transfer_item = self.redis.rpoplpush(LIST1, LIST2)
        self.assertEqual('', transfer_item)
        self.assertEqual(0, self.redis.llen(LIST1))
        self.assertEqual(3, self.redis.llen(LIST2))
        self.assertEqual([], self.redis.redis[LIST1])
        # empty string is added to the destination queue
        self.assertEqual(['', VAL3, VAL4], self.redis.redis[LIST2])

    def test_lrange_get_all(self):
        """Cases for returning entire list"""
        values = [VAL4, VAL3, VAL2, VAL1]

        self.assertEqual([], self.redis.lrange(LIST1, 0, 6))
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))
        self.redis.lpush(LIST1, *reversed(values))

        # Check with exact range
        self.assertEqual(values, self.redis.lrange(LIST1, 0, 3))
        # Check with negative index
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))
        # Check with range larger than length of list
        self.assertEqual(values, self.redis.lrange(LIST1, 0, 6))

    def test_lrange_get_sublist(self):
        """Cases for returning partial list"""
        values = [VAL4, VAL3, VAL2, VAL1]

        self.assertEqual([], self.redis.lrange(LIST1, 0, 6))
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))
        self.redis.lpush(LIST1, *reversed(values))

        # Check from left end of the list
        self.assertEqual(values[:2], self.redis.lrange(LIST1, 0, 1))
        # Check from right end of the list
        self.assertEqual(values[2:4], self.redis.lrange(LIST1, 2, 3))
        # Check from right end of the list with negative range
        self.assertEqual(values[-2:], self.redis.lrange(LIST1, -2, -1))
        # Check from middle of the list
        self.assertEqual(values[1:3], self.redis.lrange(LIST1, 1, 2))

    def test_ltrim_retain_all(self):
        values = [VAL4, VAL3, VAL2, VAL1]
        self._reinitialize_list(LIST1, *values)

        self.redis.ltrim(LIST1, 0, -1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, 0, len(values) - 1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, 0, len(values) + 1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, -1 * len(values), -1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

        self.redis.ltrim(LIST1, -1 * (len(values) + 1), -1)
        self.assertEqual(values, self.redis.lrange(LIST1, 0, -1))

    def test_ltrim_remove_all(self):
        values = [VAL4, VAL3, VAL2, VAL1]
        self._reinitialize_list(LIST1, *values)

        self.redis.ltrim(LIST1, 2, 1)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -1, -2)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, 2, -3)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -1, 2)
        self.assertEqual([], self.redis.lrange(LIST1, 0, -1))

    def test_ltrim(self):
        values = [VAL4, VAL3, VAL2, VAL1]
        self._reinitialize_list(LIST1, *values)

        self.redis.ltrim(LIST1, 1, 2)
        self.assertEqual(values[1:3], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -3, -1)
        self.assertEqual(values[-3:], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, 1, 5)
        self.assertEqual(values[1:5], self.redis.lrange(LIST1, 0, -1))

        self._reinitialize_list(LIST1, *values)
        self.redis.ltrim(LIST1, -100, 2)
        self.assertEqual(values[-100:3], self.redis.lrange(LIST1, 0, -1))

    def test_lset(self):
        with self.assertRaises(Exception):
            self.redis.lset(LIST1, 1, VAL1)

        self.redis.lpush(LIST1, VAL2)
        self.assertEqual([VAL2], self.redis.lrange(LIST1, 0, -1))

        with self.assertRaises(Exception):
            self.redis.lset(LIST1, 1, VAL1)

        self.redis.lset(LIST1, 0, VAL1)
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))

    def _reinitialize_list(self, key, *values):
        """
        Re-initialize the list
        """
        self.redis.delete(LIST1)
        self.redis.lpush(LIST1, *reversed(values))
Пример #16
0
 def setUp(self):
     self.redis = MockRedis()
Пример #17
0
class TestScript(TestCase):
    """
    Tests for MockRedis scripting operations
    """
    def setUp(self):
        self.redis = MockRedis()
        self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()
        import lua
        self.lua = lua
        self.lua_globals = lua.globals()

        assert_equal_list = """
        function compare_list(list1, list2)
            if #list1 ~= #list2 then
                return false
            end
            for i, item1 in ipairs(list1) do
                if item1 ~= list2[i] then
                    return false
                end
            end
            return true
        end

        function assert_equal_list(list1, list2)
            assert(compare_list(list1, list2))
        end
        return assert_equal_list
        """
        self.lua_assert_equal_list = self.lua.execute(assert_equal_list)

        assert_equal_list_with_pairs = """
        function pair_exists(list1, key, value)
            i = 1
            for i, item1 in ipairs(list1) do
                if i%2 == 1 then
                    if (list1[i] == key) and (list1[i + 1] == value) then
                        return true
                    end
                end
            end
            return false
        end

        function compare_list_with_pairs(list1, list2)
            if #list1 ~= #list2 or #list1 % 2 == 1 then
                return false
            end
            for i = 1, #list1, 2 do
                if not pair_exists(list2, list1[i], list1[i + 1]) then
                    return false
                end
            end
            return true
        end

        function assert_equal_list_with_pairs(list1, list2)
            assert(compare_list_with_pairs(list1, list2))
        end
        return assert_equal_list_with_pairs
        """
        self.lua_assert_equal_list_with_pairs = self.lua.execute(
            assert_equal_list_with_pairs)

        compare_val = """
        function compare_val(var1, var2)
            return var1 == var2
        end
        return compare_val
        """
        self.lua_compare_val = self.lua.execute(compare_val)

    def test_register_script_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1], args=[VAL1, VAL2])

        # validate insertion
        self.assertEquals([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        script = self.redis.register_script(script_content)
        list_item = script(keys=[LIST1])

        # validate lpop
        self.assertEquals(VAL1, list_item)
        self.assertEquals([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_rpoplpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpoplpush
        script_content = "redis.call('RPOPLPUSH', KEYS[1], KEYS[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpoplpush
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_rpop_lpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpop from LIST1 and lpush the same value to LIST2
        script_content = """
        local tmp_item = redis.call('RPOP', KEYS[1])
        redis.call('LPUSH', KEYS[2], tmp_item)
        """
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpop and then lpush
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_client(self):
        # lpush two values in LIST1 in first instance of redis
        self.redis.lpush(LIST1, VAL2, VAL1)

        # create script on first instance of redis
        script_content = LPOP_SCRIPT
        script = self.redis.register_script(script_content)

        # lpush two values in LIST1 in redis2 (second instance of redis)
        redis2 = MockRedis()
        redis2.lpush(LIST1, VAL4, VAL3)

        # execute LPOP script on redis2 instance
        list_item = script(keys=[LIST1], client=redis2)

        # validate lpop from LIST1 in redis2
        self.assertEquals(VAL3, list_item)
        self.assertEquals([VAL4], redis2.lrange(LIST1, 0, -1))
        self.assertEquals([VAL1, VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        self.redis.eval(script_content, 1, LIST1, VAL1, VAL2)

        # validate insertion
        self.assertEquals([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        list_item = self.redis.eval(script_content, 1, LIST1)

        # validate lpop
        self.assertEquals(VAL1, list_item)
        self.assertEquals([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_eval_zadd(self):
        # The score and member are reversed when the client is not strict.
        self.redis.strict = False
        script_content = "return redis.call('zadd', KEYS[1], ARGV[1], ARGV[2])"
        self.redis.eval(script_content, 1, SET1, 42, VAL1)

        self.assertEquals(42, self.redis.zscore(SET1, VAL1))

    def test_eval_zrangebyscore(self):
        # Make sure the limit is removed.
        script = "return redis.call('zrangebyscore',KEYS[1],ARGV[1],ARGV[2])"
        self.eval_zrangebyscore(script)

    def test_eval_zrangebyscore_with_limit(self):
        # Make sure the limit is removed.
        script = ("return redis.call('zrangebyscore', "
                  "KEYS[1], ARGV[1], ARGV[2], 'LIMIT', 0, 2)")

        self.eval_zrangebyscore(script)

    def eval_zrangebyscore(self, script):
        self.redis.strict = False
        self.redis.zadd(SET1, VAL1, 1)
        self.redis.zadd(SET1, VAL2, 2)

        self.assertEquals([], self.redis.eval(script, 1, SET1, 0, 0))
        self.assertEquals([VAL1], self.redis.eval(script, 1, SET1, 0, 1))
        self.assertEquals([VAL1, VAL2], self.redis.eval(script, 1, SET1, 0, 2))
        self.assertEquals([VAL2], self.redis.eval(script, 1, SET1, 2, 2))

    def test_table_type(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        script_content = """
        local items = redis.call('LRANGE', KEYS[1], ARGV[1], ARGV[2])
        return type(items)
        """
        script = self.redis.register_script(script_content)
        itemType = script(keys=[LIST1], args=[0, -1])
        self.assertEqual('table', itemType)

    def test_script_hgetall(self):
        myhash = {"k1": "v1"}
        self.redis.hmset("myhash", myhash)
        script_content = """
        return redis.call('HGETALL', KEYS[1])
        """
        script = self.redis.register_script(script_content)
        item = script(keys=["myhash"])
        self.assertIsInstance(item, list)
        self.assertEquals(["k1", "v1"], item)

    def test_evalsha(self):
        self.redis.lpush(LIST1, VAL1)
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA

        # validator error when script not registered
        with self.assertRaises(RedisError) as redisError:
            self.redis.evalsha(self.LPOP_SCRIPT_SHA, 1, LIST1)

        self.assertEqual("Sha not registered", str(redisError.exception))

        self.assertRaises(RedisError, self.redis.evalsha, self.LPOP_SCRIPT_SHA,
                          1, LIST1)

        # load script and then evalsha
        self.assertEquals(sha, self.redis.script_load(script))
        self.assertEquals(VAL1, self.redis.evalsha(sha, 1, LIST1))
        self.assertEquals(0, self.redis.llen(LIST1))

    def test_script_exists(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.assertEquals([False], self.redis.script_exists(sha))
        self.redis.register_script(script)
        self.assertEquals([True], self.redis.script_exists(sha))

    def test_script_flush(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.redis.register_script(script)
        self.assertEquals([True], self.redis.script_exists(sha))
        self.redis.script_flush()
        self.assertEquals([False], self.redis.script_exists(sha))

    def test_script_load(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.assertEquals([False], self.redis.script_exists(sha))
        self.assertEquals(sha, self.redis.script_load(script))
        self.assertEquals([True], self.redis.script_exists(sha))

    def test_lua_to_python_none(self):
        lval = self.lua.eval("")
        pval = MockredisScript._lua_to_python(lval)
        self.assertTrue(pval is None)

    def test_lua_to_python_list(self):
        lval = self.lua.eval('{"val1", "val2"}')
        pval = MockredisScript._lua_to_python(lval)
        self.assertIsInstance(pval, list)
        self.assertEqual(["val1", "val2"], pval)

    def test_lua_to_python_long(self):
        lval = self.lua.eval('22')
        pval = MockredisScript._lua_to_python(lval)
        self.assertIsInstance(pval, long)
        self.assertEqual(22, pval)

    def test_lua_to_python_flota(self):
        lval = self.lua.eval('22.2')
        pval = MockredisScript._lua_to_python(lval)
        self.assertIsInstance(pval, float)
        self.assertEqual(22.2, pval)

    def test_lua_to_python_string(self):
        lval = self.lua.eval('"somestring"')
        pval = MockredisScript._lua_to_python(lval)
        self.assertIsInstance(pval, str)
        self.assertEqual("somestring", pval)

    def test_lua_to_python_bool(self):
        lval = self.lua.eval('true')
        pval = MockredisScript._lua_to_python(lval)
        self.assertIsInstance(pval, bool)
        self.assertEqual(True, pval)

    def test_python_to_lua_none(self):
        pval = None
        lval = MockredisScript._python_to_lua(pval)
        is_null = """
        function is_null(var1)
            return var1 == nil
        end
        return is_null
        """
        lua_is_null = self.lua.execute(is_null)
        self.assertTrue(MockredisScript._lua_to_python(lua_is_null(lval)))

    def test_python_to_lua_string(self):
        pval = "somestring"
        lval = MockredisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('"somestring"')
        self.assertEqual("string", self.lua_globals.type(lval))
        self.assertEqual(lval_expected, lval)

    def test_python_to_lua_list(self):
        pval = ["abc", "xyz"]
        lval = MockredisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('{"abc", "xyz"}')
        self.lua_assert_equal_list(lval_expected, lval)

    def test_python_to_lua_dict(self):
        pval = {"k1": "v1", "k2": "v2"}
        lval = MockredisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('{"k1", "v1", "k2", "v2"}')
        self.lua_assert_equal_list_with_pairs(lval_expected, lval)

    def test_python_to_lua_long(self):
        pval = 10L
        lval = MockredisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('10')
        self.assertEqual("number", self.lua_globals.type(lval))
        self.assertTrue(
            MockredisScript._lua_to_python(
                self.lua_compare_val(lval_expected, lval)))

    def test_python_to_lua_float(self):
        pval = 10.1
        lval = MockredisScript._python_to_lua(pval)
        lval_expected = self.lua.eval('10.1')
        self.assertEqual("number", self.lua_globals.type(lval))
        self.assertTrue(
            MockredisScript._lua_to_python(
                self.lua_compare_val(lval_expected, lval)))

    def test_python_to_lua_boolean(self):
        pval = True
        lval = MockredisScript._python_to_lua(pval)
        self.assertEqual("boolean", self.lua_globals.type(lval))
        self.assertTrue(MockredisScript._lua_to_python(lval))
Пример #18
0
class TestScript(TestCase):
    """
    Tests for MockRedis scripting operations
    """
    def setUp(self):
        self.redis = MockRedis()
        self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()

    def test_register_script_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1], args=[VAL1, VAL2])

        # validate insertion
        self.assertEquals([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        script = self.redis.register_script(script_content)
        list_item = script(keys=[LIST1])

        # validate lpop
        self.assertEquals(VAL1, list_item)
        self.assertEquals([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_rpoplpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpoplpush
        script_content = "redis.call('RPOPLPUSH', KEYS[1], KEYS[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpoplpush
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_rpop_lpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpop from LIST1 and lpush the same value to LIST2
        script_content = """
        local tmp_item = redis.call('RPOP', KEYS[1])
        redis.call('LPUSH', KEYS[2], tmp_item)
        """
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpop and then lpush
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_client(self):
        # lpush two values in LIST1 in first instance of redis
        self.redis.lpush(LIST1, VAL2, VAL1)

        # create script on first instance of redis
        script_content = LPOP_SCRIPT
        script = self.redis.register_script(script_content)

        # lpush two values in LIST1 in redis2 (second instance of redis)
        redis2 = MockRedis()
        redis2.lpush(LIST1, VAL4, VAL3)

        # execute LPOP script on redis2 instance
        list_item = script(keys=[LIST1], client=redis2)

        # validate lpop from LIST1 in redis2
        self.assertEquals(VAL3, list_item)
        self.assertEquals([VAL4], redis2.lrange(LIST1, 0, -1))
        self.assertEquals([VAL1, VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        self.redis.eval(script_content, 1, LIST1, VAL1, VAL2)

        # validate insertion
        self.assertEquals([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        list_item = self.redis.eval(script_content, 1, LIST1)

        # validate lpop
        self.assertEquals(VAL1, list_item)
        self.assertEquals([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_evalsha(self):
        self.redis.lpush(LIST1, VAL1)
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA

        # validator error when script not registered
        with self.assertRaises(RedisError) as redisError:
            self.redis.evalsha(self.LPOP_SCRIPT_SHA, 1, LIST1)

        self.assertEqual("Sha not registered", str(redisError.exception))

        self.assertRaises(RedisError, self.redis.evalsha, self.LPOP_SCRIPT_SHA,
                          1, LIST1)

        # load script and then evalsha
        self.assertEquals(sha, self.redis.script_load(script))
        self.assertEquals(VAL1, self.redis.evalsha(sha, 1, LIST1))
        self.assertEquals(0, self.redis.llen(LIST1))

    def test_script_exists(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.assertEquals([False], self.redis.script_exists(sha))
        self.redis.register_script(script)
        self.assertEquals([True], self.redis.script_exists(sha))

    def test_script_flush(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.redis.register_script(script)
        self.assertEquals([True], self.redis.script_exists(sha))
        self.redis.script_flush()
        self.assertEquals([False], self.redis.script_exists(sha))

    def test_script_load(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.assertEquals([False], self.redis.script_exists(sha))
        self.assertEquals(sha, self.redis.script_load(script))
        self.assertEquals([True], self.redis.script_exists(sha))
Пример #19
0
    def setUp(self):
        self.redis = MockRedis()
        self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()
        import lua
        self.lua = lua
        self.lua_globals = lua.globals()

        assert_equal_list = """
        function compare_list(list1, list2)
            if #list1 ~= #list2 then
                return false
            end
            for i, item1 in ipairs(list1) do
                if item1 ~= list2[i] then
                    return false
                end
            end
            return true
        end

        function assert_equal_list(list1, list2)
            assert(compare_list(list1, list2))
        end
        return assert_equal_list
        """
        self.lua_assert_equal_list = self.lua.execute(assert_equal_list)

        assert_equal_list_with_pairs = """
        function pair_exists(list1, key, value)
            i = 1
            for i, item1 in ipairs(list1) do
                if i%2 == 1 then
                    if (list1[i] == key) and (list1[i + 1] == value) then
                        return true
                    end
                end
            end
            return false
        end

        function compare_list_with_pairs(list1, list2)
            if #list1 ~= #list2 or #list1 % 2 == 1 then
                return false
            end
            for i = 1, #list1, 2 do
                if not pair_exists(list2, list1[i], list1[i + 1]) then
                    return false
                end
            end
            return true
        end

        function assert_equal_list_with_pairs(list1, list2)
            assert(compare_list_with_pairs(list1, list2))
        end
        return assert_equal_list_with_pairs
        """
        self.lua_assert_equal_list_with_pairs = self.lua.execute(
            assert_equal_list_with_pairs)

        compare_val = """
        function compare_val(var1, var2)
            return var1 == var2
        end
        return compare_val
        """
        self.lua_compare_val = self.lua.execute(compare_val)
Пример #20
0
class TestScript(TestCase):
    """
    Tests for MockRedis scripting operations
    """

    def setUp(self):
        self.redis = MockRedis()
        self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()

    def test_register_script_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1], args=[VAL1, VAL2])

        # validate insertion
        self.assertEquals([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        script = self.redis.register_script(script_content)
        list_item = script(keys=[LIST1])

        # validate lpop
        self.assertEquals(VAL1, list_item)
        self.assertEquals([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_register_script_rpoplpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpoplpush
        script_content = "redis.call('RPOPLPUSH', KEYS[1], KEYS[2])"
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpoplpush
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_rpop_lpush(self):
        self.redis.lpush(LIST1, VAL2, VAL1)
        self.redis.lpush(LIST2, VAL4, VAL3)

        # rpop from LIST1 and lpush the same value to LIST2
        script_content = """
        local tmp_item = redis.call('RPOP', KEYS[1])
        redis.call('LPUSH', KEYS[2], tmp_item)
        """
        script = self.redis.register_script(script_content)
        script(keys=[LIST1, LIST2])

        #validate rpop and then lpush
        self.assertEqual([VAL1], self.redis.lrange(LIST1, 0, -1))
        self.assertEqual([VAL2, VAL3, VAL4], self.redis.lrange(LIST2, 0, -1))

    def test_register_script_client(self):
        # lpush two values in LIST1 in first instance of redis
        self.redis.lpush(LIST1, VAL2, VAL1)

        # create script on first instance of redis
        script_content = LPOP_SCRIPT
        script = self.redis.register_script(script_content)

        # lpush two values in LIST1 in redis2 (second instance of redis)
        redis2 = MockRedis()
        redis2.lpush(LIST1, VAL4, VAL3)

        # execute LPOP script on redis2 instance
        list_item = script(keys=[LIST1], client=redis2)

        # validate lpop from LIST1 in redis2
        self.assertEquals(VAL3, list_item)
        self.assertEquals([VAL4], redis2.lrange(LIST1, 0, -1))
        self.assertEquals([VAL1, VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpush(self):
        # lpush two values
        script_content = "redis.call('LPUSH', KEYS[1], ARGV[1], ARGV[2])"
        self.redis.eval(script_content, 1, LIST1, VAL1, VAL2)

        # validate insertion
        self.assertEquals([VAL2, VAL1], self.redis.lrange(LIST1, 0, -1))

    def test_eval_lpop(self):
        self.redis.lpush(LIST1, VAL2, VAL1)

        # lpop one value
        script_content = "return redis.call('LPOP', KEYS[1])"
        list_item = self.redis.eval(script_content, 1, LIST1)

        # validate lpop
        self.assertEquals(VAL1, list_item)
        self.assertEquals([VAL2], self.redis.lrange(LIST1, 0, -1))

    def test_evalsha(self):
        self.redis.lpush(LIST1, VAL1)
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA

        # validator error when script not registered
        with self.assertRaises(RedisError) as redisError:
            self.redis.evalsha(self.LPOP_SCRIPT_SHA, 1, LIST1)

        self.assertEqual("Sha not registered", str(redisError.exception))

        self.assertRaises(RedisError, self.redis.evalsha, self.LPOP_SCRIPT_SHA, 1, LIST1)

        # load script and then evalsha
        self.assertEquals(sha, self.redis.script_load(script))
        self.assertEquals(VAL1, self.redis.evalsha(sha, 1, LIST1))
        self.assertEquals(0, self.redis.llen(LIST1))

    def test_script_exists(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.assertEquals([False], self.redis.script_exists(sha))
        self.redis.register_script(script)
        self.assertEquals([True], self.redis.script_exists(sha))

    def test_script_flush(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.redis.register_script(script)
        self.assertEquals([True], self.redis.script_exists(sha))
        self.redis.script_flush()
        self.assertEquals([False], self.redis.script_exists(sha))

    def test_script_load(self):
        script = LPOP_SCRIPT
        sha = self.LPOP_SCRIPT_SHA
        self.assertEquals([False], self.redis.script_exists(sha))
        self.assertEquals(sha, self.redis.script_load(script))
        self.assertEquals([True], self.redis.script_exists(sha))
Пример #21
0
 def setUp(self):
     self.redis = MockRedis()
     self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()
Пример #22
0
 def setUp(self):
     self.redis = MockRedis()
     self.redis.flushdb()
Пример #23
0
    def setUp(self):
        self.redis = MockRedis()
        self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()
        import lua
        self.lua = lua
        self.lua_globals = lua.globals()

        assert_equal_list = """
        function compare_list(list1, list2)
            if #list1 ~= #list2 then
                return false
            end
            for i, item1 in ipairs(list1) do
                if item1 ~= list2[i] then
                    return false
                end
            end
            return true
        end

        function assert_equal_list(list1, list2)
            assert(compare_list(list1, list2))
        end
        return assert_equal_list
        """
        self.lua_assert_equal_list = self.lua.execute(assert_equal_list)

        assert_equal_list_with_pairs = """
        function pair_exists(list1, key, value)
            i = 1
            for i, item1 in ipairs(list1) do
                if i%2 == 1 then
                    if (list1[i] == key) and (list1[i + 1] == value) then
                        return true
                    end
                end
            end
            return false
        end

        function compare_list_with_pairs(list1, list2)
            if #list1 ~= #list2 or #list1 % 2 == 1 then
                return false
            end
            for i = 1, #list1, 2 do
                if not pair_exists(list2, list1[i], list1[i + 1]) then
                    return false
                end
            end
            return true
        end

        function assert_equal_list_with_pairs(list1, list2)
            assert(compare_list_with_pairs(list1, list2))
        end
        return assert_equal_list_with_pairs
        """
        self.lua_assert_equal_list_with_pairs = self.lua.execute(assert_equal_list_with_pairs)

        compare_val = """
        function compare_val(var1, var2)
            return var1 == var2
        end
        return compare_val
        """
        self.lua_compare_val = self.lua.execute(compare_val)