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

DATAGEODE-10 - Adapt to API changes in the org.apache.geode.cache.lucene.LuceneQueryFactory interface.

Browse Source 
(cherry picked from commit 78d1717381e167827fec4b9e9c1e3c938858617a)
Signed-off-by: John Blum <jblum@pivotal.io>
This commit is contained in:
John Blum
2017-05-14 16:54:55 -07:00
parent 7659ba18fb
commit 23d15285fd
3 changed files with 47 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -23,7 +23,6 @@ import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.isA;
import static org.hamcrest.Matchers.nullValue;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyVararg;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
@@ -95,6 +94,7 @@ public class LuceneAccessorUnitTests {
@Test
public void afterPropertiesSetInitializesLuceneAccessorProperly() throws Exception {
assertThat(luceneAccessor.getCache()).isNull();
assertThat(luceneAccessor.getLuceneService()).isNull();
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
@@ -122,6 +122,7 @@ public class LuceneAccessorUnitTests {
@Test
public void createLuceneQueryFactory() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
@@ -134,68 +135,43 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithProjectionFields() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setProjectionFields(anyVararg())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setResultLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
assertThat(luceneAccessor.createLuceneQueryFactory("fieldOne", "fieldTwo"))
.isEqualTo(mockLuceneQueryFactory);
verify(luceneAccessor).resolveLuceneService();
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1))
.setResultLimit(eq(LuceneAccessor.DEFAULT_RESULT_LIMIT));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(1000));
verify(mockLuceneQueryFactory, times(1))
.setPageSize(eq(LuceneAccessor.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1))
.setProjectionFields(eq("fieldOne"), eq("fieldTwo"));
}
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithResultLimitAndProjectionFields() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setProjectionFields(anyVararg())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setResultLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
assertThat(luceneAccessor.createLuceneQueryFactory(1000, "fieldOne", "fieldTwo"))
assertThat(luceneAccessor.createLuceneQueryFactory(1000))
.isEqualTo(mockLuceneQueryFactory);
verify(luceneAccessor).resolveLuceneService();
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(1000));
verify(mockLuceneQueryFactory, times(1))
.setPageSize(eq(LuceneAccessor.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1))
.setProjectionFields(eq("fieldOne"), eq("fieldTwo"));
}
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithResultLimitPageSizeAndProjectionFields() {
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setProjectionFields(anyVararg())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setResultLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
assertThat(luceneAccessor.createLuceneQueryFactory(1000, 20,
"fieldOne", "fieldTwo")).isEqualTo(mockLuceneQueryFactory);
verify(luceneAccessor).resolveLuceneService();
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(1000));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(1000));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(20));
verify(mockLuceneQueryFactory, times(1))
.setProjectionFields(eq("fieldOne"), eq("fieldTwo"));
}
@Test
public void resolveCacheReturnsConfiguredCache() {
luceneAccessor.setCache(mockCache);
assertThat(luceneAccessor.getCache()).isSameAs(mockCache);
@@ -204,6 +180,7 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceReturnsConfiguredLuceneService() {
luceneAccessor.setLuceneService(mockLuceneService);
assertThat(luceneAccessor.getLuceneService()).isSameAs(mockLuceneService);
@@ -212,6 +189,7 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveLuceneServiceLooksUpLuceneService() {
doReturn(mockCache).when(luceneAccessor).resolveCache();
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService(eq(mockCache));
@@ -224,6 +202,7 @@ 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");
@@ -234,6 +213,7 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveIndexNameReturnsConfiguredIndexName() {
luceneAccessor.setIndexName("TestIndex");
assertThat(luceneAccessor.getIndexName()).isEqualTo("TestIndex");
@@ -245,6 +225,7 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveIndexNameReturnsLuceneIndexName() {
luceneAccessor.setLuceneIndex(mockLuceneIndex);
when(mockLuceneIndex.getName()).thenReturn("MockIndex");
@@ -259,6 +240,7 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveIndexNameThrowsIllegalStateExceptionWhenIndexNameIsUnresolvable() {
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
assertThat(luceneAccessor.getLuceneIndex()).isNull();
@@ -271,6 +253,7 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveRegionPathReturnsConfiguredRegionPath() {
luceneAccessor.setRegionPath("/Example");
assertThat(luceneAccessor.getRegionPath()).isEqualTo("/Example");
@@ -280,6 +263,7 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("all")
public void resolveRegionPathReturnsRegionFullPath() {
when(mockRegion.getFullPath()).thenReturn("/Example");
luceneAccessor.setRegion(mockRegion);
@@ -293,6 +277,7 @@ public class LuceneAccessorUnitTests {
@Test
public void resolveRegionPathThrowsIllegalStatueExceptionWhenRegionPathIsUnresolvable() {
assertThat(luceneAccessor.getRegion()).isNull();
assertThat(luceneAccessor.getRegionPath()).isNullOrEmpty();
@@ -306,6 +291,7 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("unchecked")
public void doFind() throws LuceneQueryException {
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
when(mockQueryExecutor.execute()).thenReturn("test");
@@ -319,6 +305,7 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("unchecked")
public void doFindHandlesLuceneQueryException() throws LuceneQueryException {
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
when(mockQueryExecutor.execute()).thenThrow(new LuceneQueryException("test"));
@@ -339,6 +326,7 @@ public class LuceneAccessorUnitTests {
@Test
public void luceneAccessorInitializedCorrectly() {
luceneAccessor.setCache(mockCache);
luceneAccessor.setIndexName("ExampleIndex");
luceneAccessor.setLuceneIndex(mockLuceneIndex);

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

@@ -95,17 +95,18 @@ 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.setProjectionFields(any())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setResultLimit(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));
@@ -126,9 +127,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq("title : Up Shit Creek Without a Paddle"), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(LuceneOperations.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields(eq("content"));
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq("title : Up Shit Creek Without a Paddle"), eq("title"));
verify(mockLuceneQuery, times(1)).findResults();
@@ -137,6 +137,7 @@ 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);
@@ -155,9 +156,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq("title : Up Shit Creek Without a Paddle"), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(20));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields(eq("content"));
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq("title : Up Shit Creek Without a Paddle"), eq("title"));
verify(mockLuceneQuery, times(1)).findPages();
@@ -166,6 +166,7 @@ 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));
@@ -185,9 +186,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq(mockLuceneQueryProvider), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(LuceneOperations.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields(eq("content"));
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq(mockLuceneQueryProvider));
verify(mockLuceneQuery, times(1)).findResults();
@@ -196,6 +196,7 @@ 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);
@@ -213,9 +214,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq(mockLuceneQueryProvider), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(20));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields(eq("content"));
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq(mockLuceneQueryProvider));
verify(mockLuceneQuery, times(1)).findPages();
@@ -224,6 +224,7 @@ 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"));
@@ -243,9 +244,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq("title : Up Shit Creek Without a Paddle"), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(LuceneOperations.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields();
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq("title : Up Shit Creek Without a Paddle"), eq("title"));
verify(mockLuceneQuery, times(1)).findKeys();
@@ -254,6 +254,7 @@ 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"));
@@ -272,9 +273,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq(mockLuceneQueryProvider), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(LuceneOperations.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields();
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq(mockLuceneQueryProvider));
verify(mockLuceneQuery, times(1)).findKeys();
@@ -283,6 +283,7 @@ 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"));
@@ -302,9 +303,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq("title : Up Shit Creek Without a Paddle"), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(LuceneOperations.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields();
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq("title : Up Shit Creek Without a Paddle"), eq("title"));
verify(mockLuceneQuery, times(1)).findValues();
@@ -313,6 +313,7 @@ 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"));
@@ -331,9 +332,8 @@ public class LuceneTemplateUnitTests {
verify(luceneTemplate, times(1)).doFind(isA(LuceneQueryExecutor.class),
eq(mockLuceneQueryProvider), eq("/Example"), eq("TestIndex"));
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setLimit(eq(100));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(LuceneOperations.DEFAULT_PAGE_SIZE));
verify(mockLuceneQueryFactory, times(1)).setProjectionFields();
verify(mockLuceneQueryFactory, times(1)).create(eq("TestIndex"),
eq("/Example"), eq(mockLuceneQueryProvider));
verify(mockLuceneQuery, times(1)).findValues();