SGF-402 - Add Lucene Integration support.
This commit is contained in:
John Blum
@@ -0,0 +1,356 @@
|
||||
/*
|
||||
* Copyright 2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package org.springframework.data.gemfire.search.lucene;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.hamcrest.Matchers.containsString;
|
||||
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;
|
||||
import static org.mockito.Mockito.never;
|
||||
import static org.mockito.Mockito.spy;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.springframework.data.gemfire.search.lucene.LuceneAccessor.LuceneQueryExecutor;
|
||||
|
||||
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.LuceneQueryException;
|
||||
import org.apache.geode.cache.lucene.LuceneQueryFactory;
|
||||
import org.apache.geode.cache.lucene.LuceneService;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.rules.ExpectedException;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.springframework.dao.DataRetrievalFailureException;
|
||||
import org.springframework.data.gemfire.search.lucene.support.LuceneAccessorSupport;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link LuceneAccessor}.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Rule
|
||||
* @see org.junit.Test
|
||||
* @see org.junit.runner.RunWith
|
||||
* @see org.mockito.Mock
|
||||
* @see org.mockito.Mockito
|
||||
* @see org.mockito.Spy
|
||||
* @see org.mockito.runners.MockitoJUnitRunner
|
||||
* @see org.springframework.data.gemfire.search.lucene.LuceneAccessor
|
||||
* @since 1.0.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LuceneAccessorUnitTests {
|
||||
|
||||
@Rule
|
||||
public ExpectedException exception = ExpectedException.none();
|
||||
|
||||
@Mock
|
||||
private GemFireCache mockCache;
|
||||
|
||||
// SUT
|
||||
private LuceneAccessor luceneAccessor;
|
||||
|
||||
@Mock
|
||||
private LuceneIndex mockLuceneIndex;
|
||||
|
||||
@Mock
|
||||
private LuceneQueryFactory mockLuceneQueryFactory;
|
||||
|
||||
@Mock
|
||||
private LuceneService mockLuceneService;
|
||||
|
||||
@Mock
|
||||
private Region<?, ?> mockRegion;
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
luceneAccessor = spy(new LuceneAccessorSupport() { });
|
||||
}
|
||||
|
||||
@Test
|
||||
public void afterPropertiesSetInitializesLuceneAccessorProperly() throws Exception {
|
||||
assertThat(luceneAccessor.getCache()).isNull();
|
||||
assertThat(luceneAccessor.getLuceneService()).isNull();
|
||||
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
|
||||
assertThat(luceneAccessor.getRegion()).isNull();
|
||||
assertThat(luceneAccessor.getRegionPath()).isNullOrEmpty();
|
||||
|
||||
doReturn(mockCache).when(luceneAccessor).resolveCache();
|
||||
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
|
||||
doReturn("TestIndex").when(luceneAccessor).resolveIndexName();
|
||||
doReturn("/Example").when(luceneAccessor).resolveRegionPath();
|
||||
|
||||
luceneAccessor.afterPropertiesSet();
|
||||
|
||||
assertThat(luceneAccessor.getCache()).isEqualTo(mockCache);
|
||||
assertThat(luceneAccessor.getLuceneService()).isEqualTo(mockLuceneService);
|
||||
assertThat(luceneAccessor.getIndexName()).isEqualTo("TestIndex");
|
||||
assertThat(luceneAccessor.getRegion()).isNull();
|
||||
assertThat(luceneAccessor.getRegionPath()).isEqualTo("/Example");
|
||||
|
||||
verify(luceneAccessor, times(1)).resolveCache();
|
||||
verify(luceneAccessor, times(1)).resolveLuceneService();
|
||||
verify(luceneAccessor, times(1)).resolveIndexName();
|
||||
verify(luceneAccessor, times(1)).resolveRegionPath();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createLuceneQueryFactory() {
|
||||
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService();
|
||||
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
|
||||
|
||||
assertThat(luceneAccessor.createLuceneQueryFactory()).isEqualTo(mockLuceneQueryFactory);
|
||||
|
||||
verify(luceneAccessor).resolveLuceneService();
|
||||
verify(mockLuceneService, times(1)).createLuceneQueryFactory();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("deprecation")
|
||||
public void createLuceneQueryFactoryWithProjectionFields() {
|
||||
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);
|
||||
|
||||
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)).setPageSize(eq(20));
|
||||
verify(mockLuceneQueryFactory, times(1))
|
||||
.setProjectionFields(eq("fieldOne"), eq("fieldTwo"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveCacheReturnsConfiguredCache() {
|
||||
luceneAccessor.setCache(mockCache);
|
||||
|
||||
assertThat(luceneAccessor.getCache()).isSameAs(mockCache);
|
||||
assertThat(luceneAccessor.resolveCache()).isSameAs(mockCache);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveLuceneServiceReturnsConfiguredLuceneService() {
|
||||
luceneAccessor.setLuceneService(mockLuceneService);
|
||||
|
||||
assertThat(luceneAccessor.getLuceneService()).isSameAs(mockLuceneService);
|
||||
assertThat(luceneAccessor.resolveLuceneService()).isSameAs(mockLuceneService);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveLuceneServiceLooksUpLuceneService() {
|
||||
doReturn(mockCache).when(luceneAccessor).resolveCache();
|
||||
doReturn(mockLuceneService).when(luceneAccessor).resolveLuceneService(eq(mockCache));
|
||||
|
||||
assertThat(luceneAccessor.getLuceneService()).isNull();
|
||||
assertThat(luceneAccessor.resolveLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
verify(luceneAccessor, times(1)).resolveCache();
|
||||
verify(luceneAccessor, times(1)).resolveLuceneService(eq(mockCache));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveLuceneServiceThrowsIllegalArgumentExceptionWhenCacheIsNull() {
|
||||
exception.expect(IllegalArgumentException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("Cache reference was not properly configured");
|
||||
|
||||
luceneAccessor.resolveLuceneService(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveIndexNameReturnsConfiguredIndexName() {
|
||||
luceneAccessor.setIndexName("TestIndex");
|
||||
|
||||
assertThat(luceneAccessor.getIndexName()).isEqualTo("TestIndex");
|
||||
assertThat(luceneAccessor.resolveIndexName()).isEqualTo("TestIndex");
|
||||
|
||||
verify(luceneAccessor, never()).getLuceneIndex();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveIndexNameReturnsLuceneIndexName() {
|
||||
luceneAccessor.setLuceneIndex(mockLuceneIndex);
|
||||
|
||||
when(mockLuceneIndex.getName()).thenReturn("MockIndex");
|
||||
|
||||
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
|
||||
assertThat(luceneAccessor.resolveIndexName()).isEqualTo("MockIndex");
|
||||
|
||||
verify(luceneAccessor, times(1)).getLuceneIndex();
|
||||
verify(mockLuceneIndex, times(1)).getName();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveIndexNameThrowsIllegalStateExceptionWhenIndexNameIsUnresolvable() {
|
||||
assertThat(luceneAccessor.getIndexName()).isNullOrEmpty();
|
||||
assertThat(luceneAccessor.getLuceneIndex()).isNull();
|
||||
|
||||
exception.expect(IllegalStateException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("The name of the Lucene Index could not be resolved");
|
||||
|
||||
luceneAccessor.resolveIndexName();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveRegionPathReturnsConfiguredRegionPath() {
|
||||
luceneAccessor.setRegionPath("/Example");
|
||||
|
||||
assertThat(luceneAccessor.getRegionPath()).isEqualTo("/Example");
|
||||
assertThat(luceneAccessor.resolveRegionPath()).isEqualTo("/Example");
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionPathReturnsRegionFullPath() {
|
||||
when(mockRegion.getFullPath()).thenReturn("/Example");
|
||||
|
||||
luceneAccessor.setRegion(mockRegion);
|
||||
|
||||
assertThat(luceneAccessor.resolveRegionPath()).isEqualTo("/Example");
|
||||
|
||||
verify(luceneAccessor, times(1)).getRegionPath();
|
||||
verify(luceneAccessor, times(1)).getRegion();
|
||||
verify(mockRegion, times(1)).getFullPath();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveRegionPathThrowsIllegalStatueExceptionWhenRegionPathIsUnresolvable() {
|
||||
assertThat(luceneAccessor.getRegion()).isNull();
|
||||
assertThat(luceneAccessor.getRegionPath()).isNullOrEmpty();
|
||||
|
||||
exception.expect(IllegalStateException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("Region path could not be resolved");
|
||||
|
||||
luceneAccessor.resolveRegionPath();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void doFind() throws LuceneQueryException {
|
||||
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
|
||||
|
||||
when(mockQueryExecutor.execute()).thenReturn("test");
|
||||
|
||||
assertThat(luceneAccessor.doFind(mockQueryExecutor, "title : 'Up Shit Creek Without a Paddle",
|
||||
"/Example", "ExampleIndex")).isEqualTo("test");
|
||||
|
||||
verify(mockQueryExecutor, times(1)).execute();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void doFindHandlesLuceneQueryException() throws LuceneQueryException {
|
||||
LuceneQueryExecutor<String> mockQueryExecutor = mock(LuceneQueryExecutor.class);
|
||||
|
||||
when(mockQueryExecutor.execute()).thenThrow(new LuceneQueryException("test"));
|
||||
|
||||
try {
|
||||
exception.expect(DataRetrievalFailureException.class);
|
||||
exception.expectCause(isA(LuceneQueryException.class));
|
||||
exception.expectMessage(containsString(
|
||||
"Failed to execute Lucene Query [title : Up Shit Creek Without a Paddle] on Region [/Example] with Lucene Index [ExampleIndex]"));
|
||||
|
||||
luceneAccessor.doFind(mockQueryExecutor, "title : Up Shit Creek Without a Paddle",
|
||||
"/Example", "ExampleIndex");
|
||||
}
|
||||
finally {
|
||||
verify(mockQueryExecutor, times(1)).execute();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void luceneAccessorInitializedCorrectly() {
|
||||
luceneAccessor.setCache(mockCache);
|
||||
luceneAccessor.setIndexName("ExampleIndex");
|
||||
luceneAccessor.setLuceneIndex(mockLuceneIndex);
|
||||
luceneAccessor.setLuceneService(mockLuceneService);
|
||||
luceneAccessor.setRegion(mockRegion);
|
||||
luceneAccessor.setRegionPath("/Example");
|
||||
|
||||
assertThat(luceneAccessor.getCache()).isSameAs(mockCache);
|
||||
assertThat(luceneAccessor.getIndexName()).isEqualTo("ExampleIndex");
|
||||
assertThat(luceneAccessor.getLuceneIndex()).isSameAs(mockLuceneIndex);
|
||||
assertThat(luceneAccessor.getLuceneService()).isSameAs(mockLuceneService);
|
||||
assertThat(luceneAccessor.getRegion()).isSameAs(mockRegion);
|
||||
assertThat(luceneAccessor.getRegionPath()).isEqualTo("/Example");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,606 @@
|
||||
/*
|
||||
* Copyright 2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package org.springframework.data.gemfire.search.lucene;
|
||||
|
||||
import static org.assertj.core.api.Java6Assertions.assertThat;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
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;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
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.LuceneService;
|
||||
import org.apache.lucene.analysis.Analyzer;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.rules.ExpectedException;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.springframework.beans.factory.BeanFactory;
|
||||
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link LuceneIndexFactoryBean}.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Rule
|
||||
* @see org.junit.Test
|
||||
* @see org.junit.runner.RunWith
|
||||
* @see org.mockito.Mock
|
||||
* @see org.mockito.Mockito
|
||||
* @see org.mockito.Spy
|
||||
* @see org.mockito.runners.MockitoJUnitRunner
|
||||
* @see org.springframework.data.gemfire.search.lucene.LuceneIndexFactoryBean
|
||||
* @since 1.1.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LuceneIndexFactoryBeanUnitTests {
|
||||
|
||||
@Rule
|
||||
public ExpectedException exception = ExpectedException.none();
|
||||
|
||||
@Mock
|
||||
private Analyzer mockAnalyzer;
|
||||
|
||||
@Mock
|
||||
private BeanFactory mockBeanFactory;
|
||||
|
||||
@Mock
|
||||
private GemFireCache mockCache;
|
||||
|
||||
@Mock
|
||||
private LuceneIndex mockLuceneIndex;
|
||||
|
||||
@Mock
|
||||
private LuceneService mockLuceneService;
|
||||
|
||||
@Mock
|
||||
private Region<Object, Object> mockRegion;
|
||||
|
||||
private LuceneIndexFactoryBean factoryBean;
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
factoryBean = spy(new LuceneIndexFactoryBean());
|
||||
doReturn(mockLuceneService).when(factoryBean).resolveLuceneService(eq(mockCache));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void afterPropertiesSetResolvesCacheLuceneServiceRegionPathAndCreatesLuceneIndex() throws Exception {
|
||||
doReturn(mockCache).when(factoryBean).resolveCache();
|
||||
doReturn(mockLuceneService).when(factoryBean).resolveLuceneService();
|
||||
doReturn("/Example").when(factoryBean).resolveRegionPath();
|
||||
doReturn(mockLuceneIndex).when(factoryBean).createIndex(eq("ExampleIndex"), eq("/Example"));
|
||||
|
||||
factoryBean.setIndexName("ExampleIndex");
|
||||
|
||||
assertThat(factoryBean.getIndexName()).isEqualTo("ExampleIndex");
|
||||
|
||||
factoryBean.afterPropertiesSet();
|
||||
|
||||
assertThat(factoryBean.getObject()).isEqualTo(mockLuceneIndex);
|
||||
|
||||
verify(factoryBean, times(1)).resolveCache();
|
||||
verify(factoryBean, times(1)).resolveLuceneService();
|
||||
verify(factoryBean, times(1)).resolveRegionPath();
|
||||
verify(factoryBean, times(1))
|
||||
.createIndex(eq("ExampleIndex"), eq("/Example"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void afterPropertiesSetThrowsIllegalStateExceptionIndexNameNotSet() throws Exception {
|
||||
exception.expect(IllegalStateException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("indexName was not properly initialized");
|
||||
|
||||
factoryBean.afterPropertiesSet();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createIndexWithAllFields() {
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
when(mockLuceneService.getIndex(eq("ExampleIndex"), eq("/Example"))).thenReturn(mockLuceneIndex);
|
||||
|
||||
assertThat(factoryBean.getFieldAnalyzers()).isEmpty();
|
||||
assertThat(factoryBean.getFields()).isEmpty();
|
||||
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))
|
||||
.getIndex(eq("ExampleIndex"), eq("/Example"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createIndexWithFieldAnalyzers() {
|
||||
Map<String, Analyzer> fieldAnalyzers = Collections.singletonMap("fieldOne", mockAnalyzer);
|
||||
|
||||
factoryBean.setFieldAnalyzers(fieldAnalyzers);
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
when(mockLuceneService.getIndex(eq("ExampleIndex"), eq("/Example"))).thenReturn(mockLuceneIndex);
|
||||
|
||||
assertThat(factoryBean.getFieldAnalyzers()).isEqualTo(fieldAnalyzers);
|
||||
assertThat(factoryBean.getFields()).isEmpty();
|
||||
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))
|
||||
.getIndex(eq("ExampleIndex"), eq("/Example"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void createIndexWithTargetedFields() {
|
||||
factoryBean.setFields("fieldOne", "fieldTwo");
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
when(mockLuceneService.getIndex(eq("ExampleIndex"), eq("/Example"))).thenReturn(mockLuceneIndex);
|
||||
|
||||
assertThat(factoryBean.getFieldAnalyzers()).isEmpty();
|
||||
assertThat(factoryBean.getFields()).containsAll(Arrays.asList("fieldOne", "fieldTwo"));
|
||||
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))
|
||||
.getIndex(eq("ExampleIndex"), eq("/Example"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("deprecation")
|
||||
public void destroyIsSuccessful() throws Exception {
|
||||
factoryBean.setDestroy(true);
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
assertThat(factoryBean.isDestroy()).isTrue();
|
||||
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
doReturn(mockLuceneIndex).when(factoryBean).getObject();
|
||||
|
||||
factoryBean.destroy();
|
||||
|
||||
verify(factoryBean, times(1)).getObject();
|
||||
verify(mockLuceneService, times(1)).destroyIndex(eq(mockLuceneIndex));
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("deprecation")
|
||||
public void destroyDoesNothingWhenDestroyIsFalse() throws Exception {
|
||||
factoryBean.setDestroy(false);
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
assertThat(factoryBean.isDestroy()).isFalse();
|
||||
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
doReturn(mockLuceneIndex).when(factoryBean).getObject();
|
||||
|
||||
factoryBean.destroy();
|
||||
|
||||
verify(factoryBean, times(1)).getObject();
|
||||
verify(mockLuceneService, never()).destroyIndex(any(LuceneIndex.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("deprecation")
|
||||
public void destroyDoesNothingWhenLuceneIndexIsNull() throws Exception {
|
||||
factoryBean.setDestroy(true);
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
assertThat(factoryBean.isDestroy()).isTrue();
|
||||
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
doReturn(null).when(factoryBean).getObject();
|
||||
|
||||
factoryBean.destroy();
|
||||
|
||||
verify(factoryBean, times(1)).getObject();
|
||||
verify(mockLuceneService, never()).destroyIndex(isNull(LuceneIndex.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isLuceneIndexDestroyableReturnsTrue() {
|
||||
factoryBean.setDestroy(true);
|
||||
|
||||
assertThat(factoryBean.isDestroy()).isTrue();
|
||||
assertThat(factoryBean.isLuceneIndexDestroyable(mockLuceneIndex)).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isLuceneIndexDestroyableWhenDestroyIsFalseReturnsFalse() {
|
||||
factoryBean.setDestroy(false);
|
||||
|
||||
assertThat(factoryBean.isDestroy()).isFalse();
|
||||
assertThat(factoryBean.isLuceneIndexDestroyable(mockLuceneIndex)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isLuceneIndexDestroyableWhenLuceneIndexIsNullReturnsFalse() {
|
||||
factoryBean.setDestroy(true);
|
||||
|
||||
assertThat(factoryBean.isDestroy()).isTrue();
|
||||
assertThat(factoryBean.isLuceneIndexDestroyable(null)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getObjectReturnsLuceneIndexFromLuceneService() throws Exception {
|
||||
factoryBean.setCache(mockCache);
|
||||
factoryBean.setIndexName("ExampleIndex");
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
factoryBean.setRegionPath("/Example");
|
||||
|
||||
when(mockLuceneService.getIndex(eq("ExampleIndex"), eq("/Example"))).thenReturn(mockLuceneIndex);
|
||||
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.getIndexName()).isEqualTo("ExampleIndex");
|
||||
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
|
||||
assertThat(factoryBean.getRegionPath()).isEqualTo("/Example");
|
||||
assertThat(factoryBean.getObject()).isEqualTo(mockLuceneIndex);
|
||||
|
||||
verify(mockLuceneService, times(1))
|
||||
.getIndex(eq("ExampleIndex"), eq("/Example"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getObjectReturnsExistingLuceneIndex() throws Exception {
|
||||
factoryBean.setLuceneIndex(mockLuceneIndex);
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
assertThat(factoryBean.getObject()).isSameAs(mockLuceneIndex);
|
||||
|
||||
verify(mockLuceneService, never()).getIndex(anyString(), anyString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getObjectReturnsNullWhenLuceneServiceIsNull() throws Exception {
|
||||
factoryBean.setCache(mockCache);
|
||||
factoryBean.setRegionPath("/Example");
|
||||
|
||||
doReturn(null).when(factoryBean).resolveLuceneService(eq(mockCache));
|
||||
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.getLuceneService()).isNull();
|
||||
assertThat(factoryBean.getRegionPath()).isEqualTo("/Example");
|
||||
assertThat(factoryBean.getObject()).isNull();
|
||||
|
||||
verify(factoryBean, times(1)).resolveLuceneService();
|
||||
verify(factoryBean, times(1)).resolveLuceneService(eq(mockCache));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getObjectTypeBeforeInitialization() {
|
||||
assertThat(factoryBean.getObjectType()).isEqualTo(LuceneIndex.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getObjectTypeAfterInitialization() {
|
||||
assertThat(factoryBean.setLuceneIndex(mockLuceneIndex).getObjectType()).isEqualTo(mockLuceneIndex.getClass());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSingletonReturnsTrue() {
|
||||
assertThat(factoryBean.isSingleton()).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveCacheReturnsConfiguredCache() {
|
||||
factoryBean.setCache(mockCache);
|
||||
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.resolveCache()).isSameAs(mockCache);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveFieldsReturnsGivenFields() {
|
||||
List<String> expectedFields = Arrays.asList("fieldOne", "fieldTwo");
|
||||
|
||||
assertThat(factoryBean.resolveFields(expectedFields)).isSameAs(expectedFields);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveFieldsWithEmptyListReturnsAllFields() {
|
||||
assertThat(factoryBean.resolveFields(Collections.emptyList()))
|
||||
.isEqualTo(Collections.singletonList(LuceneService.REGION_VALUE_FIELD));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveFieldsWithNullReturnsAllFields() {
|
||||
assertThat(factoryBean.resolveFields(null))
|
||||
.isEqualTo(Collections.singletonList(LuceneService.REGION_VALUE_FIELD));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveLuceneServiceReturnsConfiguredLuceneService() {
|
||||
factoryBean.setBeanFactory(mockBeanFactory);
|
||||
factoryBean.setCache(mockCache);
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
|
||||
assertThat(factoryBean.getBeanFactory()).isSameAs(mockBeanFactory);
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
|
||||
assertThat(factoryBean.resolveLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
verifyZeroInteractions(mockBeanFactory);
|
||||
verifyZeroInteractions(mockCache);
|
||||
verify(factoryBean, never()).resolveLuceneService(any(GemFireCache.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveLuceneServiceFromBeanFactory() {
|
||||
factoryBean.setBeanFactory(mockBeanFactory);
|
||||
factoryBean.setCache(mockCache);
|
||||
|
||||
when(mockBeanFactory.getBean(eq(LuceneService.class))).thenReturn(mockLuceneService);
|
||||
|
||||
assertThat(factoryBean.getBeanFactory()).isSameAs(mockBeanFactory);
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.getLuceneService()).isNull();
|
||||
assertThat(factoryBean.resolveLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
verify(mockBeanFactory, times(1)).getBean(eq(LuceneService.class));
|
||||
verifyZeroInteractions(mockCache);
|
||||
verify(factoryBean, never()).resolveLuceneService(any(GemFireCache.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveLuceneServiceFromGemFireCache() {
|
||||
factoryBean.setCache(mockCache);
|
||||
|
||||
doReturn(mockLuceneService).when(factoryBean).resolveLuceneService(eq(mockCache));
|
||||
|
||||
assertThat(factoryBean.getBeanFactory()).isNull();
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.getLuceneService()).isNull();
|
||||
assertThat(factoryBean.resolveLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
verifyZeroInteractions(mockCache);
|
||||
verify(factoryBean, times(1)).resolveLuceneService(eq(mockCache));
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void resolveLuceneServiceFromGemFireCacheWithBeanFactoryThrowinBeansException() {
|
||||
factoryBean.setBeanFactory(mockBeanFactory);
|
||||
factoryBean.setCache(mockCache);
|
||||
|
||||
when(mockBeanFactory.getBean(any(Class.class))).thenThrow(new NoSuchBeanDefinitionException("test"));
|
||||
doReturn(mockLuceneService).when(factoryBean).resolveLuceneService(eq(mockCache));
|
||||
|
||||
assertThat(factoryBean.getBeanFactory()).isSameAs(mockBeanFactory);
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.getLuceneService()).isNull();
|
||||
assertThat(factoryBean.resolveLuceneService()).isSameAs(mockLuceneService);
|
||||
|
||||
verify(mockBeanFactory, times(1)).getBean(eq(LuceneService.class));
|
||||
verifyZeroInteractions(mockCache);
|
||||
verify(factoryBean, times(1)).resolveLuceneService(eq(mockCache));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void resolveLuceneServiceThrowsIllegalArgumentExceptionWhenGemFireCacheIsNotConfigured() {
|
||||
exception.expect(IllegalArgumentException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("A reference to the GemFireCache was not properly configured");
|
||||
|
||||
factoryBean.resolveLuceneService(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionReturnsConfiguredRegion() {
|
||||
factoryBean.setRegion(mockRegion);
|
||||
|
||||
assertThat(factoryBean.resolveRegion()).isSameAs(mockRegion);
|
||||
|
||||
verify(factoryBean, times(1)).getRegion();
|
||||
verify(factoryBean, never()).resolveCache();
|
||||
verify(factoryBean, never()).getRegionPath();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionReturnsRegionFromCache() {
|
||||
factoryBean.setRegionPath("/Example");
|
||||
|
||||
doReturn(mockCache).when(factoryBean).resolveCache();
|
||||
when(mockCache.getRegion(eq("/Example"))).thenReturn(mockRegion);
|
||||
|
||||
assertThat(factoryBean.resolveRegion()).isEqualTo(mockRegion);
|
||||
|
||||
verify(factoryBean, times(1)).getRegion();
|
||||
verify(factoryBean, times(1)).resolveCache();
|
||||
verify(factoryBean, times(1)).getRegionPath();
|
||||
verify(mockCache, times(1)).getRegion(eq("/Example"));
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionReturnsNullWhenCacheNotConfigured() {
|
||||
factoryBean.setRegionPath("/Example");
|
||||
|
||||
doReturn(null).when(factoryBean).resolveCache();
|
||||
|
||||
assertThat(factoryBean.resolveRegion()).isNull();
|
||||
|
||||
verify(factoryBean, times(1)).getRegion();
|
||||
verify(factoryBean, times(1)).resolveCache();
|
||||
verify(factoryBean, times(1)).getRegionPath();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionReturnsNullWhenRegionPathNotConfigured() {
|
||||
factoryBean.setCache(mockCache);
|
||||
factoryBean.setRegionPath(" ");
|
||||
|
||||
assertThat(factoryBean.resolveRegion()).isNull();
|
||||
|
||||
verify(factoryBean, times(1)).getRegion();
|
||||
verify(factoryBean, times(1)).resolveCache();
|
||||
verify(factoryBean, times(1)).getRegionPath();
|
||||
verify(mockCache, never()).getRegion(anyString());
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionPathReturnsConfiguredRegionPath() {
|
||||
factoryBean.setRegionPath("/Example");
|
||||
|
||||
doReturn(null).when(factoryBean).resolveRegion();
|
||||
|
||||
assertThat(factoryBean.resolveRegionPath()).isEqualTo("/Example");
|
||||
|
||||
verify(factoryBean, times(1)).resolveRegion();
|
||||
verify(factoryBean, times(1)).getRegionPath();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionPathReturnsRegionFullPath() {
|
||||
doReturn(mockRegion).when(factoryBean).resolveRegion();
|
||||
when(mockRegion.getFullPath()).thenReturn("/Example");
|
||||
|
||||
assertThat(factoryBean.resolveRegionPath()).isEqualTo("/Example");
|
||||
|
||||
verify(factoryBean, times(1)).resolveRegion();
|
||||
verify(factoryBean, never()).getRegionPath();
|
||||
verify(mockRegion, times(1)).getFullPath();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void resolveRegionPathThrowsIllegalStateException() {
|
||||
doReturn(null).when(factoryBean).resolveRegion();
|
||||
|
||||
factoryBean.setRegionPath(null);
|
||||
|
||||
try {
|
||||
exception.expect(IllegalStateException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("Either Region or regionPath must be specified");
|
||||
|
||||
factoryBean.resolveRegionPath();
|
||||
}
|
||||
finally {
|
||||
verify(factoryBean, times(1)).resolveRegion();
|
||||
verify(factoryBean, times(1)).getRegionPath();
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAndGetFieldAnalyzers() {
|
||||
Map<String, Analyzer> fieldAnalyzers = factoryBean.getFieldAnalyzers();
|
||||
|
||||
assertThat(fieldAnalyzers).isNotNull();
|
||||
assertThat(fieldAnalyzers).isEmpty();
|
||||
|
||||
fieldAnalyzers = Collections.singletonMap("mockField", mockAnalyzer);
|
||||
factoryBean.setFieldAnalyzers(fieldAnalyzers);
|
||||
|
||||
assertThat(factoryBean.getFieldAnalyzers()).isEqualTo(fieldAnalyzers);
|
||||
|
||||
factoryBean.setFieldAnalyzers(null);
|
||||
fieldAnalyzers = factoryBean.getFieldAnalyzers();
|
||||
|
||||
assertThat(fieldAnalyzers).isNotNull();
|
||||
assertThat(fieldAnalyzers).isEmpty();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAndGetFields() {
|
||||
List<String> fields = factoryBean.getFields();
|
||||
|
||||
assertThat(fields).isNotNull();
|
||||
assertThat(fields).isEmpty();
|
||||
|
||||
factoryBean.setFields(Arrays.asList("fieldOne", "fieldTwo"));
|
||||
|
||||
assertThat(factoryBean.getFields()).containsAll(Arrays.asList("fieldOne", "fieldTwo"));
|
||||
|
||||
factoryBean.setFields((String[]) null);
|
||||
fields = factoryBean.getFields();
|
||||
|
||||
assertThat(fields).isNotNull();
|
||||
assertThat(fields).isEmpty();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAndGetIndexName() {
|
||||
factoryBean.setBeanName("IndexOne");
|
||||
|
||||
assertThat(factoryBean.getIndexName()).isEqualTo("IndexOne");
|
||||
|
||||
factoryBean.setIndexName("IndexTwo");
|
||||
|
||||
assertThat(factoryBean.getIndexName()).isEqualTo("IndexTwo");
|
||||
|
||||
factoryBean.setIndexName(null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getUninitializedIndexName() {
|
||||
exception.expect(IllegalStateException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("indexName was not properly initialized");
|
||||
|
||||
factoryBean.getIndexName();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void factoryBeanInitializationIsSuccessful() {
|
||||
factoryBean.setCache(mockCache);
|
||||
factoryBean.setDestroy(true);
|
||||
factoryBean.setFieldAnalyzers(Collections.singletonMap("fieldThree", mockAnalyzer));
|
||||
factoryBean.setFields("fieldOne", "fieldTwo");
|
||||
factoryBean.setIndexName("TestIndex");
|
||||
factoryBean.setLuceneService(mockLuceneService);
|
||||
factoryBean.setRegion(mockRegion);
|
||||
factoryBean.setRegionPath("/Grandparent/Parent/Child");
|
||||
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
assertThat(factoryBean.isDestroy()).isTrue();
|
||||
assertThat(factoryBean.getFieldAnalyzers()).isEqualTo(Collections.singletonMap("fieldThree", mockAnalyzer));
|
||||
assertThat(factoryBean.getFields()).containsAll(Arrays.asList("fieldOne", "fieldTwo"));
|
||||
assertThat(factoryBean.getIndexName()).isEqualTo("TestIndex");
|
||||
assertThat(factoryBean.getLuceneService()).isSameAs(mockLuceneService);
|
||||
assertThat(factoryBean.getRegion()).isSameAs(mockRegion);
|
||||
assertThat(factoryBean.getRegionPath()).isEqualTo("/Grandparent/Parent/Child");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
/*
|
||||
* Copyright 2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
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;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import org.apache.geode.cache.lucene.LuceneQueryProvider;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
|
||||
/**
|
||||
* Unit tests for the {@link LuceneOperations} interface.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Test
|
||||
* @see org.junit.runner.RunWith
|
||||
* @see org.mockito.Mock
|
||||
* @see org.mockito.Mockito
|
||||
* @see org.mockito.runners.MockitoJUnitRunner
|
||||
* @see org.springframework.data.gemfire.search.lucene.LuceneOperations
|
||||
* @since 1.0.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LuceneOperationsUnitTests {
|
||||
|
||||
@Mock
|
||||
private LuceneQueryProvider mockLuceneQueryProvider;
|
||||
|
||||
@Mock
|
||||
private TestLuceneOperations mockLuceneOperations;
|
||||
|
||||
@Test
|
||||
public void stringQueryCallsQueryWithResultLimit() {
|
||||
when(mockLuceneOperations.query(anyString(), anyString(), anyVararg())).thenCallRealMethod();
|
||||
|
||||
mockLuceneOperations.query("title : Up Shit Creek Without a Paddle", "title",
|
||||
"content");
|
||||
|
||||
verify(mockLuceneOperations, times(1)).query(
|
||||
eq("title : Up Shit Creek Without a Paddle"), eq("title"),
|
||||
eq(LuceneOperations.DEFAULT_RESULT_LIMIT), eq("content"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryProviderQueryCallsQueryWithResultLimit() {
|
||||
when(mockLuceneOperations.query(any(LuceneQueryProvider.class), anyVararg())).thenCallRealMethod();
|
||||
|
||||
mockLuceneOperations.query(mockLuceneQueryProvider, "content");
|
||||
|
||||
verify(mockLuceneOperations, times(1)).query(eq(mockLuceneQueryProvider),
|
||||
eq(LuceneOperations.DEFAULT_RESULT_LIMIT), eq("content"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void stringQueryForKeysCallsQueryForKeysWithResultLimit() {
|
||||
when(mockLuceneOperations.queryForKeys(anyString(), anyString())).thenCallRealMethod();
|
||||
|
||||
mockLuceneOperations.queryForKeys("title : Up Shit Creek Without a Paddle", "title");
|
||||
|
||||
verify(mockLuceneOperations, times(1)).queryForKeys(
|
||||
eq("title : Up Shit Creek Without a Paddle"), eq("title"),
|
||||
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryProviderQueryForKeysCallsQueryForKeysWithResultLimit() {
|
||||
when(mockLuceneOperations.queryForKeys(any(LuceneQueryProvider.class))).thenCallRealMethod();
|
||||
|
||||
mockLuceneOperations.queryForKeys(mockLuceneQueryProvider);
|
||||
|
||||
verify(mockLuceneOperations, times(1)).queryForKeys(
|
||||
eq(mockLuceneQueryProvider), eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void stringQueryForValuesCallsQueryForValuesWithResultLimit() {
|
||||
when(mockLuceneOperations.queryForValues(anyString(), anyString())).thenCallRealMethod();
|
||||
|
||||
mockLuceneOperations.queryForValues("title : Up Shit Creek Without a Paddle", "title");
|
||||
|
||||
verify(mockLuceneOperations, times(1)).queryForValues(
|
||||
eq("title : Up Shit Creek Without a Paddle"), eq("title"),
|
||||
eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void queryProviderQueryForValuesCallsQueryForValuesWithResultLimit() {
|
||||
when(mockLuceneOperations.queryForValues(any(LuceneQueryProvider.class))).thenCallRealMethod();
|
||||
|
||||
mockLuceneOperations.queryForValues(mockLuceneQueryProvider);
|
||||
|
||||
verify(mockLuceneOperations, times(1)).queryForValues(
|
||||
eq(mockLuceneQueryProvider), eq(LuceneOperations.DEFAULT_RESULT_LIMIT));
|
||||
}
|
||||
|
||||
abstract class TestLuceneOperations implements LuceneOperations {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
/*
|
||||
* Copyright 2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package org.springframework.data.gemfire.search.lucene;
|
||||
|
||||
import static org.assertj.core.api.Java6Assertions.assertThat;
|
||||
import static org.hamcrest.Matchers.is;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.mockito.Matchers.eq;
|
||||
import static org.mockito.Mockito.doReturn;
|
||||
import static org.mockito.Mockito.spy;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
import org.apache.geode.cache.GemFireCache;
|
||||
import org.apache.geode.cache.lucene.LuceneService;
|
||||
import org.junit.Before;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.rules.ExpectedException;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link LuceneServiceFactoryBean}.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Rule
|
||||
* @see org.junit.Test
|
||||
* @see org.junit.runner.RunWith
|
||||
* @see org.mockito.Mock
|
||||
* @see org.mockito.Mockito
|
||||
* @see org.mockito.Spy
|
||||
* @see org.mockito.runners.MockitoJUnitRunner
|
||||
* @see org.springframework.data.gemfire.search.lucene.LuceneServiceFactoryBean
|
||||
* @since 1.1.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LuceneServiceFactoryBeanUnitTests {
|
||||
|
||||
@Rule
|
||||
public ExpectedException exception = ExpectedException.none();
|
||||
|
||||
@Mock
|
||||
private GemFireCache mockCache;
|
||||
|
||||
@Mock
|
||||
private LuceneService mockLuceneService;
|
||||
|
||||
private LuceneServiceFactoryBean factoryBean;
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
factoryBean = spy(new LuceneServiceFactoryBean());
|
||||
doReturn(mockLuceneService).when(factoryBean).resolveLuceneService(eq(mockCache));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void setAndGetCache() {
|
||||
assertThat(factoryBean.getCache()).isNull();
|
||||
|
||||
factoryBean.setCache(mockCache);
|
||||
|
||||
assertThat(factoryBean.getCache()).isSameAs(mockCache);
|
||||
|
||||
factoryBean.setCache(null);
|
||||
|
||||
assertThat(factoryBean.getCache()).isNull();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void afterPropertiesSetInitializesLuceneService() throws Exception {
|
||||
assertThat(factoryBean.getObject()).isNull();
|
||||
|
||||
factoryBean.setCache(mockCache);
|
||||
factoryBean.afterPropertiesSet();
|
||||
|
||||
assertThat(factoryBean.getObject()).isEqualTo(mockLuceneService);
|
||||
|
||||
verify(factoryBean, times(1)).resolveLuceneService(eq(mockCache));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void afterPropertiesSetThrowsIllegalStateExceptionWhenGemFireCacheIsNull() throws Exception {
|
||||
assertThat(factoryBean.getCache()).isNull();
|
||||
|
||||
exception.expect(IllegalStateException.class);
|
||||
exception.expectCause(is(nullValue(Throwable.class)));
|
||||
exception.expectMessage("A reference to the GemFireCache was not properly configured");
|
||||
|
||||
factoryBean.afterPropertiesSet();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getObjectTypeBeforeInitialization() throws Exception {
|
||||
assertThat(factoryBean.getObject()).isNull();
|
||||
assertThat(factoryBean.getObjectType()).isEqualTo(LuceneService.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getObjectTypeAfterInitialization() throws Exception {
|
||||
factoryBean.setCache(mockCache);
|
||||
factoryBean.afterPropertiesSet();
|
||||
|
||||
assertThat(factoryBean.getObject()).isSameAs(mockLuceneService);
|
||||
assertThat(factoryBean.getObjectType()).isEqualTo(mockLuceneService.getClass());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isSingletonReturnsTrue() {
|
||||
assertThat(factoryBean.isSingleton()).isTrue();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,337 @@
|
||||
/*
|
||||
* Copyright 2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package org.springframework.data.gemfire.search.lucene;
|
||||
|
||||
import static java.util.Arrays.asList;
|
||||
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;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.springframework.data.gemfire.search.lucene.LuceneAccessor.LuceneQueryExecutor;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.geode.cache.lucene.LuceneQuery;
|
||||
import org.apache.geode.cache.lucene.LuceneQueryException;
|
||||
import org.apache.geode.cache.lucene.LuceneQueryFactory;
|
||||
import org.apache.geode.cache.lucene.LuceneQueryProvider;
|
||||
import org.apache.geode.cache.lucene.LuceneResultStruct;
|
||||
import org.apache.geode.cache.lucene.LuceneService;
|
||||
import org.apache.geode.cache.lucene.PageableLuceneQueryResults;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Spy;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link LuceneTemplate}.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Test
|
||||
* @see org.junit.runner.RunWith
|
||||
* @see org.mockito.Mock
|
||||
* @see org.mockito.Mockito
|
||||
* @see org.mockito.Spy
|
||||
* @see org.mockito.runners.MockitoJUnitRunner
|
||||
* @see org.springframework.data.gemfire.search.lucene.LuceneTemplate
|
||||
* @since 1.0.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LuceneTemplateUnitTests {
|
||||
|
||||
@Mock
|
||||
private LuceneQuery<Object, Object> mockLuceneQuery;
|
||||
|
||||
@Mock
|
||||
private LuceneQueryFactory mockLuceneQueryFactory;
|
||||
|
||||
@Mock
|
||||
private LuceneQueryProvider mockLuceneQueryProvider;
|
||||
|
||||
@Mock
|
||||
private LuceneResultStruct<Object, Object> mockLuceneResultStructOne;
|
||||
|
||||
@Mock
|
||||
private LuceneResultStruct<Object, Object> mockLuceneResultStructTwo;
|
||||
|
||||
@Mock
|
||||
private LuceneService mockLuceneService;
|
||||
|
||||
@Mock
|
||||
private PageableLuceneQueryResults<Object, Object> mockPageableLuceneQueryResults;
|
||||
|
||||
@Spy
|
||||
private LuceneTemplate luceneTemplate;
|
||||
|
||||
@Before
|
||||
@SuppressWarnings("deprecation")
|
||||
public void setup() {
|
||||
luceneTemplate.setLuceneService(mockLuceneService);
|
||||
|
||||
when(mockLuceneService.createLuceneQueryFactory()).thenReturn(mockLuceneQueryFactory);
|
||||
when(mockLuceneQueryFactory.setPageSize(anyInt())).thenReturn(mockLuceneQueryFactory);
|
||||
when(mockLuceneQueryFactory.setProjectionFields(anyVararg())).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));
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
List<LuceneResultStruct<Object, Object>> results = luceneTemplate.query(
|
||||
"title : Up Shit Creek Without a Paddle", "title", 100,
|
||||
"content");
|
||||
|
||||
assertThat(results).isNotNull();
|
||||
assertThat(results).hasSize(2);
|
||||
assertThat(results).containsAll(asList(mockLuceneResultStructOne, mockLuceneResultStructTwo));
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
|
||||
@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);
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
PageableLuceneQueryResults<Object, Object> results = luceneTemplate.query(
|
||||
"title : Up Shit Creek Without a Paddle", "title", 100, 20,
|
||||
"content");
|
||||
|
||||
assertThat(results).isSameAs(mockPageableLuceneQueryResults);
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
|
||||
@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));
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
List<LuceneResultStruct<Object, Object>> results = luceneTemplate.query(mockLuceneQueryProvider,
|
||||
100, "content");
|
||||
|
||||
assertThat(results).isNotNull();
|
||||
assertThat(results).hasSize(2);
|
||||
assertThat(results).containsAll(asList(mockLuceneResultStructOne, mockLuceneResultStructTwo));
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
|
||||
@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);
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
PageableLuceneQueryResults<Object, Object> results = luceneTemplate.query(mockLuceneQueryProvider,
|
||||
100, 20, "content");
|
||||
|
||||
assertThat(results).isSameAs(mockPageableLuceneQueryResults);
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
|
||||
@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"));
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
Collection<String> keys = luceneTemplate.queryForKeys(
|
||||
"title : Up Shit Creek Without a Paddle", "title", 100);
|
||||
|
||||
assertThat(keys).isNotNull();
|
||||
assertThat(keys).hasSize(2);
|
||||
assertThat(keys).containsAll(asList("keyOne", "keyTwo"));
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
|
||||
@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"));
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
Collection<String> keys = luceneTemplate.queryForKeys(mockLuceneQueryProvider, 100);
|
||||
|
||||
assertThat(keys).isNotNull();
|
||||
assertThat(keys).hasSize(2);
|
||||
assertThat(keys).containsAll(asList("keyOne", "keyTwo"));
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
|
||||
@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"));
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
Collection<String> keys = luceneTemplate.queryForValues(
|
||||
"title : Up Shit Creek Without a Paddle", "title", 100);
|
||||
|
||||
assertThat(keys).isNotNull();
|
||||
assertThat(keys).hasSize(2);
|
||||
assertThat(keys).containsAll(asList("valueOne", "valueTwo"));
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
|
||||
@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"));
|
||||
|
||||
doReturn("TestIndex").when(luceneTemplate).resolveIndexName();
|
||||
doReturn("/Example").when(luceneTemplate).resolveRegionPath();
|
||||
|
||||
Collection<String> keys = luceneTemplate.queryForValues(mockLuceneQueryProvider, 100);
|
||||
|
||||
assertThat(keys).isNotNull();
|
||||
assertThat(keys).hasSize(2);
|
||||
assertThat(keys).containsAll(asList("valueOne", "valueTwo"));
|
||||
|
||||
verify(luceneTemplate, times(1)).resolveIndexName();
|
||||
verify(luceneTemplate, times(1)).resolveRegionPath();
|
||||
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)).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();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
/*
|
||||
* Copyright 2016 the original author or authors.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package org.springframework.data.gemfire.util;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalArgumentException;
|
||||
import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newIllegalStateException;
|
||||
import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newRuntimeException;
|
||||
import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newUnsupportedOperationException;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link RuntimeExceptionFactory}.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Test
|
||||
* @see org.junit.runner.RunWith
|
||||
* @see org.mockito.Mock
|
||||
* @see org.mockito.Mockito
|
||||
* @see org.mockito.runners.MockitoJUnitRunner
|
||||
* @see org.springframework.data.gemfire.util.RuntimeExceptionFactory
|
||||
* @since 2.0.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class RuntimeExceptionFactoryUnitTests {
|
||||
|
||||
@Mock
|
||||
private Throwable mockCause;
|
||||
|
||||
protected void assertThrowable(Throwable actual, Class<? extends Throwable> type, String message) {
|
||||
assertThrowable(actual, type, message, null);
|
||||
}
|
||||
|
||||
protected void assertThrowable(Throwable actual, Class<? extends Throwable> type, String message, Throwable cause) {
|
||||
assertThat(actual).isNotNull();
|
||||
assertThat(actual).isInstanceOf(type);
|
||||
assertThat(actual).hasMessage(message);
|
||||
assertThat(actual).hasCause(cause);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newIllegalArgumentExceptionWithMessage() {
|
||||
assertThrowable(newIllegalArgumentException("test"), IllegalArgumentException.class, "test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newIllegalArgumentExceptionWithFormattedMessageAndCause() {
|
||||
assertThrowable(newIllegalArgumentException(mockCause, "%1$s is a {1}", "This", "test"),
|
||||
IllegalArgumentException.class, "This is a test", mockCause);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newIllegalStateExceptionWithMessage() {
|
||||
assertThrowable(newIllegalStateException("test"), IllegalStateException.class, "test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newIllegalStateExceptionWithFormattedMessageAndCause() {
|
||||
assertThrowable(newIllegalStateException(mockCause, "%1$s is a {1}", "This", "test"),
|
||||
IllegalStateException.class, "This is a test", mockCause);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newRuntimeExceptionWithMessage() {
|
||||
assertThrowable(newRuntimeException("test"), RuntimeException.class, "test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newRuntimeExceptionWithFormattedMessageAndCause() {
|
||||
assertThrowable(newRuntimeException(mockCause, "%1$s is a {1}", "This", "test"),
|
||||
RuntimeException.class, "This is a test", mockCause);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newUnsupportedOperationExceptionWithMessage() {
|
||||
assertThrowable(newUnsupportedOperationException("test"), UnsupportedOperationException.class, "test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newUnsupportedOperationExceptionWithFormattedMessageAndCause() {
|
||||
assertThrowable(newUnsupportedOperationException(mockCause, "%1$s is a {1}", "This", "test"),
|
||||
UnsupportedOperationException.class, "This is a test", mockCause);
|
||||
}
|
||||
}
|
||||
@@ -19,16 +19,21 @@ package org.springframework.data.gemfire.util;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.mockito.Matchers.argThat;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.never;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.springframework.data.gemfire.test.support.MockitoMatchers.stringArrayMatcher;
|
||||
import static org.springframework.data.gemfire.util.ArrayUtils.asArray;
|
||||
|
||||
import java.util.function.Supplier;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.springframework.beans.factory.config.BeanDefinition;
|
||||
import org.springframework.data.gemfire.test.support.MockitoMatchers;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link SpringUtils}.
|
||||
@@ -49,19 +54,36 @@ public class SpringUtilsUnitTests {
|
||||
|
||||
@Test
|
||||
public void addDependsOnToExistingDependencies() {
|
||||
when(mockBeanDefinition.getDependsOn()).thenReturn(ArrayUtils.asArray("testBeanNameOne", "testBeanNameTwo"));
|
||||
when(mockBeanDefinition.getDependsOn()).thenReturn(asArray("testBeanNameOne", "testBeanNameTwo"));
|
||||
|
||||
assertThat(SpringUtils.addDependsOn(mockBeanDefinition, "testBeanNameThree")).isSameAs(mockBeanDefinition);
|
||||
|
||||
verify(mockBeanDefinition, times(1)).getDependsOn();
|
||||
verify(mockBeanDefinition, times(1)).setDependsOn(argThat(
|
||||
MockitoMatchers.stringArrayMatcher("testBeanNameOne", "testBeanNameTwo", "testBeanNameThree")));
|
||||
stringArrayMatcher("testBeanNameOne", "testBeanNameTwo", "testBeanNameThree")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addDependsOnToNonExistingDependencies() {
|
||||
when(mockBeanDefinition.getDependsOn()).thenReturn(null);
|
||||
|
||||
assertThat(SpringUtils.addDependsOn(mockBeanDefinition, "testBeanName")).isSameAs(mockBeanDefinition);
|
||||
|
||||
verify(mockBeanDefinition, times(1)).getDependsOn();
|
||||
verify(mockBeanDefinition, times(1)).setDependsOn(argThat(MockitoMatchers.stringArrayMatcher("testBeanName")));
|
||||
verify(mockBeanDefinition, times(1)).setDependsOn(argThat(stringArrayMatcher("testBeanName")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void addDependsOnWithMultipleDependenciesWithExistingDependencies() {
|
||||
when(mockBeanDefinition.getDependsOn()).thenReturn(asArray("testBeanNameOne", "testBeanNameTwo"));
|
||||
|
||||
assertThat(SpringUtils.addDependsOn(mockBeanDefinition, "testBeanNameThree", "testBeanNameFour"))
|
||||
.isSameAs(mockBeanDefinition);
|
||||
|
||||
verify(mockBeanDefinition, times(1)).getDependsOn();
|
||||
verify(mockBeanDefinition, times(1))
|
||||
.setDependsOn(argThat(stringArrayMatcher("testBeanNameOne", "testBeanNameTwo",
|
||||
"testBeanNameThree", "testBeanNameFour")));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -101,6 +123,35 @@ public class SpringUtilsUnitTests {
|
||||
assertThat(SpringUtils.defaultIfNull(null, "DEFAULT")).isEqualTo("DEFAULT");
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void defaultIfNullWithSupplierReturnsValue() {
|
||||
Supplier<String> mockSupplier = mock(Supplier.class);
|
||||
|
||||
when(mockSupplier.get()).thenReturn("supplier");
|
||||
|
||||
assertThat(SpringUtils.defaultIfNull("value", mockSupplier)).isEqualTo("value");
|
||||
|
||||
verify(mockSupplier, never()).get();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void defaultIfNullWithSupplierReturnsSupplierValue() {
|
||||
Supplier<String> mockSupplier = mock(Supplier.class);
|
||||
|
||||
when(mockSupplier.get()).thenReturn("supplier");
|
||||
|
||||
assertThat(SpringUtils.defaultIfNull(null, mockSupplier)).isEqualTo("supplier");
|
||||
|
||||
verify(mockSupplier, times(1)).get();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void dereferenceBean() {
|
||||
assertThat(SpringUtils.dereferenceBean("example")).isEqualTo("&example");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void equalsIgnoreNullIsTrue() {
|
||||
assertThat(SpringUtils.equalsIgnoreNull(null, null)).isTrue();
|
||||
@@ -123,13 +174,18 @@ public class SpringUtilsUnitTests {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nullOrEqualsWithNullIsTrue() {
|
||||
assertThat(SpringUtils.nullOrEquals(null, "test")).isTrue();
|
||||
public void nullOrEqualsWithEqualObjectsIsTrue() {
|
||||
assertThat(SpringUtils.nullOrEquals("test", "test")).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nullOrEqualsWithEqualObjectsIsTrue() {
|
||||
assertThat(SpringUtils.nullOrEquals("test", "test")).isTrue();
|
||||
public void nullOrEqualsWithNonNullObjectAndNullIsFalse() {
|
||||
assertThat(SpringUtils.nullOrEquals("test", null)).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nullOrEqualsWithNullIsTrue() {
|
||||
assertThat(SpringUtils.nullOrEquals(null, "test")).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -142,11 +198,6 @@ public class SpringUtilsUnitTests {
|
||||
assertThat(SpringUtils.nullSafeEquals("test", "test")).isTrue();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nullSafeEqualsWithUnequalObjectsIsFalse() {
|
||||
assertThat(SpringUtils.nullSafeEquals("test", "mock")).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void nullSafeEqualsWithNullObjectsIsFalse() {
|
||||
assertThat(SpringUtils.nullSafeEquals(null, "test")).isFalse();
|
||||
@@ -154,7 +205,24 @@ public class SpringUtilsUnitTests {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void dereferenceBean() {
|
||||
assertThat(SpringUtils.dereferenceBean("example")).isEqualTo("&example");
|
||||
public void nullSafeEqualsWithUnequalObjectsIsFalse() {
|
||||
assertThat(SpringUtils.nullSafeEquals("test", "mock")).isFalse();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void safeGetValueReturnsSupplierValue() {
|
||||
assertThat(SpringUtils.safeGetValue(() -> "test", null)).isEqualTo("test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void safeGetValueReturnsDefaultValue() {
|
||||
assertThat(SpringUtils.safeGetValue(() -> { throw new RuntimeException("error"); }, "test"))
|
||||
.isEqualTo("test");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void safeGetValueReturnsNull() {
|
||||
assertThat(SpringUtils.<Object>safeGetValue(() -> { throw new RuntimeException("error"); }))
|
||||
.isEqualTo("test");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user