PHP Phake::mock方法代码示例

 /** @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());
 }

 public function setUp()
 {
     $this->httpFoundationRequestHandler = \Phake::mock('Symfony\\Component\\Form\\Extension\\HttpFoundation\\HttpFoundationRequestHandler');
     $this->jsonRequestHandler = new JsonRequestHandler($this->httpFoundationRequestHandler);
     $this->form = \Phake::mock('Symfony\\Component\\Form\\FormInterface');
     $this->request = \Phake::mock('Symfony\\Component\\HttpFoundation\\Request');
 }

 /**
  * Sets up the test fixture
  */
 public function setUp()
 {
     Phake::initAnnotations($this);
     $this->matcher = $this->getMock('Phake_Matchers_MethodMatcher', array(), array(), '', false);
     $this->stubMapper = Phake::mock('Phake_Stubber_StubMapper');
     $this->binder = new Phake_Stubber_AnswerBinder($this->matcher, $this->stubMapper);
 }

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

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

 /**
  * @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'));
 }

 /**
  * {@inheritdoc}
  */
 protected function setUp()
 {
     $this->container = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerInterface');
     $this->webUploader = \Phake::mock(WebUploader::clazz());
     $this->ctr = new UniversalUploaderController();
     $this->ctr->setContainer($this->container);
 }

 /**
  * Sets up test fixture
  */
 public function setUp()
 {
     $this->matcher1 = Phake::mock('Phake_Matchers_IChainableArgumentMatcher');
     $this->obj = $this->getMock('Phake_IMock');
     PhakeTestUtil::setStubMapper($this->obj, Phake::mock('Phake_Stubber_StubMapper'));
     $this->proxy = new Phake_Proxies_CallStubberProxy($this->matcher1, false);
 }

 public function setUp()
 {
     $this->target = new Session(new Request(array(), array()), array());
     $_SESSION = array('HOGE' => 1, 'FUGA' => 2, 'PIYO' => array('FIZZ' => 'BUZZ'));
     $this->bindable = \Phake::mock('\\Hoimi\\Bindable');
     \Phake::when($this->bindable)->getSessionKey()->thenReturn('bindable.dummy');
 }

 /**
  * @expectedException Symfony\Component\Security\Core\Exception\AccessDeniedException
  */
 public function testGetAction()
 {
     $ctrl = $this->createStoredFileController();
     $request = \Phake::mock('Symfony\\Component\\HttpFoundation\\Request');
     $resp = $ctrl->getAction($request, '');
     $this->assertEquals(Response::HTTP_NOT_FOUND, $resp->getStatusCode());
     $this->assertEquals('File not found.', $resp->getContent());
     $content = 'Hello World!';
     $storageKey = 'storage-key/repository-name/file-name.txt';
     $ctrl->storedFile = $this->createStoredFile($storageKey, $content);
     $resp = $ctrl->getAction($request, 'storage-key');
     $this->assertEquals(Response::HTTP_OK, $resp->getStatusCode());
     $this->assertEquals($content, $resp->getContent());
     $this->assertNull($resp->headers->get('content-disposition'));
     $resp = $ctrl->getAction($request, $storageKey);
     $this->assertEquals(Response::HTTP_OK, $resp->getStatusCode());
     $this->assertEquals($content, $resp->getContent());
     $this->assertNull($resp->headers->get('content-disposition'));
     $content = 'Download test';
     $ctrl->storedFile = $this->createStoredFile($storageKey, $content);
     \Phake::when($request)->get('dl')->thenReturn('');
     $resp = $ctrl->getAction($request, 'storage-key/repository-name/download-me.txt');
     $this->assertEquals(Response::HTTP_OK, $resp->getStatusCode());
     $this->assertEquals($content, $resp->getContent());
     $this->assertEquals('attachment; filename="download-me.txt"', $resp->headers->get('content-disposition'));
     $resp = $ctrl->getAction($request, 'storage-key/foo.txt');
     $this->assertEquals(Response::HTTP_OK, $resp->getStatusCode());
     $this->assertEquals($content, $resp->getContent());
     $this->assertEquals('attachment; filename="foo.txt"', $resp->headers->get('content-disposition'));
     $ctrl->setEnabled(false);
     $resp = $ctrl->getAction($request, 'Exception');
 }

 /** @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->mockReader = Phake::mock('Phake_MockReader');
     $this->stubMapper = Phake::mock('Phake_Stubber_StubMapper');
     $this->callRecorder = Phake::mock('Phake_CallRecorder_Recorder');
     $this->resetter = new Phake_Mock_Resetter($this->mockReader);
 }

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

 public function testBuild()
 {
     $containerBuilder = \Phake::mock('Symfony\\Component\\DependencyInjection\\ContainerBuilder');
     $bundle = new ModeraRoutingBundle();
     $bundle->build($containerBuilder);
     \Phake::verify($containerBuilder, \Phake::atLeast(2))->addCompilerPass($this->isInstanceOf('Symfony\\Component\\DependencyInjection\\Compiler\\CompilerPassInterface'));
 }

 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());
 }