public function testFilterWhenThereAreDuplicatesAndNoPrimary()
 {
     $suite_images = [['category' => 'variant', 'field1' => 'foobar', 'field2' => 'foobar'], ['category' => 'variant', 'field1' => 'foobar1', 'field2' => 'foobar2'], ['category' => 'variant', 'field1' => 'foobar', 'field2' => 'foobar']];
     $expected_filtered_images = [['category' => 'variant', 'field1' => 'foobar', 'field2' => 'foobar'], ['category' => 'variant', 'field1' => 'foobar1', 'field2' => 'foobar2']];
     $filtered_images = $this->filter_service->filter($suite_images);
     assertThat($filtered_images, identicalTo($expected_filtered_images));
 }

 public function testPrepWhenNullAddFormIsSupplied()
 {
     $add_form_prepper = $this->app->make('Giftertipster\\Service\\Add\\AddFormPrepper');
     $prepped_add_form = $add_form_prepper->prep(null);
     $expected_prepped_add_form = [];
     assertThat($prepped_add_form, identicalTo($expected_prepped_add_form));
 }

 public function testShouldReturnTokenResponseWhenTokenIsNotLoaded()
 {
     $token = $this->givenAccessToken('');
     $token->response = 'irrelevant response (instanceof Response)';
     $response = $this->api->getStatus('irrelevant id');
     assertThat($response, identicalTo($token->response));
 }

 public function testMakeBucketLabelReturnsExpectedResponseWhenMaxIsNull()
 {
     $expected_response = '$10 +';
     $bucket = ['min' => 1000, 'max' => null];
     $response = $this->labeler->makeBucketLabel($bucket);
     assertThat($response, identicalTo($expected_response));
 }

 public function testIsProductSuiteBlacklistedReturnsFalseWhenItIsNot()
 {
     $create_response = $this->eloquent_bp->create(['vendor' => 'vendor.com', 'vendor_id' => 1]);
     $prod_suite_stub = ['vendor' => 'vendor.com', 'vendor_id' => 2];
     assertThat($create_response, equalTo(true));
     assertThat($this->eloquent_bp->isProductSuiteBlacklisted($prod_suite_stub), identicalTo(false));
 }

 public function testClearUserAddSelftProfile()
 {
     \Session::put('Giftertipster\\Service\\Add\\AddProfileMgr.user_add_self_profile', 'test');
     assertThat(\Session::has('Giftertipster\\Service\\Add\\AddProfileMgr.user_add_self_profile'), identicalTo(true));
     $this->add_profile_mgr->clearUserAddSelfProfile();
     assertThat(\Session::has('Giftertipster\\Service\\Add\\AddProfileMgr.user_add_self_profile'), identicalTo(false));
 }

 public function testValidateReturnsTrueOnSuccess()
 {
     $filter = $this->app->make('Giftertipster\\Entity\\ProductSearchFilter\\CategoriesFilter');
     $validator = $this->app->make('Giftertipster\\Service\\Validate\\ProductSearchFilter\\FilterValidatorInterface');
     $response = $validator->validate($filter);
     assertThat($response, identicalTo(true));
 }

 public function testHasPermission()
 {
     $auth_helper_mock = \Mockery::mock('Jacopo\\Authentication\\Helpers\\SentryAuthenticationHelper');
     $auth_helper_mock->shouldReceive('hasPermission')->once()->with(['permissions stub'])->andReturn('foobar');
     $this->app->instance('authentication_helper', $auth_helper_mock);
     assertThat($this->authMgr()->hasPermission(['permissions stub']), identicalTo('foobar'));
 }

 /**
  * @test
  */
 function matches_using_callback()
 {
     $matcher = new CallbackMatcher(function ($value) {
         return $value === "Hello, world.";
     });
     assertThat($matcher->matches("Hello, world."), is(identicalTo(true)));
 }

 public function testUpdateForProduct()
 {
     $product = Factory::create('Giftertipster\\Entity\\Eloquent\\Product');
     $keyword_profile = Factory::make('Giftertipster\\Entity\\Eloquent\\KeywordProfile');
     $product->keywordProfile()->save($keyword_profile);
     $this->repo->updateForProduct(1, ['profile' => ['updated', 'profile']]);
     assertThat(KeywordProfile::find(1)->profile, identicalTo(['updated', 'profile']));
 }

 public function testMakeParamsReturnsExpectedParamsWhenRefreshIsRequested()
 {
     \Config::shouldReceive('get')->with('index.index_products_type_product')->once()->andReturn($this->config);
     $doc_id = 100;
     $params_mock = ['index' => 'tests', 'type' => 'test', 'id' => $doc_id, 'refresh' => true];
     $result = $this->gen->makeParams('products', 'product', $doc_id, true);
     assertThat($result, identicalTo($params_mock));
 }

 public function testReceiveWithPolling()
 {
     $msgs = [];
     $this->client->receive(function ($msg) use(&$msgs) {
         $msgs[] = $msg;
     }, null);
     assertThat($msgs, is(identicalTo($this->messages)));
 }

 public function testMakeCompilesBucketsCorrectlyAndReturnsResult()
 {
     $expected_result = ['label' => '$0 – $510', 'count' => 84, 'min' => null, 'max' => 51000, 'filter' => ['filter' => 'NumberRangeFilter', 'params' => ['field' => 'min_price', 'min' => null, 'max' => 51000]]];
     $this->bucket_label_mock->shouldReceive('makeBucketLabel')->with(['min' => $expected_result['min'], 'max' => $expected_result['max'], 'count' => $expected_result['count'], 'filter' => $expected_result['filter'], 'label' => ''])->andReturn($expected_result['label']);
     $processor = $this->app->make('Giftertipster\\Service\\ESIndex\\FacetsGenerator\\SmartRange\\Processor\\LowBucket\\LowBucketProcessor');
     $result = $processor->make($this->bucket_label_mock, 'min_price', 1000, $this->low_buckets, 1000);
     assertThat($result, identicalTo($expected_result));
 }

 /**
  * @test
  */
 public function write_withContentsAndAFile_writesContentsToTheFileOnTheFileSystem()
 {
     $writtenContent = 'my new content that is awesome';
     $file = Mockery::mock('FileSystem\\File[]', array('file.txt', $this->rootObject));
     $file->content = $writtenContent;
     $this->fileSystem->write($file, VFS::url('root'));
     assertThat(file_get_contents(VFS::url('root/file.txt')), is(identicalTo($writtenContent)));
 }

 public function testCheckIfPaginationExistsEnvPagination()
 {
     $search = new SearchTraitDummyClass();
     $this->mock->shouldReceive('paginate')->once()->with(identicalTo(env('PAGINATION_NUMBER')))->andReturn(true);
     $query = $this->mock;
     $pagination = $search->checkIfPaginationExists($query);
     $this->assertTrue($pagination);
 }

 public function testSubProductMatchingVendorIdReturnsFalseWhenThereAreNoMatches()
 {
     $sub_product = Factory::create('Giftertipster\\Entity\\Eloquent\\SubProduct', ['vendor_id' => 'asin stub2']);
     $sub_product2 = Factory::create('Giftertipster\\Entity\\Eloquent\\SubProduct', ['vendor_id' => 'asin stub2']);
     $sub_product_repo = $this->app->make('Giftertipster\\Repository\\SubProduct\\EloquentSubProductRepository');
     $result_sub_product = $sub_product_repo->subProductMatchingVendorId('asin stub');
     assertThat($result_sub_product, identicalTo(false));
 }

 /**
  * @test
  */
 function construct_()
 {
     $extract = array('obj' => new \stdClass());
     $cfg = array('pdo' => $this->pdo, 'extract' => $extract);
     $config = new Config($cfg, __FILE__);
     $adapter = new PdoAdapter($this->pdo);
     assertThat($config->adapter, isInstanceOf(get_class($adapter)));
     assertThat($config->extract, identicalTo($extract));
 }

 public function testMakeParamsReturnsExpectedParams()
 {
     \Config::shouldReceive('get')->with('index.index_products_type_product')->once()->andReturn($this->config);
     \Config::shouldReceive('get')->with('index.index_products_type_add')->once()->andReturn($this->child_config);
     $doc_id = 100;
     $params_mock = ['index' => 'tests', 'type' => 'test,testchild', 'body' => ['query' => ['bool' => ['should' => [['term' => ['_parent' => 'test#' . $doc_id]], ['ids' => ['type' => 'test', 'values' => [$doc_id]]]]]]]];
     $result = $this->gen->makeParams('products', 'product', ['add'], $doc_id);
     assertThat($result, identicalTo($params_mock));
 }

 public function testMakeReturnsExpectedFilterWhenValueIsEmpty()
 {
     $filter_type = 'TermFilter';
     $filter_params = ['field' => 'testfield', 'value' => ''];
     $expected_response = ['term' => ['testfield' => '']];
     $filter = $this->app->make('Giftertipster\\Service\\ESIndex\\ParamsGenerator\\Search\\Filters\\' . $filter_type);
     $response = $filter->make($filter_params);
     assertThat($response, identicalTo($expected_response));
 }

 public function testMakeReturnsNoFacetDivisionsWhenIndexReturnsOnlyOneDivision()
 {
     $term_facet_generator = $this->app->make('Giftertipster\\Service\\ESIndex\\FacetsGenerator\\Term\\ESTermGenerator');
     $filter_field_name_stub = 'testfield';
     $buckets_stub = [['key' => 'value1', 'doc_count' => 3]];
     $expected_response = [];
     $response = $term_facet_generator->make($filter_field_name_stub, $buckets_stub);
     assertThat($response, identicalTo($expected_response));
 }