/** @dataProvider provideDateInterval */
 public function testShouldLoadMonthsBetweenTwoDates($start, $end, $expectedMonthsCount)
 {
     $analyzer = $this->prophesize('Scortes\\Calendar\\Month\\AnalyzeMonth');
     $analyzer->__invoke(Argument::any())->shouldBeCalledTimes($expectedMonthsCount);
     $uc = new CreateMonthsInterval($analyzer->reveal());
     $months = $uc(DateTime::createFromFormat('Y-m', $start), DateTime::createFromFormat('Y-m', $end));
     assertThat($months, arrayWithSize($expectedMonthsCount));
     return $months;
 }
 public function testShouldFormatManyAccordingToConvertMethod()
 {
     $items = ['foo', 'bar', 'baz'];
     $formatter = new MockFormatter();
     $result = $formatter->formatMany($items);
     assertThat('The result of `formatMany` should be an array of arrays.', $result, everyItem(is(typeOf('array'))));
     assertThat('The result should be the same size as the number of items passed to `formatMany`.', $result, is(arrayWithSize(count($items))));
     assertThat('The result should be correctly formatted.', $result, is(anArray([['count' => 1], ['count' => 2], ['count' => 3]])));
 }
Exemple #3
0
 public function testRouteWithOptionalVariable()
 {
     $pattern = $this->instance->build('/news/{year:\\d{4}}/{month:\\d{2}}/{?slug}');
     assertThat($pattern, is(arrayWithSize(2)));
     list($regEx, $variables) = $pattern;
     assertThat($regEx, is(equalTo('/news/(\\d{4})/(\\d{2})(?:/([^/]+))?')));
     assertThat($variables, is(equalTo(['year', 'month', 'slug'])));
     assertThat(preg_match('~^' . $regEx . '$~', '/news/2014/05/lastest-news'), is(true));
     assertThat(preg_match('~^' . $regEx . '$~', '/news/2014/05'), is(true));
 }
 public function testOperation()
 {
     $CartGetOperation = $this->app->make('Giftertipster\\Service\\Api\\AmzProductApi\\ApaiIO\\Operations\\CartGetOperation');
     $CartGetOperation->setCartId('cart id stub');
     $CartGetOperation->setHMAC('hmac stub');
     $params = $CartGetOperation->getOperationParameter();
     assertThat($CartGetOperation->getName(), equalTo('CartGet'));
     assertThat($params, arrayWithSize(2));
     assertThat($params, hasKeyValuePair('CartId', 'cart id stub'));
     assertThat($params, hasKeyValuePair('HMAC', 'hmac stub'));
 }
 public function testOperation()
 {
     $CartCreateOperation = $this->app->make('Giftertipster\\Service\\Api\\AmzProductApi\\ApaiIO\\Operations\\CartCreateOperation');
     $CartCreateOperation->addItem('foo bar', 1);
     $CartCreateOperation->addItem('foo bar2', 2);
     $params = $CartCreateOperation->getOperationParameter();
     assertThat($CartCreateOperation->getName(), equalTo('CartCreate'));
     assertThat($params, arrayWithSize(4));
     assertThat($params, hasKeyValuePair('Item.1.OfferListingId', 'foo bar'));
     assertThat($params, hasKeyValuePair('Item.1.Quantity', 1));
     assertThat($params, hasKeyValuePair('Item.2.OfferListingId', 'foo bar2'));
     assertThat($params, hasKeyValuePair('Item.2.Quantity', 2));
 }
Exemple #6
0
 public function testMountControllerWithBaseRoute()
 {
     $patternBuilder = \Mockery::mock('Rootr\\PatternBuilder');
     $router = new Router($patternBuilder);
     $controllerRouter = \Mockery::mock('Rootr\\Router');
     $controllerRouter->shouldReceive('getStaticRoutes')->andReturn(['' => ['GET' => ['Rootr\\ProductController', 'indexAction']]]);
     $controllerRouter->shouldReceive('getVariableRoutes')->andReturn(['/(\\d+)' => ['GET' => [['Rootr\\ProductController', 'showAction'], ['id']]]]);
     $controller = \Mockery::mock(['getRouter' => $controllerRouter]);
     $router->mountController('/products', $controller);
     assertThat($router->getStaticRoutes(), arrayWithSize(1));
     assertThat($router->getStaticRoutes(), hasKeyInArray('/products'));
     assertThat($router->getVariableRoutes(), arrayWithSize(1));
     assertThat($router->getVariableRoutes(), hasKeyInArray('/products/(\\d+)'));
 }
 public function testOperation()
 {
     $CartModifyOperation = $this->app->make('Giftertipster\\Service\\Api\\AmzProductApi\\ApaiIO\\Operations\\CartModifyOperation');
     $CartModifyOperation->setCartId('cart id stub');
     $CartModifyOperation->setHMAC('hmac stub');
     $CartModifyOperation->modifyItem('foo bar', 1);
     $CartModifyOperation->modifyItem('foo bar2', 2);
     $params = $CartModifyOperation->getOperationParameter();
     assertThat($CartModifyOperation->getName(), equalTo('CartModify'));
     assertThat($params, arrayWithSize(6));
     assertThat($params, hasKeyValuePair('CartId', 'cart id stub'));
     assertThat($params, hasKeyValuePair('HMAC', 'hmac stub'));
     assertThat($params, hasKeyValuePair('Item.1.CartItemId', 'foo bar'));
     assertThat($params, hasKeyValuePair('Item.1.Quantity', 1));
     assertThat($params, hasKeyValuePair('Item.2.CartItemId', 'foo bar2'));
     assertThat($params, hasKeyValuePair('Item.2.Quantity', 2));
 }
 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 testValidateCartReturnsFalseAndLogsErrorsOnFailWhenThereAreErrorsInTheResponseThatAreIgnorable()
 {
     \Config::shouldReceive('get')->with('api.amz_product_api_response_validation.ignorable_error_codes')->once()->andReturn(['ignorable test code']);
     $validator = $this->app->make('Giftertipster\\Service\\Api\\AmzProductApi\\ResponseValidation');
     $api_response_stub = new \SimpleXMLElement('<xml></xml>');
     $items = $api_response_stub->addChild('Cart');
     $items->addChild('Request')->addChild('IsValid', 'true');
     $errors = $items->Request->addChild('Errors');
     $error1 = $errors->addChild('Error');
     $error2 = $errors->addChild('Error');
     $error1->addChild('Code', 'ignorable test code');
     $error1->addChild('Message', 'message one');
     $error2->addChild('Code', 'valid code');
     $error2->addChild('Message', 'message two');
     $response = $validator->validate($api_response_stub);
     $errors = $validator->errors();
     assertThat($response, identicalTo(false));
     assertThat($errors, arrayWithSize(1));
     assertThat($errors[0], equalTo('message two'));
 }
 public function testGetIdRangeReturnsExpectedResultsWithOnlyStartId()
 {
     $this->makeRelatedModels();
     $add_attributes = ['add_type_id' => 1, 'product_id' => 1];
     $response = $this->eloquent_add->newInstance()->fill($add_attributes)->save();
     $add_attributes = ['add_type_id' => 2, 'product_id' => 1];
     $response = $this->eloquent_add->newInstance()->fill($add_attributes)->save();
     $add_attributes = ['add_type_id' => 3, 'product_id' => 1];
     $response = $this->eloquent_add->newInstance()->fill($add_attributes)->save();
     $add_attributes = ['add_type_id' => 4, 'product_id' => 1];
     $response = $this->eloquent_add->newInstance()->fill($add_attributes)->save();
     $result = $this->add_repo->getIdRange(0);
     assertThat($result, arrayWithSize(4));
     assertThat($result[0]['id'], equalTo(1));
     assertThat($result[0]['add_type_id'], equalTo(1));
     assertThat($result[3]['id'], equalTo(4));
     assertThat($result[3]['add_type_id'], equalTo(4));
 }
 private function runnerReuserScanWithARepoClearingEnhanced($runner)
 {
     $this->setUpTables();
     $this->setUpRepo();
     $originallyClearedItemId = 23;
     /* upload 3 in the test db is the same as upload 2 -> items 13-24 in upload 2 correspond to 33-44 */
     $reusingUploadItemShift = 20;
     $this->dbManager->queryOnce("UPDATE uploadtree_a SET pfile_fk=351 WHERE uploadtree_pk={$originallyClearedItemId}+{$reusingUploadItemShift}", __METHOD__ . '.minorChange');
     $this->uploadDao->addReusedUpload($uploadId = 3, $reusedUpload = 2, $this->groupId, $this->groupId, $reuseMode = 1);
     $repoPath = $this->testDb->getFossSysConf() . '/repo/files/';
     $this->treeDao->shouldReceive('getRepoPathOfPfile')->with(4)->andReturn($repoPath . '04621571bcbabce75c4dd1c6445b87dec0995734.59cacdfce5051cd8a1d8a1f2dcce40a5.12320');
     $this->treeDao->shouldReceive('getRepoPathOfPfile')->with(351)->andReturn($repoPath . 'c518ce1658140b65fa0132ad1130cb91512416bf.8e913e594d24ff3aeabe350107d97815.35829');
     list($clearingLicense1, $clearingLicense2, $addedEventIds) = $this->insertDecisionFromTwoEvents(DecisionScopes::REPO, $originallyClearedItemId);
     $clearingLicenses = array($clearingLicense1, $clearingLicense2);
     list($success, $output, $retCode) = $runner->run($uploadId, $this->userId, $this->groupId);
     $this->assertTrue($success, 'cannot run runner');
     $this->assertEquals($retCode, 0, 'reuser failed: ' . $output);
     $newUploadClearings = $this->getFilteredClearings($uploadId, $this->groupId);
     $potentiallyReusableClearings = $this->getFilteredClearings($reusedUpload, $this->groupId);
     assertThat($newUploadClearings, is(arrayWithSize(1)));
     assertThat($potentiallyReusableClearings, is(arrayWithSize(1)));
     /** @var ClearingDecision */
     $potentiallyReusableClearing = $potentiallyReusableClearings[0];
     /** @var ClearingDecision */
     $newClearing = $newUploadClearings[0];
     /* they are actually the same ClearingDecision
      * only sameFolder and sameUpload are different */
     assertThat($newClearing, not(equalTo($potentiallyReusableClearing)));
     assertThat($newClearing->getClearingLicenses(), arrayContainingInAnyOrder($clearingLicenses));
     assertThat($newClearing->getType(), equalTo($potentiallyReusableClearing->getType()));
     assertThat($newClearing->getScope(), equalTo($potentiallyReusableClearing->getScope()));
     assertThat($newClearing->getUploadTreeId(), equalTo($potentiallyReusableClearing->getUploadTreeId() + $reusingUploadItemShift));
     /* reuser should have not created a correct local event history */
     $bounds = $this->uploadDao->getItemTreeBounds($originallyClearedItemId + $reusingUploadItemShift);
     $newEvents = $this->clearingDao->getRelevantClearingEvents($bounds, $this->groupId);
     assertThat($newEvents, is(arrayWithSize(count($clearingLicenses))));
     /** @var ClearingEvent $newEvent */
     foreach ($newEvents as $newEvent) {
         assertThat($newEvent->getEventId(), anyOf($addedEventIds));
         assertThat($newEvent->getClearingLicense(), anyOf($clearingLicenses));
     }
     $this->rmRepo();
 }
Exemple #12
0
 /** @dataProvider provideLevels */
 public function testMergeValuesWithSameKey($key)
 {
     $this->events->set($key, 'value');
     $this->events->set($key, 'override');
     assertThat($this->events->get($key), arrayWithSize(2));
 }
Exemple #13
0
 private function runnerDeciderScanWithNoEventsAndNomosContainedInMonkWithButWithOtherAgentMatchForSameLicenseShouldMakeADecision($runner)
 {
     $this->setUpTables();
     $this->setUpRepo();
     $licenseRef1 = $this->licenseDao->getLicenseByShortName("GPL-3.0")->getRef();
     $licenseRef2 = $this->licenseDao->getLicenseByShortName("GPL-1.0")->getRef();
     $licenseRef3 = $this->licenseDao->getLicenseByShortName("APL-1.0")->getRef();
     $licId1 = $licenseRef1->getId();
     $licId2 = $licenseRef2->getId();
     $licId3 = $licenseRef3->getId();
     $agentNomosId = 6;
     $agentMonkId = 5;
     $agentOther = 8;
     $pfile = 4;
     $this->dbManager->queryOnce("INSERT INTO license_map(rf_fk, rf_parent, usage) VALUES ({$licId2}, {$licId1}, " . LicenseMap::CONCLUSION . ")");
     $this->dbManager->queryOnce("INSERT INTO license_map(rf_fk, rf_parent, usage) VALUES ({$licId3}, {$licId1}, " . LicenseMap::CONCLUSION . ")");
     $this->dbManager->queryOnce("DELETE FROM license_file");
     $this->dbManager->queryOnce("INSERT INTO license_file (fl_pk,rf_fk,pfile_fk,agent_fk) VALUES(12222,{$licId1},{$pfile},{$agentNomosId})");
     $this->dbManager->queryOnce("INSERT INTO highlight (fl_fk,start,len) VALUES(12222,10,3)");
     $this->dbManager->queryOnce("INSERT INTO highlight (fl_fk,start,len) VALUES(12222,18,3)");
     $this->dbManager->queryOnce("INSERT INTO license_file (fl_pk,rf_fk,pfile_fk,agent_fk) VALUES(12223,{$licId2},{$pfile},{$agentMonkId})");
     $this->dbManager->queryOnce("INSERT INTO highlight (fl_fk,start,len) VALUES(12223,6,2)");
     $this->dbManager->queryOnce("INSERT INTO highlight (fl_fk,start,len) VALUES(12223,13,19)");
     $this->dbManager->queryOnce("INSERT INTO license_file (fl_pk,rf_fk,pfile_fk,agent_fk) VALUES(12224,{$licId3},{$pfile},{$agentOther})");
     $this->dbManager->queryOnce("INSERT INTO highlight (fl_fk,start,len) VALUES(12224,9,2)");
     $this->dbManager->queryOnce("INSERT INTO highlight (fl_fk,start,len) VALUES(12224,13,19)");
     list($success, $output, $retCode) = $runner->run($uploadId = 2, $userId = 6, $groupId = 4, $jobId = 31, $args = "");
     $this->assertTrue($success, 'cannot run runner');
     $this->assertEquals($retCode, 0, 'decider failed (did you make test?): ' . $output);
     assertThat($this->getHeartCount($output), equalTo(1));
     $uploadBounds = $this->uploadDao->getParentItemBounds($uploadId);
     $decisions = $this->clearingDao->getFileClearingsFolder($uploadBounds, $groupId);
     assertThat($decisions, is(arrayWithSize(1)));
     $this->rmRepo();
 }
 public function testGetRemovableContents()
 {
     $this->folderDao->ensureTopLevelFolder();
     $folderA = $this->folderDao->insertFolder($folderName = 'A', '/A', FolderDao::TOP_LEVEL);
     $this->folderDao->insertFolder('B', '/A/B', $folderA);
     $folderC = $this->folderDao->insertFolder('C', '/C', FolderDao::TOP_LEVEL);
     assertThat($this->folderDao->getRemovableContents($folderA), arrayWithSize(0));
     $this->dbManager->insertTableRow('foldercontents', array('foldercontents_mode' => FolderDao::MODE_UPLOAD, 'parent_fk' => $folderA, 'child_id' => $folderC));
     assertThat($this->folderDao->getRemovableContents($folderA), arrayWithSize(0));
     $this->dbManager->insertTableRow('foldercontents', array('foldercontents_mode' => FolderDao::MODE_FOLDER, 'parent_fk' => $folderA, 'child_id' => $folderC));
     assertThat($this->folderDao->getRemovableContents($folderA), arrayWithSize(1));
 }
 public function testGetMappedLicenseRefView()
 {
     $this->testDb = new TestPgDb();
     $this->testDb->createPlainTables(array('license_ref', 'license_map'));
     $this->dbManager = $this->testDb->getDbManager();
     $this->dbManager->queryOnce("CREATE TABLE license_candidate (group_fk integer) INHERITS (license_ref)");
     $this->dbManager->insertTableRow('license_map', array('license_map_pk' => 0, 'rf_fk' => 2, 'rf_parent' => 1, 'usage' => LicenseMap::CONCLUSION));
     $this->dbManager->insertTableRow('license_ref', array('rf_pk' => 1, 'rf_shortname' => 'One', 'rf_fullname' => 'One-1'));
     $this->dbManager->insertTableRow('license_ref', array('rf_pk' => 2, 'rf_shortname' => 'Two', 'rf_fullname' => 'Two-2'));
     $this->dbManager->insertTableRow('license_candidate', array('rf_pk' => 3, 'rf_shortname' => 'Three', 'rf_fullname' => 'Three-3', 'group_fk' => $this->groupId));
     $this->assertCountBefore = \Hamcrest\MatcherAssert::getCount();
     $view = LicenseMap::getMappedLicenseRefView(LicenseMap::CONCLUSION);
     $stmt = __METHOD__;
     $this->dbManager->prepare($stmt, $view);
     $res = $this->dbManager->execute($stmt);
     $map = $this->dbManager->fetchAll($res);
     $this->dbManager->freeResult($res);
     assertThat($map, is(arrayWithSize(2)));
     $expected = array(array('rf_origin' => 1, 'rf_pk' => 1, 'rf_shortname' => 'One', 'rf_fullname' => 'One-1'), array('rf_origin' => 2, 'rf_pk' => 1, 'rf_shortname' => 'One', 'rf_fullname' => 'One-1'));
     assertThat($map, containsInAnyOrder($expected));
 }
 public function testGetCurrentClearingsWithUserRemovedDecisionsOnly()
 {
     /** @var LicenseRef $licenseRef */
     list($scannerResults, $licenseRef, $agentRef) = $this->createScannerDetectedLicenses();
     $removedEvent = $this->createClearingEvent(123, $this->timestamp, $licenseRef->getId(), $licenseRef->getShortName(), $licenseRef->getFullName(), ClearingEventTypes::USER, true);
     $this->agentLicenseEventProcessor->shouldReceive("getScannerEvents")->with($this->itemTreeBounds, LicenseMap::TRIVIAL)->andReturn($scannerResults);
     $this->clearingDao->shouldReceive("getRelevantClearingEvents")->with($this->itemTreeBounds, $this->groupId)->andReturn(array($licenseRef->getId() => $removedEvent));
     list($licenseDecisions, $removedClearings) = $this->clearingDecisionProcessor->getCurrentClearings($this->itemTreeBounds, $this->groupId);
     assertThat($licenseDecisions, is(emptyArray()));
     assertThat($removedClearings, is(arrayWithSize(1)));
     /** @var ClearingResult $result */
     $result = $removedClearings[$removedEvent->getLicenseId()];
     assertThat($result->getLicenseRef(), is($removedEvent->getLicenseRef()));
     assertThat($result->getClearingEvent(), is($removedEvent));
     $agentClearingEvents = $result->getAgentDecisionEvents();
     assertThat($agentClearingEvents, is(arrayWithSize(1)));
     $agentEvent = $agentClearingEvents[0];
     assertThat($agentEvent->getAgentRef(), is($agentRef));
     assertThat($agentEvent->getLicenseRef(), is($licenseRef));
     assertThat($agentEvent->getMatchId(), is(self::MATCH_ID));
     assertThat($agentEvent->getPercentage(), is(self::PERCENTAGE));
 }
 public function testCreate()
 {
     Factory::create('Giftertipster\\Entity\\Eloquent\\User', ['permissions' => []]);
     $product_attributes = ['user_id' => 1, 'vendor' => 'amazon', 'vendor_id' => 'b000000', 'binding' => 'testbinding', 'brand' => 'testbrand', 'manufacturer' => 'test manufacturer', 'model' => 'test model', 'group' => 'test group', 'type' => 'test type', 'size' => 'testsize', 'clothing_size' => 'test clothing size', 'color' => 'testcolor', 'title' => 'test title', 'department' => 'test department', 'min_price_amount' => '4000', 'min_price_currency' => 'usd', 'min_price_formatted' => '$40.00', 'max_price_amount' => '4000', 'max_price_currency' => 'usd', 'max_price_formatted' => '$40.00', 'reviews_url' => 'reviewsurl.com', 'detail_url' => 'detailurl.com'];
     $product = $this->app->make('Giftertipster\\Repository\\Product\\EloquentProductRepository');
     $response = $product->create($product_attributes);
     $products = $product->all(10);
     assertThat($response, equalTo(true));
     assertThat($products, arrayWithSize(1));
     assertThat($products[0], hasKeyValuePair('id', 1));
 }
 private function runnerDeciderScanWithForceDecision($runner)
 {
     $this->setUpTables();
     $this->setUpRepo();
     $jobId = 42;
     $licenseRef1 = $this->licenseDao->getLicenseByShortName("GPL-3.0")->getRef();
     $licenseRef2 = $this->licenseDao->getLicenseByShortName("3DFX")->getRef();
     $agentLicId = $this->licenseDao->getLicenseByShortName("Adaptec")->getRef()->getId();
     $addedLicenses = array($licenseRef1, $licenseRef2);
     assertThat($addedLicenses, not(arrayContaining(null)));
     $agentId = 5;
     $pfile = 4;
     $this->dbManager->queryOnce("INSERT INTO license_file (fl_pk,rf_fk,pfile_fk,agent_fk) VALUES(12222,{$agentLicId},{$pfile},{$agentId})");
     $itemTreeBounds = $this->uploadDao->getItemTreeBounds($itemId = 23);
     assertThat($this->agentLicenseEventProcessor->getScannerEvents($itemTreeBounds), is(not(emptyArray())));
     $eventId1 = $this->clearingDao->insertClearingEvent($itemId, $userId = 2, $groupId = 3, $licenseRef1->getId(), false);
     $eventId2 = $this->clearingDao->insertClearingEvent($itemId, 5, $groupId, $licenseRef2->getId(), true);
     $this->dbManager->queryOnce("UPDATE clearing_event SET job_fk={$jobId}");
     $addedEventIds = array($eventId1, $eventId2);
     list($success, $output, $retCode) = $runner->run($uploadId = 2, $userId, $groupId, $jobId, $args = "-k1");
     $this->assertTrue($success, 'cannot run runner');
     $this->assertEquals($retCode, 0, 'decider failed: ' . $output);
     assertThat($this->getHeartCount($output), equalTo(1));
     $uploadBounds = $this->uploadDao->getParentItemBounds($uploadId);
     $decisions = $this->clearingDao->getFileClearingsFolder($uploadBounds, $groupId);
     assertThat($decisions, is(arrayWithSize(1)));
     /** @var ClearingDecision $deciderMadeDecision */
     $deciderMadeDecision = $decisions[0];
     $eventIds = array();
     foreach ($deciderMadeDecision->getClearingEvents() as $event) {
         $eventIds[] = $event->getEventId();
     }
     assertThat($eventIds, arrayValue($addedEventIds[0]));
     assertThat($eventIds, arrayValue($addedEventIds[1]));
     assertThat($eventIds, arrayWithSize(1 + count($addedEventIds)));
     $this->rmRepo();
 }
 public function testFilteredProductsWithAllFiltersWorks()
 {
     $seed_product = Factory::create('Giftertipster\\Entity\\Eloquent\\Product', ['group' => 'foo', 'min_price_amount' => 50, 'max_price_amount' => 50]);
     $seed_product2 = Factory::create('Giftertipster\\Entity\\Eloquent\\Product', ['group' => 'bar', 'min_price_amount' => 150, 'max_price_amount' => 150]);
     $seed_product3 = Factory::create('Giftertipster\\Entity\\Eloquent\\Product', ['group' => 'foobar']);
     $seed_image1 = Factory::create('Giftertipster\\Entity\\Eloquent\\Image', ['imageable_id' => 1, 'imageable_type' => 'Giftertipster\\Entity\\Eloquent\\Product']);
     $seed_image2 = Factory::create('Giftertipster\\Entity\\Eloquent\\Image', ['imageable_id' => 2, 'imageable_type' => 'Giftertipster\\Entity\\Eloquent\\Product']);
     $categories_filter = new CategoriesFilter();
     $categories_filter->categories(['foo', 'bar']);
     $price_range_filter = new PriceRangeFilter();
     $price_range_filter->minPrice(5)->maxPrice(100);
     $product = $this->app->make('Giftertipster\\Repository\\ProductSuite\\EloquentProductSuiteRepository');
     $products = $product->filteredProducts([$categories_filter, $price_range_filter]);
     assertThat($products, arrayWithSize(1));
     assertThat($products[0], hasKeyValuePair('id', 1));
     assertThat($products[0]['images'], not(emptyArray()));
 }
Exemple #20
0
 public function testMainLicenseIds()
 {
     $this->testDb->createPlainTables(array('upload_clearing_license'));
     $uploadId = 101;
     $mainLicIdsInitially = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdsInitially, is(emptyArray()));
     $this->clearingDao->makeMainLicense($uploadId, $this->groupId, $licenseId = 402);
     $mainLicIdsAfterAddingOne = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdsAfterAddingOne, arrayContaining(array($licenseId)));
     $this->clearingDao->makeMainLicense($uploadId, $this->groupId, $licenseId);
     $mainLicIdsAfterAddingOneTwice = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdsAfterAddingOneTwice, is(arrayWithSize(1)));
     $this->clearingDao->makeMainLicense($uploadId, $this->groupId, $licenseId2 = 403);
     $mainLicIdsAfterAddingOther = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdsAfterAddingOther, arrayContainingInAnyOrder(array($licenseId, $licenseId2)));
     $this->clearingDao->removeMainLicense($uploadId, $this->groupId, $licenseId2);
     $mainLicIdsAfterRemovingOne = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdsAfterRemovingOne, is(arrayWithSize(1)));
     $this->clearingDao->removeMainLicense($uploadId, $this->groupId, $licenseId2);
     $mainLicIdAfterRemovingSomethingNotInSet = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdAfterRemovingSomethingNotInSet, is(arrayWithSize(1)));
     $this->clearingDao->removeMainLicense($uploadId, $this->groupId + 1, $licenseId);
     $mainLicIdAfterInsertToOtherGroup = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdAfterInsertToOtherGroup, is(arrayWithSize(1)));
     $this->clearingDao->removeMainLicense($uploadId + 1, $this->groupId, $licenseId);
     $mainLicIdAfterInsertToOtherUpload = $this->clearingDao->getMainLicenseIds($uploadId, $this->groupId);
     assertThat($mainLicIdAfterInsertToOtherUpload, is(arrayWithSize(1)));
 }
 public function testFinderCreateLogsNoticeWhenSomeSubProductVariationsAttributesAreInvalid()
 {
     Factory::create('Giftertipster\\Entity\\Eloquent\\Idea', ['user_id' => 1, 'is_fulfilled' => 0]);
     $suite_attributes = ['vendor' => 'amazon', 'vendor_id' => 'b000000', 'binding' => 'testbinding', 'brand' => 'testbrand', 'manufacturer' => 'test manufacturer', 'model' => 'test model', 'group' => 'test group', 'type' => 'test type', 'size' => 'testsize', 'clothing_size' => 'test clothing size', 'color' => 'testcolor', 'title' => 'test title', 'department' => 'test department', 'min_price_amount' => 4000, 'min_price_currency' => 'USD', 'min_price_formatted' => '$40.00', 'max_price_amount' => 4000, 'max_price_currency' => 'USD', 'max_price_formatted' => '$40.00', 'reviews_url' => 'reviewsurl.com', 'detail_url' => 'detailurl.com'];
     $suite_attributes['images'] = [];
     $suite_attributes['features'] = [];
     $suite_attributes['descriptions'] = [];
     $suite_attributes['sub_products'][] = ['vendor' => 'amazon', 'vendor_id' => 'b000001', 'parent_vendor_id' => 'b000000', 'binding' => 'testbinding', 'brand' => 'testbrand', 'manufacturer' => 'test manufacturer', 'model' => 'test model', 'group' => 'test group', 'type' => 'test type', 'size' => 'testsize', 'clothing_size' => 'test clothing size', 'color' => 'testcolor', 'title' => 'test title', 'condition' => 'test condition', 'department' => 'test department', 'list_price_amount' => 4000, 'list_price_currency' => 'USD', 'list_price_formatted' => '$40.00', 'price_amount' => 4000, 'price_currency' => 'USD', 'price_formatted' => '$40.00', 'availability' => 'test avail', 'availability_type' => 'test avail type', 'availability_max_hours' => 'test avail max hours', 'availability_min_hours' => 'test avail min hours', 'availability_ship' => 'test avail ship', 'availability_ss_ship' => 1, 'offer_listing_id' => 'foo1', 'images' => [], 'descriptions' => [], 'features' => []];
     $suite_attributes['sub_products'][0]['variations'][] = ['type' => 'variationtype', 'value' => 'variation1'];
     $suite_attributes['sub_products'][0]['variations'][] = ['type' => '', 'value' => 'variation2'];
     $suite_attributes['keyword_profile']['profile'] = [];
     $suite_attributes['category_keywords'] = [];
     $expected_index_attributes = ['vendor' => 'amazon', 'vendor_id' => 'b000000', 'binding' => 'testbinding', 'brand' => 'testbrand', 'manufacturer' => 'test manufacturer', 'model' => 'test model', 'group' => 'test group', 'type' => 'test type', 'size' => 'testsize', 'clothing_size' => 'test clothing size', 'color' => 'testcolor', 'title' => 'test title', 'department' => 'test department', 'min_price_amount' => 4000, 'min_price_currency' => 'USD', 'min_price_formatted' => '$40.00', 'max_price_amount' => 4000, 'max_price_currency' => 'USD', 'max_price_formatted' => '$40.00', 'reviews_url' => 'reviewsurl.com', 'detail_url' => 'detailurl.com'];
     $expected_index_attributes['images'] = [];
     $expected_index_attributes['features'] = [];
     $expected_index_attributes['descriptions'] = [];
     $expected_index_attributes['sub_products'][] = ['vendor' => 'amazon', 'vendor_id' => 'b000001', 'parent_vendor_id' => 'b000000', 'binding' => 'testbinding', 'brand' => 'testbrand', 'manufacturer' => 'test manufacturer', 'model' => 'test model', 'group' => 'test group', 'type' => 'test type', 'size' => 'testsize', 'clothing_size' => 'test clothing size', 'color' => 'testcolor', 'title' => 'test title', 'condition' => 'test condition', 'department' => 'test department', 'list_price_amount' => 4000, 'list_price_currency' => 'USD', 'list_price_formatted' => '$40.00', 'price_amount' => 4000, 'price_currency' => 'USD', 'price_formatted' => '$40.00', 'availability' => 'test avail', 'availability_type' => 'test avail type', 'availability_max_hours' => 'test avail max hours', 'availability_min_hours' => 'test avail min hours', 'availability_ship' => 'test avail ship', 'availability_ss_ship' => 1, 'offer_listing_id' => 'foo1', 'images' => [], 'descriptions' => [], 'features' => []];
     $expected_index_attributes['sub_products'][0]['variations'][] = ['type' => 'variationtype', 'value' => 'variation1'];
     $expected_index_attributes['keyword_profile']['profile'] = [];
     $expected_index_attributes['category_keywords'] = [];
     \Log::shouldReceive('notice')->once();
     //mock ProductSuiteIndexer
     $expected_product_suite = $expected_index_attributes;
     $indexer = Mockery::mock('Giftertipster\\Service\\ProductSuite\\ProductSuiteIndexerInterface');
     $indexer->shouldReceive('queueIndex')->with(Mockery::on(function ($product_suite) use($expected_product_suite) {
         if (!empty($this->arrayRecursiveDiff($expected_product_suite, $product_suite))) {
             return false;
         }
         return true;
     }), false, false)->once()->andReturn(true);
     $this->app->instance('Giftertipster\\Service\\ProductSuite\\ProductSuiteIndexerInterface', $indexer);
     $repo = $this->app->make('Giftertipster\\Repository\\ProductSuite\\EloquentProductSuiteRepository');
     $response = $repo->finderCreate($suite_attributes, 'Idea', 1, 2);
     $errors = $repo->errors();
     assertThat($response, equalTo(true));
     $eloquent_product = $this->app->make('Giftertipster\\Entity\\Eloquent\\Product');
     $product = $eloquent_product->find(1);
     $eloquent_variation = $this->app->make('Giftertipster\\Entity\\Eloquent\\Variation');
     $sub_product_variation = $eloquent_variation->where('sub_product_id', '=', 1)->get()->toArray();
     assertThat($errors, nullValue());
     assertThat($product, notNullValue());
     assertThat($sub_product_variation, arrayWithSize(1));
 }
 public function testGetAdminsWithProfile()
 {
     \Artisan::call('db:seed');
     //user 1 comes from db:seed
     $user1 = \Giftertipster\Entity\Eloquent\User::find(1);
     $user2 = Factory::create('Giftertipster\\Entity\\Eloquent\\User', ['permissions' => ['test']]);
     $user3 = Factory::create('Giftertipster\\Entity\\Eloquent\\User', ['permissions' => ['test']]);
     //seed user profile for user 1
     $user1_profile = $user1->user_profile()->get()->first();
     $user1_profile->first_name = 'foobar';
     $user1_profile->save();
     $result = $this->repo()->getAdminsWithProfile();
     assertThat($result, arrayWithSize(3));
     assertThat($result[0], hasKeyValuePair('id', 1));
     assertThat($result[0]['user_profile'][0]['first_name'], equalTo('foobar'));
     assertThat($result[1], hasKeyValuePair('id', 2));
     assertThat($result[1]['user_profile'], identicalTo([]));
     assertThat($result[2], hasKeyValuePair('id', 3));
     assertThat($result[2]['user_profile'], identicalTo([]));
 }
 public function testDeletePermDeletesProductAndIdeaRelationAndReturnsTrue()
 {
     $index_repo = Mockery::mock('Giftertipster\\Repository\\ProductsIndex\\Product\\ProductsIndexProductRepositoryInterface');
     $index_repo->shouldReceive('deleteProductAndAdds')->with(1, true)->once()->andReturn(true);
     $this->app->instance('Giftertipster\\Repository\\ProductsIndex\\Product\\ProductsIndexProductRepositoryInterface', $index_repo);
     $data_repo = $this->dataRepoSetup();
     $this->getDataRepoData();
     //make second product
     $product = $this->app->make('Giftertipster\\Entity\\Eloquent\\Product');
     $product->fill(['user_id' => 1, 'vendor' => 'amazon', 'vendor_id' => 'b000000', 'binding' => 'testbinding', 'brand' => 'testbrand', 'manufacturer' => 'test manufacturer', 'model' => 'test model', 'group' => 'test group', 'type' => 'test type', 'size' => 'testsize', 'clothing_size' => 'test clothing size', 'color' => 'testcolor', 'title' => 'test title', 'department' => 'test department', 'min_price_amount' => 4000, 'min_price_currency' => 'USD', 'min_price_formatted' => '$40.00', 'max_price_amount' => 4000, 'max_price_currency' => 'USD', 'max_price_formatted' => '$40.00', 'reviews_url' => 'reviewsurl.com', 'detail_url' => 'detailurl.com'])->save();
     //connect products to idea
     Factory::create('Giftertipster\\Entity\\Eloquent\\User', ['permissions' => []]);
     $idea = $this->app->make('Giftertipster\\Entity\\Eloquent\\Idea');
     $idea->fill(['user_id' => 1, 'vendor' => 'test', 'vendor_id' => 100, 'description' => 'test', 'add_profile' => '', 'is_fulfilled' => 0]);
     $this->product->ideas()->save($idea);
     //product id 1
     $product->ideas()->save($idea);
     //product id 2
     $idea_check = $idea->where('product_id', '=', 1)->get();
     assertThat($idea_check, not(nullValue()));
     $idea_check = $idea->where('product_id', '=', 2)->get();
     assertThat($idea_check, not(nullValue()));
     $response = $data_repo->delete(1);
     assertThat($response, identicalTo(true));
     $product = $this->app->make('Giftertipster\\Entity\\Eloquent\\Product');
     $product_check = $product->find(1);
     $idea_check = $idea->has('products')->get()->toArray();
     assertThat($product_check, nullValue());
     assertThat($idea_check, arrayWithSize(1));
     assertThat($idea->exists(), equalTo(true));
 }
 public function testGetJobInfo()
 {
     $this->dbManager->prepare($stmt = 'insert.jobqueue', "INSERT INTO jobqueue (jq_pk, jq_job_fk, jq_type, jq_args, jq_starttime, jq_endtime, jq_endtext, jq_end_bits, jq_schedinfo, jq_itemsprocessed)" . "VALUES (\$1, \$2, \$3, \$4,\$5, \$6,\$7,\$8,\$9,\$10)");
     $nowTime = time();
     $diffTime = 2345;
     $nomosTime = date('Y-m-d H:i:sO', $nowTime - $diffTime);
     $uploadArrayQue = array(array(8, $jobId = 1, "nomos", 1, $nomosTime, null, "Started", 0, "localhost.5963", $itemNomos = 147), array(1, $jobId, "ununpack", 1, "2015-04-21 18:29:19.23825+05:30", "2015-04-21 18:29:26.396562+05:30", "Completed", 1, null, $itemCount = 646));
     foreach ($uploadArrayQue as $uploadEntry) {
         $this->dbManager->freeResult($this->dbManager->execute($stmt, $uploadEntry));
     }
     $this->dbManager->prepare($stmt = 'insert.uploadtree_a', "INSERT INTO uploadtree_a (uploadtree_pk, parent, upload_fk, pfile_fk, ufile_mode, lft, rgt, ufile_name)" . "VALUES (\$1, \$2, \$3, \$4,\$5, \$6, \$7, \$8)");
     $uploadTreeArray = array(array(123, 121, 1, 103, 32768, 542, 543, "fckeditorcode_ie.js"), array(121, 120, 1, 0, 536888320, 537, 544, "js"), array(715, 651, 2, 607, 33188, 534, 535, "zconf.h.cmakein"), array(915, 651, 2, 606, 33188, 532, 533, "zconf.h"));
     foreach ($uploadTreeArray as $uploadEntry) {
         $this->dbManager->freeResult($this->dbManager->execute($stmt, $uploadEntry));
     }
     $this->dbManager->prepare($stmt = 'insert.jobdepends', "INSERT INTO jobdepends (jdep_jq_fk, jdep_jq_depends_fk) VALUES (\$1, \$2 )");
     $jqWithTwoDependencies = 8;
     $jobDependsArray = array(array(2, 1), array(3, 2), array(4, 2), array(5, 2), array(6, 2), array($jqWithTwoDependencies, 4), array($jqWithTwoDependencies, 4));
     foreach ($jobDependsArray as $uploadEntry) {
         $this->dbManager->freeResult($this->dbManager->execute($stmt, $uploadEntry));
     }
     $testMyJobInfo = $this->showJobsDao->getJobInfo($this->job_pks);
     assertThat($testMyJobInfo, hasKey($jobId));
     assertThat($testMyJobInfo[$jobId]['jobqueue'][$jqWithTwoDependencies]['depends'], is(arrayWithSize(2)));
     $testFilesPerSec = 0.23;
     $formattedEstimatedTime = $this->showJobsDao->getEstimatedTime($job_pk = 1, $jq_Type = "nomos", $testFilesPerSec);
     assertThat($formattedEstimatedTime, matchesPattern('/\\d+:\\d{2}:\\d{2}/'));
     $hourMinSec = explode(':', $formattedEstimatedTime);
     assertThat($hourMinSec[0] * 3600 + $hourMinSec[1] * 60 + $hourMinSec[2], is(closeTo(($itemCount - $itemNomos) / $testFilesPerSec, 0.5 + $testFilesPerSec)));
     $testGetEstimatedTime = $this->showJobsDao->getEstimatedTime($job_pk = 1, $jq_Type, 0);
     assertThat($testGetEstimatedTime, matchesPattern('/\\d+:\\d{2}:\\d{2}/'));
     $hourMinSec = explode(':', $testGetEstimatedTime);
     $tolerance = 0.5 + ($itemCount - $itemNomos) / $itemNomos + (time() - $nowTime);
     assertThat($hourMinSec[0] * 3600 + $hourMinSec[1] * 60 + $hourMinSec[2], is(closeTo(($itemCount - $itemNomos) / $itemNomos * $diffTime, $tolerance)));
     $fewFilesPerSec = 0.003;
     $formattedLongTime = $this->showJobsDao->getEstimatedTime($job_pk = 1, $jq_Type = "nomos", $fewFilesPerSec);
     assertThat($formattedLongTime, matchesPattern('/\\d+:\\d{2}:\\d{2}/'));
     $hourMinSec = explode(':', $formattedLongTime);
     assertThat($hourMinSec[0] * 3600 + $hourMinSec[1] * 60 + $hourMinSec[2], is(closeTo(($itemCount - $itemNomos) / $fewFilesPerSec, 0.5 + $fewFilesPerSec)));
 }
 public function testFilterEffectiveEventsOppositeIdenticalEventsOverwriteInOtherOrder()
 {
     $events = array();
     $licenseRef1 = M::mock(ClearingLicense::classname());
     $licenseRef1->shouldReceive("getLicenseId")->withNoArgs()->andReturn("fortyTwo");
     $events[] = $this->createEvent($this->timestamp, $licenseRef1);
     $licenseRef2 = M::mock(ClearingLicense::classname());
     $licenseRef2->shouldReceive("getLicenseId")->withNoArgs()->andReturn("fortyTwo");
     $events[] = $this->createEvent($this->timestamp + 60, $licenseRef2);
     $filteredEvents = $this->clearingEventProcessor->filterEffectiveEvents($events);
     assertThat($filteredEvents, is(arrayWithSize(1)));
     assertThat($filteredEvents, hasKeyValuePair('fortyTwo', $events[1]));
 }
/*
Copyright (C) 2015, Siemens AG

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/
namespace Fossology\Decider;

use Mockery as M;
$deciderPlugin = M::mock();
//'Fossology\\DeciderJob\\UI\\DeciderJobAgentPlugin');
$deciderPlugin->shouldReceive('AgentAdd')->withArgs(array(16, 2, anything(), arrayWithSize(1)))->once();
$GLOBALS['xyyzzzDeciderJob'] = $deciderPlugin;
function plugin_find($x)
{
    return $GLOBALS['xyyzzzDeciderJob'];
}
function IsAlreadyScheduled($jobId, $agentName, $uploadId)
{
    return 177;
}
Exemple #27
0
 public function testReceiveWithPolling()
 {
     $url = $this->stubCreateQueue();
     $timeout = $this->stubQueueVisibilityTimeout($url);
     $receiveModel = m::mock('Aws\\ResultInterface');
     $receiveModel->shouldReceive('get')->once()->with('Messages')->andReturn([['Body' => 'foo', 'Attributes' => [], 'MessageAttributes' => [], 'MessageId' => 0, 'ReceiptHandle' => 'a']]);
     $this->sqsClient->shouldReceive('receiveMessage')->once()->with(['QueueUrl' => $url, 'AttributeNames' => ['All'], 'MaxNumberOfMessages' => SqsAdapter::BATCHSIZE_RECEIVE, 'VisibilityTimeout' => $timeout])->andReturn($receiveModel);
     $deleteModel = m::mock('Aws\\ResultInterface');
     $deleteModel->shouldReceive('get')->once()->with('Failed')->andReturn([]);
     $this->sqsClient->shouldReceive('deleteMessageBatch')->once()->with(['QueueUrl' => $url, 'Entries' => [['Id' => 0, 'ReceiptHandle' => 'a']]])->andReturn($deleteModel);
     $msgs = [];
     $this->client->receive(function ($msg, $done) use(&$msgs) {
         $msgs[] = $msg;
         $done();
     }, null);
     assertThat($msgs, is(arrayWithSize(1)));
 }
 public function testGetThese()
 {
     $this->createStubCategories();
     $this->repo = $this->app->make('Giftertipster\\Repository\\Categories\\EloquentCategoriesRepository');
     $collection = $this->repo->getThese([2, 3], 'occasion');
     assertThat($collection, arrayWithSize(2));
     assertThat($collection[0]['id'], equalTo(2));
     assertThat($collection[1]['id'], equalTo(3));
 }
 public function testHasAReadableDescription()
 {
     $this->assertDescription('an array with size <3>', arrayWithSize(equalTo(3)));
     $this->assertDescription('an empty array', emptyArray());
 }
 public function testValidateSuiteAttributesForCreateReturnsFalseWhenCategoryKeywordsKeyIsMissing()
 {
     $stub = $this->suite_attributes_stub;
     unset($stub['category_keywords']);
     $response = $this->validator->validateSuiteAttributesForCreate($stub);
     assertThat($response, identicalTo(false));
     assertThat($this->validator->errors(), arrayWithSize(greaterThan(0)));
 }