Spring/spring-data-gemfire
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SGF-644 - Adapt to API changes in the Pivotal GemFire Lucene Integration and Support based on the Apache Geode 1.2.0 baseline.

Browse Source
This commit is contained in:
John Blum
2017-07-19 14:28:27 -07:00
parent 23d15285fd
commit 9df3028b98
11 changed files with 123 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/test/java/org/springframework/data/gemfire/search/lucene/LuceneAccessorUnitTests.java
View File

@@ -94,7 +94,6 @@ public class LuceneAccessorUnitTests {
@Test
public void afterPropertiesSetInitializesLuceneAccessorProperly() throws Exception {
assertThat(luceneAccessor.getCache()).isNull();
assertThat(luceneAccessor.getLuceneService()).isNull();
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
@@ -122,7 +121,6 @@ public class LuceneAccessorUnitTests {
@Test
public void createLuceneQueryFactory() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
@@ -134,15 +132,13 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithProjectionFields() {
public void createLuceneQueryFactoryWithResultLimit() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
assertThat(luceneAccessor.createLuceneQueryFactory("fieldOne", "fieldTwo"))
.isEqualTo(mockLuceneQueryFactory);
assertThat(luceneAccessor.createLuceneQueryFactory(1000)).isEqualTo(mockLuceneQueryFactory);
verify(luceneAccessor).resolveLuceneService();
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
@@ -153,14 +149,13 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithResultLimitAndProjectionFields() {
public void createLuceneQueryFactoryWithResultLimitAndPageSize() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
assertThat(luceneAccessor.createLuceneQueryFactory(1000))
assertThat(luceneAccessor.createLuceneQueryFactory(1000, 20))
.isEqualTo(mockLuceneQueryFactory);
verify(luceneAccessor).resolveLuceneService();
@@ -171,7 +166,6 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveCacheReturnsConfiguredCache() {
luceneAccessor.setCache(mockCache);
assertThat(luceneAccessor.getCache()).isSameAs(mockCache);
@@ -180,7 +174,6 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceReturnsConfiguredLuceneService() {
luceneAccessor.setLuceneService(mockLuceneService);
assertThat(luceneAccessor.getLuceneService()).isSameAs(mockLuceneService);
@@ -189,7 +182,6 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceLooksUpLuceneService() {
doReturn(mockCache).when(luceneAccessor).resolveCache();
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService(eq(mockCache));
@@ -202,7 +194,6 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceThrowsIllegalArgumentExceptionWhenCacheIsNull() {
exception.expect(IllegalArgumentException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("Cache reference was not properly configured");
@@ -213,7 +204,6 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveIndexNameReturnsConfiguredIndexName() {
luceneAccessor.setIndexName("TestIndex");
assertThat(luceneAccessor.getIndexName()).isEqualTo("TestIndex");
@@ -225,7 +215,6 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveIndexNameReturnsLuceneIndexName() {
luceneAccessor.setLuceneIndex(mockLuceneIndex);
when(mockLuceneIndex.getName()).thenReturn("MockIndex");
@@ -240,7 +229,6 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveIndexNameThrowsIllegalStateExceptionWhenIndexNameIsUnresolvable() {
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
assertThat(luceneAccessor.getLuceneIndex()).isNull();
@@ -253,7 +241,6 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveRegionPathReturnsConfiguredRegionPath() {
luceneAccessor.setRegionPath("/Example");
assertThat(luceneAccessor.getRegionPath()).isEqualTo("/Example");
@@ -263,7 +250,6 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveRegionPathReturnsRegionFullPath() {
when(mockRegion.getFullPath()).thenReturn("/Example");
luceneAccessor.setRegion(mockRegion);
@@ -277,7 +263,6 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveRegionPathThrowsIllegalStatueExceptionWhenRegionPathIsUnresolvable() {
assertThat(luceneAccessor.getRegion()).isNull();
assertThat(luceneAccessor.getRegionPath()).isNullOrEmpty();
@@ -291,7 +276,6 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("unchecked")
public void doFind() throws LuceneQueryException {
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
when(mockQueryExecutor.execute()).thenReturn("test");
@@ -305,7 +289,6 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("unchecked")
public void doFindHandlesLuceneQueryException() throws LuceneQueryException {
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
when(mockQueryExecutor.execute()).thenThrow(new LuceneQueryException("test"));
@@ -326,7 +309,6 @@ public class LuceneAccessorUnitTests {
@Test
public void luceneAccessorInitializedCorrectly() {
luceneAccessor.setCache(mockCache);
luceneAccessor.setIndexName("ExampleIndex");
luceneAccessor.setLuceneIndex(mockLuceneIndex);

53
src/test/java/org/springframework/data/gemfire/search/lucene/LuceneIndexFactoryBeanUnitTests.java
View File

@@ -23,7 +23,6 @@ import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isNull;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
@@ -40,6 +39,7 @@ import java.util.Map;
import org.apache.geode.cache.GemFireCache;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.lucene.LuceneIndex;
import org.apache.geode.cache.lucene.LuceneIndexFactory;
import org.apache.geode.cache.lucene.LuceneService;
import org.apache.lucene.analysis.Analyzer;
import org.junit.Before;
@@ -84,6 +84,9 @@ public class LuceneIndexFactoryBeanUnitTests {
@Mock
private LuceneIndex mockLuceneIndex;
@Mock
private LuceneIndexFactory mockLuceneIndexFactory;
@Mock
private LuceneService mockLuceneService;
@@ -93,8 +96,14 @@ public class LuceneIndexFactoryBeanUnitTests {
private LuceneIndexFactoryBean factoryBean;
@Before
@SuppressWarnings("unchecked")
public void setup() {
factoryBean = spy(new LuceneIndexFactoryBean());
doReturn(mockLuceneService).when(factoryBean).resolveLuceneService(eq(mockCache));
doReturn(mockLuceneIndexFactory).when(mockLuceneService).createIndexFactory();
doReturn(mockLuceneIndexFactory).when(mockLuceneIndexFactory).setFields((String[]) any());
doReturn(mockLuceneIndexFactory).when(mockLuceneIndexFactory).setFields(any(Map.class));
}
@Test
@@ -120,7 +129,7 @@ public class LuceneIndexFactoryBeanUnitTests {
}
@Test
public void afterPropertiesSetThrowsIllegalStateExceptionIndexNameNotSet() throws Exception {
public void afterPropertiesSetThrowsIllegalStateExceptionWhenIndexNameNotSet() throws Exception {
exception.expect(IllegalStateException.class);
exception.expectCause(is(nullValue(Throwable.class)));
exception.expectMessage("indexName was not properly initialized");
@@ -139,8 +148,11 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
assertThat(factoryBean.createLuceneIndex("ExampleIndex", "/Example")).isEqualTo(mockLuceneIndex);
verify(mockLuceneService, times(1))
.createIndex(eq("ExampleIndex"), eq("/Example"), eq(LuceneService.REGION_VALUE_FIELD));
verify(mockLuceneService, times(1)).createIndexFactory();
verify(mockLuceneIndexFactory, times(1))
.setFields(eq(LuceneService.REGION_VALUE_FIELD));
verify(mockLuceneIndexFactory, times(1))
.create(eq("ExampleIndex"), eq("/Example"));
verify(mockLuceneService, times(1))
.getIndex(eq("ExampleIndex"), eq("/Example"));
}
@@ -159,8 +171,10 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
assertThat(factoryBean.createLuceneIndex("ExampleIndex", "/Example")).isEqualTo(mockLuceneIndex);
verify(mockLuceneService, times(1))
.createIndex(eq("ExampleIndex"), eq("/Example"), eq(fieldAnalyzers));
verify(mockLuceneService, times(1)).createIndexFactory();
verify(mockLuceneIndexFactory, times(1)).setFields(eq(fieldAnalyzers));
verify(mockLuceneIndexFactory, times(1))
.create(eq("ExampleIndex"), eq("/Example"));
verify(mockLuceneService, times(1))
.getIndex(eq("ExampleIndex"), eq("/Example"));
}
@@ -177,8 +191,11 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
assertThat(factoryBean.createLuceneIndex("ExampleIndex", "/Example")).isEqualTo(mockLuceneIndex);
verify(mockLuceneService, times(1))
.createIndex(eq("ExampleIndex"), eq("/Example"), eq("fieldOne"), eq("fieldTwo"));
verify(mockLuceneService, times(1)).createIndexFactory();
verify(mockLuceneIndexFactory, times(1))
.setFields(eq("fieldOne"), eq("fieldTwo"));
verify(mockLuceneIndexFactory, times(1))
.create(eq("ExampleIndex"), eq("/Example"));
verify(mockLuceneService, times(1))
.getIndex(eq("ExampleIndex"), eq("/Example"));
}
@@ -193,11 +210,14 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
doReturn(mockLuceneIndex).when(factoryBean).getObject();
doReturn("MockIndex").when(mockLuceneIndex).getName();
doReturn("MockRegion").when(mockLuceneIndex).getRegionPath();
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
verify(mockLuceneService, times(1)).destroyIndex(eq(mockLuceneIndex));
verify(mockLuceneService, times(1))
.destroyIndex(eq("MockIndex"), eq("MockRegion"));
}
@Test
@@ -214,7 +234,7 @@ public class LuceneIndexFactoryBeanUnitTests {
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
verify(mockLuceneService, never()).destroyIndex(any(LuceneIndex.class));
verify(mockLuceneService, never()).destroyIndex(anyString(), anyString());
}
@Test
@@ -231,7 +251,7 @@ public class LuceneIndexFactoryBeanUnitTests {
factoryBean.destroy();
verify(factoryBean, times(1)).getObject();
verify(mockLuceneService, never()).destroyIndex(isNull(LuceneIndex.class));
verify(mockLuceneService, never()).destroyIndex(anyString(), anyString());
}
@Test
@@ -345,6 +365,17 @@ public class LuceneIndexFactoryBeanUnitTests {
.isEqualTo(Collections.singletonList(LuceneService.REGION_VALUE_FIELD));
}
@Test
public void resolveLuceneIndexFactoryCallsLuceneServiceCreateIndexFactory() {
factoryBean.setCache(mockCache);
doReturn(mockLuceneIndexFactory).when(mockLuceneService).createIndexFactory();
assertThat(factoryBean.resolveLuceneIndexFactory()).isEqualTo(mockLuceneIndexFactory);
verify(mockLuceneService, times(1)).createIndexFactory();
}
@Test
public void resolveLuceneServiceReturnsConfiguredLuceneService() {
factoryBean.setBeanFactory(mockBeanFactory);

12
src/test/java/org/springframework/data/gemfire/search/lucene/LuceneOperationsIntegrationTests.java
View File

@@ -25,7 +25,6 @@ import java.time.Month;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;
@@ -73,9 +72,6 @@ public class LuceneOperationsIntegrationTests {
private static final AtomicLong IDENTIFIER = new AtomicLong(0L);
private static final int LUCENE_INDEX_WAIT_UNTIL_FLUSHED_TIMEOUT =
Long.valueOf(TimeUnit.SECONDS.toMillis(15L)).intValue();
protected static final String LOG_LEVEL = "none";
private Person jonDoe;
@@ -115,8 +111,12 @@ public class LuceneOperationsIntegrationTests {
}
protected void flushLuceneIndex() {
Optional.ofNullable(this.luceneService.getIndex("PersonTitleIndex", "/People"))
.ifPresent(luceneIndex -> luceneIndex.waitUntilFlushed(LUCENE_INDEX_WAIT_UNTIL_FLUSHED_TIMEOUT));
try {
this.luceneService.waitUntilFlushed("PersonTitleIndex", "/People",
15L, TimeUnit.SECONDS);
}
catch (Throwable ignore) {
}
}
private List<String> asNames(List<? extends Nameable> nameables) {

22
src/test/java/org/springframework/data/gemfire/search/lucene/LuceneOperationsUnitTests.java
View File

@@ -19,7 +19,6 @@ package org.springframework.data.gemfire.search.lucene;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.anyVararg;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
@@ -54,24 +53,23 @@ public class LuceneOperationsUnitTests {
@Test
public void stringQueryCallsQueryWithResultLimit() {
when(mockLuceneOperations.query(anyString(), anyString(), anyVararg())).thenCallRealMethod();
when(mockLuceneOperations.query(anyString(), anyString())).thenCallRealMethod();
mockLuceneOperations.query("title : Up Shit Creek Without a Paddle", "title",
"content");
mockLuceneOperations.query("title : Up Shit Creek Without a Paddle", "title");
verify(mockLuceneOperations, times(1)).query(
eq("title : Up Shit Creek Without a Paddle"), eq("title"),
eq(LuceneOperations.DEFAULT_RESULT_LIMIT), eq("content"));
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
}
@Test
public void queryProviderQueryCallsQueryWithResultLimit() {
when(mockLuceneOperations.query(any(LuceneQueryProvider.class), anyVararg())).thenCallRealMethod();
when(mockLuceneOperations.query(any(LuceneQueryProvider.class))).thenCallRealMethod();
mockLuceneOperations.query(mockLuceneQueryProvider, "content");
mockLuceneOperations.query(mockLuceneQueryProvider);
verify(mockLuceneOperations, times(1)).query(eq(mockLuceneQueryProvider),
eq(LuceneOperations.DEFAULT_RESULT_LIMIT), eq("content"));
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
}
@Test
@@ -82,7 +80,7 @@ public class LuceneOperationsUnitTests {
verify(mockLuceneOperations, times(1)).queryForKeys(
eq("title : Up Shit Creek Without a Paddle"), eq("title"),
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
}
@Test
@@ -103,7 +101,7 @@ public class LuceneOperationsUnitTests {
verify(mockLuceneOperations, times(1)).queryForValues(
eq("title : Up Shit Creek Without a Paddle"), eq("title"),
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
}
@Test
@@ -116,6 +114,6 @@ public class LuceneOperationsUnitTests {
eq(mockLuceneQueryProvider), eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
}
abstract class TestLuceneOperations implements LuceneOperations {
}
abstract class TestLuceneOperations implements LuceneOperations { }
}

24
src/test/java/org/springframework/data/gemfire/search/lucene/LuceneTemplateUnitTests.java
View File

@@ -62,6 +62,7 @@ import org.mockito.junit.MockitoJUnitRunner;
* @see org.apache.geode.cache.lucene.LuceneQueryFactory
* @see org.apache.geode.cache.lucene.LuceneQueryProvider
* @see org.apache.geode.cache.lucene.LuceneResultStruct
* @see org.apache.geode.cache.lucene.LuceneService
* @see org.apache.geode.cache.lucene.PageableLuceneQueryResults
* @since 1.0.0
*/
@@ -95,18 +96,16 @@ public class LuceneTemplateUnitTests {
@Before
@SuppressWarnings("deprecation")
public void setup() {
luceneTemplate.setLuceneService(mockLuceneService);
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
}
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void stringQueryReturnsList() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"), anyString(), anyString()))
.thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findResults()).thenReturn(asList(mockLuceneResultStructOne, mockLuceneResultStructTwo));
@@ -115,8 +114,7 @@ public class LuceneTemplateUnitTests {
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
List<LuceneResultStruct<Object, Object>> results = luceneTemplate.query(
"title : Up Shit Creek Without a Paddle", "title", 100,
"content");
"title : Up Shit Creek Without a Paddle", "title", 100);
assertThat(results).isNotNull();
assertThat(results).hasSize(2);
@@ -137,7 +135,6 @@ public class LuceneTemplateUnitTests {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void stringQueryWithPageSizeReturnsPageableResults() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"), anyString(), anyString()))
.thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findPages()).thenReturn(mockPageableLuceneQueryResults);
@@ -146,8 +143,7 @@ public class LuceneTemplateUnitTests {
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
PageableLuceneQueryResults<Object, Object> results = luceneTemplate.query(
"title : Up Shit Creek Without a Paddle", "title", 100, 20,
"content");
"title : Up Shit Creek Without a Paddle", "title", 100, 20);
assertThat(results).isSameAs(mockPageableLuceneQueryResults);
@@ -166,7 +162,6 @@ public class LuceneTemplateUnitTests {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void queryProviderQueryReturnsList() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"),
any(LuceneQueryProvider.class))).thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findResults()).thenReturn(asList(mockLuceneResultStructOne, mockLuceneResultStructTwo));
@@ -174,8 +169,8 @@ public class LuceneTemplateUnitTests {
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
List<LuceneResultStruct<Object, Object>> results = luceneTemplate.query(mockLuceneQueryProvider,
100, "content");
List<LuceneResultStruct<Object, Object>> results =
luceneTemplate.query(mockLuceneQueryProvider, 100);
assertThat(results).isNotNull();
assertThat(results).hasSize(2);
@@ -196,7 +191,6 @@ public class LuceneTemplateUnitTests {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void queryProviderQueryWithPageSizeReturnsPageableResults() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"),
any(LuceneQueryProvider.class))).thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findPages()).thenReturn(mockPageableLuceneQueryResults);
@@ -205,7 +199,7 @@ public class LuceneTemplateUnitTests {
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
PageableLuceneQueryResults<Object, Object> results = luceneTemplate.query(mockLuceneQueryProvider,
100, 20, "content");
100, 20);
assertThat(results).isSameAs(mockPageableLuceneQueryResults);
@@ -224,7 +218,6 @@ public class LuceneTemplateUnitTests {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void stringQueryForKeysReturnsKeys() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"), anyString(), anyString()))
.thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findKeys()).thenReturn(asList("keyOne", "keyTwo"));
@@ -254,7 +247,6 @@ public class LuceneTemplateUnitTests {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void queryProviderQueryForKeysReturnsKeys() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"),
any(LuceneQueryProvider.class))).thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findKeys()).thenReturn(asList("keyOne", "keyTwo"));
@@ -283,7 +275,6 @@ public class LuceneTemplateUnitTests {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void stringQueryForValuesReturnsValues() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"), anyString(), anyString()))
.thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findValues()).thenReturn(asList("valueOne", "valueTwo"));
@@ -313,7 +304,6 @@ public class LuceneTemplateUnitTests {
@Test
@SuppressWarnings({ "deprecation", "unchecked" })
public void queryProviderQueryForValuesReturnsValues() throws LuceneQueryException {
when(mockLuceneQueryFactory.create(eq("TestIndex"), eq("/Example"),
any(LuceneQueryProvider.class))).thenReturn(mockLuceneQuery);
when(mockLuceneQuery.findValues()).thenReturn(asList("valueOne", "valueTwo"));