Java tutorial
/* * Copyright 2012 - 2014 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springframework.data.solr.core; import java.util.Arrays; import java.util.Calendar; import java.util.Collections; import java.util.List; import java.util.TimeZone; import org.apache.commons.lang3.StringUtils; import org.apache.solr.client.solrj.SolrQuery; import org.apache.solr.common.params.CommonParams; import org.apache.solr.common.params.FacetParams; import org.apache.solr.common.params.GroupParams; import org.apache.solr.common.params.HighlightParams; import org.apache.solr.common.params.StatsParams; import org.joda.time.DateTime; import org.joda.time.DateTimeZone; import org.joda.time.LocalDateTime; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.springframework.core.convert.converter.Converter; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Sort; import org.springframework.data.geo.Box; import org.springframework.data.geo.Circle; import org.springframework.data.geo.Distance; import org.springframework.data.geo.Metrics; import org.springframework.data.geo.Point; import org.springframework.data.solr.core.query.Criteria; import org.springframework.data.solr.core.query.FacetOptions; import org.springframework.data.solr.core.query.FacetOptions.FacetParameter; import org.springframework.data.solr.core.query.FacetOptions.FacetSort; import org.springframework.data.solr.core.query.FacetOptions.FieldWithFacetParameters; import org.springframework.data.solr.core.query.FacetQuery; import org.springframework.data.solr.core.query.GroupOptions; import org.springframework.data.solr.core.query.HighlightOptions; import org.springframework.data.solr.core.query.Join; import org.springframework.data.solr.core.query.MaxFunction; import org.springframework.data.solr.core.query.Query; import org.springframework.data.solr.core.query.Query.Operator; import org.springframework.data.solr.core.query.SimpleFacetQuery; import org.springframework.data.solr.core.query.SimpleField; import org.springframework.data.solr.core.query.SimpleFilterQuery; import org.springframework.data.solr.core.query.SimpleHighlightQuery; import org.springframework.data.solr.core.query.SimpleQuery; import org.springframework.data.solr.core.query.SimpleStringCriteria; import org.springframework.data.solr.core.query.SolrPageRequest; import org.springframework.data.solr.core.query.StatsOptions; /** * @author Christoph Strobl * @author John Dorman * @author Rosty Kerei * @author Andrey Paramonov * @author Philipp Jardas * @author Francisco Spaeth */ public class DefaultQueryParserTests { private DefaultQueryParser queryParser; @Before public void setUp() { this.queryParser = new DefaultQueryParser(); } @Test public void testIs() { Criteria criteria = new Criteria("field_1").is("is"); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:is", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testMultipleIs() { Criteria criteria = new Criteria("field_1").is("is").is("another is"); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:(is \"another is\")", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testEndsWith() { Criteria criteria = new Criteria("field_1").endsWith("end"); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:*end", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testEndsWithMulitpleValues() { Criteria criteria = new Criteria("field_1").endsWith(Arrays.asList("one", "two", "three")); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:(*one *two *three)", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testStartsWith() { Criteria criteria = new Criteria("field_1").startsWith("start"); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:start*", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testStartsWithMultipleValues() { Criteria criteria = new Criteria("field_1").startsWith(Arrays.asList("one", "two", "three")); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:(one* two* three*)", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testContains() { Criteria criteria = new Criteria("field_1").contains("contains"); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:*contains*", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testContainsWithMultipleValues() { Criteria criteria = new Criteria("field_1").contains(Arrays.asList("one", "two", "three")); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:(*one* *two* *three*)", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testExpression() { Criteria criteria = new Criteria("field_1").expression("(have fun using +solr && expressions*)"); Assert.assertEquals("field_1:(have fun using +solr && expressions*)", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testCriteriaChain() { Criteria criteria = new Criteria("field_1").startsWith("start").endsWith("end").contains("contains") .is("is"); Assert.assertEquals("field_1", criteria.getField().getName()); Assert.assertEquals("field_1:(start* *end *contains* is)", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testAnd() { Criteria criteria = new Criteria("field_1").startsWith("start").endsWith("end").and("field_2") .startsWith("2start").endsWith("2end"); Assert.assertEquals("field_1:(start* *end) AND field_2:(2start* *2end)", queryParser.createQueryStringFromNode(criteria)); } @Test public void testOr() { Criteria criteria = new Criteria("field_1").startsWith("start").or("field_2").endsWith("end") .startsWith("start2"); Assert.assertEquals("field_1:start* OR field_2:(*end start2*)", queryParser.createQueryStringFromNode(criteria)); } @Test public void testCriteriaWithWhiteSpace() { Criteria criteria = new Criteria("field_1").is("white space"); Assert.assertEquals("field_1:\"white space\"", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testCriteriaWithDoubleQuotes() { Criteria criteria = new Criteria("field_1").is("with \"quote"); Assert.assertEquals("field_1:\"with \\\"quote\"", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testIsNot() { Criteria criteria = new Criteria("field_1").is("value_1").not(); Assert.assertEquals("-field_1:value_1", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testFuzzy() { Criteria criteria = new Criteria("field_1").fuzzy("value_1"); Assert.assertEquals("field_1:value_1~", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testFuzzyWithDistance() { Criteria criteria = new Criteria("field_1").fuzzy("value_1", 0.5f); Assert.assertEquals("field_1:value_1~0.5", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testSloppy() { Criteria criteria = new Criteria("field_1").sloppy("value1 value2", 2); Assert.assertEquals("field_1:\"value1 value2\"~2", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBoost() { Criteria criteria = new Criteria("field_1").is("value_1").boost(2f); Assert.assertEquals("field_1:value_1^2.0", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBoostMultipleValues() { Criteria criteria = new Criteria("field_1").is("value_1").is("value_2").boost(2f); Assert.assertEquals("field_1:(value_1 value_2)^2.0", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBoostMultipleCriteriasValues() { Criteria criteria = new Criteria("field_1").is("value_1").is("value_2").boost(2f).and("field_3") .is("value_3"); Assert.assertEquals("field_1:(value_1 value_2)^2.0 AND field_3:value_3", queryParser.createQueryStringFromNode(criteria)); } @Test public void testBetween() { Criteria criteria = new Criteria("field_1").between(100, 200); Assert.assertEquals("field_1:[100 TO 200]", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBetweenExcludeLowerBound() { Criteria criteria = new Criteria("field_1").between(100, 200, false, true); Assert.assertEquals("field_1:{100 TO 200]", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBetweenExcludeUpperBound() { Criteria criteria = new Criteria("field_1").between(100, 200, true, false); Assert.assertEquals("field_1:[100 TO 200}", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBetweenWithoutUpperBound() { Criteria criteria = new Criteria("field_1").between(100, null); Assert.assertEquals("field_1:[100 TO *]", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBetweenWithoutLowerBound() { Criteria criteria = new Criteria("field_1").between(null, 200); Assert.assertEquals("field_1:[* TO 200]", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBetweenWithDateValue() { DateTime lowerBound = new DateTime(2012, 8, 21, 6, 35, 0, DateTimeZone.UTC); DateTime upperBound = new DateTime(2012, 8, 21, 19, 30, 0, DateTimeZone.UTC); Criteria criteria = new Criteria("field_1").between(lowerBound, upperBound); Assert.assertEquals("field_1:[2012\\-08\\-21T06\\:35\\:00.000Z TO 2012\\-08\\-21T19\\:30\\:00.000Z]", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testBetweenNegativeNumber() { Criteria criteria = new Criteria("field_1").between(-200, -100); Assert.assertEquals("field_1:[\\-200 TO \\-100]", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testIn() { Criteria criteria = new Criteria("field_1").in(1, 2, 3, 5, 8, 13, 21); Assert.assertEquals("field_1:(1 2 3 5 8 13 21)", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testIsWithJavaDateValue() { DateTime dateTime = new DateTime(2012, 8, 21, 6, 35, 0, DateTimeZone.UTC); Calendar calendar = Calendar.getInstance(); calendar.setTimeZone(TimeZone.getTimeZone("UTC")); calendar.setTimeInMillis(dateTime.getMillis()); Criteria criteria = new Criteria("dateField").is(calendar.getTime()); Assert.assertEquals("dateField:2012\\-08\\-21T06\\:35\\:00.000Z", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testIsWithJodaDateTime() { DateTime dateTime = new DateTime(2012, 8, 21, 6, 35, 0, DateTimeZone.UTC); Criteria criteria = new Criteria("dateField").is(dateTime); Assert.assertEquals("dateField:2012\\-08\\-21T06\\:35\\:00.000Z", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testIsWithJodaLocalDateTime() { LocalDateTime dateTime = new LocalDateTime( new DateTime(2012, 8, 21, 6, 35, 0, DateTimeZone.UTC).getMillis(), DateTimeZone.UTC); Criteria criteria = new Criteria("dateField").is(dateTime); Assert.assertEquals("dateField:2012\\-08\\-21T06\\:35\\:00.000Z", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testIsWithNegativeNumner() { Criteria criteria = new Criteria("field_1").is(-100); Assert.assertEquals("field_1:\\-100", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testNear() { Criteria criteria = new Criteria("field_1").near(new Point(48.303056, 14.290556), new Distance(5)); Assert.assertEquals("{!bbox pt=48.303056,14.290556 sfield=field_1 d=5.0}", queryParser.createQueryStringFromCriteria(criteria)); } /** * @see DATASOLR-142 */ @Test(expected = IllegalArgumentException.class) public void testCircleForNearMustNotBeNull() { new Criteria("field_1").near((Circle) null); } @Test public void testNearWithDistanceUnitMiles() { Criteria criteria = new Criteria("field_1").near(new Point(48.303056, 14.290556), new Distance(1, Metrics.MILES)); Assert.assertEquals("{!bbox pt=48.303056,14.290556 sfield=field_1 d=1.609344}", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testNearWithDistanceUnitKilometers() { Criteria criteria = new Criteria("field_1").near(new Point(48.303056, 14.290556), new Distance(1, Metrics.KILOMETERS)); Assert.assertEquals("{!bbox pt=48.303056,14.290556 sfield=field_1 d=1.0}", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testNearWithCoords() { Criteria criteria = new Criteria("field_1") .near(new Box(new Point(48.303056, 14.290556), new Point(48.303056, 14.290556))); Assert.assertEquals("field_1:[48.303056,14.290556 TO 48.303056,14.290556]", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testWithinWithDistanceUnitMiles() { Criteria criteria = new Criteria("field_1").within(new Point(48.303056, 14.290556), new Distance(1, Metrics.MILES)); Assert.assertEquals("{!geofilt pt=48.303056,14.290556 sfield=field_1 d=1.609344}", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testWithinWithDistanceUnitKilometers() { Criteria criteria = new Criteria("field_1").within(new Point(48.303056, 14.290556), new Distance(1, Metrics.KILOMETERS)); Assert.assertEquals("{!geofilt pt=48.303056,14.290556 sfield=field_1 d=1.0}", queryParser.createQueryStringFromCriteria(criteria)); } /** * @see DATASOLR-142 */ @Test(expected = IllegalArgumentException.class) public void testCircleForWithinMustNotBeNull() { new Criteria("field_1").within((Circle) null); } /** * @see DATASOLR-142 */ @Test public void testWithinCircleWorksCorrectly() { Criteria criteria = new Criteria("field_1") .within(new Circle(new Point(48.303056, 14.290556), new Distance(1, Metrics.KILOMETERS))); Assert.assertEquals("{!geofilt pt=48.303056,14.290556 sfield=field_1 d=1.0}", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testWithinWithNullDistance() { Criteria criteria = new Criteria("field_1").within(new Point(48.303056, 14.290556), null); Assert.assertEquals("{!geofilt pt=48.303056,14.290556 sfield=field_1 d=0.0}", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testStringCriteria() { Criteria criteria = new SimpleStringCriteria("field_1:value_1 AND field_2:value_2"); Assert.assertEquals("field_1:value_1 AND field_2:value_2", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testStringCriteriaWithMoreFragments() { Criteria criteria = new SimpleStringCriteria("field_1:value_1 AND field_2:value_2"); criteria = criteria.and("field_3").is("value_3"); Assert.assertEquals("field_1:value_1 AND field_2:value_2 AND field_3:value_3", queryParser.createQueryStringFromNode(criteria)); } @Test public void testRegisterAlternateConverter() { Criteria criteria = new Criteria("field_1").is(100); queryParser.registerConverter(new Converter<Number, String>() { @Override public String convert(Number arg0) { return StringUtils.reverse(arg0.toString()); } }); Assert.assertEquals("field_1:001", queryParser.createQueryStringFromCriteria(criteria)); } @Test public void testConstructSimpleSolrQuery() { Query query = new SimpleQuery(new Criteria("field_1").is("value_1")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); } @Test public void testConstructSolrQueryWithPagination() { int page = 1; int pageSize = 100; Query query = new SimpleQuery(new Criteria("field_1").is("value_1")) .setPageRequest(new PageRequest(page, pageSize)); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationPresent(solrQuery, page * pageSize, pageSize); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); } @Test public void testConstructSimpleSolrQueryWithProjection() { Query query = new SimpleQuery(new Criteria("field_1").is("value_1")).addProjectionOnField("projection_1") .addProjectionOnField(new SimpleField("projection_2")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionPresent(solrQuery, "projection_1,projection_2"); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); } @Test public void testConstructSolrQueryWithSingleGroupBy() { Query query = new SimpleQuery(new Criteria("field_1").is("value_1")).addGroupByField("group_1"); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingPresent(solrQuery, "group_1"); assertFactingNotPresent(solrQuery); } @Test public void testConstructSolrQueryWithSingleFacetOnField() { Query query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")) .setFacetOptions(new FacetOptions("facet_1")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1"); } @Test public void testConstructSolrQueryWithSinglePivot() { Query query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")) .setFacetOptions(new FacetOptions().addFacetOnPivot("field_1", "field_2")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertPivotFactingPresent(solrQuery, "field_1,field_2"); } @Test public void testConstructSolrQueryWithMultipleFacetOnFields() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")) .setFacetOptions(new FacetOptions("facet_1", "facet_2")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1", "facet_2"); } @Test public void testConstructSolrQueryWithMultiplePivot() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")).setFacetOptions( new FacetOptions().addFacetOnPivot("field_1", "field_2").addFacetOnPivot("field_2", "field_3")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertPivotFactingPresent(solrQuery, "field_1,field_2", "field_2,field_3"); } @Test public void testConstructSolrQueryWithFacetPrefix() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")); FacetOptions facetOptions = new FacetOptions(new SimpleField("facet_1"), new SimpleField("facet_2")); facetOptions.setFacetPrefix("prefix"); query.setFacetOptions(facetOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1", "facet_2"); Assert.assertEquals(facetOptions.getFacetPrefix(), solrQuery.getParams("facet.prefix")[0]); } @Test public void testConstructSolrQueryWithFieldFacetParameters() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")); FieldWithFacetParameters fieldWithFacetParameters = new FieldWithFacetParameters("facet_2") .setPrefix("prefix").setSort(FacetSort.INDEX).setLimit(3).setOffset(2).setMethod("method") .setMissing(true); FacetOptions facetOptions = new FacetOptions(new SimpleField("facet_1"), fieldWithFacetParameters); query.setFacetOptions(facetOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingPresent(solrQuery, "facet_1", "facet_2"); Assert.assertEquals(fieldWithFacetParameters.getPrefix(), solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.prefix")[0]); Assert.assertEquals(FacetParams.FACET_SORT_INDEX, solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.sort")[0]); Assert.assertEquals(Integer.toString(fieldWithFacetParameters.getOffset()), solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.offset")[0]); Assert.assertEquals(Integer.toString(fieldWithFacetParameters.getLimit()), solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.limit")[0]); Assert.assertEquals(fieldWithFacetParameters.getMethod(), solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.method")[0]); Assert.assertEquals(fieldWithFacetParameters.getMissing().toString(), solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.missing")[0]); } @Test public void testConstructSolrQueryWithCustomFieldFacetParameters() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")); FieldWithFacetParameters fieldWithFacetParameters = new FieldWithFacetParameters("facet_2") .addFacetParameter(new FacetParameter(FacetParams.FACET_ZEROS, "on")); FacetOptions facetOptions = new FacetOptions(new SimpleField("facet_1"), fieldWithFacetParameters); query.setFacetOptions(facetOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("on", solrQuery.getParams("f." + fieldWithFacetParameters.getName() + ".facet.zeros")[0]); } @Test public void testConstructSolrQueryWithFacetSort() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")) .setFacetOptions(new FacetOptions("facet_1").setFacetSort(FacetOptions.FacetSort.INDEX)); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("index", solrQuery.getFacetSortString()); query.getFacetOptions().setFacetSort(FacetOptions.FacetSort.COUNT); solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("count", solrQuery.getFacetSortString()); } @Test public void testConstructSolrQueryWithSingleFacetFilterQuery() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")).setFacetOptions( new FacetOptions().addFacetQuery(new SimpleQuery(new SimpleStringCriteria("field_2:[* TO 5]")))); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); Assert.assertArrayEquals(new String[] { "field_2:[* TO 5]" }, solrQuery.getFacetQuery()); } @Test public void testConstructSolrQueryWithMultipleFacetFilterQuerues() { FacetQuery query = new SimpleFacetQuery(new Criteria("field_1").is("value_1")).setFacetOptions( new FacetOptions().addFacetQuery(new SimpleQuery(new SimpleStringCriteria("field_2:[* TO 5]"))) .addFacetQuery(new SimpleQuery(new Criteria("field_3").startsWith("prefix")))); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); Assert.assertArrayEquals(new String[] { "field_2:[* TO 5]", "field_3:prefix*" }, solrQuery.getFacetQuery()); } @Test public void testWithFilterQuery() { Query query = new SimpleQuery(new Criteria("field_1").is("value_1")) .addFilterQuery(new SimpleFilterQuery(new Criteria("filter_field").is("filter_value"))); SolrQuery solrQuery = queryParser.constructSolrQuery(query); String[] filterQueries = solrQuery.getFilterQueries(); Assert.assertEquals(1, filterQueries.length); Assert.assertEquals("filter_field:filter_value", filterQueries[0]); } @Test public void testWithEmptyFilterQuery() { Query query = new SimpleQuery(new Criteria("field_1").is("value_1")).addFilterQuery(new SimpleQuery()); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.getFilterQueries()); } @Test public void testWithSimpleStringCriteria() { SimpleStringCriteria criteria = new SimpleStringCriteria("field_1:value_1"); Query query = new SimpleQuery(criteria); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery); assertQueryStringPresent(solrQuery); assertPaginationNotPresent(solrQuery); assertProjectionNotPresent(solrQuery); assertGroupingNotPresent(solrQuery); assertFactingNotPresent(solrQuery); Assert.assertEquals(criteria.getQueryString(), solrQuery.getQuery()); } @Test public void testWithNullSort() { SimpleStringCriteria criteria = new SimpleStringCriteria("field_1:value_1"); Query query = new SimpleQuery(criteria); query.addSort(null); // do this explicitly SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.getSortField()); Assert.assertTrue(solrQuery.getSorts().isEmpty()); } @Test public void testWithSortAscOnSingleField() { SimpleStringCriteria criteria = new SimpleStringCriteria("field_1:value_1"); Query query = new SimpleQuery(criteria); query.addSort(new Sort("field_2")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("field_2 asc", solrQuery.getSortField()); Assert.assertEquals(1, solrQuery.getSorts().size()); } @Test public void testWithSortDescOnSingleField() { SimpleStringCriteria criteria = new SimpleStringCriteria("field_1:value_1"); Query query = new SimpleQuery(criteria); query.addSort(new Sort(Sort.Direction.DESC, "field_2")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("field_2 desc", solrQuery.getSortField()); Assert.assertEquals(1, solrQuery.getSorts().size()); } @Test public void testWithSortAscMultipleFields() { SimpleStringCriteria criteria = new SimpleStringCriteria("field_1:value_1"); Query query = new SimpleQuery(criteria); query.addSort(new Sort("field_2", "field_3")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("field_2 asc,field_3 asc", solrQuery.getSortField()); Assert.assertEquals(2, solrQuery.getSorts().size()); } @Test public void testWithSortDescMultipleFields() { SimpleStringCriteria criteria = new SimpleStringCriteria("field_1:value_1"); Query query = new SimpleQuery(criteria); query.addSort(new Sort(Sort.Direction.DESC, "field_2", "field_3")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("field_2 desc,field_3 desc", solrQuery.getSortField()); Assert.assertEquals(2, solrQuery.getSorts().size()); } @Test public void testWithSortMixedDirections() { SimpleStringCriteria criteria = new SimpleStringCriteria("field_1:value_1"); Query query = new SimpleQuery(criteria); query.addSort(new Sort("field_1")); query.addSort(new Sort(Sort.Direction.DESC, "field_2", "field_3")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("field_1 asc,field_2 desc,field_3 desc", solrQuery.getSortField()); Assert.assertEquals(3, solrQuery.getSorts().size()); } @Test public void testWithORDefaultOperator() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setDefaultOperator(Operator.OR); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("OR", solrQuery.get("q.op")); } @Test public void testWithANDDefaultOperator() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setDefaultOperator(Operator.AND); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("AND", solrQuery.get("q.op")); } @Test public void testWithNONEDefaultOperator() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setDefaultOperator(Operator.NONE); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.get("q.op")); } @Test public void testWithoutDefaultOperator() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.get("q.op")); } @Test public void testWithNullDefaultOperator() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setDefaultOperator(null); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.get("q.op")); } @Test public void testWithTimeAllowed() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setTimeAllowed(100); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals(new Integer(100), solrQuery.getTimeAllowed()); } @Test public void testWithoutTimeAllowed() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.getTimeAllowed()); } @Test public void testWithLuceneDefType() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setDefType("lucene"); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery.get("defType")); } @Test public void testWithEdismaxDefType() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setDefType("edismax"); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery.get("defType")); } @Test public void testWithUndefindedDefType() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.get("defType")); } @Test public void testWithFooRequestHandler() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setRequestHandler("/foo"); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNotNull(solrQuery.get("qt")); } @Test public void testWithUndefinedRequestHandler() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertNull(solrQuery.get("qt")); } @Test public void testWithJoinOperator() { SimpleQuery query = new SimpleQuery(new SimpleStringCriteria("field_1:value_1")); query.setJoin(Join.from("inner_id").to("outer_id")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("{!join from=inner_id to=outer_id}field_1:value_1", solrQuery.getQuery()); } @Test public void testConstructSolrQueryWithEmptyHighlightOption() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); query.setHighlightOptions(new HighlightOptions()); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertTrue(solrQuery.getHighlight()); Assert.assertArrayEquals(new String[] { Criteria.WILDCARD }, solrQuery.getHighlightFields()); } @Test public void testConstructSolrQueryWithoutHighlightOption() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertFalse(solrQuery.getHighlight()); } @Test public void testConstructSolrQueryWithHighlightOptionHavingFields() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); HighlightOptions options = new HighlightOptions(); options.addField("field_2", "field_3"); query.setHighlightOptions(options); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertArrayEquals(new String[] { "field_2", "field_3" }, solrQuery.getHighlightFields()); } @Test public void testConstructSorlQueryWithHighlightOptionFragsize() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); HighlightOptions options = new HighlightOptions(); options.setFragsize(10); query.setHighlightOptions(options); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals(options.getFragsize().intValue(), solrQuery.getHighlightFragsize()); } @Test public void testConstructSorlQueryWithHighlightOptionFormatter() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); HighlightOptions options = new HighlightOptions(); options.setFormatter("formatter"); query.setHighlightOptions(options); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals(options.getFormatter(), solrQuery.getParams(HighlightParams.FORMATTER)[0]); } @Test public void testConstructSorlQueryWithHighlightOptionNrSnipplets() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); HighlightOptions options = new HighlightOptions(); options.setNrSnipplets(10); query.setHighlightOptions(options); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals(options.getNrSnipplets().intValue(), solrQuery.getHighlightSnippets()); } @Test public void testConstructSorlQueryWithHighlightOptionsAndAnySolrParameter() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); HighlightOptions options = new HighlightOptions(); options.addHighlightParameter(HighlightParams.SIMPLE_PRE, "{pre}"); query.setHighlightOptions(options); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals(options.<String>getHighlightParameterValue(HighlightParams.SIMPLE_PRE), solrQuery.getHighlightSimplePre()); } @Test public void testConstructSorlQueryWithFieldSpecificHighlightOptions() { SimpleHighlightQuery query = new SimpleHighlightQuery(new SimpleStringCriteria("field_1:value_1")); HighlightOptions options = new HighlightOptions(); HighlightOptions.FieldWithHighlightParameters fieldWithHighlightParameters = new HighlightOptions.FieldWithHighlightParameters( "field_2"); fieldWithHighlightParameters.setFormatter("formatter"); fieldWithHighlightParameters.setFragsize(10); options.addField(fieldWithHighlightParameters); query.setHighlightOptions(options); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertArrayEquals(new String[] { "field_2" }, solrQuery.getHighlightFields()); Assert.assertEquals(fieldWithHighlightParameters.getFormatter(), solrQuery.getParams("f.field_2." + HighlightParams.FORMATTER)[0]); Assert.assertEquals(fieldWithHighlightParameters.getFragsize().toString(), solrQuery.getParams("f.field_2." + HighlightParams.FRAGSIZE)[0]); } /** * @see DATASOLR-105 */ @Test public void testNestedOrPartWithAnd() { Criteria criteria = Criteria.where("field_1").is("foo") .and(Criteria.where("field_2").is("bar").or("field_3").is("roo"))// .or(Criteria.where("field_4").is("spring").and("field_5").is("data")); Assert.assertEquals("field_1:foo AND (field_2:bar OR field_3:roo) OR (field_4:spring AND field_5:data)", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-105 */ @Test public void testNestedOrPartWithAndSomeOtherThings() { Criteria criteria = Criteria.where("field_1").is("foo").is("bar") .and(Criteria.where("field_2").is("bar").is("lala").or("field_3").is("roo")) .or(Criteria.where("field_4").is("spring").and("field_5").is("data")); Assert.assertEquals( "field_1:(foo bar) AND (field_2:(bar lala) OR field_3:roo) OR (field_4:spring AND field_5:data)", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-105 */ @Test public void testMultipleAnd() { Criteria criteria = Criteria.where("field_1").is("foo").and("field_2").is("bar").and("field_3").is("roo"); Assert.assertEquals("field_1:foo AND field_2:bar AND field_3:roo", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-105 */ @Test public void testMultipleOr() { Criteria criteria = Criteria.where("field_1").is("foo").or("field_2").is("bar").or("field_3").is("roo"); Assert.assertEquals("field_1:foo OR field_2:bar OR field_3:roo", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-105 */ @Test public void testEmptyCriteriaShouldBeDefaultedToNotNUll() { Criteria criteria = Criteria.where("field_1").is("foo").and("field_2").or("field_3"); Assert.assertEquals("field_1:foo AND field_2:[* TO *] OR field_3:[* TO *]", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-105 */ @Test public void testDeepNesting() { Criteria criteria = Criteria.where("field_1").is("foo").and(Criteria.where("field_2").is("bar") .and("field_3").is("roo")// .and(Criteria.where("field_4").is("spring").and("field_5").is("data").or("field_6").is("solr"))); Assert.assertEquals( "field_1:foo AND (field_2:bar AND field_3:roo AND (field_4:spring AND field_5:data OR field_6:solr))", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-168 */ @Test public void testNotCritieraCarriedOnPorperlyForNullAndNotNull() { Criteria criteria = new Criteria("param1").isNotNull().and("param2").isNull(); Assert.assertEquals("param1:[* TO *] AND -param2:[* TO *]", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-112 */ @Test public void pageableUsingZeroShouldBeParsedCorrectlyWhenSetUsingPageable() { SimpleQuery query = new SimpleQuery("*:*").setPageRequest(new SolrPageRequest(0, 0)); assertPaginationPresent(queryParser.constructSolrQuery(query), 0, 0); } /** * @see DATASOLR-112 */ @Test public void pageableUsingZeroShouldBeParsedCorrectlyWhenSetUsingExplititMethods() { SimpleQuery query = new SimpleQuery("*:*").setOffset(0).setRows(0); assertPaginationPresent(queryParser.constructSolrQuery(query), 0, 0); } /** * @see DATASOLR-160 */ @Test public void testConstructSolrQueryWithStatField() { StatsOptions statsOptions = new StatsOptions().addField(new SimpleField("field_1")); SimpleQuery query = new SimpleQuery("*:*"); query.setStatsOptions(statsOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); Assert.assertEquals("field_1", solrQuery.get(StatsParams.STATS_FIELD)); } /** * @see DATASOLR-160 */ @Test public void testConstructSolrQueryWithStatFields() { StatsOptions statsOptions = new StatsOptions()// .addField(new SimpleField("field_1"))// .addField(new SimpleField("field_2")); SimpleQuery query = new SimpleQuery("*:*"); query.setStatsOptions(statsOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); List<String> fields = Arrays.asList(solrQuery.getParams(StatsParams.STATS_FIELD)); Collections.sort(fields); Assert.assertEquals(2, fields.size()); Assert.assertEquals(Arrays.asList("field_1", "field_2"), fields); } /** * @see DATASOLR-160 */ @Test public void testConstructSolrQueryWithStatFacets() { StatsOptions statsOptions = new StatsOptions()// .addFacet(new SimpleField("field_1"))// .addFacet(new SimpleField("field_2")); SimpleQuery query = new SimpleQuery("*:*"); query.setStatsOptions(statsOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); List<String> facets = Arrays.asList(solrQuery.getParams(StatsParams.STATS_FACET)); Collections.sort(facets); Assert.assertEquals(2, facets.size()); Assert.assertEquals(Arrays.asList("field_1", "field_2"), facets); } /** * @see DATASOLR-160 */ @Test public void testConstructSolrQueryWithStatFieldsAndFacets() { StatsOptions statsOptions = new StatsOptions()// .addField(new SimpleField("field_1"))// .addFacet(new SimpleField("field_2")); SimpleQuery query = new SimpleQuery("*:*"); query.setStatsOptions(statsOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); String[] fields = solrQuery.getParams(StatsParams.STATS_FIELD); String[] facets = solrQuery.getParams(StatsParams.STATS_FACET); Assert.assertEquals(1, fields.length); Assert.assertEquals(1, facets.length); Assert.assertEquals("field_1", fields[0]); Assert.assertEquals("field_2", facets[0]); } /** * @see DATASOLR-160 */ @Test public void testConstructSolrQueryWithSelectiveStatsFacet() { StatsOptions statsOptions = new StatsOptions()// .addField(new SimpleField("field_1"))// .addSelectiveFacet(new SimpleField("field_2")); SimpleQuery query = new SimpleQuery("*:*"); query.setStatsOptions(statsOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); String[] fields = solrQuery.getParams(StatsParams.STATS_FIELD); String[] facets = solrQuery.getParams(CommonParams.FIELD + ".field_1." + StatsParams.STATS_FACET); Assert.assertEquals(1, fields.length); Assert.assertEquals(1, facets.length); Assert.assertEquals("field_1", fields[0]); Assert.assertEquals("field_2", facets[0]); } /** * @see DATASOLR-160 */ @Test public void testConstructSolrQueryWithSelectiveStatsCountDistinct() { StatsOptions statsOptions = new StatsOptions()// .addField(new SimpleField("field_1")).setSelectiveCalcDistinct(true) // .addField(new SimpleField("field_2")).setSelectiveCalcDistinct(false) // .addField(new SimpleField("field_3")); SimpleQuery query = new SimpleQuery("*:*"); query.setStatsOptions(statsOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); String[] fields = solrQuery.getParams(StatsParams.STATS_FIELD); String[] calc1 = solrQuery.getParams(CommonParams.FIELD + ".field_1." + StatsParams.STATS_CALC_DISTINCT); String[] calc2 = solrQuery.getParams(CommonParams.FIELD + ".field_2." + StatsParams.STATS_CALC_DISTINCT); String[] calc3 = solrQuery.getParams(CommonParams.FIELD + ".field_3." + StatsParams.STATS_CALC_DISTINCT); Arrays.sort(fields); Assert.assertEquals(3, fields.length); Assert.assertArrayEquals(new String[] { "field_1", "field_2", "field_3" }, fields); Assert.assertEquals("true", calc1[0]); Assert.assertEquals("false", calc2[0]); Assert.assertNull(calc3); } /** * @see DATASOLR-160 */ @Test public void testConstructSolrQueryWithStatsConfig() { StatsOptions statsOptions = new StatsOptions()// .addField(new SimpleField("field_1"))// .addSelectiveFacet(new SimpleField("field_1_1"))// .addSelectiveFacet(new SimpleField("field_1_2"))// .addField("field_2")// .addFacet("field_3"); SimpleQuery query = new SimpleQuery("*:*"); query.setStatsOptions(statsOptions); SolrQuery solrQuery = queryParser.constructSolrQuery(query); List<String> fields = Arrays.asList(solrQuery.getParams(StatsParams.STATS_FIELD)); Collections.sort(fields); List<String> selectiveFacets = Arrays .asList(solrQuery.getParams(CommonParams.FIELD + ".field_1." + StatsParams.STATS_FACET)); String[] facets = solrQuery.getParams(StatsParams.STATS_FACET); Assert.assertEquals(2, fields.size()); Assert.assertEquals(2, selectiveFacets.size()); Assert.assertEquals("field_1", fields.get(0)); Assert.assertEquals("field_2", fields.get(1)); Assert.assertEquals("field_1_1", selectiveFacets.get(0)); Assert.assertEquals("field_1_2", selectiveFacets.get(1)); Assert.assertEquals("field_3", facets[0]); } /** * @see DATASOLR-121 */ @Test public void testConstructGroupQueryWithAllPossibleParameters() { GroupOptions groupOptions = new GroupOptions(); SimpleQuery query = new SimpleQuery(); query.addCriteria(new SimpleStringCriteria("*:*")); query.setGroupOptions(groupOptions); groupOptions.setOffset(1); groupOptions.setLimit(2); groupOptions.addGroupByField("field_1"); groupOptions.addGroupByFunction(MaxFunction.max("field_1", "field_2")); groupOptions.addGroupByQuery(new SimpleQuery("*:*")); groupOptions.addSort(new Sort(Sort.Direction.DESC, "field_3")); groupOptions.setTotalCount(true); SolrQuery solrQuery = queryParser.constructSolrQuery(query); assertGroupFormatPresent(solrQuery, true); Assert.assertEquals("field_1", solrQuery.get(GroupParams.GROUP_FIELD)); Assert.assertEquals("{!func}max(field_1,field_2)", solrQuery.get(GroupParams.GROUP_FUNC)); Assert.assertEquals("*:*", solrQuery.get(GroupParams.GROUP_QUERY)); Assert.assertEquals("field_3 desc", solrQuery.get(GroupParams.GROUP_SORT)); Assert.assertEquals("1", solrQuery.get(GroupParams.GROUP_OFFSET)); Assert.assertEquals("2", solrQuery.get(GroupParams.GROUP_LIMIT)); } /** * @see DATASOLR-121 */ @Test public void testConstructGroupQueryWithoutPagingParameters() { SimpleQuery query = new SimpleQuery(); query.addCriteria(new SimpleStringCriteria("*:*")); query.setGroupOptions(new GroupOptions().addGroupByField("fieldName")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); assertGroupFormatPresent(solrQuery, false); Assert.assertNull(solrQuery.get(GroupParams.GROUP_SORT)); Assert.assertNull(solrQuery.get(GroupParams.GROUP_OFFSET)); Assert.assertNull(solrQuery.get(GroupParams.GROUP_LIMIT)); } /** * @see DATASOLR-121 */ @Test public void testConstructGroupQueryWithMultipleFunctions() { SimpleQuery query = new SimpleQuery(); query.addCriteria(new SimpleStringCriteria("*:*")); query.setGroupOptions(new GroupOptions()); query.getGroupOptions().addGroupByFunction(MaxFunction.max("field_1", "field_2")); query.getGroupOptions().addGroupByFunction(MaxFunction.max("field_3", "field_4")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); assertGroupFormatPresent(solrQuery, false); Assert.assertArrayEquals(new String[] { "{!func}max(field_1,field_2)", "{!func}max(field_3,field_4)" }, solrQuery.getParams(GroupParams.GROUP_FUNC)); Assert.assertNull(solrQuery.getParams(GroupParams.GROUP_QUERY)); Assert.assertNull(solrQuery.getParams(GroupParams.GROUP_FIELD)); } /** * @see DATASOLR-121 */ @Test public void testConstructGroupQueryWithMultipleQueries() { SimpleQuery query = new SimpleQuery(); query.addCriteria(new SimpleStringCriteria("*:*")); query.setGroupOptions(new GroupOptions()); query.getGroupOptions().addGroupByQuery(new SimpleQuery("query1")); query.getGroupOptions().addGroupByQuery(new SimpleQuery("query2")); SolrQuery solrQuery = queryParser.constructSolrQuery(query); assertGroupFormatPresent(solrQuery, false); Assert.assertArrayEquals(new String[] { "query1", "query2" }, solrQuery.getParams(GroupParams.GROUP_QUERY)); Assert.assertNull(solrQuery.getParams(GroupParams.GROUP_FUNC)); Assert.assertNull(solrQuery.getParams(GroupParams.GROUP_FIELD)); } /** * @see DATASOLR-196 */ @Test public void connectShouldAllowConcatinationOfCriteriaWithAndPreservingDesiredBracketing() { Criteria part1 = Criteria.where("z").is("roo"); Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar"); Criteria criteria = part1.connect().and(part2); Assert.assertEquals("z:roo AND (x:foo OR y:bar)", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-196 */ @Test public void connectShouldAllowConcatinationOfCriteriaWithAndPreservingDesiredBracketingReverse() { Criteria part1 = Criteria.where("z").is("roo"); Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar"); Criteria criteria = part2.connect().and(part1); Assert.assertEquals("(x:foo OR y:bar) AND z:roo", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-196 */ @Test public void connectShouldAllowConcatinationOfCriteriaWithOrPreservingDesiredBracketing() { Criteria part1 = Criteria.where("z").is("roo"); Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar"); Criteria criteria = part1.connect().or(part2); Assert.assertEquals("z:roo OR (x:foo OR y:bar)", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-196 */ @Test public void connectShouldAllowConcatinationOfCriteriaWithOrPreservingDesiredBracketingReverse() { Criteria part1 = Criteria.where("z").is("roo"); Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar"); Criteria criteria = part2.connect().or(part1); Assert.assertEquals("(x:foo OR y:bar) OR z:roo", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-196 */ @Test public void notOperatorShouldWrapWholeExpression() { Criteria part1 = Criteria.where("text").startsWith("fx").or("product_code").startsWith("fx"); Criteria part2 = Criteria.where("text").startsWith("option").or("product_code").startsWith("option"); Criteria criteria = part1.connect().and(part2).notOperator(); String expected = "-((text:fx* OR product_code:fx*) AND (text:option* OR product_code:option*))"; Assert.assertEquals(expected, queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-196 */ @Test public void notOperatorShouldWrapNestedExpressionCorrectly() { Criteria part1 = Criteria.where("z").is("roo"); Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar").notOperator(); Criteria criteria = part1.connect().or(part2); Assert.assertEquals("z:roo OR -(x:foo OR y:bar)", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-196 */ @Test public void notOperatorShouldWrapNestedExpressionCorrectlyReverse() { Criteria part1 = Criteria.where("z").is("roo"); Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar").notOperator(); Criteria criteria = part2.connect().or(part1); Assert.assertEquals("-(x:foo OR y:bar) OR z:roo", queryParser.createQueryStringFromNode(criteria)); } /** * @see DATASOLR-196 */ @Test public void notOperatorShouldWrapNestedExpressionCorrectlyReverseWithDoubleNegation() { Criteria part1 = Criteria.where("z").is("roo"); Criteria part2 = Criteria.where("x").is("foo").or("y").is("bar").notOperator(); Criteria criteria = part2.connect().and(part1).notOperator(); Assert.assertEquals("-(-(x:foo OR y:bar) AND z:roo)", queryParser.createQueryStringFromNode(criteria)); } private void assertPivotFactingPresent(SolrQuery solrQuery, String... expected) { Assert.assertArrayEquals(expected, solrQuery.getParams(FacetParams.FACET_PIVOT)); } private void assertFactingPresent(SolrQuery solrQuery, String... expected) { Assert.assertArrayEquals(expected, solrQuery.getFacetFields()); } private void assertFactingNotPresent(SolrQuery solrQuery) { Assert.assertNull(solrQuery.get(FacetParams.FACET_FIELD)); } private void assertQueryStringPresent(SolrQuery solrQuery) { Assert.assertNotNull(solrQuery.get(CommonParams.Q)); } private void assertProjectionNotPresent(SolrQuery solrQuery) { Assert.assertNull(solrQuery.getFields()); } private void assertProjectionPresent(SolrQuery solrQuery, String expected) { Assert.assertNotNull(solrQuery.get(CommonParams.FL)); Assert.assertEquals(expected, solrQuery.get(CommonParams.FL)); } private void assertPaginationNotPresent(SolrQuery solrQuery) { Assert.assertNull(solrQuery.getStart()); Assert.assertNull(solrQuery.getRows()); } private void assertPaginationPresent(SolrQuery solrQuery, int start, int rows) { Assert.assertEquals(Integer.valueOf(start), solrQuery.getStart()); Assert.assertEquals(Integer.valueOf(rows), solrQuery.getRows()); } private void assertGroupingNotPresent(SolrQuery solrQuery) { Assert.assertNull(solrQuery.get(GroupParams.GROUP)); Assert.assertNull(solrQuery.get(GroupParams.GROUP_FIELD)); Assert.assertNull(solrQuery.get(GroupParams.GROUP_MAIN)); } private void assertGroupingPresent(SolrQuery solrQuery, String expected) { Assert.assertNotNull(solrQuery.get(GroupParams.GROUP)); Assert.assertNotNull(solrQuery.get(GroupParams.GROUP_FIELD)); Assert.assertNotNull(solrQuery.get(GroupParams.GROUP_MAIN)); Assert.assertEquals(expected, solrQuery.get(GroupParams.GROUP_FIELD)); } private void assertGroupFormatPresent(SolrQuery solrQuery, boolean groupTotalCount) { Assert.assertEquals("true", solrQuery.get(GroupParams.GROUP)); Assert.assertEquals("false", solrQuery.get(GroupParams.GROUP_MAIN)); Assert.assertEquals("grouped", solrQuery.get(GroupParams.GROUP_FORMAT)); Assert.assertEquals(String.valueOf(groupTotalCount), solrQuery.get(GroupParams.GROUP_TOTAL_COUNT)); } }