<?php defined('PHPREDIS_TESTRUN') or die("Use TestRedis.php to run tests!\n");

require_once(dirname($_SERVER['PHP_SELF'])."/RedisTest.php");

/**

* Most RedisCluster tests should work the same as the standard Redis object

* so we only override specific functions where the prototype is different or

* where we're validating specific cluster mechanisms

*/

class Redis_Cluster_Test extends Redis_Test {

private static $_arr_node_map = [];

private $_arr_redis_types = [

Redis::REDIS_STRING,

Redis::REDIS_SET,

Redis::REDIS_LIST,

Redis::REDIS_ZSET,

Redis::REDIS_HASH

];

private $_arr_failover_types = [

RedisCluster::FAILOVER_NONE,

RedisCluster::FAILOVER_ERROR,

RedisCluster::FAILOVER_DISTRIBUTE

];

/**

* @var string

*/

protected $sessionPrefix = 'PHPREDIS_CLUSTER_SESSION:';

/**

* @var string

*/

protected $sessionSaveHandler = 'rediscluster';

/* Tests we'll skip all together in the context of RedisCluster. The

* RedisCluster class doesn't implement specialized (non-redis) commands

* such as sortAsc, or sortDesc and other commands such as SELECT are

* simply invalid in Redis Cluster */

public function testSortAsc() { return $this->markTestSkipped(); }

public function testSortDesc() { return $this->markTestSkipped(); }

public function testWait() { return $this->markTestSkipped(); }

public function testSelect() { return $this->markTestSkipped(); }

public function testReconnectSelect() { return $this->markTestSkipped(); }

public function testMultipleConnect() { return $this->markTestSkipped(); }

public function testDoublePipeNoOp() { return $this->markTestSkipped(); }

public function testSwapDB() { return $this->markTestSkipped(); }

public function testConnectException() { return $this->markTestSkipped(); }

public function testTlsConnect() { return $this->markTestSkipped(); }

public function testInvalidAuthArgs() { return $this->markTestSkipped(); }

public function testlMove() { return $this->markTestSkipped(); }

public function testsMisMember() { return $this->markTestSkipped(); }

public function testzDiff() { return $this->markTestSkipped(); }

public function testzInter() { return $this->markTestSkipped(); }

public function testzUnion() { return $this->markTestSkipped(); }

public function testzDiffStore() { return $this->markTestSkipped(); }

public function testzMscore() { return $this->marktestSkipped(); }

public function testCopy() { return $this->marktestSkipped(); }

/* Session locking feature is currently not supported in in context of Redis Cluster.

The biggest issue for this is the distribution nature of Redis cluster */

public function testSession_lockKeyCorrect() { return $this->markTestSkipped(); }

public function testSession_lockingDisabledByDefault() { return $this->markTestSkipped(); }

public function testSession_lockReleasedOnClose() { return $this->markTestSkipped(); }

public function testSession_ttlMaxExecutionTime() { return $this->markTestSkipped(); }

public function testSession_ttlLockExpire() { return $this->markTestSkipped(); }

public function testSession_lockHoldCheckBeforeWrite_otherProcessHasLock() { return $this->markTestSkipped(); }

public function testSession_lockHoldCheckBeforeWrite_nobodyHasLock() { return $this->markTestSkipped(); }

public function testSession_correctLockRetryCount() { return $this->markTestSkipped(); }

public function testSession_defaultLockRetryCount() { return $this->markTestSkipped(); }

public function testSession_noUnlockOfOtherProcess() { return $this->markTestSkipped(); }

public function testSession_lockWaitTime() { return $this->markTestSkipped(); }

/* Load our seeds on construction */

public function __construct($str_host, $i_port, $str_auth) {

parent::__construct($str_host, $i_port, $str_auth);

$str_nodemap_file = dirname($_SERVER['PHP_SELF']) . '/nodes/nodemap';

if (!file_exists($str_nodemap_file)) {

fprintf(STDERR, "Error: Can't find nodemap file for seeds!\n");

exit(1);

}

/* Store our node map */

if (!self::$_arr_node_map) {

self::$_arr_node_map = array_filter(

explode("\n", file_get_contents($str_nodemap_file)

));

}

}

/* Override setUp to get info from a specific node */

public function setUp() {

$this->redis = $this->newInstance();

$info = $this->redis->info(uniqid());

$this->version = (isset($info['redis_version'])?$info['redis_version']:'0.0.0');

}

/* Override newInstance as we want a RedisCluster object */

protected function newInstance() {

return new RedisCluster(NULL, self::$_arr_node_map, 30, 30, true, $this->getAuth());

}

/* Overrides for RedisTest where the function signature is different. This

* is only true for a few commands, which by definition have to be directed

* at a specific node */

public function testPing() {

for ($i = 0; $i < 20; $i++) {

$this->assertTrue($this->redis->ping("key:$i"));

$this->assertEquals('BEEP', $this->redis->ping("key:$i", 'BEEP'));

}

/* Make sure both variations work in MULTI mode */

$this->redis->multi();

$this->redis->ping('{ping-test}');

$this->redis->ping('{ping-test}','BEEP');

$this->assertEquals([true, 'BEEP'], $this->redis->exec());

}

public function testRandomKey() {

/* Ensure some keys are present to test */

for ($i = 0; $i < 1000; $i++) {

if (rand(1, 2) == 1) {

$this->redis->set("key:$i", "val:$i");

}

}

for ($i = 0; $i < 1000; $i++) {

$k = $this->redis->randomKey("key:$i");

$this->assertTrue($this->redis->exists($k));

}

}

public function testEcho() {

$this->assertEquals($this->redis->echo('k1', 'hello'), 'hello');

$this->assertEquals($this->redis->echo('k2', 'world'), 'world');

$this->assertEquals($this->redis->echo('k3', " 0123 "), " 0123 ");

}

public function testSortPrefix() {

$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(array('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 testDBSize() {

for ($i = 0; $i < 10; $i++) {

$str_key = "key:$i";

$this->assertTrue($this->redis->flushdb($str_key));

$this->redis->set($str_key, "val:$i");

$this->assertEquals(1, $this->redis->dbsize($str_key));

}

}

public function testInfo() {

$arr_check_keys = [

"redis_version", "arch_bits", "uptime_in_seconds", "uptime_in_days",

"connected_clients", "connected_slaves", "used_memory",

"total_connections_received", "total_commands_processed",

"role"

];

for ($i = 0; $i < 3; $i++) {

$arr_info = $this->redis->info("k:$i");

foreach ($arr_check_keys as $str_check_key) {

$this->assertTrue(isset($arr_info[$str_check_key]));

}

}

}

public function testClient() {

$str_key = 'key-' . rand(1,100);

$this->assertTrue($this->redis->client($str_key, 'setname', 'cluster_tests'));

$arr_clients = $this->redis->client($str_key, 'list');

$this->assertTrue(is_array($arr_clients));

/* Find us in the list */

$str_addr = NULL;

foreach ($arr_clients as $arr_client) {

if ($arr_client['name'] == 'cluster_tests') {

$str_addr = $arr_client['addr'];

break;

}

}

/* We should be in there */

$this->assertFalse(empty($str_addr));

/* Kill our own client! */

$this->assertTrue($this->redis->client($str_key, 'kill', $str_addr));

}

public function testTime() {

$time_arr = $this->redis->time("k:" . rand(1,100));

$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 testScan() {

$i_key_count = 0;

$i_scan_count = 0;

/* Have scan retry for us */

$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);

/* Iterate over our masters, scanning each one */

foreach ($this->redis->_masters() as $arr_master) {

/* Grab the number of keys we have */

$i_key_count += $this->redis->dbsize($arr_master);

/* Scan the keys here */

$it = NULL;

while ($arr_keys = $this->redis->scan($it, $arr_master)) {

$i_scan_count += count($arr_keys);

}

}

/* Our total key count should match */

$this->assertEquals($i_scan_count, $i_key_count);

}

public function testScanPrefix() {

$arr_prefixes = ['prefix-a:', 'prefix-b:'];

$str_id = uniqid();

$arr_keys = [];

foreach ($arr_prefixes as $str_prefix) {

$this->redis->setOption(Redis::OPT_PREFIX, $str_prefix);

$this->redis->set($str_id, "LOLWUT");

$arr_keys[$str_prefix] = $str_id;

}

$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_RETRY);

$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_PREFIX);

foreach ($arr_prefixes as $str_prefix) {

$arr_prefix_keys = [];

$this->redis->setOption(Redis::OPT_PREFIX, $str_prefix);

foreach ($this->redis->_masters() as $arr_master) {

$it = NULL;

while ($arr_iter = $this->redis->scan($it, $arr_master, "*$str_id*")) {

foreach ($arr_iter as $str_key) {

$arr_prefix_keys[$str_prefix] = $str_key;

}

}

}

$this->assertTrue(count($arr_prefix_keys) == 1 && isset($arr_prefix_keys[$str_prefix]));

}

$this->redis->setOption(Redis::OPT_SCAN, Redis::SCAN_NOPREFIX);

$arr_scan_keys = [];

foreach ($this->redis->_masters() as $arr_master) {

$it = NULL;

while ($arr_iter = $this->redis->scan($it, $arr_master, "*$str_id*")) {

foreach ($arr_iter as $str_key) {

$arr_scan_keys[] = $str_key;

}

}

}

/* We should now have both prefixs' keys */

foreach ($arr_keys as $str_prefix => $str_id) {

$this->assertTrue(in_array("${str_prefix}${str_id}", $arr_scan_keys));

}

}

// 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() {

// PUBSUB CHANNELS ...

$result = $this->redis->pubsub("somekey", "channels", "*");

$this->assertTrue(is_array($result));

$result = $this->redis->pubsub("somekey", "channels");

$this->assertTrue(is_array($result));

// PUBSUB NUMSUB

$c1 = '{pubsub}-' . rand(1,100);

$c2 = '{pubsub}-' . rand(1,100);

$result = $this->redis->pubsub("{pubsub}", "numsub", $c1, $c2);

// Should get an array back, with two elements

$this->assertTrue(is_array($result));

$this->assertEquals(count($result), 4);

$arr_zipped = [];

for ($i = 0; $i <= count($result) / 2; $i+=2) {

$arr_zipped[$result[$i]] = $result[$i+1];

}

$result = $arr_zipped;

// Make sure the elements are correct, and have zero counts

foreach([$c1,$c2] as $channel) {

$this->assertTrue(isset($result[$channel]));

$this->assertEquals($result[$channel], 0);

}

// PUBSUB NUMPAT

$result = $this->redis->pubsub("somekey", "numpat");

$this->assertTrue(is_int($result));

// Invalid call

$this->assertFalse($this->redis->pubsub("somekey", "notacommand"));

}

/* Unlike Redis proper, MsetNX won't always totally fail if all keys can't

* be set, but rather will only fail per-node when that is the case */

public function testMSetNX() {

/* All of these keys should get set */

$this->redis->del('x','y','z');

$ret = $this->redis->msetnx(['x'=>'a','y'=>'b','z'=>'c']);

$this->assertTrue(is_array($ret));

$this->assertEquals(array_sum($ret),count($ret));

/* Delete one key */

$this->redis->del('x');

$ret = $this->redis->msetnx(['x'=>'a','y'=>'b','z'=>'c']);

$this->assertTrue(is_array($ret));

$this->assertEquals(array_sum($ret),1);

$this->assertFalse($this->redis->msetnx(array())); // set ø → FALSE

}

/* Slowlog needs to take a key or [ip, port], to direct it to a node */

public function testSlowlog() {

$str_key = uniqid() . '-' . rand(1, 1000);

$this->assertTrue(is_array($this->redis->slowlog($str_key, 'get')));

$this->assertTrue(is_array($this->redis->slowlog($str_key, 'get', 10)));

$this->assertTrue(is_int($this->redis->slowlog($str_key, 'len')));

$this->assertTrue($this->redis->slowlog($str_key, 'reset'));

$this->assertFalse($this->redis->slowlog($str_key, 'notvalid'));

}

/* INFO COMMANDSTATS requires a key or ip:port for node direction */

public function testInfoCommandStats() {

$str_key = uniqid() . '-' . rand(1,1000);

$arr_info = $this->redis->info($str_key, "COMMANDSTATS");

$this->assertTrue(is_array($arr_info));

if (is_array($arr_info)) {

foreach($arr_info as $k => $str_value) {

$this->assertTrue(strpos($k, 'cmdstat_') !== false);

}

}

}

/* RedisCluster will always respond with an array, even if transactions

* failed, because the commands could be coming from multiple nodes */

public function testFailedTransactions() {

$this->redis->set('x', 42);

// failed transaction

$this->redis->watch('x');

$r = $this->newInstance(); // new instance, modifying `x'.

$r->incr('x');

// This transaction should fail because the other client changed 'x'

$ret = $this->redis->multi()->get('x')->exec();

$this->assertTrue($ret === [false]);

// watch and unwatch

$this->redis->watch('x');

$r->incr('x'); // other instance

$this->redis->unwatch('x'); // cancel transaction watch

// This should succeed as the watch has been cancelled

$ret = $this->redis->multi()->get('x')->exec();

$this->assertTrue($ret === array('44'));

}

public function testDiscard()

{

/* start transaction */

$this->redis->multi();

/* Set and get in our transaction */

$this->redis->set('pipecount','over9000')->get('pipecount');

$this->assertTrue($this->redis->discard());

}

/* RedisCluster::script() is a 'raw' command, which requires a key such that

* we can direct it to a given node */

public function testScript() {

$str_key = uniqid() . '-' . rand(1,1000);

// Flush any scripts we have

$this->assertTrue($this->redis->script($str_key, '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($str_key, 'exists', $s1_sha, $s2_sha, $s3_sha);

$this->assertTrue(is_array($result) && count($result) == 3);

$this->assertTrue(is_array($result) && count(array_filter($result)) == 0);

// Load them up

$this->assertTrue($this->redis->script($str_key, 'load', $s1_src) == $s1_sha);

$this->assertTrue($this->redis->script($str_key, 'load', $s2_src) == $s2_sha);

$this->assertTrue($this->redis->script($str_key, 'load', $s3_src) == $s3_sha);

// They should all exist

$result = $this->redis->script($str_key, 'exists', $s1_sha, $s2_sha, $s3_sha);

$this->assertTrue(is_array($result) && count(array_filter($result)) == 3);

}

/* RedisCluster::EVALSHA needs a 'key' to let us know which node we want to

* direct the command at */

public function testEvalSHA() {

$str_key = uniqid() . '-' . rand(1,1000);

// Flush any loaded scripts

$this->redis->script($str_key, 'flush');

// Non existant script (but proper sha1), and a random (not) sha1 string

$this->assertFalse($this->redis->evalsha(sha1(uniqid()),[$str_key], 1));

$this->assertFalse($this->redis->evalsha('some-random-data'),[$str_key], 1);

// 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->assertTrue(false === $this->redis->evalsha($scr,[$str_key], 1));

$this->assertTrue(1 === $this->redis->eval($scr,[$str_key], 1));

$this->assertTrue(1 === $this->redis->evalsha($sha,[$str_key], 1));

}

public function testEvalBulkResponse() {

$str_key1 = uniqid() . '-' . rand(1,1000) . '{hash}';

$str_key2 = uniqid() . '-' . rand(1,1000) . '{hash}';

$this->redis->script($str_key1, 'flush');

$this->redis->script($str_key2, 'flush');

$scr = "return {KEYS[1],KEYS[2]}";

$result = $this->redis->eval($scr,[$str_key1, $str_key2], 2);

$this->assertTrue($str_key1 === $result[0]);

$this->assertTrue($str_key2 === $result[1]);

}

public function testEvalBulkResponseMulti() {

$str_key1 = uniqid() . '-' . rand(1,1000) . '{hash}';

$str_key2 = uniqid() . '-' . rand(1,1000) . '{hash}';

$this->redis->script($str_key1, 'flush');

$this->redis->script($str_key2, 'flush');

$scr = "return {KEYS[1],KEYS[2]}";

$this->redis->multi();

$this->redis->eval($scr, [$str_key1, $str_key2], 2);

$result = $this->redis->exec();

$this->assertTrue($str_key1 === $result[0][0]);

$this->assertTrue($str_key2 === $result[0][1]);

}

public function testEvalBulkEmptyResponse() {

$str_key1 = uniqid() . '-' . rand(1,1000) . '{hash}';

$str_key2 = uniqid() . '-' . rand(1,1000) . '{hash}';

$this->redis->script($str_key1, 'flush');

$this->redis->script($str_key2, 'flush');

$scr = "for _,key in ipairs(KEYS) do redis.call('SET', key, 'value') end";

$result = $this->redis->eval($scr, [$str_key1, $str_key2], 2);

$this->assertTrue(null === $result);

}

public function testEvalBulkEmptyResponseMulti() {

$str_key1 = uniqid() . '-' . rand(1,1000) . '{hash}';

$str_key2 = uniqid() . '-' . rand(1,1000) . '{hash}';

$this->redis->script($str_key1, 'flush');

$this->redis->script($str_key2, 'flush');

$scr = "for _,key in ipairs(KEYS) do redis.call('SET', key, 'value') end";

$this->redis->multi();

$this->redis->eval($scr, [$str_key1, $str_key2], 2);

$result = $this->redis->exec();

$this->assertTrue(null === $result[0]);

}

/* Cluster specific introspection stuff */

public function testIntrospection() {

$arr_masters = $this->redis->_masters();

$this->assertTrue(is_array($arr_masters));

foreach ($arr_masters as $arr_info) {

$this->assertTrue(is_array($arr_info));

$this->assertTrue(is_string($arr_info[0]));

$this->assertTrue(is_long($arr_info[1]));

}

}

protected function genKeyName($i_key_idx, $i_type) {

switch ($i_type) {

case Redis::REDIS_STRING:

return "string-$i_key_idx";

case Redis::REDIS_SET:

return "set-$i_key_idx";

case Redis::REDIS_LIST:

return "list-$i_key_idx";

case Redis::REDIS_ZSET:

return "zset-$i_key_idx";

case Redis::REDIS_HASH:

return "hash-$i_key_idx";

default:

return "unknown-$i_key_idx";

}

}

protected function setKeyVals($i_key_idx, $i_type, &$arr_ref) {

$str_key = $this->genKeyName($i_key_idx, $i_type);

$this->redis->del($str_key);

switch ($i_type) {

case Redis::REDIS_STRING:

$value = "$str_key-value";

$this->redis->set($str_key, $value);

break;

case Redis::REDIS_SET:

$value = [

$str_key . '-mem1', $str_key . '-mem2', $str_key . '-mem3',

$str_key . '-mem4', $str_key . '-mem5', $str_key . '-mem6'

];

$arr_args = $value;

array_unshift($arr_args, $str_key);

call_user_func_array([$this->redis, 'sadd'], $arr_args);

break;

case Redis::REDIS_HASH:

$value = [

$str_key . '-mem1' => $str_key . '-val1',

$str_key . '-mem2' => $str_key . '-val2',

$str_key . '-mem3' => $str_key . '-val3'

];

$this->redis->hmset($str_key, $value);

break;

case Redis::REDIS_LIST:

$value = [

$str_key . '-ele1', $str_key . '-ele2', $str_key . '-ele3',

$str_key . '-ele4', $str_key . '-ele5', $str_key . '-ele6'

];

$arr_args = $value;

array_unshift($arr_args, $str_key);

call_user_func_array([$this->redis, 'rpush'], $arr_args);

break;

case Redis::REDIS_ZSET:

$i_score = 1;

$value = [

$str_key . '-mem1' => 1, $str_key . '-mem2' => 2,

$str_key . '-mem3' => 3, $str_key . '-mem3' => 3

];

foreach ($value as $str_mem => $i_score) {

$this->redis->zadd($str_key, $i_score, $str_mem);

}

break;

}

/* Update our reference array so we can verify values */

$arr_ref[$str_key] = $value;

return $str_key;

}

/* Verify that our ZSET values are identical */

protected function checkZSetEquality($a, $b) {

/* If the count is off, the array keys are different or the sums are

* different, we know there is something off */

$boo_diff = count($a) != count($b) ||

count(array_diff(array_keys($a), array_keys($b))) != 0 ||

array_sum($a) != array_sum($b);

if ($boo_diff) {

$this->assertEquals($a,$b);

return;

}

}

protected function checkKeyValue($str_key, $i_type, $value) {

switch ($i_type) {

case Redis::REDIS_STRING:

$this->assertEquals($value, $this->redis->get($str_key));

break;

case Redis::REDIS_SET:

$arr_r_values = $this->redis->sMembers($str_key);

$arr_l_values = $value;

sort($arr_r_values);

sort($arr_l_values);

$this->assertEquals($arr_r_values, $arr_l_values);

break;

case Redis::REDIS_LIST:

$this->assertEquals($value, $this->redis->lrange($str_key,0,-1));

break;

case Redis::REDIS_HASH:

$this->assertEquals($value, $this->redis->hgetall($str_key));

break;

case Redis::REDIS_ZSET:

$this->checkZSetEquality($value, $this->redis->zrange($str_key,0,-1,true));

break;

default:

throw new Exception("Unknown type " . $i_type);

}

}

/* Test automatic load distributor */

public function testFailOver() {

$arr_value_ref = [];

$arr_type_ref = [];

/* Set a bunch of keys of various redis types*/

for ($i = 0; $i < 200; $i++) {

foreach ($this->_arr_redis_types as $i_type) {

$str_key = $this->setKeyVals($i, $i_type, $arr_value_ref);

$arr_type_ref[$str_key] = $i_type;

}

}

/* Iterate over failover options */

foreach ($this->_arr_failover_types as $i_opt) {

$this->redis->setOption(RedisCluster::OPT_SLAVE_FAILOVER, $i_opt);

foreach ($arr_value_ref as $str_key => $value) {

$this->checkKeyValue($str_key, $arr_type_ref[$str_key], $value);

}

break;

}

}

/* Test a 'raw' command */

public function testRawCommand() {

$this->redis->rawCommand('mykey', 'set', 'mykey', 'my-value');

$this->assertEquals($this->redis->get('mykey'), 'my-value');

$this->redis->del('mylist');

$this->redis->rpush('mylist', 'A','B','C','D');

$this->assertEquals($this->redis->lrange('mylist', 0, -1), ['A','B','C','D']);

}

protected function rawCommandArray($key, $args) {

array_unshift($args, $key);

return call_user_func_array([$this->redis, 'rawCommand'], $args);

}

/* Test that rawCommand and EVAL can be configured to return simple string values */

public function testReplyLiteral() {

$this->redis->setOption(Redis::OPT_REPLY_LITERAL, false);

$this->assertTrue($this->redis->rawCommand('foo', 'set', 'foo', 'bar'));

$this->assertTrue($this->redis->eval("return redis.call('set', KEYS[1], 'bar')", ['foo'], 1));

$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('foo', 'set', 'foo', 'bar'));

$this->assertEquals('OK', $this->redis->eval("return redis.call('set', KEYS[1], 'bar')", ['foo'], 1));

$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);

}

/* Redis and RedisCluster use the same handler for the ACL command but verify we can direct

the command to a specific node. */

public function testAcl() {

if ( ! $this->minVersionCheck("6.0"))

return $this->markTestSkipped();

$this->assertInArray('default', $this->redis->acl('foo', 'USERS'));

}

public function testSession()

{

@ini_set('session.save_handler', 'rediscluster');

@ini_set('session.save_path', $this->getFullHostPath() . '&failover=error');

if (!@session_start()) {

return $this->markTestSkipped();

}

session_write_close();

$this->assertTrue($this->redis->exists('PHPREDIS_CLUSTER_SESSION:' . session_id()));

}

/* Test that we are able to use the slot cache without issues */

public function testSlotCache() {

ini_set('redis.clusters.cache_slots', 1);

$pong = 0;

for ($i = 0; $i < 10; $i++) {

$obj_rc = new RedisCluster(NULL, self::$_arr_node_map, 30, 30, true, $this->getAuth());

$pong += $obj_rc->ping("key:$i");

}

$this->assertEquals($pong, $i);

ini_set('redis.clusters.cache_slots', 0);

}

/* Regression test for connection pool liveness checks */

public function testConnectionPool() {

$prev_value = ini_get('redis.pconnect.pooling_enabled');

ini_set('redis.pconnect.pooling_enabled', 1);

$pong = 0;

for ($i = 0; $i < 10; $i++) {

$obj_rc = new RedisCluster(NULL, self::$_arr_node_map, 30, 30, true, $this->getAuth());

$pong += $obj_rc->ping("key:$i");

}

$this->assertEquals($pong, $i);

ini_set('redis.pconnect.pooling_enabled', $prev_value);

}

/**

* @inheritdoc

*/

protected function getFullHostPath()

{

$auth = $this->getAuthFragment();

return implode('&', array_map(function ($host) {

return 'seed[]=' . $host;

}, self::$_arr_node_map)) . ($auth ? "&$auth" : '');

}

/* Test correct handling of null multibulk replies */

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($key, "BLPOP", $key, .05);

$this->assertEquals($test, $r);

$this->redis->multi();

$this->redis->rawCommand($key, "BLPOP", $key, .05);

$r = $this->redis->exec();

$this->assertEquals([$test], $r);

}

$this->redis->setOption(Redis::OPT_NULL_MULTIBULK_AS_NULL, false);

}

}

?>