mirror of
https://github.com/predis/predis.git
synced 2026-08-22 03:21:00 +00:00
Daniele Alessandri
7bb2192294
This method improves the previous one, which worked only by picking a connection by ID, allowing users to specify a selector type among the following ones: "id", "key", "slot", "command". These selectors are expanded internally to methods, invoked against the connection object in use by the client, that follow the getConnectionByXXX() convention already in use through the library: id => getConnectionById() key => getConnectionByKey() slot => getConnectionBySlot() command => getConnectionByCommand() The underlying connection does not necessarily need to implement the aggregate connection interface as the client relies on a duck-typing approach by using method_exists().
1217 lines
41 KiB
PHP
1217 lines
41 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of the Predis package.
|
|
*
|
|
* (c) Daniele Alessandri <suppakilla@gmail.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Predis;
|
|
|
|
use PredisTestCase;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
class ClientTest extends PredisTestCase
|
|
{
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithoutArguments()
|
|
{
|
|
$client = new Client();
|
|
|
|
$connection = $client->getConnection();
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $connection);
|
|
|
|
$parameters = $connection->getParameters();
|
|
$this->assertSame($parameters->host, '127.0.0.1');
|
|
$this->assertSame($parameters->port, 6379);
|
|
|
|
$options = $client->getOptions();
|
|
$this->assertSame($options->commands, $client->getCommandFactory());
|
|
|
|
$this->assertFalse($client->isConnected());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithNullArgument()
|
|
{
|
|
$client = new Client(null);
|
|
|
|
$connection = $client->getConnection();
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $connection);
|
|
|
|
$parameters = $connection->getParameters();
|
|
$this->assertSame($parameters->host, '127.0.0.1');
|
|
$this->assertSame($parameters->port, 6379);
|
|
|
|
$options = $client->getOptions();
|
|
$this->assertSame($options->commands, $client->getCommandFactory());
|
|
|
|
$this->assertFalse($client->isConnected());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithNullAndNullArguments()
|
|
{
|
|
$client = new Client(null, null);
|
|
|
|
$connection = $client->getConnection();
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $connection);
|
|
|
|
$parameters = $connection->getParameters();
|
|
$this->assertSame($parameters->host, '127.0.0.1');
|
|
$this->assertSame($parameters->port, 6379);
|
|
|
|
$options = $client->getOptions();
|
|
$this->assertSame($options->commands, $client->getCommandFactory());
|
|
|
|
$this->assertFalse($client->isConnected());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithArrayArgument()
|
|
{
|
|
$client = new Client($arg1 = array('host' => 'localhost', 'port' => 7000));
|
|
|
|
$parameters = $client->getConnection()->getParameters();
|
|
$this->assertSame($parameters->host, $arg1['host']);
|
|
$this->assertSame($parameters->port, $arg1['port']);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \InvalidArgumentException
|
|
* @expectedExceptionMessage Array of connection parameters requires `cluster`, `replication` or `aggregate` client option
|
|
*/
|
|
public function testConstructorThrowsExceptionWithArrayOfParametersArgumentAndMissingOption()
|
|
{
|
|
$arg1 = array(
|
|
array('host' => 'localhost', 'port' => 7000),
|
|
array('host' => 'localhost', 'port' => 7001),
|
|
);
|
|
|
|
$client = new Client($arg1);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithArrayOfArrayArgumentAndClusterOption()
|
|
{
|
|
$arg1 = array(
|
|
array('host' => 'localhost', 'port' => 7000),
|
|
array('host' => 'localhost', 'port' => 7001),
|
|
);
|
|
|
|
$client = new Client($arg1, array(
|
|
'aggregate' => $this->getAggregateInitializer($arg1),
|
|
));
|
|
|
|
$this->assertInstanceOf('Predis\Connection\AggregateConnectionInterface', $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithStringArgument()
|
|
{
|
|
$client = new Client('tcp://localhost:7000');
|
|
|
|
$parameters = $client->getConnection()->getParameters();
|
|
$this->assertSame($parameters->host, 'localhost');
|
|
$this->assertSame($parameters->port, 7000);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithArrayOfStringArgument()
|
|
{
|
|
$arg1 = array('tcp://localhost:7000', 'tcp://localhost:7001');
|
|
|
|
$client = new Client($arg1, array(
|
|
'aggregate' => $this->getAggregateInitializer($arg1),
|
|
));
|
|
|
|
$this->assertInstanceOf('Predis\Connection\AggregateConnectionInterface', $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithArrayOfConnectionsArgument()
|
|
{
|
|
$arg1 = array(
|
|
$this->getMock('Predis\Connection\NodeConnectionInterface'),
|
|
$this->getMock('Predis\Connection\NodeConnectionInterface'),
|
|
);
|
|
|
|
$client = new Client($arg1, array(
|
|
'aggregate' => $this->getAggregateInitializer($arg1),
|
|
));
|
|
|
|
$this->assertInstanceOf('Predis\Connection\AggregateConnectionInterface', $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithConnectionArgument()
|
|
{
|
|
$factory = new Connection\Factory();
|
|
$connection = $factory->create('tcp://localhost:7000');
|
|
|
|
$client = new Client($connection);
|
|
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $client->getConnection());
|
|
$this->assertSame($connection, $client->getConnection());
|
|
|
|
$parameters = $client->getConnection()->getParameters();
|
|
$this->assertSame($parameters->host, 'localhost');
|
|
$this->assertSame($parameters->port, 7000);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithClusterArgument()
|
|
{
|
|
$cluster = new Connection\Cluster\PredisCluster();
|
|
|
|
$factory = new Connection\Factory();
|
|
$factory->aggregate($cluster, array('tcp://localhost:7000', 'tcp://localhost:7001'));
|
|
|
|
$client = new Client($cluster);
|
|
|
|
$this->assertInstanceOf('Predis\Connection\Cluster\ClusterInterface', $client->getConnection());
|
|
$this->assertSame($cluster, $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithReplicationArgument()
|
|
{
|
|
$replication = new Connection\Replication\MasterSlaveReplication();
|
|
|
|
$factory = new Connection\Factory();
|
|
$factory->aggregate($replication, array('tcp://host1?alias=master', 'tcp://host2?alias=slave'));
|
|
|
|
$client = new Client($replication);
|
|
|
|
$this->assertInstanceOf('Predis\Connection\Replication\ReplicationInterface', $client->getConnection());
|
|
$this->assertSame($replication, $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithCallableArgument()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->isInstanceOf('Predis\Configuration\OptionsInterface'))
|
|
->will($this->returnValue($connection));
|
|
|
|
$client = new Client($callable);
|
|
|
|
$this->assertSame($connection, $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \InvalidArgumentException
|
|
* @expectedExceptionMessage Callable parameters must return a valid connection
|
|
*/
|
|
public function testConstructorWithCallableConnectionInitializerThrowsExceptionOnInvalidReturnType()
|
|
{
|
|
$wrongType = $this->getMock('stdClass');
|
|
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->isInstanceOf('Predis\Configuration\OptionsInterface'))
|
|
->will($this->returnValue($wrongType));
|
|
|
|
new Client($callable);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithNullAndArrayArgument()
|
|
{
|
|
$connections = $this->getMock('Predis\Connection\FactoryInterface');
|
|
|
|
$arg2 = array('prefix' => 'prefix:', 'connections' => $connections);
|
|
$client = new Client(null, $arg2);
|
|
|
|
$this->assertInstanceOf('Predis\Command\FactoryInterface', $commands = $client->getCommandFactory());
|
|
$this->assertInstanceOf('Predis\Command\Processor\KeyPrefixProcessor', $commands->getProcessor());
|
|
$this->assertSame('prefix:', $commands->getProcessor()->getPrefix());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConstructorWithArrayAndOptionReplication()
|
|
{
|
|
$arg1 = array('tcp://host1?alias=master', 'tcp://host2?alias=slave');
|
|
$arg2 = array('replication' => 'predis');
|
|
$client = new Client($arg1, $arg2);
|
|
|
|
$this->assertInstanceOf('Predis\Connection\Replication\ReplicationInterface', $connection = $client->getConnection());
|
|
$this->assertSame('host1', $connection->getConnectionById('master')->getParameters()->host);
|
|
$this->assertSame('host2', $connection->getConnectionById('slave')->getParameters()->host);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testClusterOptionHasPrecedenceOverReplicationOptionAndAggregateOption()
|
|
{
|
|
$arg1 = array('tcp://host1', 'tcp://host2');
|
|
|
|
$connection = $this->getMock('Predis\Connection\AggregateConnectionInterface');
|
|
|
|
$fncluster = $this->getMock('stdClass', array('__invoke'));
|
|
$fncluster
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->isInstanceOf('Predis\Configuration\OptionsInterface'), $arg1)
|
|
->will($this->returnValue($connection));
|
|
|
|
$fnreplication = $this->getMock('stdClass', array('__invoke'));
|
|
$fnreplication
|
|
->expects($this->never())
|
|
->method('__invoke');
|
|
|
|
$fnaggregate = $this->getMock('stdClass', array('__invoke'));
|
|
$fnaggregate
|
|
->expects($this->never())
|
|
->method('__invoke');
|
|
|
|
$arg2 = array(
|
|
'cluster' => $fncluster,
|
|
'replication' => $fnreplication,
|
|
'aggregate' => $fnaggregate,
|
|
);
|
|
|
|
$client = new Client($arg1, $arg2);
|
|
|
|
$this->assertSame($connection, $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testReplicationOptionHasPrecedenceOverAggregateOption()
|
|
{
|
|
$arg1 = array('tcp://host1', 'tcp://host2');
|
|
|
|
$connection = $this->getMock('Predis\Connection\AggregateConnectionInterface');
|
|
|
|
$fnreplication = $this->getMock('stdClass', array('__invoke'));
|
|
$fnreplication
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->isInstanceOf('Predis\Configuration\OptionsInterface'), $arg1)
|
|
->will($this->returnValue($connection));
|
|
|
|
$fnaggregate = $this->getMock('stdClass', array('__invoke'));
|
|
$fnaggregate->expects($this->never())->method('__invoke');
|
|
|
|
$arg2 = array(
|
|
'replication' => $fnreplication,
|
|
'aggregate' => $fnaggregate,
|
|
);
|
|
|
|
$client = new Client($arg1, $arg2);
|
|
|
|
$this->assertSame($connection, $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testAggregateOptionDoesNotTriggerAggregationInClient()
|
|
{
|
|
$arg1 = array('tcp://host1', 'tcp://host2');
|
|
|
|
$connection = $this->getMock('Predis\Connection\AggregateConnectionInterface');
|
|
|
|
$fnaggregate = $this->getMock('stdClass', array('__invoke'));
|
|
$fnaggregate
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->isInstanceOf('Predis\Configuration\OptionsInterface'), $arg1)
|
|
->will($this->returnValue($connection));
|
|
|
|
$connections = $this->getMock('Predis\Connection\FactoryInterface');
|
|
$connections
|
|
->expects($this->never())
|
|
->method('aggregate');
|
|
|
|
$arg2 = array('aggregate' => $fnaggregate, 'connections' => $connections);
|
|
|
|
$client = new Client($arg1, $arg2);
|
|
|
|
$this->assertSame($connection, $client->getConnection());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \InvalidArgumentException
|
|
* @expectedExceptionMessage Invalid type for connection parameters
|
|
*/
|
|
public function testConstructorWithInvalidArgumentType()
|
|
{
|
|
$client = new Client(new \stdClass());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \InvalidArgumentException
|
|
* @expectedExceptionMessage Invalid type for client options
|
|
*/
|
|
public function testConstructorWithInvalidOptionType()
|
|
{
|
|
$client = new Client('tcp://host1', new \stdClass());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testConnectAndDisconnect()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('connect');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('disconnect');
|
|
|
|
$client = new Client($connection);
|
|
$client->connect();
|
|
$client->disconnect();
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testIsConnectedChecksConnectionState()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('isConnected');
|
|
|
|
$client = new Client($connection);
|
|
$client->isConnected();
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testQuitIsAliasForDisconnect()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('disconnect');
|
|
|
|
$client = new Client($connection);
|
|
$client->quit();
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testCreatesNewCommandUsingSpecifiedCommandFactory()
|
|
{
|
|
$ping = $this->getCommandFactory()->createCommand('ping', array());
|
|
|
|
$commands = $this->getMock('Predis\Command\FactoryInterface');
|
|
$commands
|
|
->expects($this->once())
|
|
->method('createCommand')
|
|
->with('ping', array())
|
|
->will($this->returnValue($ping));
|
|
|
|
$client = new Client(null, array('commands' => $commands));
|
|
$this->assertSame($ping, $client->createCommand('ping', array()));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testExecuteCommandReturnsParsedResponses()
|
|
{
|
|
$commands = $this->getCommandFactory();
|
|
|
|
$ping = $commands->createCommand('ping', array());
|
|
$hgetall = $commands->createCommand('hgetall', array('metavars', 'foo', 'hoge'));
|
|
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->at(0))
|
|
->method('executeCommand')
|
|
->with($ping)
|
|
->will($this->returnValue(new Response\Status('PONG')));
|
|
$connection
|
|
->expects($this->at(1))
|
|
->method('executeCommand')
|
|
->with($hgetall)
|
|
->will($this->returnValue(array('foo', 'bar', 'hoge', 'piyo')));
|
|
|
|
$client = new Client($connection);
|
|
|
|
$this->assertEquals('PONG', $client->executeCommand($ping));
|
|
$this->assertSame(array('foo' => 'bar', 'hoge' => 'piyo'), $client->executeCommand($hgetall));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \Predis\Response\ServerException
|
|
* @expectedExceptionMessage Operation against a key holding the wrong kind of value
|
|
*/
|
|
public function testExecuteCommandThrowsExceptionOnRedisError()
|
|
{
|
|
$ping = $this->getCommandFactory()->createCommand('ping', array());
|
|
$expectedResponse = new Response\Error('ERR Operation against a key holding the wrong kind of value');
|
|
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('executeCommand')
|
|
->will($this->returnValue($expectedResponse));
|
|
|
|
$client = new Client($connection);
|
|
$client->executeCommand($ping);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testExecuteCommandReturnsErrorResponseOnRedisError()
|
|
{
|
|
$ping = $this->getCommandFactory()->createCommand('ping', array());
|
|
$expectedResponse = new Response\Error('ERR Operation against a key holding the wrong kind of value');
|
|
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('executeCommand')
|
|
->will($this->returnValue($expectedResponse));
|
|
|
|
$client = new Client($connection, array('exceptions' => false));
|
|
$response = $client->executeCommand($ping);
|
|
|
|
$this->assertSame($response, $expectedResponse);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testCallingRedisCommandExecutesInstanceOfCommand()
|
|
{
|
|
$ping = $this->getCommandFactory()->createCommand('ping', array());
|
|
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('executeCommand')
|
|
->with($this->isInstanceOf('Predis\Command\Redis\PING'))
|
|
->will($this->returnValue('PONG'));
|
|
|
|
$commands = $this->getMock('Predis\Command\FactoryInterface');
|
|
$commands
|
|
->expects($this->once())
|
|
->method('createCommand')
|
|
->with('ping', array())
|
|
->will($this->returnValue($ping));
|
|
|
|
$options = array('commands' => $commands);
|
|
$client = $this->getMock('Predis\Client', null, array($connection, $options));
|
|
|
|
$this->assertEquals('PONG', $client->ping());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \Predis\Response\ServerException
|
|
* @expectedExceptionMessage Operation against a key holding the wrong kind of value
|
|
*/
|
|
public function testCallingRedisCommandThrowsExceptionOnServerError()
|
|
{
|
|
$expectedResponse = new Response\Error('ERR Operation against a key holding the wrong kind of value');
|
|
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('PING'))
|
|
->will($this->returnValue($expectedResponse));
|
|
|
|
$client = new Client($connection);
|
|
$client->ping();
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testCallingRedisCommandReturnsErrorResponseOnRedisError()
|
|
{
|
|
$expectedResponse = new Response\Error('ERR Operation against a key holding the wrong kind of value');
|
|
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('PING'))
|
|
->will($this->returnValue($expectedResponse));
|
|
|
|
$client = new Client($connection, array('exceptions' => false));
|
|
$response = $client->ping();
|
|
|
|
$this->assertSame($response, $expectedResponse);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testRawCommand()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->at(0))
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('SET', array('foo', 'bar')))
|
|
->will($this->returnValue(new Response\Status('OK')));
|
|
$connection
|
|
->expects($this->at(1))
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('GET', array('foo')))
|
|
->will($this->returnValue('bar'));
|
|
$connection
|
|
->expects($this->at(2))
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('PING'))
|
|
->will($this->returnValue('PONG'));
|
|
|
|
$client = new Client($connection);
|
|
|
|
$this->assertSame('OK', $client->executeRaw(array('SET', 'foo', 'bar')));
|
|
$this->assertSame('bar', $client->executeRaw(array('GET', 'foo')));
|
|
|
|
$error = true; // $error is always populated by reference.
|
|
$this->assertSame('PONG', $client->executeRaw(array('PING'), $error));
|
|
$this->assertFalse($error);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testRawCommandNeverAppliesPrefix()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->at(0))
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('SET', array('foo', 'bar')))
|
|
->will($this->returnValue(new Response\Status('OK')));
|
|
$connection
|
|
->expects($this->at(1))
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('GET', array('foo')))
|
|
->will($this->returnValue('bar'));
|
|
|
|
$client = new Client($connection, array('prefix' => 'predis:'));
|
|
|
|
$this->assertSame('OK', $client->executeRaw(array('SET', 'foo', 'bar')));
|
|
$this->assertSame('bar', $client->executeRaw(array('GET', 'foo')));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testRawCommandNeverThrowsExceptions()
|
|
{
|
|
$message = 'ERR Mock error response';
|
|
$response = new Response\Error($message);
|
|
|
|
$connection = $this->getMock('Predis\Connection\ConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('PING'))
|
|
->will($this->returnValue($response));
|
|
|
|
$client = new Client($connection, array('exceptions' => true));
|
|
|
|
$this->assertSame($message, $client->executeRaw(array('PING'), $error));
|
|
$this->assertTrue($error);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \Predis\ClientException
|
|
* @expectedExceptionMessage Command 'INVALIDCOMMAND' is not a registered Redis command.
|
|
*/
|
|
public function testThrowsExceptionOnNonRegisteredRedisCommand()
|
|
{
|
|
$client = new Client();
|
|
$client->invalidCommand();
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetConnectionFromAggregateConnectionWithAlias()
|
|
{
|
|
$client = new Client(array('tcp://host1?alias=node01', 'tcp://host2?alias=node02'), array('cluster' => 'predis'));
|
|
|
|
$this->assertInstanceOf('Predis\Connection\Cluster\ClusterInterface', $cluster = $client->getConnection());
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $node01 = $client->getConnectionById('node01'));
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $node02 = $client->getConnectionById('node02'));
|
|
|
|
$this->assertSame('host1', $node01->getParameters()->host);
|
|
$this->assertSame('host2', $node02->getParameters()->host);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \Predis\NotSupportedException
|
|
* @expectedExceptionMessage Retrieving connections by ID is supported only by aggregate connections.
|
|
*/
|
|
public function testGetConnectionByIdWorksOnlyWithAggregateConnections()
|
|
{
|
|
$client = new Client();
|
|
|
|
$client->getConnectionById('node01');
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetClientByMethodCreatesClientWithConnectionFromAggregateConnection()
|
|
{
|
|
$client = new Client(array('tcp://host1?alias=node01', 'tcp://host2?alias=node02'), array('prefix' => 'pfx:', 'cluster' => 'predis'));
|
|
|
|
$this->assertInstanceOf('Predis\Connection\Cluster\ClusterInterface', $cluster = $client->getConnection());
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $node01 = $client->getConnectionById('node01'));
|
|
$this->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $node02 = $client->getConnectionById('node02'));
|
|
|
|
$clientNode02 = $client->getClientBy('id', 'node02');
|
|
|
|
$this->assertInstanceOf('Predis\Client', $clientNode02);
|
|
$this->assertSame($node02, $clientNode02->getConnection());
|
|
$this->assertSame($client->getOptions(), $clientNode02->getOptions());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetClientByMethodReturnsInstanceOfSubclass()
|
|
{
|
|
$nodes = array('tcp://host1?alias=node01', 'tcp://host2?alias=node02');
|
|
$client = $this->getMock('Predis\Client', array('dummy'), array($nodes, array('cluster' => 'predis')), 'SubclassedClient');
|
|
|
|
$this->assertInstanceOf('SubclassedClient', $client->getClientBy('id', 'node02'));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetClientByMethodInvokesCallableInSecondArgumentAndReturnsItsReturnValue()
|
|
{
|
|
$test = $this;
|
|
$client = new Client(array('tcp://host1?alias=node01', 'tcp://host2?alias=node02'), array('cluster' => 'predis'));
|
|
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->callback(function ($clientNode) use ($test, $client) {
|
|
$test->isInstanceOf('Predis\ClientInterface', $clientNode);
|
|
$test->assertNotSame($client, $clientNode);
|
|
$test->assertInstanceOf('Predis\Connection\NodeConnectionInterface', $connection = $clientNode->getConnection());
|
|
$test->assertSame('node02', $connection->getParameters()->alias);
|
|
|
|
return true;
|
|
}))
|
|
->will($this->returnValue('value'));
|
|
|
|
$this->assertSame('value', $client->getClientBy('id', 'node02', $callable));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetClientByMethodSupportsSelectingConnectionById()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
|
|
$aggregate = $this->getMockBuilder('Predis\Connection\AggregateConnectionInterface')
|
|
->setMethods(array('getConnectionById'))
|
|
->getMockForAbstractClass();
|
|
$aggregate
|
|
->expects($this->once())
|
|
->method('getConnectionById')
|
|
->with('nodeXX')
|
|
->will($this->returnValue($connection));
|
|
|
|
$client = new Client($aggregate);
|
|
$nodeClient = $client->getClientBy('id', 'nodeXX');
|
|
|
|
$this->assertSame($connection, $nodeClient->getConnection());
|
|
$this->assertSame($client->getOptions(), $nodeClient->getOptions());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \InvalidArgumentException
|
|
* @expectedExceptionMessage Cannot find a connection by id matching `nodeXX`
|
|
*/
|
|
public function testGetClientByMethodThrowsExceptionSelectingConnectionByUnknownId()
|
|
{
|
|
$aggregate = $this->getMock('Predis\Connection\AggregateConnectionInterface');
|
|
$aggregate
|
|
->expects($this->once())
|
|
->method('getConnectionById')
|
|
->with('nodeXX')
|
|
->will($this->returnValue(null));
|
|
|
|
$client = new Client($aggregate);
|
|
$client->getClientBy('id', 'nodeXX');
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetClientByMethodSupportsSelectingConnectionByKey()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
|
|
$aggregate = $this->getMockBuilder('Predis\Connection\AggregateConnectionInterface')
|
|
->setMethods(array('getConnectionByKey'))
|
|
->getMockForAbstractClass();
|
|
$aggregate
|
|
->expects($this->once())
|
|
->method('getConnectionByKey')
|
|
->with('key:1')
|
|
->will($this->returnValue($connection));
|
|
|
|
$client = new Client($aggregate);
|
|
$nodeClient = $client->getClientBy('key', 'key:1');
|
|
|
|
$this->assertSame($connection, $nodeClient->getConnection());
|
|
$this->assertSame($client->getOptions(), $nodeClient->getOptions());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetClientByMethodSupportsSelectingConnectionBySlot()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
|
|
$aggregate = $this->getMockBuilder('Predis\Connection\AggregateConnectionInterface')
|
|
->setMethods(array('getConnectionBySlot'))
|
|
->getMockForAbstractClass();
|
|
$aggregate
|
|
->expects($this->once())
|
|
->method('getConnectionBySlot')
|
|
->with(5460)
|
|
->will($this->returnValue($connection));
|
|
|
|
$client = new Client($aggregate);
|
|
$nodeClient = $client->getClientBy('slot', 5460);
|
|
|
|
$this->assertSame($connection, $nodeClient->getConnection());
|
|
$this->assertSame($client->getOptions(), $nodeClient->getOptions());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetClientByMethodSupportsSelectingConnectionByCommand()
|
|
{
|
|
$command = \Predis\Command\RawCommand::create('GET', 'key');
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
|
|
$aggregate = $this->getMockBuilder('Predis\Connection\AggregateConnectionInterface')
|
|
->setMethods(array('getConnectionByCommand'))
|
|
->getMockForAbstractClass();
|
|
$aggregate
|
|
->expects($this->once())
|
|
->method('getConnectionByCommand')
|
|
->with($command)
|
|
->will($this->returnValue($connection));
|
|
|
|
$client = new Client($aggregate);
|
|
$nodeClient = $client->getClientBy('command', $command);
|
|
|
|
$this->assertSame($connection, $nodeClient->getConnection());
|
|
$this->assertSame($client->getOptions(), $nodeClient->getOptions());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \InvalidArgumentException
|
|
* @expectedExceptionMessage Invalid selector type: `unknown`
|
|
*/
|
|
public function testGetClientByMethodThrowsExceptionWhenSelectingConnectionByUnknownType()
|
|
{
|
|
$client = new Client('tcp://127.0.0.1?alias=node01');
|
|
|
|
$client->getClientBy('unknown', 'test');
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \InvalidArgumentException
|
|
* @expectedExceptionMessage Selecting connection by id is not supported by Predis\Connection\StreamConnection
|
|
*/
|
|
public function testGetClientByMethodThrowsExceptionWhenConnectionDoesNotSupportSelectorType()
|
|
{
|
|
$client = new Client('tcp://127.0.0.1?alias=node01');
|
|
|
|
$client->getClientBy('id', 'node01');
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testPipelineWithoutArgumentsReturnsPipeline()
|
|
{
|
|
$client = new Client();
|
|
|
|
$this->assertInstanceOf('Predis\Pipeline\Pipeline', $client->pipeline());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testPipelineWithArrayReturnsPipeline()
|
|
{
|
|
$client = new Client();
|
|
|
|
$this->assertInstanceOf('Predis\Pipeline\Pipeline', $client->pipeline(array()));
|
|
$this->assertInstanceOf('Predis\Pipeline\Atomic', $client->pipeline(array('atomic' => true)));
|
|
$this->assertInstanceOf('Predis\Pipeline\FireAndForget', $client->pipeline(array('fire-and-forget' => true)));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testPipelineWithCallableExecutesPipeline()
|
|
{
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->isInstanceOf('Predis\Pipeline\Pipeline'));
|
|
|
|
$client = new Client();
|
|
$client->pipeline($callable);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testPubSubLoopWithoutArgumentsReturnsPubSubConsumer()
|
|
{
|
|
$client = new Client();
|
|
|
|
$this->assertInstanceOf('Predis\PubSub\Consumer', $client->pubSubLoop());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testPubSubLoopWithArrayReturnsPubSubConsumerWithOptions()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
$options = array('subscribe' => 'channel');
|
|
|
|
$client = new Client($connection);
|
|
|
|
$this->assertInstanceOf('Predis\PubSub\Consumer', $pubsub = $client->pubSubLoop($options));
|
|
|
|
$reflection = new \ReflectionProperty($pubsub, 'options');
|
|
$reflection->setAccessible(true);
|
|
|
|
$this->assertSame($options, $reflection->getValue($pubsub));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testPubSubLoopWithArrayAndCallableExecutesPubSub()
|
|
{
|
|
// NOTE: we use a subscribe count of 0 in the message payload to trick
|
|
// the context and forcing it to be closed since there are no more
|
|
// active subscriptions.
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('read')
|
|
->will($this->returnValue(array('subscribe', 'channel', 0)));
|
|
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->once())
|
|
->method('__invoke');
|
|
|
|
$client = new Client($connection);
|
|
$this->assertNull($client->pubSubLoop(array('subscribe' => 'channel'), $callable));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testPubSubLoopWithCallableReturningFalseStopsPubSubConsumer()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
$connection
|
|
->expects($this->at(1))
|
|
->method('read')
|
|
->will($this->returnValue(array('subscribe', 'channel', 1)));
|
|
$connection
|
|
->expects($this->at(2))
|
|
->method('writeRequest')
|
|
->with($this->isRedisCommand('UNSUBSCRIBE'));
|
|
$connection
|
|
->expects($this->at(3))
|
|
->method('read')
|
|
->will($this->returnValue(array('unsubscribe', 'channel', 0)));
|
|
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->at(0))
|
|
->method('__invoke')
|
|
->will($this->returnValue(false));
|
|
|
|
$client = new Client($connection);
|
|
|
|
$this->assertNull($client->pubSubLoop(array('subscribe' => 'channel'), $callable));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testTransactionWithoutArgumentsReturnsMultiExec()
|
|
{
|
|
$client = new Client();
|
|
|
|
$this->assertInstanceOf('Predis\Transaction\MultiExec', $client->transaction());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testTransactionWithArrayReturnsMultiExecTransactionWithOptions()
|
|
{
|
|
$options = array('cas' => true, 'retry' => 3);
|
|
|
|
$client = new Client();
|
|
|
|
$this->assertInstanceOf('Predis\Transaction\MultiExec', $tx = $client->transaction($options));
|
|
|
|
// I hate this part but reflection is the easiest way in this case.
|
|
$property = new \ReflectionProperty($tx, 'modeCAS');
|
|
$property->setAccessible(true);
|
|
$this->assertSame($options['cas'], $property->getValue($tx));
|
|
|
|
$property = new \ReflectionProperty($tx, 'attempts');
|
|
$property->setAccessible(true);
|
|
$this->assertSame($options['retry'], $property->getValue($tx));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testTransactionWithArrayAndCallableExecutesMultiExec()
|
|
{
|
|
// We use CAS here as we don't care about the actual MULTI/EXEC context.
|
|
$options = array('cas' => true, 'retry' => 3);
|
|
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
$connection
|
|
->expects($this->once())
|
|
->method('executeCommand')
|
|
->will($this->returnValue(new Response\Status('QUEUED')));
|
|
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->will($this->returnCallback(function ($tx) { $tx->ping(); }));
|
|
|
|
$client = new Client($connection);
|
|
$client->transaction($options, $callable);
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testMonitorReturnsMonitorConsumer()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
$client = new Client($connection);
|
|
|
|
$this->assertInstanceOf('Predis\Monitor\Consumer', $monitor = $client->monitor());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testClientResendScriptCommandUsingEvalOnNoScriptErrors()
|
|
{
|
|
$command = $this->getMockForAbstractClass('Predis\Command\ScriptCommand', array(), '', true, true, true, array('parseResponse'));
|
|
$command
|
|
->expects($this->once())
|
|
->method('getScript')
|
|
->will($this->returnValue('return redis.call(\'exists\', KEYS[1])'));
|
|
$command
|
|
->expects($this->once())
|
|
->method('parseResponse')
|
|
->with('OK')
|
|
->will($this->returnValue(true));
|
|
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
$connection
|
|
->expects($this->at(0))
|
|
->method('executeCommand')
|
|
->with($command)
|
|
->will($this->returnValue(new Response\Error('NOSCRIPT')));
|
|
$connection
|
|
->expects($this->at(1))
|
|
->method('executeCommand')
|
|
->with($this->isRedisCommand('EVAL'))
|
|
->will($this->returnValue('OK'));
|
|
|
|
$client = new Client($connection);
|
|
|
|
$this->assertTrue($client->executeCommand($command));
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
*/
|
|
public function testGetIteratorWithTraversableConnections()
|
|
{
|
|
$connection1 = $this->getMockConnection('tcp://127.0.0.1:6381');
|
|
$connection2 = $this->getMockConnection('tcp://127.0.0.1:6382');
|
|
$connection3 = $this->getMockConnection('tcp://127.0.0.1:6383');
|
|
|
|
$aggregate = new \Predis\Connection\Cluster\PredisCluster();
|
|
|
|
$aggregate->add($connection1);
|
|
$aggregate->add($connection2);
|
|
$aggregate->add($connection3);
|
|
|
|
$client = new Client($aggregate);
|
|
|
|
$iterator = $client->getIterator();
|
|
|
|
$this->assertInstanceOf('\Predis\Client', $nodeClient = $iterator->current());
|
|
$this->assertSame($connection1, $nodeClient->getConnection());
|
|
$this->assertSame('127.0.0.1:6381', $iterator->key());
|
|
|
|
$iterator->next();
|
|
|
|
$this->assertInstanceOf('\Predis\Client', $nodeClient = $iterator->current());
|
|
$this->assertSame($connection2, $nodeClient->getConnection());
|
|
$this->assertSame('127.0.0.1:6382', $iterator->key());
|
|
|
|
$iterator->next();
|
|
|
|
$this->assertInstanceOf('\Predis\Client', $nodeClient = $iterator->current());
|
|
$this->assertSame($connection3, $nodeClient->getConnection());
|
|
$this->assertSame('127.0.0.1:6383', $iterator->key());
|
|
}
|
|
|
|
/**
|
|
* @group disconnected
|
|
* @expectedException \Predis\ClientException
|
|
* @expectedExceptionMessage The underlying connection is not traversable
|
|
*/
|
|
public function testGetIteratorWithNonTraversableConnectionThrowsException()
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\NodeConnectionInterface');
|
|
$client = new Client($connection);
|
|
|
|
$client->getIterator();
|
|
}
|
|
|
|
// ******************************************************************** //
|
|
// ---- HELPER METHODS ------------------------------------------------ //
|
|
// ******************************************************************** //
|
|
|
|
/**
|
|
* Returns an URI string representation of the specified connection parameters.
|
|
*
|
|
* @param array $parameters Array of connection parameters.
|
|
*
|
|
* @return string URI string.
|
|
*/
|
|
protected function getParametersString(array $parameters)
|
|
{
|
|
$defaults = $this->getDefaultParametersArray();
|
|
|
|
$scheme = isset($parameters['scheme']) ? $parameters['scheme'] : $defaults['scheme'];
|
|
$host = isset($parameters['host']) ? $parameters['host'] : $defaults['host'];
|
|
$port = isset($parameters['port']) ? $parameters['port'] : $defaults['port'];
|
|
|
|
unset($parameters['scheme'], $parameters['host'], $parameters['port']);
|
|
$uriString = "$scheme://$host:$port/?";
|
|
|
|
foreach ($parameters as $k => $v) {
|
|
$uriString .= "$k=$v&";
|
|
}
|
|
|
|
return $uriString;
|
|
}
|
|
|
|
/**
|
|
* Returns a mock callable simulating an aggregate connection initializer.
|
|
*
|
|
* @param mixed $parameters Expected connection parameters
|
|
*
|
|
* @return callable
|
|
*/
|
|
protected function getAggregateInitializer($parameters)
|
|
{
|
|
$connection = $this->getMock('Predis\Connection\AggregateConnectionInterface');
|
|
|
|
$callable = $this->getMock('stdClass', array('__invoke'));
|
|
$callable
|
|
->expects($this->once())
|
|
->method('__invoke')
|
|
->with($this->isInstanceOf('Predis\Configuration\OptionsInterface'), $parameters)
|
|
->will($this->returnValue($connection));
|
|
|
|
return $callable;
|
|
}
|
|
}
|