PHP Phake::when方法代碼示例

 /** @test */
 public function simpleStubWithPhake()
 {
     $service = \Phake::mock('\\Acme\\ServiceInterface');
     \Phake::when($service)->readTemp()->thenReturn(10)->thenReturn(12)->thenReturn(14);
     $temperature = new Temperature($service);
     $this->assertEquals(12, $temperature->average());
 }

 protected function setUp()
 {
     parent::setUp();
     $this->container = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
     \Phake::when($this->container)->get('modera_server_crud.persistence.default_handler')->thenReturn(new DummyDoctrinePersistenceHandler());
     \Phake::when($this->container)->get('doctrine.orm.entity_manager')->thenReturn(new DummyDoctrineEntityManager());
 }

 private function createIUT(array $cssAssets = array(), array $jsAssets = array())
 {
     $container = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
     \Phake::when($container)->get('modera_mjr_integration.css_resources_provider')->thenReturn($this->createMockProvider($cssAssets));
     \Phake::when($container)->get('modera_mjr_integration.js_resources_provider')->thenReturn($this->createMockProvider($jsAssets));
     return new AssetsProvider($container);
 }

 protected function setUp()
 {
     $this->paginUrl = \Phake::mock('Behoimi\\Pager\\PagingUrl');
     \Phake::when($this->paginUrl)->getPrev()->thenReturn('hoge');
     \Phake::when($this->paginUrl)->getNext()->thenReturn('fuga');
     $this->target = new ListResult(true, array((object) array('id' => 1, 'name' => 'name')), $this->paginUrl, null);
 }

 public function testGetUrl()
 {
     $container = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
     \Phake::when($container)->getParameter(ModeraFileRepositoryExtension::CONFIG_KEY . '.default_url_generator')->thenReturn('default_url_generator');
     \Phake::when($container)->getParameter(ModeraFileRepositoryExtension::CONFIG_KEY . '.url_generators')->thenReturn(array('foo' => 'foo_url_generator', 'bar' => 'bar_url_generator'));
     $defaultUrlGenerator = \Phake::mock('Modera\\FileRepositoryBundle\\StoredFile\\UrlGeneratorInterface');
     \Phake::when($container)->get('default_url_generator')->thenReturn($defaultUrlGenerator);
     $fooUrlGenerator = \Phake::mock('Modera\\FileRepositoryBundle\\StoredFile\\UrlGeneratorInterface');
     \Phake::when($container)->get('foo_url_generator')->thenReturn($fooUrlGenerator);
     \Phake::when($container)->get('bar_url_generator')->thenReturn('not_url_generator');
     $context = array();
     $splFile = new \SplFileInfo(__FILE__);
     $repository = \Phake::mock('Modera\\FileRepositoryBundle\\Entity\\Repository');
     \Phake::when($repository)->generateStorageKey($splFile, $context)->thenReturn('storage-key');
     $storedFile = new StoredFile($repository, $splFile, $context);
     $storedFile->init($container);
     \Phake::when($defaultUrlGenerator)->generateUrl($storedFile)->thenReturn('default_url');
     \Phake::when($fooUrlGenerator)->generateUrl($storedFile)->thenReturn('foo_url');
     \Phake::when($repository)->getConfig()->thenReturn(array('filesystem' => 'foo'));
     $this->assertEquals('foo_url', $storedFile->getUrl());
     \Phake::when($repository)->getConfig()->thenReturn(array('filesystem' => 'bar'));
     $this->assertEquals('default_url', $storedFile->getUrl());
     \Phake::when($repository)->getConfig()->thenReturn(array('filesystem' => 'baz'));
     $this->assertEquals('default_url', $storedFile->getUrl());
 }

 public function testEventWithoutStringShouldThrowInvalidArgumentExceptionError()
 {
     $this->setExpectedExceptionRegExp('InvalidArgumentException', '/^Invalid argument: the submitted variable must be a string when you enable the json_format option.$/');
     $json = ['invalid json'];
     \Phake::when($this->formEvent)->getData()->thenReturn($json);
     $this->jsonExtensionListener->onPreSubmit($this->formEvent);
 }

 /** @test */
 public function should_convert_segment_to_string()
 {
     $segment = new Segment('XXX');
     $segment->var = 'value';
     $segmentMapping = new SegmentMapping('XXX');
     $segmentMapping->addDataElement(1, new DataElementMapping(2345, true, DataElementType::A, 'var'));
     $message = new Message();
     $message->setReferenceNumber(34834);
     $message->setIdentifier(["type" => 'TEST', "version" => 'S', "release" => '404', "controllingAgency" => 'PG']);
     $message->addSegment($segment);
     //        $messageMapping = new MessageMapping();
     //        $messageMapping->setDefaults(["0065" => 'TEST', "0052" => 'S', "0054" => '404', "0051" => 'PG']);
     //        $messageMapping->addSegment(new MessageSegmentMapping('UNH', 1, true));
     //        $messageMapping->addSegment(new MessageSegmentMapping('XXX', 99, true));
     //        $messageMapping->addSegment(new MessageSegmentMapping('UNT', 1, true));
     $interchange = new Interchange();
     $interchange->setSyntax(["name" => 'UNOC', "version" => 3]);
     $interchange->setSender(['id' => 'zenon']);
     $interchange->setRecipient(['id' => 'stefan']);
     $interchange->setTime(['date' => '20150101', 'time' => '1034']);
     $interchange->setControlReference('17');
     $interchange->setMessages([$message]);
     $mappingLoader = \Phake::mock(MappingLoader::class);
     \Phake::when($mappingLoader)->loadSegments(\Phake::anyParameters())->thenReturn(['XXX' => $segmentMapping]);
     $encoder = new Encoder(new AnnotationPrinter(new AnnotationReader()), new SegmentPrinter(), $mappingLoader);
     $result = $encoder->encode($interchange);
     $this->assertEquals("UNB+UNOC:3+zenon+stefan+20150101:1034+17'UNH+34834+TEST:S:404:PG'XXX+value'UNT+1+34834'UNZ+1+17'", $result);
 }

 public function setUp()
 {
     $this->mock = $this->getMock('Phake_IMock');
     $this->mockReader = Phake::mock('Phake_MockReader');
     Phake::when($this->mockReader)->getName($this->mock)->thenReturn('Phake_IMock');
     $this->call = new Phake_CallRecorder_Call($this->mock, 'someMethod', array('foo', 'bar'), $this->mockReader);
 }

 /**
  * @test
  */
 public function parseNormal()
 {
     \Phake::when($this->commentsParser)->parse(\Phake::anyParameters())->thenReturn(null);
     $stmts = (include __DIR__ . '/../fixtures/1/Model/Product.php.property_base.cache');
     $this->parser->parse($stmts, $this->property, $this->class);
     \Phake::verify($this->commentsParser)->parse(\Phake::anyParameters());
 }

 public function setUp()
 {
     $this->mockReader = Phake::mock('Phake_MockReader');
     $this->callRecorder = Phake::mock('Phake_CallRecorder_Recorder');
     Phake::when($this->mockReader)->getCallRecorder($this->anything())->thenReturn($this->callRecorder);
     $this->handler = new Phake_ClassGenerator_InvocationHandler_MagicCallRecorder($this->mockReader);
 }

 /**
  * @test
  */
 public function it_grants_access_from_token_roles()
 {
     $user = \Phake::mock('Symfony\\Component\\Security\\Core\\User\\UserInterface');
     \Phake::when($user)->getRoles()->thenReturn(array('ROLE_USER', 'ROLE_ADMIN'));
     $context = new MockTokenContext($user);
     $this->assertTrue($context->isGranted('ROLE_USER'));
 }

 public function createRedisClient(array $parameters = array())
 {
     $mockedRedisClient = \Phake::mock('\\PSRedis\\Client');
     \Phake::when($mockedRedisClient)->isMaster()->thenReturn(false);
     \Phake::when($mockedRedisClient)->getMaster(\Phake::anyParameters())->thenReturn($mockedRedisClient);
     return $mockedRedisClient;
 }

 /**
  * @test
  */
 public function parseMethodComment()
 {
     \Phake::when($this->annotationsParser)->parse(\Phake::anyParameters())->thenReturn([]);
     $stmts = (include __DIR__ . '/../fixtures/1/Model/Product.php.method.cache');
     $method = $this->parser->parse($stmts, $this->class);
     $this->assertThat($method->comment, $this->equalTo('Sets updated datetimedetailed description here'));
 }

 protected function callProtectedMusicAPI($call_fn, $expected_url_extension, $expected_params = [], $sample_response = null)
 {
     if ($sample_response === null) {
         $sample_response = ['foo' => 'bar'];
     }
     $generator = new Generator();
     // set up the mock to check headers generated
     $tokenly_api = Phake::partialMock('Tokenly\\APIClient\\TokenlyAPI', 'https://127.0.0.1/api/v1', $generator, 'MY_CLIENT_ID', 'MY_CLIENT_SECRET');
     $called_vars = [];
     Phake::when($tokenly_api)->callRequest(Phake::anyParameters())->thenReturnCallback(function ($url, $headers, $request_params, $method, $request_options) use($sample_response, &$called_vars) {
         $called_vars = [];
         $response = new Requests_Response();
         $response->body = json_encode($sample_response);
         $called_vars['headers'] = $headers;
         $called_vars['url'] = $url;
         $called_vars['params'] = $request_params;
         return $response;
     });
     $music_api = new MusicAPI($tokenly_api);
     // check API call
     $result = $call_fn($music_api);
     PHPUnit::assertEquals($sample_response, $result);
     // check called URL
     PHPUnit::assertEquals('https://127.0.0.1/api/v1/' . $expected_url_extension, $called_vars['url']);
     // check headers
     $headers_generated = $called_vars['headers'];
     PHPUnit::assertNotEmpty($headers_generated);
     $nonce = $headers_generated['X-TOKENLY-AUTH-NONCE'];
     PHPUnit::assertGreaterThanOrEqual(time(), $nonce);
     PHPUnit::assertEquals('MY_CLIENT_ID', $headers_generated['X-TOKENLY-AUTH-API-TOKEN']);
     $expected_signature = $this->expectedSignature($nonce, 'https://127.0.0.1/api/v1/' . $expected_url_extension, $expected_params);
     PHPUnit::assertEquals($expected_signature, $headers_generated['X-TOKENLY-AUTH-SIGNATURE']);
     // return the called vars
     return $called_vars;
 }

 public function testWork()
 {
     \Phake::when($this->scraper)->scrape(\Phake::anyParameters())->thenReturn(array(new Entity(), new Entity()));
     $result = $this->target->work(null);
     \Phake::verify($this->scraper)->scrape($this->definition);
     $this->assertCount(2, $result);
 }