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

SGF-609 - Upgrade to Apache Geode 1.2.0-SNAPSHOT.

Browse Source 
Adapt to API changes in the Apache Geode Lucene integration after 1.2.0-SNAPSHOT.

Set version to 1.2.0.BUILD-SNAPSHOT.
This commit is contained in:
John Blum
2017-03-31 14:55:25 -07:00
parent d7f11b93c9
commit a6b3569b67
16 changed files with 143 additions and 180 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/test/java/org/springframework/data/gemfire/config/annotation/EnableIndexingConfigurationUnitTests.java
View File

@@ -22,6 +22,7 @@ import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -36,12 +37,12 @@ import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.RegionFactory;
import org.apache.geode.cache.RegionShortcut;
import org.apache.geode.cache.lucene.LuceneIndex;
import org.apache.geode.cache.lucene.LuceneIndexFactory;
import org.apache.geode.cache.lucene.LuceneService;
import org.apache.geode.cache.query.Index;
import org.apache.geode.cache.query.QueryService;
import org.junit.After;
import org.junit.Test;
import org.mockito.Matchers;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.springframework.context.ConfigurableApplicationContext;
@@ -208,6 +209,10 @@ public class EnableIndexingConfigurationUnitTests {
LuceneService luceneService() {
LuceneService mockLuceneService = mock(LuceneService.class);
LuceneIndexFactory mockLuceneIndexFactory = mock(LuceneIndexFactory.class);
doReturn(mockLuceneIndexFactory).when(mockLuceneService).createIndexFactory();
doAnswer(invocation -> {
LuceneIndex mockLuceneIndex = mock(LuceneIndex.class);
@@ -220,7 +225,7 @@ public class EnableIndexingConfigurationUnitTests {
when(mockLuceneService.getIndex(eq(indexName), eq(regionPath))).thenReturn(mockLuceneIndex);
return mockLuceneIndex;
}).when(mockLuceneService).createIndex(anyString(), anyString(), Matchers.<String[]>anyVararg());
}).when(mockLuceneIndexFactory).create(anyString(), anyString());
return mockLuceneService;
}

33
src/test/java/org/springframework/data/gemfire/config/xml/LuceneNamespaceUnitTests.java
View File

@@ -21,8 +21,8 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
@@ -35,6 +35,7 @@ import java.util.Optional;
import org.apache.geode.cache.GemFireCache;
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.Test;
@@ -97,9 +98,9 @@ public class LuceneNamespaceUnitTests {
String... keys) {
assertLuceneIndex(index, name, regionPath);
assertThat(index.getFieldNames()).isEmpty();
assertThat(index.getFieldAnalyzers()).hasSize(keys.length);
assertThat(index.getFieldAnalyzers()).containsKeys(keys);
assertThat(index.getFieldNames()).isEmpty();
}
protected void assertLuceneIndexWithFields(LuceneIndex index, String name, String regionPath, String... fieldNames) {
@@ -112,14 +113,8 @@ public class LuceneNamespaceUnitTests {
@SuppressWarnings({ "deprecation", "unchecked" })
public void luceneServiceConfigurationAndInteractionsAreCorrect() {
assertThat(this.luceneService).isNotNull();
verify(this.luceneService, times(1))
.createIndex(eq("IndexOne"), eq("/Example"), eq("fieldOne"), eq("fieldTwo"));
verify(this.luceneService, times(1))
.createIndex(eq("IndexTwo"), eq("/AnotherExample"), isA(Map.class));
verify(this.luceneService, never()).destroyIndex(any(LuceneIndex.class));
verify(this.luceneService, times(2)).createIndexFactory();
verify(this.luceneService, never()).destroyIndex(anyString(), anyString());
}
@Test
@@ -157,7 +152,6 @@ public class LuceneNamespaceUnitTests {
public static class MockLuceneServiceFactoryBean implements FactoryBean<LuceneService>, InitializingBean {
@SuppressWarnings("all")
private GemFireCache gemfireCache;
private LuceneService luceneService;
@@ -173,20 +167,25 @@ public class LuceneNamespaceUnitTests {
return Optional.ofNullable(this.luceneService).orElseGet(() -> {
this.luceneService = mock(LuceneService.class);
Answer<LuceneIndex> mockLuceneIndex = newMockLuceneIndex(this.luceneService);
when(this.luceneService.createIndexFactory()).thenAnswer(invocation -> {
LuceneIndexFactory mockLuceneIndexFactory = mock(LuceneIndexFactory.class);
doAnswer(mockLuceneIndex).when(this.luceneService)
.createIndex(anyString(), anyString(), (String[]) any());
doReturn(mockLuceneIndexFactory).when(mockLuceneIndexFactory).setFields((String[]) any());
doReturn(mockLuceneIndexFactory).when(mockLuceneIndexFactory).setFields(any(Map.class));
doAnswer(mockLuceneIndex).when(this.luceneService)
.createIndex(anyString(), anyString(), isA(Map.class));
Answer<LuceneIndex> mockLuceneIndex = mockLuceneIndex(this.luceneService);
doAnswer(mockLuceneIndex).when(mockLuceneIndexFactory).create(anyString(), anyString());
return mockLuceneIndexFactory;
});
return this.luceneService;
});
}
@SuppressWarnings("unchecked")
private Answer<LuceneIndex> newMockLuceneIndex(LuceneService mockLuceneService) {
private Answer<LuceneIndex> mockLuceneIndex(LuceneService mockLuceneService) {
return (invocationOnMock) -> {
String indexName = invocationOnMock.getArgument(0);
String regionPath = invocationOnMock.getArgument(1);

40
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;
@@ -133,65 +132,36 @@ public class LuceneAccessorUnitTests {
@Test
@SuppressWarnings("deprecation")
public void createLuceneQueryFactoryWithProjectionFields() {
public void createLuceneQueryFactoryWithResultLimit() {
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("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))
.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.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setProjectionFields(anyVararg())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setResultLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
assertThat(luceneAccessor.createLuceneQueryFactory(1000, "fieldOne", "fieldTwo"))
.isEqualTo(mockLuceneQueryFactory);
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() {
public void createLuceneQueryFactoryWithResultLimitAndPageSize() {
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);
assertThat(luceneAccessor.createLuceneQueryFactory(1000, 20))
.isEqualTo(mockLuceneQueryFactory);
verify(luceneAccessor).resolveLuceneService();
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(eq(1000));
verify(mockLuceneQueryFactory, times(1)).setPageSize(eq(20));
verify(mockLuceneQueryFactory, times(1))
.setProjectionFields(eq("fieldOne"), eq("fieldTwo"));
}
@Test

52
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,9 +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
@@ -121,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");
@@ -140,8 +148,11 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
assertThat(factoryBean.createIndex("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"));
}
@@ -160,8 +171,10 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
assertThat(factoryBean.createIndex("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"));
}
@@ -178,8 +191,11 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
assertThat(factoryBean.createIndex("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"));
}
@@ -194,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
@@ -215,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
@@ -232,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
@@ -346,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);

18
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
@@ -116,6 +114,6 @@ public class LuceneOperationsUnitTests {
eq(mockLuceneQueryProvider), eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
}
abstract class TestLuceneOperations implements LuceneOperations {
}
abstract class TestLuceneOperations implements LuceneOperations { }
}

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

@@ -22,7 +22,6 @@ import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.anyVararg;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.doReturn;
@@ -63,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
*/
@@ -100,7 +100,6 @@ public class LuceneTemplateUnitTests {
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setProjectionFields(anyVararg())).thenReturn(mockLuceneQueryFactory);
when(mockLuceneQueryFactory.setResultLimit(anyInt())).thenReturn(mockLuceneQueryFactory);
}
@@ -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);
@@ -129,7 +127,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();
@@ -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);
@@ -158,7 +154,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();
@@ -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);
@@ -188,7 +183,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();
@@ -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);
@@ -216,7 +210,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();
@@ -246,7 +239,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();
@@ -275,7 +267,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();
@@ -305,7 +296,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();
@@ -334,7 +324,6 @@ public class LuceneTemplateUnitTests {
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
verify(mockLuceneQueryFactory, times(1)).setResultLimit(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();

1
src/test/java/org/springframework/data/gemfire/search/lucene/ProjectingLuceneTemplateUnitTests.java
View File

@@ -86,7 +86,6 @@ public class ProjectingLuceneTemplateUnitTests {
LuceneResultStruct<K, V> mockLuceneResultStruct =
mock(LuceneResultStruct.class, String.format("MockLuceneResultStruct%s", key));
when(mockLuceneResultStruct.getKey()).thenReturn(key);
when(mockLuceneResultStruct.getValue()).thenReturn(value);
return mockLuceneResultStruct;

4
src/test/java/org/springframework/data/gemfire/search/lucene/support/LucenePageUnitTests.java
View File

@@ -75,9 +75,9 @@ public class LucenePageUnitTests {
@SuppressWarnings("unchecked")
protected <K, V> LuceneResultStruct<K, V> mockLuceneResultStruct(K key, V value) {
LuceneResultStruct<K, V> mockLuceneResultStruct = mock(LuceneResultStruct.class);
LuceneResultStruct<K, V> mockLuceneResultStruct =
mock(LuceneResultStruct.class, String.format("MockLuceneResultStruct$%1$s", key));
when(mockLuceneResultStruct.getKey()).thenReturn(key);
when(mockLuceneResultStruct.getValue()).thenReturn(value);
return mockLuceneResultStruct;