package com.sematext.solr.redis; import org.apache.lucene.analysis.core.WhitespaceAnalyzer; import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.index.Term; import org.apache.lucene.search.Query; import org.apache.solr.common.params.SolrParams; import org.apache.solr.request.SolrQueryRequest; import org.apache.solr.schema.IndexSchema; import org.apache.solr.search.QParser; import org.apache.solr.search.QueryParsing; import org.apache.solr.search.SyntaxError; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.ArgumentCaptor; import org.mockito.Mock; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.SortingParams; import redis.clients.jedis.Tuple; import redis.clients.jedis.exceptions.JedisException; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.util.*; import java.util.zip.GZIPOutputStream; import org.apache.lucene.index.MultiReader; import org.apache.lucene.queries.TermsQuery; import org.apache.lucene.search.ConstantScoreQuery; import org.apache.lucene.search.IndexSearcher; import static org.junit.Assert.assertTrue; import static org.mockito.Matchers.*; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static org.mockito.MockitoAnnotations.initMocks; public class TestRedisQParser { private QParser redisQParser; @Mock private SolrParams localParamsMock; @Mock private SolrParams paramsMock; @Mock private SolrQueryRequest requestMock; @Mock private IndexSchema schema; @Mock private JedisPool jedisPoolMock; @Mock private Jedis jedisMock; @Mock private Jedis jedisFailingMock; private CommandHandler commandHandler; @Before public void setUp() { initMocks(this); when(jedisPoolMock.getResource()).thenReturn(jedisMock); commandHandler = new RetryingCommandHandler(jedisPoolMock, 1); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionOnMissingCommand() { when(localParamsMock.get(anyString())).thenReturn(null); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionOnMissingKey() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("smembers"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); } @Test public void shouldQueryRedisOnSmembersCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("smembers"); when(localParamsMock.get("key")).thenReturn("simpleKey"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).smembers("simpleKey"); } @Test public void shouldAddTermsFromRedisOnSmembersCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("smembers"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.smembers(anyString())).thenReturn(new HashSet<>(Arrays.asList("123", "321"))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).smembers("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfSmembers() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("smembers"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.smembers(anyString())).thenReturn(new HashSet<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).smembers("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnSrandmemberCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("srandmember"); when(localParamsMock.get("key")).thenReturn("simpleKey"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).srandmember("simpleKey", 1); } @Test public void shouldAddMultipleTermsFromRedisOnSrandmemberCommandWithExplicitCount() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("srandmember"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("count")).thenReturn("2"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.srandmember(anyString(), anyInt())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).srandmember("simpleKey", 2); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddMultipleTermsFromRedisOnSrandmemberCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("srandmember"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.srandmember(anyString(), anyInt())).thenReturn(Collections.singletonList("123")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).srandmember("simpleKey", 1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfSrandmember() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("srandmember"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.srandmember(anyString(), anyInt())).thenReturn(new ArrayList<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).srandmember("simpleKey", 1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnSinterCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("sinter"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("keyfoo")).thenReturn("key3"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.get("keyempty")).thenReturn(""); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1", "keyfoo", "keyempty").iterator()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).sinter("key1", "key2", "key3"); } @Test public void shouldAddTermsFromRedisOnSinterCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sinter"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sinter(anyString(), anyString())).thenReturn(new HashSet<>(Arrays.asList("123", "321"))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).sinter("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfSinter() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sinter"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sinter(anyString(), anyString())).thenReturn(new HashSet<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).sinter("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnKeysCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("keys"); when(localParamsMock.get("key")).thenReturn("pattern"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).keys("pattern"); } @Test public void shouldAddTermsFromRedisOnKeysCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("keys"); when(localParamsMock.get("key")).thenReturn("pattern"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.keys(anyString())).thenReturn(new HashSet<>(Arrays.asList("123", "321"))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).keys("pattern"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfKeys() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("keys"); when(localParamsMock.get("key")).thenReturn("pattern"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sdiff(anyString(), anyString())).thenReturn(new HashSet<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).keys("pattern"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnSdiffCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("sdiff"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("keyfoo")).thenReturn("key3"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.get("keyempty")).thenReturn(""); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1", "keyfoo", "keyempty").iterator()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).sdiff("key1", "key2", "key3"); } @Test public void shouldAddTermsFromRedisOnSdiffCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sdiff"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sdiff(anyString(), anyString())).thenReturn(new HashSet<>(Arrays.asList("123", "321"))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).sdiff("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfSdiff() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sdiff"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sdiff(anyString(), anyString())).thenReturn(new HashSet<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).sdiff("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnSunionCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("sunion"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("keyfoo")).thenReturn("key3"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.get("keyempty")).thenReturn(""); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1", "keyfoo", "keyempty").iterator()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).sunion("key1", "key2", "key3"); } @Test public void shouldAddTermsFromRedisOnSunionCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sunion"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sunion(anyString(), anyString())).thenReturn(new HashSet<>(Arrays.asList("123", "321"))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).sunion("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfSunion() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sunion"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sunion(anyString(), anyString())).thenReturn(new HashSet<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).sunion("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnHvalsCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("hvals"); when(localParamsMock.get("key")).thenReturn("simpleKey"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).hvals("simpleKey"); } @Test public void shouldAddTermsFromRedisOnHvalsCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hvals"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hvals(anyString())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hvals("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfHvals() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hvals"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hvals(anyString())).thenReturn(new ArrayList<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hvals("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnHkeysCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("hkeys"); when(localParamsMock.get("key")).thenReturn("simpleKey"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).hkeys("simpleKey"); } @Test public void shouldAddTermsFromRedisOnHkeysCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hkeys"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hkeys(anyString())).thenReturn(new HashSet<>(Arrays.asList("123", "321"))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hkeys("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfHkeys() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hkeys"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hkeys(anyString())).thenReturn(new HashSet<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hkeys("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnHgetCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("hget"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("field")).thenReturn("f1"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).hget("simpleKey", "f1"); } @Test(expected = IllegalArgumentException.class) public void shouldThrowExceptionIfFieldIsMissing() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("hget"); when(localParamsMock.get("key")).thenReturn("simpleKey"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).hget("simpleKey", "f1"); } @Test public void shouldAddTermsFromRedisOnHgetCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hget"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("field")).thenReturn("f1"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hget(anyString(), anyString())).thenReturn("123"); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hget("simpleKey", "f1"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfHget() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hget"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("field")).thenReturn("f1"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hget(anyString(), anyString())).thenReturn(null); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hget("simpleKey", "f1"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnHmgetCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("hmget"); when(localParamsMock.get("key")).thenReturn("hash"); when(localParamsMock.get("fieldfoo")).thenReturn("field2"); when(localParamsMock.get("field1")).thenReturn("field1"); when(localParamsMock.get("field")).thenReturn("field3"); when(localParamsMock.get("fieldempty")).thenReturn(""); when(localParamsMock.getParameterNamesIterator()).thenReturn( Arrays.asList("command", "key", "field1", "fieldfoo", "fieldempty", "field").iterator()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).hmget("hash", "field1", "field2", "field3"); } @Test public void shouldAddTermsFromRedisOnHmgetCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hmget"); when(localParamsMock.get("key")).thenReturn("hash"); when(localParamsMock.get("field")).thenReturn("field1"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "field").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hmget(anyString(), anyString())).thenReturn(Arrays.asList("123")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hmget("hash", "field1"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfHmget() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("hmget"); when(localParamsMock.get("key")).thenReturn("hash"); when(localParamsMock.get("field")).thenReturn("field1"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "field").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.hmget(anyString(), anyString())).thenReturn(new ArrayList<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).hmget("hash", "field1"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnGetCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("get"); when(localParamsMock.get("key")).thenReturn("simpleKey"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).get("simpleKey".getBytes()); } @Test public void shouldAddTermsFromRedisOnGetCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("get"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.get(any(byte[].class))).thenReturn("val".getBytes()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).get("simpleKey".getBytes()); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldParseJsonTermsFromRedisOnGetCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("get"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("serialization")).thenReturn("json"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.get(any(byte[].class))).thenReturn("[1,2,3]".getBytes()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).get("simpleKey".getBytes()); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(3, terms.size()); } @Test public void shouldDeflateGzipTermsFromRedisOnGetCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("get"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("compression")).thenReturn("gzip"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.get(any(byte[].class))).thenReturn(Compressor.compressGzip("1".getBytes())); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).get("simpleKey".getBytes()); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldDeflateGzipAndParseJsonTermsFromRedisOnGetCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("get"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("compression")).thenReturn("gzip"); when(localParamsMock.get("serialization")).thenReturn("json"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.get(any(byte[].class))).thenReturn(Compressor.compressGzip("[100,200,300]".getBytes())); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).get("simpleKey".getBytes()); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(3, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyResultOfGet() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("get"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.get(anyString())).thenReturn(null); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).get("simpleKey".getBytes()); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldAddTermsFromRedisOnLindexCommandDefault0() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lindex"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lindex(anyString(), anyLong())).thenReturn("value"); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lindex("simpleKey", 0); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldAddTermsFromRedisOnLindexCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lindex"); when(localParamsMock.get("index")).thenReturn("10"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lindex(anyString(), anyLong())).thenReturn("value"); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lindex("simpleKey", 10); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyResultOfLindex() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lindex"); when(localParamsMock.get("index")).thenReturn("10"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lindex(anyString(), anyLong())).thenReturn(null); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lindex("simpleKey", 10); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnMgetCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("mget"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("keyfoo")).thenReturn("key3"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.get("keyempty")).thenReturn(""); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1", "keyfoo", "keyempty").iterator()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).mget("key1", "key2", "key3"); } @Test public void shouldAddTermsFromRedisOnMgetCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("mget"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.mget(anyString(), anyString())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).mget("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfMget() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("mget"); when(localParamsMock.get("key")).thenReturn("key1"); when(localParamsMock.get("key1")).thenReturn("key2"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "key1").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.mget(anyString(), anyString())).thenReturn(new ArrayList<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).mget("key1", "key2"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldQueryRedisOnLrangeCommand() throws SyntaxError { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("key")).thenReturn("simpleKey"); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 0, -1); } @Test public void shouldAddTermsFromRedisOnLrangeCommand() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 0, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnLrangeCommandCustomMin() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("min")).thenReturn("-1"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", -1, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnLrangeCommandCustomMax() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("max")).thenReturn("1"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 0, 1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnLrangeCommandCustomMinAndMax() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("min")).thenReturn("2"); when(localParamsMock.get("max")).thenReturn("3"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 2, 3); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnLrangeCommandInvalidMinAndMaxFallsBackToDefault() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("min")).thenReturn("-foo"); when(localParamsMock.get("min")).thenReturn("-bar"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 0, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnLrangeCommandEmptyStringMinAndMaxFallsBackToDefault() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("min")).thenReturn(" "); when(localParamsMock.get("min")).thenReturn(" "); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 0, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnLrangeCommandEmptyMinAndMaxFallsBackToDefault() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("min")).thenReturn(""); when(localParamsMock.get("max")).thenReturn(""); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 0, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyListOfLrange() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("lrange"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.lrange(anyString(), anyLong(), anyLong())).thenReturn(new ArrayList<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).lrange("simpleKey", 0, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldReturnEmptyQueryOnEmptyResultOfSort() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(new ArrayList<String>()); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams()), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(0, terms.size()); } @Test public void shouldAddTermsFromSort() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams()), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortAlgorithmAlpha() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("algorithm")).thenReturn("alpha"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().alpha()), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortOrderAsc() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("order")).thenReturn("asc"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().asc()), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortOrderDesc() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("order")).thenReturn("desc"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().desc()), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortLimit() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("limit")).thenReturn("100"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().limit(0, 100)), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortOffset() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("offset")).thenReturn("100"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().limit(100, 0)), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortLimitAndOffset() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("offset")).thenReturn("100"); when(localParamsMock.get("limit")).thenReturn("1000"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().limit(100, 1000)), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortWithByClause() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("by")).thenReturn("foo_*"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().by("foo_*")), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromSortWithSingleGetClause() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("sort"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("get")).thenReturn("get_*"); when(localParamsMock.getParameterNamesIterator()).thenReturn(Arrays.asList("command", "key", "get").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.sort(anyString(), any(SortingParams.class))).thenReturn(Arrays.asList("123", "321")); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); final ArgumentCaptor<SortingParams> argument = ArgumentCaptor.forClass(SortingParams.class); verify(jedisMock).sort(eq("simpleKey"), argument.capture()); Assert.assertEquals(getSortingParamString(new SortingParams().get("get_*")), getSortingParamString(argument.getValue())); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrevrangeCommandWithDefaultParams() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrevrange"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrevrangeWithScores(anyString(), anyLong(), anyLong())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrevrangeWithScores("simpleKey", 0, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrevrangeCommandWithCustomRange() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrevrange"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("range_start")).thenReturn("1"); when(localParamsMock.get("range_end")).thenReturn("100"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrevrangeWithScores(anyString(), anyLong(), anyLong())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrevrangeWithScores("simpleKey", 1, 100); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrangeCommandWithDefaultParams() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrange"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrangeWithScores(anyString(), anyLong(), anyLong())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrangeWithScores("simpleKey", 0, -1); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrangeCommandWithCustomRange() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrange"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("range_start")).thenReturn("1"); when(localParamsMock.get("range_end")).thenReturn("100"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrangeWithScores(anyString(), anyLong(), anyLong())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrangeWithScores("simpleKey", 1, 100); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrevrangebyscoreCommandWithDefaultParams() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrevrangebyscore"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrevrangeByScoreWithScores(anyString(), anyString(), anyString())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrevrangeByScoreWithScores("simpleKey", "+inf", "-inf"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrevrangebyscoreCommandWithCustomRange() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrevrangebyscore"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("min")).thenReturn("1"); when(localParamsMock.get("max")).thenReturn("100"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrevrangeByScoreWithScores(anyString(), anyString(), anyString())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrevrangeByScoreWithScores("simpleKey", "100", "1"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrangebyscoreCommandWithDefaultParams() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrangebyscore"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrangeByScoreWithScores(anyString(), anyString(), anyString())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrangeByScoreWithScores("simpleKey", "-inf", "+inf"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnZrangebyscoreCommandWithCustomRange() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("zrangebyscore"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("min")).thenReturn("1"); when(localParamsMock.get("max")).thenReturn("100"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.zrangeByScoreWithScores(anyString(), anyString(), anyString())) .thenReturn(new HashSet<>(Arrays.asList(new Tuple("123", (double) 1.0f), new Tuple("321", (double) 1.0f)))); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).zrangeByScoreWithScores("simpleKey", "1", "100"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldAddTermsFromRedisOnEval() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("eval"); when(localParamsMock.get("script")).thenReturn("return 1;"); when(localParamsMock.get("key")).thenReturn("k"); when(localParamsMock.get("arg")).thenReturn("a"); when(localParamsMock.getParameterNamesIterator()) .thenReturn( Arrays.asList("command", "script", "key", "arg").iterator(), Arrays.asList("command", "script", "key", "arg").iterator()); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.eval(anyString(), anyInt(), (String) anyVararg())).thenReturn(1); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new StandardAnalyzer()); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).eval("return 1;", 1, "k", "a"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldTurnAnalysisOff() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("smembers"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("useAnalyzer")).thenReturn("false"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(jedisMock.smembers(anyString())).thenReturn(new HashSet<>(Arrays.asList("123 124", "321"))); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).smembers("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(2, terms.size()); } @Test public void shouldTurnAnalysisOn() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("smembers"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.getBool("useAnalyzer", false)).thenReturn(true); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new WhitespaceAnalyzer()); when(jedisMock.smembers(anyString())).thenReturn(new HashSet<>(Arrays.asList("123 124", "321"))); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).smembers("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(3, terms.size()); } @Test public void shouldRetryWhenRedisFailed() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("smembers"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.getBool("useAnalyzer", false)).thenReturn(false); when(localParamsMock.get("retries")).thenReturn("2"); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new WhitespaceAnalyzer()); when(jedisPoolMock.getResource()).thenReturn(jedisFailingMock).thenReturn(jedisMock); when(jedisFailingMock.smembers("simpleKey")).thenThrow(new JedisException("Synthetic exception")); when(jedisMock.smembers("simpleKey")).thenReturn(new HashSet<String>(Collections.singletonList("value"))); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, new RetryingCommandHandler(jedisPoolMock, 1)); final Query query = redisQParser.parse(); IndexSearcher searcher = new IndexSearcher(new MultiReader()); final Set<Term> terms = extractTerms(searcher, query); Assert.assertEquals(1, terms.size()); } @Test public void shouldUseTermsQuery() throws SyntaxError, IOException { when(localParamsMock.get("command")).thenReturn("smembers"); when(localParamsMock.get("key")).thenReturn("simpleKey"); when(localParamsMock.get("ignoreScore")).thenReturn("true"); when(localParamsMock.getBool("useAnalyzer", false)).thenReturn(true); when(localParamsMock.get(QueryParsing.V)).thenReturn("string_field"); when(requestMock.getSchema()).thenReturn(schema); when(schema.getQueryAnalyzer()).thenReturn(new WhitespaceAnalyzer()); when(jedisMock.smembers(anyString())).thenReturn(new HashSet<>(Arrays.asList("123 124", "321", "322", "323", "324", "325", "326", "327", "328", "329", "330", "331", "332", "333", "334", "335", "336", "337", "338"))); redisQParser = new RedisQParser("string_field", localParamsMock, paramsMock, requestMock, commandHandler); final Query query = redisQParser.parse(); verify(jedisMock).smembers("simpleKey"); IndexSearcher searcher = new IndexSearcher(new MultiReader()); Query rewrittenQuery = searcher.rewrite(query); assertTrue(rewrittenQuery instanceof TermsQuery); } private static String getSortingParamString(final SortingParams params) { final StringBuilder builder = new StringBuilder(); for (final byte[] param: params.getParams()) { builder.append(new String(param)); builder.append(" "); } return builder.toString().trim(); } private static Set<Term> extractTerms(IndexSearcher searcher, Query query) throws IOException { final Set<Term> terms = new HashSet<>(); Query rewrittenQuery = searcher.rewrite(query); if (rewrittenQuery instanceof ConstantScoreQuery) { ConstantScoreQuery constantScoreQuery = (ConstantScoreQuery)rewrittenQuery; rewrittenQuery = constantScoreQuery.getQuery(); } searcher.createNormalizedWeight(rewrittenQuery, true).extractTerms(terms); return terms; } } final class Compressor { public static byte[] compressGzip(final byte[] input) { final byte[] compressed; try { try ( ByteArrayOutputStream output = new ByteArrayOutputStream(input.length); ) { try ( GZIPOutputStream stream = new GZIPOutputStream(output); ) { stream.write(input); } compressed = output.toByteArray(); } return compressed; } catch (final IOException e) { return null; } } }