PHP Mockery::mock方法代码示例

 public function setUp()
 {
     parent::setUp();
     $this->subjectConfirmation = m::mock('SAML2\\XML\\saml\\SubjectConfirmation');
     $this->subjectConfirmationData = m::mock('SAML2\\XML\\saml\\SubjectConfirmationData');
     $this->subjectConfirmation->SubjectConfirmationData = $this->subjectConfirmationData;
 }

 public function setUp()
 {
     $this->mockProxy = M::mock('Webservice\\TransactionDbProxy');
     $this->handler = new BugHandler();
     $this->handler->setLanguage("de");
     $this->handler->setDbProxy($this->mockProxy);
 }

 public function testAddingRouteActuallyAddsPhalcoreRoute()
 {
     $route = $this->instance->add('/foo', ['controller' => 'foo', 'action' => 'bar']);
     $this->assertInstanceOf('Phalcore\\Mvc\\Router\\Route', $route);
     $this->assertContains($route, $this->instance->getRoutes());
     $this->assertNotContains(m::mock('Phalcore\\Mvc\\Router\\Route'), $this->instance->getRoutes());
 }

 /**
  * Verify that talks with ampersands and other characters in them can
  * be created and then edited properly
  *
  * @test
  */
 public function ampersandsAcceptableCharacterForTalks()
 {
     $controller = new OpenCFP\Http\Controller\TalkController();
     $controller->setApplication($this->app);
     // Create a test double for SwiftMailer
     $swiftmailer = m::mock('StdClass');
     $swiftmailer->shouldReceive('send')->andReturn(true);
     $this->app['mailer'] = $swiftmailer;
     // Get our request object to return expected data
     $talk_data = ['title' => 'Test Title With Ampersand', 'description' => "The title should contain this & that", 'type' => 'regular', 'level' => 'entry', 'category' => 'other', 'desired' => 0, 'slides' => '', 'other' => '', 'sponsor' => '', 'user_id' => $this->app['sentry']->getUser()->getId()];
     $this->setPost($talk_data);
     /**
      * If the talk was successfully created, a success value is placed
      * into the session flash area for display
      */
     $create_response = $controller->processCreateAction($this->req);
     $create_flash = $this->app['session']->get('flash');
     $this->assertEquals($create_flash['type'], 'success');
     // Now, edit the results and update them
     $talk_data['id'] = 1;
     $talk_data['description'] = "The title should contain this & that & this other thing";
     $talk_data['title'] = "Test Title With Ampersand & More Things";
     $this->setPost($talk_data);
     $update_response = $controller->updateAction($this->req, $this->app);
     $update_flash = $this->app['session']->get('flash');
     $this->assertEquals($update_flash['type'], 'success');
 }

 public function testGetIncludedColumn()
 {
     $model = m::mock(array('getTable' => 'table', 'method' => m::mock(array('getRelated' => m::mock(array('getKeyName' => 'fk'))))));
     $this->config->shouldReceive('getDataModel')->once()->andReturn($model);
     $this->column->shouldReceive('getOption')->once()->andReturn('method');
     $this->assertEquals($this->column->getIncludedColumn(), array('fk' => 'table.fk'));
 }

 /**
  * @return mixed Really a Filesystem|MockInterface but coding standards get confused
  */
 private function getFilesystem()
 {
     $fileSystem = m::mock(Filesystem::class);
     $fileSystem->shouldReceive('getAdapter')->andReturn(m::mock(AdapterInterface::class));
     $fileSystem->shouldReceive('getConfig')->andReturn(null);
     return $fileSystem;
 }

 public function testHandleThrowPass()
 {
     $middleware = new AuthoriseRole();
     $this->assertTrue($middleware->handle(Mockery::mock('\\Illuminate\\Http\\Request'), function () {
         return true;
     }, 'su'));
 }

 /**
  * Setup method
  * @return void
  */
 public function setup()
 {
     $targetClass = DefinedTargetClass::factory('Mockery\\Test\\Generator\\StringManipulation\\Pass\\MagicDummy');
     $this->pass = new MagicMethodTypeHintsPass();
     $this->mockedConfiguration = m::mock('Mockery\\Generator\\MockConfiguration');
     $this->mockedConfiguration->shouldReceive('getTargetClass')->andReturn($targetClass)->byDefault();
 }

 /**
  * Integration Test.
  */
 public function testPushCommand()
 {
     $configuration_file = ['bypass' => false, 'default' => 'AwsS3', 'url' => 'https://s3.amazonaws.com', 'threshold' => 10, 'providers' => ['aws' => ['s3' => ['region' => 'us-standard', 'version' => 'latest', 'buckets' => ['my-bucket-name' => '*'], 'acl' => 'public-read', 'cloudfront' => ['use' => false, 'cdn_url' => ''], 'metadata' => [], 'expires' => gmdate('D, d M Y H:i:s T', strtotime('+5 years')), 'cache-control' => 'max-age=2628000', 'version' => '']]], 'include' => ['directories' => [__DIR__], 'extensions' => [], 'patterns' => []], 'exclude' => ['directories' => [], 'files' => [], 'extensions' => [], 'patterns' => [], 'hidden' => true]];
     $m_consol = M::mock('Symfony\\Component\\Console\\Output\\ConsoleOutput');
     $m_consol->shouldReceive('writeln')->atLeast(1);
     $finder = new \Vinelab\Cdn\Finder($m_consol);
     $asset = new \Vinelab\Cdn\Asset();
     $provider_factory = new \Vinelab\Cdn\ProviderFactory();
     $m_config = M::mock('Illuminate\\Config\\Repository');
     $m_config->shouldReceive('get')->with('cdn')->once()->andReturn($configuration_file);
     $helper = new \Vinelab\Cdn\CdnHelper($m_config);
     $m_console = M::mock('Symfony\\Component\\Console\\Output\\ConsoleOutput');
     $m_console->shouldReceive('writeln')->atLeast(2);
     $m_validator = M::mock('Vinelab\\Cdn\\Validators\\Contracts\\ProviderValidatorInterface');
     $m_validator->shouldReceive('validate');
     $m_helper = M::mock('Vinelab\\Cdn\\CdnHelper');
     $m_spl_file = M::mock('Symfony\\Component\\Finder\\SplFileInfo');
     $m_spl_file->shouldReceive('getPathname')->andReturn('vinelab/cdn/tests/Vinelab/Cdn/AwsS3ProviderTest.php');
     $m_spl_file->shouldReceive('getRealPath')->andReturn(__DIR__ . '/AwsS3ProviderTest.php');
     // partial mock
     $p_aws_s3_provider = M::mock('\\Vinelab\\Cdn\\Providers\\AwsS3Provider[connect]', array($m_console, $m_validator, $m_helper));
     $m_s3 = M::mock('Aws\\S3\\S3Client')->shouldIgnoreMissing();
     $m_s3->shouldReceive('factory')->andReturn('Aws\\S3\\S3Client');
     $m_command = M::mock('Aws\\Command');
     $m_s3->shouldReceive('getCommand')->andReturn($m_command);
     $m_s3->shouldReceive('execute');
     $p_aws_s3_provider->setS3Client($m_s3);
     $p_aws_s3_provider->shouldReceive('connect')->andReturn(true);
     \Illuminate\Support\Facades\App::shouldReceive('make')->once()->andReturn($p_aws_s3_provider);
     $cdn = new \Vinelab\Cdn\Cdn($finder, $asset, $provider_factory, $helper);
     $result = $cdn->push();
     assertEquals($result, true);
 }

 public function setUp()
 {
     DI::reset();
     DI::setDefault($di = new DI());
     $this->instance = m::mock('Phalcore\\Di\\Facade');
     $di->setShared('foo', m::mock('foo'));
 }

 public function testGetCustomersInvalidCustomer()
 {
     $this->setExpectedException('\\DomainException');
     $jsonProvider = \Mockery::mock('\\KieranBamforth\\CustomerInviter\\CustomerProvider\\JsonProvider[isCustomerValid]', [$this->json]);
     $jsonProvider->shouldReceive('isCustomerValid')->andReturn(false);
     $jsonProvider->getCustomers();
 }

 public function testRotate()
 {
     $newProfile = $this->getFaker()->word;
     $encryptor = \Mockery::mock('Giftcards\\Encryption\\Encryptor');
     $observer = \Mockery::mock('Giftcards\\Encryption\\CipherText\\Rotator\\ObserverInterface');
     $fields = $this->fields;
     $fields[] = $this->idField;
     $faker = $this->getFaker();
     $row1 = array_combine($fields, array_map(function () use($faker) {
         return $faker->unique()->word;
     }, $fields));
     $row2 = array_combine($fields, array_map(function () use($faker) {
         return $faker->unique()->word;
     }, $fields));
     $row3 = array_combine($fields, array_map(function () use($faker) {
         return $faker->unique()->word;
     }, $fields));
     $this->pdo->shouldReceive('prepare')->once()->with(sprintf('SELECT %s FROM %s', implode(', ', $fields), $this->table))->andReturn(\Mockery::mock()->shouldReceive('execute')->once()->getMock()->shouldReceive('fetch')->times(4)->with(\PDO::FETCH_ASSOC)->andReturn($row1, $row2, $row3, false)->getMock());
     $observer->shouldReceive('rotating')->once()->ordered()->with($row1[$this->idField])->getMock()->shouldReceive('rotated')->once()->ordered()->with($row1[$this->idField])->getMock()->shouldReceive('rotating')->once()->ordered()->with($row2[$this->idField])->getMock()->shouldReceive('rotated')->once()->ordered()->with($row2[$this->idField])->getMock()->shouldReceive('rotating')->once()->ordered()->with($row3[$this->idField])->getMock()->shouldReceive('rotated')->once()->ordered()->with($row3[$this->idField])->getMock();
     foreach (array($row1, $row2, $row3) as $row) {
         $parameters = array();
         $setFields = array();
         foreach ($row as $field => $value) {
             if ($field == $this->idField) {
                 continue;
             }
             $encryptor->shouldReceive('decrypt')->once()->with($value)->andReturn($decrypted = $this->getFaker()->unique()->word)->getMock()->shouldReceive('encrypt')->once()->with($decrypted, $newProfile)->andReturn($parameters[] = $this->getFaker()->unique()->word)->getMock();
             $setFields[] = sprintf('%s = ?', $field);
         }
         $parameters[] = $row[$this->idField];
         $this->pdo->shouldReceive('prepare')->once()->with(sprintf('UPDATE %s SET %s WHERE %s = ?', $this->table, implode(',', $setFields), $this->idField))->andReturn(\Mockery::mock()->shouldReceive('execute')->once()->with($parameters)->getMock());
     }
     $this->rotator->rotate($observer, $encryptor, $newProfile);
 }

 protected function setUp()
 {
     $this->outputInterface = new InMemoryOutputInterface();
     $this->preCommitConfig = new InMemoryHookConfig();
     $this->codeSnifferHandler = \Mockery::mock('PhpGitHooks\\Infrastructure\\CodeSniffer\\CodeSnifferHandler');
     $this->checkCodeStyleCodeSnifferPreCommitExecuter = new CheckCodeStyleCodeSnifferPreCommitExecuter($this->preCommitConfig, $this->codeSnifferHandler);
 }

 public function testBoot()
 {
     $this->app['orlex.controller.dirs'] = [$path = '/sample/path/to/controllers'];
     $this->app['orlex.route.compiler'] = m::mock('Orlex\\AnnotationManager\\Compiler');
     $this->app['orlex.route.compiler']->shouldReceive('compile')->once()->with($path)->andReturnNull();
     $this->provider->boot($this->app);
 }

 public function testValidSegmentsWithIndex()
 {
     $body['docs'] = '1';
     $mockTransport = m::mock('\\Elasticsearch\\Transport')->shouldReceive('performRequest')->once()->with('PUT', '/testIndex/_settings', array(), array('docs' => 1))->getMock();
     $action = new Put($mockTransport);
     $action->setBody($body)->setIndex('testIndex')->performRequest();
 }