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

DATAES-785 - Various entity callbacks implementation improvements.

Browse Source 
Original PR: #431
This commit is contained in:
Roman Puchkovskiy
2020-04-21 23:24:22 +04:00
committed by GitHub
parent 5019793f17
commit 7501c19be4
18 changed files with 413 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/test/java/org/springframework/data/elasticsearch/config/AuditingIntegrationTest.java
View File

@@ -31,12 +31,14 @@ import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.domain.AuditorAware;
import org.springframework.data.domain.Persistable;
import org.springframework.data.elasticsearch.core.event.BeforeConvertCallback;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
import org.springframework.data.mapping.callback.EntityCallbacks;
import org.springframework.lang.Nullable;
/**
* @author Peter-Josef Meisch
* @author Roman Puchkovskiy
*/
public abstract class AuditingIntegrationTest {
@@ -64,7 +66,7 @@ public abstract class AuditingIntegrationTest {
Entity entity = new Entity();
entity.setId("1");
entity = callbacks.callback(BeforeConvertCallback.class, entity);
entity = callbacks.callback(BeforeConvertCallback.class, entity, IndexCoordinates.of("index"));
assertThat(entity.getCreated()).isNotNull();
assertThat(entity.getModified()).isEqualTo(entity.created);
@@ -73,7 +75,7 @@ public abstract class AuditingIntegrationTest {
Thread.sleep(10);
entity = callbacks.callback(BeforeConvertCallback.class, entity);
entity = callbacks.callback(BeforeConvertCallback.class, entity, IndexCoordinates.of("index"));
assertThat(entity.getCreated()).isNotNull();
assertThat(entity.getModified()).isNotEqualTo(entity.created);

6
src/test/java/org/springframework/data/elasticsearch/config/ReactiveAuditingIntegrationTest.java
View File

@@ -33,6 +33,7 @@ import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.domain.AuditorAware;
import org.springframework.data.domain.Persistable;
import org.springframework.data.elasticsearch.core.event.ReactiveBeforeConvertCallback;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
import org.springframework.data.elasticsearch.junit.jupiter.ReactiveElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
@@ -42,6 +43,7 @@ import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
* @author Roman Puchkovskiy
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ReactiveAuditingIntegrationTest.Config.class })
@@ -81,7 +83,7 @@ public class ReactiveAuditingIntegrationTest {
Entity entity = new Entity();
entity.setId("1");
entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity).block();
entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity, IndexCoordinates.of("index")).block();
assertThat(entity.getCreated()).isNotNull();
assertThat(entity.getModified()).isEqualTo(entity.created);
@@ -90,7 +92,7 @@ public class ReactiveAuditingIntegrationTest {
Thread.sleep(10);
entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity).block();
entity = callbacks.callback(ReactiveBeforeConvertCallback.class, entity, IndexCoordinates.of("index")).block();
assertThat(entity.getCreated()).isNotNull();
assertThat(entity.getModified()).isNotEqualTo(entity.created);

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

@@ -40,6 +40,7 @@ import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.event.AfterConvertCallback;
import org.springframework.data.elasticsearch.core.event.AfterSaveCallback;
import org.springframework.data.elasticsearch.core.event.BeforeConvertCallback;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.BulkOptions;
import org.springframework.data.elasticsearch.core.query.GetQuery;
@@ -66,11 +67,10 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Spy private ValueCapturingAfterSaveCallback afterSaveCallback = new ValueCapturingAfterSaveCallback();
@Spy private ValueCapturingAfterConvertCallback afterConvertCallback = new ValueCapturingAfterConvertCallback();
@Spy private ValueCapturingBeforeConvertCallback beforeConvertCallback = new ValueCapturingBeforeConvertCallback();
protected final void initTemplate(AbstractElasticsearchTemplate template) {
this.template = template;
this.template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback, afterConvertCallback));
}
protected final org.elasticsearch.search.SearchHits nSearchHits(int count) {
@@ -82,78 +82,90 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-771
void saveOneShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity = new Person("init", "luke");
Person saved = template.save(entity);
verify(afterSaveCallback).onAfterSave(eq(entity));
assertThat(saved.id).isEqualTo("after-save");
verify(afterSaveCallback).onAfterSave(eq(entity), any());
assertThat(saved.firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity = new Person("init", "luke");
Person saved = template.save(entity, index);
verify(afterSaveCallback).onAfterSave(eq(entity));
assertThat(saved.id).isEqualTo("after-save");
verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
assertThat(saved.firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveArrayShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
Iterable<Person> saved = template.save(entity1, entity2);
verify(afterSaveCallback, times(2)).onAfterSave(any());
verify(afterSaveCallback, times(2)).onAfterSave(any(), any());
Iterator<Person> savedIterator = saved.iterator();
assertThat(savedIterator.next().getId()).isEqualTo("after-save");
assertThat(savedIterator.next().getId()).isEqualTo("after-save");
assertThat(savedIterator.next().firstname).isEqualTo("after-save");
assertThat(savedIterator.next().firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveIterableShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
Iterable<Person> saved = template.save(Arrays.asList(entity1, entity2));
verify(afterSaveCallback, times(2)).onAfterSave(any());
verify(afterSaveCallback, times(2)).onAfterSave(any(), any());
Iterator<Person> savedIterator = saved.iterator();
assertThat(savedIterator.next().getId()).isEqualTo("after-save");
assertThat(savedIterator.next().getId()).isEqualTo("after-save");
assertThat(savedIterator.next().firstname).isEqualTo("after-save");
assertThat(savedIterator.next().firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveIterableWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
Iterable<Person> saved = template.save(Arrays.asList(entity1, entity2), index);
verify(afterSaveCallback, times(2)).onAfterSave(any());
verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
Iterator<Person> savedIterator = saved.iterator();
assertThat(savedIterator.next().getId()).isEqualTo("after-save");
assertThat(savedIterator.next().getId()).isEqualTo("after-save");
assertThat(savedIterator.next().firstname).isEqualTo("after-save");
assertThat(savedIterator.next().firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void indexShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity = new Person("init", "luke");
IndexQuery indexQuery = indexQueryForEntity(entity);
template.index(indexQuery, index);
verify(afterSaveCallback).onAfterSave(eq(entity));
verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
Person savedPerson = (Person) indexQuery.getObject();
assertThat(savedPerson.id).isEqualTo("after-save");
assertThat(savedPerson.firstname).isEqualTo("after-save");
}
private IndexQuery indexQueryForEntity(Person entity) {
@@ -165,6 +177,8 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-771
void bulkIndexShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
@@ -172,16 +186,18 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
IndexQuery query2 = indexQueryForEntity(entity2);
template.bulkIndex(Arrays.asList(query1, query2), index);
verify(afterSaveCallback, times(2)).onAfterSave(any());
verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
Person savedPerson1 = (Person) query1.getObject();
Person savedPerson2 = (Person) query2.getObject();
assertThat(savedPerson1.getId()).isEqualTo("after-save");
assertThat(savedPerson2.getId()).isEqualTo("after-save");
assertThat(savedPerson1.firstname).isEqualTo("after-save");
assertThat(savedPerson2.firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void bulkIndexWithOptionsShouldInvokeAfterSaveCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(afterSaveCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
@@ -189,20 +205,22 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
IndexQuery query2 = indexQueryForEntity(entity2);
template.bulkIndex(Arrays.asList(query1, query2), BulkOptions.defaultOptions(), index);
verify(afterSaveCallback, times(2)).onAfterSave(any());
verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
Person savedPerson1 = (Person) query1.getObject();
Person savedPerson2 = (Person) query2.getObject();
assertThat(savedPerson1.getId()).isEqualTo("after-save");
assertThat(savedPerson2.getId()).isEqualTo("after-save");
assertThat(savedPerson1.firstname).isEqualTo("after-save");
assertThat(savedPerson2.firstname).isEqualTo("after-save");
}
@Test // DATAES-772
void getShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
Person result = template.get("init", Person.class);
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
private Document lukeDocument() {
@@ -212,31 +230,37 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void getWithCoordinatesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
Person result = template.get("init", Person.class, index);
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void getViaQueryShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
Person result = template.get(new GetQuery("init"), Person.class, index);
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void multiGetShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
List<Person> results = template.multiGet(queryForTwo(), Person.class, 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");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
private Query queryForTwo() {
@@ -246,13 +270,15 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void queryForObjectShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
doReturn(nSearchHits(1)).when(searchResponse).getHits();
@SuppressWarnings("deprecation") // we know what we test
Person result = template.queryForObject(queryForOne(), Person.class, index);
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
private Query queryForOne() {
@@ -262,31 +288,37 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void queryForPageShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@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));
assertThat(results.getContent().get(0).id).isEqualTo("after-convert");
assertThat(results.getContent().get(1).id).isEqualTo("after-convert");
assertThat(results.getContent().get(0).firstname).isEqualTo("after-convert");
assertThat(results.getContent().get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void queryForPageWithMultipleQueriesAndSameEntityClassShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@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));
List<Person> persons = results.get(0).getContent();
assertThat(persons.get(0).id).isEqualTo("after-convert");
assertThat(persons.get(1).id).isEqualTo("after-convert");
assertThat(persons.get(0).firstname).isEqualTo("after-convert");
assertThat(persons.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void queryForPageWithMultipleQueriesAndEntityClassesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
List<AggregatedPage<?>> results = template.queryForPage(singletonList(queryForTwo()), singletonList(Person.class),
index);
@@ -294,29 +326,33 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
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");
assertThat(persons.get(0).firstname).isEqualTo("after-convert");
assertThat(persons.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void streamShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
CloseableIterator<Person> results = template.stream(queryForTwo(), Person.class, 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");
assertThat(results.next().firstname).isEqualTo("after-convert");
assertThat(results.next().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchScrollContinueShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
CloseableIterator<Person> results = template.stream(queryForTwo(), Person.class, index);
skipItemsFromScrollStart(results);
assertThat(results.next().id).isEqualTo("after-convert");
assertThat(results.next().id).isEqualTo("after-convert");
assertThat(results.next().firstname).isEqualTo("after-convert");
assertThat(results.next().firstname).isEqualTo("after-convert");
verify(afterConvertCallback, times(4)).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()),
eq(index));
@@ -330,51 +366,59 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void queryForListShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@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));
assertThat(results.get(0).id).isEqualTo("after-convert");
assertThat(results.get(1).id).isEqualTo("after-convert");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void queryForListWithMultipleQueriesAndSameEntityClassShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@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));
List<Person> persons = results.get(0);
assertThat(persons.get(0).id).isEqualTo("after-convert");
assertThat(persons.get(1).id).isEqualTo("after-convert");
assertThat(persons.get(0).firstname).isEqualTo("after-convert");
assertThat(persons.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void queryForListWithMultipleQueriesAndEntityClassesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@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());
assertThat(persons.get(0).id).isEqualTo("after-convert");
assertThat(persons.get(1).id).isEqualTo("after-convert");
assertThat(persons.get(0).firstname).isEqualTo("after-convert");
assertThat(persons.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void moreLikeThisShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
@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));
assertThat(results.getContent().get(0).id).isEqualTo("after-convert");
assertThat(results.getContent().get(1).id).isEqualTo("after-convert");
assertThat(results.getContent().get(0).firstname).isEqualTo("after-convert");
assertThat(results.getContent().get(1).firstname).isEqualTo("after-convert");
}
private MoreLikeThisQuery moreLikeThisQuery() {
@@ -387,115 +431,164 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void searchOneShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
doReturn(nSearchHits(1)).when(searchResponse).getHits();
SearchHit<Person> result = template.searchOne(queryForOne(), Person.class);
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(result.getContent().id).isEqualTo("after-convert");
assertThat(result.getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchOneWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
doReturn(nSearchHits(1)).when(searchResponse).getHits();
SearchHit<Person> result = template.searchOne(queryForOne(), Person.class, index);
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
assertThat(result.getContent().id).isEqualTo("after-convert");
assertThat(result.getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void multiSearchShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
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));
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");
assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void multiSearchWithMultipleEntityClassesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
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));
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");
assertThat(((Person) hits.get(0).getContent()).firstname).isEqualTo("after-convert");
assertThat(((Person) hits.get(1).getContent()).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
SearchHits<Person> results = template.search(queryForTwo(), Person.class);
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");
assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
SearchHits<Person> results = template.search(queryForTwo(), Person.class, 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");
assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchViaMoreLikeThisShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
SearchHits<Person> results = template.search(moreLikeThisQuery(), Person.class);
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");
assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchViaMoreLikeThisWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
SearchHits<Person> results = template.search(moreLikeThisQuery(), Person.class, 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");
assertThat(hits.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(hits.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchForStreamShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
SearchHitsIterator<Person> results = template.searchForStream(queryForTwo(), Person.class);
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");
assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchForStreamWithIndexCoordinatesShouldInvokeAfterConvertCallback() {
template.setEntityCallbacks(EntityCallbacks.create(afterConvertCallback));
SearchHitsIterator<Person> results = template.searchForStream(queryForTwo(), Person.class, 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");
assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
assertThat(results.next().getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-785
void saveOneShouldInvokeBeforeConvertCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(beforeConvertCallback));
Person entity = new Person("init1", "luke1");
Person saved = template.save(entity, index);
verify(beforeConvertCallback).onBeforeConvert(any(), eq(index));
assertThat(saved.firstname).isEqualTo("before-convert");
}
@Test // DATAES-785
void saveAllShouldInvokeBeforeConvertCallbacks() {
template.setEntityCallbacks(EntityCallbacks.create(beforeConvertCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
Iterable<Person> saved = template.save(Arrays.asList(entity1, entity2), index);
verify(beforeConvertCallback, times(2)).onBeforeConvert(any(), eq(index));
Iterator<Person> iterator = saved.iterator();
assertThat(iterator.next().firstname).isEqualTo("before-convert");
assertThat(iterator.next().firstname).isEqualTo("before-convert");
}
@Data
@@ -530,13 +623,13 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
implements AfterSaveCallback<Person> {
@Override
public Person onAfterSave(Person entity) {
public Person onAfterSave(Person entity, IndexCoordinates index) {
capture(entity);
return new Person() {
{
id = "after-save";
firstname = entity.firstname;
id = entity.id;
firstname = "after-save";
}
};
}
@@ -551,8 +644,24 @@ abstract class AbstractElasticsearchTemplateCallbackTests {
capture(entity);
return new Person() {
{
id = "after-convert";
firstname = entity.firstname;
id = entity.id;
firstname = "after-convert";
}
};
}
}
static class ValueCapturingBeforeConvertCallback extends ValueCapturingEntityCallback<Person>
implements BeforeConvertCallback<Person> {
@Override
public Person onBeforeConvert(Person entity, IndexCoordinates indexCoordinates) {
capture(entity);
return new Person() {
{
id = entity.id;
firstname = "before-convert";
}
};
}

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

@@ -46,6 +46,7 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
@@ -55,6 +56,7 @@ import org.springframework.data.elasticsearch.client.reactive.ReactiveElasticsea
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.event.ReactiveAfterConvertCallback;
import org.springframework.data.elasticsearch.core.event.ReactiveAfterSaveCallback;
import org.springframework.data.elasticsearch.core.event.ReactiveBeforeConvertCallback;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.Query;
@@ -82,6 +84,10 @@ public class ReactiveElasticsearchTemplateCallbackTests {
private final IndexCoordinates index = IndexCoordinates.of("index");
@Spy private ValueCapturingAfterSaveCallback afterSaveCallback = new ValueCapturingAfterSaveCallback();
@Spy private ValueCapturingAfterConvertCallback afterConvertCallback = new ValueCapturingAfterConvertCallback();
@Spy private ValueCapturingBeforeConvertCallback beforeConvertCallback = new ValueCapturingBeforeConvertCallback();
@BeforeEach
public void setUp() {
template = new ReactiveElasticsearchTemplate(client);
@@ -122,104 +128,90 @@ public class ReactiveElasticsearchTemplateCallbackTests {
@Test // DATAES-771
void saveOneShouldInvokeAfterSaveCallbacks() {
ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
Person entity = new Person("init", "luke");
Person saved = template.save(entity).block(Duration.ofSeconds(1));
verify(afterSaveCallback).onAfterSave(eq(entity));
assertThat(saved.id).isEqualTo("after-save");
verify(afterSaveCallback).onAfterSave(eq(entity), any());
assertThat(saved.firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveOneFromPublisherShouldInvokeAfterSaveCallbacks() {
ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
Person entity = new Person("init", "luke");
Person saved = template.save(Mono.just(entity)).block(Duration.ofSeconds(1));
verify(afterSaveCallback).onAfterSave(eq(entity));
assertThat(saved.id).isEqualTo("after-save");
verify(afterSaveCallback).onAfterSave(eq(entity), any());
assertThat(saved.firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
Person entity = new Person("init", "luke");
Person saved = template.save(entity, IndexCoordinates.of("index")).block(Duration.ofSeconds(1));
Person saved = template.save(entity, index).block(Duration.ofSeconds(1));
verify(afterSaveCallback).onAfterSave(eq(entity));
assertThat(saved.id).isEqualTo("after-save");
verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
assertThat(saved.firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveFromPublisherWithIndexCoordinatesShouldInvokeAfterSaveCallbacks() {
ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
Person entity = new Person("init", "luke");
Person saved = template.save(Mono.just(entity), IndexCoordinates.of("index")).block(Duration.ofSeconds(1));
Person saved = template.save(Mono.just(entity), index).block(Duration.ofSeconds(1));
verify(afterSaveCallback).onAfterSave(eq(entity));
assertThat(saved.id).isEqualTo("after-save");
verify(afterSaveCallback).onAfterSave(eq(entity), eq(index));
assertThat(saved.firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveAllShouldInvokeAfterSaveCallbacks() {
ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
List<Person> saved = template.saveAll(Arrays.asList(entity1, entity2), IndexCoordinates.of("index")).toStream()
List<Person> saved = template.saveAll(Arrays.asList(entity1, entity2), index).toStream()
.collect(Collectors.toList());
verify(afterSaveCallback, times(2)).onAfterSave(any());
assertThat(saved.get(0).getId()).isEqualTo("after-save");
assertThat(saved.get(1).getId()).isEqualTo("after-save");
verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
assertThat(saved.get(0).firstname).isEqualTo("after-save");
assertThat(saved.get(1).firstname).isEqualTo("after-save");
}
@Test // DATAES-771
void saveFromMonoAllShouldInvokeAfterSaveCallbacks() {
ValueCapturingAfterSaveCallback afterSaveCallback = spy(new ValueCapturingAfterSaveCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterSaveCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
List<Person> saved = template.saveAll(Mono.just(Arrays.asList(entity1, entity2)), IndexCoordinates.of("index"))
List<Person> saved = template.saveAll(Mono.just(Arrays.asList(entity1, entity2)), index)
.toStream().collect(Collectors.toList());
verify(afterSaveCallback, times(2)).onAfterSave(any());
assertThat(saved.get(0).getId()).isEqualTo("after-save");
assertThat(saved.get(1).getId()).isEqualTo("after-save");
verify(afterSaveCallback, times(2)).onAfterSave(any(), eq(index));
assertThat(saved.get(0).firstname).isEqualTo("after-save");
assertThat(saved.get(1).firstname).isEqualTo("after-save");
}
@Test // DATAES-772
void multiGetShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<Person> results = template.multiGet(pagedQueryForTwo(), Person.class, index).timeout(Duration.ofSeconds(1))
@@ -227,69 +219,59 @@ public class ReactiveElasticsearchTemplateCallbackTests {
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");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void findByIdShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
Person result = template.findById("init", Person.class).block(Duration.ofSeconds(1));
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void findByIdWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
Person result = template.findById("init", Person.class, index).block(Duration.ofSeconds(1));
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void getShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
Person result = template.get("init", Person.class).block(Duration.ofSeconds(1));
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), any());
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void getWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
Person result = template.get("init", Person.class, index).block(Duration.ofSeconds(1));
verify(afterConvertCallback).onAfterConvert(eq(new Person("init", "luke")), eq(lukeDocument()), eq(index));
assertThat(result.id).isEqualTo("after-convert");
assertThat(result.firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void findUsingPageableShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
@@ -297,8 +279,8 @@ public class ReactiveElasticsearchTemplateCallbackTests {
.collect(Collectors.toList());
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");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
private Query pagedQueryForTwo() {
@@ -313,8 +295,6 @@ public class ReactiveElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void findUsingScrollShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
@@ -322,8 +302,8 @@ public class ReactiveElasticsearchTemplateCallbackTests {
.collect(Collectors.toList());
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");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
private Query scrollingQueryForTwo() {
@@ -333,8 +313,6 @@ public class ReactiveElasticsearchTemplateCallbackTests {
@Test // DATAES-772
void findWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
@@ -343,15 +321,13 @@ public class ReactiveElasticsearchTemplateCallbackTests {
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");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void findWithReturnTypeShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
@@ -359,15 +335,13 @@ public class ReactiveElasticsearchTemplateCallbackTests {
.toStream().collect(Collectors.toList());
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");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void findWithReturnTypeAndIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
@SuppressWarnings("deprecation") // we know what we test
@@ -376,30 +350,26 @@ public class ReactiveElasticsearchTemplateCallbackTests {
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");
assertThat(results.get(0).firstname).isEqualTo("after-convert");
assertThat(results.get(1).firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
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());
assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchWithIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, index)
@@ -407,30 +377,26 @@ public class ReactiveElasticsearchTemplateCallbackTests {
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");
assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchWithResultTypeShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<SearchHit<Person>> results = template.search(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());
assertThat(results.get(0).getContent().id).isEqualTo("after-convert");
assertThat(results.get(1).getContent().id).isEqualTo("after-convert");
assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-772
void searchWithResultTypeAndIndexCoordinatesShouldInvokeAfterConvertCallbacks() {
ValueCapturingAfterConvertCallback afterConvertCallback = spy(new ValueCapturingAfterConvertCallback());
template.setEntityCallbacks(ReactiveEntityCallbacks.create(afterConvertCallback));
List<SearchHit<Person>> results = template.search(pagedQueryForTwo(), Person.class, Person.class, index)
@@ -438,8 +404,37 @@ public class ReactiveElasticsearchTemplateCallbackTests {
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");
assertThat(results.get(0).getContent().firstname).isEqualTo("after-convert");
assertThat(results.get(1).getContent().firstname).isEqualTo("after-convert");
}
@Test // DATAES-785
void saveOneShouldInvokeBeforeConvertCallbacks() {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(beforeConvertCallback));
Person entity = new Person("init1", "luke1");
Person saved = template.save(entity, index).block(Duration.ofSeconds(1));
verify(beforeConvertCallback).onBeforeConvert(any(), eq(index));
assertThat(saved.firstname).isEqualTo("before-convert");
}
@Test // DATAES-785
void saveAllShouldInvokeBeforeConvertCallbacks() {
template.setEntityCallbacks(ReactiveEntityCallbacks.create(beforeConvertCallback));
Person entity1 = new Person("init1", "luke1");
Person entity2 = new Person("init2", "luke2");
List<Person> saved = template.saveAll(Arrays.asList(entity1, entity2), index).toStream()
.collect(Collectors.toList());
verify(beforeConvertCallback, times(2)).onBeforeConvert(any(), eq(index));
assertThat(saved.get(0).firstname).isEqualTo("before-convert");
assertThat(saved.get(1).firstname).isEqualTo("before-convert");
}
@Data
@@ -474,14 +469,14 @@ public class ReactiveElasticsearchTemplateCallbackTests {
implements ReactiveAfterSaveCallback<Person> {
@Override
public Mono<Person> onAfterSave(Person entity) {
public Mono<Person> onAfterSave(Person entity, IndexCoordinates index) {
return Mono.defer(() -> {
capture(entity);
Person newPerson = new Person() {
{
id = "after-save";
firstname = entity.firstname;
id = entity.id;
firstname = "after-save";
}
};
return Mono.just(newPerson);
@@ -499,8 +494,27 @@ public class ReactiveElasticsearchTemplateCallbackTests {
capture(entity);
Person newPerson = new Person() {
{
id = "after-convert";
firstname = entity.firstname;
id = entity.id;
firstname = "after-convert";
}
};
return Mono.just(newPerson);
});
}
}
static class ValueCapturingBeforeConvertCallback extends ValueCapturingEntityCallback<Person>
implements ReactiveBeforeConvertCallback<Person> {
@Override
public Mono<Person> onBeforeConvert(Person entity, IndexCoordinates index) {
return Mono.defer(() -> {
capture(entity);
Person newPerson = new Person() {
{
id = entity.id;
firstname = "before-convert";
}
};
return Mono.just(newPerson);

6
src/test/java/org/springframework/data/elasticsearch/core/event/AuditingEntityCallbackTests.java
View File

@@ -30,12 +30,14 @@ import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.auditing.IsNewAwareAuditingHandler;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
import org.springframework.data.mapping.context.PersistentEntities;
import org.springframework.lang.Nullable;
/**
* @author Peter-Josef Meisch
* @author Roman Puchkovskiy
*/
@ExtendWith(MockitoExtension.class)
class AuditingEntityCallbackTests {
@@ -66,7 +68,7 @@ class AuditingEntityCallbackTests {
void shouldCallHandler() {
Sample entity = new Sample();
entity.setId("42");
callback.onBeforeConvert(entity);
callback.onBeforeConvert(entity, IndexCoordinates.of("index"));
verify(handler).markAudited(eq(entity));
}
@@ -79,7 +81,7 @@ class AuditingEntityCallbackTests {
sample2.setId("2");
doReturn(sample2).when(handler).markAudited(any());
Sample result = (Sample) callback.onBeforeConvert(sample1);
Sample result = (Sample) callback.onBeforeConvert(sample1, IndexCoordinates.of("index"));
assertThat(result).isSameAs(sample2);
}

4
src/test/java/org/springframework/data/elasticsearch/core/event/ElasticsearchOperationsCallbackTest.java
View File

@@ -26,10 +26,12 @@ import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.stereotype.Component;
/**
* @author Peter-Josef Meisch
* @author Roman Puchkovskiy
*/
abstract class ElasticsearchOperationsCallbackTest {
@@ -41,7 +43,7 @@ abstract class ElasticsearchOperationsCallbackTest {
@Component
static class SampleEntityBeforeConvertCallback implements BeforeConvertCallback<SampleEntity> {
@Override
public SampleEntity onBeforeConvert(SampleEntity entity) {
public SampleEntity onBeforeConvert(SampleEntity entity, IndexCoordinates index) {
entity.setText("converted");
return entity;
}

6
src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallbackTests.java
View File

@@ -18,6 +18,7 @@ package org.springframework.data.elasticsearch.core.event;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.Mockito.*;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import reactor.test.StepVerifier;
import java.time.LocalDateTime;
@@ -38,6 +39,7 @@ import org.springframework.lang.Nullable;
/**
* @author Peter-Josef Meisch
* @author Roman Puchkovskiy
*/
@ExtendWith(MockitoExtension.class)
class ReactiveAuditingEntityCallbackTests {
@@ -68,7 +70,7 @@ class ReactiveAuditingEntityCallbackTests {
void shouldCallHandler() {
Sample entity = new Sample();
entity.setId("42");
callback.onBeforeConvert(entity);
callback.onBeforeConvert(entity, IndexCoordinates.of("index"));
verify(handler).markAudited(eq(entity));
}
@@ -81,7 +83,7 @@ class ReactiveAuditingEntityCallbackTests {
sample2.setId("2");
doReturn(sample2).when(handler).markAudited(any());
callback.onBeforeConvert(sample1) //
callback.onBeforeConvert(sample1, IndexCoordinates.of("index")) //
.as(StepVerifier::create) //
.consumeNextWith(it -> { //
assertThat(it).isSameAs(sample2); //

4
src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveElasticsearchOperationsCallbackTest.java
View File

@@ -31,6 +31,7 @@ import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ReactiveElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
@@ -39,6 +40,7 @@ import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
* @author Roman Puchkovskiy
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ReactiveElasticsearchOperationsCallbackTest.Config.class })
@@ -50,7 +52,7 @@ public class ReactiveElasticsearchOperationsCallbackTest {
@Component
static class SampleEntityBeforeConvertCallback implements ReactiveBeforeConvertCallback<SampleEntity> {
@Override
public Mono<SampleEntity> onBeforeConvert(SampleEntity entity) {
public Mono<SampleEntity> onBeforeConvert(SampleEntity entity, IndexCoordinates index) {
entity.setText("reactive-converted");
return Mono.just(entity);
}