public function testBelongToGalleryRelationshipObjectReturned()
{
$meta = Factory::create('PostMeta', ['post_id' => 1]);
Factory::create('Gallery');
$relationship = $meta->gallery();
assertThat($relationship, is(anInstanceOf('Illuminate\\Database\\Eloquent\\Relations\\BelongsTo')));
}
public function testTestHasManyMetaRetionshipObjectIsReturned()
{
$gallery = Factory::create('Gallery');
Factory::create('PostMeta', ['post_id' => 1]);
$relationship = $gallery->meta();
assertThat($relationship, is(anInstanceOf('Illuminate\\Database\\Eloquent\\Relations\\HasMany')));
}
public function testGetFileLicenseMatches()
{
$this->testDb->createPlainTables(array('license_ref', 'uploadtree', 'license_file', 'agent'));
$this->testDb->insertData_license_ref();
$lic0 = $this->dbManager->getSingleRow("Select * from license_ref limit 1");
$licenseRefNumber = $lic0['rf_pk'];
$licenseFileId = 1;
$pfileId = 42;
$agentId = 23;
$matchPercent = 50;
$uploadtreeId = 512;
$uploadID = 123;
$left = 2009;
$right = 2014;
$agentName = "fake";
$agentRev = 1;
$mydate = "'2014-06-04 14:01:30.551093+02'";
$this->testDb->createViews(array('license_file_ref'));
$this->dbManager->queryOnce("INSERT INTO license_file (fl_pk, rf_fk, agent_fk, rf_match_pct, rf_timestamp, pfile_fk)\n VALUES ({$licenseFileId}, {$licenseRefNumber}, {$agentId}, {$matchPercent}, {$mydate}, {$pfileId})");
$this->dbManager->queryOnce("INSERT INTO uploadtree (uploadtree_pk, upload_fk, pfile_fk, lft, rgt)\n VALUES ({$uploadtreeId}, {$uploadID}, {$pfileId}, {$left}, {$right})");
$stmt = __METHOD__ . '.insert.agent';
$this->dbManager->prepare($stmt, "INSERT INTO agent (agent_pk, agent_name, agent_rev, agent_enabled) VALUES (\$1,\$2,\$3,\$4)");
$this->dbManager->execute($stmt, array($agentId, $agentName, $agentRev, 'true'));
$licDao = new LicenseDao($this->dbManager);
$itemTreeBounds = new ItemTreeBounds($uploadtreeId, "uploadtree", $uploadID, $left, $right);
$matches = $licDao->getAgentFileLicenseMatches($itemTreeBounds);
$licenseRef = new LicenseRef($licenseRefNumber, $lic0['rf_shortname'], $lic0['rf_fullname']);
$agentRef = new AgentRef($agentId, $agentName, $agentRev);
$expected = array(new LicenseMatch($pfileId, $licenseRef, $agentRef, $licenseFileId, $matchPercent));
assertThat($matches, equalTo($expected));
assertThat($matches[0], is(anInstanceOf(LicenseMatch::classname())));
$this->addToAssertionCount(\Hamcrest\MatcherAssert::getCount() - $this->assertCountBefore);
}
public function testInterface()
{
assertThat($this->client, is(anInstanceOf('Graze\\Queue\\ConsumerInterface')));
assertThat($this->client, is(anInstanceOf('Graze\\Queue\\DeleterInterface')));
assertThat($this->client, is(anInstanceOf('Graze\\Queue\\ProducerInterface')));
assertThat($this->client, is(anInstanceOf('Graze\\Queue\\PurgerInterface')));
}
public function testSetHostToCreateNewGallery()
{
$model = new RemoteModelStub();
$model->setHost('Flickr');
$gallery = $model->newModel();
assertThat($gallery, is(anInstanceOf('PullAutomaticallyGalleries\\RemoteApi\\RemoteApiModelInterface')));
}
function testBoot()
{
$ioc = org_tubepress_impl_ioc_IocContainer::getInstance();
$pm = $ioc->get(org_tubepress_api_plugin_PluginManager::_);
$expectedSystemFilters = array(array(org_tubepress_api_const_plugin_FilterPoint::OPTION_SET_PRE_VALIDATION, 'org_tubepress_impl_plugin_filters_prevalidationoptionset_YouTubePlaylistPlPrefixRemover'), array(org_tubepress_api_const_plugin_FilterPoint::OPTION_SET_PRE_VALIDATION, 'org_tubepress_impl_plugin_filters_prevalidationoptionset_StringMagic'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_EMBEDDED, 'org_tubepress_impl_plugin_filters_embeddedtemplate_CoreVariables'), array(org_tubepress_api_const_plugin_FilterPoint::HTML_EMBEDDED, 'org_tubepress_impl_plugin_filters_embeddedhtml_PlayerJavaScriptApi'), array(org_tubepress_api_const_plugin_FilterPoint::HTML_GALLERY, 'org_tubepress_impl_plugin_filters_galleryhtml_GalleryJs'), array(org_tubepress_api_const_plugin_FilterPoint::JAVASCRIPT_GALLERYINIT, 'org_tubepress_impl_plugin_filters_galleryinitjs_GalleryInitJsBaseParams'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_GALLERY, 'org_tubepress_impl_plugin_filters_gallerytemplate_CoreVariables'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_GALLERY, 'org_tubepress_impl_plugin_filters_gallerytemplate_EmbeddedPlayerName'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_GALLERY, 'org_tubepress_impl_plugin_filters_gallerytemplate_Pagination'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_GALLERY, 'org_tubepress_impl_plugin_filters_gallerytemplate_Player'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_GALLERY, 'org_tubepress_impl_plugin_filters_gallerytemplate_VideoMeta'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_PLAYER, 'org_tubepress_impl_plugin_filters_playertemplate_CoreVariables'), array(org_tubepress_api_const_plugin_FilterPoint::PROVIDER_RESULT, 'org_tubepress_impl_plugin_filters_providerresult_ResultCountCapper'), array(org_tubepress_api_const_plugin_FilterPoint::PROVIDER_RESULT, 'org_tubepress_impl_plugin_filters_providerresult_VideoBlacklist'), array(org_tubepress_api_const_plugin_FilterPoint::PROVIDER_RESULT, 'org_tubepress_impl_plugin_filters_providerresult_PerPageSorter'), array(org_tubepress_api_const_plugin_FilterPoint::PROVIDER_RESULT, 'org_tubepress_impl_plugin_filters_providerresult_VideoPrepender'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_SEARCHINPUT, 'org_tubepress_impl_plugin_filters_searchinputtemplate_CoreVariables'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_SINGLEVIDEO, 'org_tubepress_impl_plugin_filters_singlevideotemplate_CoreVariables'), array(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_SINGLEVIDEO, 'org_tubepress_impl_plugin_filters_singlevideotemplate_VideoMeta'), array(org_tubepress_api_const_plugin_FilterPoint::VARIABLE_READ_FROM_EXTERNAL_INPUT, 'org_tubepress_impl_plugin_filters_variablereadfromexternalinput_StringMagic'));
foreach ($expectedSystemFilters as $filter) {
$pm->shouldReceive('registerFilter')->with($filter[0], anInstanceOf($filter[1]))->once();
}
$pm->shouldReceive('registerListener')->with(org_tubepress_api_const_plugin_EventName::BOOT, anInstanceOf('org_tubepress_impl_plugin_listeners_StorageManagerInitListener'));
$pm->shouldReceive('registerListener')->with(org_tubepress_api_const_plugin_EventName::BOOT, anInstanceOf('org_tubepress_impl_plugin_listeners_WordPressBoot'));
$pm->shouldReceive('registerListener')->with(org_tubepress_api_const_plugin_EventName::BOOT, anInstanceOf('org_tubepress_impl_plugin_listeners_SkeletonExistsListener'));
$pm->shouldReceive('notifyListeners')->with(org_tubepress_api_const_plugin_EventName::BOOT)->once();
$envD = $ioc->get(org_tubepress_api_environment_Detector::_);
$envD->shouldReceive('isWordPress')->once()->andReturn(false);
$context = $ioc->get(org_tubepress_api_exec_ExecutionContext::_);
$context->shouldReceive('get')->with(org_tubepress_api_const_options_names_Advanced::DEBUG_ON)->andReturn(false);
$fe = $ioc->get(org_tubepress_api_filesystem_Explorer::_);
$fe->shouldReceive('getDirectoriesInDirectory')->once()->with('<<user-content-dir>>/plugins', anything())->andReturn(array('fakedirectory'));
$fe->shouldReceive('getFilenamesInDirectory')->once()->with('fakedirectory', anything())->andReturn(array(dirname(__FILE__) . '/../../../resources/simplePhpFile.php'));
$th = $ioc->get(org_tubepress_api_theme_ThemeHandler::_);
$th->shouldReceive('getUserContentDirectory')->once()->andReturn('<<user-content-dir>>');
$sm = $ioc->get(org_tubepress_api_options_StorageManager::_);
$sm->shouldReceive('init')->once();
$this->_sut->boot();
}
public function testFormatterImplementsInterfaces()
{
$formatter = new MockFormatter();
assertThat($formatter, is(anInstanceOf(FormatterInterface::class)));
assertThat($formatter, is(anInstanceOf(ProcessorAwareInterface::class)));
assertThat($formatter, is(anInstanceOf(FilterAwareInterface::class)));
assertThat($formatter, is(anInstanceOf(SorterAwareInterface::class)));
}
public function testDispatchNotFoundRoute()
{
$dispatcher = new Dispatcher($this->router);
$response = $dispatcher->dispatch('GET', '/not-found');
assertThat($response, is(anInstanceOf('Rootr\\Response')));
assertThat($this->readAttribute($response, 'status'), is(equalTo(404)));
assertThat($this->readAttribute($response, 'body'), is(equalTo('Not Found')));
}
public function testCreateMessageWithValidator()
{
$message = $this->factory->createMessage('bar', ['validator' => function ($msg) {
return false;
}]);
assertThat($message, is(anInstanceOf('Graze\\Queue\\Message\\MessageInterface')));
assertThat($message->getBody(), is(identicalTo('bar')));
assertThat($message->isValid(), is(identicalTo(false)));
}
public function testCancelUsurpation()
{
$token = $this->mock('Symfony\\Component\\Security\\Core\\Authentication\\Token\\AbstractToken');
$user = new User();
$token->shouldReceive('getUser')->once()->andReturn($user);
$this->om->shouldReceive('refresh')->once()->with($user);
$this->sc->shouldReceive('setToken')->once()->with(anInstanceOf('Symfony\\Component\\Security\\Core\\Authentication\\Token\\UsernamePasswordToken'));
$this->getUpdater()->cancelUsurpation($token);
}
public function testShouldMonitorExecutionOfFunction()
{
$result = monitorExecution(function () {
});
assertThat($result->dateStart, anInstanceOf('Datetime'));
assertThat($result->dateFinish, anInstanceOf('Datetime'));
assertThat($result->elapsedSeconds, greaterThanOrEqualTo(0));
assertThat($result->convertSecondsToReadableString(), is('0s'));
assertThat($result->hasFailed(), is(false));
}
public function testDetectCircularDependencies()
{
$items = array('item1' => array('deps' => null, 'id' => 'item1'), 'item2' => array('deps' => null, 'id' => 'item2'), 'item3' => array('deps' => array('item2'), 'id' => 'item3'), 'item4' => array('deps' => array('item1', 'item3'), 'id' => 'item4'), 'item5' => array('deps' => array('item4', 'item6', 'item7'), 'id' => 'item5'), 'item6' => array('deps' => array('item2'), 'id' => 'item6'), 'item7' => array('deps' => array('item1', 'item4', 'item5'), 'id' => 'item7'));
$resolver = new DependencyResolver();
$resolver->register($items);
try {
$resolver->resolveAll();
} catch (\Exception $e) {
assertThat($e, is(anInstanceOf('\\RuntimeException')));
}
}
public function testUpdateJob()
{
Artisan::call('migrate');
RangeCronJob::create(['job_name' => 'foobar job', 'last_id_processed' => 1, 'last_status' => 'fooness']);
$job = $this->repo->findJob('foobar job');
assertThat($job, anInstanceOf('Giftertipster\\Entity\\Eloquent\\RangeCronJob'));
$this->repo->updateJob($job, 'test status', 0);
$updated_job = $this->repo->findJob('foobar job');
assertThat($updated_job->last_status, identicalTo('test status'));
assertThat($updated_job->last_id_processed, equalTo(0));
}
public function testAuthenticateSuccess()
{
$user = $this->mock('Claroline\\CoreBundle\\Entity\\User');
$user->shouldReceive('getSalt')->once()->andReturn('salt');
$user->shouldReceive('getPassword')->once()->andReturn('trueEncodedPw');
$user->shouldReceive('getRoles')->once()->andReturn(array());
$encoder = $this->mock('Symfony\\Component\\Security\\Core\\Encoder\\PasswordEncoderInterface');
$this->userRepo->shouldReceive('loadUserByUsername')->once()->with('name')->andReturn($user);
$this->encoderFactory->shouldReceive('getEncoder')->andReturn($encoder);
$encoder->shouldReceive('encodePassword')->once()->with('pw', 'salt')->andReturn('trueEncodedPw');
$this->sc->shouldReceive('setToken')->with(anInstanceOf('Symfony\\Component\\Security\\Core\\Authentication\\Token\\UsernamePasswordToken'));
$this->assertTrue($this->authenticator->authenticate('name', 'pw'));
}
public function testShouldFormatTraversableAccordingToConvertMethod()
{
$items = ['foo', 'bar', 'baz'];
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('The result of `formatTraversable` should be a Generator.', $result, is(anInstanceOf('Generator')));
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('Every item in the result should be an array.', iterator_to_array($result), everyItem(is(typeOf('array'))));
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('The result should be the same size as the number of items passed to `formatTraversable`.', $result, is(traversableWithSize(count($items))));
/** @var Generator **/
$result = (new MockFormatter())->formatTraversable(new ArrayIterator($items));
assertThat('The result should be correctly formatted.', iterator_to_array($result), is(anArray([['count' => 1], ['count' => 2], ['count' => 3]])));
}
function testConvert()
{
$ioc = org_tubepress_impl_ioc_IocContainer::getInstance();
$pm = $ioc->get(org_tubepress_api_plugin_PluginManager::_);
$pm->shouldReceive('hasFilters')->once()->with(org_tubepress_api_const_plugin_FilterPoint::VIDEO)->andReturn(true);
$pm->shouldReceive('runFilters')->once()->with(org_tubepress_api_const_plugin_FilterPoint::VIDEO, 'one', 'providerrr')->andReturn('modified one');
$pm->shouldReceive('runFilters')->once()->with(org_tubepress_api_const_plugin_FilterPoint::VIDEO, 'two', 'providerrr')->andReturn('modified two');
$pc = $ioc->get(org_tubepress_api_provider_ProviderCalculator::_);
$pc->shouldReceive('calculateCurrentVideoProvider')->once()->andReturn('providerrr');
$mockChainContext = \Mockery::mock('stdClass');
$mockChainContext->returnValue = array('one', 'two');
$chain = $ioc->get(org_tubepress_spi_patterns_cor_Chain::_);
$chain->shouldReceive('execute')->once()->with(anInstanceOf('stdClass'), array('org_tubepress_impl_factory_commands_YouTubeFactoryCommand', 'org_tubepress_impl_factory_commands_VimeoFactoryCommand'))->andReturn(true);
$chain->shouldReceive('createContextInstance')->once()->andReturn($mockChainContext);
$this->assertEquals(array('modified one', 'modified two'), $this->_sut->feedToVideoArray('bla'));
}
function testGetHtml()
{
$mockTemplate = \Mockery::mock('org_tubepress_api_template_Template');
$mockTemplate->shouldReceive('toString')->once()->andReturn('templateAsString');
$mockChainContext = \Mockery::mock('stdClass');
$mockChainContext->template = $mockTemplate;
$mockChainContext->dataUrl = 'dataurl';
$mockChainContext->embeddedImplementationName = 'implname';
$ioc = org_tubepress_impl_ioc_IocContainer::getInstance();
$pc = $ioc->get(org_tubepress_api_provider_ProviderCalculator::_);
$pc->shouldReceive('calculateProviderOfVideoId')->with('videoid')->once()->andReturn('video_provider');
$chain = $ioc->get(org_tubepress_spi_patterns_cor_Chain::_);
$chain->shouldReceive('execute')->once()->with(anInstanceOf('stdClass'), array('org_tubepress_impl_embedded_commands_JwFlvCommand', 'org_tubepress_impl_embedded_commands_EmbedPlusCommand', 'org_tubepress_impl_embedded_commands_YouTubeIframeCommand', 'org_tubepress_impl_embedded_commands_VimeoCommand'))->andReturn(true);
$chain->shouldReceive('createContextInstance')->once()->andReturn($mockChainContext);
$pm = $ioc->get(org_tubepress_api_plugin_PluginManager::_);
$pm->shouldReceive('runFilters')->once()->with(org_tubepress_api_const_plugin_FilterPoint::TEMPLATE_EMBEDDED, $mockTemplate, 'videoid', 'video_provider', 'dataurl', 'implname')->andReturn($mockTemplate);
$pm->shouldReceive('runFilters')->once()->with(org_tubepress_api_const_plugin_FilterPoint::HTML_EMBEDDED, 'templateAsString', 'videoid', 'video_provider', 'implname')->andReturn('final_result');
$result = $this->_sut->getHtml('videoid');
$this->assertEquals('final_result', $result);
}
public function testGetCopyrightHighlights()
{
$this->testDb->createPlainTables(array(), true);
$this->testDb->createInheritedTables();
$uploadDao = M::mock('Fossology\\Lib\\Dao\\UploadDao');
$uploadDao->shouldReceive('getUploadEntry')->with(1)->andReturn(array('pfile_fk' => 8));
$uploadDao->shouldReceive('getUploadEntry')->with(2)->andReturn(array('pfile_fk' => 9));
$copyrightDao = new CopyrightDao($this->dbManager, $uploadDao);
$noHighlights = $copyrightDao->getHighlights($uploadTreeId = 1);
assertThat($noHighlights, emptyArray());
$this->testDb->insertData(array('copyright'));
$highlights = $copyrightDao->getHighlights($uploadTreeId = 1);
assertThat($highlights, arrayWithSize(1));
$highlight0 = $highlights[0];
assertThat($highlight0, anInstanceOf(Highlight::classname()));
$this->assertInstanceOf('Fossology\\Lib\\Data\\Highlight', $highlight0);
assertThat($highlight0->getEnd(), equalTo(201));
$hilights = $copyrightDao->getHighlights($uploadTreeId = 2);
assertThat($hilights, arrayWithSize(1));
$hilight0 = $hilights[0];
assertThat($hilight0->getStart(), equalTo(0));
}
public function testCustomAction()
{
$controller = $this->getController(array('checkAccess'));
$action = 'action';
$node = $this->mock('Claroline\\CoreBundle\\Entity\\Resource\\ResourceNode');
$res = $this->mock('Claroline\\CoreBundle\\Entity\\Resource\\AbstractResource');
$this->resourceManager->shouldReceive('getResourceFromNode')->with($node)->once()->andReturn($res);
$type = $this->mock('Claroline\\CoreBundle\\Entity\\Resource\\ResourceType');
$type->shouldReceive('getName')->andReturn('type');
$node->shouldReceive('getResourceType')->andReturn($type);
$customActionEvent = $this->mock('Claroline\\CoreBundle\\Event\\CustomActionResourceEvent');
$menuAction = $this->mock('Claroline\\CoreBundle\\Entity\\Resource\\MenuAction');
$menuAction->shouldReceive('getValue')->once()->andReturn(42);
$this->maskManager->shouldReceive('getMenuFromNameAndResourceType')->with($action, $type)->andReturn($menuAction);
$decoder = $this->mock('Claroline\\CoreBundle\\Entity\\Resource\\MaskDecoder');
$decoder->shouldReceive('getName')->andReturn('decoderaction');
$this->maskManager->shouldReceive('getByValue')->once()->with($type, 42)->andReturn($decoder);
$controller->shouldReceive('checkAccess')->with('decoderaction', anInstanceOf('Claroline\\CoreBundle\\Library\\Resource\\ResourceCollection'));
$this->dispatcher->shouldReceive('dispatch')->once()->with('action_type', 'CustomActionResource', array($res))->andReturn($customActionEvent);
$response = new \Symfony\Component\HttpFoundation\Response();
$customActionEvent->shouldReceive('getResponse')->andReturn($response);
$this->assertEquals($response->getContent(), $controller->customAction('action', $node)->getContent());
$this->assertInstanceOf('Symfony\\Component\\HttpFoundation\\Response', $controller->customAction('action', $node));
}
public function testDecribesActualClassInMismatchMessage()
{
$this->assertMismatchDescription('[Hamcrest_Core_SampleBaseClass] <good>', anInstanceOf('Hamcrest_Core_SampleSubClass'), $this->_baseClassInstance);
}
public function testRunReturnsFalseWithErrorsWhenResponseIsNotValidated()
{
$this->ConfigMock->shouldReceive('setCountry')->andReturn($this->ConfigMock);
$this->ConfigMock->shouldReceive('setAccessKey')->andReturn($this->ConfigMock);
$this->ConfigMock->shouldReceive('setSecretKey')->andReturn($this->ConfigMock);
$this->ConfigMock->shouldReceive('setAssociateTag')->andReturn($this->ConfigMock);
$this->ApaiIOMock->shouldReceive('runOperation')->once()->andReturn('<xml>foo</xml>');
$SearchOperationMock = Mockery::mock('ApaiIO\\Operations\\Search');
$this->app->instance('ApaiIO\\Configuration\\GenericConfiguration', $this->ConfigMock);
$this->app->instance('ApaiIO\\ApaiIO', $this->ApaiIOMock);
$response_validator_mock = Mockery::mock('Giftertipster\\Service\\Api\\AmzProductApi\\ResponseValidationInterface');
$response_validator_mock->shouldReceive('validate')->with(anInstanceOf('\\SimpleXMLElement'))->andReturn(false);
$response_validator_mock->shouldReceive('errors')->once()->andReturn(['errors stub']);
$this->app->instance('Giftertipster\\Service\\Api\\AmzProductApi\\ResponseValidationInterface', $response_validator_mock);
$Repository = $this->app->make('Giftertipster\\Service\\Api\\AmzProductApi\\ApaiIO\\ApaiIOAmzProductApi');
$Response = $Repository->run($SearchOperationMock);
$errors = $Repository->errors();
assertThat($Response, identicalTo(false));
assertThat($errors, identicalTo(['errors stub']));
}
/** @dataProvider provideDates */
public function testShouldExtractPartOfDate($unit, $expectedDate)
{
$today = new Today();
assertThat($today->date, anInstanceOf('DateTime'));
assertThat($today->{$unit}, is(date($expectedDate)));
}
public function testConstructAndSanity()
{
$uploadBrowseProxy = new UploadBrowseProxy($this->groupId, UserDao::USER, $this->testDb->getDbManager(), true);
assertThat($uploadBrowseProxy, is(anInstanceOf(UploadBrowseProxy::classname())));
}
public function testCreateWithPatternBuilder()
{
$patternBuilder = \Mockery::mock('Rootr\\PatternBuilder');
$router = new Router($patternBuilder);
assertThat($router, is(anInstanceOf('Rootr\\Router')));
}
public function testGetSingleVideo()
{
$val = array($this->_fakeVideo);
$this->_setupSingleVideoMocks($val);
$ioc = org_tubepress_impl_ioc_IocContainer::getInstance();
$pc = $ioc->get(org_tubepress_api_provider_ProviderCalculator::_);
$pc->shouldReceive('calculateProviderOfVideoId')->with('video-id')->andReturn('video-provider');
$pm = $ioc->get(org_tubepress_api_plugin_PluginManager::_);
$pm->shouldReceive('runFilters')->with(org_tubepress_api_const_plugin_FilterPoint::PROVIDER_RESULT, anInstanceOf('org_tubepress_api_provider_ProviderResult'), 'video-provider')->once();
$this->assertEquals($this->_fakeVideo, $this->_sut->getSingleVideo('video-id'));
}
public function testGetPreviousItemWithMultipleFiles()
{
$subentries = $this->getSubentriesForMultipleFiles();
$this->prepareModularTable($subentries);
$nextItem = $this->uploadDao->getPreviousItem(1, 6);
assertThat($nextItem, anInstanceOf(Item::classname()));
assertThat($nextItem->getId(), is(8));
}
/**
* @expectedException \RuntimeException
*/
public function testSandboxMultiResponseException()
{
// [1] Check basic multiResponse with one response by params
$request = new ParameterBag(['some_parameter' => 3, 'some_parameter2' => 4]);
$query = new ParameterBag();
$rawRequest = new ArrayCollection();
$object = new testObject();
$method = 'annotatedResponseFunction';
$annotationsReader = ShortifyPunit::mock('Doctrine\\Common\\Annotations\\AnnotationReader');
$responseObj = new \StdClass();
$responseObj->parameters = [['name' => 'some_parameter', 'required' => true]];
$responseObj->type = 'json';
$responseObj->responseCode = 200;
$responseObj->multiResponse = [['resource' => '@SandboxBundle/Resources/responses/token.json']];
ShortifyPunit::when($annotationsReader)->getMethodAnnotation(anInstanceOf('ReflectionMethod'), 'danrevah\\SandboxBundle\\Annotation\\ApiSandboxResponse')->returns(false);
ShortifyPunit::when($annotationsReader)->getMethodAnnotation(anInstanceOf('ReflectionMethod'), 'danrevah\\SandboxBundle\\Annotation\\ApiSandboxMultiResponse')->returns($responseObj);
$sandboxResponseManager = $this->createManager(true, $annotationsReader);
$sandboxResponseManager->getResponseController($object, $method, $request, $query, $rawRequest);
}
public function testReceiveMessageWaitTimeSecondsOption()
{
$options = ['ReceiveMessageWaitTimeSeconds' => 20];
$adapter = new SqsAdapter($this->client, 'foo', $options);
$url = $this->stubCreateQueue('foo', $options);
$timeout = $this->stubQueueVisibilityTimeout($url);
$this->stubCreateDequeueMessage('foo', 0, 'a');
$this->stubCreateDequeueMessage('bar', 1, 'b');
$this->stubCreateDequeueMessage('baz', 2, 'c');
$this->model->shouldReceive('get')->once()->with('Messages')->andReturn([['Body' => 'foo', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 0, 'ReceiptHandle' => 'a'], ['Body' => 'bar', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 1, 'ReceiptHandle' => 'b'], ['Body' => 'baz', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 2, 'ReceiptHandle' => 'c']]);
$this->client->shouldReceive('receiveMessage')->once()->with(['QueueUrl' => $url, 'AttributeNames' => ['All'], 'MaxNumberOfMessages' => 3, 'VisibilityTimeout' => $timeout, 'WaitTimeSeconds' => 20])->andReturn($this->model);
$iterator = $adapter->dequeue($this->factory, 3);
assertThat($iterator, is(anInstanceOf('Generator')));
assertThat(iterator_to_array($iterator), is(equalTo($this->messages)));
}
public function testShouldInitalize()
{
$dataValidator = new DataValidator();
assertThat('`Graze\\DataValidator\\DataValidator` should implement `Graze\\DataValidator\\DataValidatorInterface`.', $dataValidator, is(anInstanceOf(DataValidatorInterface::class)));
}
public function testRelevantClearingEvents()
{
$groupId = 701;
$this->buildProposals(array(array(301, 1, $groupId, 401, false, -99), array(301, 2, $groupId, 402, true, -98), array(301, 2, $groupId, 401, true, -97)), $firstEventId = 0);
$this->buildDecisions(array(array(301, 1, $groupId, DecisionTypes::IDENTIFIED, -90, DecisionScopes::REPO, array($firstEventId, $firstEventId + 1, $firstEventId + 2))));
$itemTreeBounds = M::mock(ItemTreeBounds::classname());
$itemTreeBounds->shouldReceive('getItemId')->andReturn(301);
$itemTreeBounds->shouldReceive('getUploadTreeTableName')->andReturn('uploadtree');
$itemTreeBounds->shouldReceive('containsFiles')->andReturn(false);
$itemTreeBounds->shouldReceive('getUploadId')->andReturn($this->items[301][0]);
$itemTreeBounds->shouldReceive('getLeft')->andReturn($this->items[301][4]);
$itemTreeBounds->shouldReceive('getRight')->andReturn($this->items[301][5]);
$events1 = $this->clearingDao->getRelevantClearingEvents($itemTreeBounds, $groupId);
assertThat($events1, arrayWithSize(2));
assertThat($events1, hasKeyInArray(401));
assertThat($events1, hasKeyInArray(402));
assertThat($events1[401], is(anInstanceOf(ClearingEvent::classname())));
assertThat($events1[402]->getEventId(), is($firstEventId + 1));
assertThat($events1[401]->getEventId(), is($firstEventId + 2));
}
