Viewing File: /opt/alt/tests/alt-php84-pecl-redis_6.1.0-7.el8/tests/RedisTest.php
<?php defined('PHPREDIS_TESTRUN') or die('Use TestRedis.php to run tests!\n');
require_once __DIR__ . '/TestSuite.php';
require_once __DIR__ . '/SessionHelpers.php';
class Redis_Test extends TestSuite {
/**
* @var Redis
*/
public $redis;
/* City lat/long */
protected $cities = [
'Chico' => [-121.837478, 39.728494],
'Sacramento' => [-121.494400, 38.581572],
'Gridley' => [-121.693583, 39.363777],
'Marysville' => [-121.591355, 39.145725],
'Cupertino' => [-122.032182, 37.322998]
];
protected $serializers = [
Redis::SERIALIZER_NONE,
Redis::SERIALIZER_PHP,
];
protected function getNilValue() {
return FALSE;
}
protected function getSerializers() {
$result = [Redis::SERIALIZER_NONE, Redis::SERIALIZER_PHP];
if (defined('Redis::SERIALIZER_IGBINARY'))
$result[] = Redis::SERIALIZER_IGBINARY;
if (defined('Redis::SERIALIZER_JSON'))
$result[] = Redis::SERIALIZER_JSON;
if (defined('Redis::SERIALIZER_MSGPACK'))
$result[] = Redis::SERIALIZER_MSGPACK;
return $result;
}
protected function getCompressors() {
$result['none'] = Redis::COMPRESSION_NONE;
if (defined('Redis::COMPRESSION_LZF'))
$result['lzf'] = Redis::COMPRESSION_LZF;
if (defined('Redis::COMPRESSION_LZ4'))
$result['lz4'] = Redis::COMPRESSION_LZ4;
if (defined('Redis::COMPRESSION_ZSTD'))
$result['zstd'] = Redis::COMPRESSION_ZSTD;
return $result;
}
/* Overridable left/right constants */
protected function getLeftConstant() {
return Redis::LEFT;
}
protected function getRightConstant() {
return Redis::RIGHT;
}
protected function detectKeyDB(array $info) {
return strpos($info['executable'] ?? '', 'keydb') !== false ||
isset($info['keydb']) ||
isset($info['mvcc_depth']);
}
public function setUp() {
$this->redis = $this->newInstance();
$info = $this->redis->info();
$this->version = (isset($info['redis_version'])?$info['redis_version']:'0.0.0');
$this->is_keydb = $this->detectKeyDB($info);
}
protected function minVersionCheck($version) {
return version_compare($this->version, $version) >= 0;
}
protected function mstime() {
return round(microtime(true)*1000);
}
protected function getAuthParts(&$user, &$pass) {
$user = $pass = NULL;
$auth = $this->getAuth();
if ( ! $auth)
return;
if (is_array($auth)) {
if (count($auth) > 1) {
list($user, $pass) = $auth;
} else {
$pass = $auth[0];
}
} else {
$pass = $auth;
}
}
protected function sessionPrefix(): string {
return 'PHPREDIS_SESSION:';
}
protected function sessionSaveHandler(): string {
return 'redis';
}
protected function sessionSavePath(): string {
return sprintf('tcp://%s:%d?%s', $this->getHost(), $this->getPort(),
$this->getAuthFragment());
}
protected function getAuthFragment() {
$this->getAuthParts($user, $pass);
if ($user && $pass) {
return sprintf('auth[user]=%s&auth[pass]=%s', $user, $pass);
} else if ($pass) {
return sprintf('auth[pass]=%s', $pass);
} else {
return '';
}
}
protected function newInstance() {
$r = new Redis([
'host' => $this->getHost(),
'port' => $this->getPort(),
]);
if ($this->getAuth()) {
$this->assertTrue($r->auth($this->getAuth()));
}
return $r;
}
public function tearDown() {
if ($this->redis) {
$this->redis->close();
}
}
public function reset() {
$this->setUp();
$this->tearDown();
}
/* Helper function to determine if the class has pipeline support */
protected function havePipeline() {
return defined(get_class($this->redis) . '::PIPELINE');
}
protected function haveMulti() {
return defined(get_class($this->redis) . '::MULTI');
}
public function testMinimumVersion() {
$this->assertTrue(version_compare($this->version, '2.4.0') >= 0);
}
public function testPing() {
/* Reply literal off */
$this->assertTrue($this->redis->ping());
$this->assertTrue($this->redis->ping(NULL));
$this->assertEquals('BEEP', $this->redis->ping('BEEP'));
/* Make sure we're good in MULTI mode */
if ($this->haveMulti()) {
$this->assertEquals(
[true, 'BEEP'],
$this->redis->multi()
->ping()
->ping('BEEP')
->exec()
);
}
}
public function testPipelinePublish() {
$ret = $this->redis->pipeline()
->publish('chan', 'msg')
->exec();
$this->assertIsArray($ret, 1);
$this->assertGT(-1, $ret[0] ?? -1);
}
// Run some simple tests against the PUBSUB command. This is problematic, as we
// can't be sure what's going on in the instance, but we can do some things.
public function testPubSub() {
// Only available since 2.8.0
if (version_compare($this->version, '2.8.0') < 0)
$this->markTestSkipped();
// PUBSUB CHANNELS ...
$result = $this->redis->pubsub('channels', '*');
$this->assertIsArray($result);
$result = $this->redis->pubsub('channels');
$this->assertIsArray($result);
// PUBSUB NUMSUB
$c1 = uniqid();
$c2 = uniqid();
$result = $this->redis->pubsub('numsub', [$c1, $c2]);
// Should get an array back, with two elements
$this->assertIsArray($result);
$this->assertEquals(2, count($result));
// Make sure the elements are correct, and have zero counts
foreach ([$c1,$c2] as $channel) {
$this->assertArrayKeyEquals($result, $channel, 0);
}
// PUBSUB NUMPAT
$result = $this->redis->pubsub('numpat');
$this->assertIsInt($result);
// Invalid calls
$this->assertFalse(@$this->redis->pubsub('notacommand'));
$this->assertFalse(@$this->redis->pubsub('numsub', 'not-an-array'));
}
/* These test cases were generated randomly. We're just trying to test
that PhpRedis handles all combination of arguments correctly. */
public function testBitcount() {
/* key */
$this->redis->set('bitcountkey', hex2bin('bd906b854ca76cae'));
$this->assertEquals(33, $this->redis->bitcount('bitcountkey'));
/* key, start */
$this->redis->set('bitcountkey', hex2bin('400aac171382a29bebaab554f178'));
$this->assertEquals(4, $this->redis->bitcount('bitcountkey', 13));
/* key, start, end */
$this->redis->set('bitcountkey', hex2bin('b1f32405'));
$this->assertEquals(2, $this->redis->bitcount('bitcountkey', 3, 3));
/* key, start, end BYTE */
$this->redis->set('bitcountkey', hex2bin('10eb8939e68bfdb640260f0629f3'));
$this->assertEquals(1, $this->redis->bitcount('bitcountkey', 8, 8, false));
if ( ! $this->is_keydb && $this->minVersionCheck('7.0')) {
/* key, start, end, BIT */
$this->redis->set('bitcountkey', hex2bin('cd0e4c80f9e4590d888a10'));
$this->assertEquals(5, $this->redis->bitcount('bitcountkey', 0, 9, true));
}
}
public function testBitop() {
if ( ! $this->minVersionCheck('2.6.0'))
$this->markTestSkipped();
$this->redis->set('{key}1', 'foobar');
$this->redis->set('{key}2', 'abcdef');
// Regression test for GitHub issue #2210
$this->assertEquals(6, $this->redis->bitop('AND', '{key}1', '{key}2'));
// Make sure RedisCluster doesn't even send the command. We don't care
// about what Redis returns
@$this->redis->bitop('AND', 'key1', 'key2', 'key3');
$this->assertNull($this->redis->getLastError());
$this->redis->del('{key}1', '{key}2');
}
public function testBitsets() {
$this->redis->del('key');
$this->assertEquals(0, $this->redis->getBit('key', 0));
$this->assertFalse($this->redis->getBit('key', -1));
$this->assertEquals(0, $this->redis->getBit('key', 100000));
$this->redis->set('key', "\xff");
for ($i = 0; $i < 8; $i++) {
$this->assertEquals(1, $this->redis->getBit('key', $i));
}
$this->assertEquals(0, $this->redis->getBit('key', 8));
// change bit 0
$this->assertEquals(1, $this->redis->setBit('key', 0, 0));
$this->assertEquals(0, $this->redis->setBit('key', 0, 0));
$this->assertEquals(0, $this->redis->getBit('key', 0));
$this->assertKeyEquals("\x7f", 'key');
// change bit 1
$this->assertEquals(1, $this->redis->setBit('key', 1, 0));
$this->assertEquals(0, $this->redis->setBit('key', 1, 0));
$this->assertEquals(0, $this->redis->getBit('key', 1));
$this->assertKeyEquals("\x3f", 'key');
// change bit > 1
$this->assertEquals(1, $this->redis->setBit('key', 2, 0));
$this->assertEquals(0, $this->redis->setBit('key', 2, 0));
$this->assertEquals(0, $this->redis->getBit('key', 2));
$this->assertKeyEquals("\x1f", 'key');
// values above 1 are changed to 1 but don't overflow on bits to the right.
$this->assertEquals(0, $this->redis->setBit('key', 0, 0xff));
$this->assertKeyEquals("\x9f", 'key');
// Verify valid offset ranges
$this->assertFalse($this->redis->getBit('key', -1));
$this->redis->setBit('key', 0x7fffffff, 1);
$this->assertEquals(1, $this->redis->getBit('key', 0x7fffffff));
}
public function testLcs() {
if ( ! $this->minVersionCheck('7.0.0') || $this->is_keydb)
$this->markTestSkipped();
$key1 = '{lcs}1'; $key2 = '{lcs}2';
$this->assertTrue($this->redis->set($key1, '12244447777777'));
$this->assertTrue($this->redis->set($key2, '6666662244441'));
$this->assertEquals('224444', $this->redis->lcs($key1, $key2));
$this->assertEquals(
['matches', [[[1, 6], [6, 11]]], 'len', 6],
$this->redis->lcs($key1, $key2, ['idx'])
);
$this->assertEquals(
['matches', [[[1, 6], [6, 11], 6]], 'len', 6],
$this->redis->lcs($key1, $key2, ['idx', 'withmatchlen'])
);
$this->assertEquals(6, $this->redis->lcs($key1, $key2, ['len']));
$this->redis->del([$key1, $key2]);
}
public function testLmpop() {
if (version_compare($this->version, '7.0.0') < 0)
$this->markTestSkipped();
$key1 = '{l}1';
$key2 = '{l}2';
$this->redis->del($key1, $key2);
$this->assertEquals(6, $this->redis->rpush($key1, 'A', 'B', 'C', 'D', 'E', 'F'));
$this->assertEquals(6, $this->redis->rpush($key2, 'F', 'E', 'D', 'C', 'B', 'A'));
$this->assertEquals([$key1, ['A']], $this->redis->lmpop([$key1, $key2], 'LEFT'));
$this->assertEquals([$key1, ['F']], $this->redis->lmpop([$key1, $key2], 'RIGHT'));
$this->assertEquals([$key1, ['B', 'C', 'D']], $this->redis->lmpop([$key1, $key2], 'LEFT', 3));
$this->assertEquals(2, $this->redis->del($key1, $key2));
}
public function testBLmpop() {
if (version_compare($this->version, '7.0.0') < 0)
$this->markTestSkipped();
$key1 = '{bl}1';
$key2 = '{bl}2';
$this->redis->del($key1, $key2);
$this->assertEquals(2, $this->redis->rpush($key1, 'A', 'B'));
$this->assertEquals(2, $this->redis->rpush($key2, 'C', 'D'));
$this->assertEquals([$key1, ['B', 'A']], $this->redis->blmpop(.2, [$key1, $key2], 'RIGHT', 2));
$this->assertEquals([$key2, ['C']], $this->redis->blmpop(.2, [$key1, $key2], 'LEFT'));
$this->assertEquals([$key2, ['D']], $this->redis->blmpop(.2, [$key1, $key2], 'LEFT'));
$st = microtime(true);
$this->assertFalse($this->redis->blmpop(.2, [$key1, $key2], 'LEFT'));
$et = microtime(true);
// Very loose tolerance because CI is run on a potato
$this->assertBetween($et - $st, .05, .75);
}
function testZmpop() {
if (version_compare($this->version, '7.0.0') < 0)
$this->markTestSkipped();
$key1 = '{z}1';
$key2 = '{z}2';
$this->redis->del($key1, $key2);
$this->assertEquals(4, $this->redis->zadd($key1, 0, 'zero', 2, 'two', 4, 'four', 6, 'six'));
$this->assertEquals(4, $this->redis->zadd($key2, 1, 'one', 3, 'three', 5, 'five', 7, 'seven'));
$this->assertEquals([$key1, ['zero' => 0.0]], $this->redis->zmpop([$key1, $key2], 'MIN'));
$this->assertEquals([$key1, ['six' => 6.0]], $this->redis->zmpop([$key1, $key2], 'MAX'));
$this->assertEquals([$key1, ['two' => 2.0, 'four' => 4.0]], $this->redis->zmpop([$key1, $key2], 'MIN', 3));
$this->assertEquals(
[$key2, ['one' => 1.0, 'three' => 3.0, 'five' => 5.0, 'seven' => 7.0]],
$this->redis->zmpop([$key1, $key2], 'MIN', 128)
);
$this->assertFalse($this->redis->zmpop([$key1, $key2], 'MIN'));
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, true);
$this->assertNull($this->redis->zmpop([$key1, $key2], 'MIN'));
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, false);
}
function testBZmpop() {
if (version_compare($this->version, '7.0.0') < 0)
$this->markTestSkipped();
$key1 = '{z}1';
$key2 = '{z}2';
$this->redis->del($key1, $key2);
$this->assertEquals(2, $this->redis->zadd($key1, 0, 'zero', 2, 'two'));
$this->assertEquals(2, $this->redis->zadd($key2, 1, 'one', 3, 'three'));
$this->assertEquals(
[$key1, ['zero' => 0.0, 'two' => 2.0]],
$this->redis->bzmpop(.1, [$key1, $key2], 'MIN', 2)
);
$this->assertEquals([$key2, ['three' => 3.0]], $this->redis->bzmpop(.1, [$key1, $key2], 'MAX'));
$this->assertEquals([$key2, ['one' => 1.0]], $this->redis->bzmpop(.1, [$key1, $key2], 'MAX'));
$st = microtime(true);
$this->assertFalse($this->redis->bzmpop(.2, [$key1, $key2], 'MIN'));
$et = microtime(true);
$this->assertBetween($et - $st, .05, .75);
}
public function testBitPos() {
if (version_compare($this->version, '2.8.7') < 0) {
$this->MarkTestSkipped();
return;
}
$this->redis->del('bpkey');
$this->redis->set('bpkey', "\xff\xf0\x00");
$this->assertEquals(12, $this->redis->bitpos('bpkey', 0));
$this->redis->set('bpkey', "\x00\xff\xf0");
$this->assertEquals(8, $this->redis->bitpos('bpkey', 1, 0));
$this->assertEquals(8, $this->redis->bitpos('bpkey', 1, 1));
$this->redis->set('bpkey', "\x00\x00\x00");
$this->assertEquals(-1, $this->redis->bitpos('bpkey', 1));
if ( ! $this->minVersionCheck('7.0.0'))
return;
$this->redis->set('bpkey', "\xF");
$this->assertEquals(4, $this->redis->bitpos('bpkey', 1, 0, -1, true));
$this->assertEquals(-1, $this->redis->bitpos('bpkey', 1, 1, -1));
$this->assertEquals(-1, $this->redis->bitpos('bpkey', 1, 1, -1, false));
}
public function testSetLargeKeys() {
foreach ([1000, 100000, 1000000] as $size) {
$value = str_repeat('A', $size);
$this->assertTrue($this->redis->set('x', $value));
$this->assertKeyEquals($value, 'x');
}
}
public function testEcho() {
$this->assertEquals('hello', $this->redis->echo('hello'));
$this->assertEquals('', $this->redis->echo(''));
$this->assertEquals(' 0123 ', $this->redis->echo(' 0123 '));
}
public function testErr() {
$this->redis->set('x', '-ERR');
$this->assertKeyEquals('-ERR', 'x');
}
public function testSet() {
$this->assertTrue($this->redis->set('key', 'nil'));
$this->assertKeyEquals('nil', 'key');
$this->assertTrue($this->redis->set('key', 'val'));
$this->assertKeyEquals('val', 'key');
$this->assertKeyEquals('val', 'key');
$this->redis->del('keyNotExist');
$this->assertKeyMissing('keyNotExist');
$this->redis->set('key2', 'val');
$this->assertKeyEquals('val', 'key2');
$value1 = bin2hex(random_bytes(rand(64, 128)));
$value2 = random_bytes(rand(65536, 65536 * 2));;
$this->redis->set('key2', $value1);
$this->assertKeyEquals($value1, 'key2');
$this->assertKeyEquals($value1, 'key2');
$this->redis->del('key');
$this->redis->del('key2');
$this->redis->set('key', $value2);
$this->assertKeyEquals($value2, 'key');
$this->redis->del('key');
$this->assertKeyMissing('key');
$data = gzcompress('42');
$this->assertTrue($this->redis->set('key', $data));
$this->assertEquals('42', gzuncompress($this->redis->get('key')));
$this->redis->del('key');
$data = gzcompress('value1');
$this->assertTrue($this->redis->set('key', $data));
$this->assertEquals('value1', gzuncompress($this->redis->get('key')));
$this->redis->del('key');
$this->assertTrue($this->redis->set('key', 0));
$this->assertKeyEquals('0', 'key');
$this->assertTrue($this->redis->set('key', 1));
$this->assertKeyEquals('1', 'key');
$this->assertTrue($this->redis->set('key', 0.1));
$this->assertKeyEquals('0.1', 'key');
$this->assertTrue($this->redis->set('key', '0.1'));
$this->assertKeyEquals('0.1', 'key');
$this->assertTrue($this->redis->set('key', true));
$this->assertKeyEquals('1', 'key');
$this->assertTrue($this->redis->set('key', ''));
$this->assertKeyEquals('', 'key');
$this->assertTrue($this->redis->set('key', NULL));
$this->assertKeyEquals('', 'key');
$this->assertTrue($this->redis->set('key', gzcompress('42')));
$this->assertEquals('42', gzuncompress($this->redis->get('key')));
}
/* Extended SET options for Redis >= 2.6.12 */
public function testExtendedSet() {
// Skip the test if we don't have a new enough version of Redis
if (version_compare($this->version, '2.6.12') < 0)
$this->markTestSkipped();
/* Legacy SETEX redirection */
$this->redis->del('foo');
$this->assertTrue($this->redis->set('foo', 'bar', 20));
$this->assertKeyEquals('bar', 'foo');
$this->assertEquals(20, $this->redis->ttl('foo'));
/* Should coerce doubles into long */
$this->assertTrue($this->redis->set('foo', 'bar-20.5', 20.5));
$this->assertEquals(20, $this->redis->ttl('foo'));
$this->assertKeyEquals('bar-20.5', 'foo');
/* Invalid third arguments */
$this->assertFalse(@$this->redis->set('foo', 'bar', 'baz'));
$this->assertFalse(@$this->redis->set('foo', 'bar',new StdClass()));
/* Set if not exist */
$this->redis->del('foo');
$this->assertTrue($this->redis->set('foo', 'bar', ['nx']));
$this->assertKeyEquals('bar', 'foo');
$this->assertFalse($this->redis->set('foo', 'bar', ['nx']));
/* Set if exists */
$this->assertTrue($this->redis->set('foo', 'bar', ['xx']));
$this->assertKeyEquals('bar', 'foo');
$this->redis->del('foo');
$this->assertFalse($this->redis->set('foo', 'bar', ['xx']));
/* Set with a TTL */
$this->assertTrue($this->redis->set('foo', 'bar', ['ex' => 100]));
$this->assertEquals(100, $this->redis->ttl('foo'));
/* Set with a PTTL */
$this->assertTrue($this->redis->set('foo', 'bar', ['px' => 100000]));
$this->assertBetween($this->redis->pttl('foo'), 99000, 100001);
/* Set if exists, with a TTL */
$this->assertTrue($this->redis->set('foo', 'bar', ['xx', 'ex' => 105]));
$this->assertEquals(105, $this->redis->ttl('foo'));
$this->assertKeyEquals('bar', 'foo');
/* Set if not exists, with a TTL */
$this->redis->del('foo');
$this->assertTrue($this->redis->set('foo', 'bar', ['nx', 'ex' => 110]));
$this->assertEquals(110, $this->redis->ttl('foo'));
$this->assertKeyEquals('bar', 'foo');
$this->assertFalse($this->redis->set('foo', 'bar', ['nx', 'ex' => 110]));
/* Throw some nonsense into the array, and check that the TTL came through */
$this->redis->del('foo');
$this->assertTrue($this->redis->set('foo', 'barbaz', ['not-valid', 'nx', 'invalid', 'ex' => 200]));
$this->assertEquals(200, $this->redis->ttl('foo'));
$this->assertKeyEquals('barbaz', 'foo');
/* Pass NULL as the optional arguments which should be ignored */
$this->redis->del('foo');
$this->redis->set('foo', 'bar', NULL);
$this->assertKeyEquals('bar', 'foo');
$this->assertLT(0, $this->redis->ttl('foo'));
/* Make sure we ignore bad/non-string options (regression test for #1835) */
$this->assertTrue($this->redis->set('foo', 'bar', [NULL, 'EX' => 60]));
$this->assertTrue($this->redis->set('foo', 'bar', [NULL, new stdClass(), 'EX' => 60]));
$this->assertFalse(@$this->redis->set('foo', 'bar', [NULL, 'EX' => []]));
if (version_compare($this->version, '6.0.0') < 0)
return;
/* KEEPTTL works by itself */
$this->redis->set('foo', 'bar', ['EX' => 100]);
$this->redis->set('foo', 'bar', ['KEEPTTL']);
$this->assertBetween($this->redis->ttl('foo'), 90, 100);
/* Works with other options */
$this->redis->set('foo', 'bar', ['XX', 'KEEPTTL']);
$this->assertBetween($this->redis->ttl('foo'), 90, 100);
$this->redis->set('foo', 'bar', ['XX']);
$this->assertEquals(-1, $this->redis->ttl('foo'));
if (version_compare($this->version, '6.2.0') < 0)
return;
$this->assertEquals('bar', $this->redis->set('foo', 'baz', ['GET']));
}
public function testGetSet() {
$this->redis->del('key');
$this->assertFalse($this->redis->getSet('key', '42'));
$this->assertEquals('42', $this->redis->getSet('key', '123'));
$this->assertEquals('123', $this->redis->getSet('key', '123'));
}
public function testRandomKey() {
for ($i = 0; $i < 1000; $i++) {
$k = $this->redis->randomKey();
$this->assertKeyExists($k);
}
}
public function testRename() {
// strings
$this->redis->del('{key}0');
$this->redis->set('{key}0', 'val0');
$this->redis->rename('{key}0', '{key}1');
$this->assertKeyMissing('{key}0');
$this->assertKeyEquals('val0', '{key}1');
}
public function testRenameNx() {
// strings
$this->redis->del('{key}0', '{key}1');
$this->redis->set('{key}0', 'val0');
$this->redis->set('{key}1', 'val1');
$this->assertFalse($this->redis->renameNx('{key}0', '{key}1'));
$this->assertKeyEquals('val0', '{key}0');
$this->assertKeyEquals('val1', '{key}1');
// lists
$this->redis->del('{key}0');
$this->redis->del('{key}1');
$this->redis->lPush('{key}0', 'val0');
$this->redis->lPush('{key}0', 'val1');
$this->redis->lPush('{key}1', 'val1-0');
$this->redis->lPush('{key}1', 'val1-1');
$this->assertFalse($this->redis->renameNx('{key}0', '{key}1'));
$this->assertEquals(['val1', 'val0'], $this->redis->lRange('{key}0', 0, -1));
$this->assertEquals(['val1-1', 'val1-0'], $this->redis->lRange('{key}1', 0, -1));
$this->redis->del('{key}2');
$this->assertTrue($this->redis->renameNx('{key}0', '{key}2'));
$this->assertEquals([], $this->redis->lRange('{key}0', 0, -1));
$this->assertEquals(['val1', 'val0'], $this->redis->lRange('{key}2', 0, -1));
}
public function testMultiple() {
$kvals = [
'mget1' => 'v1',
'mget2' => 'v2',
'mget3' => 'v3'
];
$this->redis->mset($kvals);
$this->redis->set(1, 'test');
$this->assertEquals([$kvals['mget1']], $this->redis->mget(['mget1']));
$this->assertEquals(['v1', 'v2', false], $this->redis->mget(['mget1', 'mget2', 'NoKey']));
$this->assertEquals(['v1', 'v2', 'v3'], $this->redis->mget(['mget1', 'mget2', 'mget3']));
$this->assertEquals(['v1', 'v2', 'v3'], $this->redis->mget(['mget1', 'mget2', 'mget3']));
$this->redis->set('k5', '$1111111111');
$this->assertEquals(['$1111111111'], $this->redis->mget(['k5']));
$this->assertEquals(['test'], $this->redis->mget([1])); // non-string
}
public function testMultipleBin() {
$kvals = [
'binkey-1' => random_bytes(16),
'binkey-2' => random_bytes(16),
'binkey-3' => random_bytes(16),
];
foreach ($kvals as $k => $v) {
$this->redis->set($k, $v);
}
$this->assertEquals(array_values($kvals),
$this->redis->mget(array_keys($kvals)));
}
public function testExpire() {
$this->redis->del('key');
$this->redis->set('key', 'value');
$this->assertKeyEquals('value', 'key');
$this->redis->expire('key', 1);
$this->assertKeyEquals('value', 'key');
sleep(2);
$this->assertKeyMissing('key');
}
/* This test is prone to failure in the Travis container, so attempt to
mitigate this by running more than once */
public function testExpireAt() {
$success = false;
for ($i = 0; !$success && $i < 3; $i++) {
$this->redis->del('key');
$this->redis->set('key', 'value');
$this->redis->expireAt('key', time() + 1);
usleep(1500000);
$success = FALSE === $this->redis->get('key');
}
$this->assertTrue($success);
}
function testExpireOptions() {
if ( ! $this->minVersionCheck('7.0.0'))
$this->markTestSkipped();
$this->redis->set('eopts', 'value');
/* NX -- Only if expiry isn't set so success, then failure */
$this->assertTrue($this->redis->expire('eopts', 1000, 'NX'));
$this->assertFalse($this->redis->expire('eopts', 1000, 'NX'));
/* XX -- Only set if the key has an existing expiry */
$this->assertTrue($this->redis->expire('eopts', 1000, 'XX'));
$this->assertTrue($this->redis->persist('eopts'));
$this->assertFalse($this->redis->expire('eopts', 1000, 'XX'));
/* GT -- Only set when new expiry > current expiry */
$this->assertTrue($this->redis->expire('eopts', 200));
$this->assertTrue($this->redis->expire('eopts', 300, 'GT'));
$this->assertFalse($this->redis->expire('eopts', 100, 'GT'));
/* LT -- Only set when expiry < current expiry */
$this->assertTrue($this->redis->expire('eopts', 200));
$this->assertTrue($this->redis->expire('eopts', 100, 'LT'));
$this->assertFalse($this->redis->expire('eopts', 300, 'LT'));
/* Sending a nonsensical mode fails without sending a command */
$this->redis->clearLastError();
$this->assertFalse(@$this->redis->expire('eopts', 999, 'nonsense'));
$this->assertNull($this->redis->getLastError());
$this->redis->del('eopts');
}
public function testExpiretime() {
if (version_compare($this->version, '7.0.0') < 0)
$this->markTestSkipped();
$now = time();
$this->assertTrue($this->redis->set('key1', 'value'));
$this->assertTrue($this->redis->expireat('key1', $now + 10));
$this->assertEquals($now + 10, $this->redis->expiretime('key1'));
$this->assertEquals(1000 * ($now + 10), $this->redis->pexpiretime('key1'));
$this->redis->del('key1');
}
public function testGetEx() {
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->assertTrue($this->redis->set('key', 'value'));
$this->assertEquals('value', $this->redis->getEx('key', ['EX' => 100]));
$this->assertBetween($this->redis->ttl('key'), 95, 100);
$this->assertEquals('value', $this->redis->getEx('key', ['PX' => 100000]));
$this->assertBetween($this->redis->pttl('key'), 95000, 100000);
$this->assertEquals('value', $this->redis->getEx('key', ['EXAT' => time() + 200]));
$this->assertBetween($this->redis->ttl('key'), 195, 200);
$this->assertEquals('value', $this->redis->getEx('key', ['PXAT' => (time()*1000) + 25000]));
$this->assertBetween($this->redis->pttl('key'), 24000, 25000);
$this->assertEquals('value', $this->redis->getEx('key', ['PERSIST' => true]));
$this->assertEquals(-1, $this->redis->ttl('key'));
$this->assertTrue($this->redis->expire('key', 100));
$this->assertBetween($this->redis->ttl('key'), 95, 100);
$this->assertEquals('value', $this->redis->getEx('key', ['PERSIST']));
$this->assertEquals(-1, $this->redis->ttl('key'));
}
public function testSetEx() {
$this->redis->del('key');
$this->assertTrue($this->redis->setex('key', 7, 'val'));
$this->assertEquals(7, $this->redis->ttl('key'));
$this->assertKeyEquals('val', 'key');
}
public function testPSetEx() {
$this->redis->del('key');
$this->assertTrue($this->redis->psetex('key', 7 * 1000, 'val'));
$this->assertEquals(7, $this->redis->ttl('key'));
$this->assertKeyEquals('val', 'key');
}
public function testSetNX() {
$this->redis->set('key', 42);
$this->assertFalse($this->redis->setnx('key', 'err'));
$this->assertKeyEquals('42', 'key');
$this->redis->del('key');
$this->assertTrue($this->redis->setnx('key', '42'));
$this->assertKeyEquals('42', 'key');
}
public function testExpireAtWithLong() {
if (PHP_INT_SIZE != 8)
$this->markTestSkipped('64 bits only');
$large_expiry = 3153600000;
$this->redis->del('key');
$this->assertTrue($this->redis->setex('key', $large_expiry, 'val'));
$this->assertEquals($large_expiry, $this->redis->ttl('key'));
}
public function testIncr() {
$this->redis->set('key', 0);
$this->redis->incr('key');
$this->assertKeyEqualsWeak(1, 'key');
$this->redis->incr('key');
$this->assertKeyEqualsWeak(2, 'key');
$this->redis->incrBy('key', 3);
$this->assertKeyEqualsWeak(5, 'key');
$this->redis->incrBy('key', 1);
$this->assertKeyEqualsWeak(6, 'key');
$this->redis->incrBy('key', -1);
$this->assertKeyEqualsWeak(5, 'key');
$this->redis->incr('key', 5);
$this->assertKeyEqualsWeak(10, 'key');
$this->redis->del('key');
$this->redis->set('key', 'abc');
$this->redis->incr('key');
$this->assertKeyEquals('abc', 'key');
$this->redis->incr('key');
$this->assertKeyEquals('abc', 'key');
$this->redis->set('key', 0);
$this->assertEquals(PHP_INT_MAX, $this->redis->incrby('key', PHP_INT_MAX));
}
public function testIncrByFloat() {
// incrbyfloat is new in 2.6.0
if (version_compare($this->version, '2.5.0') < 0)
$this->markTestSkipped();
$this->redis->del('key');
$this->redis->set('key', 0);
$this->redis->incrbyfloat('key', 1.5);
$this->assertKeyEquals('1.5', 'key');
$this->redis->incrbyfloat('key', 2.25);
$this->assertKeyEquals('3.75', 'key');
$this->redis->incrbyfloat('key', -2.25);
$this->assertKeyEquals('1.5', 'key');
$this->redis->set('key', 'abc');
$this->redis->incrbyfloat('key', 1.5);
$this->assertKeyEquals('abc', 'key');
$this->redis->incrbyfloat('key', -1.5);
$this->assertKeyEquals('abc', 'key');
// Test with prefixing
$this->redis->setOption(Redis::OPT_PREFIX, 'someprefix:');
$this->redis->del('key');
$this->redis->incrbyfloat('key',1.8);
$this->assertKeyEqualsWeak(1.8, 'key');
$this->redis->setOption(Redis::OPT_PREFIX, '');
$this->assertKeyExists('someprefix:key');
$this->redis->del('someprefix:key');
}
public function testDecr() {
$this->redis->set('key', 5);
$this->redis->decr('key');
$this->assertKeyEqualsWeak(4, 'key');
$this->redis->decr('key');
$this->assertKeyEqualsWeak(3, 'key');
$this->redis->decrBy('key', 2);
$this->assertKeyEqualsWeak(1, 'key');
$this->redis->decrBy('key', 1);
$this->assertKeyEqualsWeak(0, 'key');
$this->redis->decrBy('key', -10);
$this->assertKeyEqualsWeak(10, 'key');
$this->redis->decr('key', 10);
$this->assertKeyEqualsWeak(0, 'key');
}
public function testExists() {
/* Single key */
$this->redis->del('key');
$this->assertKeyMissing('key');
$this->redis->set('key', 'val');
$this->assertKeyExists('key');
/* Add multiple keys */
$mkeys = [];
for ($i = 0; $i < 10; $i++) {
if (rand(1, 2) == 1) {
$mkey = "{exists}key:$i";
$this->redis->set($mkey, $i);
$mkeys[] = $mkey;
}
}
/* Test passing an array as well as the keys variadic */
$this->assertEquals(count($mkeys), $this->redis->exists($mkeys));
if (count($mkeys))
$this->assertEquals(count($mkeys), $this->redis->exists(...$mkeys));
}
public function testTouch() {
if ( ! $this->minVersionCheck('3.2.1'))
$this->markTestSkipped();
$this->redis->del('notakey');
$this->assertTrue($this->redis->mset(['{idle}1' => 'beep', '{idle}2' => 'boop']));
usleep(1100000);
$this->assertGT(0, $this->redis->object('idletime', '{idle}1'));
$this->assertGT(0, $this->redis->object('idletime', '{idle}2'));
$this->assertEquals(2, $this->redis->touch('{idle}1', '{idle}2', '{idle}notakey'));
$idle1 = $this->redis->object('idletime', '{idle}1');
$idle2 = $this->redis->object('idletime', '{idle}2');
/* We're not testing if idle is 0 because CPU scheduling on GitHub CI
* potatoes can cause that to erroneously fail. */
$this->assertLT(2, $idle1);
$this->assertLT(2, $idle2);
}
public function testKeys() {
$pattern = 'keys-test-';
for ($i = 1; $i < 10; $i++) {
$this->redis->set($pattern.$i, $i);
}
$this->redis->del($pattern.'3');
$keys = $this->redis->keys($pattern.'*');
$this->redis->set($pattern.'3', 'something');
$keys2 = $this->redis->keys($pattern.'*');
$this->assertEquals((count($keys) + 1), count($keys2));
// empty array when no key matches
$this->assertEquals([], $this->redis->keys(uniqid() . '*'));
}
protected function genericDelUnlink($cmd) {
$key = uniqid('key:');
$this->redis->set($key, 'val');
$this->assertKeyEquals('val', $key);
$this->assertEquals(1, $this->redis->$cmd($key));
$this->assertFalse($this->redis->get($key));
// multiple, all existing
$this->redis->set('x', 0);
$this->redis->set('y', 1);
$this->redis->set('z', 2);
$this->assertEquals(3, $this->redis->$cmd('x', 'y', 'z'));
$this->assertFalse($this->redis->get('x'));
$this->assertFalse($this->redis->get('y'));
$this->assertFalse($this->redis->get('z'));
// multiple, none existing
$this->assertEquals(0, $this->redis->$cmd('x', 'y', 'z'));
$this->assertFalse($this->redis->get('x'));
$this->assertFalse($this->redis->get('y'));
$this->assertFalse($this->redis->get('z'));
// multiple, some existing
$this->redis->set('y', 1);
$this->assertEquals(1, $this->redis->$cmd('x', 'y', 'z'));
$this->assertFalse($this->redis->get('y'));
$this->redis->set('x', 0);
$this->redis->set('y', 1);
$this->assertEquals(2, $this->redis->$cmd(['x', 'y']));
}
public function testDelete() {
$this->genericDelUnlink('DEL');
}
public function testUnlink() {
if (version_compare($this->version, '4.0.0') < 0)
$this->markTestSkipped();
$this->genericDelUnlink('UNLINK');
}
public function testType() {
// string
$this->redis->set('key', 'val');
$this->assertEquals(Redis::REDIS_STRING, $this->redis->type('key'));
// list
$this->redis->lPush('keyList', 'val0');
$this->redis->lPush('keyList', 'val1');
$this->assertEquals(Redis::REDIS_LIST, $this->redis->type('keyList'));
// set
$this->redis->del('keySet');
$this->redis->sAdd('keySet', 'val0');
$this->redis->sAdd('keySet', 'val1');
$this->assertEquals(Redis::REDIS_SET, $this->redis->type('keySet'));
// sadd with numeric key
$this->redis->del(123);
$this->assertEquals(1, $this->redis->sAdd(123, 'val0'));
$this->assertEquals(['val0'], $this->redis->sMembers(123));
// zset
$this->redis->del('keyZSet');
$this->redis->zAdd('keyZSet', 0, 'val0');
$this->redis->zAdd('keyZSet', 1, 'val1');
$this->assertEquals(Redis::REDIS_ZSET, $this->redis->type('keyZSet'));
// hash
$this->redis->del('keyHash');
$this->redis->hSet('keyHash', 'key0', 'val0');
$this->redis->hSet('keyHash', 'key1', 'val1');
$this->assertEquals(Redis::REDIS_HASH, $this->redis->type('keyHash'));
// stream
if ($this->minVersionCheck('5.0')) {
$this->redis->del('stream');
$this->redis->xAdd('stream', '*', ['foo' => 'bar']);
$this->assertEquals(Redis::REDIS_STREAM, $this->redis->type('stream'));
}
// None
$this->redis->del('keyNotExists');
$this->assertEquals(Redis::REDIS_NOT_FOUND, $this->redis->type('keyNotExists'));
}
public function testStr() {
$this->redis->set('key', 'val1');
$this->assertEquals(8, $this->redis->append('key', 'val2'));
$this->assertKeyEquals('val1val2', 'key');
$this->redis->del('keyNotExist');
$this->assertEquals(5, $this->redis->append('keyNotExist', 'value'));
$this->assertKeyEquals('value', 'keyNotExist');
$this->redis->set('key', 'This is a string') ;
$this->assertEquals('This', $this->redis->getRange('key', 0, 3));
$this->assertEquals('string', $this->redis->getRange('key', -6, -1));
$this->assertEquals('string', $this->redis->getRange('key', -6, 100000));
$this->assertKeyEquals('This is a string', 'key');
$this->redis->set('key', 'This is a string') ;
$this->assertEquals(16, $this->redis->strlen('key'));
$this->redis->set('key', 10) ;
$this->assertEquals(2, $this->redis->strlen('key'));
$this->redis->set('key', '') ;
$this->assertEquals(0, $this->redis->strlen('key'));
$this->redis->set('key', '000') ;
$this->assertEquals(3, $this->redis->strlen('key'));
}
public function testlPop() {
$this->redis->del('list');
$this->redis->lPush('list', 'val');
$this->redis->lPush('list', 'val2');
$this->redis->rPush('list', 'val3');
$this->assertEquals('val2', $this->redis->lPop('list'));
if (version_compare($this->version, '6.2.0') < 0) {
$this->assertEquals('val', $this->redis->lPop('list'));
$this->assertEquals('val3', $this->redis->lPop('list'));
} else {
$this->assertEquals(['val', 'val3'], $this->redis->lPop('list', 2));
}
$this->assertFalse($this->redis->lPop('list'));
$this->redis->del('list');
$this->assertEquals(1, $this->redis->lPush('list', gzcompress('val1')));
$this->assertEquals(2, $this->redis->lPush('list', gzcompress('val2')));
$this->assertEquals(3, $this->redis->lPush('list', gzcompress('val3')));
$this->assertEquals('val3', gzuncompress($this->redis->lPop('list')));
$this->assertEquals('val2', gzuncompress($this->redis->lPop('list')));
$this->assertEquals('val1', gzuncompress($this->redis->lPop('list')));
}
public function testrPop() {
$this->redis->del('list');
$this->redis->rPush('list', 'val');
$this->redis->rPush('list', 'val2');
$this->redis->lPush('list', 'val3');
$this->assertEquals('val2', $this->redis->rPop('list'));
if (version_compare($this->version, '6.2.0') < 0) {
$this->assertEquals('val', $this->redis->rPop('list'));
$this->assertEquals('val3', $this->redis->rPop('list'));
} else {
$this->assertEquals(['val', 'val3'], $this->redis->rPop('list', 2));
}
$this->assertFalse($this->redis->rPop('list'));
$this->redis->del('list');
$this->assertEquals(1, $this->redis->rPush('list', gzcompress('val1')));
$this->assertEquals(2, $this->redis->rPush('list', gzcompress('val2')));
$this->assertEquals(3, $this->redis->rPush('list', gzcompress('val3')));
$this->assertEquals('val3', gzuncompress($this->redis->rPop('list')));
$this->assertEquals('val2', gzuncompress($this->redis->rPop('list')));
$this->assertEquals('val1', gzuncompress($this->redis->rPop('list')));
}
/* Regression test for GH #2329 */
public function testrPopSerialization() {
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
$this->redis->del('rpopkey');
$this->redis->rpush('rpopkey', ['foo'], ['bar']);
$this->assertEquals([['bar'], ['foo']], $this->redis->rpop('rpopkey', 2));
$this->redis->rpush('rpopkey', ['foo'], ['bar']);
$this->assertEquals([['foo'], ['bar']], $this->redis->lpop('rpopkey', 2));
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
}
public function testblockingPop() {
/* Test with a double timeout in Redis >= 6.0.0 */
if (version_compare($this->version, '6.0.0') >= 0) {
$this->redis->del('list');
$this->redis->lpush('list', 'val1', 'val2');
$this->assertEquals(['list', 'val2'], $this->redis->blpop(['list'], .1));
$this->assertEquals(['list', 'val1'], $this->redis->blpop(['list'], .1));
}
// non blocking blPop, brPop
$this->redis->del('list');
$this->redis->lPush('list', 'val1', 'val2');
$this->assertEquals(['list', 'val2'], $this->redis->blPop(['list'], 2));
$this->assertEquals(['list', 'val1'], $this->redis->blPop(['list'], 2));
$this->redis->del('list');
$this->redis->lPush('list', 'val1', 'val2');
$this->assertEquals(['list', 'val1'], $this->redis->brPop(['list'], 1));
$this->assertEquals(['list', 'val2'], $this->redis->brPop(['list'], 1));
// blocking blpop, brpop
$this->redis->del('list');
/* Also test our option that we want *-1 to be returned as NULL */
foreach ([false => [], true => NULL] as $opt => $val) {
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, $opt);
$this->assertEquals($val, $this->redis->blPop(['list'], 1));
$this->assertEquals($val, $this->redis->brPop(['list'], 1));
}
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, false);
}
public function testLLen() {
$this->redis->del('list');
$this->redis->lPush('list', 'val');
$this->assertEquals(1, $this->redis->llen('list'));
$this->redis->lPush('list', 'val2');
$this->assertEquals(2, $this->redis->llen('list'));
$this->assertEquals('val2', $this->redis->lPop('list'));
$this->assertEquals(1, $this->redis->llen('list'));
$this->assertEquals('val', $this->redis->lPop('list'));
$this->assertEquals(0, $this->redis->llen('list'));
$this->assertFalse($this->redis->lPop('list'));
$this->assertEquals(0, $this->redis->llen('list')); // empty returns 0
$this->redis->del('list');
$this->assertEquals(0, $this->redis->llen('list')); // non-existent returns 0
$this->redis->set('list', 'actually not a list');
$this->assertFalse($this->redis->llen('list'));// not a list returns FALSE
}
public function testlPopx() {
$this->redis->del('keyNotExists');
$this->assertEquals(0, $this->redis->lPushx('keyNotExists', 'value'));
$this->assertEquals(0, $this->redis->rPushx('keyNotExists', 'value'));
$this->redis->del('key');
$this->redis->lPush('key', 'val0');
$this->assertEquals(2, $this->redis->lPushx('key', 'val1'));
$this->assertEquals(3, $this->redis->rPushx('key', 'val2'));
$this->assertEquals(['val1', 'val0', 'val2'], $this->redis->lrange('key', 0, -1));
//test linsert
$this->redis->del('key');
$this->redis->lPush('key', 'val0');
$this->assertEquals(0, $this->redis->lInsert('keyNotExists', Redis::AFTER, 'val1', 'val2'));
$this->assertEquals(-1, $this->redis->lInsert('key', Redis::BEFORE, 'valX', 'val2'));
$this->assertEquals(2, $this->redis->lInsert('key', Redis::AFTER, 'val0', 'val1'));
$this->assertEquals(3, $this->redis->lInsert('key', Redis::BEFORE, 'val0', 'val2'));
$this->assertEquals(['val2', 'val0', 'val1'], $this->redis->lrange('key', 0, -1));
}
public function testlPos() {
$this->redis->del('key');
$this->redis->lPush('key', 'val0', 'val1', 'val1');
$this->assertEquals(2, $this->redis->lPos('key', 'val0'));
$this->assertEquals(0, $this->redis->lPos('key', 'val1'));
$this->assertEquals(1, $this->redis->lPos('key', 'val1', ['rank' => 2]));
$this->assertEquals([0, 1], $this->redis->lPos('key', 'val1', ['count' => 2]));
$this->assertEquals([0], $this->redis->lPos('key', 'val1', ['count' => 2, 'maxlen' => 1]));
$this->assertEquals([], $this->redis->lPos('key', 'val2', ['count' => 1]));
foreach ([[true, NULL], [false, false]] as $optpack) {
list ($setting, $expected) = $optpack;
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, $setting);
$this->assertEquals($expected, $this->redis->lPos('key', 'val2'));
}
}
// ltrim, lLen, lpop
public function testltrim() {
$this->redis->del('list');
$this->redis->lPush('list', 'val');
$this->redis->lPush('list', 'val2');
$this->redis->lPush('list', 'val3');
$this->redis->lPush('list', 'val4');
$this->assertTrue($this->redis->ltrim('list', 0, 2));
$this->assertEquals(3, $this->redis->llen('list'));
$this->redis->ltrim('list', 0, 0);
$this->assertEquals(1, $this->redis->llen('list'));
$this->assertEquals('val4', $this->redis->lPop('list'));
$this->assertTrue($this->redis->ltrim('list', 10, 10000));
$this->assertTrue($this->redis->ltrim('list', 10000, 10));
// test invalid type
$this->redis->set('list', 'not a list...');
$this->assertFalse($this->redis->ltrim('list', 0, 2));
}
public function setupSort() {
// people with name, age, salary
$this->redis->set('person:name_1', 'Alice');
$this->redis->set('person:age_1', 27);
$this->redis->set('person:salary_1', 2500);
$this->redis->set('person:name_2', 'Bob');
$this->redis->set('person:age_2', 34);
$this->redis->set('person:salary_2', 2000);
$this->redis->set('person:name_3', 'Carol');
$this->redis->set('person:age_3', 25);
$this->redis->set('person:salary_3', 2800);
$this->redis->set('person:name_4', 'Dave');
$this->redis->set('person:age_4', 41);
$this->redis->set('person:salary_4', 3100);
// set-up
$this->redis->del('person:id');
foreach ([1, 2, 3, 4] as $id) {
$this->redis->lPush('person:id', $id);
}
}
public function testSortPrefix() {
// Make sure that sorting works with a prefix
$this->redis->setOption(Redis::OPT_PREFIX, 'some-prefix:');
$this->redis->del('some-item');
$this->redis->sadd('some-item', 1);
$this->redis->sadd('some-item', 2);
$this->redis->sadd('some-item', 3);
$this->assertEquals(['1', '2', '3'], $this->redis->sort('some-item', ['sort' => 'asc']));
$this->assertEquals(['3', '2', '1'], $this->redis->sort('some-item', ['sort' => 'desc']));
$this->assertEquals(['1', '2', '3'], $this->redis->sort('some-item'));
// Kill our set/prefix
$this->redis->del('some-item');
$this->redis->setOption(Redis::OPT_PREFIX, '');
}
public function testSortAsc() {
$this->setupSort();
// sort by age and get IDs
$byAgeAsc = ['3', '1', '2', '4'];
$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', ['by' => 'person:age_*']));
$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'sort' => 'asc']));
$this->assertEquals(['1', '2', '3', '4'], $this->redis->sort('person:id', ['by' => NULL])); // check that NULL works.
$this->assertEquals(['1', '2', '3', '4'], $this->redis->sort('person:id', ['by' => NULL, 'get' => NULL])); // for all fields.
$this->assertEquals(['1', '2', '3', '4'], $this->redis->sort('person:id', ['sort' => 'asc']));
// sort by age and get names
$byAgeAsc = ['Carol', 'Alice', 'Bob', 'Dave'];
$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*']));
$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'sort' => 'asc']));
$this->assertEquals(array_slice($byAgeAsc, 0, 2), $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [0, 2]]));
$this->assertEquals(array_slice($byAgeAsc, 0, 2), $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [0, 2], 'sort' => 'asc']));
$this->assertEquals(array_slice($byAgeAsc, 1, 2), $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [1, 2]]));
$this->assertEquals(array_slice($byAgeAsc, 1, 2), $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [1, 2], 'sort' => 'asc']));
$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [0, 4]]));
$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [0, '4']])); // with strings
$this->assertEquals($byAgeAsc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => ['0', 4]]));
// sort by salary and get ages
$agesBySalaryAsc = ['34', '27', '25', '41'];
$this->assertEquals($agesBySalaryAsc, $this->redis->sort('person:id', ['by' => 'person:salary_*', 'get' => 'person:age_*']));
$this->assertEquals($agesBySalaryAsc, $this->redis->sort('person:id', ['by' => 'person:salary_*', 'get' => 'person:age_*', 'sort' => 'asc']));
$agesAndSalaries = $this->redis->sort('person:id', ['by' => 'person:salary_*', 'get' => ['person:age_*', 'person:salary_*'], 'sort' => 'asc']);
$this->assertEquals(['34', '2000', '27', '2500', '25', '2800', '41', '3100'], $agesAndSalaries);
// sort non-alpha doesn't change all-string lists
// list → [ghi, def, abc]
$list = ['abc', 'def', 'ghi'];
$this->redis->del('list');
foreach ($list as $i) {
$this->redis->lPush('list', $i);
}
// SORT list → [ghi, def, abc]
if (version_compare($this->version, '2.5.0') < 0) {
$this->assertEquals(array_reverse($list), $this->redis->sort('list'));
$this->assertEquals(array_reverse($list), $this->redis->sort('list', ['sort' => 'asc']));
} else {
// TODO rewrite, from 2.6.0 release notes:
// SORT now will refuse to sort in numerical mode elements that can't be parsed
// as numbers
}
// SORT list ALPHA → [abc, def, ghi]
$this->assertEquals($list, $this->redis->sort('list', ['alpha' => true]));
$this->assertEquals($list, $this->redis->sort('list', ['sort' => 'asc', 'alpha' => true]));
}
public function testSortDesc() {
$this->setupSort();
// sort by age and get IDs
$byAgeDesc = ['4', '2', '1', '3'];
$this->assertEquals($byAgeDesc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'sort' => 'desc']));
// sort by age and get names
$byAgeDesc = ['Dave', 'Bob', 'Alice', 'Carol'];
$this->assertEquals($byAgeDesc, $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'sort' => 'desc']));
$this->assertEquals(array_slice($byAgeDesc, 0, 2), $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [0, 2], 'sort' => 'desc']));
$this->assertEquals(array_slice($byAgeDesc, 1, 2), $this->redis->sort('person:id', ['by' => 'person:age_*', 'get' => 'person:name_*', 'limit' => [1, 2], 'sort' => 'desc']));
// sort by salary and get ages
$agesBySalaryDesc = ['41', '25', '27', '34'];
$this->assertEquals($agesBySalaryDesc, $this->redis->sort('person:id', ['by' => 'person:salary_*', 'get' => 'person:age_*', 'sort' => 'desc']));
// sort non-alpha doesn't change all-string lists
$list = ['def', 'abc', 'ghi'];
$this->redis->del('list');
foreach ($list as $i) {
$this->redis->lPush('list', $i);
}
// SORT list ALPHA → [abc, def, ghi]
$this->assertEquals(['ghi', 'def', 'abc'], $this->redis->sort('list', ['sort' => 'desc', 'alpha' => true]));
}
/* This test is just to make sure SORT and SORT_RO are both callable */
public function testSortHandler() {
$this->redis->del('list');
$this->redis->rpush('list', 'c', 'b', 'a');
$methods = ['sort'];
if ($this->minVersionCheck('7.0.0')) $methods[] = 'sort_ro';
foreach ($methods as $method) {
$this->assertEquals(['a', 'b', 'c'], $this->redis->$method('list', ['sort' => 'asc', 'alpha' => true]));
}
}
public function testLindex() {
$this->redis->del('list');
$this->redis->lPush('list', 'val');
$this->redis->lPush('list', 'val2');
$this->redis->lPush('list', 'val3');
$this->assertEquals('val3', $this->redis->lIndex('list', 0));
$this->assertEquals('val2', $this->redis->lIndex('list', 1));
$this->assertEquals('val', $this->redis->lIndex('list', 2));
$this->assertEquals('val', $this->redis->lIndex('list', -1));
$this->assertEquals('val2', $this->redis->lIndex('list', -2));
$this->assertEquals('val3', $this->redis->lIndex('list', -3));
$this->assertFalse($this->redis->lIndex('list', -4));
$this->redis->rPush('list', 'val4');
$this->assertEquals('val4', $this->redis->lIndex('list', 3));
$this->assertEquals('val4', $this->redis->lIndex('list', -1));
}
public function testlMove() {
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
[$list1, $list2] = ['{l}0', '{l}1'];
$left = $this->getLeftConstant();
$right = $this->getRightConstant();
$this->redis->del($list1, $list2);
$this->redis->lPush($list1, 'a');
$this->redis->lPush($list1, 'b');
$this->redis->lPush($list1, 'c');
$return = $this->redis->lMove($list1, $list2, $left, $right);
$this->assertEquals('c', $return);
$return = $this->redis->lMove($list1, $list2, $right, $left);
$this->assertEquals('a', $return);
$this->assertEquals(['b'], $this->redis->lRange($list1, 0, -1));
$this->assertEquals(['a', 'c'], $this->redis->lRange($list2, 0, -1));
}
public function testBlmove() {
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
[$list1, $list2] = ['{l}0', '{l}1'];
$left = $this->getLeftConstant();
$this->redis->del($list1, $list2);
$this->redis->rpush($list1, 'a');
$this->assertEquals('a', $this->redis->blmove($list1, $list2, $left, $left, 1.));
$st = microtime(true);
$ret = $this->redis->blmove($list1, $list2, $left, $left, .1);
$et = microtime(true);
$this->assertFalse($ret);
$this->assertGT(.09, $et - $st);
}
// lRem testing
public function testLRem() {
$this->redis->del('list');
$this->redis->lPush('list', 'a');
$this->redis->lPush('list', 'b');
$this->redis->lPush('list', 'c');
$this->redis->lPush('list', 'c');
$this->redis->lPush('list', 'b');
$this->redis->lPush('list', 'c');
// ['c', 'b', 'c', 'c', 'b', 'a']
$return = $this->redis->lrem('list', 'b', 2);
// ['c', 'c', 'c', 'a']
$this->assertEquals(2, $return);
$this->assertEquals('c', $this->redis->lIndex('list', 0));
$this->assertEquals('c', $this->redis->lIndex('list', 1));
$this->assertEquals('c', $this->redis->lIndex('list', 2));
$this->assertEquals('a', $this->redis->lIndex('list', 3));
$this->redis->del('list');
$this->redis->lPush('list', 'a');
$this->redis->lPush('list', 'b');
$this->redis->lPush('list', 'c');
$this->redis->lPush('list', 'c');
$this->redis->lPush('list', 'b');
$this->redis->lPush('list', 'c');
// ['c', 'b', 'c', 'c', 'b', 'a']
$this->redis->lrem('list', 'c', -2);
// ['c', 'b', 'b', 'a']
$this->assertEquals(2, $return);
$this->assertEquals('c', $this->redis->lIndex('list', 0));
$this->assertEquals('b', $this->redis->lIndex('list', 1));
$this->assertEquals('b', $this->redis->lIndex('list', 2));
$this->assertEquals('a', $this->redis->lIndex('list', 3));
// remove each element
$this->assertEquals(1, $this->redis->lrem('list', 'a', 0));
$this->assertEquals(0, $this->redis->lrem('list', 'x', 0));
$this->assertEquals(2, $this->redis->lrem('list', 'b', 0));
$this->assertEquals(1, $this->redis->lrem('list', 'c', 0));
$this->assertFalse($this->redis->get('list'));
$this->redis->set('list', 'actually not a list');
$this->assertFalse($this->redis->lrem('list', 'x'));
}
public function testSAdd() {
$this->redis->del('set');
$this->assertEquals(1, $this->redis->sAdd('set', 'val'));
$this->assertEquals(0, $this->redis->sAdd('set', 'val'));
$this->assertTrue($this->redis->sismember('set', 'val'));
$this->assertFalse($this->redis->sismember('set', 'val2'));
$this->assertEquals(1, $this->redis->sAdd('set', 'val2'));
$this->assertTrue($this->redis->sismember('set', 'val2'));
}
public function testSCard() {
$this->redis->del('set');
$this->assertEquals(1, $this->redis->sAdd('set', 'val'));
$this->assertEquals(1, $this->redis->scard('set'));
$this->assertEquals(1, $this->redis->sAdd('set', 'val2'));
$this->assertEquals(2, $this->redis->scard('set'));
}
public function testSRem() {
$this->redis->del('set');
$this->redis->sAdd('set', 'val');
$this->redis->sAdd('set', 'val2');
$this->redis->srem('set', 'val');
$this->assertEquals(1, $this->redis->scard('set'));
$this->redis->srem('set', 'val2');
$this->assertEquals(0, $this->redis->scard('set'));
}
public function testsMove() {
$this->redis->del('{set}0');
$this->redis->del('{set}1');
$this->redis->sAdd('{set}0', 'val');
$this->redis->sAdd('{set}0', 'val2');
$this->assertTrue($this->redis->sMove('{set}0', '{set}1', 'val'));
$this->assertFalse($this->redis->sMove('{set}0', '{set}1', 'val'));
$this->assertFalse($this->redis->sMove('{set}0', '{set}1', 'val-what'));
$this->assertEquals(1, $this->redis->scard('{set}0'));
$this->assertEquals(1, $this->redis->scard('{set}1'));
$this->assertEquals(['val2'], $this->redis->smembers('{set}0'));
$this->assertEquals(['val'], $this->redis->smembers('{set}1'));
}
public function testsPop() {
$this->redis->del('set0');
$this->assertFalse($this->redis->sPop('set0'));
$this->redis->sAdd('set0', 'val');
$this->redis->sAdd('set0', 'val2');
$v0 = $this->redis->sPop('set0');
$this->assertEquals(1, $this->redis->scard('set0'));
$this->assertInArray($v0, ['val', 'val2']);
$v1 = $this->redis->sPop('set0');
$this->assertEquals(0, $this->redis->scard('set0'));
$this->assertEqualsCanonicalizing(['val', 'val2'], [$v0, $v1]);
$this->assertFalse($this->redis->sPop('set0'));
}
public function testsPopWithCount() {
if ( ! $this->minVersionCheck('3.2'))
$this->markTestSkipped();
$set = 'set0';
$prefix = 'member';
$count = 5;
/* Add a few members */
$this->redis->del($set);
for ($i = 0; $i < $count; $i++) {
$this->redis->sadd($set, $prefix.$i);
}
/* Pop them all */
$ret = $this->redis->sPop($set, $i);
/* Make sure we got an arary and the count is right */
if ($this->assertIsArray($ret, $count)) {
/* Probably overkill but validate the actual returned members */
for ($i = 0; $i < $count; $i++) {
$this->assertInArray($prefix.$i, $ret);
}
}
}
public function testsRandMember() {
$this->redis->del('set0');
$this->assertFalse($this->redis->sRandMember('set0'));
$this->redis->sAdd('set0', 'val');
$this->redis->sAdd('set0', 'val2');
$got = [];
while (true) {
$v = $this->redis->sRandMember('set0');
$this->assertEquals(2, $this->redis->scard('set0')); // no change.
$this->assertInArray($v, ['val', 'val2']);
$got[$v] = $v;
if (count($got) == 2) {
break;
}
}
//
// With and without count, while serializing
//
$this->redis->del('set0');
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP);
for ($i = 0; $i < 5; $i++) {
$member = "member:$i";
$this->redis->sAdd('set0', $member);
$mems[] = $member;
}
$member = $this->redis->srandmember('set0');
$this->assertInArray($member, $mems);
$rmembers = $this->redis->srandmember('set0', $i);
foreach ($rmembers as $reply_mem) {
$this->assertInArray($reply_mem, $mems);
}
/* Ensure we can handle basically any return type */
foreach ([3.1415, new stdClass(), 42, 'hello', NULL] as $val) {
$this->assertEquals(1, $this->redis->del('set0'));
$this->assertEquals(1, $this->redis->sadd('set0', $val));
$this->assertSameType($val, $this->redis->srandmember('set0'));
}
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
}
public function testSRandMemberWithCount() {
// Make sure the set is nuked
$this->redis->del('set0');
// Run with a count (positive and negative) on an empty set
$ret_pos = $this->redis->sRandMember('set0', 10);
$ret_neg = $this->redis->sRandMember('set0', -10);
// Should both be empty arrays
$this->assertEquals([], $ret_pos);
$this->assertEquals([], $ret_neg);
// Add a few items to the set
for ($i = 0; $i < 100; $i++) {
$this->redis->sadd('set0', "member$i");
}
// Get less than the size of the list
$ret_slice = $this->redis->srandmember('set0', 20);
// Should be an array with 20 items
$this->assertIsArray($ret_slice, 20);
// Ask for more items than are in the list (but with a positive count)
$ret_slice = $this->redis->srandmember('set0', 200);
// Should be an array, should be however big the set is, exactly
$this->assertIsArray($ret_slice, $i);
// Now ask for too many items but negative
$ret_slice = $this->redis->srandmember('set0', -200);
// Should be an array, should have exactly the # of items we asked for (will be dups)
$this->assertIsArray($ret_slice, 200);
//
// Test in a pipeline
//
if ($this->havePipeline()) {
$pipe = $this->redis->pipeline();
$pipe->srandmember('set0', 20);
$pipe->srandmember('set0', 200);
$pipe->srandmember('set0', -200);
$ret = $this->redis->exec();
$this->assertIsArray($ret[0], 20);
$this->assertIsArray($ret[1], $i);
$this->assertIsArray($ret[2], 200);
// Kill the set
$this->redis->del('set0');
}
}
public function testSIsMember() {
$this->redis->del('set');
$this->redis->sAdd('set', 'val');
$this->assertTrue($this->redis->sismember('set', 'val'));
$this->assertFalse($this->redis->sismember('set', 'val2'));
}
public function testSMembers() {
$this->redis->del('set');
$data = ['val', 'val2', 'val3'];
foreach ($data as $member) {
$this->redis->sAdd('set', $member);
}
$this->assertEqualsCanonicalizing($data, $this->redis->smembers('set'));
}
public function testsMisMember() {
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->redis->del('set');
$this->redis->sAdd('set', 'val');
$this->redis->sAdd('set', 'val2');
$this->redis->sAdd('set', 'val3');
$misMembers = $this->redis->sMisMember('set', 'val', 'notamember', 'val3');
$this->assertEquals([1, 0, 1], $misMembers);
$misMembers = $this->redis->sMisMember('wrongkey', 'val', 'val2', 'val3');
$this->assertEquals([0, 0, 0], $misMembers);
}
public function testlSet() {
$this->redis->del('list');
$this->redis->lPush('list', 'val');
$this->redis->lPush('list', 'val2');
$this->redis->lPush('list', 'val3');
$this->assertEquals('val3', $this->redis->lIndex('list', 0));
$this->assertEquals('val2', $this->redis->lIndex('list', 1));
$this->assertEquals('val', $this->redis->lIndex('list', 2));
$this->assertTrue($this->redis->lSet('list', 1, 'valx'));
$this->assertEquals('val3', $this->redis->lIndex('list', 0));
$this->assertEquals('valx', $this->redis->lIndex('list', 1));
$this->assertEquals('val', $this->redis->lIndex('list', 2));
}
public function testsInter() {
$this->redis->del('{set}odd'); // set of odd numbers
$this->redis->del('{set}prime'); // set of prime numbers
$this->redis->del('{set}square'); // set of squares
$this->redis->del('{set}seq'); // set of numbers of the form n^2 - 1
$x = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25];
foreach ($x as $i) {
$this->redis->sAdd('{set}odd', $i);
}
$y = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23];
foreach ($y as $i) {
$this->redis->sAdd('{set}prime', $i);
}
$z = [1, 4, 9, 16, 25];
foreach ($z as $i) {
$this->redis->sAdd('{set}square', $i);
}
$t = [2, 5, 10, 17, 26];
foreach ($t as $i) {
$this->redis->sAdd('{set}seq', $i);
}
$xy = $this->redis->sInter('{set}odd', '{set}prime'); // odd prime numbers
foreach ($xy as $i) {
$i = (int)$i;
$this->assertInArray($i, array_intersect($x, $y));
}
$xy = $this->redis->sInter(['{set}odd', '{set}prime']); // odd prime numbers, as array.
foreach ($xy as $i) {
$i = (int)$i;
$this->assertInArray($i, array_intersect($x, $y));
}
$yz = $this->redis->sInter('{set}prime', '{set}square'); // set of prime squares
foreach ($yz as $i) {
$i = (int)$i;
$this->assertInArray($i, array_intersect($y, $z));
}
$yz = $this->redis->sInter(['{set}prime', '{set}square']); // set of odd squares, as array
foreach ($yz as $i) {
$i = (int)$i;
$this->assertInArray($i, array_intersect($y, $z));
}
$zt = $this->redis->sInter('{set}square', '{set}seq'); // prime squares
$this->assertEquals([], $zt);
$zt = $this->redis->sInter(['{set}square', '{set}seq']); // prime squares, as array
$this->assertEquals([], $zt);
$xyz = $this->redis->sInter('{set}odd', '{set}prime', '{set}square');// odd prime squares
$this->assertEquals(['1'], $xyz);
$xyz = $this->redis->sInter(['{set}odd', '{set}prime', '{set}square']);// odd prime squares, with an array as a parameter
$this->assertEquals(['1'], $xyz);
$nil = $this->redis->sInter([]);
$this->assertFalse($nil);
}
public function testsInterStore() {
$this->redis->del('{set}x', '{set}y', '{set}z', '{set}t');
$x = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25];
foreach ($x as $i) {
$this->redis->sAdd('{set}x', $i);
}
$y = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23];
foreach ($y as $i) {
$this->redis->sAdd('{set}y', $i);
}
$z = [1, 4, 9, 16, 25];
foreach ($z as $i) {
$this->redis->sAdd('{set}z', $i);
}
$t = [2, 5, 10, 17, 26];
foreach ($t as $i) {
$this->redis->sAdd('{set}t', $i);
}
/* Regression test for passing a single array */
$this->assertEquals(
count(array_intersect($x,$y)),
$this->redis->sInterStore(['{set}k', '{set}x', '{set}y'])
);
$count = $this->redis->sInterStore('{set}k', '{set}x', '{set}y'); // odd prime numbers
$this->assertEquals($count, $this->redis->scard('{set}k'));
foreach (array_intersect($x, $y) as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sInterStore('{set}k', '{set}y', '{set}z'); // set of odd squares
$this->assertEquals($count, $this->redis->scard('{set}k'));
foreach (array_intersect($y, $z) as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sInterStore('{set}k', '{set}z', '{set}t'); // squares of the form n^2 + 1
$this->assertEquals($count, 0);
$this->assertEquals($count, $this->redis->scard('{set}k'));
$this->redis->del('{set}z');
$xyz = $this->redis->sInterStore('{set}k', '{set}x', '{set}y', '{set}z'); // only z missing, expect 0.
$this->assertEquals(0, $xyz);
$this->redis->del('{set}y');
$xyz = $this->redis->sInterStore('{set}k', '{set}x', '{set}y', '{set}z'); // y and z missing, expect 0.
$this->assertEquals(0, $xyz);
$this->redis->del('{set}x');
$xyz = $this->redis->sInterStore('{set}k', '{set}x', '{set}y', '{set}z'); // x y and z ALL missing, expect 0.
$this->assertEquals(0, $xyz);
}
public function testsUnion() {
$this->redis->del('{set}x'); // set of odd numbers
$this->redis->del('{set}y'); // set of prime numbers
$this->redis->del('{set}z'); // set of squares
$this->redis->del('{set}t'); // set of numbers of the form n^2 - 1
$x = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25];
foreach ($x as $i) {
$this->redis->sAdd('{set}x', $i);
}
$y = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23];
foreach ($y as $i) {
$this->redis->sAdd('{set}y', $i);
}
$z = [1, 4, 9, 16, 25];
foreach ($z as $i) {
$this->redis->sAdd('{set}z', $i);
}
$t = [2, 5, 10, 17, 26];
foreach ($t as $i) {
$this->redis->sAdd('{set}t', $i);
}
$xy = $this->redis->sUnion('{set}x', '{set}y'); // x U y
foreach ($xy as $i) {
$this->assertInArray($i, array_merge($x, $y));
}
$yz = $this->redis->sUnion('{set}y', '{set}z'); // y U Z
foreach ($yz as $i) {
$i = (int)$i;
$this->assertInArray($i, array_merge($y, $z));
}
$zt = $this->redis->sUnion('{set}z', '{set}t'); // z U t
foreach ($zt as $i) {
$i = (int)$i;
$this->assertInArray($i, array_merge($z, $t));
}
$xyz = $this->redis->sUnion('{set}x', '{set}y', '{set}z'); // x U y U z
foreach ($xyz as $i) {
$this->assertInArray($i, array_merge($x, $y, $z));
}
}
public function testsUnionStore() {
$this->redis->del('{set}x', '{set}y', '{set}z', '{set}t');
$x = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25];
foreach ($x as $i) {
$this->redis->sAdd('{set}x', $i);
}
$y = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23];
foreach ($y as $i) {
$this->redis->sAdd('{set}y', $i);
}
$z = [1, 4, 9, 16, 25];
foreach ($z as $i) {
$this->redis->sAdd('{set}z', $i);
}
$t = [2, 5, 10, 17, 26];
foreach ($t as $i) {
$this->redis->sAdd('{set}t', $i);
}
$count = $this->redis->sUnionStore('{set}k', '{set}x', '{set}y'); // x U y
$xy = array_unique(array_merge($x, $y));
$this->assertEquals($count, count($xy));
foreach ($xy as $i) {
$i = (int)$i;
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sUnionStore('{set}k', '{set}y', '{set}z'); // y U z
$yz = array_unique(array_merge($y, $z));
$this->assertEquals($count, count($yz));
foreach ($yz as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sUnionStore('{set}k', '{set}z', '{set}t'); // z U t
$zt = array_unique(array_merge($z, $t));
$this->assertEquals($count, count($zt));
foreach ($zt as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sUnionStore('{set}k', '{set}x', '{set}y', '{set}z'); // x U y U z
$xyz = array_unique(array_merge($x, $y, $z));
$this->assertEquals($count, count($xyz));
foreach ($xyz as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$this->redis->del('{set}x'); // x missing now
$count = $this->redis->sUnionStore('{set}k', '{set}x', '{set}y', '{set}z'); // x U y U z
$this->assertEquals($count, count(array_unique(array_merge($y, $z))));
$this->redis->del('{set}y'); // x and y missing
$count = $this->redis->sUnionStore('{set}k', '{set}x', '{set}y', '{set}z'); // x U y U z
$this->assertEquals($count, count(array_unique($z)));
$this->redis->del('{set}z'); // x, y, and z ALL missing
$count = $this->redis->sUnionStore('{set}k', '{set}x', '{set}y', '{set}z'); // x U y U z
$this->assertEquals(0, $count);
}
public function testsDiff() {
$this->redis->del('{set}x'); // set of odd numbers
$this->redis->del('{set}y'); // set of prime numbers
$this->redis->del('{set}z'); // set of squares
$this->redis->del('{set}t'); // set of numbers of the form n^2 - 1
$x = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25];
foreach ($x as $i) {
$this->redis->sAdd('{set}x', $i);
}
$y = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23];
foreach ($y as $i) {
$this->redis->sAdd('{set}y', $i);
}
$z = [1, 4, 9, 16, 25];
foreach ($z as $i) {
$this->redis->sAdd('{set}z', $i);
}
$t = [2, 5, 10, 17, 26];
foreach ($t as $i) {
$this->redis->sAdd('{set}t', $i);
}
$xy = $this->redis->sDiff('{set}x', '{set}y'); // x U y
foreach ($xy as $i) {
$i = (int)$i;
$this->assertInArray($i, array_diff($x, $y));
}
$yz = $this->redis->sDiff('{set}y', '{set}z'); // y U Z
foreach ($yz as $i) {
$i = (int)$i;
$this->assertInArray($i, array_diff($y, $z));
}
$zt = $this->redis->sDiff('{set}z', '{set}t'); // z U t
foreach ($zt as $i) {
$i = (int)$i;
$this->assertInArray($i, array_diff($z, $t));
}
$xyz = $this->redis->sDiff('{set}x', '{set}y', '{set}z'); // x U y U z
foreach ($xyz as $i) {
$i = (int)$i;
$this->assertInArray($i, array_diff($x, $y, $z));
}
}
public function testsDiffStore() {
$this->redis->del('{set}x', '{set}y', '{set}z', '{set}t');
$x = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25];
foreach ($x as $i) {
$this->redis->sAdd('{set}x', $i);
}
$y = [1, 2, 3, 5, 7, 11, 13, 17, 19, 23];
foreach ($y as $i) {
$this->redis->sAdd('{set}y', $i);
}
$z = [1, 4, 9, 16, 25];
foreach ($z as $i) {
$this->redis->sAdd('{set}z', $i);
}
$t = [2, 5, 10, 17, 26];
foreach ($t as $i) {
$this->redis->sAdd('{set}t', $i);
}
$count = $this->redis->sDiffStore('{set}k', '{set}x', '{set}y'); // x - y
$xy = array_unique(array_diff($x, $y));
$this->assertEquals($count, count($xy));
foreach ($xy as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sDiffStore('{set}k', '{set}y', '{set}z'); // y - z
$yz = array_unique(array_diff($y, $z));
$this->assertEquals($count, count($yz));
foreach ($yz as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sDiffStore('{set}k', '{set}z', '{set}t'); // z - t
$zt = array_unique(array_diff($z, $t));
$this->assertEquals($count, count($zt));
foreach ($zt as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$count = $this->redis->sDiffStore('{set}k', '{set}x', '{set}y', '{set}z'); // x - y - z
$xyz = array_unique(array_diff($x, $y, $z));
$this->assertEquals($count, count($xyz));
foreach ($xyz as $i) {
$this->assertTrue($this->redis->sismember('{set}k', $i));
}
$this->redis->del('{set}x'); // x missing now
$count = $this->redis->sDiffStore('{set}k', '{set}x', '{set}y', '{set}z'); // x - y - z
$this->assertEquals(0, $count);
$this->redis->del('{set}y'); // x and y missing
$count = $this->redis->sDiffStore('{set}k', '{set}x', '{set}y', '{set}z'); // x - y - z
$this->assertEquals(0, $count);
$this->redis->del('{set}z'); // x, y, and z ALL missing
$count = $this->redis->sDiffStore('{set}k', '{set}x', '{set}y', '{set}z'); // x - y - z
$this->assertEquals(0, $count);
}
public function testInterCard() {
if (version_compare($this->version, '7.0.0') < 0)
$this->markTestSkipped();
$set_data = [
['aardvark', 'dog', 'fish', 'squirrel', 'tiger'],
['bear', 'coyote', 'fish', 'gorilla', 'dog']
];
$ssets = $zsets = [];
foreach ($set_data as $n => $values) {
$sset = "s{set}:$n";
$zset = "z{set}:$n";
$this->redis->del([$sset, $zset]);
$ssets[] = $sset;
$zsets[] = $zset;
foreach ($values as $score => $value) {
$this->assertEquals(1, $this->redis->sAdd("s{set}:$n", $value));
$this->assertEquals(1, $this->redis->zAdd("z{set}:$n", $score, $value));
}
}
$exp = count(array_intersect(...$set_data));
$act = $this->redis->sintercard($ssets);
$this->assertEquals($exp, $act);
$act = $this->redis->zintercard($zsets);
$this->assertEquals($exp, $act);
$this->assertEquals(1, $this->redis->sintercard($ssets, 1));
$this->assertEquals(2, $this->redis->sintercard($ssets, 2));
$this->assertEquals(1, $this->redis->zintercard($zsets, 1));
$this->assertEquals(2, $this->redis->zintercard($zsets, 2));
$this->assertFalse(@$this->redis->sintercard($ssets, -1));
$this->assertFalse(@$this->redis->zintercard($ssets, -1));
$this->assertFalse(@$this->redis->sintercard([]));
$this->assertFalse(@$this->redis->zintercard([]));
$this->redis->del(array_merge($ssets, $zsets));
}
public function testLRange() {
$this->redis->del('list');
$this->redis->lPush('list', 'val');
$this->redis->lPush('list', 'val2');
$this->redis->lPush('list', 'val3');
$this->assertEquals(['val3'], $this->redis->lrange('list', 0, 0));
$this->assertEquals(['val3', 'val2'], $this->redis->lrange('list', 0, 1));
$this->assertEquals(['val3', 'val2', 'val'], $this->redis->lrange('list', 0, 2));
$this->assertEquals(['val3', 'val2', 'val'], $this->redis->lrange('list', 0, 3));
$this->assertEquals(['val3', 'val2', 'val'], $this->redis->lrange('list', 0, -1));
$this->assertEquals(['val3', 'val2'], $this->redis->lrange('list', 0, -2));
$this->assertEquals(['val2', 'val'], $this->redis->lrange('list', -2, -1));
$this->redis->del('list');
$this->assertEquals([], $this->redis->lrange('list', 0, -1));
}
public function testdbSize() {
$this->assertTrue($this->redis->flushDB());
$this->redis->set('x', 'y');
$this->assertEquals(1, $this->redis->dbSize());
}
public function testFlushDB() {
$this->assertTrue($this->redis->flushdb());
$this->assertTrue($this->redis->flushdb(NULL));
$this->assertTrue($this->redis->flushdb(false));
$this->assertTrue($this->redis->flushdb(true));
}
public function testTTL() {
$this->redis->set('x', 'y');
$this->redis->expire('x', 5);
$ttl = $this->redis->ttl('x');
$this->assertBetween($ttl, 1, 5);
// A key with no TTL
$this->redis->del('x'); $this->redis->set('x', 'bar');
$this->assertEquals(-1, $this->redis->ttl('x'));
// A key that doesn't exist (> 2.8 will return -2)
if (version_compare($this->version, '2.8.0') >= 0) {
$this->redis->del('x');
$this->assertEquals(-2, $this->redis->ttl('x'));
}
}
public function testPersist() {
$this->redis->set('x', 'y');
$this->redis->expire('x', 100);
$this->assertTrue($this->redis->persist('x')); // true if there is a timeout
$this->assertEquals(-1, $this->redis->ttl('x')); // -1: timeout has been removed.
$this->assertFalse($this->redis->persist('x')); // false if there is no timeout
$this->redis->del('x');
$this->assertFalse($this->redis->persist('x')); // false if the key doesn’t exist.
}
public function testClient() {
/* CLIENT SETNAME */
$this->assertTrue($this->redis->client('setname', 'phpredis_unit_tests'));
/* CLIENT LIST */
$clients = $this->redis->client('list');
$this->assertIsArray($clients);
// Figure out which ip:port is us!
$address = NULL;
foreach ($clients as $client) {
if ($client['name'] == 'phpredis_unit_tests') {
$address = $client['addr'];
}
}
// We should have found our connection
$this->assertIsString($address);
/* CLIENT GETNAME */
$this->assertEquals('phpredis_unit_tests', $this->redis->client('getname'));
if (version_compare($this->version, '5.0.0') >= 0) {
$this->assertGT(0, $this->redis->client('id'));
if (version_compare($this->version, '6.0.0') >= 0) {
$this->assertEquals(-1, $this->redis->client('getredir'));
$this->assertTrue($this->redis->client('tracking', 'on', ['optin' => true]));
$this->assertEquals(0, $this->redis->client('getredir'));
$this->assertTrue($this->redis->client('caching', 'yes'));
$this->assertTrue($this->redis->client('tracking', 'off'));
if (version_compare($this->version, '6.2.0') >= 0) {
$this->assertFalse(empty($this->redis->client('info')));
$this->assertEquals([
'flags' => ['off'],
'redirect' => -1,
'prefixes' => [],
], $this->redis->client('trackinginfo'));
if (version_compare($this->version, '7.0.0') >= 0) {
$this->assertTrue($this->redis->client('no-evict', 'on'));
}
}
}
}
/* CLIENT KILL -- phpredis will reconnect, so we can do this */
$this->assertTrue($this->redis->client('kill', $address));
}
public function testSlowlog() {
// We don't really know what's going to be in the slowlog, but make sure
// the command returns proper types when called in various ways
$this->assertIsArray($this->redis->slowlog('get'));
$this->assertIsArray($this->redis->slowlog('get', 10));
$this->assertIsInt($this->redis->slowlog('len'));
$this->assertTrue($this->redis->slowlog('reset'));
$this->assertFalse(@$this->redis->slowlog('notvalid'));
}
public function testWait() {
// Closest we can check based on redis commit history
if (version_compare($this->version, '2.9.11') < 0)
$this->markTestSkipped();
// We could have slaves here, so determine that
$info = $this->redis->info();
$replicas = $info['connected_slaves'];
// Send a couple commands
$this->redis->set('wait-foo', 'over9000');
$this->redis->set('wait-bar', 'revo9000');
// Make sure we get the right replication count
$this->assertEquals($replicas, $this->redis->wait($replicas, 100));
// Pass more slaves than are connected
$this->redis->set('wait-foo', 'over9000');
$this->redis->set('wait-bar', 'revo9000');
$this->assertLT($replicas + 1, $this->redis->wait($replicas + 1, 100));
// Make sure when we pass with bad arguments we just get back false
$this->assertFalse($this->redis->wait(-1, -1));
$this->assertEquals(0, $this->redis->wait(-1, 20));
}
public function testInfo() {
$sequence = [false];
if ($this->haveMulti())
$sequence[] = true;
foreach ($sequence as $boo_multi) {
if ($boo_multi) {
$this->redis->multi();
$this->redis->info();
$info = $this->redis->exec();
$info = $info[0];
} else {
$info = $this->redis->info();
}
$keys = [
'redis_version',
'arch_bits',
'uptime_in_seconds',
'uptime_in_days',
'connected_clients',
'connected_slaves',
'used_memory',
'total_connections_received',
'total_commands_processed',
'role'
];
if (version_compare($this->version, '2.5.0') < 0) {
array_push($keys,
'changes_since_last_save',
'bgsave_in_progress',
'last_save_time'
);
} else {
array_push($keys,
'rdb_changes_since_last_save',
'rdb_bgsave_in_progress',
'rdb_last_save_time'
);
}
foreach ($keys as $k) {
$this->assertInArray($k, array_keys($info));
}
}
if ( ! $this->minVersionCheck('7.0.0'))
return;
$res = $this->redis->info('server', 'memory');
$this->assertTrue(is_array($res) && isset($res['redis_version']) && isset($res['used_memory']));
}
public function testInfoCommandStats() {
// INFO COMMANDSTATS is new in 2.6.0
if (version_compare($this->version, '2.5.0') < 0)
$this->markTestSkipped();
$info = $this->redis->info('COMMANDSTATS');
if ( ! $this->assertIsArray($info))
return;
foreach ($info as $k => $value) {
$this->assertStringContains('cmdstat_', $k);
}
}
public function testSelect() {
$this->assertFalse(@$this->redis->select(-1));
$this->assertTrue($this->redis->select(0));
}
public function testSwapDB() {
if (version_compare($this->version, '4.0.0') < 0)
$this->markTestSkipped();
$this->assertTrue($this->redis->swapdb(0, 1));
$this->assertTrue($this->redis->swapdb(0, 1));
}
public function testMset() {
$this->redis->del('x', 'y', 'z'); // remove x y z
$this->assertTrue($this->redis->mset(['x' => 'a', 'y' => 'b', 'z' => 'c'])); // set x y z
$this->assertEquals(['a', 'b', 'c'], $this->redis->mget(['x', 'y', 'z'])); // check x y z
$this->redis->del('x'); // delete just x
$this->assertTrue($this->redis->mset(['x' => 'a', 'y' => 'b', 'z' => 'c'])); // set x y z
$this->assertEquals(['a', 'b', 'c'], $this->redis->mget(['x', 'y', 'z'])); // check x y z
$this->assertFalse($this->redis->mset([])); // set ø → FALSE
/*
* Integer keys
*/
// No prefix
$set_array = [-1 => 'neg1', -2 => 'neg2', -3 => 'neg3', 1 => 'one', 2 => 'two', '3' => 'three'];
$this->redis->del(array_keys($set_array));
$this->assertTrue($this->redis->mset($set_array));
$this->assertEquals(array_values($set_array), $this->redis->mget(array_keys($set_array)));
$this->redis->del(array_keys($set_array));
// With a prefix
$this->redis->setOption(Redis::OPT_PREFIX, 'pfx:');
$this->redis->del(array_keys($set_array));
$this->assertTrue($this->redis->mset($set_array));
$this->assertEquals(array_values($set_array), $this->redis->mget(array_keys($set_array)));
$this->redis->del(array_keys($set_array));
$this->redis->setOption(Redis::OPT_PREFIX, '');
}
public function testMsetNX() {
$this->redis->del('x', 'y', 'z'); // remove x y z
$this->assertTrue($this->redis->msetnx(['x' => 'a', 'y' => 'b', 'z' => 'c'])); // set x y z
$this->assertEquals(['a', 'b', 'c'], $this->redis->mget(['x', 'y', 'z'])); // check x y z
$this->redis->del('x'); // delete just x
$this->assertFalse($this->redis->msetnx(['x' => 'A', 'y' => 'B', 'z' => 'C'])); // set x y z
$this->assertEquals([FALSE, 'b', 'c'], $this->redis->mget(['x', 'y', 'z'])); // check x y z
$this->assertFalse($this->redis->msetnx([])); // set ø → FALSE
}
public function testRpopLpush() {
// standard case.
$this->redis->del('{list}x', '{list}y');
$this->redis->lpush('{list}x', 'abc');
$this->redis->lpush('{list}x', 'def'); // x = [def, abc]
$this->redis->lpush('{list}y', '123');
$this->redis->lpush('{list}y', '456'); // y = [456, 123]
$this->assertEquals('abc', $this->redis->rpoplpush('{list}x', '{list}y')); // we RPOP x, yielding abc.
$this->assertEquals(['def'], $this->redis->lrange('{list}x', 0, -1)); // only def remains in x.
$this->assertEquals(['abc', '456', '123'], $this->redis->lrange('{list}y', 0, -1)); // abc has been lpushed to y.
// with an empty source, expecting no change.
$this->redis->del('{list}x', '{list}y');
$this->assertFalse($this->redis->rpoplpush('{list}x', '{list}y'));
$this->assertEquals([], $this->redis->lrange('{list}x', 0, -1));
$this->assertEquals([], $this->redis->lrange('{list}y', 0, -1));
}
public function testBRpopLpush() {
// standard case.
$this->redis->del('{list}x', '{list}y');
$this->redis->lpush('{list}x', 'abc');
$this->redis->lpush('{list}x', 'def'); // x = [def, abc]
$this->redis->lpush('{list}y', '123');
$this->redis->lpush('{list}y', '456'); // y = [456, 123]
$this->assertEquals('abc', $this->redis->brpoplpush('{list}x', '{list}y', 1)); // we RPOP x, yielding abc.
$this->assertEquals(['def'], $this->redis->lrange('{list}x', 0, -1)); // only def remains in x.
$this->assertEquals(['abc', '456', '123'], $this->redis->lrange('{list}y', 0, -1)); // abc has been lpushed to y.
// with an empty source, expecting no change.
$this->redis->del('{list}x', '{list}y');
$this->assertFalse($this->redis->brpoplpush('{list}x', '{list}y', 1));
$this->assertEquals([], $this->redis->lrange('{list}x', 0, -1));
$this->assertEquals([], $this->redis->lrange('{list}y', 0, -1));
if ( ! $this->minVersionCheck('6.0.0'))
return;
// Redis >= 6.0.0 allows floating point timeouts
$st = microtime(true);
$this->assertFalse($this->redis->brpoplpush('{list}x', '{list}y', .1));
$et = microtime(true);
$this->assertLT(1.0, $et - $st);
}
public function testZAddFirstArg() {
$this->redis->del('key');
$zsetName = 100; // not a string!
$this->assertEquals(1, $this->redis->zAdd($zsetName, 0, 'val0'));
$this->assertEquals(1, $this->redis->zAdd($zsetName, 1, 'val1'));
$this->assertEquals(['val0', 'val1'], $this->redis->zRange($zsetName, 0, -1));
}
public function testZaddIncr() {
$this->redis->del('zset');
$this->assertEquals(10.0, $this->redis->zAdd('zset', ['incr'], 10, 'value'));
$this->assertEquals(20.0, $this->redis->zAdd('zset', ['incr'], 10, 'value'));
$this->assertFalse($this->redis->zAdd('zset', ['incr'], 10, 'value', 20, 'value2'));
}
public function testZX() {
$this->redis->del('key');
$this->assertEquals([], $this->redis->zRange('key', 0, -1));
$this->assertEquals([], $this->redis->zRange('key', 0, -1, true));
$this->assertEquals(1, $this->redis->zAdd('key', 0, 'val0'));
$this->assertEquals(1, $this->redis->zAdd('key', 2, 'val2'));
$this->assertEquals(2, $this->redis->zAdd('key', 4, 'val4', 5, 'val5')); // multiple parameters
if (version_compare($this->version, '3.0.2') < 0) {
$this->assertEquals(1, $this->redis->zAdd('key', 1, 'val1'));
$this->assertEquals(1, $this->redis->zAdd('key', 3, 'val3'));
} else {
$this->assertEquals(1, $this->redis->zAdd('key', [], 1, 'val1')); // empty options
$this->assertEquals(1, $this->redis->zAdd('key', ['nx'], 3, 'val3')); // nx option
$this->assertEquals(0, $this->redis->zAdd('key', ['xx'], 3, 'val3')); // xx option
if (version_compare($this->version, '6.2.0') >= 0) {
$this->assertEquals(0, $this->redis->zAdd('key', ['lt'], 4, 'val3')); // lt option
$this->assertEquals(0, $this->redis->zAdd('key', ['gt'], 2, 'val3')); // gt option
}
}
$this->assertEquals(['val0', 'val1', 'val2', 'val3', 'val4', 'val5'], $this->redis->zRange('key', 0, -1));
// withscores
$ret = $this->redis->zRange('key', 0, -1, true);
$this->assertEquals(6, count($ret));
$this->assertEquals(0.0, $ret['val0']);
$this->assertEquals(1.0, $ret['val1']);
$this->assertEquals(2.0, $ret['val2']);
$this->assertEquals(3.0, $ret['val3']);
$this->assertEquals(4.0, $ret['val4']);
$this->assertEquals(5.0, $ret['val5']);
$this->assertEquals(0, $this->redis->zRem('key', 'valX'));
$this->assertEquals(1, $this->redis->zRem('key', 'val3'));
$this->assertEquals(1, $this->redis->zRem('key', 'val4'));
$this->assertEquals(1, $this->redis->zRem('key', 'val5'));
$this->assertEquals(['val0', 'val1', 'val2'], $this->redis->zRange('key', 0, -1));
// zGetReverseRange
$this->assertEquals(1, $this->redis->zAdd('key', 3, 'val3'));
$this->assertEquals(1, $this->redis->zAdd('key', 3, 'aal3'));
$zero_to_three = $this->redis->zRangeByScore('key', 0, 3);
$this->assertEquals(['val0', 'val1', 'val2', 'aal3', 'val3'], $zero_to_three);
$three_to_zero = $this->redis->zRevRangeByScore('key', 3, 0);
$this->assertEquals(array_reverse(['val0', 'val1', 'val2', 'aal3', 'val3']), $three_to_zero);
$this->assertEquals(5, $this->redis->zCount('key', 0, 3));
// withscores
$this->redis->zRem('key', 'aal3');
$zero_to_three = $this->redis->zRangeByScore('key', 0, 3, ['withscores' => true]);
$this->assertEquals(['val0' => 0.0, 'val1' => 1.0, 'val2' => 2.0, 'val3' => 3.0], $zero_to_three);
$this->assertEquals(4, $this->redis->zCount('key', 0, 3));
// limit
$this->assertEquals(['val0'], $this->redis->zRangeByScore('key', 0, 3, ['limit' => [0, 1]]));
$this->assertEquals(['val0', 'val1'],
$this->redis->zRangeByScore('key', 0, 3, ['limit' => [0, 2]]));
$this->assertEquals(['val1', 'val2'],
$this->redis->zRangeByScore('key', 0, 3, ['limit' => [1, 2]]));
$this->assertEquals(['val0', 'val1'],
$this->redis->zRangeByScore('key', 0, 1, ['limit' => [0, 100]]));
if ($this->minVersionCheck('6.2.0'))
$this->assertEquals(['val0', 'val1'], $this->redis->zrange('key', 0, 1, ['byscore', 'limit' => [0, 100]]));
// limits as references
$limit = [0, 100];
foreach ($limit as &$val) {}
$this->assertEquals(['val0', 'val1'], $this->redis->zRangeByScore('key', 0, 1, ['limit' => $limit]));
$this->assertEquals(
['val3'], $this->redis->zRevRangeByScore('key', 3, 0, ['limit' => [0, 1]])
);
$this->assertEquals(
['val3', 'val2'], $this->redis->zRevRangeByScore('key', 3, 0, ['limit' => [0, 2]])
);
$this->assertEquals(
['val2', 'val1'], $this->redis->zRevRangeByScore('key', 3, 0, ['limit' => [1, 2]])
);
$this->assertEquals(
['val1', 'val0'], $this->redis->zRevRangeByScore('key', 1, 0, ['limit' => [0, 100]])
);
if ($this->minVersionCheck('6.2.0')) {
$this->assertEquals(['val1', 'val0'],
$this->redis->zrange('key', 1, 0, ['byscore', 'rev', 'limit' => [0, 100]]));
$this->assertEquals(2, $this->redis->zrangestore('dst{key}', 'key', 1, 0,
['byscore', 'rev', 'limit' => [0, 100]]));
$this->assertEquals(['val0', 'val1'], $this->redis->zRange('dst{key}', 0, -1));
$this->assertEquals(1, $this->redis->zrangestore('dst{key}', 'key', 1, 0,
['byscore', 'rev', 'limit' => [0, 1]]));
$this->assertEquals(['val1'], $this->redis->zrange('dst{key}', 0, -1));
}
$this->assertEquals(4, $this->redis->zCard('key'));
$this->assertEquals(1.0, $this->redis->zScore('key', 'val1'));
$this->assertFalse($this->redis->zScore('key', 'val'));
$this->assertFalse($this->redis->zScore(3, 2));
// with () and +inf, -inf
$this->redis->del('zset');
$this->redis->zAdd('zset', 1, 'foo');
$this->redis->zAdd('zset', 2, 'bar');
$this->redis->zAdd('zset', 3, 'biz');
$this->redis->zAdd('zset', 4, 'foz');
$this->assertEquals(
['foo' => 1.0, 'bar' => 2.0, 'biz' => 3.0, 'foz' => 4.0],
$this->redis->zRangeByScore('zset', '-inf', '+inf', ['withscores' => true])
);
$this->assertEquals(
['foo' => 1.0, 'bar' => 2.0],
$this->redis->zRangeByScore('zset', 1, 2, ['withscores' => true])
);
$this->assertEquals(
['bar' => 2.0],
$this->redis->zRangeByScore('zset', '(1', 2, ['withscores' => true])
);
$this->assertEquals([], $this->redis->zRangeByScore('zset', '(1', '(2', ['withscores' => true]));
$this->assertEquals(4, $this->redis->zCount('zset', '-inf', '+inf'));
$this->assertEquals(2, $this->redis->zCount('zset', 1, 2));
$this->assertEquals(1, $this->redis->zCount('zset', '(1', 2));
$this->assertEquals(0, $this->redis->zCount('zset', '(1', '(2'));
// zincrby
$this->redis->del('key');
$this->assertEquals(1.0, $this->redis->zIncrBy('key', 1, 'val1'));
$this->assertEquals(1.0, $this->redis->zScore('key', 'val1'));
$this->assertEquals(2.5, $this->redis->zIncrBy('key', 1.5, 'val1'));
$this->assertEquals(2.5, $this->redis->zScore('key', 'val1'));
// zUnionStore
$this->redis->del('{zset}1');
$this->redis->del('{zset}2');
$this->redis->del('{zset}3');
$this->redis->del('{zset}U');
$this->redis->zAdd('{zset}1', 0, 'val0');
$this->redis->zAdd('{zset}1', 1, 'val1');
$this->redis->zAdd('{zset}2', 2, 'val2');
$this->redis->zAdd('{zset}2', 3, 'val3');
$this->redis->zAdd('{zset}3', 4, 'val4');
$this->redis->zAdd('{zset}3', 5, 'val5');
$this->assertEquals(4, $this->redis->zUnionStore('{zset}U', ['{zset}1', '{zset}3']));
$this->assertEquals(['val0', 'val1', 'val4', 'val5'], $this->redis->zRange('{zset}U', 0, -1));
// Union on non existing keys
$this->redis->del('{zset}U');
$this->assertEquals(0, $this->redis->zUnionStore('{zset}U', ['{zset}X', '{zset}Y']));
$this->assertEquals([],$this->redis->zRange('{zset}U', 0, -1));
// !Exist U Exist → copy of existing zset.
$this->redis->del('{zset}U', 'X');
$this->assertEquals(2, $this->redis->zUnionStore('{zset}U', ['{zset}1', '{zset}X']));
// test weighted zUnion
$this->redis->del('{zset}Z');
$this->assertEquals(4, $this->redis->zUnionStore('{zset}Z', ['{zset}1', '{zset}2'], [1, 1]));
$this->assertEquals(['val0', 'val1', 'val2', 'val3'], $this->redis->zRange('{zset}Z', 0, -1));
$this->redis->zRemRangeByScore('{zset}Z', 0, 10);
$this->assertEquals(4, $this->redis->zUnionStore('{zset}Z', ['{zset}1', '{zset}2'], [5, 1]));
$this->assertEquals(['val0', 'val2', 'val3', 'val1'], $this->redis->zRange('{zset}Z', 0, -1));
$this->redis->del('{zset}1');
$this->redis->del('{zset}2');
$this->redis->del('{zset}3');
//test zUnion with weights and aggegration function
$this->redis->zadd('{zset}1', 1, 'duplicate');
$this->redis->zadd('{zset}2', 2, 'duplicate');
$this->redis->zUnionStore('{zset}U', ['{zset}1', '{zset}2'], [1, 1], 'MIN');
$this->assertEquals(1.0, $this->redis->zScore('{zset}U', 'duplicate'));
$this->redis->del('{zset}U');
//now test zUnion *without* weights but with aggregate function
$this->redis->zUnionStore('{zset}U', ['{zset}1', '{zset}2'], null, 'MIN');
$this->assertEquals(1.0, $this->redis->zScore('{zset}U', 'duplicate'));
$this->redis->del('{zset}U', '{zset}1', '{zset}2');
// test integer and float weights (GitHub issue #109).
$this->redis->del('{zset}1', '{zset}2', '{zset}3');
$this->redis->zadd('{zset}1', 1, 'one');
$this->redis->zadd('{zset}1', 2, 'two');
$this->redis->zadd('{zset}2', 1, 'one');
$this->redis->zadd('{zset}2', 2, 'two');
$this->redis->zadd('{zset}2', 3, 'three');
$this->assertEquals(3, $this->redis->zUnionStore('{zset}3', ['{zset}1', '{zset}2'], [2, 3.0]));
$this->redis->del('{zset}1');
$this->redis->del('{zset}2');
$this->redis->del('{zset}3');
// Test 'inf', '-inf', and '+inf' weights (GitHub issue #336)
$this->redis->zadd('{zset}1', 1, 'one', 2, 'two', 3, 'three');
$this->redis->zadd('{zset}2', 3, 'three', 4, 'four', 5, 'five');
// Make sure phpredis handles these weights
$this->assertEquals(5, $this->redis->zUnionStore('{zset}3', ['{zset}1', '{zset}2'], [1, 'inf']) );
$this->assertEquals(5, $this->redis->zUnionStore('{zset}3', ['{zset}1', '{zset}2'], [1, '-inf']));
$this->assertEquals(5, $this->redis->zUnionStore('{zset}3', ['{zset}1', '{zset}2'], [1, '+inf']));
// Now, confirm that they're being sent, and that it works
$weights = ['inf', '-inf', '+inf'];
foreach ($weights as $weight) {
$r = $this->redis->zUnionStore('{zset}3', ['{zset}1', '{zset}2'], [1, $weight]);
$this->assertEquals(5, $r);
$r = $this->redis->zrangebyscore('{zset}3', '(-inf', '(inf',['withscores'=>true]);
$this->assertEquals(2, count($r));
$this->assertArrayKey($r, 'one');
$this->assertArrayKey($r, 'two');
}
$this->redis->del('{zset}1', '{zset}2', '{zset}3');
$this->redis->zadd('{zset}1', 2000.1, 'one');
$this->redis->zadd('{zset}1', 3000.1, 'two');
$this->redis->zadd('{zset}1', 4000.1, 'three');
$ret = $this->redis->zRange('{zset}1', 0, -1, true);
$this->assertEquals(3, count($ret));
$retValues = array_keys($ret);
$this->assertEquals(['one', 'two', 'three'], $retValues);
// + 0 converts from string to float OR integer
$this->assertArrayKeyEquals($ret, 'one', 2000.1);
$this->assertArrayKeyEquals($ret, 'two', 3000.1);
$this->assertArrayKeyEquals($ret, 'three', 4000.1);
$this->redis->del('{zset}1');
// ZREMRANGEBYRANK
$this->redis->zAdd('{zset}1', 1, 'one');
$this->redis->zAdd('{zset}1', 2, 'two');
$this->redis->zAdd('{zset}1', 3, 'three');
$this->assertEquals(2, $this->redis->zremrangebyrank('{zset}1', 0, 1));
$this->assertEquals(['three' => 3.], $this->redis->zRange('{zset}1', 0, -1, true));
$this->redis->del('{zset}1');
// zInterStore
$this->redis->zAdd('{zset}1', 0, 'val0');
$this->redis->zAdd('{zset}1', 1, 'val1');
$this->redis->zAdd('{zset}1', 3, 'val3');
$this->redis->zAdd('{zset}2', 2, 'val1');
$this->redis->zAdd('{zset}2', 3, 'val3');
$this->redis->zAdd('{zset}3', 4, 'val3');
$this->redis->zAdd('{zset}3', 5, 'val5');
$this->redis->del('{zset}I');
$this->assertEquals(2, $this->redis->zInterStore('{zset}I', ['{zset}1', '{zset}2']));
$this->assertEquals(['val1', 'val3'], $this->redis->zRange('{zset}I', 0, -1));
// Union on non existing keys
$this->assertEquals(0, $this->redis->zInterStore('{zset}X', ['{zset}X', '{zset}Y']));
$this->assertEquals([], $this->redis->zRange('{zset}X', 0, -1));
// !Exist U Exist
$this->assertEquals(0, $this->redis->zInterStore('{zset}Y', ['{zset}1', '{zset}X']));
$this->assertEquals([], $this->redis->zRange('keyY', 0, -1));
// test weighted zInterStore
$this->redis->del('{zset}1');
$this->redis->del('{zset}2');
$this->redis->del('{zset}3');
$this->redis->zAdd('{zset}1', 0, 'val0');
$this->redis->zAdd('{zset}1', 1, 'val1');
$this->redis->zAdd('{zset}1', 3, 'val3');
$this->redis->zAdd('{zset}2', 2, 'val1');
$this->redis->zAdd('{zset}2', 1, 'val3');
$this->redis->zAdd('{zset}3', 7, 'val1');
$this->redis->zAdd('{zset}3', 3, 'val3');
$this->redis->del('{zset}I');
$this->assertEquals(2, $this->redis->zInterStore('{zset}I', ['{zset}1', '{zset}2'], [1, 1]));
$this->assertEquals(['val1', 'val3'], $this->redis->zRange('{zset}I', 0, -1));
$this->redis->del('{zset}I');
$this->assertEquals(2, $this->redis->zInterStore('{zset}I', ['{zset}1', '{zset}2', '{zset}3'], [1, 5, 1], 'min'));
$this->assertEquals(['val1', 'val3'], $this->redis->zRange('{zset}I', 0, -1));
$this->redis->del('{zset}I');
$this->assertEquals(2, $this->redis->zInterStore('{zset}I', ['{zset}1', '{zset}2', '{zset}3'], [1, 5, 1], 'max'));
$this->assertEquals(['val3', 'val1'], $this->redis->zRange('{zset}I', 0, -1));
$this->redis->del('{zset}I');
$this->assertEquals(2, $this->redis->zInterStore('{zset}I', ['{zset}1', '{zset}2', '{zset}3'], null, 'max'));
$this->assertEquals(7., $this->redis->zScore('{zset}I', 'val1'));
// zrank, zrevrank
$this->redis->del('z');
$this->redis->zadd('z', 1, 'one');
$this->redis->zadd('z', 2, 'two');
$this->redis->zadd('z', 5, 'five');
$this->assertEquals(0, $this->redis->zRank('z', 'one'));
$this->assertEquals(1, $this->redis->zRank('z', 'two'));
$this->assertEquals(2, $this->redis->zRank('z', 'five'));
$this->assertEquals(2, $this->redis->zRevRank('z', 'one'));
$this->assertEquals(1, $this->redis->zRevRank('z', 'two'));
$this->assertEquals(0, $this->redis->zRevRank('z', 'five'));
}
public function testZRangeScoreArg() {
$this->redis->del('{z}');
$mems = ['one' => 1.0, 'two' => 2.0, 'three' => 3.0];
foreach ($mems as $mem => $score) {
$this->redis->zAdd('{z}', $score, $mem);
}
/* Verify we can pass true and ['withscores' => true] */
$this->assertEquals($mems, $this->redis->zRange('{z}', 0, -1, true));
$this->assertEquals($mems, $this->redis->zRange('{z}', 0, -1, ['withscores' => true]));
}
public function testZRangeByLex() {
/* ZRANGEBYLEX available on versions >= 2.8.9 */
if (version_compare($this->version, '2.8.9') < 0) {
$this->MarkTestSkipped();
return;
}
$this->redis->del('key');
foreach (range('a', 'g') as $c) {
$this->redis->zAdd('key', 0, $c);
}
$this->assertEquals(['a', 'b', 'c'], $this->redis->zRangeByLex('key', '-', '[c'));
$this->assertEquals(['f', 'g'], $this->redis->zRangeByLex('key', '(e', '+'));
// with limit offset
$this->assertEquals(['b', 'c'], $this->redis->zRangeByLex('key', '-', '[c', 1, 2) );
$this->assertEquals(['b'], $this->redis->zRangeByLex('key', '-', '(c', 1, 2));
/* Test getting the same functionality via ZRANGE and options */
if ($this->minVersionCheck('6.2.0')) {
$this->assertEquals(['a', 'b', 'c'], $this->redis->zRange('key', '-', '[c', ['BYLEX']));
$this->assertEquals(['b', 'c'], $this->redis->zRange('key', '-', '[c', ['BYLEX', 'LIMIT' => [1, 2]]));
$this->assertEquals(['b'], $this->redis->zRange('key', '-', '(c', ['BYLEX', 'LIMIT' => [1, 2]]));
$this->assertEquals(['b', 'a'], $this->redis->zRange('key', '[c', '-', ['BYLEX', 'REV', 'LIMIT' => [1, 2]]));
}
}
public function testZLexCount() {
if (version_compare($this->version, '2.8.9') < 0) {
$this->MarkTestSkipped();
return;
}
$this->redis->del('key');
foreach (range('a', 'g') as $c) {
$entries[] = $c;
$this->redis->zAdd('key', 0, $c);
}
/* Special -/+ values */
$this->assertEquals(0, $this->redis->zLexCount('key', '-', '-'));
$this->assertEquals(count($entries), $this->redis->zLexCount('key', '-', '+'));
/* Verify invalid arguments return FALSE */
$this->assertFalse(@$this->redis->zLexCount('key', '[a', 'bad'));
$this->assertFalse(@$this->redis->zLexCount('key', 'bad', '[a'));
/* Now iterate through */
$start = $entries[0];
for ($i = 1; $i < count($entries); $i++) {
$end = $entries[$i];
$this->assertEquals($i + 1, $this->redis->zLexCount('key', "[$start", "[$end"));
$this->assertEquals($i, $this->redis->zLexCount('key', "[$start", "($end"));
$this->assertEquals($i - 1, $this->redis->zLexCount('key', "($start", "($end"));
}
}
public function testzDiff() {
// Only available since 6.2.0
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->redis->del('key');
foreach (range('a', 'c') as $c) {
$this->redis->zAdd('key', 1, $c);
}
$this->assertEquals(['a', 'b', 'c'], $this->redis->zDiff(['key']));
$this->assertEquals(['a' => 1.0, 'b' => 1.0, 'c' => 1.0], $this->redis->zDiff(['key'], ['withscores' => true]));
}
public function testzInter() {
// Only available since 6.2.0
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->redis->del('key');
foreach (range('a', 'c') as $c) {
$this->redis->zAdd('key', 1, $c);
}
$this->assertEquals(['a', 'b', 'c'], $this->redis->zInter(['key']));
$this->assertEquals(['a' => 1.0, 'b' => 1.0, 'c' => 1.0], $this->redis->zInter(['key'], null, ['withscores' => true]));
}
public function testzUnion() {
// Only available since 6.2.0
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->redis->del('key');
foreach (range('a', 'c') as $c) {
$this->redis->zAdd('key', 1, $c);
}
$this->assertEquals(['a', 'b', 'c'], $this->redis->zUnion(['key']));
$this->assertEquals(['a' => 1.0, 'b' => 1.0, 'c' => 1.0], $this->redis->zUnion(['key'], null, ['withscores' => true]));
}
public function testzDiffStore() {
// Only available since 6.2.0
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->redis->del('{zkey}src');
foreach (range('a', 'c') as $c) {
$this->redis->zAdd('{zkey}src', 1, $c);
}
$this->assertEquals(3, $this->redis->zDiffStore('{zkey}dst', ['{zkey}src']));
$this->assertEquals(['a', 'b', 'c'], $this->redis->zRange('{zkey}dst', 0, -1));
}
public function testzMscore() {
// Only available since 6.2.0
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->redis->del('key');
foreach (range('a', 'c') as $c) {
$this->redis->zAdd('key', 1, $c);
}
$scores = $this->redis->zMscore('key', 'a', 'notamember', 'c');
$this->assertEquals([1.0, false, 1.0], $scores);
$scores = $this->redis->zMscore('wrongkey', 'a', 'b', 'c');
$this->assertEquals([false, false, false], $scores);
}
public function testZRemRangeByLex() {
if (version_compare($this->version, '2.8.9') < 0) {
$this->MarkTestSkipped();
return;
}
$this->redis->del('key');
$this->redis->zAdd('key', 0, 'a', 0, 'b', 0, 'c');
$this->assertEquals(3, $this->redis->zRemRangeByLex('key', '-', '+'));
$this->redis->zAdd('key', 0, 'a', 0, 'b', 0, 'c');
$this->assertEquals(3, $this->redis->zRemRangeByLex('key', '[a', '[c'));
$this->redis->zAdd('key', 0, 'a', 0, 'b', 0, 'c');
$this->assertEquals(0, $this->redis->zRemRangeByLex('key', '[a', '(a'));
$this->assertEquals(1, $this->redis->zRemRangeByLex('key', '(a', '(c'));
$this->assertEquals(2, $this->redis->zRemRangeByLex('key', '[a', '[c'));
}
public function testBZPop() {
if (version_compare($this->version, '5.0.0') < 0) {
$this->MarkTestSkipped();
return;
}
$this->redis->del('{zs}1', '{zs}2');
$this->redis->zAdd('{zs}1', 0, 'a', 1, 'b', 2, 'c');
$this->redis->zAdd('{zs}2', 3, 'A', 4, 'B', 5, 'D');
$this->assertEquals(['{zs}1', 'a', '0'], $this->redis->bzPopMin('{zs}1', '{zs}2', 0));
$this->assertEquals(['{zs}1', 'c', '2'], $this->redis->bzPopMax(['{zs}1', '{zs}2'], 0));
$this->assertEquals(['{zs}2', 'A', '3'], $this->redis->bzPopMin('{zs}2', '{zs}1', 0));
/* Verify timeout is being sent */
$this->redis->del('{zs}1', '{zs}2');
$st = microtime(true) * 1000;
$this->redis->bzPopMin('{zs}1', '{zs}2', 1);
$et = microtime(true) * 1000;
$this->assertGT(100, $et - $st);
}
public function testZPop() {
if (version_compare($this->version, '5.0.0') < 0) {
$this->MarkTestSkipped();
return;
}
// zPopMax and zPopMin without a COUNT argument
$this->redis->del('key');
$this->redis->zAdd('key', 0, 'a', 1, 'b', 2, 'c', 3, 'd', 4, 'e');
$this->assertEquals(['e' => 4.0], $this->redis->zPopMax('key'));
$this->assertEquals(['a' => 0.0], $this->redis->zPopMin('key'));
// zPopMax with a COUNT argument
$this->redis->del('key');
$this->redis->zAdd('key', 0, 'a', 1, 'b', 2, 'c', 3, 'd', 4, 'e');
$this->assertEquals(['e' => 4.0, 'd' => 3.0, 'c' => 2.0], $this->redis->zPopMax('key', 3));
// zPopMin with a COUNT argument
$this->redis->del('key');
$this->redis->zAdd('key', 0, 'a', 1, 'b', 2, 'c', 3, 'd', 4, 'e');
$this->assertEquals(['a' => 0.0, 'b' => 1.0, 'c' => 2.0], $this->redis->zPopMin('key', 3));
}
public function testZRandMember() {
if (version_compare($this->version, '6.2.0') < 0) {
$this->MarkTestSkipped();
return;
}
$this->redis->del('key');
$this->redis->zAdd('key', 0, 'a', 1, 'b', 2, 'c', 3, 'd', 4, 'e');
$this->assertInArray($this->redis->zRandMember('key'), ['a', 'b', 'c', 'd', 'e']);
$result = $this->redis->zRandMember('key', ['count' => 3]);
$this->assertEquals(3, count($result));
$this->assertEquals(array_intersect($result, ['a', 'b', 'c', 'd', 'e']), $result);
$result = $this->redis->zRandMember('key', ['count' => 2, 'withscores' => true]);
$this->assertEquals(2, count($result));
$this->assertEquals(array_intersect_key($result, ['a' => 0, 'b' => 1, 'c' => 2, 'd' => 3, 'e' => 4]), $result);
}
public function testHashes() {
$this->redis->del('h', 'key');
$this->assertEquals(0, $this->redis->hLen('h'));
$this->assertEquals(1, $this->redis->hSet('h', 'a', 'a-value'));
$this->assertEquals(1, $this->redis->hLen('h'));
$this->assertEquals(1, $this->redis->hSet('h', 'b', 'b-value'));
$this->assertEquals(2, $this->redis->hLen('h'));
$this->assertEquals('a-value', $this->redis->hGet('h', 'a')); // simple get
$this->assertEquals('b-value', $this->redis->hGet('h', 'b')); // simple get
$this->assertEquals(0, $this->redis->hSet('h', 'a', 'another-value')); // replacement
$this->assertEquals('another-value', $this->redis->hGet('h', 'a')); // get the new value
$this->assertEquals('b-value', $this->redis->hGet('h', 'b')); // simple get
$this->assertFalse($this->redis->hGet('h', 'c')); // unknown hash member
$this->assertFalse($this->redis->hGet('key', 'c')); // unknownkey
// hDel
$this->assertEquals(1, $this->redis->hDel('h', 'a')); // 1 on success
$this->assertEquals(0, $this->redis->hDel('h', 'a')); // 0 on failure
$this->redis->del('h');
$this->redis->hSet('h', 'x', 'a');
$this->redis->hSet('h', 'y', 'b');
$this->assertEquals(2, $this->redis->hDel('h', 'x', 'y')); // variadic
// hsetnx
$this->redis->del('h');
$this->assertTrue($this->redis->hSetNx('h', 'x', 'a'));
$this->assertTrue($this->redis->hSetNx('h', 'y', 'b'));
$this->assertFalse($this->redis->hSetNx('h', 'x', '?'));
$this->assertFalse($this->redis->hSetNx('h', 'y', '?'));
$this->assertEquals('a', $this->redis->hGet('h', 'x'));
$this->assertEquals('b', $this->redis->hGet('h', 'y'));
// keys
$keys = $this->redis->hKeys('h');
$this->assertEqualsCanonicalizing(['x', 'y'], $keys);
// values
$values = $this->redis->hVals('h');
$this->assertEqualsCanonicalizing(['a', 'b'], $values);
// keys + values
$all = $this->redis->hGetAll('h');
$this->assertEqualsCanonicalizing(['x' => 'a', 'y' => 'b'], $all, true);
// hExists
$this->assertTrue($this->redis->hExists('h', 'x'));
$this->assertTrue($this->redis->hExists('h', 'y'));
$this->assertFalse($this->redis->hExists('h', 'w'));
$this->redis->del('h');
$this->assertFalse($this->redis->hExists('h', 'x'));
// hIncrBy
$this->redis->del('h');
$this->assertEquals(2, $this->redis->hIncrBy('h', 'x', 2));
$this->assertEquals(3, $this->redis->hIncrBy('h', 'x', 1));
$this->assertEquals(2, $this->redis->hIncrBy('h', 'x', -1));
$this->assertEquals('2', $this->redis->hGet('h', 'x'));
$this->assertEquals(PHP_INT_MAX, $this->redis->hIncrBy('h', 'x', PHP_INT_MAX-2));
$this->assertEquals(''.PHP_INT_MAX, $this->redis->hGet('h', 'x'));
$this->redis->hSet('h', 'y', 'not-a-number');
$this->assertFalse($this->redis->hIncrBy('h', 'y', 1));
if (version_compare($this->version, '2.5.0') >= 0) {
// hIncrByFloat
$this->redis->del('h');
$this->assertEquals(1.5, $this->redis->hIncrByFloat('h', 'x', 1.5));
$this->assertEquals(3.0, $this->redis->hincrByFloat('h', 'x', 1.5));
$this->assertEquals(1.5, $this->redis->hincrByFloat('h', 'x', -1.5));
$this->assertEquals(1000000000001.5, $this->redis->hincrByFloat('h', 'x', 1000000000000));
$this->redis->hset('h', 'y', 'not-a-number');
$this->assertFalse($this->redis->hIncrByFloat('h', 'y', 1.5));
}
// hmset
$this->redis->del('h');
$this->assertTrue($this->redis->hMset('h', ['x' => 123, 'y' => 456, 'z' => 'abc']));
$this->assertEquals('123', $this->redis->hGet('h', 'x'));
$this->assertEquals('456', $this->redis->hGet('h', 'y'));
$this->assertEquals('abc', $this->redis->hGet('h', 'z'));
$this->assertFalse($this->redis->hGet('h', 't'));
// hmget
$this->assertEquals(['x' => '123', 'y' => '456'], $this->redis->hMget('h', ['x', 'y']));
$this->assertEquals(['z' => 'abc'], $this->redis->hMget('h', ['z']));
$this->assertEquals(['x' => '123', 't' => FALSE, 'y' => '456'], $this->redis->hMget('h', ['x', 't', 'y']));
$this->assertEquals(['x' => '123', 't' => FALSE, 'y' => '456'], $this->redis->hMget('h', ['x', 't', 'y']));
$this->assertNotEquals([123 => 'x'], $this->redis->hMget('h', [123]));
$this->assertEquals([123 => FALSE], $this->redis->hMget('h', [123]));
// Test with an array populated with things we can't use as keys
$this->assertFalse($this->redis->hmget('h', [false,NULL,false]));
// Test with some invalid keys mixed in (which should just be ignored)
$this->assertEquals(
['x' => '123', 'y' => '456', 'z' => 'abc'],
$this->redis->hMget('h', ['x', null, 'y', '', 'z', false])
);
// hmget/hmset with numeric fields
$this->redis->del('h');
$this->assertTrue($this->redis->hMset('h', [123 => 'x', 'y' => 456]));
$this->assertEquals('x', $this->redis->hGet('h', 123));
$this->assertEquals('x', $this->redis->hGet('h', '123'));
$this->assertEquals('456', $this->redis->hGet('h', 'y'));
$this->assertEquals([123 => 'x', 'y' => '456'], $this->redis->hMget('h', ['123', 'y']));
// references
$keys = [123, 'y'];
foreach ($keys as &$key) {}
$this->assertEquals([123 => 'x', 'y' => '456'], $this->redis->hMget('h', $keys));
// check non-string types.
$this->redis->del('h1');
$this->assertTrue($this->redis->hMSet('h1', ['x' => 0, 'y' => [], 'z' => new stdclass(), 't' => NULL]));
$h1 = $this->redis->hGetAll('h1');
$this->assertEquals('0', $h1['x']);
$this->assertEquals('Array', $h1['y']);
$this->assertEquals('Object', $h1['z']);
$this->assertEquals('', $h1['t']);
// hset with fields + values as an associative array
if (version_compare($this->version, '4.0.0') >= 0) {
$this->redis->del('h');
$this->assertEquals(3, $this->redis->hSet('h', ['x' => 123, 'y' => 456, 'z' => 'abc']));
$this->assertEquals(['x' => '123', 'y' => '456', 'z' => 'abc'], $this->redis->hGetAll('h'));
$this->assertEquals(0, $this->redis->hSet('h', ['x' => 789]));
$this->assertEquals(['x' => '789', 'y' => '456', 'z' => 'abc'], $this->redis->hGetAll('h'));
}
// hset with variadic fields + values
if (version_compare($this->version, '4.0.0') >= 0) {
$this->redis->del('h');
$this->assertEquals(3, $this->redis->hSet('h', 'x', 123, 'y', 456, 'z', 'abc'));
$this->assertEquals(['x' => '123', 'y' => '456', 'z' => 'abc'], $this->redis->hGetAll('h'));
$this->assertEquals(0, $this->redis->hSet('h', 'x', 789));
$this->assertEquals(['x' => '789', 'y' => '456', 'z' => 'abc'], $this->redis->hGetAll('h'));
}
// hstrlen
if (version_compare($this->version, '3.2.0') >= 0) {
$this->redis->del('h');
$this->assertEquals(0, $this->redis->hStrLen('h', 'x')); // key doesn't exist
$this->redis->hSet('h', 'foo', 'bar');
$this->assertEquals(0, $this->redis->hStrLen('h', 'x')); // field is not present in the hash
$this->assertEquals(3, $this->redis->hStrLen('h', 'foo'));
}
}
public function testHRandField() {
if (version_compare($this->version, '6.2.0') < 0)
$this->MarkTestSkipped();
$this->redis->del('key');
$this->redis->hMSet('key', ['a' => 0, 'b' => 1, 'c' => 'foo', 'd' => 'bar', 'e' => null]);
$this->assertInArray($this->redis->hRandField('key'), ['a', 'b', 'c', 'd', 'e']);
$result = $this->redis->hRandField('key', ['count' => 3]);
$this->assertEquals(3, count($result));
$this->assertEquals(array_intersect($result, ['a', 'b', 'c', 'd', 'e']), $result);
$result = $this->redis->hRandField('key', ['count' => 2, 'withvalues' => true]);
$this->assertEquals(2, count($result));
$this->assertEquals(array_intersect_key($result, ['a' => 0, 'b' => 1, 'c' => 'foo', 'd' => 'bar', 'e' => null]), $result);
/* Make sure PhpRedis sends COUNt (1) when `WITHVALUES` is set */
$result = $this->redis->hRandField('key', ['withvalues' => true]);
$this->assertNull($this->redis->getLastError());
$this->assertIsArray($result);
$this->assertEquals(1, count($result));
/* We can return false if the key doesn't exist */
$this->assertIsInt($this->redis->del('notahash'));
$this->assertFalse($this->redis->hRandField('notahash'));
}
public function testSetRange() {
$this->redis->del('key');
$this->redis->set('key', 'hello world');
$this->redis->setRange('key', 6, 'redis');
$this->assertKeyEquals('hello redis', 'key');
$this->redis->setRange('key', 6, 'you'); // don't cut off the end
$this->assertKeyEquals('hello youis', 'key');
$this->redis->set('key', 'hello world');
// fill with zeros if needed
$this->redis->del('key');
$this->redis->setRange('key', 6, 'foo');
$this->assertKeyEquals("\x00\x00\x00\x00\x00\x00foo", 'key');
}
public function testObject() {
/* Version 3.0.0 (represented as >= 2.9.0 in redis info) and moving
* forward uses 'embstr' instead of 'raw' for small string values */
if (version_compare($this->version, '2.9.0') < 0) {
$small_encoding = 'raw';
} else {
$small_encoding = 'embstr';
}
$this->redis->del('key');
$this->assertFalse($this->redis->object('encoding', 'key'));
$this->assertFalse($this->redis->object('refcount', 'key'));
$this->assertFalse($this->redis->object('idletime', 'key'));
$this->redis->set('key', 'value');
$this->assertEquals($small_encoding, $this->redis->object('encoding', 'key'));
$this->assertEquals(1, $this->redis->object('refcount', 'key'));
$this->assertTrue(is_numeric($this->redis->object('idletime', 'key')));
$this->redis->del('key');
$this->redis->lpush('key', 'value');
/* Redis has improved the encoding here throughout the various versions. The value
can either be 'ziplist', 'quicklist', or 'listpack' */
$encoding = $this->redis->object('encoding', 'key');
$this->assertInArray($encoding, ['ziplist', 'quicklist', 'listpack']);
$this->assertEquals(1, $this->redis->object('refcount', 'key'));
$this->assertTrue(is_numeric($this->redis->object('idletime', 'key')));
$this->redis->del('key');
$this->redis->sadd('key', 'value');
/* Redis 7.2.0 switched to 'listpack' for small sets */
$encoding = $this->redis->object('encoding', 'key');
$this->assertInArray($encoding, ['hashtable', 'listpack']);
$this->assertEquals(1, $this->redis->object('refcount', 'key'));
$this->assertTrue(is_numeric($this->redis->object('idletime', 'key')));
$this->redis->del('key');
$this->redis->sadd('key', 42);
$this->redis->sadd('key', 1729);
$this->assertEquals('intset', $this->redis->object('encoding', 'key'));
$this->assertEquals(1, $this->redis->object('refcount', 'key'));
$this->assertTrue(is_numeric($this->redis->object('idletime', 'key')));
$this->redis->del('key');
$this->redis->lpush('key', str_repeat('A', pow(10, 6))); // 1M elements, too big for a ziplist.
$encoding = $this->redis->object('encoding', 'key');
$this->assertInArray($encoding, ['linkedlist', 'quicklist']);
$this->assertEquals(1, $this->redis->object('refcount', 'key'));
$this->assertTrue(is_numeric($this->redis->object('idletime', 'key')));
}
public function testMultiExec() {
$this->sequence(Redis::MULTI);
$this->differentType(Redis::MULTI);
// with prefix as well
$this->redis->setOption(Redis::OPT_PREFIX, 'test:');
$this->sequence(Redis::MULTI);
$this->differentType(Redis::MULTI);
$this->redis->setOption(Redis::OPT_PREFIX, '');
$this->redis->set('x', '42');
$this->assertTrue($this->redis->watch('x'));
$ret = $this->redis->multi()->get('x')->exec();
// successful transaction
$this->assertEquals(['42'], $ret);
}
public function testFailedTransactions() {
$this->redis->set('x', 42);
// failed transaction
$this->redis->watch('x');
$r = $this->newInstance(); // new instance, modifying `x'.
$r->incr('x');
$ret = $this->redis->multi()->get('x')->exec();
$this->assertFalse($ret); // failed because another client changed our watched key between WATCH and EXEC.
// watch and unwatch
$this->redis->watch('x');
$r->incr('x'); // other instance
$this->redis->unwatch(); // cancel transaction watch
$ret = $this->redis->multi()->get('x')->exec();
// succeeded since we've cancel the WATCH command.
$this->assertEquals(['44'], $ret);
}
public function testPipeline() {
if ( ! $this->havePipeline())
$this->markTestSkipped();
$this->sequence(Redis::PIPELINE);
$this->differentType(Redis::PIPELINE);
// with prefix as well
$this->redis->setOption(Redis::OPT_PREFIX, 'test:');
$this->sequence(Redis::PIPELINE);
$this->differentType(Redis::PIPELINE);
$this->redis->setOption(Redis::OPT_PREFIX, '');
}
public function testPipelineMultiExec() {
if ( ! $this->havePipeline())
$this->markTestSkipped();
$ret = $this->redis->pipeline()->multi()->exec()->exec();
$this->assertIsArray($ret);
$this->assertEquals(1, count($ret)); // empty transaction
$ret = $this->redis->pipeline()
->ping()
->multi()->set('x', 42)->incr('x')->exec()
->ping()
->multi()->get('x')->del('x')->exec()
->ping()
->exec();
$this->assertIsArray($ret);
$this->assertEquals(5, count($ret)); // should be 5 atomic operations
}
/* GitHub issue #1211 (ignore redundant calls to pipeline or multi) */
public function testDoublePipeNoOp() {
/* Only the first pipeline should be honored */
for ($i = 0; $i < 6; $i++) {
$this->redis->pipeline();
}
/* Set and get in our pipeline */
$this->redis->set('pipecount', 'over9000')->get('pipecount');
$data = $this->redis->exec();
$this->assertEquals([true,'over9000'], $data);
/* Only the first MULTI should be honored */
for ($i = 0; $i < 6; $i++) {
$this->redis->multi();
}
/* Set and get in our MULTI block */
$this->redis->set('multicount', 'over9000')->get('multicount');
$data = $this->redis->exec();
$this->assertEquals([true, 'over9000'], $data);
}
public function testDiscard() {
foreach ([Redis::PIPELINE, Redis::MULTI] as $mode) {
/* start transaction */
$this->redis->multi($mode);
/* Set and get in our transaction */
$this->redis->set('pipecount', 'over9000')->get('pipecount');
/* first call closes transaction and clears commands queue */
$this->assertTrue($this->redis->discard());
/* next call fails because mode is ATOMIC */
$this->assertFalse($this->redis->discard());
}
}
protected function sequence($mode) {
$ret = $this->redis->multi($mode)
->set('x', 42)
->type('x')
->get('x')
->exec();
$this->assertIsArray($ret);
$i = 0;
$this->assertTrue($ret[$i++]);
$this->assertEquals(Redis::REDIS_STRING, $ret[$i++]);
$this->assertEqualsWeak('42', $ret[$i]);
$serializer = $this->redis->getOption(Redis::OPT_SERIALIZER);
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE); // testing incr, which doesn't work with the serializer
$ret = $this->redis->multi($mode)
->del('{key}1')
->set('{key}1', 'value1')
->get('{key}1')
->getSet('{key}1', 'value2')
->get('{key}1')
->set('{key}2', 4)
->incr('{key}2')
->get('{key}2')
->decr('{key}2')
->get('{key}2')
->rename('{key}2', '{key}3')
->get('{key}3')
->renameNx('{key}3', '{key}1')
->rename('{key}3', '{key}2')
->incrby('{key}2', 5)
->get('{key}2')
->decrby('{key}2', 5)
->get('{key}2')
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertTrue(is_long($ret[$i++]));
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEqualsWeak('value1', $ret[$i++]);
$this->assertEqualsWeak('value1', $ret[$i++]);
$this->assertEqualsWeak('value2', $ret[$i++]);
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEqualsWeak(5, $ret[$i++]);
$this->assertEqualsWeak(5, $ret[$i++]);
$this->assertEqualsWeak(4, $ret[$i++]);
$this->assertEqualsWeak(4, $ret[$i++]);
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEqualsWeak(4, $ret[$i++]);
$this->assertEqualsWeak(FALSE, $ret[$i++]);
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEqualsWeak(9, $ret[$i++]);
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEqualsWeak(4, $ret[$i++]);
$this->assertEquals($i, count($ret));
$this->redis->setOption(Redis::OPT_SERIALIZER, $serializer);
$ret = $this->redis->multi($mode)
->del('{key}1')
->del('{key}2')
->set('{key}1', 'val1')
->setnx('{key}1', 'valX')
->setnx('{key}2', 'valX')
->exists('{key}1')
->exists('{key}3')
->exec();
$this->assertIsArray($ret);
$this->assertEqualsWeak(true, $ret[0]);
$this->assertEqualsWeak(true, $ret[1]);
$this->assertEqualsWeak(true, $ret[2]);
$this->assertEqualsWeak(false, $ret[3]);
$this->assertEqualsWeak(true, $ret[4]);
$this->assertEqualsWeak(true, $ret[5]);
$this->assertEqualsWeak(false, $ret[6]);
// ttl, mget, mset, msetnx, expire, expireAt
$this->redis->del('key');
$ret = $this->redis->multi($mode)
->ttl('key')
->mget(['{key}1', '{key}2', '{key}3'])
->mset(['{key}3' => 'value3', '{key}4' => 'value4'])
->set('key', 'value')
->expire('key', 5)
->ttl('key')
->expireAt('key', '0000')
->exec();
$this->assertIsArray($ret);
$i = 0;
$ttl = $ret[$i++];
$this->assertBetween($ttl, -2, -1);
$this->assertEquals(['val1', 'valX', false], $ret[$i++]); // mget
$this->assertTrue($ret[$i++]); // mset
$this->assertTrue($ret[$i++]); // set
$this->assertTrue($ret[$i++]); // expire
$this->assertEquals(5, $ret[$i++]); // ttl
$this->assertTrue($ret[$i++]); // expireAt
$this->assertEquals($i, count($ret));
$ret = $this->redis->multi($mode)
->set('{list}lkey', 'x')
->set('{list}lDest', 'y')
->del('{list}lkey', '{list}lDest')
->rpush('{list}lkey', 'lvalue')
->lpush('{list}lkey', 'lvalue')
->lpush('{list}lkey', 'lvalue')
->lpush('{list}lkey', 'lvalue')
->lpush('{list}lkey', 'lvalue')
->lpush('{list}lkey', 'lvalue')
->rpoplpush('{list}lkey', '{list}lDest')
->lrange('{list}lDest', 0, -1)
->lpop('{list}lkey')
->llen('{list}lkey')
->lrem('{list}lkey', 'lvalue', 3)
->llen('{list}lkey')
->lIndex('{list}lkey', 0)
->lrange('{list}lkey', 0, -1)
->lSet('{list}lkey', 1, 'newValue') // check errors on key not exists
->lrange('{list}lkey', 0, -1)
->llen('{list}lkey')
->exec();
$this->assertIsArray($ret);
$i = 0;
$this->assertTrue($ret[$i++]); // SET
$this->assertTrue($ret[$i++]); // SET
$this->assertEquals(2, $ret[$i++]); // deleting 2 keys
$this->assertEquals(1, $ret[$i++]); // rpush, now 1 element
$this->assertEquals(2, $ret[$i++]); // lpush, now 2 elements
$this->assertEquals(3, $ret[$i++]); // lpush, now 3 elements
$this->assertEquals(4, $ret[$i++]); // lpush, now 4 elements
$this->assertEquals(5, $ret[$i++]); // lpush, now 5 elements
$this->assertEquals(6, $ret[$i++]); // lpush, now 6 elements
$this->assertEquals('lvalue', $ret[$i++]); // rpoplpush returns the element: 'lvalue'
$this->assertEquals(['lvalue'], $ret[$i++]); // lDest contains only that one element.
$this->assertEquals('lvalue', $ret[$i++]); // removing a second element from lkey, now 4 elements left ↓
$this->assertEquals(4, $ret[$i++]); // 4 elements left, after 2 pops.
$this->assertEquals(3, $ret[$i++]); // removing 3 elements, now 1 left.
$this->assertEquals(1, $ret[$i++]); // 1 element left
$this->assertEquals('lvalue', $ret[$i++]); // this is the current head.
$this->assertEquals(['lvalue'], $ret[$i++]); // this is the current list.
$this->assertFalse($ret[$i++]); // updating a non-existent element fails.
$this->assertEquals(['lvalue'], $ret[$i++]); // this is the current list.
$this->assertEquals(1, $ret[$i++]); // 1 element left
$this->assertEquals($i, count($ret));
$ret = $this->redis->multi($mode)
->del('{list}lkey', '{list}lDest')
->rpush('{list}lkey', 'lvalue')
->lpush('{list}lkey', 'lvalue')
->lpush('{list}lkey', 'lvalue')
->rpoplpush('{list}lkey', '{list}lDest')
->lrange('{list}lDest', 0, -1)
->lpop('{list}lkey')
->exec();
$this->assertIsArray($ret);
$i = 0;
$this->assertLTE(2, $ret[$i++]); // deleting 2 keys
$this->assertEquals(1, $ret[$i++]); // 1 element in the list
$this->assertEquals(2, $ret[$i++]); // 2 elements in the list
$this->assertEquals(3, $ret[$i++]); // 3 elements in the list
$this->assertEquals('lvalue', $ret[$i++]); // rpoplpush returns the element: 'lvalue'
$this->assertEquals(['lvalue'], $ret[$i++]); // rpoplpush returns the element: 'lvalue'
$this->assertEquals('lvalue', $ret[$i++]); // pop returns the front element: 'lvalue'
$this->assertEquals($i, count($ret));
$serializer = $this->redis->getOption(Redis::OPT_SERIALIZER);
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE); // testing incr, which doesn't work with the serializer
$ret = $this->redis->multi($mode)
->del('{key}1')
->set('{key}1', 'value1')
->get('{key}1')
->getSet('{key}1', 'value2')
->get('{key}1')
->set('{key}2', 4)
->incr('{key}2')
->get('{key}2')
->decr('{key}2')
->get('{key}2')
->rename('{key}2', '{key}3')
->get('{key}3')
->renameNx('{key}3', '{key}1')
->rename('{key}3', '{key}2')
->incrby('{key}2', 5)
->get('{key}2')
->decrby('{key}2', 5)
->get('{key}2')
->set('{key}3', 'value3')
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertLTE(1, $ret[$i++]);
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEquals('value1', $ret[$i++]);
$this->assertEquals('value1', $ret[$i++]);
$this->assertEquals('value2', $ret[$i++]);
$this->assertEqualsWeak(true, $ret[$i++]);
$this->assertEqualsWeak(5, $ret[$i++]);
$this->assertEqualsWeak(5, $ret[$i++]);
$this->assertEqualsWeak(4, $ret[$i++]);
$this->assertEqualsWeak(4, $ret[$i++]);
$this->assertTrue($ret[$i++]);
$this->assertEqualsWeak(4, $ret[$i++]);
$this->assertFalse($ret[$i++]);
$this->assertTrue($ret[$i++]);
$this->assertEquals(9, $ret[$i++]); // incrby('{key}2', 5)
$this->assertEqualsWeak(9, $ret[$i++]); // get('{key}2')
$this->assertEquals(4, $ret[$i++]); // decrby('{key}2', 5)
$this->assertEqualsWeak(4, $ret[$i++]); // get('{key}2')
$this->assertTrue($ret[$i++]);
$this->redis->setOption(Redis::OPT_SERIALIZER, $serializer);
$ret = $this->redis->multi($mode)
->del('{key}1')
->del('{key}2')
->del('{key}3')
->set('{key}1', 'val1')
->setnx('{key}1', 'valX')
->setnx('{key}2', 'valX')
->exists('{key}1')
->exists('{key}3')
->exec();
$this->assertIsArray($ret);
$this->assertEquals(1, $ret[0]); // del('{key}1')
$this->assertEquals(1, $ret[1]); // del('{key}2')
$this->assertEquals(1, $ret[2]); // del('{key}3')
$this->assertTrue($ret[3]); // set('{key}1', 'val1')
$this->assertFalse($ret[4]); // setnx('{key}1', 'valX')
$this->assertTrue($ret[5]); // setnx('{key}2', 'valX')
$this->assertEquals(1, $ret[6]); // exists('{key}1')
$this->assertEquals(0, $ret[7]); // exists('{key}3')
// ttl, mget, mset, msetnx, expire, expireAt
$ret = $this->redis->multi($mode)
->ttl('key')
->mget(['{key}1', '{key}2', '{key}3'])
->mset(['{key}3' => 'value3', '{key}4' => 'value4'])
->set('key', 'value')
->expire('key', 5)
->ttl('key')
->expireAt('key', '0000')
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertTrue(is_long($ret[$i++]));
$this->assertIsArray($ret[$i++], 3);
// $i++;
$this->assertTrue($ret[$i++]); // mset always returns true
$this->assertTrue($ret[$i++]); // set always returns true
$this->assertTrue($ret[$i++]); // expire always returns true
$this->assertEquals(5, $ret[$i++]); // TTL was just set.
$this->assertTrue($ret[$i++]); // expireAt returns true for an existing key
$this->assertEquals($i, count($ret));
// lists
$ret = $this->redis->multi($mode)
->del('{l}key', '{l}Dest')
->rpush('{l}key', 'lvalue')
->lpush('{l}key', 'lvalue')
->lpush('{l}key', 'lvalue')
->lpush('{l}key', 'lvalue')
->lpush('{l}key', 'lvalue')
->lpush('{l}key', 'lvalue')
->rpoplpush('{l}key', '{l}Dest')
->lrange('{l}Dest', 0, -1)
->lpop('{l}key')
->llen('{l}key')
->lrem('{l}key', 'lvalue', 3)
->llen('{l}key')
->lIndex('{l}key', 0)
->lrange('{l}key', 0, -1)
->lSet('{l}key', 1, 'newValue') // check errors on missing key
->lrange('{l}key', 0, -1)
->llen('{l}key')
->exec();
$this->assertIsArray($ret);
$i = 0;
$this->assertBetween($ret[$i++], 0, 2); // del
$this->assertEquals(1, $ret[$i++]); // 1 value
$this->assertEquals(2, $ret[$i++]); // 2 values
$this->assertEquals(3, $ret[$i++]); // 3 values
$this->assertEquals(4, $ret[$i++]); // 4 values
$this->assertEquals(5, $ret[$i++]); // 5 values
$this->assertEquals(6, $ret[$i++]); // 6 values
$this->assertEquals('lvalue', $ret[$i++]);
$this->assertEquals(['lvalue'], $ret[$i++]); // 1 value only in lDest
$this->assertEquals('lvalue', $ret[$i++]); // now 4 values left
$this->assertEquals(4, $ret[$i++]);
$this->assertEquals(3, $ret[$i++]); // removing 3 elements.
$this->assertEquals(1, $ret[$i++]); // length is now 1
$this->assertEquals('lvalue', $ret[$i++]); // this is the head
$this->assertEquals(['lvalue'], $ret[$i++]); // 1 value only in lkey
$this->assertFalse($ret[$i++]); // can't set list[1] if we only have a single value in it.
$this->assertEquals(['lvalue'], $ret[$i++]); // the previous error didn't touch anything.
$this->assertEquals(1, $ret[$i++]); // the previous error didn't change the length
$this->assertEquals($i, count($ret));
// sets
$ret = $this->redis->multi($mode)
->del('{s}key1', '{s}key2', '{s}keydest', '{s}keyUnion', '{s}DiffDest')
->sadd('{s}key1', 'sValue1')
->sadd('{s}key1', 'sValue2')
->sadd('{s}key1', 'sValue3')
->sadd('{s}key1', 'sValue4')
->sadd('{s}key2', 'sValue1')
->sadd('{s}key2', 'sValue2')
->scard('{s}key1')
->srem('{s}key1', 'sValue2')
->scard('{s}key1')
->sMove('{s}key1', '{s}key2', 'sValue4')
->scard('{s}key2')
->sismember('{s}key2', 'sValue4')
->sMembers('{s}key1')
->sMembers('{s}key2')
->sInter('{s}key1', '{s}key2')
->sInterStore('{s}keydest', '{s}key1', '{s}key2')
->sMembers('{s}keydest')
->sUnion('{s}key2', '{s}keydest')
->sUnionStore('{s}keyUnion', '{s}key2', '{s}keydest')
->sMembers('{s}keyUnion')
->sDiff('{s}key1', '{s}key2')
->sDiffStore('{s}DiffDest', '{s}key1', '{s}key2')
->sMembers('{s}DiffDest')
->sPop('{s}key2')
->scard('{s}key2')
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertBetween($ret[$i++], 0, 5); // we deleted at most 5 values.
$this->assertEquals(1, $ret[$i++]); // skey1 now has 1 element.
$this->assertEquals(1, $ret[$i++]); // skey1 now has 2 elements.
$this->assertEquals(1, $ret[$i++]); // skey1 now has 3 elements.
$this->assertEquals(1, $ret[$i++]); // skey1 now has 4 elements.
$this->assertEquals(1, $ret[$i++]); // skey2 now has 1 element.
$this->assertEquals(1, $ret[$i++]); // skey2 now has 2 elements.
$this->assertEquals(4, $ret[$i++]);
$this->assertEquals(1, $ret[$i++]); // we did remove that value.
$this->assertEquals(3, $ret[$i++]); // now 3 values only.
$this->assertTrue($ret[$i++]); // the move did succeed.
$this->assertEquals(3, $ret[$i++]); // sKey2 now has 3 values.
$this->assertTrue($ret[$i++]); // sKey2 does contain sValue4.
foreach (['sValue1', 'sValue3'] as $k) { // sKey1 contains sValue1 and sValue3.
$this->assertInArray($k, $ret[$i]);
}
$this->assertEquals(2, count($ret[$i++]));
foreach (['sValue1', 'sValue2', 'sValue4'] as $k) { // sKey2 contains sValue1, sValue2, and sValue4.
$this->assertInArray($k, $ret[$i]);
}
$this->assertEquals(3, count($ret[$i++]));
$this->assertEquals(['sValue1'], $ret[$i++]); // intersection
$this->assertEquals(1, $ret[$i++]); // intersection + store → 1 value in the destination set.
$this->assertEquals(['sValue1'], $ret[$i++]); // sinterstore destination contents
foreach (['sValue1', 'sValue2', 'sValue4'] as $k) { // (skeydest U sKey2) contains sValue1, sValue2, and sValue4.
$this->assertInArray($k, $ret[$i]);
}
$this->assertEquals(3, count($ret[$i++])); // union size
$this->assertEquals(3, $ret[$i++]); // unionstore size
foreach (['sValue1', 'sValue2', 'sValue4'] as $k) { // (skeyUnion) contains sValue1, sValue2, and sValue4.
$this->assertInArray($k, $ret[$i]);
}
$this->assertEquals(3, count($ret[$i++])); // skeyUnion size
$this->assertEquals(['sValue3'], $ret[$i++]); // diff skey1, skey2 : only sValue3 is not shared.
$this->assertEquals(1, $ret[$i++]); // sdiffstore size == 1
$this->assertEquals(['sValue3'], $ret[$i++]); // contents of sDiffDest
$this->assertInArray($ret[$i++], ['sValue1', 'sValue2', 'sValue4']); // we removed an element from sKey2
$this->assertEquals(2, $ret[$i++]); // sKey2 now has 2 elements only.
$this->assertEquals($i, count($ret));
// sorted sets
$ret = $this->redis->multi($mode)
->del('{z}key1', '{z}key2', '{z}key5', '{z}Inter', '{z}Union')
->zadd('{z}key1', 1, 'zValue1')
->zadd('{z}key1', 5, 'zValue5')
->zadd('{z}key1', 2, 'zValue2')
->zRange('{z}key1', 0, -1)
->zRem('{z}key1', 'zValue2')
->zRange('{z}key1', 0, -1)
->zadd('{z}key1', 11, 'zValue11')
->zadd('{z}key1', 12, 'zValue12')
->zadd('{z}key1', 13, 'zValue13')
->zadd('{z}key1', 14, 'zValue14')
->zadd('{z}key1', 15, 'zValue15')
->zRemRangeByScore('{z}key1', 11, 13)
->zrange('{z}key1', 0, -1)
->zRevRange('{z}key1', 0, -1)
->zRangeByScore('{z}key1', 1, 6)
->zCard('{z}key1')
->zScore('{z}key1', 'zValue15')
->zadd('{z}key2', 5, 'zValue5')
->zadd('{z}key2', 2, 'zValue2')
->zInterStore('{z}Inter', ['{z}key1', '{z}key2'])
->zRange('{z}key1', 0, -1)
->zRange('{z}key2', 0, -1)
->zRange('{z}Inter', 0, -1)
->zUnionStore('{z}Union', ['{z}key1', '{z}key2'])
->zRange('{z}Union', 0, -1)
->zadd('{z}key5', 5, 'zValue5')
->zIncrBy('{z}key5', 3, 'zValue5') // fix this
->zScore('{z}key5', 'zValue5')
->zScore('{z}key5', 'unknown')
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertBetween($ret[$i++], 0, 5); // we deleted at most 5 values.
$this->assertEquals(1, $ret[$i++]);
$this->assertEquals(1, $ret[$i++]);
$this->assertEquals(1, $ret[$i++]);
$this->assertEquals(['zValue1', 'zValue2', 'zValue5'], $ret[$i++]);
$this->assertEquals(1, $ret[$i++]);
$this->assertEquals(['zValue1', 'zValue5'], $ret[$i++]);
$this->assertEquals(1, $ret[$i++]); // adding zValue11
$this->assertEquals(1, $ret[$i++]); // adding zValue12
$this->assertEquals(1, $ret[$i++]); // adding zValue13
$this->assertEquals(1, $ret[$i++]); // adding zValue14
$this->assertEquals(1, $ret[$i++]); // adding zValue15
$this->assertEquals(3, $ret[$i++]); // deleted zValue11, zValue12, zValue13
$this->assertEquals(['zValue1', 'zValue5', 'zValue14', 'zValue15'], $ret[$i++]);
$this->assertEquals(['zValue15', 'zValue14', 'zValue5', 'zValue1'], $ret[$i++]);
$this->assertEquals(['zValue1', 'zValue5'], $ret[$i++]);
$this->assertEquals(4, $ret[$i++]); // 4 elements
$this->assertEquals(15.0, $ret[$i++]);
$this->assertEquals(1, $ret[$i++]); // added value
$this->assertEquals(1, $ret[$i++]); // added value
$this->assertEquals(1, $ret[$i++]); // zinter only has 1 value
$this->assertEquals(['zValue1', 'zValue5', 'zValue14', 'zValue15'], $ret[$i++]); // {z}key1 contents
$this->assertEquals(['zValue2', 'zValue5'], $ret[$i++]); // {z}key2 contents
$this->assertEquals(['zValue5'], $ret[$i++]); // {z}inter contents
$this->assertEquals(5, $ret[$i++]); // {z}Union has 5 values (1, 2, 5, 14, 15)
$this->assertEquals(['zValue1', 'zValue2', 'zValue5', 'zValue14', 'zValue15'], $ret[$i++]); // {z}Union contents
$this->assertEquals(1, $ret[$i++]); // added value to {z}key5, with score 5
$this->assertEquals(8.0, $ret[$i++]); // incremented score by 3 → it is now 8.
$this->assertEquals(8.0, $ret[$i++]); // current score is 8.
$this->assertFalse($ret[$i++]); // score for unknown element.
$this->assertEquals($i, count($ret));
// hash
$ret = $this->redis->multi($mode)
->del('hkey1')
->hset('hkey1', 'key1', 'value1')
->hset('hkey1', 'key2', 'value2')
->hset('hkey1', 'key3', 'value3')
->hmget('hkey1', ['key1', 'key2', 'key3'])
->hget('hkey1', 'key1')
->hlen('hkey1')
->hdel('hkey1', 'key2')
->hdel('hkey1', 'key2')
->hexists('hkey1', 'key2')
->hkeys('hkey1')
->hvals('hkey1')
->hgetall('hkey1')
->hset('hkey1', 'valn', 1)
->hset('hkey1', 'val-fail', 'non-string')
->hget('hkey1', 'val-fail')
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertLT(2, $ret[$i++]); // delete
$this->assertEquals(1, $ret[$i++]); // added 1 element
$this->assertEquals(1, $ret[$i++]); // added 1 element
$this->assertEquals(1, $ret[$i++]); // added 1 element
$this->assertEquals(['key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3'], $ret[$i++]); // hmget, 3 elements
$this->assertEquals('value1', $ret[$i++]); // hget
$this->assertEquals(3, $ret[$i++]); // hlen
$this->assertEquals(1, $ret[$i++]); // hdel succeeded
$this->assertEquals(0, $ret[$i++]); // hdel failed
$this->assertFalse($ret[$i++]); // hexists didn't find the deleted key
$this->assertEqualsCanonicalizing(['key1', 'key3'], $ret[$i++]); // hkeys
$this->assertEqualsCanonicalizing(['value1', 'value3'], $ret[$i++]); // hvals
$this->assertEqualsCanonicalizing(['key1' => 'value1', 'key3' => 'value3'], $ret[$i++]); // hgetall
$this->assertEquals(1, $ret[$i++]); // added 1 element
$this->assertEquals(1, $ret[$i++]); // added the element, so 1.
$this->assertEquals('non-string', $ret[$i++]); // hset succeeded
$this->assertEquals($i, count($ret));
$ret = $this->redis->multi($mode) // default to MULTI, not PIPELINE.
->del('test')
->set('test', 'xyz')
->get('test')
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertLTE(1, $ret[$i++]); // delete
$this->assertTrue($ret[$i++]); // added 1 element
$this->assertEquals('xyz', $ret[$i++]);
$this->assertEquals($i, count($ret));
// GitHub issue 78
$this->redis->del('test');
for ($i = 1; $i <= 5; $i++)
$this->redis->zadd('test', $i, (string)$i);
$result = $this->redis->multi($mode)
->zscore('test', '1')
->zscore('test', '6')
->zscore('test', '8')
->zscore('test', '2')
->exec();
$this->assertEquals([1.0, FALSE, FALSE, 2.0], $result);
}
protected function differentType($mode) {
// string
$key = '{hash}string';
$dkey = '{hash}' . __FUNCTION__;
$ret = $this->redis->multi($mode)
->del($key)
->set($key, 'value')
// lists I/F
->rPush($key, 'lvalue')
->lPush($key, 'lvalue')
->lLen($key)
->lPop($key)
->lrange($key, 0, -1)
->lTrim($key, 0, 1)
->lIndex($key, 0)
->lSet($key, 0, 'newValue')
->lrem($key, 'lvalue', 1)
->lPop($key)
->rPop($key)
->rPoplPush($key, $dkey . 'lkey1')
// sets I/F
->sAdd($key, 'sValue1')
->srem($key, 'sValue1')
->sPop($key)
->sMove($key, $dkey . 'skey1', 'sValue1')
->scard($key)
->sismember($key, 'sValue1')
->sInter($key, $dkey . 'skey2')
->sUnion($key, $dkey . 'skey4')
->sDiff($key, $dkey . 'skey7')
->sMembers($key)
->sRandMember($key)
// sorted sets I/F
->zAdd($key, 1, 'zValue1')
->zRem($key, 'zValue1')
->zIncrBy($key, 1, 'zValue1')
->zRank($key, 'zValue1')
->zRevRank($key, 'zValue1')
->zRange($key, 0, -1)
->zRevRange($key, 0, -1)
->zRangeByScore($key, 1, 2)
->zCount($key, 0, -1)
->zCard($key)
->zScore($key, 'zValue1')
->zRemRangeByRank($key, 1, 2)
->zRemRangeByScore($key, 1, 2)
// hash I/F
->hSet($key, 'key1', 'value1')
->hGet($key, 'key1')
->hMGet($key, ['key1'])
->hMSet($key, ['key1' => 'value1'])
->hIncrBy($key, 'key2', 1)
->hExists($key, 'key2')
->hDel($key, 'key2')
->hLen($key)
->hKeys($key)
->hVals($key)
->hGetAll($key)
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertTrue(is_long($ret[$i++])); // delete
$this->assertTrue($ret[$i++]); // set
$this->assertFalse($ret[$i++]); // rpush
$this->assertFalse($ret[$i++]); // lpush
$this->assertFalse($ret[$i++]); // llen
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // lrange
$this->assertFalse($ret[$i++]); // ltrim
$this->assertFalse($ret[$i++]); // lindex
$this->assertFalse($ret[$i++]); // lset
$this->assertFalse($ret[$i++]); // lrem
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // rpop
$this->assertFalse($ret[$i++]); // rpoplush
$this->assertFalse($ret[$i++]); // sadd
$this->assertFalse($ret[$i++]); // srem
$this->assertFalse($ret[$i++]); // spop
$this->assertFalse($ret[$i++]); // smove
$this->assertFalse($ret[$i++]); // scard
$this->assertFalse($ret[$i++]); // sismember
$this->assertFalse($ret[$i++]); // sinter
$this->assertFalse($ret[$i++]); // sunion
$this->assertFalse($ret[$i++]); // sdiff
$this->assertFalse($ret[$i++]); // smembers
$this->assertFalse($ret[$i++]); // srandmember
$this->assertFalse($ret[$i++]); // zadd
$this->assertFalse($ret[$i++]); // zrem
$this->assertFalse($ret[$i++]); // zincrby
$this->assertFalse($ret[$i++]); // zrank
$this->assertFalse($ret[$i++]); // zrevrank
$this->assertFalse($ret[$i++]); // zrange
$this->assertFalse($ret[$i++]); // zreverserange
$this->assertFalse($ret[$i++]); // zrangebyscore
$this->assertFalse($ret[$i++]); // zcount
$this->assertFalse($ret[$i++]); // zcard
$this->assertFalse($ret[$i++]); // zscore
$this->assertFalse($ret[$i++]); // zremrangebyrank
$this->assertFalse($ret[$i++]); // zremrangebyscore
$this->assertFalse($ret[$i++]); // hset
$this->assertFalse($ret[$i++]); // hget
$this->assertFalse($ret[$i++]); // hmget
$this->assertFalse($ret[$i++]); // hmset
$this->assertFalse($ret[$i++]); // hincrby
$this->assertFalse($ret[$i++]); // hexists
$this->assertFalse($ret[$i++]); // hdel
$this->assertFalse($ret[$i++]); // hlen
$this->assertFalse($ret[$i++]); // hkeys
$this->assertFalse($ret[$i++]); // hvals
$this->assertFalse($ret[$i++]); // hgetall
$this->assertEquals($i, count($ret));
// list
$key = '{hash}list';
$dkey = '{hash}' . __FUNCTION__;
$ret = $this->redis->multi($mode)
->del($key)
->lpush($key, 'lvalue')
// string I/F
->get($key)
->getset($key, 'value2')
->append($key, 'append')
->getRange($key, 0, 8)
->mget([$key])
->incr($key)
->incrBy($key, 1)
->decr($key)
->decrBy($key, 1)
// sets I/F
->sAdd($key, 'sValue1')
->srem($key, 'sValue1')
->sPop($key)
->sMove($key, $dkey . 'skey1', 'sValue1')
->scard($key)
->sismember($key, 'sValue1')
->sInter($key, $dkey . 'skey2')
->sUnion($key, $dkey . 'skey4')
->sDiff($key, $dkey . 'skey7')
->sMembers($key)
->sRandMember($key)
// sorted sets I/F
->zAdd($key, 1, 'zValue1')
->zRem($key, 'zValue1')
->zIncrBy($key, 1, 'zValue1')
->zRank($key, 'zValue1')
->zRevRank($key, 'zValue1')
->zRange($key, 0, -1)
->zRevRange($key, 0, -1)
->zRangeByScore($key, 1, 2)
->zCount($key, 0, -1)
->zCard($key)
->zScore($key, 'zValue1')
->zRemRangeByRank($key, 1, 2)
->zRemRangeByScore($key, 1, 2)
// hash I/F
->hSet($key, 'key1', 'value1')
->hGet($key, 'key1')
->hMGet($key, ['key1'])
->hMSet($key, ['key1' => 'value1'])
->hIncrBy($key, 'key2', 1)
->hExists($key, 'key2')
->hDel($key, 'key2')
->hLen($key)
->hKeys($key)
->hVals($key)
->hGetAll($key)
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertTrue(is_long($ret[$i++])); // delete
$this->assertEquals(1, $ret[$i++]); // lpush
$this->assertFalse($ret[$i++]); // get
$this->assertFalse($ret[$i++]); // getset
$this->assertFalse($ret[$i++]); // append
$this->assertFalse($ret[$i++]); // getRange
$this->assertEquals([false], $ret[$i++]); // mget
$this->assertFalse($ret[$i++]); // incr
$this->assertFalse($ret[$i++]); // incrBy
$this->assertFalse($ret[$i++]); // decr
$this->assertFalse($ret[$i++]); // decrBy
$this->assertFalse($ret[$i++]); // sadd
$this->assertFalse($ret[$i++]); // srem
$this->assertFalse($ret[$i++]); // spop
$this->assertFalse($ret[$i++]); // smove
$this->assertFalse($ret[$i++]); // scard
$this->assertFalse($ret[$i++]); // sismember
$this->assertFalse($ret[$i++]); // sinter
$this->assertFalse($ret[$i++]); // sunion
$this->assertFalse($ret[$i++]); // sdiff
$this->assertFalse($ret[$i++]); // smembers
$this->assertFalse($ret[$i++]); // srandmember
$this->assertFalse($ret[$i++]); // zadd
$this->assertFalse($ret[$i++]); // zrem
$this->assertFalse($ret[$i++]); // zincrby
$this->assertFalse($ret[$i++]); // zrank
$this->assertFalse($ret[$i++]); // zrevrank
$this->assertFalse($ret[$i++]); // zrange
$this->assertFalse($ret[$i++]); // zreverserange
$this->assertFalse($ret[$i++]); // zrangebyscore
$this->assertFalse($ret[$i++]); // zcount
$this->assertFalse($ret[$i++]); // zcard
$this->assertFalse($ret[$i++]); // zscore
$this->assertFalse($ret[$i++]); // zremrangebyrank
$this->assertFalse($ret[$i++]); // zremrangebyscore
$this->assertFalse($ret[$i++]); // hset
$this->assertFalse($ret[$i++]); // hget
$this->assertFalse($ret[$i++]); // hmget
$this->assertFalse($ret[$i++]); // hmset
$this->assertFalse($ret[$i++]); // hincrby
$this->assertFalse($ret[$i++]); // hexists
$this->assertFalse($ret[$i++]); // hdel
$this->assertFalse($ret[$i++]); // hlen
$this->assertFalse($ret[$i++]); // hkeys
$this->assertFalse($ret[$i++]); // hvals
$this->assertFalse($ret[$i++]); // hgetall
$this->assertEquals($i, count($ret));
// set
$key = '{hash}set';
$dkey = '{hash}' . __FUNCTION__;
$ret = $this->redis->multi($mode)
->del($key)
->sAdd($key, 'sValue')
// string I/F
->get($key)
->getset($key, 'value2')
->append($key, 'append')
->getRange($key, 0, 8)
->mget([$key])
->incr($key)
->incrBy($key, 1)
->decr($key)
->decrBy($key, 1)
// lists I/F
->rPush($key, 'lvalue')
->lPush($key, 'lvalue')
->lLen($key)
->lPop($key)
->lrange($key, 0, -1)
->lTrim($key, 0, 1)
->lIndex($key, 0)
->lSet($key, 0, 'newValue')
->lrem($key, 'lvalue', 1)
->lPop($key)
->rPop($key)
->rPoplPush($key, $dkey . 'lkey1')
// sorted sets I/F
->zAdd($key, 1, 'zValue1')
->zRem($key, 'zValue1')
->zIncrBy($key, 1, 'zValue1')
->zRank($key, 'zValue1')
->zRevRank($key, 'zValue1')
->zRange($key, 0, -1)
->zRevRange($key, 0, -1)
->zRangeByScore($key, 1, 2)
->zCount($key, 0, -1)
->zCard($key)
->zScore($key, 'zValue1')
->zRemRangeByRank($key, 1, 2)
->zRemRangeByScore($key, 1, 2)
// hash I/F
->hSet($key, 'key1', 'value1')
->hGet($key, 'key1')
->hMGet($key, ['key1'])
->hMSet($key, ['key1' => 'value1'])
->hIncrBy($key, 'key2', 1)
->hExists($key, 'key2')
->hDel($key, 'key2')
->hLen($key)
->hKeys($key)
->hVals($key)
->hGetAll($key)
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertTrue(is_long($ret[$i++])); // delete
$this->assertEquals(1, $ret[$i++]); // zadd
$this->assertFalse($ret[$i++]); // get
$this->assertFalse($ret[$i++]); // getset
$this->assertFalse($ret[$i++]); // append
$this->assertFalse($ret[$i++]); // getRange
$this->assertEquals([false], $ret[$i++]); // mget
$this->assertFalse($ret[$i++]); // incr
$this->assertFalse($ret[$i++]); // incrBy
$this->assertFalse($ret[$i++]); // decr
$this->assertFalse($ret[$i++]); // decrBy
$this->assertFalse($ret[$i++]); // rpush
$this->assertFalse($ret[$i++]); // lpush
$this->assertFalse($ret[$i++]); // llen
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // lrange
$this->assertFalse($ret[$i++]); // ltrim
$this->assertFalse($ret[$i++]); // lindex
$this->assertFalse($ret[$i++]); // lset
$this->assertFalse($ret[$i++]); // lrem
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // rpop
$this->assertFalse($ret[$i++]); // rpoplush
$this->assertFalse($ret[$i++]); // zadd
$this->assertFalse($ret[$i++]); // zrem
$this->assertFalse($ret[$i++]); // zincrby
$this->assertFalse($ret[$i++]); // zrank
$this->assertFalse($ret[$i++]); // zrevrank
$this->assertFalse($ret[$i++]); // zrange
$this->assertFalse($ret[$i++]); // zreverserange
$this->assertFalse($ret[$i++]); // zrangebyscore
$this->assertFalse($ret[$i++]); // zcount
$this->assertFalse($ret[$i++]); // zcard
$this->assertFalse($ret[$i++]); // zscore
$this->assertFalse($ret[$i++]); // zremrangebyrank
$this->assertFalse($ret[$i++]); // zremrangebyscore
$this->assertFalse($ret[$i++]); // hset
$this->assertFalse($ret[$i++]); // hget
$this->assertFalse($ret[$i++]); // hmget
$this->assertFalse($ret[$i++]); // hmset
$this->assertFalse($ret[$i++]); // hincrby
$this->assertFalse($ret[$i++]); // hexists
$this->assertFalse($ret[$i++]); // hdel
$this->assertFalse($ret[$i++]); // hlen
$this->assertFalse($ret[$i++]); // hkeys
$this->assertFalse($ret[$i++]); // hvals
$this->assertFalse($ret[$i++]); // hgetall
$this->assertEquals($i, count($ret));
// sorted set
$key = '{hash}sortedset';
$dkey = '{hash}' . __FUNCTION__;
$ret = $this->redis->multi($mode)
->del($key)
->zAdd($key, 0, 'zValue')
// string I/F
->get($key)
->getset($key, 'value2')
->append($key, 'append')
->getRange($key, 0, 8)
->mget([$key])
->incr($key)
->incrBy($key, 1)
->decr($key)
->decrBy($key, 1)
// lists I/F
->rPush($key, 'lvalue')
->lPush($key, 'lvalue')
->lLen($key)
->lPop($key)
->lrange($key, 0, -1)
->lTrim($key, 0, 1)
->lIndex($key, 0)
->lSet($key, 0, 'newValue')
->lrem($key, 'lvalue', 1)
->lPop($key)
->rPop($key)
->rPoplPush($key, $dkey . 'lkey1')
// sets I/F
->sAdd($key, 'sValue1')
->srem($key, 'sValue1')
->sPop($key)
->sMove($key, $dkey . 'skey1', 'sValue1')
->scard($key)
->sismember($key, 'sValue1')
->sInter($key, $dkey . 'skey2')
->sUnion($key, $dkey . 'skey4')
->sDiff($key, $dkey . 'skey7')
->sMembers($key)
->sRandMember($key)
// hash I/F
->hSet($key, 'key1', 'value1')
->hGet($key, 'key1')
->hMGet($key, ['key1'])
->hMSet($key, ['key1' => 'value1'])
->hIncrBy($key, 'key2', 1)
->hExists($key, 'key2')
->hDel($key, 'key2')
->hLen($key)
->hKeys($key)
->hVals($key)
->hGetAll($key)
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertTrue(is_long($ret[$i++])); // delete
$this->assertEquals(1, $ret[$i++]); // zadd
$this->assertFalse($ret[$i++]); // get
$this->assertFalse($ret[$i++]); // getset
$this->assertFalse($ret[$i++]); // append
$this->assertFalse($ret[$i++]); // getRange
$this->assertEquals([false], $ret[$i++]); // mget
$this->assertFalse($ret[$i++]); // incr
$this->assertFalse($ret[$i++]); // incrBy
$this->assertFalse($ret[$i++]); // decr
$this->assertFalse($ret[$i++]); // decrBy
$this->assertFalse($ret[$i++]); // rpush
$this->assertFalse($ret[$i++]); // lpush
$this->assertFalse($ret[$i++]); // llen
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // lrange
$this->assertFalse($ret[$i++]); // ltrim
$this->assertFalse($ret[$i++]); // lindex
$this->assertFalse($ret[$i++]); // lset
$this->assertFalse($ret[$i++]); // lrem
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // rpop
$this->assertFalse($ret[$i++]); // rpoplush
$this->assertFalse($ret[$i++]); // sadd
$this->assertFalse($ret[$i++]); // srem
$this->assertFalse($ret[$i++]); // spop
$this->assertFalse($ret[$i++]); // smove
$this->assertFalse($ret[$i++]); // scard
$this->assertFalse($ret[$i++]); // sismember
$this->assertFalse($ret[$i++]); // sinter
$this->assertFalse($ret[$i++]); // sunion
$this->assertFalse($ret[$i++]); // sdiff
$this->assertFalse($ret[$i++]); // smembers
$this->assertFalse($ret[$i++]); // srandmember
$this->assertFalse($ret[$i++]); // hset
$this->assertFalse($ret[$i++]); // hget
$this->assertFalse($ret[$i++]); // hmget
$this->assertFalse($ret[$i++]); // hmset
$this->assertFalse($ret[$i++]); // hincrby
$this->assertFalse($ret[$i++]); // hexists
$this->assertFalse($ret[$i++]); // hdel
$this->assertFalse($ret[$i++]); // hlen
$this->assertFalse($ret[$i++]); // hkeys
$this->assertFalse($ret[$i++]); // hvals
$this->assertFalse($ret[$i++]); // hgetall
$this->assertEquals($i, count($ret));
// hash
$key = '{hash}hash';
$dkey = '{hash}' . __FUNCTION__;
$ret = $this->redis->multi($mode)
->del($key)
->hset($key, 'key1', 'hValue')
// string I/F
->get($key)
->getset($key, 'value2')
->append($key, 'append')
->getRange($key, 0, 8)
->mget([$key])
->incr($key)
->incrBy($key, 1)
->decr($key)
->decrBy($key, 1)
// lists I/F
->rPush($key, 'lvalue')
->lPush($key, 'lvalue')
->lLen($key)
->lPop($key)
->lrange($key, 0, -1)
->lTrim($key, 0, 1)
->lIndex($key, 0)
->lSet($key, 0, 'newValue')
->lrem($key, 'lvalue', 1)
->lPop($key)
->rPop($key)
->rPoplPush($key, $dkey . 'lkey1')
// sets I/F
->sAdd($key, 'sValue1')
->srem($key, 'sValue1')
->sPop($key)
->sMove($key, $dkey . 'skey1', 'sValue1')
->scard($key)
->sismember($key, 'sValue1')
->sInter($key, $dkey . 'skey2')
->sUnion($key, $dkey . 'skey4')
->sDiff($key, $dkey . 'skey7')
->sMembers($key)
->sRandMember($key)
// sorted sets I/F
->zAdd($key, 1, 'zValue1')
->zRem($key, 'zValue1')
->zIncrBy($key, 1, 'zValue1')
->zRank($key, 'zValue1')
->zRevRank($key, 'zValue1')
->zRange($key, 0, -1)
->zRevRange($key, 0, -1)
->zRangeByScore($key, 1, 2)
->zCount($key, 0, -1)
->zCard($key)
->zScore($key, 'zValue1')
->zRemRangeByRank($key, 1, 2)
->zRemRangeByScore($key, 1, 2)
->exec();
$i = 0;
$this->assertIsArray($ret);
$this->assertTrue(is_long($ret[$i++])); // delete
$this->assertEquals(1, $ret[$i++]); // hset
$this->assertFalse($ret[$i++]); // get
$this->assertFalse($ret[$i++]); // getset
$this->assertFalse($ret[$i++]); // append
$this->assertFalse($ret[$i++]); // getRange
$this->assertEquals([false], $ret[$i++]); // mget
$this->assertFalse($ret[$i++]); // incr
$this->assertFalse($ret[$i++]); // incrBy
$this->assertFalse($ret[$i++]); // decr
$this->assertFalse($ret[$i++]); // decrBy
$this->assertFalse($ret[$i++]); // rpush
$this->assertFalse($ret[$i++]); // lpush
$this->assertFalse($ret[$i++]); // llen
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // lrange
$this->assertFalse($ret[$i++]); // ltrim
$this->assertFalse($ret[$i++]); // lindex
$this->assertFalse($ret[$i++]); // lset
$this->assertFalse($ret[$i++]); // lrem
$this->assertFalse($ret[$i++]); // lpop
$this->assertFalse($ret[$i++]); // rpop
$this->assertFalse($ret[$i++]); // rpoplush
$this->assertFalse($ret[$i++]); // sadd
$this->assertFalse($ret[$i++]); // srem
$this->assertFalse($ret[$i++]); // spop
$this->assertFalse($ret[$i++]); // smove
$this->assertFalse($ret[$i++]); // scard
$this->assertFalse($ret[$i++]); // sismember
$this->assertFalse($ret[$i++]); // sinter
$this->assertFalse($ret[$i++]); // sunion
$this->assertFalse($ret[$i++]); // sdiff
$this->assertFalse($ret[$i++]); // smembers
$this->assertFalse($ret[$i++]); // srandmember
$this->assertFalse($ret[$i++]); // zadd
$this->assertFalse($ret[$i++]); // zrem
$this->assertFalse($ret[$i++]); // zincrby
$this->assertFalse($ret[$i++]); // zrank
$this->assertFalse($ret[$i++]); // zrevrank
$this->assertFalse($ret[$i++]); // zrange
$this->assertFalse($ret[$i++]); // zreverserange
$this->assertFalse($ret[$i++]); // zrangebyscore
$this->assertFalse($ret[$i++]); // zcount
$this->assertFalse($ret[$i++]); // zcard
$this->assertFalse($ret[$i++]); // zscore
$this->assertFalse($ret[$i++]); // zremrangebyrank
$this->assertFalse($ret[$i++]); // zremrangebyscore
$this->assertEquals($i, count($ret));
}
public function testDifferentTypeString() {
$key = '{hash}string';
$dkey = '{hash}' . __FUNCTION__;
$this->redis->del($key);
$this->assertTrue($this->redis->set($key, 'value'));
// lists I/F
$this->assertFalse($this->redis->rPush($key, 'lvalue'));
$this->assertFalse($this->redis->lPush($key, 'lvalue'));
$this->assertFalse($this->redis->lLen($key));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->lrange($key, 0, -1));
$this->assertFalse($this->redis->lTrim($key, 0, 1));
$this->assertFalse($this->redis->lIndex($key, 0));
$this->assertFalse($this->redis->lSet($key, 0, 'newValue'));
$this->assertFalse($this->redis->lrem($key, 'lvalue', 1));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->rPop($key));
$this->assertFalse($this->redis->rPoplPush($key, $dkey . 'lkey1'));
// sets I/F
$this->assertFalse($this->redis->sAdd($key, 'sValue1'));
$this->assertFalse($this->redis->srem($key, 'sValue1'));
$this->assertFalse($this->redis->sPop($key));
$this->assertFalse($this->redis->sMove($key, $dkey . 'skey1', 'sValue1'));
$this->assertFalse($this->redis->scard($key));
$this->assertFalse($this->redis->sismember($key, 'sValue1'));
$this->assertFalse($this->redis->sInter($key, $dkey. 'skey2'));
$this->assertFalse($this->redis->sUnion($key, $dkey . 'skey4'));
$this->assertFalse($this->redis->sDiff($key, $dkey . 'skey7'));
$this->assertFalse($this->redis->sMembers($key));
$this->assertFalse($this->redis->sRandMember($key));
// sorted sets I/F
$this->assertFalse($this->redis->zAdd($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRem($key, 'zValue1'));
$this->assertFalse($this->redis->zIncrBy($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRevRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRange($key, 0, -1));
$this->assertFalse($this->redis->zRevRange($key, 0, -1));
$this->assertFalse($this->redis->zRangeByScore($key, 1, 2));
$this->assertFalse($this->redis->zCount($key, 0, -1));
$this->assertFalse($this->redis->zCard($key));
$this->assertFalse($this->redis->zScore($key, 'zValue1'));
$this->assertFalse($this->redis->zRemRangeByRank($key, 1, 2));
$this->assertFalse($this->redis->zRemRangeByScore($key, 1, 2));
// hash I/F
$this->assertFalse($this->redis->hSet($key, 'key1', 'value1'));
$this->assertFalse($this->redis->hGet($key, 'key1'));
$this->assertFalse($this->redis->hMGet($key, ['key1']));
$this->assertFalse($this->redis->hMSet($key, ['key1' => 'value1']));
$this->assertFalse($this->redis->hIncrBy($key, 'key2', 1));
$this->assertFalse($this->redis->hExists($key, 'key2'));
$this->assertFalse($this->redis->hDel($key, 'key2'));
$this->assertFalse($this->redis->hLen($key));
$this->assertFalse($this->redis->hKeys($key));
$this->assertFalse($this->redis->hVals($key));
$this->assertFalse($this->redis->hGetAll($key));
}
public function testDifferentTypeList() {
$key = '{hash}list';
$dkey = '{hash}' . __FUNCTION__;
$this->redis->del($key);
$this->assertEquals(1, $this->redis->lPush($key, 'value'));
// string I/F
$this->assertFalse($this->redis->get($key));
$this->assertFalse($this->redis->getset($key, 'value2'));
$this->assertFalse($this->redis->append($key, 'append'));
$this->assertFalse($this->redis->getRange($key, 0, 8));
$this->assertEquals([FALSE], $this->redis->mget([$key]));
$this->assertFalse($this->redis->incr($key));
$this->assertFalse($this->redis->incrBy($key, 1));
$this->assertFalse($this->redis->decr($key));
$this->assertFalse($this->redis->decrBy($key, 1));
// sets I/F
$this->assertFalse($this->redis->sAdd($key, 'sValue1'));
$this->assertFalse($this->redis->srem($key, 'sValue1'));
$this->assertFalse($this->redis->sPop($key));
$this->assertFalse($this->redis->sMove($key, $dkey . 'skey1', 'sValue1'));
$this->assertFalse($this->redis->scard($key));
$this->assertFalse($this->redis->sismember($key, 'sValue1'));
$this->assertFalse($this->redis->sInter($key, $dkey . 'skey2'));
$this->assertFalse($this->redis->sUnion($key, $dkey . 'skey4'));
$this->assertFalse($this->redis->sDiff($key, $dkey . 'skey7'));
$this->assertFalse($this->redis->sMembers($key));
$this->assertFalse($this->redis->sRandMember($key));
// sorted sets I/F
$this->assertFalse($this->redis->zAdd($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRem($key, 'zValue1'));
$this->assertFalse($this->redis->zIncrBy($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRevRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRange($key, 0, -1));
$this->assertFalse($this->redis->zRevRange($key, 0, -1));
$this->assertFalse($this->redis->zRangeByScore($key, 1, 2));
$this->assertFalse($this->redis->zCount($key, 0, -1));
$this->assertFalse($this->redis->zCard($key));
$this->assertFalse($this->redis->zScore($key, 'zValue1'));
$this->assertFalse($this->redis->zRemRangeByRank($key, 1, 2));
$this->assertFalse($this->redis->zRemRangeByScore($key, 1, 2));
// hash I/F
$this->assertFalse($this->redis->hSet($key, 'key1', 'value1'));
$this->assertFalse($this->redis->hGet($key, 'key1'));
$this->assertFalse($this->redis->hMGet($key, ['key1']));
$this->assertFalse($this->redis->hMSet($key, ['key1' => 'value1']));
$this->assertFalse($this->redis->hIncrBy($key, 'key2', 1));
$this->assertFalse($this->redis->hExists($key, 'key2'));
$this->assertFalse($this->redis->hDel($key, 'key2'));
$this->assertFalse($this->redis->hLen($key));
$this->assertFalse($this->redis->hKeys($key));
$this->assertFalse($this->redis->hVals($key));
$this->assertFalse($this->redis->hGetAll($key));
}
public function testDifferentTypeSet() {
$key = '{hash}set';
$dkey = '{hash}' . __FUNCTION__;
$this->redis->del($key);
$this->assertEquals(1, $this->redis->sAdd($key, 'value'));
// string I/F
$this->assertFalse($this->redis->get($key));
$this->assertFalse($this->redis->getset($key, 'value2'));
$this->assertFalse($this->redis->append($key, 'append'));
$this->assertFalse($this->redis->getRange($key, 0, 8));
$this->assertEquals([FALSE], $this->redis->mget([$key]));
$this->assertFalse($this->redis->incr($key));
$this->assertFalse($this->redis->incrBy($key, 1));
$this->assertFalse($this->redis->decr($key));
$this->assertFalse($this->redis->decrBy($key, 1));
// lists I/F
$this->assertFalse($this->redis->rPush($key, 'lvalue'));
$this->assertFalse($this->redis->lPush($key, 'lvalue'));
$this->assertFalse($this->redis->lLen($key));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->lrange($key, 0, -1));
$this->assertFalse($this->redis->lTrim($key, 0, 1));
$this->assertFalse($this->redis->lIndex($key, 0));
$this->assertFalse($this->redis->lSet($key, 0, 'newValue'));
$this->assertFalse($this->redis->lrem($key, 'lvalue', 1));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->rPop($key));
$this->assertFalse($this->redis->rPoplPush($key, $dkey . 'lkey1'));
// sorted sets I/F
$this->assertFalse($this->redis->zAdd($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRem($key, 'zValue1'));
$this->assertFalse($this->redis->zIncrBy($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRevRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRange($key, 0, -1));
$this->assertFalse($this->redis->zRevRange($key, 0, -1));
$this->assertFalse($this->redis->zRangeByScore($key, 1, 2));
$this->assertFalse($this->redis->zCount($key, 0, -1));
$this->assertFalse($this->redis->zCard($key));
$this->assertFalse($this->redis->zScore($key, 'zValue1'));
$this->assertFalse($this->redis->zRemRangeByRank($key, 1, 2));
$this->assertFalse($this->redis->zRemRangeByScore($key, 1, 2));
// hash I/F
$this->assertFalse($this->redis->hSet($key, 'key1', 'value1'));
$this->assertFalse($this->redis->hGet($key, 'key1'));
$this->assertFalse($this->redis->hMGet($key, ['key1']));
$this->assertFalse($this->redis->hMSet($key, ['key1' => 'value1']));
$this->assertFalse($this->redis->hIncrBy($key, 'key2', 1));
$this->assertFalse($this->redis->hExists($key, 'key2'));
$this->assertFalse($this->redis->hDel($key, 'key2'));
$this->assertFalse($this->redis->hLen($key));
$this->assertFalse($this->redis->hKeys($key));
$this->assertFalse($this->redis->hVals($key));
$this->assertFalse($this->redis->hGetAll($key));
}
public function testDifferentTypeSortedSet() {
$key = '{hash}sortedset';
$dkey = '{hash}' . __FUNCTION__;
$this->redis->del($key);
$this->assertEquals(1, $this->redis->zAdd($key, 0, 'value'));
// string I/F
$this->assertFalse($this->redis->get($key));
$this->assertFalse($this->redis->getset($key, 'value2'));
$this->assertFalse($this->redis->append($key, 'append'));
$this->assertFalse($this->redis->getRange($key, 0, 8));
$this->assertEquals([FALSE], $this->redis->mget([$key]));
$this->assertFalse($this->redis->incr($key));
$this->assertFalse($this->redis->incrBy($key, 1));
$this->assertFalse($this->redis->decr($key));
$this->assertFalse($this->redis->decrBy($key, 1));
// lists I/F
$this->assertFalse($this->redis->rPush($key, 'lvalue'));
$this->assertFalse($this->redis->lPush($key, 'lvalue'));
$this->assertFalse($this->redis->lLen($key));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->lrange($key, 0, -1));
$this->assertFalse($this->redis->lTrim($key, 0, 1));
$this->assertFalse($this->redis->lIndex($key, 0));
$this->assertFalse($this->redis->lSet($key, 0, 'newValue'));
$this->assertFalse($this->redis->lrem($key, 'lvalue', 1));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->rPop($key));
$this->assertFalse($this->redis->rPoplPush($key, $dkey . 'lkey1'));
// sets I/F
$this->assertFalse($this->redis->sAdd($key, 'sValue1'));
$this->assertFalse($this->redis->srem($key, 'sValue1'));
$this->assertFalse($this->redis->sPop($key));
$this->assertFalse($this->redis->sMove($key, $dkey . 'skey1', 'sValue1'));
$this->assertFalse($this->redis->scard($key));
$this->assertFalse($this->redis->sismember($key, 'sValue1'));
$this->assertFalse($this->redis->sInter($key, $dkey . 'skey2'));
$this->assertFalse($this->redis->sUnion($key, $dkey . 'skey4'));
$this->assertFalse($this->redis->sDiff($key, $dkey . 'skey7'));
$this->assertFalse($this->redis->sMembers($key));
$this->assertFalse($this->redis->sRandMember($key));
// hash I/F
$this->assertFalse($this->redis->hSet($key, 'key1', 'value1'));
$this->assertFalse($this->redis->hGet($key, 'key1'));
$this->assertFalse($this->redis->hMGet($key, ['key1']));
$this->assertFalse($this->redis->hMSet($key, ['key1' => 'value1']));
$this->assertFalse($this->redis->hIncrBy($key, 'key2', 1));
$this->assertFalse($this->redis->hExists($key, 'key2'));
$this->assertFalse($this->redis->hDel($key, 'key2'));
$this->assertFalse($this->redis->hLen($key));
$this->assertFalse($this->redis->hKeys($key));
$this->assertFalse($this->redis->hVals($key));
$this->assertFalse($this->redis->hGetAll($key));
}
public function testDifferentTypeHash() {
$key = '{hash}hash';
$dkey = '{hash}hash';
$this->redis->del($key);
$this->assertEquals(1, $this->redis->hSet($key, 'key', 'value'));
// string I/F
$this->assertFalse($this->redis->get($key));
$this->assertFalse($this->redis->getset($key, 'value2'));
$this->assertFalse($this->redis->append($key, 'append'));
$this->assertFalse($this->redis->getRange($key, 0, 8));
$this->assertEquals([FALSE], $this->redis->mget([$key]));
$this->assertFalse($this->redis->incr($key));
$this->assertFalse($this->redis->incrBy($key, 1));
$this->assertFalse($this->redis->decr($key));
$this->assertFalse($this->redis->decrBy($key, 1));
// lists I/F
$this->assertFalse($this->redis->rPush($key, 'lvalue'));
$this->assertFalse($this->redis->lPush($key, 'lvalue'));
$this->assertFalse($this->redis->lLen($key));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->lrange($key, 0, -1));
$this->assertFalse($this->redis->lTrim($key, 0, 1));
$this->assertFalse($this->redis->lIndex($key, 0));
$this->assertFalse($this->redis->lSet($key, 0, 'newValue'));
$this->assertFalse($this->redis->lrem($key, 'lvalue', 1));
$this->assertFalse($this->redis->lPop($key));
$this->assertFalse($this->redis->rPop($key));
$this->assertFalse($this->redis->rPoplPush($key, $dkey . 'lkey1'));
// sets I/F
$this->assertFalse($this->redis->sAdd($key, 'sValue1'));
$this->assertFalse($this->redis->srem($key, 'sValue1'));
$this->assertFalse($this->redis->sPop($key));
$this->assertFalse($this->redis->sMove($key, $dkey . 'skey1', 'sValue1'));
$this->assertFalse($this->redis->scard($key));
$this->assertFalse($this->redis->sismember($key, 'sValue1'));
$this->assertFalse($this->redis->sInter($key, $dkey . 'skey2'));
$this->assertFalse($this->redis->sUnion($key, $dkey . 'skey4'));
$this->assertFalse($this->redis->sDiff($key, $dkey . 'skey7'));
$this->assertFalse($this->redis->sMembers($key));
$this->assertFalse($this->redis->sRandMember($key));
// sorted sets I/F
$this->assertFalse($this->redis->zAdd($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRem($key, 'zValue1'));
$this->assertFalse($this->redis->zIncrBy($key, 1, 'zValue1'));
$this->assertFalse($this->redis->zRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRevRank($key, 'zValue1'));
$this->assertFalse($this->redis->zRange($key, 0, -1));
$this->assertFalse($this->redis->zRevRange($key, 0, -1));
$this->assertFalse($this->redis->zRangeByScore($key, 1, 2));
$this->assertFalse($this->redis->zCount($key, 0, -1));
$this->assertFalse($this->redis->zCard($key));
$this->assertFalse($this->redis->zScore($key, 'zValue1'));
$this->assertFalse($this->redis->zRemRangeByRank($key, 1, 2));
$this->assertFalse($this->redis->zRemRangeByScore($key, 1, 2));
}
public function testSerializerPHP() {
$this->checkSerializer(Redis::SERIALIZER_PHP);
// with prefix
$this->redis->setOption(Redis::OPT_PREFIX, 'test:');
$this->checkSerializer(Redis::SERIALIZER_PHP);
$this->redis->setOption(Redis::OPT_PREFIX, '');
}
public function testSerializerIGBinary() {
if ( ! defined('Redis::SERIALIZER_IGBINARY'))
$this->markTestSkipped('Redis::SERIALIZER_IGBINARY is not defined');
$this->checkSerializer(Redis::SERIALIZER_IGBINARY);
// with prefix
$this->redis->setOption(Redis::OPT_PREFIX, 'test:');
$this->checkSerializer(Redis::SERIALIZER_IGBINARY);
$this->redis->setOption(Redis::OPT_PREFIX, '');
/* Test our igbinary header check logic. The check allows us to do
simple INCR type operations even with the serializer enabled, and
should also protect against igbinary-like data from being erroneously
deserialized */
$this->redis->del('incrkey');
$this->redis->set('spoof-1', "\x00\x00\x00\x00");
$this->redis->set('spoof-2', "\x00\x00\x00\x00bad-version1");
$this->redis->set('spoof-3', "\x00\x00\x00\x05bad-version2");
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_IGBINARY);
$this->assertEquals(16, $this->redis->incrby('incrkey', 16));
$this->assertKeyEquals('16', 'incrkey');
$this->assertKeyEquals("\x00\x00\x00\x00", 'spoof-1');
$this->assertKeyEquals("\x00\x00\x00\x00bad-version1", 'spoof-2');
$this->assertKeyEquals("\x00\x00\x00\x05bad-version2", 'spoof-3');
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
$this->redis->del('incrkey', 'spoof-1', 'spoof-2', 'spoof-3');
}
public function testSerializerMsgPack() {
if ( ! defined('Redis::SERIALIZER_MSGPACK'))
$this->markTestSkipped('Redis::SERIALIZER_MSGPACK is not defined');
$this->checkSerializer(Redis::SERIALIZER_MSGPACK);
// with prefix
$this->redis->setOption(Redis::OPT_PREFIX, 'test:');
$this->checkSerializer(Redis::SERIALIZER_MSGPACK);
$this->redis->setOption(Redis::OPT_PREFIX, '');
}
public function testSerializerJSON() {
$this->checkSerializer(Redis::SERIALIZER_JSON);
// with prefix
$this->redis->setOption(Redis::OPT_PREFIX, 'test:');
$this->checkSerializer(Redis::SERIALIZER_JSON);
$this->redis->setOption(Redis::OPT_PREFIX, '');
}
private function checkSerializer($mode) {
$this->redis->del('key');
$this->assertEquals(Redis::SERIALIZER_NONE, $this->redis->getOption(Redis::OPT_SERIALIZER)); // default
$this->assertTrue($this->redis->setOption(Redis::OPT_SERIALIZER, $mode)); // set ok
$this->assertEquals($mode, $this->redis->getOption(Redis::OPT_SERIALIZER)); // get ok
// lPush, rPush
$a = ['hello world', 42, true, ['<tag>' => 1729]];
$this->redis->del('key');
$this->redis->lPush('key', $a[0]);
$this->redis->rPush('key', $a[1]);
$this->redis->rPush('key', $a[2]);
$this->redis->rPush('key', $a[3]);
// lrange
$this->assertEquals($a, $this->redis->lrange('key', 0, -1));
// lIndex
$this->assertEquals($a[0], $this->redis->lIndex('key', 0));
$this->assertEquals($a[1], $this->redis->lIndex('key', 1));
$this->assertEquals($a[2], $this->redis->lIndex('key', 2));
$this->assertEquals($a[3], $this->redis->lIndex('key', 3));
// lrem
$this->assertEquals(1, $this->redis->lrem('key', $a[3]));
$this->assertEquals(array_slice($a, 0, 3), $this->redis->lrange('key', 0, -1));
// lSet
$a[0] = ['k' => 'v']; // update
$this->assertTrue($this->redis->lSet('key', 0, $a[0]));
$this->assertEquals($a[0], $this->redis->lIndex('key', 0));
// lInsert
$this->assertEquals(4, $this->redis->lInsert('key', Redis::BEFORE, $a[0], [1, 2, 3]));
$this->assertEquals(5, $this->redis->lInsert('key', Redis::AFTER, $a[0], [4, 5, 6]));
$a = [[1, 2, 3], $a[0], [4, 5, 6], $a[1], $a[2]];
$this->assertEquals($a, $this->redis->lrange('key', 0, -1));
// sAdd
$this->redis->del('{set}key');
$s = [1,'a', [1, 2, 3], ['k' => 'v']];
$this->assertEquals(1, $this->redis->sAdd('{set}key', $s[0]));
$this->assertEquals(1, $this->redis->sAdd('{set}key', $s[1]));
$this->assertEquals(1, $this->redis->sAdd('{set}key', $s[2]));
$this->assertEquals(1, $this->redis->sAdd('{set}key', $s[3]));
// variadic sAdd
$this->redis->del('k');
$this->assertEquals(3, $this->redis->sAdd('k', 'a', 'b', 'c'));
$this->assertEquals(1, $this->redis->sAdd('k', 'a', 'b', 'c', 'd'));
// srem
$this->assertEquals(1, $this->redis->srem('{set}key', $s[3]));
$this->assertEquals(0, $this->redis->srem('{set}key', $s[3]));
// variadic
$this->redis->del('k');
$this->redis->sAdd('k', 'a', 'b', 'c', 'd');
$this->assertEquals(2, $this->redis->sRem('k', 'a', 'd'));
$this->assertEquals(2, $this->redis->sRem('k', 'b', 'c', 'e'));
$this->assertKeyMissing('k');
// sismember
$this->assertTrue($this->redis->sismember('{set}key', $s[0]));
$this->assertTrue($this->redis->sismember('{set}key', $s[1]));
$this->assertTrue($this->redis->sismember('{set}key', $s[2]));
$this->assertFalse($this->redis->sismember('{set}key', $s[3]));
unset($s[3]);
// sMove
$this->redis->del('{set}tmp');
$this->redis->sMove('{set}key', '{set}tmp', $s[0]);
$this->assertFalse($this->redis->sismember('{set}key', $s[0]));
$this->assertTrue($this->redis->sismember('{set}tmp', $s[0]));
unset($s[0]);
// sorted sets
$z = ['z0', ['k' => 'v'], FALSE, NULL];
$this->redis->del('key');
// zAdd
$this->assertEquals(1, $this->redis->zAdd('key', 0, $z[0]));
$this->assertEquals(1, $this->redis->zAdd('key', 1, $z[1]));
$this->assertEquals(1, $this->redis->zAdd('key', 2, $z[2]));
$this->assertEquals(1, $this->redis->zAdd('key', 3, $z[3]));
// zRem
$this->assertEquals(1, $this->redis->zRem('key', $z[3]));
$this->assertEquals(0, $this->redis->zRem('key', $z[3]));
unset($z[3]);
// variadic
$this->redis->del('k');
$this->redis->zAdd('k', 0, 'a');
$this->redis->zAdd('k', 1, 'b');
$this->redis->zAdd('k', 2, 'c');
$this->assertEquals(2, $this->redis->zRem('k', 'a', 'c'));
$this->assertEquals(1.0, $this->redis->zScore('k', 'b'));
$this->assertEquals(['b' => 1.0], $this->redis->zRange('k', 0, -1, true));
// zRange
$this->assertEquals($z, $this->redis->zRange('key', 0, -1));
// zScore
$this->assertEquals(0.0, $this->redis->zScore('key', $z[0]));
$this->assertEquals(1.0, $this->redis->zScore('key', $z[1]));
$this->assertEquals(2.0, $this->redis->zScore('key', $z[2]));
// zRank
$this->assertEquals(0, $this->redis->zRank('key', $z[0]));
$this->assertEquals(1, $this->redis->zRank('key', $z[1]));
$this->assertEquals(2, $this->redis->zRank('key', $z[2]));
// zRevRank
$this->assertEquals(2, $this->redis->zRevRank('key', $z[0]));
$this->assertEquals(1, $this->redis->zRevRank('key', $z[1]));
$this->assertEquals(0, $this->redis->zRevRank('key', $z[2]));
// zIncrBy
$this->assertEquals(3.0, $this->redis->zIncrBy('key', 1.0, $z[2]));
$this->assertEquals(3.0, $this->redis->zScore('key', $z[2]));
$this->assertEquals(5.0, $this->redis->zIncrBy('key', 2.0, $z[2]));
$this->assertEquals(5.0, $this->redis->zScore('key', $z[2]));
$this->assertEquals(2.0, $this->redis->zIncrBy('key', -3.0, $z[2]));
$this->assertEquals(2.0, $this->redis->zScore('key', $z[2]));
// mset
$a = ['k0' => 1, 'k1' => 42, 'k2' => NULL, 'k3' => FALSE, 'k4' => ['a' => 'b']];
$this->assertTrue($this->redis->mset($a));
foreach ($a as $k => $v) {
$this->assertKeyEquals($v, $k);
}
$a = ['f0' => 1, 'f1' => 42, 'f2' => NULL, 'f3' => FALSE, 'f4' => ['a' => 'b']];
// hSet
$this->redis->del('hash');
foreach ($a as $k => $v) {
$this->assertEquals(1, $this->redis->hSet('hash', $k, $v));
}
// hGet
foreach ($a as $k => $v) {
$this->assertEquals($v, $this->redis->hGet('hash', $k));
}
// hGetAll
$this->assertEquals($a, $this->redis->hGetAll('hash'));
$this->assertTrue($this->redis->hExists('hash', 'f0'));
$this->assertTrue($this->redis->hExists('hash', 'f1'));
$this->assertTrue($this->redis->hExists('hash', 'f2'));
$this->assertTrue($this->redis->hExists('hash', 'f3'));
$this->assertTrue($this->redis->hExists('hash', 'f4'));
// hMSet
$this->redis->del('hash');
$this->redis->hMSet('hash', $a);
foreach ($a as $k => $v) {
$this->assertEquals($v, $this->redis->hGet('hash', $k));
}
// hMget
$hmget = $this->redis->hMget('hash', array_keys($a));
foreach ($hmget as $k => $v) {
$this->assertEquals($a[$k], $v);
}
// mGet
$this->redis->set('a', NULL);
$this->redis->set('b', FALSE);
$this->redis->set('c', 42);
$this->redis->set('d', ['x' => 'y']);
$this->assertEquals([NULL, FALSE, 42, ['x' => 'y']], $this->redis->mGet(['a', 'b', 'c', 'd']));
// pipeline
if ($this->havePipeline()) {
$this->sequence(Redis::PIPELINE);
}
// multi-exec
if ($this->haveMulti()) {
$this->sequence(Redis::MULTI);
}
$this->assertIsArray($this->redis->keys('*'));
// issue #62, hgetall
$this->redis->del('hash1');
$this->redis->hSet('hash1', 'data', 'test 1');
$this->redis->hSet('hash1', 'session_id', 'test 2');
$data = $this->redis->hGetAll('hash1');
$this->assertEquals('test 1', $data['data']);
$this->assertEquals('test 2', $data['session_id']);
// issue #145, serializer with objects.
$this->redis->set('x', [new stdClass, new stdClass]);
$x = $this->redis->get('x');
$this->assertIsArray($x);
if ($mode === Redis::SERIALIZER_JSON) {
$this->assertIsArray($x[0]);
$this->assertIsArray($x[1]);
} else {
$this->assertIsObject($x[0], 'stdClass');
$this->assertIsObject($x[1], 'stdClass');
}
// revert
$this->assertTrue($this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE)); // set ok
$this->assertEquals(Redis::SERIALIZER_NONE, $this->redis->getOption(Redis::OPT_SERIALIZER)); // get ok
}
public function testCompressionLZF() {
if ( ! defined('Redis::COMPRESSION_LZF'))
$this->markTestSkipped();
/* Don't crash on improperly compressed LZF data */
$payload = 'not-actually-lzf-compressed';
$this->redis->set('badlzf', $payload);
$this->redis->setOption(Redis::OPT_COMPRESSION, Redis::COMPRESSION_LZF);
$this->assertKeyEquals($payload, 'badlzf');
$this->redis->setOption(Redis::OPT_COMPRESSION, Redis::COMPRESSION_NONE);
$this->checkCompression(Redis::COMPRESSION_LZF, 0);
}
public function testCompressionZSTD() {
if ( ! defined('Redis::COMPRESSION_ZSTD'))
$this->markTestSkipped();
/* Issue 1936 regression. Make sure we don't overflow on bad data */
$this->redis->del('badzstd');
$this->redis->set('badzstd', '123');
$this->redis->setOption(Redis::OPT_COMPRESSION, Redis::COMPRESSION_ZSTD);
$this->assertKeyEquals('123', 'badzstd');
$this->redis->setOption(Redis::OPT_COMPRESSION, Redis::COMPRESSION_NONE);
$this->checkCompression(Redis::COMPRESSION_ZSTD, 0);
$this->checkCompression(Redis::COMPRESSION_ZSTD, 9);
}
public function testCompressionLZ4() {
if ( ! defined('Redis::COMPRESSION_LZ4'))
$this->markTestSkipped();
$this->checkCompression(Redis::COMPRESSION_LZ4, 0);
$this->checkCompression(Redis::COMPRESSION_LZ4, 9);
}
private function checkCompression($mode, $level) {
$set_cmp = $this->redis->setOption(Redis::OPT_COMPRESSION, $mode);
$this->assertTrue($set_cmp);
if ($set_cmp !== true)
return;
$get_cmp = $this->redis->getOption(Redis::OPT_COMPRESSION);
$this->assertEquals($get_cmp, $mode);
if ($get_cmp !== $mode)
return;
$set_lvl = $this->redis->setOption(Redis::OPT_COMPRESSION_LEVEL, $level);
$this->assertTrue($set_lvl);
if ($set_lvl !== true)
return;
$get_lvl = $this->redis->getOption(Redis::OPT_COMPRESSION_LEVEL);
$this->assertEquals($get_lvl, $level);
if ($get_lvl !== $level)
return;
$val = 'xxxxxxxxxx';
$this->redis->set('key', $val);
$this->assertKeyEquals($val, 'key');
/* Empty data */
$this->redis->set('key', '');
$this->assertKeyEquals('', 'key');
/* Iterate through class sizes */
for ($i = 1; $i <= 65536; $i *= 2) {
foreach ([str_repeat('A', $i), random_bytes($i)] as $val) {
$this->redis->set('key', $val);
$this->assertKeyEquals($val, 'key');
}
}
// Issue 1945. Ensure we decompress data with hmget.
$this->redis->hset('hkey', 'data', 'abc');
$this->assertEquals('abc', current($this->redis->hmget('hkey', ['data'])));
}
public function testDumpRestore() {
if (version_compare($this->version, '2.5.0') < 0)
$this->markTestSkipped();
$this->redis->del('foo');
$this->redis->del('bar');
$this->redis->set('foo', 'this-is-foo');
$this->redis->set('bar', 'this-is-bar');
$d_foo = $this->redis->dump('foo');
$d_bar = $this->redis->dump('bar');
$this->redis->del('foo');
$this->redis->del('bar');
// Assert returns from restore
$this->assertTrue($this->redis->restore('foo', 0, $d_bar));
$this->assertTrue($this->redis->restore('bar', 0, $d_foo));
// Now check that the keys have switched
$this->assertKeyEquals('this-is-bar', 'foo');
$this->assertKeyEquals('this-is-foo', 'bar');
/* Test that we can REPLACE a key */
$this->assertTrue($this->redis->set('foo', 'some-value'));
$this->assertTrue($this->redis->restore('foo', 0, $d_bar, ['REPLACE']));
/* Ensure we can set an absolute TTL */
$this->assertTrue($this->redis->restore('foo', time() + 10, $d_bar, ['REPLACE', 'ABSTTL']));
$this->assertLTE(10, $this->redis->ttl('foo'));
/* Ensure we can set an IDLETIME */
$this->assertTrue($this->redis->restore('foo', 0, $d_bar, ['REPLACE', 'IDLETIME' => 200]));
$this->assertGT(100, $this->redis->object('idletime', 'foo'));
/* We can't neccissarily check this depending on LRU policy, but at least attempt to use
the FREQ option */
$this->assertTrue($this->redis->restore('foo', 0, $d_bar, ['REPLACE', 'FREQ' => 200]));
$this->redis->del('foo');
$this->redis->del('bar');
}
public function testGetLastError() {
// We shouldn't have any errors now
$this->assertNull($this->redis->getLastError());
// test getLastError with a regular command
$this->redis->set('x', 'a');
$this->assertFalse($this->redis->incr('x'));
$incrError = $this->redis->getLastError();
$this->assertGT(0, strlen($incrError));
// clear error
$this->redis->clearLastError();
$this->assertNull($this->redis->getLastError());
}
// Helper function to compare nested results -- from the php.net array_diff page, I believe
private function array_diff_recursive($aArray1, $aArray2) {
$aReturn = [];
foreach ($aArray1 as $mKey => $mValue) {
if (array_key_exists($mKey, $aArray2)) {
if (is_array($mValue)) {
$aRecursiveDiff = $this->array_diff_recursive($mValue, $aArray2[$mKey]);
if (count($aRecursiveDiff)) {
$aReturn[$mKey] = $aRecursiveDiff;
}
} else {
if ($mValue != $aArray2[$mKey]) {
$aReturn[$mKey] = $mValue;
}
}
} else {
$aReturn[$mKey] = $mValue;
}
}
return $aReturn;
}
public function testScript() {
if (version_compare($this->version, '2.5.0') < 0)
$this->markTestSkipped();
// Flush any scripts we have
$this->assertTrue($this->redis->script('flush'));
// Silly scripts to test against
$s1_src = 'return 1';
$s1_sha = sha1($s1_src);
$s2_src = 'return 2';
$s2_sha = sha1($s2_src);
$s3_src = 'return 3';
$s3_sha = sha1($s3_src);
// None should exist
$result = $this->redis->script('exists', $s1_sha, $s2_sha, $s3_sha);
$this->assertIsArray($result, 3);
$this->assertTrue(is_array($result) && count(array_filter($result)) == 0);
// Load them up
$this->assertEquals($s1_sha, $this->redis->script('load', $s1_src));
$this->assertEquals($s2_sha, $this->redis->script('load', $s2_src));
$this->assertEquals($s3_sha, $this->redis->script('load', $s3_src));
// They should all exist
$result = $this->redis->script('exists', $s1_sha, $s2_sha, $s3_sha);
$this->assertTrue(is_array($result) && count(array_filter($result)) == 3);
}
public function testEval() {
if (version_compare($this->version, '2.5.0') < 0)
$this->markTestSkipped();
/* The eval_ro method uses the same underlying handlers as eval so we
only need to verify we can call it. */
if ($this->minVersionCheck('7.0.0'))
$this->assertEquals('1.55', $this->redis->eval_ro("return '1.55'"));
// Basic single line response tests
$this->assertEquals(1, $this->redis->eval('return 1'));
$this->assertEqualsWeak(1.55, $this->redis->eval("return '1.55'"));
$this->assertEquals('hello, world', $this->redis->eval("return 'hello, world'"));
/*
* Keys to be incorporated into lua results
*/
// Make a list
$this->redis->del('{eval-key}-list');
$this->redis->rpush('{eval-key}-list', 'a');
$this->redis->rpush('{eval-key}-list', 'b');
$this->redis->rpush('{eval-key}-list', 'c');
// Make a set
$this->redis->del('{eval-key}-zset');
$this->redis->zadd('{eval-key}-zset', 0, 'd');
$this->redis->zadd('{eval-key}-zset', 1, 'e');
$this->redis->zadd('{eval-key}-zset', 2, 'f');
// Basic keys
$this->redis->set('{eval-key}-str1', 'hello, world');
$this->redis->set('{eval-key}-str2', 'hello again!');
// Use a script to return our list, and verify its response
$list = $this->redis->eval("return redis.call('lrange', KEYS[1], 0, -1)", ['{eval-key}-list'], 1);
$this->assertEquals(['a', 'b', 'c'], $list);
// Use a script to return our zset
$zset = $this->redis->eval("return redis.call('zrange', KEYS[1], 0, -1)", ['{eval-key}-zset'], 1);
$this->assertEquals(['d', 'e', 'f'], $zset);
// Test an empty MULTI BULK response
$this->redis->del('{eval-key}-nolist');
$empty_resp = $this->redis->eval("return redis.call('lrange', '{eval-key}-nolist', 0, -1)",
['{eval-key}-nolist'], 1);
$this->assertEquals([], $empty_resp);
// Now test a nested reply
$nested_script = "
return {
1,2,3, {
redis.call('get', '{eval-key}-str1'),
redis.call('get', '{eval-key}-str2'),
redis.call('lrange', 'not-any-kind-of-list', 0, -1),
{
redis.call('zrange', '{eval-key}-zset', 0, -1),
redis.call('lrange', '{eval-key}-list', 0, -1)
}
}
}
";
$expected = [
1, 2, 3, [
'hello, world',
'hello again!',
[],
[
['d', 'e', 'f'],
['a', 'b', 'c']
]
]
];
// Now run our script, and check our values against each other
$eval_result = $this->redis->eval($nested_script, ['{eval-key}-str1', '{eval-key}-str2', '{eval-key}-zset', '{eval-key}-list'], 4);
$this->assertTrue(
is_array($eval_result) &&
count($this->array_diff_recursive($eval_result, $expected)) == 0
);
/*
* Nested reply wihin a multi/pipeline block
*/
$num_scripts = 10;
$modes = [Redis::MULTI];
if ($this->havePipeline()) $modes[] = Redis::PIPELINE;
foreach ($modes as $mode) {
$this->redis->multi($mode);
for ($i = 0; $i < $num_scripts; $i++) {
$this->redis->eval($nested_script, ['{eval-key}-dummy'], 1);
}
$replies = $this->redis->exec();
foreach ($replies as $reply) {
$this->assertTrue(
is_array($reply) &&
count($this->array_diff_recursive($reply, $expected)) == 0
);
}
}
/*
* KEYS/ARGV
*/
$args_script = 'return {KEYS[1],KEYS[2],KEYS[3],ARGV[1],ARGV[2],ARGV[3]}';
$args_args = ['{k}1', '{k}2', '{k}3', 'v1', 'v2', 'v3'];
$args_result = $this->redis->eval($args_script, $args_args, 3);
$this->assertEquals($args_args, $args_result);
// turn on key prefixing
$this->redis->setOption(Redis::OPT_PREFIX, 'prefix:');
$args_result = $this->redis->eval($args_script, $args_args, 3);
// Make sure our first three are prefixed
for ($i = 0; $i < count($args_result); $i++) {
if ($i < 3) {
$this->assertEquals('prefix:' . $args_args[$i], $args_result[$i]);
} else {
$this->assertEquals($args_args[$i], $args_result[$i]);
}
}
}
public function testEvalSHA() {
if (version_compare($this->version, '2.5.0') < 0)
$this->markTestSkipped();
// Flush any loaded scripts
$this->redis->script('flush');
// Non existent script (but proper sha1), and a random (not) sha1 string
$this->assertFalse($this->redis->evalsha(sha1(uniqid())));
$this->assertFalse($this->redis->evalsha('some-random-data'));
// Load a script
$cb = uniqid(); // To ensure the script is new
$scr = "local cb='$cb' return 1";
$sha = sha1($scr);
// Run it when it doesn't exist, run it with eval, and then run it with sha1
$this->assertFalse($this->redis->evalsha($scr));
$this->assertEquals(1, $this->redis->eval($scr));
$this->assertEquals(1, $this->redis->evalsha($sha));
/* Our evalsha_ro handler is the same as evalsha so just make sure
we can invoke the command */
if ($this->minVersionCheck('7.0.0'))
$this->assertEquals(1, $this->redis->evalsha_ro($sha));
}
public function testSerialize() {
$vals = [1, 1.5, 'one', ['here', 'is', 'an', 'array']];
// Test with no serialization at all
$this->assertEquals('test', $this->redis->_serialize('test'));
$this->assertEquals('1', $this->redis->_serialize(1));
$this->assertEquals('Array', $this->redis->_serialize([]));
$this->assertEquals('Object', $this->redis->_serialize(new stdClass));
foreach ($this->getSerializers() as $mode) {
$enc = [];
$dec = [];
foreach ($vals as $k => $v) {
$enc = $this->redis->_serialize($v);
$dec = $this->redis->_unserialize($enc);
// They should be the same
$this->assertEquals($enc, $dec);
}
}
}
public function testUnserialize() {
$vals = [1, 1.5,'one',['this', 'is', 'an', 'array']];
/* We want to skip SERIALIZER_NONE because strict type checking will
fail on the assertions (which is expected). */
$serializers = array_filter($this->getSerializers(), function($v) {
return $v != Redis::SERIALIZER_NONE;
});
foreach ($serializers as $mode) {
$vals_enc = [];
// Pass them through redis so they're serialized
foreach ($vals as $key => $val) {
$this->redis->setOption(Redis::OPT_SERIALIZER, $mode);
$key = 'key' . ++$key;
$this->redis->del($key);
$this->redis->set($key, $val);
// Clear serializer, get serialized value
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
$vals_enc[] = $this->redis->get($key);
}
// Run through our array comparing values
for ($i = 0; $i < count($vals); $i++) {
// reset serializer
$this->redis->setOption(Redis::OPT_SERIALIZER, $mode);
$this->assertEquals($vals[$i], $this->redis->_unserialize($vals_enc[$i]));
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
}
}
}
public function testCompressHelpers() {
$compressors = $this->getCompressors();
$vals = ['foo', 12345, random_bytes(128), ''];
$oldcmp = $this->redis->getOption(Redis::OPT_COMPRESSION);
foreach ($compressors as $cmp) {
foreach ($vals as $val) {
$this->redis->setOption(Redis::OPT_COMPRESSION, $cmp);
$this->redis->set('cmpkey', $val);
/* Get the value raw */
$this->redis->setOption(Redis::OPT_COMPRESSION, Redis::COMPRESSION_NONE);
$raw = $this->redis->get('cmpkey');
$this->redis->setOption(Redis::OPT_COMPRESSION, $cmp);
$this->assertEquals($raw, $this->redis->_compress($val));
$uncompressed = $this->redis->get('cmpkey');
$this->assertEquals($uncompressed, $this->redis->_uncompress($raw));
}
}
$this->redis->setOption(Redis::OPT_COMPRESSION, $oldcmp);
}
public function testPackHelpers() {
list ($oldser, $oldcmp) = [
$this->redis->getOption(Redis::OPT_SERIALIZER),
$this->redis->getOption(Redis::OPT_COMPRESSION)
];
foreach ($this->getSerializers() as $ser) {
$compressors = $this->getCompressors();
foreach ($compressors as $cmp) {
$this->redis->setOption(Redis::OPT_SERIALIZER, $ser);
$this->redis->setOption(Redis::OPT_COMPRESSION, $cmp);
foreach (['foo', 12345, random_bytes(128), '', ['an', 'array']] as $v) {
/* Can only attempt the array if we're serializing */
if (is_array($v) && $ser == Redis::SERIALIZER_NONE)
continue;
$this->redis->set('packkey', $v);
/* Get the value raw */
$this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_NONE);
$this->redis->setOption(Redis::OPT_COMPRESSION, Redis::COMPRESSION_NONE);
$raw = $this->redis->get('packkey');
$this->redis->setOption(Redis::OPT_SERIALIZER, $ser);
$this->redis->setOption(Redis::OPT_COMPRESSION, $cmp);
$this->assertEquals($raw, $this->redis->_pack($v));
$unpacked = $this->redis->get('packkey');
$this->assertEquals($unpacked, $this->redis->_unpack($raw));
}
}
}
$this->redis->setOption(Redis::OPT_SERIALIZER, $oldser);
$this->redis->setOption(Redis::OPT_COMPRESSION, $oldcmp);
}
public function testPrefix() {
// no prefix
$this->redis->setOption(Redis::OPT_PREFIX, '');
$this->assertEquals('key', $this->redis->_prefix('key'));
// with a prefix
$this->redis->setOption(Redis::OPT_PREFIX, 'some-prefix:');
$this->assertEquals('some-prefix:key', $this->redis->_prefix('key'));
// Clear prefix
$this->redis->setOption(Redis::OPT_PREFIX, '');
}
public function testReplyLiteral() {
$this->redis->setOption(Redis::OPT_REPLY_LITERAL, false);
$this->assertTrue($this->redis->rawCommand('set', 'foo', 'bar'));
$this->assertTrue($this->redis->eval("return redis.call('set', 'foo', 'bar')", [], 0));
$rv = $this->redis->eval("return {redis.call('set', KEYS[1], 'bar'), redis.call('ping')}", ['foo'], 1);
$this->assertEquals([true, true], $rv);
$this->redis->setOption(Redis::OPT_REPLY_LITERAL, true);
$this->assertEquals('OK', $this->redis->rawCommand('set', 'foo', 'bar'));
$this->assertEquals('OK', $this->redis->eval("return redis.call('set', 'foo', 'bar')", [], 0));
// Nested
$rv = $this->redis->eval("return {redis.call('set', KEYS[1], 'bar'), redis.call('ping')}", ['foo'], 1);
$this->assertEquals(['OK', 'PONG'], $rv);
// Reset
$this->redis->setOption(Redis::OPT_REPLY_LITERAL, false);
}
public function testNullArray() {
$key = 'key:arr';
$this->redis->del($key);
foreach ([false => [], true => NULL] as $opt => $test) {
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, $opt);
$r = $this->redis->rawCommand('BLPOP', $key, .05);
$this->assertEquals($test, $r);
$this->redis->multi();
$this->redis->rawCommand('BLPOP', $key, .05);
$r = $this->redis->exec();
$this->assertEquals([$test], $r);
}
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, false);
}
/* Test that we can configure PhpRedis to return NULL for *-1 even nestedwithin replies */
public function testNestedNullArray() {
$this->redis->del('{notaset}');
foreach ([false => [], true => NULL] as $opt => $test) {
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, $opt);
$this->assertEquals([$test, $test], $this->redis->geoPos('{notaset}', 'm1', 'm2'));
$this->redis->multi();
$this->redis->geoPos('{notaset}', 'm1', 'm2');
$this->assertEquals([[$test, $test]], $this->redis->exec());
}
$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, false);
}
public function testConfig() {
/* GET */
$cfg = $this->redis->config('GET', 'timeout');
$this->assertArrayKey($cfg, 'timeout');
$sec = $cfg['timeout'];
/* SET */
foreach ([$sec + 30, $sec] as $val) {
$this->assertTrue($this->redis->config('SET', 'timeout', $val));
$cfg = $this->redis->config('GET', 'timeout');
$this->assertArrayKey($cfg, 'timeout', function ($v) use ($val) {
return $v == $val;
});
}
/* RESETSTAT */
$c1 = count($this->redis->info('commandstats'));
$this->assertTrue($this->redis->config('resetstat'));
$this->assertLT($c1, count($this->redis->info('commandstats')));
/* Ensure invalid calls are handled by PhpRedis */
foreach (['notacommand', 'get', 'set'] as $cmd) {
$this->assertFalse(@$this->redis->config($cmd));
}
$this->assertFalse(@$this->redis->config('set', 'foo'));
/* REWRITE. We don't care if it actually works, just that the
command be attempted */
$res = $this->redis->config('rewrite');
$this->assertIsBool($res);
if ($res == false) {
$this->assertPatternMatch('/.*config.*/', $this->redis->getLastError());
$this->redis->clearLastError();
}
if ( ! $this->minVersionCheck('7.0.0'))
return;
/* Test getting multiple values */
$settings = $this->redis->config('get', ['timeout', 'databases', 'set-max-intset-entries']);
$this->assertTrue(is_array($settings) && isset($settings['timeout']) &&
isset($settings['databases']) && isset($settings['set-max-intset-entries']));
/* Short circuit if the above assertion would have failed */
if ( ! is_array($settings) || ! isset($settings['timeout']) || ! isset($settings['set-max-intset-entries']))
return;
list($timeout, $max_intset) = [$settings['timeout'], $settings['set-max-intset-entries']];
$updates = [
['timeout' => $timeout + 30, 'set-max-intset-entries' => $max_intset + 128],
['timeout' => $timeout, 'set-max-intset-entries' => $max_intset],
];
foreach ($updates as $update) {
$this->assertTrue($this->redis->config('set', $update));
$vals = $this->redis->config('get', array_keys($update));
$this->assertEqualsWeak($vals, $update, true);
}
/* Make sure PhpRedis catches malformed multiple get/set calls */
$this->assertFalse(@$this->redis->config('get', []));
$this->assertFalse(@$this->redis->config('set', []));
$this->assertFalse(@$this->redis->config('set', [0, 1, 2]));
}
public function testReconnectSelect() {
$key = 'reconnect-select';
$value = 'Has been set!';
$original_cfg = $this->redis->config('GET', 'timeout');
// Make sure the default DB doesn't have the key.
$this->redis->select(0);
$this->redis->del($key);
// Set the key on a different DB.
$this->redis->select(5);
$this->redis->set($key, $value);
// Time out after 1 second.
$this->redis->config('SET', 'timeout', '1');
// Wait for the connection to time out. On very old versions
// of Redis we need to wait much longer (TODO: Investigate
// which version exactly)
sleep($this->minVersionCheck('3.0.0') ? 2 : 11);
// Make sure we're still using the same DB.
$this->assertKeyEquals($value, $key);
// Revert the setting.
$this->redis->config('SET', 'timeout', $original_cfg['timeout']);
}
public function testTime() {
if (version_compare($this->version, '2.5.0') < 0)
$this->markTestSkipped();
$time_arr = $this->redis->time();
$this->assertTrue(is_array($time_arr) && count($time_arr) == 2 &&
strval(intval($time_arr[0])) === strval($time_arr[0]) &&
strval(intval($time_arr[1])) === strval($time_arr[1]));
}
public function testReadTimeoutOption() {
$this->assertTrue(defined('Redis::OPT_READ_TIMEOUT'));
$this->redis->setOption(Redis::OPT_READ_TIMEOUT, '12.3');
$this->assertEquals(12.3, $this->redis->getOption(Redis::OPT_READ_TIMEOUT));
}
public function testIntrospection() {
// Simple introspection tests
$this->assertEquals($this->getHost(), $this->redis->getHost());
$this->assertEquals($this->getPort(), $this->redis->getPort());
$this->assertEquals($this->getAuth(), $this->redis->getAuth());
}
public function testTransferredBytes() {
$this->redis->set('key', 'val');
$this->redis->clearTransferredBytes();
$get_tx_resp = "*3\r\n$3\r\nGET\r\n$3\r\nkey\r\n";
$get_rx_resp = "$3\r\nval\r\n";
$this->assertKeyEquals('val', 'key');
list ($tx, $rx) = $this->redis->getTransferredBytes();
$this->assertEquals(strlen($get_tx_resp), $tx);
$this->assertEquals(strlen($get_rx_resp), $rx);
$this->redis->clearTransferredBytes();
$this->redis->multi()->get('key')->get('key')->exec();
list($tx, $rx) = $this->redis->getTransferredBytes();
$this->assertEquals($tx, strlen("*1\r\n$5\r\nMULTI\r\n*1\r\n$4\r\nEXEC\r\n") +
2 * strlen($get_tx_resp));
$this->assertEquals($rx, strlen("+OK\r\n") + strlen("+QUEUED\r\n+QUEUED\r\n") +
strlen("*2\r\n") + 2 * strlen($get_rx_resp));
}
/**
* Scan and variants
*/
protected function get_keyspace_count($db) {
$info = $this->redis->info();
if (isset($info[$db])) {
$info = $info[$db];
$info = explode(',', $info);
$info = explode('=', $info[0]);
return $info[1];
} else {
return 0;
}
}
public function testScan() {
if (version_compare($this->version, '2.8.0') < 0)
$this->markTestSkipped();
// Key count
$key_count = $this->get_keyspace_count('db0');
// Have scan retry
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
// Scan them all
$it = NULL;
while ($keys = $this->redis->scan($it)) {
$key_count -= count($keys);
}
// Should have iterated all keys
$this->assertEquals(0, $key_count);
// Unique keys, for pattern matching
$uniq = uniqid();
for ($i = 0; $i < 10; $i++) {
$this->redis->set($uniq . "::$i", "bar::$i");
}
// Scan just these keys using a pattern match
$it = NULL;
while ($keys = $this->redis->scan($it, "*$uniq*")) {
$i -= count($keys);
}
$this->assertEquals(0, $i);
// SCAN with type is scheduled for release in Redis 6.
if (version_compare($this->version, '6.0.0') >= 0) {
// Use a unique ID so we can find our type keys
$id = uniqid();
// Create some simple keys and lists
for ($i = 0; $i < 3; $i++) {
$simple = "simple:{$id}:$i";
$list = "list:{$id}:$i";
$this->redis->set($simple, $i);
$this->redis->del($list);
$this->redis->rpush($list, ['foo']);
$keys['STRING'][] = $simple;
$keys['LIST'][] = $list;
}
// Make sure we can scan for specific types
foreach ($keys as $type => $vals) {
foreach ([0, 10] as $count) {
$resp = [];
$it = NULL;
while ($scan = $this->redis->scan($it, "*$id*", $count, $type)) {
$resp = array_merge($resp, $scan);
}
$this->assertEqualsCanonicalizing($vals, $resp);
}
}
}
}
public function testScanPrefix() {
$keyid = uniqid();
/* Set some keys with different prefixes */
$prefixes = ['prefix-a:', 'prefix-b:'];
foreach ($prefixes as $prefix) {
$this->redis->setOption(Redis::OPT_PREFIX, $prefix);
$this->redis->set("$keyid", 'LOLWUT');
$all_keys["{$prefix}{$keyid}"] = true;
}
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_PREFIX);
foreach ($prefixes as $prefix) {
$this->redis->setOption(Redis::OPT_PREFIX, $prefix);
$it = NULL;
$keys = $this->redis->scan($it, "*$keyid*");
$this->assertEquals($keys, ["{$prefix}{$keyid}"]);
}
/* Unset the prefix option */
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NOPREFIX);
$it = NULL;
while ($keys = $this->redis->scan($it, "*$keyid*")) {
foreach ($keys as $key) {
unset($all_keys[$key]);
}
}
/* Should have touched every key */
$this->assertEquals(0, count($all_keys));
}
public function testMaxRetriesOption() {
$maxRetriesExpected = 5;
$this->redis->setOption(Redis::OPT_MAX_RETRIES, $maxRetriesExpected);
$maxRetriesActual=$this->redis->getOption(Redis::OPT_MAX_RETRIES);
$this->assertEquals($maxRetriesActual, $maxRetriesExpected);
}
public function testBackoffOptions() {
$algorithms = [
Redis::BACKOFF_ALGORITHM_DEFAULT,
Redis::BACKOFF_ALGORITHM_CONSTANT,
Redis::BACKOFF_ALGORITHM_UNIFORM,
Redis::BACKOFF_ALGORITHM_EXPONENTIAL,
Redis::BACKOFF_ALGORITHM_EQUAL_JITTER,
Redis::BACKOFF_ALGORITHM_FULL_JITTER,
Redis::BACKOFF_ALGORITHM_DECORRELATED_JITTER
];
foreach ($algorithms as $algorithm) {
$this->assertTrue($this->redis->setOption(Redis::OPT_BACKOFF_ALGORITHM, $algorithm));
$this->assertEquals($algorithm, $this->redis->getOption(Redis::OPT_BACKOFF_ALGORITHM));
}
// Invalid algorithm
$this->assertFalse($this->redis->setOption(Redis::OPT_BACKOFF_ALGORITHM, 55555));
foreach ([Redis::OPT_BACKOFF_BASE, Redis::OPT_BACKOFF_CAP] as $option) {
foreach ([500, 750] as $value) {
$this->redis->setOption($option, $value);
$this->assertEquals($value, $this->redis->getOption($option));
}
}
}
public function testHScan() {
if (version_compare($this->version, '2.8.0') < 0)
$this->markTestSkipped();
// Never get empty sets
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
$this->redis->del('hash');
$foo_mems = 0;
for ($i = 0; $i < 100; $i++) {
if ($i > 3) {
$this->redis->hset('hash', "member:$i", "value:$i");
} else {
$this->redis->hset('hash', "foomember:$i", "value:$i");
$foo_mems++;
}
}
// Scan all of them
$it = NULL;
while ($keys = $this->redis->hscan('hash', $it)) {
$i -= count($keys);
}
$this->assertEquals(0, $i);
// Scan just *foomem* (should be 4)
$it = NULL;
while ($keys = $this->redis->hscan('hash', $it, '*foomember*')) {
$foo_mems -= count($keys);
foreach ($keys as $mem => $val) {
$this->assertStringContains('member', $mem);
$this->assertStringContains('value', $val);
}
}
$this->assertEquals(0, $foo_mems);
}
public function testSScan() {
if (version_compare($this->version, '2.8.0') < 0)
$this->markTestSkipped();
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
$this->redis->del('set');
for ($i = 0; $i < 100; $i++) {
$this->redis->sadd('set', "member:$i");
}
// Scan all of them
$it = NULL;
while ($keys = $this->redis->sscan('set', $it)) {
$i -= count($keys);
foreach ($keys as $mem) {
$this->assertStringContains('member', $mem);
}
}
$this->assertEquals(0, $i);
// Scan just ones with zero in them (0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
$it = NULL;
$w_zero = 0;
while ($keys = $this->redis->sscan('set', $it, '*0*')) {
$w_zero += count($keys);
}
$this->assertEquals(10, $w_zero);
}
public function testZScan() {
if (version_compare($this->version, '2.8.0') < 0)
$this->markTestSkipped();
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);
$this->redis->del('zset');
[$t_score, $p_score, $p_count] = [0, 0, 0];
for ($i = 0; $i < 2000; $i++) {
if ($i < 10) {
$this->redis->zadd('zset', $i, "pmem:$i");
$p_score += $i;
$p_count++;
} else {
$this->redis->zadd('zset', $i, "mem:$i");
}
$t_score += $i;
}
// Scan them all
$it = NULL;
while ($keys = $this->redis->zscan('zset', $it)) {
foreach ($keys as $mem => $f_score) {
$t_score -= $f_score;
$i--;
}
}
$this->assertEquals(0, $i);
$this->assertEquals(0., $t_score);
// Just scan 'pmem' members
$it = NULL;
$p_score_old = $p_score;
$p_count_old = $p_count;
while ($keys = $this->redis->zscan('zset', $it, '*pmem*')) {
foreach ($keys as $mem => $f_score) {
$p_score -= $f_score;
$p_count -= 1;
}
}
$this->assertEquals(0., $p_score);
$this->assertEquals(0, $p_count);
// Turn off retrying and we should get some empty results
$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NORETRY);
[$skips, $p_score, $p_count] = [0, $p_score_old, $p_count_old];
$it = NULL;
while (($keys = $this->redis->zscan('zset', $it, '*pmem*')) !== FALSE) {
if (count($keys) == 0) $skips++;
foreach ($keys as $mem => $f_score) {
$p_score -= $f_score;
$p_count -= 1;
}
}
// We should still get all the keys, just with several empty results
$this->assertGT(0, $skips);
$this->assertEquals(0., $p_score);
$this->assertEquals(0, $p_count);
}
/* Make sure we capture errors when scanning */
public function testScanErrors() {
$this->redis->set('scankey', 'simplekey');
foreach (['sScan', 'hScan', 'zScan'] as $method) {
$it = NULL;
$this->redis->$method('scankey', $it);
$this->assertEquals(0, strpos($this->redis->getLastError(), 'WRONGTYPE'));
}
}
//
// HyperLogLog (PF) commands
//
protected function createPFKey($key, $count) {
$mems = [];
for ($i = 0; $i < $count; $i++) {
$mems[] = uniqid('pfmem:');
}
// Estimation by Redis
$this->redis->pfAdd($key, $count);
}
public function testPFCommands() {
if (version_compare($this->version, '2.8.9') < 0)
$this->markTestSkipped();
$mems = [];
for ($i = 0; $i < 1000; $i++) {
if ($i % 2 == 0) {
$mems[] = uniqid();
} else {
$mems[] = $i;
}
}
// How many keys to create
$key_count = 10;
// Iterate prefixing/serialization options
foreach ($this->getSerializers() as $ser) {
foreach (['', 'hl-key-prefix:'] as $prefix) {
$keys = [];
// Now add for each key
for ($i = 0; $i < $key_count; $i++) {
$key = "{key}:$i";
$keys[] = $key;
// Clean up this key
$this->redis->del($key);
// Add to our cardinality set, and confirm we got a valid response
$this->assertGT(0, $this->redis->pfadd($key, $mems));
// Grab estimated cardinality
$card = $this->redis->pfcount($key);
$this->assertIsInt($card);
// Count should be close
$this->assertBetween($card, count($mems) * .9, count($mems) * 1.1);
// The PFCOUNT on this key should be the same as the above returned response
$this->assertEquals($card, $this->redis->pfcount($key));
}
// Clean up merge key
$this->redis->del('pf-merge-{key}');
// Merge the counters
$this->assertTrue($this->redis->pfmerge('pf-merge-{key}', $keys));
// Validate our merged count
$redis_card = $this->redis->pfcount('pf-merge-{key}');
// Merged cardinality should still be roughly 1000
$this->assertBetween($redis_card, count($mems) * .9,
count($mems) * 1.1);
// Clean up merge key
$this->redis->del('pf-merge-{key}');
}
}
}
//
// GEO* command tests
//
protected function rawCommandArray($key, $args) {
return call_user_func_array([$this->redis, 'rawCommand'], $args);
}
protected function addCities($key) {
$this->redis->del($key);
foreach ($this->cities as $city => $longlat) {
$this->redis->geoadd($key, $longlat[0], $longlat[1], $city);
}
}
/* GEOADD */
public function testGeoAdd() {
if ( ! $this->minVersionCheck('3.2'))
$this->markTestSkipped();
$this->redis->del('geokey');
/* Add them one at a time */
foreach ($this->cities as $city => $longlat) {
$this->assertEquals(1, $this->redis->geoadd('geokey', $longlat[0], $longlat[1], $city));
}
/* Add them again, all at once */
$args = ['geokey'];
foreach ($this->cities as $city => $longlat) {
$args = array_merge($args, [$longlat[0], $longlat[1], $city]);
}
/* They all exist, should be nothing added */
$this->assertEquals(call_user_func_array([$this->redis, 'geoadd'], $args), 0);
}
/* GEORADIUS */
public function genericGeoRadiusTest($cmd) {
if ( ! $this->minVersionCheck('3.2.0'))
$this->markTestSkipped();
/* Chico */
$city = 'Chico';
$lng = -121.837478;
$lat = 39.728494;
$this->addCities('{gk}');
/* Pre tested with redis-cli. We're just verifying proper delivery of distance and unit */
if ($cmd == 'georadius' || $cmd == 'georadius_ro') {
$this->assertEquals(['Chico'], $this->redis->$cmd('{gk}', $lng, $lat, 10, 'mi'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $lng, $lat, 30, 'mi'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $lng, $lat, 50, 'km'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $lng, $lat, 50000, 'm'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $lng, $lat, 150000, 'ft'));
$args = [$cmd, '{gk}', $lng, $lat, 500, 'mi'];
/* Test a bad COUNT argument */
foreach ([-1, 0, 'notanumber'] as $count) {
$this->assertFalse(@$this->redis->$cmd('{gk}', $lng, $lat, 10, 'mi', ['count' => $count]));
}
} else {
$this->assertEquals(['Chico'], $this->redis->$cmd('{gk}', $city, 10, 'mi'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $city, 30, 'mi'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $city, 50, 'km'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $city, 50000, 'm'));
$this->assertEquals(['Gridley', 'Chico'], $this->redis->$cmd('{gk}', $city, 150000, 'ft'));
$args = [$cmd, '{gk}', $city, 500, 'mi'];
/* Test a bad COUNT argument */
foreach ([-1, 0, 'notanumber'] as $count) {
$this->assertFalse(@$this->redis->$cmd('{gk}', $city, 10, 'mi', ['count' => $count]));
}
}
/* Options */
$opts = ['WITHCOORD', 'WITHDIST', 'WITHHASH'];
$sortopts = ['', 'ASC', 'DESC'];
$storeopts = ['', 'STORE', 'STOREDIST'];
for ($i = 0; $i < count($opts); $i++) {
$subopts = array_slice($opts, 0, $i);
shuffle($subopts);
$subargs = $args;
foreach ($subopts as $opt) {
$subargs[] = $opt;
}
/* Cannot mix STORE[DIST] with the WITH* arguments */
$realstoreopts = count($subopts) == 0 ? $storeopts : [];
$base_subargs = $subargs;
$base_subopts = $subopts;
foreach ($realstoreopts as $store_type) {
for ($c = 0; $c < 3; $c++) {
$subargs = $base_subargs;
$subopts = $base_subopts;
/* Add a count if we're past first iteration */
if ($c > 0) {
$subopts['count'] = $c;
$subargs[] = 'count';
$subargs[] = $c;
}
/* Adding optional sort */
foreach ($sortopts as $sortopt) {
$realargs = $subargs;
$realopts = $subopts;
if ($sortopt) {
$realargs[] = $sortopt;
$realopts[] = $sortopt;
}
if ($store_type) {
$realopts[$store_type] = "{gk}-$store_type";
$realargs[] = $store_type;
$realargs[] = "{gk}-$store_type";
}
$ret1 = $this->rawCommandArray('{gk}', $realargs);
if ($cmd == 'georadius' || $cmd == 'georadius_ro') {
$ret2 = $this->redis->$cmd('{gk}', $lng, $lat, 500, 'mi', $realopts);
} else {
$ret2 = $this->redis->$cmd('{gk}', $city, 500, 'mi', $realopts);
}
$this->assertEquals($ret1, $ret2);
}
}
}
}
}
public function testGeoRadius() {
if ( ! $this->minVersionCheck('3.2.0'))
$this->markTestSkipped();
$this->genericGeoRadiusTest('georadius');
$this->genericGeoRadiusTest('georadius_ro');
}
public function testGeoRadiusByMember() {
if ( ! $this->minVersionCheck('3.2.0'))
$this->markTestSkipped();
$this->genericGeoRadiusTest('georadiusbymember');
$this->genericGeoRadiusTest('georadiusbymember_ro');
}
public function testGeoPos() {
if ( ! $this->minVersionCheck('3.2.0'))
$this->markTestSkipped();
$this->addCities('gk');
$this->assertEquals($this->rawCommandArray('gk', ['geopos', 'gk', 'Chico', 'Sacramento']), $this->redis->geopos('gk', 'Chico', 'Sacramento'));
$this->assertEquals($this->rawCommandArray('gk', ['geopos', 'gk', 'Cupertino']), $this->redis->geopos('gk', 'Cupertino'));
}
public function testGeoHash() {
if ( ! $this->minVersionCheck('3.2.0'))
$this->markTestSkipped();
$this->addCities('gk');
$this->assertEquals($this->rawCommandArray('gk', ['geohash', 'gk', 'Chico', 'Sacramento']), $this->redis->geohash('gk', 'Chico', 'Sacramento'));
$this->assertEquals($this->rawCommandArray('gk', ['geohash', 'gk', 'Chico']), $this->redis->geohash('gk', 'Chico'));
}
public function testGeoDist() {
if ( ! $this->minVersionCheck('3.2.0'))
$this->markTestSkipped();
$this->addCities('gk');
$r1 = $this->redis->geodist('gk', 'Chico', 'Cupertino');
$r2 = $this->rawCommandArray('gk', ['geodist', 'gk', 'Chico', 'Cupertino']);
$this->assertEquals(round($r1, 8), round($r2, 8));
$r1 = $this->redis->geodist('gk', 'Chico', 'Cupertino', 'km');
$r2 = $this->rawCommandArray('gk', ['geodist', 'gk', 'Chico', 'Cupertino', 'km']);
$this->assertEquals(round($r1, 8), round($r2, 8));
}
public function testGeoSearch() {
if ( ! $this->minVersionCheck('6.2.0'))
$this->markTestSkipped();
$this->addCities('gk');
$this->assertEquals(['Chico'], $this->redis->geosearch('gk', 'Chico', 1, 'm'));
$this->assertValidate($this->redis->geosearch('gk', 'Chico', 1, 'm', ['withcoord', 'withdist', 'withhash']), function ($v) {
$this->assertArrayKey($v, 'Chico', 'is_array');
$this->assertEquals(count($v['Chico']), 3);
$this->assertArrayKey($v['Chico'], 0, 'is_float');
$this->assertArrayKey($v['Chico'], 1, 'is_int');
$this->assertArrayKey($v['Chico'], 2, 'is_array');
return true;
});
}
public function testGeoSearchStore() {
if ( ! $this->minVersionCheck('6.2.0'))
$this->markTestSkipped();
$this->addCities('{gk}src');
$this->assertEquals(3, $this->redis->geosearchstore('{gk}dst', '{gk}src', 'Chico', 100, 'km'));
$this->assertEquals(['Chico'], $this->redis->geosearch('{gk}dst', 'Chico', 1, 'm'));
}
/* Test a 'raw' command */
public function testRawCommand() {
$key = uniqid();
$this->redis->set($key,'some-value');
$result = $this->redis->rawCommand('get', $key);
$this->assertEquals($result, 'some-value');
$this->redis->del('mylist');
$this->redis->rpush('mylist', 'A', 'B', 'C', 'D');
$this->assertEquals(['A', 'B', 'C', 'D'], $this->redis->lrange('mylist', 0, -1));
}
/* STREAMS */
protected function addStreamEntries($key, $count) {
$ids = [];
$this->redis->del($key);
for ($i = 0; $i < $count; $i++) {
$ids[] = $this->redis->xAdd($key, '*', ['field' => "value:$i"]);
}
return $ids;
}
protected function addStreamsAndGroups($streams, $count, $groups) {
$ids = [];
foreach ($streams as $stream) {
$ids[$stream] = $this->addStreamEntries($stream, $count);
foreach ($groups as $group => $id) {
$this->redis->xGroup('CREATE', $stream, $group, $id);
}
}
return $ids;
}
public function testXAdd() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
$this->redis->del('stream');
for ($i = 0; $i < 5; $i++) {
$id = $this->redis->xAdd('stream', '*', ['k1' => 'v1', 'k2' => 'v2']);
$this->assertEquals($i+1, $this->redis->xLen('stream'));
/* Redis should return <timestamp>-<sequence> */
$bits = explode('-', $id);
$this->assertEquals(count($bits), 2);
$this->assertTrue(is_numeric($bits[0]));
$this->assertTrue(is_numeric($bits[1]));
}
/* Test an absolute maximum length */
for ($i = 0; $i < 100; $i++) {
$this->redis->xAdd('stream', '*', ['k' => 'v'], 10);
}
$this->assertEquals(10, $this->redis->xLen('stream'));
/* Not the greatest test but I'm unsure if approximate trimming is
* totally deterministic, so just make sure we are able to add with
* an approximate maxlen argument structure */
$id = $this->redis->xAdd('stream', '*', ['k' => 'v'], 10, true);
$this->assertEquals(count(explode('-', $id)), 2);
/* Empty message should fail */
@$this->redis->xAdd('stream', '*', []);
}
protected function doXRangeTest($reverse) {
$key = '{stream}';
if ($reverse) {
list($cmd,$a1,$a2) = ['xRevRange', '+', 0];
} else {
list($cmd,$a1,$a2) = ['xRange', 0, '+'];
}
$this->redis->del($key);
for ($i = 0; $i < 3; $i++) {
$msg = ['field' => "value:$i"];
$id = $this->redis->xAdd($key, '*', $msg);
$rows[$id] = $msg;
}
$messages = $this->redis->$cmd($key, $a1, $a2);
$this->assertEquals(count($messages), 3);
$i = $reverse ? 2 : 0;
foreach ($messages as $seq => $v) {
$this->assertEquals(count(explode('-', $seq)), 2);
$this->assertEquals($v, ['field' => "value:$i"]);
$i += $reverse ? -1 : 1;
}
/* Test COUNT option */
for ($count = 1; $count <= 3; $count++) {
$messages = $this->redis->$cmd($key, $a1, $a2, $count);
$this->assertEquals(count($messages), $count);
}
}
public function testXRange() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
foreach ([false, true] as $reverse) {
foreach ($this->getSerializers() as $serializer) {
foreach ([NULL, 'prefix:'] as $prefix) {
$this->redis->setOption(Redis::OPT_PREFIX, $prefix);
$this->redis->setOption(Redis::OPT_SERIALIZER, $serializer);
$this->doXRangeTest($reverse);
}
}
}
}
protected function testXLen() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
$this->redis->del('{stream}');
for ($i = 0; $i < 5; $i++) {
$this->redis->xadd('{stream}', '*', ['foo' => 'bar']);
$this->assertEquals($i+1, $this->redis->xLen('{stream}'));
}
}
public function testXGroup() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
/* CREATE MKSTREAM */
$key = 's:' . uniqid();
$this->assertFalse($this->redis->xGroup('CREATE', $key, 'g0', 0));
$this->assertTrue($this->redis->xGroup('CREATE', $key, 'g1', 0, true));
/* XGROUP DESTROY */
$this->assertEquals(1, $this->redis->xGroup('DESTROY', $key, 'g1'));
/* Populate some entries in stream 's' */
$this->addStreamEntries('s', 2);
/* CREATE */
$this->assertTrue($this->redis->xGroup('CREATE', 's', 'mygroup', '$'));
$this->assertFalse($this->redis->xGroup('CREATE', 's', 'mygroup', 'BAD_ID'));
/* BUSYGROUP */
$this->redis->xGroup('CREATE', 's', 'mygroup', '$');
$this->assertEquals(0, strpos($this->redis->getLastError(), 'BUSYGROUP'));
/* SETID */
$this->assertTrue($this->redis->xGroup('SETID', 's', 'mygroup', '$'));
$this->assertFalse($this->redis->xGroup('SETID', 's', 'mygroup', 'BAD_ID'));
$this->assertEquals(0, $this->redis->xGroup('DELCONSUMER', 's', 'mygroup', 'myconsumer'));
if ( ! $this->minVersionCheck('6.2.0'))
return;
/* CREATECONSUMER */
$this->assertEquals(1, $this->redis->del('s'));
$this->assertTrue($this->redis->xgroup('create', 's', 'mygroup', '$', true));
for ($i = 0; $i < 3; $i++) {
$this->assertEquals(1, $this->redis->xgroup('createconsumer', 's', 'mygroup', "c:$i"));
$info = $this->redis->xinfo('consumers', 's', 'mygroup');
$this->assertIsArray($info, $i + 1);
for ($j = 0; $j <= $i; $j++) {
$this->assertTrue(isset($info[$j]) && isset($info[$j]['name']) && $info[$j]['name'] == "c:$j");
}
}
/* Make sure we don't erroneously send options that don't belong to the operation */
$this->assertEquals(1,
$this->redis->xGroup('CREATECONSUMER', 's', 'mygroup', 'fake-consumer', true, 1337));
/* Make sure we handle the case where the user doesn't send enough arguments */
$this->redis->clearLastError();
$this->assertFalse(@$this->redis->xGroup('CREATECONSUMER'));
$this->assertNull($this->redis->getLastError());
$this->assertFalse(@$this->redis->xGroup('create'));
$this->assertNull($this->redis->getLastError());
if ( ! $this->minVersionCheck('7.0.0'))
return;
/* ENTRIESREAD */
$this->assertEquals(1, $this->redis->del('s'));
$this->assertTrue($this->redis->xGroup('create', 's', 'mygroup', '$', true, 1337));
$info = $this->redis->xinfo('groups', 's');
$this->assertTrue(isset($info[0]['entries-read']) && 1337 == (int)$info[0]['entries-read']);
}
public function testXAck() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
for ($n = 1; $n <= 3; $n++) {
$this->addStreamsAndGroups(['{s}'], 3, ['g1' => 0]);
$msg = $this->redis->xReadGroup('g1', 'c1', ['{s}' => '>']);
/* Extract IDs */
$smsg = array_shift($msg);
$ids = array_keys($smsg);
/* Now ACK $n messages */
$ids = array_slice($ids, 0, $n);
$this->assertEquals($n, $this->redis->xAck('{s}', 'g1', $ids));
}
/* Verify sending no IDs is a failure */
$this->assertFalse($this->redis->xAck('{s}', 'g1', []));
}
protected function doXReadTest() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
$row = ['f1' => 'v1', 'f2' => 'v2'];
$msgdata = [
'{stream}-1' => $row,
'{stream}-2' => $row,
];
/* Append a bit of data and populate STREAM queries */
$this->redis->del(array_keys($msgdata));
foreach ($msgdata as $key => $message) {
for ($r = 0; $r < 2; $r++) {
$id = $this->redis->xAdd($key, '*', $message);
$qresult[$key][$id] = $message;
}
$qzero[$key] = 0;
$qnew[$key] = '$';
$keys[] = $key;
}
/* Everything from both streams */
$rmsg = $this->redis->xRead($qzero);
$this->assertEquals($rmsg, $qresult);
/* Test COUNT option */
for ($count = 1; $count <= 2; $count++) {
$rmsg = $this->redis->xRead($qzero, $count);
foreach ($keys as $key) {
$this->assertEquals(count($rmsg[$key]), $count);
}
}
/* Should be empty (no new entries) */
$this->assertEquals(count($this->redis->xRead($qnew)),0);
/* Test against a specific ID */
$id = $this->redis->xAdd('{stream}-1', '*', $row);
$new_id = $this->redis->xAdd('{stream}-1', '*', ['final' => 'row']);
$rmsg = $this->redis->xRead(['{stream}-1' => $id]);
$this->assertEquals(
$this->redis->xRead(['{stream}-1' => $id]),
['{stream}-1' => [$new_id => ['final' => 'row']]]
);
/* Empty query should fail */
$this->assertFalse(@$this->redis->xRead([]));
}
public function testXRead() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
foreach ($this->getSerializers() as $serializer) {
$this->redis->setOption(Redis::OPT_SERIALIZER, $serializer);
$this->doXReadTest();
}
/* Don't need to test BLOCK multiple times */
$m1 = round(microtime(true)*1000);
$this->redis->xRead(['somestream' => '$'], -1, 100);
$m2 = round(microtime(true)*1000);
$this->assertGT(99, $m2 - $m1);
}
protected function compareStreamIds($redis, $control) {
foreach ($control as $stream => $ids) {
$rcount = count($redis[$stream]);
$lcount = count($control[$stream]);
/* We should have the same number of messages */
$this->assertEquals($rcount, $lcount);
/* We should have the exact same IDs */
foreach ($ids as $k => $id) {
$this->assertTrue(isset($redis[$stream][$id]));
}
}
}
public function testXReadGroup() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
/* Create some streams and groups */
$streams = ['{s}-1', '{s}-2'];
$groups = ['group1' => 0, 'group2' => 0];
/* I'm not totally sure why Redis behaves this way, but we have to
* send '>' first and then send ID '0' for subsequent xReadGroup calls
* or Redis will not return any messages. This behavior changed from
* redis 5.0.1 and 5.0.2 but doing it this way works for both versions. */
$qcount = 0;
$query1 = ['{s}-1' => '>', '{s}-2' => '>'];
$query2 = ['{s}-1' => '0', '{s}-2' => '0'];
$ids = $this->addStreamsAndGroups($streams, 1, $groups);
/* Test that we get get the IDs we should */
foreach (['group1', 'group2'] as $group) {
foreach ($ids as $stream => $messages) {
while ($ids[$stream]) {
/* Read more messages */
$query = !$qcount++ ? $query1 : $query2;
$resp = $this->redis->xReadGroup($group, 'consumer', $query);
/* They should match with our local control array */
$this->compareStreamIds($resp, $ids);
/* Remove a message from our control *and* XACK it in Redis */
$id = array_shift($ids[$stream]);
$this->redis->xAck($stream, $group, [$id]);
}
}
}
/* Test COUNT option */
for ($c = 1; $c <= 3; $c++) {
$this->addStreamsAndGroups($streams, 3, $groups);
$resp = $this->redis->xReadGroup('group1', 'consumer', $query1, $c);
foreach ($resp as $stream => $smsg) {
$this->assertEquals(count($smsg), $c);
}
}
/* Test COUNT option with NULL (should be ignored) */
$this->addStreamsAndGroups($streams, 3, $groups, NULL);
$resp = $this->redis->xReadGroup('group1', 'consumer', $query1, NULL);
foreach ($resp as $stream => $smsg) {
$this->assertEquals(count($smsg), 3);
}
/* Finally test BLOCK with a sloppy timing test */
$tm1 = $this->mstime();
$qnew = ['{s}-1' => '>', '{s}-2' => '>'];
$this->redis->xReadGroup('group1', 'c1', $qnew, 0, 100);
$this->assertGTE(100, $this->mstime() - $tm1);
/* Make sure passing NULL to block doesn't block */
$tm1 = $this->mstime();
$this->redis->xReadGroup('group1', 'c1', $qnew, NULL, NULL);
$this->assertLT(100, $this->mstime() - $tm1);
/* Make sure passing bad values to BLOCK or COUNT immediately fails */
$this->assertFalse(@$this->redis->xReadGroup('group1', 'c1', $qnew, -1));
$this->assertFalse(@$this->redis->xReadGroup('group1', 'c1', $qnew, NULL, -1));
}
public function testXPending() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
$rows = 5;
$this->addStreamsAndGroups(['s'], $rows, ['group' => 0]);
$msg = $this->redis->xReadGroup('group', 'consumer', ['s' => 0]);
$ids = array_keys($msg['s']);
for ($n = count($ids); $n >= 0; $n--) {
$xp = $this->redis->xPending('s', 'group');
$this->assertEquals(count($ids), $xp[0]);
/* Verify we're seeing the IDs themselves */
for ($idx = 1; $idx <= 2; $idx++) {
if ($xp[$idx]) {
$this->assertPatternMatch('/^[0-9].*-[0-9].*/', $xp[$idx]);
}
}
if ($ids) {
$id = array_shift($ids);
$this->redis->xAck('s', 'group', [$id]);
}
}
/* Ensure we can have NULL trailing arguments */
$this->assertTrue(is_array($this->redis->xpending('s', 'group', '-', '+', 1, null)));
$this->assertTrue(is_array($this->redis->xpending('s', 'group', NULL, NULL, -1, NULL)));
}
public function testXDel() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
for ($n = 5; $n > 0; $n--) {
$ids = $this->addStreamEntries('s', 5);
$todel = array_slice($ids, 0, $n);
$this->assertEquals(count($todel), $this->redis->xDel('s', $todel));
}
/* Empty array should fail */
$this->assertFalse(@$this->redis->xDel('s', []));
}
public function testXTrim() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
for ($maxlen = 0; $maxlen <= 50; $maxlen += 10) {
$this->addStreamEntries('stream', 100);
$trimmed = $this->redis->xTrim('stream', $maxlen);
$this->assertEquals(100 - $maxlen, $trimmed);
}
/* APPROX trimming isn't easily deterministic, so just make sure we
can call it with the flag */
$this->addStreamEntries('stream', 100);
$this->assertEquals(0, $this->redis->xTrim('stream', 1, true));
/* We need Redis >= 6.2.0 for MINID and LIMIT options */
if ( ! $this->minVersionCheck('6.2.0'))
return;
$this->assertEquals(1, $this->redis->del('stream'));
/* Test minid by generating a stream with more than one */
for ($i = 1; $i < 3; $i++) {
for ($j = 0; $j < 3; $j++) {
$this->redis->xadd('stream', "$i-$j", ['foo' => 'bar']);
}
}
/* MINID of 2-0 */
$this->assertEquals(3, $this->redis->xtrim('stream', 2, false, true));
$this->assertEquals(['2-0', '2-1', '2-2'], array_keys($this->redis->xrange('stream', '0', '+')));
/* TODO: Figure oiut how to test LIMIT deterministically. For now just
send a LIMIT and verify we don't get a failure from Redis. */
$this->assertIsInt(@$this->redis->xtrim('stream', 2, false, false, 3));
}
/* XCLAIM is one of the most complicated commands, with a great deal of different options
* The following test attempts to verify every combination of every possible option. */
public function testXClaim() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
foreach ([0, 100] as $min_idle_time) {
foreach ([false, true] as $justid) {
foreach ([0, 10] as $retrycount) {
/* We need to test not passing TIME/IDLE as well as passing either */
if ($min_idle_time == 0) {
$topts = [[], ['IDLE', 1000000], ['TIME', time() * 1000]];
} else {
$topts = [NULL];
}
foreach ($topts as $tinfo) {
if ($tinfo) {
list($ttype, $tvalue) = $tinfo;
} else {
$ttype = NULL; $tvalue = NULL;
}
/* Add some messages and create a group */
$this->addStreamsAndGroups(['s'], 10, ['group1' => 0]);
/* Create a second stream we can FORCE ownership on */
$fids = $this->addStreamsAndGroups(['f'], 10, ['group1' => 0]);
$fids = $fids['f'];
/* Have consumer 'Mike' read the messages */
$oids = $this->redis->xReadGroup('group1', 'Mike', ['s' => '>']);
$oids = array_keys($oids['s']); /* We're only dealing with stream 's' */
/* Construct our options array */
$opts = [];
if ($justid) $opts[] = 'JUSTID';
if ($retrycount) $opts['RETRYCOUNT'] = $retrycount;
if ($tvalue !== NULL) $opts[$ttype] = $tvalue;
/* Now have pavlo XCLAIM them */
$cids = $this->redis->xClaim('s', 'group1', 'Pavlo', $min_idle_time, $oids, $opts);
if ( ! $justid) $cids = array_keys($cids);
if ($min_idle_time == 0) {
$this->assertEquals($cids, $oids);
/* Append the FORCE option to our second stream where we have not already
* assigned to a PEL group */
$opts[] = 'FORCE';
$freturn = $this->redis->xClaim('f', 'group1', 'Test', 0, $fids, $opts);
if ( ! $justid) $freturn = array_keys($freturn);
$this->assertEquals($freturn, $fids);
if ($retrycount || $tvalue !== NULL) {
$pending = $this->redis->xPending('s', 'group1', 0, '+', 1, 'Pavlo');
if ($retrycount) {
$this->assertEquals($pending[0][3], $retrycount);
}
if ($tvalue !== NULL) {
if ($ttype == 'IDLE') {
/* If testing IDLE the value must be >= what we set */
$this->assertGTE($tvalue, $pending[0][2]);
} else {
/* Timing tests are notoriously irritating but I don't see
* how we'll get >= 20,000 ms between XCLAIM and XPENDING no
* matter how slow the machine/VM running the tests is */
$this->assertLT(20000, $pending[0][2]);
}
}
}
} else {
/* We're verifying that we get no messages when we've set 100 seconds
* as our idle time, which should match nothing */
$this->assertEquals([], $cids);
}
}
}
}
}
}
/* Make sure our XAUTOCLAIM handler works */
public function testXAutoClaim() {
$this->redis->del('ships');
$this->redis->xGroup('CREATE', 'ships', 'combatants', '0-0', true);
// Test an empty xautoclaim reply
$res = $this->redis->xAutoClaim('ships', 'combatants', 'Sisko', 0, '0-0');
$this->assertTrue(is_array($res) && (count($res) == 2 || count($res) == 3));
if (count($res) == 2) {
$this->assertEquals(['0-0', []], $res);
} else {
$this->assertEquals(['0-0', [], []], $res);
}
$this->redis->xAdd('ships', '1424-74205', ['name' => 'Defiant']);
// Consume the ['name' => 'Defiant'] message
$this->redis->xReadGroup('combatants', "Jem'Hadar", ['ships' => '>'], 1);
// The "Jem'Hadar" consumer has the message presently
$pending = $this->redis->xPending('ships', 'combatants');
$this->assertTrue($pending && isset($pending[3][0][0]) && $pending[3][0][0] == "Jem'Hadar");
// Assume control of the pending message with a different consumer.
$res = $this->redis->xAutoClaim('ships', 'combatants', 'Sisko', 0, '0-0');
$this->assertTrue($res && (count($res) == 2 || count($res) == 3));
$this->assertTrue(isset($res[1]['1424-74205']['name']) &&
$res[1]['1424-74205']['name'] == 'Defiant');
// Now the 'Sisko' consumer should own the message
$pending = $this->redis->xPending('ships', 'combatants');
$this->assertTrue(isset($pending[3][0][0]) && $pending[3][0][0] == 'Sisko');
}
public function testXInfo() {
if ( ! $this->minVersionCheck('5.0'))
$this->markTestSkipped();
/* Create some streams and groups */
$stream = 's';
$groups = ['g1' => 0, 'g2' => 0];
$this->addStreamsAndGroups([$stream], 1, $groups);
$info = $this->redis->xInfo('GROUPS', $stream);
$this->assertIsArray($info);
$this->assertEquals(count($info), count($groups));
foreach ($info as $group) {
$this->assertArrayKey($group, 'name');
$this->assertArrayKey($groups, $group['name']);
}
$info = $this->redis->xInfo('STREAM', $stream);
$this->assertIsArray($info);
$this->assertArrayKey($info, 'groups', function ($v) use ($groups) {
return count($groups) == $v;
});
foreach (['first-entry', 'last-entry'] as $key) {
$this->assertArrayKey($info, $key, 'is_array');
}
/* Ensure that default/NULL arguments are ignored */
$info = $this->redis->xInfo('STREAM', $stream, NULL);
$this->assertIsArray($info);
$info = $this->redis->xInfo('STREAM', $stream, NULL, -1);
$this->assertIsArray($info);
/* XINFO STREAM FULL [COUNT N] Requires >= 6.0.0 */
if ( ! $this->minVersionCheck('6.0'))
return;
/* Add some items to the stream so we can test COUNT */
for ($i = 0; $i < 5; $i++) {
$this->redis->xAdd($stream, '*', ['foo' => 'bar']);
}
$info = $this->redis->xInfo('STREAM', $stream, 'full');
$this->assertArrayKey($info, 'length', 'is_numeric');
for ($count = 1; $count < 5; $count++) {
$info = $this->redis->xInfo('STREAM', $stream, 'full', $count);
$n = isset($info['entries']) ? count($info['entries']) : 0;
$this->assertEquals($n, $count);
}
/* Count <= 0 should be ignored */
foreach ([-1, 0] as $count) {
$info = $this->redis->xInfo('STREAM', $stream, 'full', 0);
$n = isset($info['entries']) ? count($info['entries']) : 0;
$this->assertEquals($n, $this->redis->xLen($stream));
}
/* Make sure we can't erroneously send non-null args after null ones */
$this->redis->clearLastError();
$this->assertFalse(@$this->redis->xInfo('FOO', NULL, 'fail', 25));
$this->assertNull($this->redis->getLastError());
$this->assertFalse(@$this->redis->xInfo('FOO', NULL, NULL, -2));
$this->assertNull($this->redis->getLastError());
}
/* Regression test for issue-1831 (XINFO STREAM on an empty stream) */
public function testXInfoEmptyStream() {
/* Configure an empty stream */
$this->redis->del('s');
$this->redis->xAdd('s', '*', ['foo' => 'bar']);
$this->redis->xTrim('s', 0);
$info = $this->redis->xInfo('STREAM', 's');
$this->assertIsArray($info);
$this->assertEquals(0, $info['length']);
$this->assertNull($info['first-entry']);
$this->assertNull($info['last-entry']);
}
public function testInvalidAuthArgs() {
$client = $this->newInstance();
$args = [
[],
[NULL, NULL],
['foo', 'bar', 'baz'],
['a', 'b', 'c', 'd'],
['a', 'b', 'c'],
[['a', 'b'], 'a'],
[['a', 'b', 'c']],
[[NULL, 'pass']],
[[NULL, NULL]],
];
foreach ($args as $arg) {
try {
if (is_array($arg)) {
@call_user_func_array([$client, 'auth'], $arg);
}
} catch (Exception $ex) {
unset($ex); /* Suppress intellisense warning */
} catch (ArgumentCountError $ex) {
unset($ex); /* Suppress intellisense warning */
}
}
}
public function testAcl() {
if ( ! $this->minVersionCheck('6.0'))
$this->markTestSkipped();
/* ACL USERS/SETUSER */
$this->assertTrue($this->redis->acl('SETUSER', 'admin', 'on', '>admin', '+@all'));
$this->assertTrue($this->redis->acl('SETUSER', 'noperm', 'on', '>noperm', '-@all'));
$this->assertInArray('default', $this->redis->acl('USERS'));
/* Verify ACL GETUSER has the correct hash and is in 'nice' format */
$admin = $this->redis->acl('GETUSER', 'admin');
$this->assertInArray(hash('sha256', 'admin'), $admin['passwords']);
/* Now nuke our 'admin' user and make sure it went away */
$this->assertEquals(1, $this->redis->acl('DELUSER', 'admin'));
$this->assertFalse(in_array('admin', $this->redis->acl('USERS')));
/* Try to log in with a bad username/password */
$this->assertThrowsMatch($this->redis,
function($o) { $o->auth(['1337haxx00r', 'lolwut']); }, '/^WRONGPASS.*$/');
/* We attempted a bad login. We should have an ACL log entry */
$log = $this->redis->acl('log');
if ( ! $log || !is_array($log)) {
$this->assert('Expected an array from ACL LOG, got: ' . var_export($log, true));
return;
}
/* Make sure our ACL LOG entries are nice for the user */
$entry = array_shift($log);
$this->assertArrayKey($entry, 'age-seconds', 'is_numeric');
$this->assertArrayKey($entry, 'count', 'is_int');
/* ACL CAT */
$cats = $this->redis->acl('CAT');
foreach (['read', 'write', 'slow'] as $cat) {
$this->assertInArray($cat, $cats);
}
/* ACL CAT <string> */
$cats = $this->redis->acl('CAT', 'string');
foreach (['get', 'set', 'setnx'] as $cat) {
$this->assertInArray($cat, $cats);
}
/* ctype_xdigit even if PHP doesn't have it */
$ctype_xdigit = function($v) {
if (function_exists('ctype_xdigit')) {
return ctype_xdigit($v);
} else {
return strspn(strtoupper($v), '0123456789ABCDEF') == strlen($v);
}
};
/* ACL GENPASS/ACL GENPASS <bits> */
$this->assertValidate($this->redis->acl('GENPASS'), $ctype_xdigit);
$this->assertValidate($this->redis->acl('GENPASS', 1024), $ctype_xdigit);
/* ACL WHOAMI */
$this->assertValidate($this->redis->acl('WHOAMI'), 'strlen');
/* Finally make sure AUTH errors throw an exception */
$r2 = $this->newInstance(true);
/* Test NOPERM exception */
$this->assertTrue($r2->auth(['noperm', 'noperm']));
$this->assertThrowsMatch($r2, function($r) { $r->set('foo', 'bar'); }, '/^NOPERM.*$/');
}
/* If we detect a unix socket make sure we can connect to it in a variety of ways */
public function testUnixSocket() {
if ( ! file_exists('/tmp/redis.sock'))
$this->markTestSkipped();
$sock_tests = [
['/tmp/redis.sock'],
['/tmp/redis.sock', null],
['/tmp/redis.sock', 0],
['/tmp/redis.sock', -1],
];
try {
foreach ($sock_tests as $args) {
$redis = new Redis();
if (count($args) == 2) {
@$redis->connect($args[0], $args[1]);
} else {
@$redis->connect($args[0]);
}
if ($this->getAuth()) {
$this->assertTrue($redis->auth($this->getAuth()));
}
$this->assertTrue($redis->ping());
}
} catch (Exception $ex) {
$this->assert("Exception: {$ex}");
}
}
protected function detectRedis($host, $port) {
$sock = @fsockopen($host, $port, $errno, $errstr, .1);
if ( ! $sock)
return false;
stream_set_timeout($sock, 0, 100000);
$ping_cmd = "*1\r\n$4\r\nPING\r\n";
if (fwrite($sock, $ping_cmd) != strlen($ping_cmd))
return false;
return fread($sock, strlen("+PONG\r\n")) == "+PONG\r\n";
}
/* Test high ports if we detect Redis running there */
public function testHighPorts() {
$ports = array_filter(array_map(function ($port) {
return $this->detectRedis('localhost', $port) ? $port : 0;
}, [32768, 32769, 32770]));
if ( ! $ports)
$this->markTestSkipped();
foreach ($ports as $port) {
$redis = new Redis();
try {
@$redis->connect('localhost', $port);
if ($this->getAuth()) {
$this->assertTrue($redis->auth($this->getAuth()));
}
$this->assertTrue($redis->ping());
} catch(Exception $ex) {
$this->assert("Exception: $ex");
}
}
}
protected function sessionRunner() {
$this->getAuthParts($user, $pass);
return (new SessionHelpers\Runner())
->prefix($this->sessionPrefix())
->handler($this->sessionSaveHandler())
->savePath($this->sessionSavePath());
}
protected function testRequiresMode(string $mode) {
if (php_sapi_name() != $mode) {
$this->markTestSkipped("Test requires PHP running in '$mode' mode");
}
}
public function testSession_compression() {
$this->testRequiresMode('cli');
foreach ($this->getCompressors() as $name => $val) {
$data = "testing_compression_$name";
$runner = $this->sessionRunner()
->maxExecutionTime(300)
->lockingEnabled(true)
->lockWaitTime(-1)
->lockExpires(0)
->data($data)
->compression($name);
$this->assertEquals('SUCCESS', $runner->execFg());
$this->redis->setOption(Redis::OPT_COMPRESSION, $val);
$this->assertPatternMatch("/.*$data.*/", $this->redis->get($runner->getSessionKey()));
$this->redis->setOption(Redis::OPT_COMPRESSION, Redis::COMPRESSION_NONE);
}
}
public function testSession_savedToRedis() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner();
$this->assertEquals('SUCCESS', $runner->execFg());
$this->assertKeyExists($runner->getSessionKey());
}
protected function sessionWaitUsec() {
return ini_get('redis.session.lock_wait_time') *
ini_get('redis.session.lock_retries');
}
protected function sessionWaitSec() {
return $this->sessionWaitUsec() / 1000000.0;
}
public function testSession_lockKeyCorrect() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()->sleep(5);
$this->assertTrue($runner->execBg());
if ( ! $runner->waitForLockKey($this->redis, $this->sessionWaitSec())) {
$this->externalCmdFailure($runner->getCmd(), $runner->output(),
"Failed waiting for session lock key '{$runner->getSessionLockKey()}'",
$runner->getExitCode());
}
}
public function testSession_lockingDisabledByDefault() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()
->lockingEnabled(false)
->sleep(5);
$this->assertEquals('SUCCESS', $runner->execFg());
$this->assertKeyMissing($runner->getSessionLockKey());
}
public function testSession_lockReleasedOnClose() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()
->sleep(1)
->lockingEnabled(true);
$this->assertTrue($runner->execBg());
usleep($this->sessionWaitUsec() + 100000);
$this->assertKeyMissing($runner->getSessionLockKey());
}
public function testSession_lock_ttlMaxExecutionTime() {
$this->testRequiresMode('cli');
$runner1 = $this->sessionRunner()
->sleep(10)
->maxExecutionTime(2);
$this->assertTrue($runner1->execBg());
usleep(100000);
$runner2 = $this->sessionRunner()
->id($runner1->getId())
->sleep(0);
$st = microtime(true);
$this->assertEquals('SUCCESS', $runner2->execFg());
$el = microtime(true) - $st;
$this->assertLT(4, $el);
}
public function testSession_lock_ttlLockExpire() {
$this->testRequiresMode('cli');
$runner1 = $this->sessionRunner()
->sleep(10)
->maxExecutionTime(300)
->lockingEnabled(true)
->lockExpires(2);
$this->assertTrue($runner1->execBg());
usleep(100000);
$runner2 = $this->sessionRunner()
->id($runner1->getId())
->sleep(0);
$st = microtime(true);
$this->assertEquals('SUCCESS', $runner2->execFg());
$this->assertLT(3, microtime(true) - $st);
}
public function testSession_lockHoldCheckBeforeWrite_otherProcessHasLock() {
$this->testRequiresMode('cli');
$id = 'test-id';
$runner = $this->sessionRunner()
->sleep(2)
->lockingEnabled(true)
->lockExpires(1)
->data('firstProcess');
$runner2 = $this->sessionRunner()
->id($runner->getId())
->sleep(0)
->lockingEnabled(true)
->lockExpires(10)
->data('secondProcess');
$this->assertTrue($runner->execBg());
usleep(1500000); // 1.5 sec
$this->assertEquals('SUCCESS', $runner2->execFg());
$this->assertEquals('secondProcess', $runner->getData());
}
public function testSession_lockHoldCheckBeforeWrite_nobodyHasLock() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()
->sleep(2)
->lockingEnabled(true)
->lockExpires(1)
->data('firstProcess');
$this->assertNotEquals('SUCCESS', $runner->execFg());
$this->assertNotEquals('firstProcess', $runner->getData());
}
public function testSession_correctLockRetryCount() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()
->sleep(10);
$this->assertTrue($runner->execBg());
if ( ! $runner->waitForLockKey($this->redis, 2)) {
$this->externalCmdFailure($runner->getCmd(), $runner->output(),
'Failed waiting for session lock key',
$runner->getExitCode());
}
$runner2 = $this->sessionRunner()
->id($runner->getId())
->sleep(0)
->maxExecutionTime(10)
->lockingEnabled(true)
->lockWaitTime(100000)
->lockRetries(10);
$st = microtime(true);
$ex = $runner2->execFg();
if (stripos($ex, 'SUCCESS') !== false) {
$this->externalCmdFailure($runner2->getCmd(), $ex,
'Expected failure but lock was acquired!',
$runner2->getExitCode());
}
$et = microtime(true);
$this->assertBetween($et - $st, 1, 3);
}
public function testSession_defaultLockRetryCount() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()
->sleep(10);
$runner2 = $this->sessionRunner()
->id($runner->getId())
->sleep(0)
->lockingEnabled(true)
->maxExecutionTime(10)
->lockWaitTime(20000)
->lockRetries(0);
$this->assertTrue($runner->execBg());
if ( ! $runner->waitForLockKey($this->redis, 3)) {
$this->externalCmdFailure($runner->getCmd(), $runner->output(),
'Failed waiting for session lock key',
$runner->getExitCode());
}
$st = microtime(true);
$this->assertNotEquals('SUCCESS', $runner2->execFg());
$et = microtime(true);
$this->assertBetween($et - $st, 2, 3);
}
public function testSession_noUnlockOfOtherProcess() {
$this->testRequiresMode('cli');
$st = microtime(true);
$sleep = 3;
$runner = $this->sessionRunner()
->sleep($sleep)
->maxExecutionTime(3);
$tm1 = microtime(true);
/* 1. Start a background process, and wait until we are certain
* the lock was attained. */
$this->assertTrue($runner->execBg());
if ( ! $runner->waitForLockKey($this->redis, 1)) {
$this->assert('Failed waiting for session lock key');
return;
}
/* 2. Attempt to lock the same session. This should force us to
* wait until the first lock is released. */
$runner2 = $this->sessionRunner()
->id($runner->getId())
->sleep(0);
$tm2 = microtime(true);
$this->assertEquals('SUCCESS', $runner2->execFg());
$tm3 = microtime(true);
/* 3. Verify we had to wait for this lock */
$this->assertGTE($sleep - ($tm2 - $tm1), $tm3 - $tm2);
}
public function testSession_lockWaitTime() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()
->sleep(1)
->maxExecutionTime(300);
$runner2 = $this->sessionRunner()
->id($runner->getId())
->sleep(0)
->maxExecutionTime(300)
->lockingEnabled(true)
->lockWaitTime(3000000);
$this->assertTrue($runner->execBg());
usleep(100000);
$st = microtime(true);
$this->assertEquals('SUCCESS', $runner2->execFg());
$et = microtime(true);
$this->assertBetween($et - $st, 2.5, 3.5);
}
public function testMultipleConnect() {
$host = $this->redis->GetHost();
$port = $this->redis->GetPort();
for ($i = 0; $i < 5; $i++) {
$this->redis->connect($host, $port);
if ($this->getAuth()) {
$this->assertTrue($this->redis->auth($this->getAuth()));
}
$this->assertTrue($this->redis->ping());
}
}
public function testConnectException() {
$host = 'github.com';
if (gethostbyname($host) === $host)
$this->markTestSkipped('online test');
$redis = new Redis();
try {
$redis->connect($host, 6379, 0.01);
} catch (Exception $e) {
$this->assertStringContains('timed out', $e->getMessage());
}
}
public function testTlsConnect() {
if (($fp = @fsockopen($this->getHost(), 6378)) == NULL)
$this->markTestSkipped();
fclose($fp);
foreach (['localhost' => true, '127.0.0.1' => false] as $host => $verify) {
$redis = new Redis();
$this->assertTrue($redis->connect('tls://' . $host, 6378, 0, null, 0, 0, [
'stream' => ['verify_peer_name' => $verify, 'verify_peer' => false]
]));
}
}
public function testReset() {
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->assertTrue($this->redis->multi()->select(2)->set('foo', 'bar')->reset());
$this->assertEquals(Redis::ATOMIC, $this->redis->getMode());
$this->assertEquals(0, $this->redis->getDBNum());
}
public function testCopy() {
if (version_compare($this->version, '6.2.0') < 0)
$this->markTestSkipped();
$this->redis->del('{key}dst');
$this->redis->set('{key}src', 'foo');
$this->assertTrue($this->redis->copy('{key}src', '{key}dst'));
$this->assertKeyEquals('foo', '{key}dst');
$this->redis->set('{key}src', 'bar');
$this->assertFalse($this->redis->copy('{key}src', '{key}dst'));
$this->assertKeyEquals('foo', '{key}dst');
$this->assertTrue($this->redis->copy('{key}src', '{key}dst', ['replace' => true]));
$this->assertKeyEquals('bar', '{key}dst');
}
public function testCommand() {
$commands = $this->redis->command();
$this->assertIsArray($commands);
$this->assertEquals(count($commands), $this->redis->command('count'));
if ( ! $this->is_keydb && $this->minVersionCheck('7.0')) {
$infos = $this->redis->command('info');
$this->assertIsArray($infos);
$this->assertEquals(count($infos), count($commands));
}
if (version_compare($this->version, '7.0') >= 0) {
$docs = $this->redis->command('docs');
$this->assertIsArray($docs);
$this->assertEquals(count($docs), 2 * count($commands));
$list = $this->redis->command('list', 'filterby', 'pattern', 'lol*');
$this->assertIsArray($list);
$this->assertEquals(['lolwut'], $list);
}
}
public function testFunction() {
if (version_compare($this->version, '7.0') < 0)
$this->markTestSkipped();
$this->assertTrue($this->redis->function('flush', 'sync'));
$this->assertEquals('mylib', $this->redis->function('load', "#!lua name=mylib\nredis.register_function('myfunc', function(keys, args) return args[1] end)"));
$this->assertEquals('foo', $this->redis->fcall('myfunc', [], ['foo']));
$payload = $this->redis->function('dump');
$this->assertEquals('mylib', $this->redis->function('load', 'replace', "#!lua name=mylib\nredis.register_function{function_name='myfunc', callback=function(keys, args) return args[1] end, flags={'no-writes'}}"));
$this->assertEquals('foo', $this->redis->fcall_ro('myfunc', [], ['foo']));
$this->assertEquals(['running_script' => false, 'engines' => ['LUA' => ['libraries_count' => 1, 'functions_count' => 1]]], $this->redis->function('stats'));
$this->assertTrue($this->redis->function('delete', 'mylib'));
$this->assertTrue($this->redis->function('restore', $payload));
$this->assertEquals([['library_name' => 'mylib', 'engine' => 'LUA', 'functions' => [['name' => 'myfunc', 'description' => false,'flags' => []]]]], $this->redis->function('list'));
$this->assertTrue($this->redis->function('delete', 'mylib'));
}
protected function execWaitAOF() {
return $this->redis->waitaof(0, 0, 0);
}
public function testWaitAOF() {
if ( ! $this->minVersionCheck('7.2.0'))
$this->markTestSkipped();
$res = $this->execWaitAOF();
$this->assertValidate($res, function ($v) {
if ( ! is_array($v) || count($v) != 2)
return false;
return isset($v[0]) && is_int($v[0]) &&
isset($v[1]) && is_int($v[1]);
});
}
/* Make sure we handle a bad option value gracefully */
public function testBadOptionValue() {
$this->assertFalse(@$this->redis->setOption(pow(2, 32), false));
}
protected function regenerateIdHelper(bool $lock, bool $destroy, bool $proxy) {
$this->testRequiresMode('cli');
$data = uniqid('regenerate-id:');
$runner = $this->sessionRunner()
->sleep(0)
->maxExecutionTime(300)
->lockingEnabled(true)
->lockRetries(1)
->data($data);
$this->assertEquals('SUCCESS', $runner->execFg());
$new_id = $runner->regenerateId($lock, $destroy, $proxy);
$this->assertNotEquals($runner->getId(), $new_id);
$this->assertEquals($runner->getData(), $runner->getData());
}
public function testSession_regenerateSessionId_noLock_noDestroy() {
$this->regenerateIdHelper(false, false, false);
}
public function testSession_regenerateSessionId_noLock_withDestroy() {
$this->regenerateIdHelper(false, true, false);
}
public function testSession_regenerateSessionId_withLock_noDestroy() {
$this->regenerateIdHelper(true, false, false);
}
public function testSession_regenerateSessionId_withLock_withDestroy() {
$this->regenerateIdHelper(true, true, false);
}
public function testSession_regenerateSessionId_noLock_noDestroy_withProxy() {
$this->regenerateIdHelper(false, false, true);
}
public function testSession_regenerateSessionId_noLock_withDestroy_withProxy() {
$this->regenerateIdHelper(false, true, true);
}
public function testSession_regenerateSessionId_withLock_noDestroy_withProxy() {
$this->regenerateIdHelper(true, false, true);
}
public function testSession_regenerateSessionId_withLock_withDestroy_withProxy() {
$this->regenerateIdHelper(true, true, true);
}
public function testSession_ttl_equalsToSessionLifetime() {
$this->testRequiresMode('cli');
$runner = $this->sessionRunner()->lifetime(600);
$this->assertEquals('SUCCESS', $runner->execFg());
$this->assertEquals(600, $this->redis->ttl($runner->getSessionKey()));
}
public function testSession_ttl_resetOnWrite() {
$this->testRequiresMode('cli');
$runner1 = $this->sessionRunner()->lifetime(600);
$this->assertEquals('SUCCESS', $runner1->execFg());
$runner2 = $this->sessionRunner()->id($runner1->getId())->lifetime(1800);
$this->assertEquals('SUCCESS', $runner2->execFg());
$this->assertEquals(1800, $this->redis->ttl($runner2->getSessionKey()));
}
public function testSession_ttl_resetOnRead() {
$this->testRequiresMode('cli');
$data = uniqid(__FUNCTION__);
$runner = $this->sessionRunner()->lifetime(600)->data($data);
$this->assertEquals('SUCCESS', $runner->execFg());
$this->redis->expire($runner->getSessionKey(), 9999);
$this->assertEquals($data, $runner->getData());
$this->assertEquals(600, $this->redis->ttl($runner->getSessionKey()));
}
}
?>
Back to Directory
File Manager
<