SGF-402 - Implement support for proper Paging with Projections in Lucene query results.
This commit is contained in:
John Blum
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
* 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.domain;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.springframework.data.gemfire.domain.ListablePage.newListablePage;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.springframework.data.domain.Page;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link ListablePage}.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Test
|
||||
* @since 1.0.0
|
||||
*/
|
||||
public class ListablePageUnitTests {
|
||||
|
||||
@Test
|
||||
public void newListablePageWithArray() {
|
||||
ListablePage<String> page = newListablePage("one", "two", "three");
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page).contains("one", "two", "three");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newListablePageWithList() {
|
||||
ListablePage<Integer> page = newListablePage(Arrays.asList(1, 2, 3));
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page).contains(1, 2, 3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newListablePageWithNull() {
|
||||
ListablePage<Object> page = newListablePage((List<Object>) null);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page).isEmpty();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void listablePageWithContentHasCorrectState() {
|
||||
List<Object> content = Arrays.asList(1, 2, 3);
|
||||
ListablePage<Object> page = newListablePage(content);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page).isNotEmpty();
|
||||
assertThat(page).containsAll(content);
|
||||
assertThat(page.hasContent()).isTrue();
|
||||
assertThat(page.hasNext()).isFalse();
|
||||
assertThat(page.hasPrevious()).isFalse();
|
||||
assertThat(page.isFirst()).isTrue();
|
||||
assertThat(page.isLast()).isTrue();
|
||||
assertThat(page.getContent()).isEqualTo(content);
|
||||
assertThat(page.getNumber()).isEqualTo(1);
|
||||
assertThat(page.getNumberOfElements()).isEqualTo(content.size());
|
||||
assertThat(page.getSize()).isEqualTo(content.size());
|
||||
assertThat(page.getSort()).isNull();
|
||||
assertThat(page.getTotalElements()).isEqualTo(content.size());
|
||||
assertThat(page.getTotalPages()).isEqualTo(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void listablePageWithNoContentHasCorrectState() {
|
||||
ListablePage<Object> page = newListablePage();
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page).isEmpty();
|
||||
assertThat(page.hasContent()).isFalse();
|
||||
assertThat(page.hasNext()).isFalse();
|
||||
assertThat(page.hasPrevious()).isFalse();
|
||||
assertThat(page.isFirst()).isTrue();
|
||||
assertThat(page.isLast()).isTrue();
|
||||
assertThat(page.getContent()).isEqualTo(Collections.emptyList());
|
||||
assertThat(page.getNumber()).isEqualTo(1);
|
||||
assertThat(page.getNumberOfElements()).isEqualTo(0);
|
||||
assertThat(page.getSize()).isEqualTo(0);
|
||||
assertThat(page.getSort()).isNull();
|
||||
assertThat(page.getTotalElements()).isEqualTo(0);
|
||||
assertThat(page.getTotalPages()).isEqualTo(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void iterationIsCorrect() {
|
||||
ListablePage<Object> page = newListablePage(1, 2, 3);
|
||||
List<Object> elements = new ArrayList<>(page.getSize());
|
||||
|
||||
for (Object element : page) {
|
||||
elements.add(element);
|
||||
}
|
||||
|
||||
assertThat(elements).isEqualTo(page.getContent());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mapWithConvertersIsCorrect() {
|
||||
ListablePage<Object> page = newListablePage("1", "2", "3");
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page).hasSize(3);
|
||||
|
||||
Page<Integer> integersPage = page.map(value -> Integer.parseInt(String.valueOf(value)));
|
||||
|
||||
assertThat(integersPage).isNotNull();
|
||||
assertThat(integersPage).contains(1, 2, 3);
|
||||
|
||||
Page<Double> doublesPage = integersPage.map(Integer::doubleValue);
|
||||
|
||||
assertThat(doublesPage).isNotNull();
|
||||
assertThat(doublesPage).contains(1.0d, 2.0d, 3.0d);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,161 @@
|
||||
/*
|
||||
* 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.domain.support;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.mockito.Mockito.doReturn;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Spy;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.springframework.data.domain.Pageable;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link AbstractSliceSupport}.
|
||||
*
|
||||
* @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
|
||||
* @since 1.0.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class AbstractSliceSupportTests {
|
||||
|
||||
@Spy
|
||||
private AbstractSliceSupport mockSlice;
|
||||
|
||||
@Test
|
||||
public void hasContentIsTrue() {
|
||||
doReturn(1).when(mockSlice).getNumberOfElements();
|
||||
assertThat(mockSlice.hasContent()).isTrue();
|
||||
verify(mockSlice, times(1)).getNumberOfElements();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void hasContentIsFalse() {
|
||||
doReturn(0).when(mockSlice).getNumberOfElements();
|
||||
assertThat(mockSlice.hasContent()).isFalse();
|
||||
verify(mockSlice, times(1)).getNumberOfElements();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isFirstReturnsTrueWhenHasPreviousIsFalse() {
|
||||
doReturn(false).when(mockSlice).hasPrevious();
|
||||
assertThat(mockSlice.isFirst()).isTrue();
|
||||
verify(mockSlice, times(1)).hasPrevious();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isFirstReturnsFalseWhenHasPreviousIsTrue() {
|
||||
doReturn(true).when(mockSlice).hasPrevious();
|
||||
assertThat(mockSlice.isFirst()).isFalse();
|
||||
verify(mockSlice, times(1)).hasPrevious();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isLastReturnsTrueWhenHasNextIsFalse() {
|
||||
doReturn(false).when(mockSlice).hasNext();
|
||||
assertThat(mockSlice.isLast()).isTrue();
|
||||
verify(mockSlice, times(1)).hasNext();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isLastReturnFalseWhenHasNextIsTrue() {
|
||||
doReturn(true).when(mockSlice).hasNext();
|
||||
assertThat(mockSlice.isLast()).isFalse();
|
||||
verify(mockSlice, times(1)).hasNext();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getNumberReturnsOne() {
|
||||
doReturn(null).when(mockSlice).previousPageable();
|
||||
assertThat(mockSlice.getNumber()).isEqualTo(1);
|
||||
verify(mockSlice, times(1)).previousPageable();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getNumberReturnsTwo() {
|
||||
Pageable mockPageable = mock(Pageable.class);
|
||||
|
||||
when(mockPageable.previousOrFirst()).thenReturn(mockPageable);
|
||||
when(mockPageable.hasPrevious()).thenReturn(false);
|
||||
doReturn(mockPageable).when(mockSlice).previousPageable();
|
||||
|
||||
assertThat(mockSlice.getNumber()).isEqualTo(2);
|
||||
|
||||
verify(mockSlice, times(1)).previousPageable();
|
||||
verify(mockPageable, times(1)).previousOrFirst();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getNumberReturnsThree() {
|
||||
Pageable mockPageableOne = mock(Pageable.class, "Page One");
|
||||
Pageable mockPageableTwo = mock(Pageable.class, "Page Two");
|
||||
|
||||
when(mockPageableOne.previousOrFirst()).thenReturn(mockPageableOne);
|
||||
when(mockPageableOne.hasPrevious()).thenReturn(false);
|
||||
when(mockPageableTwo.previousOrFirst()).thenReturn(mockPageableOne);
|
||||
when(mockPageableTwo.hasPrevious()).thenReturn(true);
|
||||
doReturn(mockPageableTwo).when(mockSlice).previousPageable();
|
||||
|
||||
assertThat(mockSlice.getNumber()).isEqualTo(3);
|
||||
|
||||
verify(mockSlice, times(1)).previousPageable();
|
||||
verify(mockPageableOne, times(1)).previousOrFirst();
|
||||
verify(mockPageableTwo, times(1)).previousOrFirst();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getNumberOfElementsReturnsTwenty() {
|
||||
List<?> mockContent = mock(List.class);
|
||||
|
||||
when(mockContent.size()).thenReturn(20);
|
||||
doReturn(mockContent).when(mockSlice).getContent();
|
||||
|
||||
assertThat(mockSlice.getNumberOfElements()).isEqualTo(20);
|
||||
|
||||
verify(mockSlice, times(1)).getContent();
|
||||
verify(mockContent, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getSizeCallsGetNumberOfElements() {
|
||||
doReturn(18).when(mockSlice).getNumberOfElements();
|
||||
assertThat(mockSlice.getSize()).isEqualTo(18);
|
||||
verify(mockSlice, times(1)).getNumberOfElements();
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void iteratorWithContent() {
|
||||
doReturn(Arrays.asList(1, 2, 3)).when(mockSlice).getContent();
|
||||
assertThat(mockSlice.iterator()).contains(1, 2, 3);
|
||||
verify(mockSlice, times(1)).getContent();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,201 @@
|
||||
/*
|
||||
* 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 java.io.Serializable;
|
||||
import java.time.LocalDate;
|
||||
import java.time.Month;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import javax.annotation.Resource;
|
||||
|
||||
import org.apache.geode.cache.GemFireCache;
|
||||
import org.apache.geode.cache.Region;
|
||||
import org.apache.geode.cache.lucene.LuceneIndex;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
import org.springframework.context.annotation.Bean;
|
||||
import org.springframework.context.annotation.DependsOn;
|
||||
import org.springframework.data.annotation.Id;
|
||||
import org.springframework.data.gemfire.PartitionedRegionFactoryBean;
|
||||
import org.springframework.data.gemfire.config.annotation.PeerCacheApplication;
|
||||
import org.springframework.test.context.ContextConfiguration;
|
||||
import org.springframework.test.context.junit4.SpringRunner;
|
||||
|
||||
import lombok.Data;
|
||||
import lombok.NonNull;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
|
||||
/**
|
||||
* Integration tests for the Spring Data Geode, Apache Geode and Apache Lucene Integration.
|
||||
*
|
||||
* @author John Blum
|
||||
* @see org.junit.Test
|
||||
* @see lombok
|
||||
* @see org.apache.geode.cache.GemFireCache
|
||||
* @see org.apache.geode.cache.Region
|
||||
* @see org.apache.geode.cache.lucene.LuceneIndex
|
||||
* @see org.springframework.data.gemfire.config.annotation.PeerCacheApplication
|
||||
* @see org.springframework.test.context.ContextConfiguration
|
||||
* @see org.springframework.test.context.junit4.SpringRunner
|
||||
* @since 1.1.0
|
||||
*/
|
||||
@RunWith(SpringRunner.class)
|
||||
@ContextConfiguration
|
||||
@SuppressWarnings("unused")
|
||||
public class LuceneOperationsIntegrationTests {
|
||||
|
||||
private static final AtomicLong IDENTIFIER = new AtomicLong(0L);
|
||||
|
||||
protected static final String LOG_LEVEL = "none";
|
||||
|
||||
private Person jonDoe;
|
||||
private Person janeDoe;
|
||||
private Person cookieDoe;
|
||||
private Person froDoe;
|
||||
private Person hoDoe;
|
||||
private Person pieDoe;
|
||||
private Person sourDoe;
|
||||
|
||||
@Autowired
|
||||
private ProjectingLuceneOperations template;
|
||||
|
||||
@Resource(name = "People")
|
||||
private Region<Long, Person> people;
|
||||
|
||||
protected Person save(Person person) {
|
||||
person.setId(IDENTIFIER.incrementAndGet());
|
||||
people.put(person.getId(), person);
|
||||
return person;
|
||||
}
|
||||
|
||||
@Before
|
||||
public void setup() {
|
||||
jonDoe = save(Person.newPerson(LocalDate.of(1969, Month.JULY, 4), "Jon", "Doe").with("Master of Science"));
|
||||
janeDoe = save(Person.newPerson(LocalDate.of(1969, Month.AUGUST, 16), "Jane", "Doe").with("Doctor of Astrophysics"));
|
||||
cookieDoe = save(Person.newPerson(LocalDate.of(1991, Month.APRIL, 2), "Cookie", "Doe").with("Bachelor of Physics"));
|
||||
froDoe = save(Person.newPerson(LocalDate.of(1988, Month.MAY, 25), "Fro", "Doe").with("Doctor of Computer Science"));
|
||||
hoDoe = save(Person.newPerson(LocalDate.of(1984, Month.NOVEMBER, 11), "Ho", "Doe").with("Doctor of Math"));
|
||||
pieDoe = save(Person.newPerson(LocalDate.of(1996, Month.JUNE, 4), "Pie", "Doe").with("Master of Astronomy"));
|
||||
sourDoe = save(Person.newPerson(LocalDate.of(1999, Month.DECEMBER, 1), "Sour", "Doe").with("Bachelor of Art"));
|
||||
}
|
||||
|
||||
protected List<String> asNames(List<? extends Nameable> nameables) {
|
||||
return nameables.stream().map(Nameable::getName).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
protected List<User> asUsers(Person... people) {
|
||||
return Arrays.stream(people).map(User::from).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void findsDoctorDoesAsTypePersonSuccessfully() {
|
||||
Collection<Person> doctorDoes = template.queryForValues("title: Doctor*", "title");
|
||||
|
||||
assertThat(doctorDoes).isNotNull();
|
||||
assertThat(doctorDoes).hasSize(3);
|
||||
assertThat(doctorDoes).contains(janeDoe, froDoe, hoDoe);
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("all")
|
||||
public void findsMasterDoesAsTypeUserSuccessfully() {
|
||||
List<User> masterDoes = template.query("title: Master*", "title", User.class);
|
||||
|
||||
assertThat(masterDoes).isNotNull();
|
||||
assertThat(masterDoes).hasSize(2);
|
||||
assertThat(masterDoes.stream().allMatch(user -> user instanceof User)).isTrue();
|
||||
assertThat(asNames(masterDoes)).containsAll(asNames(asUsers(jonDoe, pieDoe)));
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
@PeerCacheApplication(name = "LuceneOperationsIntegrationTests", logLevel = LOG_LEVEL)
|
||||
static class LuceneOperationsIntegrationTestConfiguration {
|
||||
|
||||
@Bean(name = "People")
|
||||
@DependsOn("personTitleIndex")
|
||||
PartitionedRegionFactoryBean<Long, Person> peopleRegion(GemFireCache gemfireCache) {
|
||||
PartitionedRegionFactoryBean<Long, Person> peopleRegion = new PartitionedRegionFactoryBean<>();
|
||||
|
||||
peopleRegion.setCache(gemfireCache);
|
||||
peopleRegion.setClose(false);
|
||||
peopleRegion.setPersistent(false);
|
||||
|
||||
return peopleRegion;
|
||||
}
|
||||
|
||||
@Bean
|
||||
LuceneIndexFactoryBean personTitleIndex(GemFireCache gemFireCache) {
|
||||
LuceneIndexFactoryBean luceneIndex = new LuceneIndexFactoryBean();
|
||||
|
||||
luceneIndex.setCache(gemFireCache);
|
||||
luceneIndex.setFields("title");
|
||||
luceneIndex.setRegionPath("/People");
|
||||
|
||||
return luceneIndex;
|
||||
}
|
||||
|
||||
@Bean
|
||||
ProjectingLuceneOperations luceneTemplate(LuceneIndex luceneIndex) {
|
||||
return new ProjectingLuceneTemplate("personTitleIndex", "/People");
|
||||
}
|
||||
}
|
||||
|
||||
interface Nameable {
|
||||
String getName();
|
||||
}
|
||||
|
||||
@Data
|
||||
@RequiredArgsConstructor(staticName = "newPerson")
|
||||
static class Person implements Nameable, Serializable {
|
||||
|
||||
@Id
|
||||
Long id;
|
||||
|
||||
@NonNull LocalDate birthDate;
|
||||
|
||||
@NonNull String firstName;
|
||||
@NonNull String lastName;
|
||||
|
||||
String title;
|
||||
|
||||
public String getName() {
|
||||
return String.format("%1$s %2$s", getFirstName(), getLastName());
|
||||
}
|
||||
|
||||
Person with(String title) {
|
||||
setTitle(title);
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
interface User extends Nameable {
|
||||
static User from(Person person) {
|
||||
return person::getName;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,549 @@
|
||||
/*
|
||||
* 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.support;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.mockito.Matchers.eq;
|
||||
import static org.mockito.Matchers.isA;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.springframework.data.gemfire.search.lucene.support.LucenePage.newLucenePage;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicLong;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import org.apache.geode.cache.lucene.LuceneResultStruct;
|
||||
import org.apache.geode.cache.lucene.PageableLuceneQueryResults;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.runners.MockitoJUnitRunner;
|
||||
import org.springframework.data.domain.Page;
|
||||
import org.springframework.data.gemfire.search.lucene.ProjectingLuceneAccessor;
|
||||
|
||||
import lombok.Data;
|
||||
import lombok.NonNull;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
|
||||
/**
|
||||
* Unit tests for {@link LucenePage}.
|
||||
*
|
||||
* @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.ProjectingLuceneAccessor
|
||||
* @see org.springframework.data.gemfire.search.lucene.support.LucenePage
|
||||
* @see org.apache.geode.cache.lucene.LuceneResultStruct
|
||||
* @see org.apache.geode.cache.lucene.PageableLuceneQueryResults
|
||||
* @since 1.0.0
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LucenePageUnitTests {
|
||||
|
||||
@Mock
|
||||
private PageableLuceneQueryResults<Long, String> mockQueryResults;
|
||||
|
||||
@Mock
|
||||
private ProjectingLuceneAccessor mockTemplate;
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
protected <K, V> LuceneResultStruct<K, V> mockLuceneResultStruct(K key, V value) {
|
||||
LuceneResultStruct<K, V> mockLuceneResultStruct = mock(LuceneResultStruct.class);
|
||||
|
||||
when(mockLuceneResultStruct.getKey()).thenReturn(key);
|
||||
when(mockLuceneResultStruct.getValue()).thenReturn(value);
|
||||
|
||||
return mockLuceneResultStruct;
|
||||
}
|
||||
|
||||
protected List<LuceneResultStruct<Long, String>> mockLuceneResultStructList(List<Person> people) {
|
||||
AtomicLong id = new AtomicLong(0L);
|
||||
|
||||
return people.stream().map(person -> mockLuceneResultStruct(id.incrementAndGet(), person.getName()))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
protected List<LuceneResultStruct<Long, String>> prepare(PageableLuceneQueryResults<Long, String> mockQueryResults,
|
||||
Person... results) {
|
||||
|
||||
return prepare(mockQueryResults, Arrays.asList(results), results.length).get(0);
|
||||
}
|
||||
|
||||
protected List<LuceneResultStruct<Long, String>> prepare(PageableLuceneQueryResults<Long, String> mockQueryResults,
|
||||
Iterable<Person> results) {
|
||||
|
||||
return prepare(mockQueryResults, results, size(results)).get(0);
|
||||
}
|
||||
|
||||
protected List<List<LuceneResultStruct<Long, String>>> prepare(
|
||||
PageableLuceneQueryResults<Long, String> mockQueryResults, Iterable<Person> results, int pageSize) {
|
||||
|
||||
List<List<Person>> pages = paginate(results, pageSize);
|
||||
|
||||
List<List<LuceneResultStruct<Long, String>>> resultStructs =
|
||||
pages.stream().map(this::mockLuceneResultStructList).collect(Collectors.toList());
|
||||
|
||||
Iterator iterator = resultStructs.iterator();
|
||||
|
||||
when(mockQueryResults.hasNext()).thenAnswer(invocation -> iterator.hasNext());
|
||||
when(mockQueryResults.next()).thenAnswer(invocation -> iterator.next());
|
||||
|
||||
return resultStructs;
|
||||
}
|
||||
|
||||
private List<List<Person>> paginate(Iterable<Person> people, int pageSize) {
|
||||
List<List<Person>> pages = new ArrayList<>();
|
||||
List<Person> page = new ArrayList<>(pageSize);
|
||||
|
||||
for (Person person : people) {
|
||||
if (page.size() == pageSize) {
|
||||
pages.add(page);
|
||||
page = new ArrayList<>(pageSize);
|
||||
}
|
||||
|
||||
page.add(person);
|
||||
}
|
||||
|
||||
pages.add(page);
|
||||
|
||||
return pages;
|
||||
}
|
||||
|
||||
private int size(Iterable<?> iterable) {
|
||||
int size = 0;
|
||||
|
||||
for (Object element : iterable) {
|
||||
size++;
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
protected ProjectingLuceneAccessor prepare(ProjectingLuceneAccessor mockTemplate) {
|
||||
when(mockTemplate.project(isA(List.class), eq(Person.class))).thenAnswer(invocation -> {
|
||||
List<LuceneResultStruct<Long, String>> results = invocation.getArgumentAt(0, List.class);
|
||||
assertThat(invocation.getArgumentAt(1, Class.class)).isEqualTo(Person.class);
|
||||
return results.stream().map(result -> Person.parse(result.getValue())).collect(Collectors.toList());
|
||||
});
|
||||
|
||||
return mockTemplate;
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void newLucenePageWithNoPreviousPageIsMaterialized() {
|
||||
List<Person> people = Collections.singletonList(Person.newPerson("Jon", "Doe"));
|
||||
|
||||
List<LuceneResultStruct<Long, String>> mockResultStructList = prepare(mockQueryResults, people);
|
||||
|
||||
LucenePage<Person, Long, String> page =
|
||||
newLucenePage(prepare(mockTemplate), mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getContent()).isEqualTo(people);
|
||||
assertThat(page.getPageSize()).isEqualTo(20);
|
||||
assertThat(page.getPrevious()).isNull();
|
||||
assertThat(page.getProjectionType()).isEqualTo(Person.class);
|
||||
assertThat(page.getQueryResults()).isSameAs(mockQueryResults);
|
||||
assertThat(page.getTemplate()).isSameAs(mockTemplate);
|
||||
assertThat(page.hasNext()).isFalse();
|
||||
assertThat(page.hasPrevious()).isFalse();
|
||||
|
||||
verify(mockQueryResults, times(2)).hasNext();
|
||||
verify(mockQueryResults, times(1)).next();
|
||||
verifyNoMoreInteractions(mockQueryResults);
|
||||
verify(mockTemplate, times(1)).project(eq(mockResultStructList), eq(Person.class));
|
||||
verifyNoMoreInteractions(mockTemplate);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void newLucenePageWithPreviousPageIsMaterialized() {
|
||||
List<Person> expectedContent = Arrays.asList(Person.newPerson("Jon", "Doe"), Person.newPerson("Jane", "Doe"));
|
||||
|
||||
List<List<LuceneResultStruct<Long, String>>> mockResults =
|
||||
prepare(mockQueryResults, expectedContent, 1);
|
||||
|
||||
LucenePage<Person, Long, String> firstPage =
|
||||
newLucenePage(prepare(mockTemplate), mockQueryResults, 1, Person.class);
|
||||
|
||||
LucenePage<Person, Long, String> secondPage =
|
||||
newLucenePage(mockTemplate, mockQueryResults, 1, Person.class, firstPage);
|
||||
|
||||
assertThat(secondPage).isNotNull();
|
||||
assertThat(secondPage.getContent()).isEqualTo(Collections.singletonList(expectedContent.get(1)));
|
||||
assertThat(secondPage.getPageSize()).isEqualTo(1);
|
||||
assertThat(secondPage.getPrevious()).isEqualTo(firstPage);
|
||||
assertThat(secondPage.getProjectionType()).isEqualTo(Person.class);
|
||||
assertThat(secondPage.getQueryResults()).isSameAs(mockQueryResults);
|
||||
assertThat(secondPage.getTemplate()).isSameAs(mockTemplate);
|
||||
assertThat(secondPage.hasNext()).isFalse();
|
||||
assertThat(secondPage.hasPrevious()).isTrue();
|
||||
|
||||
verify(mockQueryResults, times(3)).hasNext();
|
||||
verify(mockQueryResults, times(2)).next();
|
||||
verifyNoMoreInteractions(mockQueryResults);
|
||||
verify(mockTemplate, times(1))
|
||||
.project(eq(mockResults.get(0)), eq(Person.class));
|
||||
verify(mockTemplate, times(1))
|
||||
.project(eq(mockResults.get(1)), eq(Person.class));
|
||||
verifyNoMoreInteractions(mockTemplate);
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void newLucenePageWithNullTemplateThrowsIllegalArgumentException() {
|
||||
try {
|
||||
newLucenePage(null, mockQueryResults, 10, Person.class);
|
||||
}
|
||||
catch (IllegalArgumentException expected) {
|
||||
assertThat(expected).hasMessage("ProjectingLuceneAccessor must not be null");
|
||||
assertThat(expected).hasNoCause();
|
||||
|
||||
throw expected;
|
||||
}
|
||||
finally {
|
||||
verifyZeroInteractions(mockQueryResults);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void newLucenePageWithNullQueryResultsThrowsIllegalArgumentException() {
|
||||
try {
|
||||
newLucenePage(mockTemplate, null, 10, Person.class);
|
||||
}
|
||||
catch (IllegalArgumentException expected) {
|
||||
assertThat(expected).hasMessage("PageableLuceneQueryResults must not be null");
|
||||
assertThat(expected).hasNoCause();
|
||||
|
||||
throw expected;
|
||||
}
|
||||
finally {
|
||||
verifyZeroInteractions(mockTemplate);
|
||||
}
|
||||
}
|
||||
|
||||
@Test(expected = IllegalArgumentException.class)
|
||||
public void newLucenePageWithNoContentThrowsIllegalArgumentException() {
|
||||
try {
|
||||
when(mockQueryResults.hasNext()).thenReturn(false);
|
||||
newLucenePage(mockTemplate, mockQueryResults, 10, Person.class);
|
||||
}
|
||||
catch (IllegalArgumentException expected) {
|
||||
assertThat(expected).hasMessage("PageableLuceneQueryResults must have content");
|
||||
assertThat(expected).hasNoCause();
|
||||
|
||||
throw expected;
|
||||
}
|
||||
finally {
|
||||
verify(mockQueryResults, times(1)).hasNext();
|
||||
verifyZeroInteractions(mockTemplate);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getNextReturnsNextPage() {
|
||||
List<Person> expectedContent = Arrays.asList(Person.newPerson("Jon", "Doe"), Person.newPerson("Jane", "Doe"));
|
||||
|
||||
List<List<LuceneResultStruct<Long, String>>> mockResults =
|
||||
prepare(mockQueryResults, expectedContent, 1);
|
||||
|
||||
LucenePage<Person, Long, String> firstPage =
|
||||
newLucenePage(prepare(mockTemplate), mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(firstPage).isNotNull();
|
||||
assertThat(firstPage.getContent()).isEqualTo(Collections.singletonList(expectedContent.get(0)));
|
||||
|
||||
LucenePage<Person, Long, String> nextPage = firstPage.getNext();
|
||||
|
||||
assertThat(nextPage).isNotNull();
|
||||
assertThat(nextPage.getContent()).isEqualTo(Collections.singletonList(expectedContent.get(1)));
|
||||
|
||||
verify(mockQueryResults, times(3)).hasNext();
|
||||
verify(mockQueryResults, times(2)).next();
|
||||
verifyNoMoreInteractions(mockQueryResults);
|
||||
verify(mockTemplate, times(1)).project(eq(mockResults.get(0)), eq(Person.class));
|
||||
verify(mockTemplate, times(1)).project(eq(mockResults.get(1)), eq(Person.class));
|
||||
verifyNoMoreInteractions(mockQueryResults);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Test(expected = IllegalStateException.class)
|
||||
public void getNextThrowsIllegalStateExceptionWhenNoMorePages() {
|
||||
try {
|
||||
prepare(mockQueryResults, Person.newPerson("Jon", "Doe"));
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getPrevious()).isNull();
|
||||
|
||||
page.getNext();
|
||||
}
|
||||
catch (IllegalStateException expected) {
|
||||
assertThat(expected).hasMessage("No more pages");
|
||||
assertThat(expected).hasNoCause();
|
||||
|
||||
throw expected;
|
||||
}
|
||||
finally {
|
||||
verify(mockQueryResults, times(2)).hasNext();
|
||||
verify(mockQueryResults, times(1)).next();
|
||||
verifyNoMoreInteractions(mockQueryResults);
|
||||
verify(mockTemplate, times(1)).project(isA(List.class), eq(Person.class));
|
||||
verifyNoMoreInteractions(mockTemplate);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void getNumberReturnsOne() {
|
||||
prepare(mockQueryResults, Person.newPerson("Jon", "Doe"));
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getPrevious()).isNull();
|
||||
assertThat(page.getNumber()).isEqualTo(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void getNumberReturnsTwo() {
|
||||
prepare(mockQueryResults, Arrays.asList(Person.newPerson("Jon", "Doe"), Person.newPerson("Jane", "Doe")),
|
||||
1);
|
||||
|
||||
LucenePage<Person, Long, String> previousPage =
|
||||
newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
LucenePage<Person, Long, String> page =
|
||||
newLucenePage(mockTemplate, mockQueryResults, 20, Person.class, previousPage);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getPrevious()).isEqualTo(previousPage);
|
||||
assertThat(page.getNumber()).isEqualTo(2);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void getNumberReturnsThree() {
|
||||
prepare(mockQueryResults, Arrays.asList(Person.newPerson("Jon", "Doe"), Person.newPerson("Jane", "Doe"),
|
||||
Person.newPerson("Pie", "Doe")), 1);
|
||||
|
||||
LucenePage<Person, Long, String> firstPage = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
LucenePage<Person, Long, String> secondPage =
|
||||
newLucenePage(mockTemplate, mockQueryResults, 20, Person.class, firstPage);
|
||||
|
||||
LucenePage<Person, Long, String> thirdPage =
|
||||
newLucenePage(mockTemplate, mockQueryResults, 20, Person.class, secondPage);
|
||||
|
||||
assertThat(thirdPage).isNotNull();
|
||||
assertThat(thirdPage.getPrevious()).isEqualTo(secondPage);
|
||||
assertThat(secondPage.getPrevious()).isEqualTo(firstPage);
|
||||
assertThat(firstPage.getPrevious()).isNull();
|
||||
assertThat(thirdPage.getNumber()).isEqualTo(3);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getSizeWithNoContentEqualsPageSize() {
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getNumberOfElements()).isEqualTo(0);
|
||||
assertThat(page.getPageSize()).isEqualTo(20);
|
||||
assertThat(page.getSize()).isEqualTo(20);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void getSizeWithSingleElementEqualsPageSize() {
|
||||
prepare(mockQueryResults, Person.newPerson("Jon", "Doe"));
|
||||
|
||||
LucenePage<Person, Long, String> page =
|
||||
newLucenePage(prepare(mockTemplate), mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getNumberOfElements()).isEqualTo(1);
|
||||
assertThat(page.getPageSize()).isEqualTo(20);
|
||||
assertThat(page.getSize()).isEqualTo(20);
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void getSizeWithMultipleElementsEqualsPageSize() {
|
||||
List<Person> mockList = mock(List.class);
|
||||
|
||||
when(mockList.size()).thenReturn(101);
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
when(mockTemplate.project(isA(List.class), eq(Person.class))).thenReturn(mockList);
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getNumberOfElements()).isEqualTo(101);
|
||||
assertThat(page.getPageSize()).isEqualTo(20);
|
||||
assertThat(page.getSize()).isEqualTo(20);
|
||||
|
||||
verify(mockList, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void totalElementsEqualsLuceneQueryResultsSize() {
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
when(mockQueryResults.size()).thenReturn(409);
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getTotalElements()).isEqualTo(409);
|
||||
|
||||
verify(mockQueryResults, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void totalPagesIsOneWhenTotalElementsIsLessThanPageSize() {
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
when(mockQueryResults.size()).thenReturn(9);
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getTotalPages()).isEqualTo(1);
|
||||
|
||||
verify(mockQueryResults, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void totalPagesIsOneWhenTotalElementsEqualsPageSize() {
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
when(mockQueryResults.size()).thenReturn(20);
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getTotalPages()).isEqualTo(1);
|
||||
|
||||
verify(mockQueryResults, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void totalPagesIsTwoWhenTotalElementsIsGreaterThanPageSize() {
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
when(mockQueryResults.size()).thenReturn(31);
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getTotalPages()).isEqualTo(2);
|
||||
|
||||
verify(mockQueryResults, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void totalPagesIsFiveWhenTotalElementsIsGreaterThanEqualToPageSize() {
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
when(mockQueryResults.size()).thenReturn(100);
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getTotalPages()).isEqualTo(5);
|
||||
|
||||
verify(mockQueryResults, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void totalPagesIsSixWhenTotalElementsIsGreaterThanPageSize() {
|
||||
when(mockQueryResults.hasNext()).thenReturn(true);
|
||||
when(mockQueryResults.next()).thenReturn(Collections.emptyList());
|
||||
when(mockQueryResults.size()).thenReturn(101);
|
||||
|
||||
LucenePage<Person, Long, String> page = newLucenePage(mockTemplate, mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getTotalPages()).isEqualTo(6);
|
||||
|
||||
verify(mockQueryResults, times(1)).size();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void mapIsSuccessful() {
|
||||
List<Person> expectedContent = Arrays.asList(Person.newPerson("Jon", "Doe"), Person.newPerson("Jane", "Doe"));
|
||||
|
||||
prepare(mockQueryResults, expectedContent);
|
||||
|
||||
LucenePage<Person, Long, String> page =
|
||||
newLucenePage(prepare(mockTemplate), mockQueryResults, 20, Person.class);
|
||||
|
||||
assertThat(page).isNotNull();
|
||||
assertThat(page.getNumberOfElements()).isEqualTo(expectedContent.size());
|
||||
assertThat(page).containsAll(expectedContent);
|
||||
|
||||
Page<User> users = page.map(User::from);
|
||||
|
||||
assertThat(users).isNotNull();
|
||||
assertThat(users.getNumberOfElements()).isEqualTo(expectedContent.size());
|
||||
assertThat(users).contains(User.newUser("jonDoe"), User.newUser("janeDoe"));
|
||||
}
|
||||
|
||||
@Data
|
||||
@RequiredArgsConstructor(staticName = "newPerson")
|
||||
static class Person {
|
||||
@NonNull String firstName;
|
||||
@NonNull String lastName;
|
||||
|
||||
static Person parse(String name) {
|
||||
String[] firstNameLastName = name.split(" ");
|
||||
return newPerson(firstNameLastName[0], firstNameLastName[1]);
|
||||
}
|
||||
|
||||
String getName() {
|
||||
return String.format("%1$s %2$s", getFirstName(), getLastName());
|
||||
}
|
||||
}
|
||||
|
||||
@Data
|
||||
@RequiredArgsConstructor(staticName = "newUser")
|
||||
static class User {
|
||||
@NonNull String name;
|
||||
|
||||
static User from(Person person) {
|
||||
return newUser(String.format("%1$s%2$s", person.getFirstName().toLowerCase(), person.getLastName()));
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user