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(); }
public function testGetSchemas() { $generator = new Generator($this->em, $this->schemaTool); $metadataFactory = m::mock('Doctrine\\ORM\\Mapping\\ClassMetadataFactory'); $connection = m::mock('Doctrine\\DBAL\\Connection'); $schemaManager = m::mock('Doctrine\\DBAL\\Schema\\AbstractSchemaManager'); $this->em->shouldReceive('getMetadataFactory')->once()->andReturn($metadataFactory); $metadataFactory->shouldReceive('getAllMetadata')->once()->andReturn($this->metadata); $this->em->shouldReceive('getConnection')->once()->andReturn($connection); $connection->shouldReceive('getSchemaManager')->once()->andReturn($schemaManager); $schemaManager->shouldReceive('createSchema')->once()->andReturn($this->fromSchema); $this->schemaTool->shouldReceive('getSchemaFromMetadata')->once()->with($this->metadata)->andReturn($this->toSchema); // multiple calls should return different clones of the same schemas $schemasA = $generator->getSchemas(); $schemasB = $generator->getSchemas(); $this->assertEquals(3, count($schemasA)); $this->assertEquals(3, count($schemasB)); $this->assertEquals($schemasA['metadata'], $this->metadata); $this->assertEquals($schemasB['metadata'], $this->metadata); $this->assertEquals($schemasA['fromSchema'], $this->fromSchema); $this->assertNotSame($schemasA['fromSchema'], $this->fromSchema); $this->assertEquals($schemasA['toSchema'], $this->toSchema); $this->assertNotSame($schemasA['toSchema'], $this->toSchema); $this->assertEquals($schemasB['fromSchema'], $this->fromSchema); $this->assertEquals($schemasB['toSchema'], $this->toSchema); $this->assertNotSame($schemasB['fromSchema'], $this->fromSchema); $this->assertNotSame($schemasB['toSchema'], $this->toSchema); $this->assertNotSame($schemasA['fromSchema'], $schemasB['fromSchema']); $this->assertNotSame($schemasA['toSchema'], $schemasB['toSchema']); }
/** * @expectedException Mockery\Exception\NoMatchingExpectationException * * Note that without the patch checked in with this test, rather than throwing * an exception, the program will go into an infinite recursive loop */ public function testFormatObjectsWithMockCalledInGetterDoesNotLeadToRecursion() { $mock = Mockery::mock('stdClass'); $mock->shouldReceive('doBar')->with('foo'); $obj = new ClassWithGetter($mock); $obj->getFoo(); }
public function setUp() { parent::setUp(); $this->mVideo_validator = M::mock('Agency\\Validators\\Contracts\\VideoValidatorInterface'); $this->parser = new parser($this->mVideo_validator); $this->mVideo = M::mock('Agency\\Video'); }
public function testCommitHydratorHappyPath() { $sha = "c3c8d149d63338c1215e0b06c839768cdf1933d5"; $data = <<<EOF tree b4ac469697c1e0f5fbb5702befc59fd7a90970a0 parent b3bf978c063bc6491919a97d1f6d6c9a6c074a2d parent deadbeefcafec0ffee19a97d1f6d6c9a6c074a2d parent cafebabe063bc6491919a97d1f6d6c9a6c074a2d author Magnus Nordlander <*****@*****.**> 1316430078 +0200 committer Magnus Nordlander <*****@*****.**> 1316430078 +0200 Updated to version 2.1.2 EOF; $raw_object = M::mock('Gittern\\Transport\\RawObject', array('getSha' => $sha, 'getData' => $data)); $hydrator = new CommitHydrator(M::mock('Gittern\\Repository')); $commit = $hydrator->hydrate($raw_object); $this->assertEquals($sha, $commit->getSha()); $this->assertEquals("b4ac469697c1e0f5fbb5702befc59fd7a90970a0", $commit->getTree()->getSha()); $parents = $commit->getParents(); $this->assertEquals("b3bf978c063bc6491919a97d1f6d6c9a6c074a2d", $parents[0]->getSha()); $user = new GitObject\User('Magnus Nordlander', "*****@*****.**"); $this->assertEquals($user, $commit->getAuthor()); $this->assertEquals($user, $commit->getCommitter()); $timestamp = \DateTime::createFromFormat('U O', '1316430078 +0200'); $this->assertEquals($timestamp, $commit->getAuthorTime()); $this->assertEquals($timestamp, $commit->getCommitTime()); }
/** * @test */ public function shouldAddAnyInterfaceNamesToImplementsDefinition() { $pass = new InterfacePass(); $config = m::mock("Mockery\\Generator\\MockConfiguration", array("getTargetInterfaces" => array(m::mock(array("getName" => "Dave\\Dave")), m::mock(array("getName" => "Paddy\\Paddy"))))); $code = $pass->apply(static::CODE, $config); $this->assertContains("implements MockInterface, \\Dave\\Dave, \\Paddy\\Paddy", $code); }
function dtestGetMultiple() { $mockChainContext = \Mockery::mock('stdClass'); $mockChainContext->feed = $this->_multipleFeed; $this->_sut->execute($mockChainContext); $result = $mockChainContext->returnValue; $this->assertTrue(is_array($result)); $this->assertEquals(8, count($result)); $video = $result[5]; $this->assertEquals('makimono', $video->getAuthorDisplayName()); $this->assertEquals('tagtool', $video->getAuthorUid()); $this->assertEquals('', $video->getCategory()); $this->assertEquals('N/A', $video->getCommentCount()); $this->assertEquals('Tagtool performance by Austrian artist Die.Puntigam at Illuminating York, 30th o...', $video->getDescription()); $this->assertEquals('6:52', $video->getDuration()); $this->assertEquals('http://vimeo.com/7416172', $video->getHomeUrl()); $this->assertEquals('7416172', $video->getId()); $this->assertEquals(array('Tagtool', 'Die.Puntigam', 'Illuminating York', 'Wall of Light'), $video->getKeywords()); $this->assertEquals('2', $video->getLikesCount()); $this->assertEquals('', $video->getRatingAverage()); $this->assertEquals('N/A', $video->getRatingCount()); $this->assertEquals('http://b.vimeocdn.com/ts/317/800/31780003_100.jpg', $video->getThumbnailUrl()); $this->assertEquals('', $video->getTimeLastUpdated()); $this->assertEquals('Nov 3, 2009', $video->getTimePublished()); $this->assertEquals('747', $video->getViewCount()); }
public function testIfTrueWhenNonAjaxRequest() { $filter = new Filter(); $request = m::mock('Illuminate\\Http\\Request'); $request->shouldReceive('ajax')->once()->andReturn(false); $this->assertTrue($filter->filter($request)); }
public function test_it_sets_default_order_by() { $Manager = m::mock('Devise\\Support\\Sortable\\Manager'); $Framework = new \Devise\Support\Framework(); $Sort = new Sort($Manager, $Framework); $Sort->setDefaultOrderBy('fieldname'); }
function testDelete() { $http = m::mock(new Services_Twilio_TinyHttp()); $http->shouldReceive('delete')->once()->with('/v1/Services/SV123')->andReturn(array(204, array('Content-Type' => 'application/json'), '')); $ipMessagingClient = new IPMessaging_Services_Twilio('AC123', '123', null, $http); $ipMessagingClient->services->delete('SV123'); }
/** * @test */ public function shouldRemoveCallStaticTypeHintIfRequired() { $pass = new CallTypeHintPass(); $config = m::mock("Mockery\\Generator\\MockConfiguration", array("requiresCallStaticTypeHintRemoval" => true))->shouldDeferMissing(); $code = $pass->apply(static::CODE, $config); $this->assertContains('__callStatic($method, $args)', $code); }
public function testBase() { // WIP $service = m::mock('service'); $service->shouldReceive('readTemp')->times(3)->andReturn(10, 12, 14); $this->markTestIncomplete('This test has not been implemented yet.'); }
/** * {@inheritdoc} */ public function setUp() { parent::setUp(); $this->factory = new ProcessFactory('pwd'); $this->directory = \Mockery::mock(\SplFileInfo::class); $this->directory->shouldReceive('__toString')->andReturn('/tmp'); }
public function _before() { $this->pheanstalkJob = \Mockery::mock('Pheanstalk\\Job'); $this->pheanstalkJob->shouldReceive('getData')->andReturn(json_encode([])); $this->connector = \Mockery::mock('Indigo\\Queue\\Connector\\BeanstalkdConnector'); $this->manager = new BeanstalkdManager('test', $this->pheanstalkJob, $this->connector); }
function testVerify() { // Given $this->startSession(); $userData = ['name' => 'Some name', 'email' => '*****@*****.**', 'password' => 'strongpassword', 'country_code' => '1', 'phone_number' => '5558180101']; $user = new User($userData); $user->authy_id = 'authy_id'; $user->save(); $this->be($user); $mockAuthyApi = Mockery::mock('Authy\\AuthyApi')->makePartial(); $mockVerification = Mockery::mock(); $mockTwilioClient = Mockery::mock(\Twilio\Rest\Client::class)->makePartial(); $mockTwilioClient->messages = Mockery::mock(); $twilioNumber = config('services.twilio')['number']; $mockTwilioClient->messages->shouldReceive('create')->with($user->fullNumber(), ['body' => 'You did it! Signup complete :)', 'from' => $twilioNumber])->once(); $mockAuthyApi->shouldReceive('verifyToken')->with($user->authy_id, 'authy_token')->once()->andReturn($mockVerification); $mockVerification->shouldReceive('ok')->once()->andReturn(true); $this->app->instance(\Twilio\Rest\Client::class, $mockTwilioClient); $this->app->instance('Authy\\AuthyApi', $mockAuthyApi); $modifiedUser = User::first(); $this->assertFalse($modifiedUser->verified); // When $response = $this->call('POST', route('user-verify'), ['token' => 'authy_token', '_token' => csrf_token()]); // Then $modifiedUser = User::first(); $this->assertRedirectedToRoute('user-index'); $this->assertTrue($modifiedUser->verified); }
public function setUp() { $this->req_tok_sample = file('./tests/samples/twt_request_token.txt')[0]; $this->acc_tok_sample = file('./tests/samples/twt_access_token.txt')[0]; $this->token = new OAuthToken(); $this->response = M::mock('Vinelab\\Http\\Response'); }