/** @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());
}
/**
* @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());
}
protected function setUp()
{
parent::setUp();
Phake::when($this->facade)->is_user_logged_in()->thenReturn(true);
Phake::when($this->facade)->wp_get_current_user()->thenReturn($this->user);
Phake::when($this->wpdb)->get_var(Phake::anyParameters())->thenReturn('true');
}
public function initialize($object)
{
$reflectionClass = new ReflectionClass($object);
$reader = new Phake_Annotation_Reader($reflectionClass);
if ($this->useDoctrineParser()) {
$parser = new \Doctrine\Common\Annotations\PhpParser();
}
$properties = $reader->getPropertiesWithAnnotation('Mock');
foreach ($properties as $property) {
$annotations = $reader->getPropertyAnnotations($property);
if ($annotations['Mock'] !== true) {
$mockedClass = $annotations['Mock'];
} else {
$mockedClass = $annotations['var'];
}
if (isset($parser)) {
// Ignore it if the class start with a backslash
if (substr($mockedClass, 0, 1) !== '\\') {
$useStatements = $parser->parseClass($reflectionClass);
$key = strtolower($mockedClass);
if (array_key_exists($key, $useStatements)) {
$mockedClass = $useStatements[$key];
}
}
}
$reflProp = new ReflectionProperty(get_class($object), $property);
$reflProp->setAccessible(true);
$reflProp->setValue($object, Phake::mock($mockedClass));
}
}
public function testToString()
{
Phake::when($this->adapted)->__toString->thenReturn('test string');
$result = $this->matcher->__toString();
Phake::verify($this->adapted)->__toString();
$this->assertEquals('test string', $result);
}
public function testStorageDestruct()
{
$this->Web->queries($this->queries);
$this->Web->crawl();
// assertion maximus
\Phake::verify($this->Storage, \Phake::times(1))->destruct();
}
/**
* @test
*/
public function parseClassComment()
{
\Phake::when($this->annotationsParser)->parse(\Phake::anyParameters())->thenReturn([]);
$stmts = (include __DIR__ . '/../fixtures/1/Model/Product.php.class.cache');
$class = $this->parser->parse($stmts, '', '');
$this->assertThat($class->comment, $this->equalTo('商品エンティティ'));
}
/**
* 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 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());
}
/** @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 testFindInTrans()
{
$this->target->begin();
$this->target->find('hoge', 'ssd', array('a', 'b', 3), 'fuga');
\Phake::verify($this->write)->find('hoge', 'ssd', array('a', 'b', 3), 'fuga');
\Phake::verify($this->read, \Phake::never())->find('hoge', 'ssd', array('a', 'b', 3), 'fuga');
}
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 testCorrelationDataIsAttached()
{
CorrelationDataHolder::setCorrelationData(array('correlationId' => 'test'));
$this->testSubject->send(new HelloCommand('Hi !!!'));
\Phake::verify($this->mockCommandBus)->dispatch(\Phake::capture($command), null);
$this->assertEquals(array('correlationId' => 'test'), $command->getMetaData()->all());
}
public function invoke($mock, $method, array $arguments, array &$argumentReference)
{
if ($this->mockInfo->isObjectFrozen()) {
$result = new Phake_CallRecorder_VerifierResult(false, array(), 'This object has been frozen.');
Phake::getClient()->processVerifierResult($result);
}
}
/**
* @param Phake_IMock $mock
* @return Phake_Mock_Info
*/
public static function getMockedInfo(Phake_IMock $mock)
{
if (empty($mock->__PHAKE_info)) {
$mock->__PHAKE_info = Phake::mock('Phake_Mock_Info');
}
return $mock->__PHAKE_info;
}
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);
}
public function testReset()
{
$this->registry->resetAll();
Phake::verify($this->info1)->resetInfo();
Phake::verify($this->info2)->resetInfo();
Phake::verify($this->info3)->resetInfo();
}
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);
}
public function testConfigureCustomAggregateFactory()
{
$this->fixture->registerAggregateFactory($this->mockAggregateFactory);
$this->fixture->registerAnnotatedCommandHandler(new MyCommandHandler($this->fixture->getRepository(), $this->fixture->getEventBus()));
$this->fixture->given([new MyEvent("id1", 1)])->when(new TestCommand("id1"));
\Phake::verify($this->mockAggregateFactory, \Phake::atLeast(1))->createAggregate(\Phake::equalTo("id1"), \Phake::anyParameters());
}
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);
}
/**
* @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'));
}
/**
* @test
*
* @since Method available since Release 2.1.0
*/
public function setsTheStateMachineObject()
{
$stateMachine1 = \Phake::mock('Stagehand\\FSM\\StateMachine\\StateMachineInterface');
$stateMachineBuilder = new StateMachineBuilder($stateMachine1);
$stateMachine2 = $stateMachineBuilder->getStateMachine();
$this->assertThat($stateMachine2, $this->identicalTo($stateMachine1));
}
public function testFreeze()
{
$client = Phake::mock('Phake_Client_IClient');
$this->freezer->freeze($this->mockInfo, $client);
Phake::verify($client)->processObjectFreeze();
Phake::verify($this->mockInfo)->freezeObject();
}
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());
}
/**
* For some reason setUp nor setUpBeforeClass would create the requested object
*
* @return Screen
*/
protected function getScreen()
{
if (empty($this->screen) === true) {
$this->screen = Phake::partialMock('Arjf\\Devices\\Handheld\\Apple\\Screen', 320, 480);
}
return $this->screen;
}
/**
* @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 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);
}
public function testNonMagicCallDoesNothing()
{
$mock = $this->getMock('Phake_IMock');
$ref = array();
$this->handler->invoke($mock, 'foo', array(), $ref);
Phake::verifyNoInteraction($this->callRecorder);
}
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 parseNormal()
{
\Phake::when($this->parser)->parse(\Phake::anyParameters())->thenReturn(null);
$path = __DIR__ . '/../fixtures/1';
$this->projectParser->parse($path);
\Phake::verify($this->parser, \Phake::times(3))->parse(\Phake::anyParameters());
}