PHP ServerProfile::getDefault方法代码示例

 /**
  * {@inheritdoc}
  */
 public function getDefault(ClientOptionsInterface $options)
 {
     $profile = ServerProfile::getDefault();
     if (isset($options->prefix)) {
         $profile->setProcessor($options->prefix);
     }
     return $profile;
 }

 /**
  * @group disconnected
  */
 public function testConstructorOpensContext()
 {
     $cmdMonitor = ServerProfile::getDefault()->createCommand('monitor');
     $connection = $this->getMock('Predis\\Connection\\SingleConnectionInterface');
     $client = $this->getMock('Predis\\Client', array('createCommand', 'executeCommand'), array($connection));
     $client->expects($this->once())->method('createCommand')->with('monitor', array())->will($this->returnValue($cmdMonitor));
     $client->expects($this->once())->method('executeCommand')->with($cmdMonitor);
     $monitor = new MonitorContext($client);
 }

 /**
  * @group disconnected
  */
 public function testExecuteCommandDoesNotSendCommandsWithoutExecute()
 {
     $profile = ServerProfile::getDefault();
     $executor = $this->getMock('Predis\\Pipeline\\PipelineExecutorInterface');
     $executor->expects($this->never())->method('executor');
     $pipeline = new PipelineContext(new Client(), $executor);
     $pipeline->executeCommand($profile->createCommand('echo', array('one')));
     $pipeline->executeCommand($profile->createCommand('echo', array('two')));
     $pipeline->executeCommand($profile->createCommand('echo', array('three')));
 }

 /**
  * @group disconnected
  */
 public function testCallingRedisCommandExecutesInstanceOfCommand()
 {
     $ping = ServerProfile::getDefault()->createCommand('ping', array());
     $connection = $this->getMock('Predis\\Connection\\ConnectionInterface');
     $connection->expects($this->once())->method('executeCommand')->with($this->isInstanceOf('Predis\\Command\\ConnectionPing'))->will($this->returnValue('PONG'));
     $profile = $this->getMock('Predis\\Profile\\ServerProfileInterface');
     $profile->expects($this->once())->method('createCommand')->with('ping', array())->will($this->returnValue($ping));
     $options = array('profile' => $profile);
     $client = $this->getMock('Predis\\Client', null, array($connection, $options));
     $this->assertTrue($client->ping());
 }

 /**
  * @group disconnected
  */
 public function testChainOfProcessors()
 {
     $processor = $this->getMock('Predis\\Command\\Processor\\CommandProcessorInterface');
     $processor->expects($this->exactly(2))->method('process');
     $chain = new ProcessorChain();
     $chain->add($processor);
     $chain->add($processor);
     $profile = ServerProfile::getDefault();
     $profile->setProcessor($chain);
     $profile->createCommand('info');
 }

 /**
  * @group disconnected
  */
 public function testCreatesNewCommandUsingSpecifiedProfile()
 {
     $ping = ServerProfile::getDefault()->createCommand('ping', array());
     $profile = $this->getMock('Predis\\Profile\\ServerProfileInterface');
     $profile->expects($this->once())->method('createCommand')->with('ping', array())->will($this->returnValue($ping));
     $client = new Client(null, array('profile' => $profile));
     $this->assertSame($ping, $client->createCommand('ping', array()));
 }

 /**
  * @group disconnected
  * @expectedException Predis\NotSupportedException
  * @expectedExceptionMessage Cannot use PING with redis-cluster
  */
 public function testThrowsExceptionOnNonSupportedCommand()
 {
     $ping = ServerProfile::getDefault()->createCommand('ping');
     $cluster = new RedisCluster();
     $cluster->add($this->getMockConnection('tcp://127.0.0.1:6379'));
     $cluster->getConnection($ping);
 }

 /**
  * @group disconnected
  */
 public function testValidationDoesNotSetPrefixProcessorWhenValueIsProfileInstance()
 {
     $options = $this->getMock('Predis\\Option\\ClientOptions', array('__isset', '__get'));
     $options->expects($this->never())->method('__isset');
     $options->expects($this->never())->method('__get');
     $option = new ClientProfile();
     $profile = $option->filter($options, ServerProfile::getDefault());
     $this->assertInstanceOf('Predis\\Profile\\ServerProfileInterface', $profile);
     $this->assertNull($profile->getProcessor());
 }

 /**
  * @group disconnected
  */
 public function testIterationRewindable()
 {
     $client = $this->getMock('Predis\\Client', array('getProfile', 'lrange'));
     $client->expects($this->any())->method('getProfile')->will($this->returnValue(ServerProfile::getDefault()));
     $client->expects($this->exactly(2))->method('lrange')->with('key:list', 0, 9)->will($this->returnValue(array('item:1', 'item:2')));
     $iterator = new ListKey($client, 'key:list');
     $iterator->rewind();
     $this->assertTrue($iterator->valid());
     $this->assertSame('item:1', $iterator->current());
     $this->assertSame(0, $iterator->key());
     $iterator->rewind();
     $this->assertTrue($iterator->valid());
     $this->assertSame('item:1', $iterator->current());
     $this->assertSame(0, $iterator->key());
     $iterator->next();
     $this->assertTrue($iterator->valid());
     $this->assertSame(1, $iterator->key());
     $this->assertSame('item:2', $iterator->current());
     $iterator->next();
     $this->assertFalse($iterator->valid());
 }

 /**
  * @group disconnected
  */
 public function testExecuteCommandOnEachNode()
 {
     $ping = ServerProfile::getDefault()->createCommand('ping', array());
     $connection1 = $this->getMock('Predis\\Connection\\SingleConnectionInterface');
     $connection1->expects($this->once())->method('executeCommand')->with($ping)->will($this->returnValue(true));
     $connection2 = $this->getMock('Predis\\Connection\\SingleConnectionInterface');
     $connection2->expects($this->once())->method('executeCommand')->with($ping)->will($this->returnValue(false));
     $cluster = new PredisCluster();
     $cluster->add($connection1);
     $cluster->add($connection2);
     $this->assertSame(array(true, false), $cluster->executeCommandOnNodes($ping));
 }

 /**
  * @group disconnected
  */
 public function testAcceptsCallableToOverrideReadOnlyFlagForCommands()
 {
     $profile = ServerProfile::getDefault();
     $cmdExistsFoo = $profile->createCommand('exists', array('foo'));
     $cmdExistsBar = $profile->createCommand('exists', array('bar'));
     $master = $this->getMockConnection('tcp://host1?alias=master');
     $master->expects($this->once())->method('executeCommand')->with($cmdExistsBar);
     $slave1 = $this->getMockConnection('tcp://host2?alias=slave1');
     $slave1->expects($this->once())->method('executeCommand')->with($cmdExistsFoo);
     $replication = new MasterSlaveReplication();
     $replication->add($master);
     $replication->add($slave1);
     $replication->setCommandReadOnly('exists', function ($cmd) {
         list($arg1) = $cmd->getArguments();
         return $arg1 === 'foo';
     });
     $replication->executeCommand($cmdExistsFoo);
     $replication->executeCommand($cmdExistsBar);
 }

 /**
  * {@inheritdoc}
  */
 public function create($parameters, ServerProfileInterface $profile = null)
 {
     if (!$parameters instanceof ConnectionParametersInterface) {
         $parameters = new ConnectionParameters($parameters ?: array());
     }
     $scheme = $parameters->scheme;
     if (!isset($this->schemes[$scheme])) {
         throw new \InvalidArgumentException("Unknown connection scheme: {$scheme}");
     }
     $initializer = $this->schemes[$scheme];
     if (!is_callable($initializer)) {
         $connection = new $initializer($parameters);
         $this->prepareConnection($connection, $profile ?: ServerProfile::getDefault());
         return $connection;
     }
     $connection = call_user_func($initializer, $parameters, $profile);
     if (!$connection instanceof SingleConnectionInterface) {
         throw new \InvalidArgumentException('Objects returned by connection initializers must implement ' . 'Predis\\Connection\\SingleConnectionInterface');
     }
     return $connection;
 }

 /**
  *
  */
 public function __construct(ServerProfileInterface $profile = null)
 {
     $this->setProfile($profile ?: ServerProfile::getDefault());
 }

 /**
  *
  */
 public function __construct()
 {
     $this->setProfile(ServerProfile::getDefault());
 }