File manager - Edit - /opt/alt/tests/alt-php84-pecl-redis_6.1.0-7.el8/tests/RedisTest.php
Back
<?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())); } } ?>
| ver. 1.4 |
Github
|
.
| PHP 7.4.33 | Generation time: 0.24 |
proxy
|
phpinfo
|
Settings