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 setUp(self): self.redis = MockRedis()
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])
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])
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)
def setUp(self): self.redis = MockRedis() self.LPOP_SCRIPT_SHA = sha1(LPOP_SCRIPT).hexdigest()
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))
def setUp(self): self.redis = MockRedis() self.redis.flushdb()
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 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)
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))
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'])
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))
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))
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))
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 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)