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

DATAGEODE-101 - Add support for setting a LuceneSerializer on LuceneIndex creation.

Browse Source
This commit is contained in:
John Blum
2018-04-27 14:08:58 -07:00
parent 251f1f12e0
commit d16bbc8d28
6 changed files with 148 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -34,10 +34,12 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicReference;
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.LuceneSerializer;
import org.apache.geode.cache.lucene.LuceneService;
import org.apache.lucene.analysis.Analyzer;
import org.junit.Test;
@@ -50,6 +52,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
@@ -93,12 +96,17 @@ public class LuceneNamespaceUnitTests {
@Qualifier("IndexFour")
private LuceneIndex luceneIndexFour;
@Autowired
private LuceneSerializer luceneSerializer;
private static String[] asArray(List<String> list) {
return list.toArray(new String[list.size()]);
}
private static String[] toStringArray(Object[] array) {
String[] stringArray = new String[array.length];
int index = 0;
for (Object element : array) {
@@ -108,13 +116,14 @@ public class LuceneNamespaceUnitTests {
return stringArray;
}
protected void assertLuceneIndex(LuceneIndex index, String name, String regionPath) {
private void assertLuceneIndex(LuceneIndex index, String name, String regionPath) {
assertThat(index).isNotNull();
assertThat(index.getName()).isEqualTo(name);
assertThat(index.getRegionPath()).isEqualTo(regionPath);
}
protected void assertLuceneIndexWithFieldAnalyzers(LuceneIndex index, String name, String regionPath,
private void assertLuceneIndexWithFieldAnalyzers(LuceneIndex index, String name, String regionPath,
String... keys) {
assertLuceneIndex(index, name, regionPath);
@@ -123,7 +132,8 @@ public class LuceneNamespaceUnitTests {
assertThat(index.getFieldNames()).isEmpty();
}
protected void assertLuceneIndexWithFields(LuceneIndex index, String name, String regionPath, String... fieldNames) {
private void assertLuceneIndexWithFields(LuceneIndex index, String name, String regionPath, String... fieldNames) {
assertLuceneIndex(index, name, regionPath);
assertThat(index.getFieldAnalyzers()).isEmpty();
assertThat(index.getFieldNames()).contains(fieldNames);
@@ -131,6 +141,7 @@ public class LuceneNamespaceUnitTests {
@Test
public void luceneServiceConfigurationAndInteractionsAreCorrect() {
assertThat(this.luceneService).isNotNull();
verify(this.luceneService, times(4)).createIndexFactory();
verify(this.luceneService, never()).destroyIndex(anyString(), anyString());
@@ -138,26 +149,38 @@ public class LuceneNamespaceUnitTests {
@Test
public void luceneIndexOneIsConfiguredCorrectly() {
assertLuceneIndexWithFields(this.luceneIndexOne, "IndexOne", "/Example",
"fieldOne", "fieldTwo");
assertThat(this.luceneIndexOne.getLuceneSerializer()).isNull();
}
@Test
public void luceneIndexTwoIsConfiguredCorrectly() {
assertLuceneIndexWithFieldAnalyzers(this.luceneIndexTwo, "IndexTwo", "/AnotherExample",
"fieldOne", "fieldTwo");
assertThat(this.luceneIndexTwo.getLuceneSerializer()).isInstanceOf(LuceneSerializer.class);
}
@Test
public void luceneIndexThreeIsConfiguredCorrectly() {
assertLuceneIndexWithFields(this.luceneIndexThree, "IndexThree", "/Example",
"singleField");
assertThat(this.luceneIndexThree.getLuceneSerializer()).isNull();
}
@Test
public void luceneIndexFourIsConfiguredCorrectly() {
assertLuceneIndexWithFieldAnalyzers(this.luceneIndexFour, "IndexFour", "/YetAnotherExample",
"singleField");
assertThat(this.luceneIndexFour.getLuceneSerializer()).isEqualTo(luceneSerializer);
}
public static class LuceneNamespaceUnitTestsBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@@ -183,10 +206,13 @@ public class LuceneNamespaceUnitTests {
@Override
@SuppressWarnings("unchecked")
public LuceneService getObject() throws Exception {
return Optional.ofNullable(this.luceneService).orElseGet(() -> {
this.luceneService = mock(LuceneService.class);
when(this.luceneService.createIndexFactory()).thenAnswer(invocation -> {
LuceneIndexFactory mockLuceneIndexFactory = mock(LuceneIndexFactory.class);
List<String> fieldNames = new ArrayList<>();
@@ -203,8 +229,15 @@ public class LuceneNamespaceUnitTests {
return mockLuceneIndexFactory;
});
Answer<LuceneIndex> mockLuceneIndex =
mockLuceneIndex(this.luceneService, fieldAnalyzers, fieldNames);
AtomicReference<LuceneSerializer> luceneSerializer = new AtomicReference<>(null);
when(mockLuceneIndexFactory.setLuceneSerializer(any())).thenAnswer(setLuceneSerializerInvocation -> {
luceneSerializer.set(setLuceneSerializerInvocation.getArgument(0));
return mockLuceneIndexFactory;
});
Answer mockLuceneIndex =
mockLuceneIndex(this.luceneService, fieldAnalyzers, fieldNames, luceneSerializer);
doAnswer(mockLuceneIndex).when(mockLuceneIndexFactory).create(anyString(), anyString());
@@ -217,18 +250,21 @@ public class LuceneNamespaceUnitTests {
@SuppressWarnings("unchecked")
private Answer<LuceneIndex> mockLuceneIndex(LuceneService mockLuceneService,
Map<String, Analyzer> fieldAnalyzers, List<String> fieldNames) {
Map<String, Analyzer> fieldAnalyzers, List<String> fieldNames,
AtomicReference<LuceneSerializer> luceneSerializer) {
return invocation -> {
String indexName = invocation.getArgument(0);
String regionPath = invocation.getArgument(1);
LuceneIndex mockLuceneIndex = mock(LuceneIndex.class, indexName);
when(mockLuceneIndex.getName()).thenReturn(indexName);
when(mockLuceneIndex.getRegionPath()).thenReturn(regionPath);
when(mockLuceneIndex.getFieldAnalyzers()).thenReturn(fieldAnalyzers);
when(mockLuceneIndex.getFieldNames()).thenReturn(asArray(fieldNames));
when(mockLuceneIndex.getLuceneSerializer()).thenAnswer(it -> luceneSerializer.get());
when(mockLuceneIndex.getName()).thenReturn(indexName);
when(mockLuceneIndex.getRegionPath()).thenReturn(regionPath);
when(mockLuceneService.getIndex(eq(indexName), eq(regionPath))).thenReturn(mockLuceneIndex);
return mockLuceneIndex;
@@ -237,7 +273,9 @@ public class LuceneNamespaceUnitTests {
@Override
public Class<?> getObjectType() {
return Optional.ofNullable(this.luceneService).<Class<?>>map(LuceneService::getClass)
return Optional.ofNullable(this.luceneService)
.<Class<?>>map(LuceneService::getClass)
.orElse(LuceneService.class);
}
@@ -271,4 +309,24 @@ public class LuceneNamespaceUnitTests {
return this.name;
}
}
public static class MockLuceneSerializerFactoryBean implements FactoryBean<LuceneSerializer> {
private LuceneSerializer luceneSerializer;
@Nullable @Override
public LuceneSerializer getObject() throws Exception {
return Optional.ofNullable(this.luceneSerializer)
.orElseGet(() -> this.luceneSerializer = mock(LuceneSerializer.class));
}
@Nullable @Override
public Class<?> getObjectType() {
return Optional.ofNullable(this.luceneSerializer)
.<Class<?>>map(LuceneSerializer::getClass)
.orElse(LuceneSerializer.class);
}
}
}

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

@@ -38,6 +38,7 @@ 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.LuceneSerializer;
import org.apache.geode.cache.lucene.LuceneService;
import org.apache.lucene.analysis.Analyzer;
import org.junit.Before;
@@ -81,6 +82,9 @@ public class LuceneIndexFactoryBeanUnitTests {
@Mock
private LuceneIndexFactory mockLuceneIndexFactory;
@Mock
private LuceneSerializer mockLuceneSerializer;
@Mock
private LuceneService mockLuceneService;
@@ -155,6 +159,7 @@ public class LuceneIndexFactoryBeanUnitTests {
verify(mockLuceneService, times(1)).createIndexFactory();
verify(mockLuceneIndexFactory, times(1))
.setFields(eq(LuceneService.REGION_VALUE_FIELD));
verify(mockLuceneIndexFactory, never()).setLuceneSerializer(any(LuceneSerializer.class));
verify(mockLuceneIndexFactory, times(1))
.create(eq("ExampleIndex"), eq("/Example"));
verify(mockLuceneService, times(1))
@@ -167,6 +172,7 @@ public class LuceneIndexFactoryBeanUnitTests {
Map<String, Analyzer> fieldAnalyzers = Collections.singletonMap("fieldOne", mockAnalyzer);
factoryBean.setFieldAnalyzers(fieldAnalyzers);
factoryBean.setLuceneSerializer(mockLuceneSerializer);
factoryBean.setLuceneService(mockLuceneService);
when(mockLuceneService.getIndex(eq("ExampleIndex"), eq("/Example"))).thenReturn(mockLuceneIndex);
@@ -174,11 +180,13 @@ public class LuceneIndexFactoryBeanUnitTests {
assertThat(factoryBean.getFieldAnalyzers()).isEqualTo(fieldAnalyzers);
assertThat(factoryBean.getFields()).isEmpty();
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
assertThat(factoryBean.createLuceneIndex("ExampleIndex", "/Example")).isEqualTo(mockLuceneIndex);
assertThat(factoryBean.createLuceneIndex("ExampleIndex", "/Example"))
.isEqualTo(mockLuceneIndex);
verify(factoryBean, times(1)).postProcess(eq(mockLuceneIndexFactory));
verify(mockLuceneService, times(1)).createIndexFactory();
verify(mockLuceneIndexFactory, times(1)).setFields(eq(fieldAnalyzers));
verify(mockLuceneIndexFactory, times(1)).setLuceneSerializer(eq(mockLuceneSerializer));
verify(mockLuceneIndexFactory, times(1))
.create(eq("ExampleIndex"), eq("/Example"));
verify(mockLuceneService, times(1))
@@ -189,6 +197,7 @@ public class LuceneIndexFactoryBeanUnitTests {
public void createLuceneIndexWithTargetedFields() {
factoryBean.setFields("fieldOne", "fieldTwo");
factoryBean.setLuceneSerializer(mockLuceneSerializer);
factoryBean.setLuceneService(mockLuceneService);
when(mockLuceneService.getIndex(eq("ExampleIndex"), eq("/Example"))).thenReturn(mockLuceneIndex);
@@ -202,6 +211,7 @@ public class LuceneIndexFactoryBeanUnitTests {
verify(mockLuceneService, times(1)).createIndexFactory();
verify(mockLuceneIndexFactory, times(1))
.setFields(eq("fieldOne"), eq("fieldTwo"));
verify(mockLuceneIndexFactory, times(1)).setLuceneSerializer(eq(mockLuceneSerializer));
verify(mockLuceneIndexFactory, times(1))
.create(eq("ExampleIndex"), eq("/Example"));
verify(mockLuceneService, times(1))
@@ -667,6 +677,16 @@ public class LuceneIndexFactoryBeanUnitTests {
factoryBean.setIndexName(null);
}
@Test
public void setAndGetLuceneSerializer() {
assertThat(factoryBean.getLuceneSerializer()).isNull();
factoryBean.setLuceneSerializer(mockLuceneSerializer);
assertThat(factoryBean.getLuceneSerializer()).isEqualTo(mockLuceneSerializer);
}
@Test(expected = IllegalStateException.class)
public void getUninitializedIndexName() {