Cwikius-Spring/spring-data-elasticsearch
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-data-elasticsearch.git synced 2025-05-31 09:12:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

DATAES-772 - Polishing.

Browse Source
This commit is contained in:
Peter-Josef Meisch 2020-04-17 21:40:54 +02:00
parent 76e91c3366
commit f6a37f4601
8 changed files with 114 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/org/springframework/data/elasticsearch/core/SearchHitSupport.java
View File

@ -97,7 +97,7 @@ public final class SearchHitSupport {
}
private static CloseableIterator<?> unwrapSearchHitsIterator(SearchHitsIterator<?> iterator) {
return new CloseableIterator<Object>() {
@Override
public boolean hasNext() {

4
src/main/java/org/springframework/data/elasticsearch/core/event/AfterConvertCallback.java
View File

@ -30,8 +30,8 @@ import org.springframework.data.mapping.callback.EntityCallback;
public interface AfterConvertCallback<T> extends EntityCallback<T> {
/**
* Entity callback method invoked after a domain object is materialized from a {@link Document}. Can return either
* the same or a modified instance of the domain object.
* Entity callback method invoked after a domain object is materialized from a {@link Document}. Can return either the
* same or a modified instance of the domain object.
*
* @param entity the domain object (the result of the conversion).
* @param document must not be {@literal null}.

4
src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveAfterConvertCallback.java
View File

@ -31,8 +31,8 @@ import org.springframework.data.mapping.callback.EntityCallback;
public interface ReactiveAfterConvertCallback<T> extends EntityCallback<T> {
/**
* Entity callback method invoked after a domain object is materialized from a {@link Document}. Can return either
* the same or a modified instance of the domain object.
* Entity callback method invoked after a domain object is materialized from a {@link Document}. Can return either the
* same or a modified instance of the domain object.
*
* @param entity the domain object (the result of the conversion).
* @param document must not be {@literal null}.

94
src/test/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplateCallbackTests.java
View File

@ -69,7 +69,7 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
protected final void initTemplate(AbstractElasticsearchTemplate template) {
this.template = template;
this.template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback, afterConvertCallback));
}
@ -206,9 +206,7 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
}
private Document lukeDocument() {
return Document.create()
.append("id", "init")
.append("firstname", "luke");
return Document.create().append("id", "init").append("firstname", "luke");
}
@Test // DATAES-772
@ -235,8 +233,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
List<Person> results = template.multiGet(queryForTwo(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
@ -267,8 +265,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@SuppressWarnings("deprecation") // we know what we test
AggregatedPage<Person> results = template.queryForPage(queryForTwo(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.getContent().get(0).id).isEqualTo("after-convert");
assertThat(results.getContent().get(1).id).isEqualTo("after-convert");
}
@ -279,8 +277,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@SuppressWarnings("deprecation") // we know what we test
List<Page<Person>> results = template.queryForPage(singletonList(queryForTwo()), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<Person> persons = results.get(0).getContent();
assertThat(persons.get(0).id).isEqualTo("after-convert");
assertThat(persons.get(1).id).isEqualTo("after-convert");
@ -290,14 +288,12 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
void queryForPageWithMultipleQueriesAndEntityClassesShouldInvokeAfterConvertCallback() {
@SuppressWarnings("deprecation") // we know what we test
List<AggregatedPage<?>> results = template.queryForPage(singletonList(queryForTwo()),
singletonList(Person.class), index);
List<AggregatedPage<?>> results = template.queryForPage(singletonList(queryForTwo()), singletonList(Person.class),
index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
List<Person> persons = results.get(0).getContent().stream()
.map(Person.class::cast)
.collect(Collectors.toList());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<Person> persons = results.get(0).getContent().stream().map(Person.class::cast).collect(Collectors.toList());
assertThat(persons.get(0).id).isEqualTo("after-convert");
assertThat(persons.get(1).id).isEqualTo("after-convert");
}
@ -307,8 +303,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
CloseableIterator<Person> results = template.stream(queryForTwo(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.next().id).isEqualTo("after-convert");
assertThat(results.next().id).isEqualTo("after-convert");
}
@ -322,8 +318,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
assertThat(results.next().id).isEqualTo("after-convert");
assertThat(results.next().id).isEqualTo("after-convert");
verify(afterConvertCallback, times(4))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(4)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
}
private void skipItemsFromScrollStart(CloseableIterator<Person> results) {
@ -337,8 +333,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@SuppressWarnings("deprecation") // we know what we test
List<Person> results = template.queryForList(queryForTwo(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
@ -349,8 +345,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@SuppressWarnings("deprecation") // we know what we test
List<List<Person>> results = template.queryForList(singletonList(queryForTwo()), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<Person> persons = results.get(0);
assertThat(persons.get(0).id).isEqualTo("after-convert");
assertThat(persons.get(1).id).isEqualTo("after-convert");
@ -362,11 +358,9 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@SuppressWarnings("deprecation") // we know what we test
List<List<?>> results = template.queryForList(singletonList(queryForTwo()), singletonList(Person.class), index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
List<Person> persons = results.get(0).stream()
.map(Person.class::cast)
.collect(Collectors.toList());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<Person> persons = results.get(0).stream().map(Person.class::cast).collect(Collectors.toList());
assertThat(persons.get(0).id).isEqualTo("after-convert");
assertThat(persons.get(1).id).isEqualTo("after-convert");
}
@ -377,8 +371,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@SuppressWarnings("deprecation") // we know what we test
AggregatedPage<Person> results = template.moreLikeThis(moreLikeThisQuery(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.getContent().get(0).id).isEqualTo("after-convert");
assertThat(results.getContent().get(1).id).isEqualTo("after-convert");
}
@ -408,8 +402,7 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
SearchHit<Person> result = template.searchOne(queryForOne(), Person.class, index);
verify(afterConvertCallback)
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
assertThat(result.getContent().id).isEqualTo("after-convert");
}
@ -418,8 +411,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
List<SearchHits<Person>> results = template.multiSearch(singletonList(queryForTwo()), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<SearchHit<Person>> hits = results.get(0).getSearchHits();
assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
@ -428,11 +421,11 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void multiSearchWithMultipleEntityClassesShouldInvokeAfterConvertCallback() {
List<SearchHits<?>> results = template.multiSearch(singletonList(queryForTwo()),
singletonList(Person.class), index);
List<SearchHits<?>> results = template.multiSearch(singletonList(queryForTwo()), singletonList(Person.class),
index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<? extends SearchHit<?>> hits = results.get(0).getSearchHits();
assertThat(((Person) hits.get(0).getContent()).id).isEqualTo("after-convert");
assertThat(((Person) hits.get(1).getContent()).id).isEqualTo("after-convert");
@ -443,8 +436,7 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
SearchHits<Person> results = template.search(queryForTwo(), Person.class);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
List<SearchHit<Person>> hits = results.getSearchHits();
assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
@ -455,8 +447,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
SearchHits<Person> results = template.search(queryForTwo(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<SearchHit<Person>> hits = results.getSearchHits();
assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
@ -467,8 +459,7 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
SearchHits<Person> results = template.search(moreLikeThisQuery(), Person.class);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
List<SearchHit<Person>> hits = results.getSearchHits();
assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
@ -479,8 +470,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
SearchHits<Person> results = template.search(moreLikeThisQuery(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
List<SearchHit<Person>> hits = results.getSearchHits();
assertThat(hits.get(0).getContent().id).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().id).isEqualTo("after-convert");
@ -491,8 +482,7 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
SearchHitsIterator<Person> results = template.searchForStream(queryForTwo(), Person.class);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(results.next().getContent().id).isEqualTo("after-convert");
assertThat(results.next().getContent().id).isEqualTo("after-convert");
}
@ -502,8 +492,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
SearchHitsIterator<Person> results = template.searchForStream(queryForTwo(), Person.class, index);
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.next().getContent().id).isEqualTo("after-convert");
assertThat(results.next().getContent().id).isEqualTo("after-convert");
}

22
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchRestTemplateCallbackTests.java
View File

@ -77,15 +77,15 @@ class ElasticsearchRestTemplateCallbackTests extends AbstractElasticsearchTempla
doReturn(true).when(getResponse).isExists();
doReturn(false).when(getResponse).isSourceEmpty();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
{
put("id", "init");
put("firstname", "luke");
}
}).when(getResponse).getSourceAsMap();
doReturn(multiGetResponse).when(client).mget(any(MultiGetRequest.class), any(RequestOptions.class));
doReturn(new MultiGetItemResponse[]{multiGetItemResponse, multiGetItemResponse})
.when(multiGetResponse).getResponses();
doReturn(new MultiGetItemResponse[] { multiGetItemResponse, multiGetItemResponse }).when(multiGetResponse)
.getResponses();
doReturn(getResponse).when(multiGetItemResponse).getResponse();
doReturn(searchResponse).when(client).search(any(SearchRequest.class), any(RequestOptions.class));
@ -93,14 +93,14 @@ class ElasticsearchRestTemplateCallbackTests extends AbstractElasticsearchTempla
doReturn("scroll-id").when(searchResponse).getScrollId();
doReturn(new BytesArray(new byte[8])).when(searchHit).getSourceRef();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
{
put("id", "init");
put("firstname", "luke");
}
}).when(searchHit).getSourceAsMap();
MultiSearchResponse multiSearchResponse = new MultiSearchResponse(
new MultiSearchResponse.Item[]{ multiSearchResponseItem }, 1L);
new MultiSearchResponse.Item[] { multiSearchResponseItem }, 1L);
doReturn(multiSearchResponse).when(client).multiSearch(any(MultiSearchRequest.class), any());
doReturn(searchResponse).when(multiSearchResponseItem).getResponse();

22
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTransportTemplateCallbackTests.java
View File

@ -98,17 +98,17 @@ class ElasticsearchTransportTemplateCallbackTests extends AbstractElasticsearchT
doReturn(true).when(getResponse).isExists();
doReturn(false).when(getResponse).isSourceEmpty();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
{
put("id", "init");
put("firstname", "luke");
}
}).when(getResponse).getSourceAsMap();
when(client.prepareMultiGet()).thenReturn(multiGetRequestBuilder);
doReturn(multiGetResponseActionFuture).when(multiGetRequestBuilder).execute();
when(multiGetResponseActionFuture.actionGet()).thenReturn(multiGetResponse);
doReturn(new MultiGetItemResponse[]{ multiGetItemResponse, multiGetItemResponse })
.when(multiGetResponse).getResponses();
doReturn(new MultiGetItemResponse[] { multiGetItemResponse, multiGetItemResponse }).when(multiGetResponse)
.getResponses();
doReturn(getResponse).when(multiGetItemResponse).getResponse();
when(client.prepareSearch(anyVararg())).thenReturn(searchRequestBuilder);
@ -123,15 +123,15 @@ class ElasticsearchTransportTemplateCallbackTests extends AbstractElasticsearchT
doReturn("scroll-id").when(searchResponse).getScrollId();
doReturn(new BytesArray(new byte[8])).when(searchHit).getSourceRef();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
{
put("id", "init");
put("firstname", "luke");
}
}).when(searchHit).getSourceAsMap();
when(client.multiSearch(any(MultiSearchRequest.class))).thenReturn(multiSearchResponseActionFuture);
MultiSearchResponse multiSearchResponse = new MultiSearchResponse(
new MultiSearchResponse.Item[]{ multiSearchResponseItem }, 1L);
new MultiSearchResponse.Item[] { multiSearchResponseItem }, 1L);
when(multiSearchResponseActionFuture.actionGet()).thenReturn(multiSearchResponse);
doReturn(searchResponse).when(multiSearchResponseItem).getResponse();

103
src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateCallbackTests.java
View File

@ -99,10 +99,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
doReturn(true).when(getResult).isExists();
doReturn(false).when(getResult).isSourceEmpty();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
{
put("id", "init");
put("firstname", "luke");
}
}).when(getResult).getSource();
doReturn(Mono.just(getResult)).when(client).get(any(GetRequest.class));
@ -110,10 +110,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
when(client.search(any(SearchRequest.class))).thenReturn(Flux.just(searchHit, searchHit));
doReturn(new BytesArray(new byte[8])).when(searchHit).getSourceRef();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
{
put("id", "init");
put("firstname", "luke");
}
}).when(searchHit).getSourceAsMap();
when(client.scroll(any(SearchRequest.class))).thenReturn(Flux.just(searchHit, searchHit));
@ -222,12 +222,11 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<Person> results = template.multiGet(pagedQueryForTwo(), Person.class, index)
.timeout(Duration.ofSeconds(1))
List<Person> results = template.multiGet(pagedQueryForTwo(), Person.class, index).timeout(Duration.ofSeconds(1))
.toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
@ -294,27 +293,21 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
List<Person> results = template.find(pagedQueryForTwo(), Person.class)
.timeout(Duration.ofSeconds(1)).toStream()
List<Person> results = template.find(pagedQueryForTwo(), Person.class).timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
private Query pagedQueryForTwo() {
return new NativeSearchQueryBuilder()
.withIds(Arrays.asList("init1", "init2"))
.withPageable(PageRequest.of(0, 10))
return new NativeSearchQueryBuilder().withIds(Arrays.asList("init1", "init2")).withPageable(PageRequest.of(0, 10))
.build();
}
private Document lukeDocument() {
return Document.create()
.append("id", "init")
.append("firstname", "luke");
return Document.create().append("id", "init").append("firstname", "luke");
}
@Test // DATAES-772
@ -325,20 +318,16 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
List<Person> results = template.find(scrollingQueryForTwo(), Person.class)
.timeout(Duration.ofSeconds(1))
.toStream().collect(Collectors.toList());
List<Person> results = template.find(scrollingQueryForTwo(), Person.class).timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
private Query scrollingQueryForTwo() {
return new NativeSearchQueryBuilder()
.withIds(Arrays.asList("init1", "init2"))
.build();
return new NativeSearchQueryBuilder().withIds(Arrays.asList("init1", "init2")).build();
}
@Test // DATAES-772
@ -349,12 +338,11 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
List<Person> results = template.find(pagedQueryForTwo(), Person.class, index)
.timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
List<Person> results = template.find(pagedQueryForTwo(), Person.class, index).timeout(Duration.ofSeconds(1))
.toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
@ -367,12 +355,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
List<Person> results = template.find(pagedQueryForTwo(), Person.class, Person.class)
.timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
List<Person> results = template.find(pagedQueryForTwo(), Person.class, Person.class).timeout(Duration.ofSeconds(1))
.toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
@ -386,11 +372,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
@SuppressWarnings("deprecation") // we know what we test
List<Person> results = template.find(pagedQueryForTwo(), Person.class, Person.class, index)
.timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
.timeout(Duration.ofSeconds(1)).toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
}
@ -402,12 +387,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class)
.timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class).timeout(Duration.ofSeconds(1))
.toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
}
@ -420,11 +403,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, index)
.timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
.timeout(Duration.ofSeconds(1)).toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
}
@ -437,11 +419,9 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, Person.class)
.timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
.timeout(Duration.ofSeconds(1)).toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
}
@ -454,11 +434,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, Person.class, index)
.timeout(Duration.ofSeconds(1)).toStream()
.collect(Collectors.toList());
.timeout(Duration.ofSeconds(1)).toStream().collect(Collectors.toList());
verify(afterConvertCallback, times(2))
.onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
verify(afterConvertCallback, times(2)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
}

7
src/test/java/org/springframework/data/elasticsearch/core/SearchHitSupportTest.java
View File

@ -34,8 +34,9 @@ class SearchHitSupportTest {
void unwrapsSearchHitsIteratorToCloseableIteratorOfEntities() {
TestStringSearchHitsIterator searchHitsIterator = new TestStringSearchHitsIterator();
@SuppressWarnings("unchecked") CloseableIterator<String> unwrappedIterator =
(CloseableIterator<String>) SearchHitSupport.unwrapSearchHits(searchHitsIterator);
@SuppressWarnings("unchecked")
CloseableIterator<String> unwrappedIterator = (CloseableIterator<String>) SearchHitSupport
.unwrapSearchHits(searchHitsIterator);
assertThat(unwrappedIterator.next()).isEqualTo("one");
assertThat(unwrappedIterator.next()).isEqualTo("two");
@ -86,4 +87,4 @@ class SearchHitSupportTest {
return new SearchHit<>("id", 1.0f, new Object[0], emptyMap(), nextString);
}
}
}
}