/**
* @group functional
*/
public function testSearchByDocument()
{
$client = $this->_getClient(array('persistent' => false));
$index = $client->getIndex('elastica_test');
$index->create(array('index' => array('number_of_shards' => 1, 'number_of_replicas' => 0)), true);
$type = new Type($index, 'mlt_test');
$type->addDocuments(array(new Document(1, array('visible' => true, 'name' => 'bruce wayne batman')), new Document(2, array('visible' => true, 'name' => 'bruce wayne')), new Document(3, array('visible' => false, 'name' => 'bruce wayne')), new Document(4, array('visible' => true, 'name' => 'batman')), new Document(5, array('visible' => false, 'name' => 'batman')), new Document(6, array('visible' => true, 'name' => 'superman')), new Document(7, array('visible' => true, 'name' => 'spiderman'))));
$index->refresh();
$doc = $type->getDocument(1);
// Return all similar from id
$mltQuery = new MoreLikeThis();
$mltQuery->setMinTermFrequency(1);
$mltQuery->setMinDocFrequency(1);
$mltQuery->setLike($doc);
$query = new Query($mltQuery);
$resultSet = $type->search($query);
$this->assertEquals(4, $resultSet->count());
$mltQuery = new MoreLikeThis();
$mltQuery->setMinTermFrequency(1);
$mltQuery->setMinDocFrequency(1);
$mltQuery->setLike($doc);
$query = new Query\BoolQuery();
$query->addMust($mltQuery);
$this->hideDeprecated();
// Return just the visible similar from id
$filter = new Query\BoolQuery();
$filterTerm = new Query\Term();
$filterTerm->setTerm('visible', true);
$filter->addMust($filterTerm);
$query->addFilter($filter);
$this->showDeprecated();
$resultSet = $type->search($query);
$this->assertEquals(2, $resultSet->count());
// Return all similar from source
$mltQuery = new MoreLikeThis();
$mltQuery->setMinTermFrequency(1);
$mltQuery->setMinDocFrequency(1);
$mltQuery->setMinimumShouldMatch(90);
$mltQuery->setLike($type->getDocument(1)->setId(''));
$query = new Query($mltQuery);
$resultSet = $type->search($query);
$this->assertEquals(1, $resultSet->count());
// Legacy test with filter
$mltQuery = new MoreLikeThis();
$mltQuery->setMinTermFrequency(1);
$mltQuery->setMinDocFrequency(1);
$mltQuery->setLike($doc);
$query = new Query\BoolQuery();
$query->addMust($mltQuery);
$this->hideDeprecated();
// Return just the visible similar
$filter = new BoolFilter();
$filterTerm = new Term();
$filterTerm->setTerm('visible', true);
$filter->addMust($filterTerm);
$query->addFilter($filter);
$this->showDeprecated();
$resultSet = $type->search($query);
$this->assertEquals(2, $resultSet->count());
}
/**
* @param RelationDefinition $query
* @param string $lang
* @param string $type
*
* @return void
*/
public function defineSearch($query, $lang, $type)
{
$category = $query->getCategory();
$tags = $query->getTags();
$exclude = $query->getExclude();
$rootNode = $this->domainConfiguration->getRootNode();
$bool = (new Query\BoolQuery())->setMinimumNumberShouldMatch(1);
$bool->addMust((new Term())->setTerm('lang', $this->language));
$bool->addMust((new Term())->setTerm('type', $type));
$bool->addMust((new Term())->setTerm('view_roles', 'IS_AUTHENTICATED_ANONYMOUSLY'));
if ($rootNode instanceof Node) {
$root = new Term();
$root->setTerm('root_id', $rootNode->getId());
$bool->addMust($root);
}
// check if slug is non-empty: avoid filtering for home page
if ($category && $category->getSlug()) {
$bool->addShould((new Term())->setTerm('ancestors', $category->getNodeId()));
}
if ($tags) {
$tagLogic = $this->tagsLogic instanceof TagLogic ?: new TagLogic(TagLogic::LOGIC_FEW);
$minimum = $tagLogic->getMinMatch($tags);
$bool->addShould((new Terms())->setMinimumMatch($minimum)->setTerms('tags', $tags));
}
if (0 !== sizeof($exclude)) {
$bool->addMustNot((new Terms())->setTerms('node_id', $exclude));
}
$this->query = new Query();
$queryDefinition = new QueryDefinition($this->query, $bool);
$this->feed->modifyQuery($queryDefinition);
$queryDefinition->getQuery()->setQuery($queryDefinition->getFilterQuery());
}
/**
* @group unit
*/
public function testToArray()
{
$query = new BoolQuery();
$idsQuery1 = new Ids();
$idsQuery1->setIds(1);
$idsQuery2 = new Ids();
$idsQuery2->setIds(2);
$idsQuery3 = new Ids();
$idsQuery3->setIds(3);
$filter1 = new Term();
$filter1->setTerm('test', '1');
$filter2 = new Term();
$filter2->setTerm('username', 'ruth');
$boost = 1.2;
$minMatch = 2;
$query->setBoost($boost);
$query->setMinimumNumberShouldMatch($minMatch);
$query->addMust($idsQuery1);
$query->addMustNot($idsQuery2);
$query->addShould($idsQuery3->toArray());
$query->addFilter($filter1);
$query->addFilter($filter2);
$expectedArray = array('bool' => array('must' => array($idsQuery1->toArray()), 'should' => array($idsQuery3->toArray()), 'filter' => array($filter1->toArray(), $filter2->toArray()), 'minimum_number_should_match' => $minMatch, 'must_not' => array($idsQuery2->toArray()), 'boost' => $boost));
$this->assertEquals($expectedArray, $query->toArray());
}
public function testToArray()
{
$query = new Term();
$key = 'name';
$value = 'nicolas';
$boost = 2;
$query->setTerm($key, $value, $boost);
$data = $query->toArray();
$this->assertInternalType('array', $data['term']);
$this->assertInternalType('array', $data['term'][$key]);
$this->assertEquals($data['term'][$key]['value'], $value);
$this->assertEquals($data['term'][$key]['boost'], $boost);
}
/**
* Perform a search on messages using Elasticsearch
*
* @param string $query The query string
* @return Message[] The results of the search
*/
private function elasticSearch($query)
{
$finder = \Service::getContainer()->get('fos_elastica.finder.search');
$boolQuery = new Bool();
// We have only stored "active" messages and groups on Elasticsearch's
// database, so there is no check for that again
if ($this->player) {
// Make sure that the parent of the message (i.e. the group that the
// message belongs into) has the current player as its member
$recipientQuery = new Term();
$recipientQuery->setTerm('members', $this->player->getId());
$parentQuery = new HasParent($recipientQuery, 'group');
$boolQuery->addMust($parentQuery);
}
$fieldQuery = new Match();
$fieldQuery->setFieldQuery('content', $query)->setFieldFuzziness('content', 'auto');
$boolQuery->addMust($fieldQuery);
return $finder->find($boolQuery);
}
/**
* @group unit
*/
public function testSetQueryToArrayChangeQuery()
{
$query = new Query();
$termQuery = new Term();
$termQuery->setTerm('text', 'value');
$query->setQuery($termQuery);
$queryArray = $query->toArray();
$termQuery = $query->getQuery();
$termQuery->setTerm('text', 'another value');
$this->assertNotEquals($queryArray, $query->toArray());
}
/**
* @group functional
*/
public function testGlobalSearchTypeSearchWithKeys()
{
$type = $this->_createType();
$index = $type->getIndex();
$client = $index->getClient();
$multiSearch = new MultiSearch($client);
$search1 = new Search($client);
$search1->addIndex($index)->addType($type);
$query1 = new Query();
$termQuery1 = new Term();
$termQuery1->setTerm('username', 'farrelley');
$query1->setQuery($termQuery1);
$query1->setSize(2);
$search1->setQuery($query1);
$multiSearch->addSearch($search1);
$this->assertCount(1, $multiSearch->getSearches());
$search2 = new Search($client);
$search2->addIndex($index)->addType($type);
$query2 = new Query();
$termQuery2 = new Term();
$termQuery2->setTerm('username', 'bunny');
$query2->setQuery($termQuery2);
$query2->setSize(3);
$search2->setQuery($query2);
$multiSearch->addSearch($search2);
$multiSearch->setSearchType(Search::OPTION_SEARCH_TYPE_COUNT);
$multiResultSet = $multiSearch->search();
$this->assertInstanceOf('Elastica\\Multi\\ResultSet', $multiResultSet);
$this->assertCount(2, $multiResultSet);
$this->assertInstanceOf('Elastica\\Response', $multiResultSet->getResponse());
$resultSets = $multiResultSet->getResultSets();
$this->assertInternalType('array', $resultSets);
$this->assertArrayHasKey(0, $resultSets);
$this->assertInstanceOf('Elastica\\ResultSet', $resultSets[0]);
$this->assertCount(0, $resultSets[0]);
$this->assertSame($query1, $resultSets[0]->getQuery());
$this->assertEquals(3, $resultSets[0]->getTotalHits());
$this->assertArrayHasKey(1, $resultSets);
$this->assertInstanceOf('Elastica\\ResultSet', $resultSets[1]);
$this->assertCount(0, $resultSets[1]);
$this->assertSame($query2, $resultSets[1]->getQuery());
$this->assertEquals(6, $resultSets[1]->getTotalHits());
$search1->setOption(Search::OPTION_SEARCH_TYPE, Search::OPTION_SEARCH_TYPE_QUERY_AND_FETCH);
$multiResultSet = $multiSearch->search();
$this->assertInstanceOf('Elastica\\Multi\\ResultSet', $multiResultSet);
$this->assertCount(2, $multiResultSet);
$this->assertInstanceOf('Elastica\\Response', $multiResultSet->getResponse());
$resultSets = $multiResultSet->getResultSets();
$this->assertInternalType('array', $resultSets);
$this->assertArrayHasKey(0, $resultSets);
$this->assertInstanceOf('Elastica\\ResultSet', $resultSets[0]);
$this->assertCount(2, $resultSets[0]);
$this->assertSame($query1, $resultSets[0]->getQuery());
$this->assertEquals(3, $resultSets[0]->getTotalHits());
$this->assertArrayHasKey(1, $resultSets);
$this->assertInstanceOf('Elastica\\ResultSet', $resultSets[1]);
$this->assertCount(0, $resultSets[1]);
$this->assertSame($query2, $resultSets[1]->getQuery());
$this->assertEquals(6, $resultSets[1]->getTotalHits());
}
/**
* Find a document matching an exact term.
*
* @link https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-term-query.html
*
* @param string $key
* @param string $value
* @param float $boost
* @return Query
*/
public function term($key, $value, $boost = 1.0)
{
$term = new Term();
$term->setTerm($key, $value, $boost);
$query = $this->newQuery($term);
$this->query[] = $query;
return $query;
}
/**
* @group functional
*/
public function testQuery()
{
$query = new Query();
$match = new Match();
$match->setField('make', 'ford');
$query->setQuery($match);
$filter = new Query\Term();
$filter->setTerm('color', 'green');
$query->setPostFilter($filter);
$results = $this->_getTestIndex()->search($query);
$this->assertEquals(1, $results->getTotalHits());
}
/**
* @group functional
*/
public function testCount()
{
$index = $this->_createIndex();
// Add document to normal index
$doc1 = new Document(null, array('name' => 'ruflin'));
$doc2 = new Document(null, array('name' => 'nicolas'));
$type = $index->getType('test');
$type->addDocument($doc1);
$type->addDocument($doc2);
$index->refresh();
$this->assertEquals(2, $index->count());
$query = new Term();
$key = 'name';
$value = 'nicolas';
$query->setTerm($key, $value);
$this->assertEquals(1, $index->count($query));
}
public function testGetQuery()
{
$query = new Query();
try {
$query->getQuery();
$this->fail('should throw exception because query does not exist');
} catch (InvalidException $e) {
$this->assertTrue(true);
}
$termQuery = new Term();
$termQuery->setTerm('text', 'value');
$query->setQuery($termQuery);
$this->assertEquals($termQuery->toArray(), $query->getQuery());
}
/**
* @param string $field
* @param string $value
*
* @return \Elastica\Query\Term
*/
public function createTermQuery($field, $value)
{
$termQuery = new Term();
return $termQuery->setTerm($field, $value);
}
