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

DATAES-672 - Introduce SearchHit and SearchHits types to enrich search results.

Browse Source 
Original PR: #359
This commit is contained in:
Peter-Josef Meisch
2019-12-22 12:15:46 +01:00
committed by GitHub
parent 2bb3fdfa8b
commit e55bae725e
30 changed files with 1119 additions and 527 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/test/java/org/springframework/data/elasticsearch/NestedObjectTests.java
View File

@@ -45,6 +45,9 @@ import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.InnerField;
import org.springframework.data.elasticsearch.annotations.MultiField;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.GetQuery;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
@@ -131,7 +134,7 @@ public class NestedObjectTests {
boolQuery().must(termQuery("car.name", "saturn")).must(termQuery("car.model", "imprezza")), ScoreMode.None);
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder).build();
List<Person> persons = elasticsearchTemplate.queryForList(searchQuery, Person.class, index);
SearchHits<Person> persons = elasticsearchTemplate.search(searchQuery, Person.class, index);
assertThat(persons).hasSize(1);
}
@@ -193,11 +196,11 @@ public class NestedObjectTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder).build();
Page<PersonMultipleLevelNested> personIndexed = elasticsearchTemplate.queryForPage(searchQuery,
Page<SearchHit<PersonMultipleLevelNested>> personIndexed = elasticsearchTemplate.searchForPage(searchQuery,
PersonMultipleLevelNested.class, index);
assertThat(personIndexed).isNotNull();
assertThat(personIndexed.getTotalElements()).isEqualTo(1);
assertThat(personIndexed.getContent().get(0).getId()).isEqualTo("1");
assertThat(personIndexed.getContent().get(0).getContent().getId()).isEqualTo("1");
}
private List<IndexQuery> createPerson() {
@@ -330,7 +333,7 @@ public class NestedObjectTests {
QueryBuilder builder = nestedQuery("books", boolQuery().must(termQuery("books.name", "java")), ScoreMode.None);
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(builder).build();
List<Person> persons = elasticsearchTemplate.queryForList(searchQuery, Person.class, index);
SearchHits<Person> persons = elasticsearchTemplate.search(searchQuery, Person.class, index);
// then
assertThat(persons).hasSize(1);
@@ -378,10 +381,10 @@ public class NestedObjectTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(nestedQuery("buckets", termQuery("buckets.1", "test3"), ScoreMode.None)).build();
Page<Book> books = elasticsearchTemplate.queryForPage(searchQuery, Book.class, index);
AggregatedPage<SearchHit<Book>> books = elasticsearchTemplate.searchForPage(searchQuery, Book.class, index);
assertThat(books.getContent()).hasSize(1);
assertThat(books.getContent().get(0).getId()).isEqualTo(book2.getId());
assertThat(books.getContent().get(0).getContent().getId()).isEqualTo(book2.getId());
}
@Setter

323
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java
View File

@@ -282,7 +282,7 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities).isNotNull();
@@ -306,8 +306,8 @@ public abstract class ElasticsearchTemplateTests {
.withPreference("_local").build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQueryWithValidPreference, SampleEntity.class,
index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQueryWithValidPreference,
SampleEntity.class, index);
// then
assertThat(sampleEntities).isNotNull();
@@ -332,7 +332,7 @@ public abstract class ElasticsearchTemplateTests {
// when
assertThatThrownBy(() -> {
operations.queryForPage(searchQueryWithInvalidPreference, SampleEntity.class, index);
operations.searchForPage(searchQueryWithInvalidPreference, SampleEntity.class, index);
}).isInstanceOf(Exception.class);
}
@@ -352,7 +352,7 @@ public abstract class ElasticsearchTemplateTests {
// when
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery())
.withIndicesOptions(IndicesOptions.lenientExpandOpen()).build();
Page<SampleEntity> entities = operations.queryForPage(searchQuery, SampleEntity.class,
Page<SearchHit<SampleEntity>> entities = operations.searchForPage(searchQuery, SampleEntity.class,
IndexCoordinates.of(INDEX_1_NAME, INDEX_2_NAME));
// then
@@ -384,7 +384,7 @@ public abstract class ElasticsearchTemplateTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(2);
}
@@ -439,7 +439,7 @@ public abstract class ElasticsearchTemplateTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(0);
}
@@ -461,7 +461,7 @@ public abstract class ElasticsearchTemplateTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(0);
}
@@ -486,7 +486,7 @@ public abstract class ElasticsearchTemplateTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(0);
}
@@ -574,7 +574,7 @@ public abstract class ElasticsearchTemplateTests {
.withFilter(boolQuery().filter(termQuery("id", documentId))).build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(1);
@@ -609,11 +609,11 @@ public abstract class ElasticsearchTemplateTests {
.withSort(new FieldSortBuilder("rate").order(SortOrder.ASC)).build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(3);
assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity2.getRate());
assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate());
}
@Test
@@ -646,12 +646,12 @@ public abstract class ElasticsearchTemplateTests {
.withSort(new FieldSortBuilder("message").order(SortOrder.ASC)).build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(3);
assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity2.getRate());
assertThat(sampleEntities.getContent().get(1).getMessage()).isEqualTo(sampleEntity1.getMessage());
assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate());
assertThat(sampleEntities.getContent().get(1).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage());
}
@Test // DATAES-312
@@ -684,12 +684,12 @@ public abstract class ElasticsearchTemplateTests {
.withPageable(PageRequest.of(0, 10, Sort.by(Sort.Order.asc("message").nullsFirst()))).build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(3);
assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity3.getRate());
assertThat(sampleEntities.getContent().get(1).getMessage()).isEqualTo(sampleEntity1.getMessage());
assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity3.getRate());
assertThat(sampleEntities.getContent().get(1).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage());
}
@Test // DATAES-312
@@ -722,12 +722,12 @@ public abstract class ElasticsearchTemplateTests {
.withPageable(PageRequest.of(0, 10, Sort.by(Sort.Order.asc("message").nullsLast()))).build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(3);
assertThat(sampleEntities.getContent().get(0).getRate()).isEqualTo(sampleEntity1.getRate());
assertThat(sampleEntities.getContent().get(1).getMessage()).isEqualTo(sampleEntity2.getMessage());
assertThat(sampleEntities.getContent().get(0).getContent().getRate()).isEqualTo(sampleEntity1.getRate());
assertThat(sampleEntities.getContent().get(1).getContent().getMessage()).isEqualTo(sampleEntity2.getMessage());
}
@Test // DATAES-467, DATAES-657
@@ -748,12 +748,12 @@ public abstract class ElasticsearchTemplateTests {
.build();
// when
Page<SampleEntity> page = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(page.getTotalElements()).isEqualTo(2);
assertThat(page.getContent().get(0).getId()).isEqualTo("2");
assertThat(page.getContent().get(1).getId()).isEqualTo("1");
assertThat(page.getContent().get(0).getContent().getId()).isEqualTo("2");
assertThat(page.getContent().get(1).getContent().getId()).isEqualTo("1");
}
@Test
@@ -772,7 +772,7 @@ public abstract class ElasticsearchTemplateTests {
StringQuery stringQuery = new StringQuery(matchAllQuery().toString());
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(stringQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(stringQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(1);
@@ -803,11 +803,11 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).withScriptField(
new ScriptField("scriptedRate", new Script(ScriptType.INLINE, "expression", "doc['rate'] * factor", params)))
.build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(1);
assertThat(sampleEntities.getContent().get(0).getScriptedRate()).isEqualTo(4.0);
assertThat(sampleEntities.getContent().get(0).getContent().getScriptedRate()).isEqualTo(4.0);
}
@Test
@@ -826,7 +826,7 @@ public abstract class ElasticsearchTemplateTests {
StringQuery stringQuery = new StringQuery(matchAllQuery().toString(), PageRequest.of(0, 10));
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(stringQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(stringQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isGreaterThanOrEqualTo(1);
@@ -853,7 +853,7 @@ public abstract class ElasticsearchTemplateTests {
Sort.by(Order.asc("message")));
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(stringQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(stringQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isGreaterThanOrEqualTo(1);
@@ -875,11 +875,11 @@ public abstract class ElasticsearchTemplateTests {
StringQuery stringQuery = new StringQuery(termQuery("id", documentId).toString());
// when
SampleEntity sampleEntity1 = operations.queryForObject(stringQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity1 = operations.searchOne(stringQuery, SampleEntity.class, index);
// then
assertThat(sampleEntity1).isNotNull();
assertThat(sampleEntity1.getId()).isEqualTo(documentId);
assertThat(sampleEntity1.getContent().getId()).isEqualTo(documentId);
}
@Test
@@ -909,7 +909,7 @@ public abstract class ElasticsearchTemplateTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("test"));
// when
SampleEntity sampleEntity1 = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity1 = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(sampleEntity1).isNotNull();
@@ -935,7 +935,7 @@ public abstract class ElasticsearchTemplateTests {
// then
StringQuery stringQuery = new StringQuery(matchAllQuery().toString());
List<SampleEntity> sampleEntities = operations.queryForList(stringQuery, SampleEntity.class, index);
SearchHits<SampleEntity> sampleEntities = operations.search(stringQuery, SampleEntity.class, index);
assertThat(sampleEntities).isEmpty();
}
@@ -958,12 +958,12 @@ public abstract class ElasticsearchTemplateTests {
.build();
// when
Page<SampleEntity> page = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
assertThat(page.getTotalElements()).isEqualTo(1);
final SampleEntity actual = page.getContent().get(0);
final SampleEntity actual = page.getContent().get(0).getContent();
assertThat(actual.message).isEqualTo(message);
assertThat(actual.getType()).isNull();
assertThat(actual.getLocation()).isNull();
@@ -990,12 +990,12 @@ public abstract class ElasticsearchTemplateTests {
.withSourceFilter(sourceFilter.build()).build();
// when
Page<SampleEntity> page = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
assertThat(page.getTotalElements()).isEqualTo(1);
assertThat(page.getContent().get(0).getMessage()).isEqualTo(message);
assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo(message);
}
@Test
@@ -1030,11 +1030,13 @@ public abstract class ElasticsearchTemplateTests {
moreLikeThisQuery.setMinDocFreq(1);
// when
Page<SampleEntity> sampleEntities = operations.moreLikeThis(moreLikeThisQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.search(moreLikeThisQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities.getTotalElements()).isEqualTo(1);
assertThat(sampleEntities.getContent()).contains(sampleEntity);
List<SampleEntity> content = sampleEntities.getContent().stream().map(SearchHit::getContent)
.collect(Collectors.toList());
assertThat(content).contains(sampleEntity);
}
@Test // DATAES-167
@@ -1051,13 +1053,14 @@ public abstract class ElasticsearchTemplateTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
criteriaQuery.setPageable(PageRequest.of(0, 10));
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class);
}
operations.clearScroll(scroll.getScrollId());
operations.searchScrollClear(scroll.getScrollId());
assertThat(sampleEntities).hasSize(30);
}
@@ -1076,13 +1079,14 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery())
.withPageable(PageRequest.of(0, 10)).build();
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class);
}
operations.clearScroll(scroll.getScrollId());
operations.searchScrollClear(scroll.getScrollId());
assertThat(sampleEntities).hasSize(30);
}
@@ -1101,15 +1105,16 @@ public abstract class ElasticsearchTemplateTests {
criteriaQuery.addFields("message");
criteriaQuery.setPageable(PageRequest.of(0, 10));
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index);
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class,
index);
String scrollId = scroll.getScrollId();
List<SampleEntity> sampleEntities = new ArrayList<>();
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scrollId = scroll.getScrollId();
scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class);
}
operations.clearScroll(scrollId);
operations.searchScrollClear(scrollId);
assertThat(sampleEntities).hasSize(30);
}
@@ -1127,15 +1132,16 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).withFields("message")
.withQuery(matchAllQuery()).withPageable(PageRequest.of(0, 10)).build();
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
String scrollId = scroll.getScrollId();
List<SampleEntity> sampleEntities = new ArrayList<>();
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scrollId = scroll.getScrollId();
scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class);
}
operations.clearScroll(scrollId);
operations.searchScrollClear(scrollId);
assertThat(sampleEntities).hasSize(30);
}
@@ -1153,15 +1159,16 @@ public abstract class ElasticsearchTemplateTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
criteriaQuery.setPageable(PageRequest.of(0, 10));
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index);
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class,
index);
String scrollId = scroll.getScrollId();
List<SampleEntity> sampleEntities = new ArrayList<>();
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scrollId = scroll.getScrollId();
scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class);
}
operations.clearScroll(scrollId);
operations.searchScrollClear(scrollId);
assertThat(sampleEntities).hasSize(30);
}
@@ -1179,15 +1186,16 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery())
.withPageable(PageRequest.of(0, 10)).build();
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
String scrollId = scroll.getScrollId();
List<SampleEntity> sampleEntities = new ArrayList<>();
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scrollId = scroll.getScrollId();
scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class);
}
operations.clearScroll(scrollId);
operations.searchScrollClear(scrollId);
assertThat(sampleEntities).hasSize(30);
}
@@ -1205,15 +1213,16 @@ public abstract class ElasticsearchTemplateTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
criteriaQuery.setPageable(PageRequest.of(0, 10));
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index);
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class,
index);
String scrollId = scroll.getScrollId();
List<SampleEntity> sampleEntities = new ArrayList<>();
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scrollId = scroll.getScrollId();
scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class);
}
operations.clearScroll(scrollId);
operations.searchScrollClear(scrollId);
assertThat(sampleEntities).hasSize(30);
}
@@ -1231,15 +1240,16 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery())
.withPageable(PageRequest.of(0, 10)).build();
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
String scrollId = scroll.getScrollId();
List<SampleEntity> sampleEntities = new ArrayList<>();
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scrollId = scroll.getScrollId();
scroll = operations.continueScroll(scrollId, 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scrollId, 1000, SampleEntity.class);
}
operations.clearScroll(scrollId);
operations.searchScrollClear(scrollId);
assertThat(sampleEntities).hasSize(30);
}
@@ -1257,8 +1267,9 @@ public abstract class ElasticsearchTemplateTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria());
criteriaQuery.setPageable(PageRequest.of(0, 10));
CloseableIterator<SampleEntity> stream = operations.stream(criteriaQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
CloseableIterator<SearchHit<SampleEntity>> stream = operations.searchForStream(criteriaQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (stream.hasNext()) {
sampleEntities.add(stream.next());
}
@@ -1311,9 +1322,9 @@ public abstract class ElasticsearchTemplateTests {
CriteriaQuery singleCriteriaQuery = new CriteriaQuery(new Criteria("message").contains("test"));
CriteriaQuery multipleCriteriaQuery = new CriteriaQuery(
new Criteria("message").contains("some").and("message").contains("message"));
List<SampleEntity> sampleEntitiesForSingleCriteria = operations.queryForList(singleCriteriaQuery,
SearchHits<SampleEntity> sampleEntitiesForSingleCriteria = operations.search(singleCriteriaQuery,
SampleEntity.class, index);
List<SampleEntity> sampleEntitiesForAndCriteria = operations.queryForList(multipleCriteriaQuery, SampleEntity.class,
SearchHits<SampleEntity> sampleEntitiesForAndCriteria = operations.search(multipleCriteriaQuery, SampleEntity.class,
index);
// then
assertThat(sampleEntitiesForSingleCriteria).hasSize(2);
@@ -1346,17 +1357,17 @@ public abstract class ElasticsearchTemplateTests {
indexOperations.refresh(SampleEntity.class);
StringQuery stringQuery = new StringQuery(matchAllQuery().toString());
List<SampleEntity> sampleEntities = operations.queryForList(stringQuery, SampleEntity.class, index);
SearchHits<SampleEntity> sampleEntities = operations.search(stringQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities).hasSize(3);
}
@Test
public void shouldPutMappingForGivenEntity() throws Exception {
public void shouldPutMappingForGivenEntity() {
// given
Class entity = SampleMappingEntity.class;
Class<SampleEntity> entity = SampleEntity.class;
indexOperations.deleteIndex(entity);
indexOperations.createIndex(entity);
@@ -1367,7 +1378,7 @@ public abstract class ElasticsearchTemplateTests {
}
@Test // DATAES-305
public void shouldPutMappingWithCustomIndexName() throws Exception {
public void shouldPutMappingWithCustomIndexName() {
// given
Class<SampleEntity> entity = SampleEntity.class;
@@ -1510,15 +1521,15 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery())
.withIndicesOptions(IndicesOptions.lenientExpandOpen()).build();
List<SampleEntity> entities = new ArrayList<>();
List<SearchHit<SampleEntity>> entities = new ArrayList<>();
ScrolledPage<SampleEntity> scroll = operations.startScroll(scrollTimeInMillis, searchQuery, SampleEntity.class,
index);
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(scrollTimeInMillis, searchQuery,
SampleEntity.class, index);
entities.addAll(scroll.getContent());
while (scroll.hasContent()) {
scroll = operations.continueScroll(scroll.getScrollId(), scrollTimeInMillis, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), scrollTimeInMillis, SampleEntity.class);
entities.addAll(scroll.getContent());
}
@@ -1549,8 +1560,9 @@ public abstract class ElasticsearchTemplateTests {
queries.add(new NativeSearchQueryBuilder().withQuery(termQuery("message", "ac")).build());
// then
List<Page<SampleEntity>> sampleEntities = operations.queryForPage(queries, SampleEntity.class, index);
for (Page<SampleEntity> sampleEntity : sampleEntities) {
List<AggregatedPage<SearchHit<SampleEntity>>> sampleEntities = operations.multiSearchForPage(queries,
SampleEntity.class, index);
for (Page<SearchHit<SampleEntity>> sampleEntity : sampleEntities) {
assertThat(sampleEntity.getTotalElements()).isEqualTo(1);
}
}
@@ -1577,16 +1589,19 @@ public abstract class ElasticsearchTemplateTests {
queries.add(new NativeSearchQueryBuilder().withQuery(termQuery("message", "ab")).build());
queries.add(new NativeSearchQueryBuilder().withQuery(termQuery("description", "bc")).build());
List<Page<?>> pages = operations.queryForPage(queries, Lists.newArrayList(SampleEntity.class, clazz),
List<AggregatedPage<? extends SearchHit<?>>> pages = operations.multiSearchForPage(queries,
Lists.newArrayList(SampleEntity.class, clazz),
IndexCoordinates.of(index.getIndexName(), bookIndex.getIndexName()));
// then
Page<?> page0 = pages.get(0);
assertThat(page0.getTotalElements()).isEqualTo(1L);
assertThat(page0.getContent().get(0).getClass()).isEqualTo(SampleEntity.class);
SearchHit<SampleEntity> searchHit0 = (SearchHit<SampleEntity>) page0.getContent().get(0);
assertThat(searchHit0.getContent().getClass()).isEqualTo(SampleEntity.class);
Page<?> page1 = pages.get(1);
assertThat(page1.getTotalElements()).isEqualTo(1L);
assertThat(page1.getContent().get(0).getClass()).isEqualTo(clazz);
SearchHit<Book> searchHit1 = (SearchHit<Book>) page1.getContent().get(0);
assertThat(searchHit1.getContent().getClass()).isEqualTo(clazz);
}
@Test
@@ -1610,7 +1625,7 @@ public abstract class ElasticsearchTemplateTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("id", documentId)).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(0);
}
@@ -1630,10 +1645,10 @@ public abstract class ElasticsearchTemplateTests {
.build();
// then
Page<SampleEntity> page = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(page).isNotNull();
assertThat(page.getContent()).hasSize(1);
assertThat(page.getContent().get(0).getId()).isEqualTo(indexQuery.getId());
assertThat(page.getContent().get(0).getContent().getId()).isEqualTo(indexQuery.getId());
}
@Test
@@ -1680,11 +1695,11 @@ public abstract class ElasticsearchTemplateTests {
.withQuery(boolQuery().must(wildcardQuery("message", "*a*")).should(wildcardQuery("message", "*b*")))
.withMinScore(2.0F).build();
Page<SampleEntity> page = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(page.getTotalElements()).isEqualTo(1);
assertThat(page.getContent().get(0).getMessage()).isEqualTo("ab");
assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo("ab");
}
@Test // DATAES-462
@@ -1704,7 +1719,7 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("message", "xz"))
.withSort(SortBuilders.fieldSort("message")).withTrackScores(true).build();
Page<SampleEntity> page = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(page).isInstanceOf(AggregatedPage.class);
@@ -1765,12 +1780,12 @@ public abstract class ElasticsearchTemplateTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(2);
List<SampleEntity> content = sampleEntities.getContent();
assertThat(content.get(0).getId()).isNotNull();
assertThat(content.get(1).getId()).isNotNull();
List<SearchHit<SampleEntity>> content = sampleEntities.getContent();
assertThat(content.get(0).getContent().getId()).isNotNull();
assertThat(content.get(1).getContent().getId()).isNotNull();
}
@Test
@@ -1809,12 +1824,12 @@ public abstract class ElasticsearchTemplateTests {
// then
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
Page<Map> sampleEntities = operations.queryForPage(searchQuery, Map.class, index);
Page<SearchHit<Map>> sampleEntities = operations.searchForPage(searchQuery, Map.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(2);
List<Map> content = sampleEntities.getContent();
assertThat(content.get(0).get("userId")).isEqualTo(person1.get("userId"));
assertThat(content.get(1).get("userId")).isEqualTo(person2.get("userId"));
List<SearchHit<Map>> content = sampleEntities.getContent();
assertThat(content.get(0).getContent().get("userId")).isEqualTo(person1.get("userId"));
assertThat(content.get(1).getContent().get("userId")).isEqualTo(person2.get("userId"));
}
@Test // DATAES-523
@@ -1833,7 +1848,7 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
// when
Page<GTEVersionEntity> entities = operations.queryForPage(searchQuery, GTEVersionEntity.class, index);
Page<SearchHit<GTEVersionEntity>> entities = operations.searchForPage(searchQuery, GTEVersionEntity.class, index);
// then
assertThat(entities).isNotNull();
assertThat(entities.getTotalElements()).isGreaterThanOrEqualTo(1);
@@ -1864,7 +1879,7 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
// when
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(sampleEntities).isNotNull();
@@ -2241,7 +2256,7 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
// when
List<SampleEntity> sampleEntities = operations.queryForList(searchQuery, SampleEntity.class,
SearchHits<SampleEntity> sampleEntities = operations.search(searchQuery, SampleEntity.class,
IndexCoordinates.of(INDEX_1_NAME, INDEX_2_NAME));
// then
@@ -2268,7 +2283,7 @@ public abstract class ElasticsearchTemplateTests {
// when
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
Page<ResultAggregator> page = operations.queryForPage(searchQuery, ResultAggregator.class,
Page<SearchHit<ResultAggregator>> page = operations.searchForPage(searchQuery, ResultAggregator.class,
IndexCoordinates.of(INDEX_1_NAME, INDEX_2_NAME));
assertThat(page.getTotalElements()).isEqualTo(2);
@@ -2329,9 +2344,9 @@ public abstract class ElasticsearchTemplateTests {
// then
// document with id "remainingDocumentId" should still be indexed
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(1);
assertThat(sampleEntities.getContent().get(0).getId()).isEqualTo(remainingDocumentId);
assertThat(sampleEntities.getContent().get(0).getContent().getId()).isEqualTo(remainingDocumentId);
}
@Test // DATAES-525
@@ -2360,9 +2375,9 @@ public abstract class ElasticsearchTemplateTests {
// then
// document with id "remainingDocumentId" should still be indexed
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(1);
assertThat(sampleEntities.getContent().get(0).getId()).isEqualTo(remainingDocumentId);
assertThat(sampleEntities.getContent().get(0).getContent().getId()).isEqualTo(remainingDocumentId);
}
@Test // DATAES-525
@@ -2389,9 +2404,9 @@ public abstract class ElasticsearchTemplateTests {
// then
// document with id "remainingDocumentId" should still be indexed
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
Page<SampleEntity> sampleEntities = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> sampleEntities = operations.searchForPage(searchQuery, SampleEntity.class, index);
assertThat(sampleEntities.getTotalElements()).isEqualTo(1L);
assertThat(sampleEntities.getContent().get(0).getId()).isEqualTo(remainingDocumentId);
assertThat(sampleEntities.getContent().get(0).getContent().getId()).isEqualTo(remainingDocumentId);
}
@Test // DATAES-525
@@ -2415,18 +2430,20 @@ public abstract class ElasticsearchTemplateTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("message"));
criteriaQuery.setPageable(PageRequest.of(0, 10));
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, criteriaQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, criteriaQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class);
}
operations.clearScroll(scroll.getScrollId());
operations.searchScrollClear(scroll.getScrollId());
// then
assertThat(sampleEntities).hasSize(2);
assertThat(sampleEntities.stream().map(SampleEntity::getMessage).collect(Collectors.toList()))
.doesNotContain(notFindableMessage);
assertThat(
sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getMessage).collect(Collectors.toList()))
.doesNotContain(notFindableMessage);
}
@Test // DATAES-525
@@ -2450,18 +2467,20 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchQuery("message", "message"))
.withPageable(PageRequest.of(0, 10)).build();
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class);
}
operations.clearScroll(scroll.getScrollId());
operations.searchScrollClear(scroll.getScrollId());
// then
assertThat(sampleEntities).hasSize(2);
assertThat(sampleEntities.stream().map(SampleEntity::getMessage).collect(Collectors.toList()))
.doesNotContain(notFindableMessage);
assertThat(
sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getMessage).collect(Collectors.toList()))
.doesNotContain(notFindableMessage);
}
@Test // DATAES-565
@@ -2480,18 +2499,20 @@ public abstract class ElasticsearchTemplateTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery())
.withPageable(PageRequest.of(0, 10)).withSourceFilter(sourceFilter).build();
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class);
}
operations.clearScroll(scroll.getScrollId());
operations.searchScrollClear(scroll.getScrollId());
assertThat(sampleEntities).hasSize(3);
assertThat(sampleEntities.stream().map(SampleEntity::getId).collect(Collectors.toList()))
assertThat(sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getId).collect(Collectors.toList()))
.doesNotContain((String) null);
assertThat(sampleEntities.stream().map(SampleEntity::getMessage).collect(Collectors.toList()))
.containsOnly((String) null);
assertThat(
sampleEntities.stream().map(SearchHit::getContent).map(SampleEntity::getMessage).collect(Collectors.toList()))
.containsOnly((String) null);
}
@Test // DATAES-457
@@ -2524,20 +2545,21 @@ public abstract class ElasticsearchTemplateTests {
.withSort(new FieldSortBuilder("message").order(SortOrder.DESC)).withPageable(PageRequest.of(0, 10)).build();
// when
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class);
}
// then
assertThat(sampleEntities).hasSize(3);
assertThat(sampleEntities.get(0).getRate()).isEqualTo(sampleEntity2.getRate());
assertThat(sampleEntities.get(1).getRate()).isEqualTo(sampleEntity3.getRate());
assertThat(sampleEntities.get(1).getMessage()).isEqualTo(sampleEntity3.getMessage());
assertThat(sampleEntities.get(2).getRate()).isEqualTo(sampleEntity1.getRate());
assertThat(sampleEntities.get(2).getMessage()).isEqualTo(sampleEntity1.getMessage());
assertThat(sampleEntities.get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate());
assertThat(sampleEntities.get(1).getContent().getRate()).isEqualTo(sampleEntity3.getRate());
assertThat(sampleEntities.get(1).getContent().getMessage()).isEqualTo(sampleEntity3.getMessage());
assertThat(sampleEntities.get(2).getContent().getRate()).isEqualTo(sampleEntity1.getRate());
assertThat(sampleEntities.get(2).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage());
}
@Test // DATAES-457
@@ -2571,20 +2593,21 @@ public abstract class ElasticsearchTemplateTests {
.build();
// when
ScrolledPage<SampleEntity> scroll = operations.startScroll(1000, searchQuery, SampleEntity.class, index);
List<SampleEntity> sampleEntities = new ArrayList<>();
ScrolledPage<SearchHit<SampleEntity>> scroll = operations.searchScrollStart(1000, searchQuery, SampleEntity.class,
index);
List<SearchHit<SampleEntity>> sampleEntities = new ArrayList<>();
while (scroll.hasContent()) {
sampleEntities.addAll(scroll.getContent());
scroll = operations.continueScroll(scroll.getScrollId(), 1000, SampleEntity.class);
scroll = operations.searchScrollContinue(scroll.getScrollId(), 1000, SampleEntity.class);
}
// then
assertThat(sampleEntities).hasSize(3);
assertThat(sampleEntities.get(0).getRate()).isEqualTo(sampleEntity2.getRate());
assertThat(sampleEntities.get(1).getRate()).isEqualTo(sampleEntity3.getRate());
assertThat(sampleEntities.get(1).getMessage()).isEqualTo(sampleEntity3.getMessage());
assertThat(sampleEntities.get(2).getRate()).isEqualTo(sampleEntity1.getRate());
assertThat(sampleEntities.get(2).getMessage()).isEqualTo(sampleEntity1.getMessage());
assertThat(sampleEntities.get(0).getContent().getRate()).isEqualTo(sampleEntity2.getRate());
assertThat(sampleEntities.get(1).getContent().getRate()).isEqualTo(sampleEntity3.getRate());
assertThat(sampleEntities.get(1).getContent().getMessage()).isEqualTo(sampleEntity3.getMessage());
assertThat(sampleEntities.get(2).getContent().getRate()).isEqualTo(sampleEntity1.getRate());
assertThat(sampleEntities.get(2).getContent().getMessage()).isEqualTo(sampleEntity1.getMessage());
}
@Test // DATAES-593
@@ -2607,14 +2630,14 @@ public abstract class ElasticsearchTemplateTests {
.build();
// when
Page<SampleEntity> page = operations.queryForPage(searchQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(searchQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
assertThat(page.getTotalElements()).isEqualTo(3);
assertThat(page.getContent()).hasSize(2);
assertThat(page.getContent().get(0).getMessage()).isEqualTo("message 1");
assertThat(page.getContent().get(1).getMessage()).isEqualTo("message 2");
assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo("message 1");
assertThat(page.getContent().get(1).getContent().getMessage()).isEqualTo("message 2");
}
private IndexQuery getIndexQuery(SampleEntity sampleEntity) {

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

@@ -25,7 +25,6 @@ import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import org.elasticsearch.ElasticsearchException;
import org.junit.jupiter.api.BeforeEach;
@@ -90,7 +89,7 @@ public class LogEntityTests {
// when
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("ip", "10.10.10.1")).build();
List<LogEntity> entities = operations.queryForList(searchQuery, LogEntity.class, index);
SearchHits<LogEntity> entities = operations.search(searchQuery, LogEntity.class, index);
// then
assertThat(entities).isNotNull().hasSize(1);
@@ -103,7 +102,7 @@ public class LogEntityTests {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(termQuery("ip", "10.10.10")).build();
assertThatThrownBy(() -> {
List<LogEntity> entities = operations.queryForList(searchQuery, LogEntity.class, index);
SearchHits<LogEntity> entities = operations.search(searchQuery, LogEntity.class, index);
}).isInstanceOf(ElasticsearchException.class);
}
@@ -113,7 +112,7 @@ public class LogEntityTests {
// when
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder()
.withQuery(rangeQuery("ip").from("10.10.10.1").to("10.10.10.3")).build();
List<LogEntity> entities = operations.queryForList(searchQuery, LogEntity.class, index);
SearchHits<LogEntity> entities = operations.search(searchQuery, LogEntity.class, index);
// then
assertThat(entities).isNotNull().hasSize(3);

41
src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateTests.java
View File

@@ -24,7 +24,6 @@ import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
@@ -54,6 +53,7 @@ import org.springframework.data.elasticsearch.TestUtils;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.Score;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.Criteria;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
@@ -137,7 +137,7 @@ public class ReactiveElasticsearchTemplateTests {
restTemplate.refresh(SampleEntity.class);
List<SampleEntity> result = restTemplate.queryForList(
SearchHits<SampleEntity> result = restTemplate.search(
new CriteriaQuery(Criteria.where("message").is(sampleEntity.getMessage())), SampleEntity.class,
IndexCoordinates.of(DEFAULT_INDEX));
assertThat(result).hasSize(1);
@@ -311,38 +311,39 @@ public class ReactiveElasticsearchTemplateTests {
}
@Test // DATAES-519
public void findShouldCompleteWhenIndexDoesNotExist() {
public void searchShouldCompleteWhenIndexDoesNotExist() {
template
.find(new CriteriaQuery(Criteria.where("message").is("some message")), SampleEntity.class,
.search(new CriteriaQuery(Criteria.where("message").is("some message")), SampleEntity.class,
IndexCoordinates.of("no-such-index")) //
.as(StepVerifier::create) //
.verifyComplete();
}
@Test // DATAES-504
public void findShouldApplyCriteria() {
public void searchShouldApplyCriteria() {
SampleEntity sampleEntity = randomEntity("some message");
index(sampleEntity);
CriteriaQuery criteriaQuery = new CriteriaQuery(Criteria.where("message").is("some message"));
template.find(criteriaQuery, SampleEntity.class) //
template.search(criteriaQuery, SampleEntity.class) //
.map(SearchHit::getContent) //
.as(StepVerifier::create) //
.expectNext(sampleEntity) //
.verifyComplete();
}
@Test // DATAES-504
public void findShouldReturnEmptyFluxIfNothingFound() {
public void searchShouldReturnEmptyFluxIfNothingFound() {
SampleEntity sampleEntity = randomEntity("some message");
index(sampleEntity);
CriteriaQuery criteriaQuery = new CriteriaQuery(Criteria.where("message").is("foo"));
template.find(criteriaQuery, SampleEntity.class) //
template.search(criteriaQuery, SampleEntity.class) //
.as(StepVerifier::create) //
.verifyComplete();
}
@@ -352,7 +353,7 @@ public class ReactiveElasticsearchTemplateTests {
index(randomEntity("test message"), randomEntity("test test"), randomEntity("some message"));
template.find(new StringQuery(matchAllQuery().toString()), SampleEntity.class) //
template.search(new StringQuery(matchAllQuery().toString()), SampleEntity.class) //
.as(StepVerifier::create) //
.expectNextCount(3) //
.verifyComplete();
@@ -367,7 +368,8 @@ public class ReactiveElasticsearchTemplateTests {
CriteriaQuery query = new CriteriaQuery(new Criteria("message").contains("test"));
template.find(query, SampleEntity.class) //
template.search(query, SampleEntity.class) //
.map(SearchHit::getContent) //
.as(StepVerifier::create) //
.expectNext(shouldMatch) //
.verifyComplete();
@@ -385,7 +387,8 @@ public class ReactiveElasticsearchTemplateTests {
CriteriaQuery query = new CriteriaQuery(
new Criteria("message").contains("some").and("message").contains("message"));
template.find(query, SampleEntity.class) //
template.search(query, SampleEntity.class) //
.map(SearchHit::getContent) //
.as(StepVerifier::create) //
.expectNext(sampleEntity3) //
.verifyComplete();
@@ -404,7 +407,8 @@ public class ReactiveElasticsearchTemplateTests {
new Criteria("message").contains("some").and("message").contains("message"));
queryWithValidPreference.setPreference("_local");
template.find(queryWithValidPreference, SampleEntity.class) //
template.search(queryWithValidPreference, SampleEntity.class) //
.map(SearchHit::getContent) //
.as(StepVerifier::create) //
.expectNext(sampleEntity3) //
.verifyComplete();
@@ -423,7 +427,7 @@ public class ReactiveElasticsearchTemplateTests {
new Criteria("message").contains("some").and("message").contains("message"));
queryWithInvalidPreference.setPreference("_only_nodes:oops");
template.find(queryWithInvalidPreference, SampleEntity.class) //
template.search(queryWithInvalidPreference, SampleEntity.class) //
.as(StepVerifier::create) //
.expectError(ElasticsearchStatusException.class).verify();
}
@@ -440,14 +444,15 @@ public class ReactiveElasticsearchTemplateTests {
CriteriaQuery query = new CriteriaQuery(
new Criteria("message").contains("some").and("message").contains("message"));
template.find(query, SampleEntity.class, Message.class) //
template.search(query, SampleEntity.class, Message.class) //
.map(SearchHit::getContent) //
.as(StepVerifier::create) //
.expectNext(new Message(sampleEntity3.getMessage())) //
.verifyComplete();
}
@Test // DATAES-518
public void findShouldApplyPagingCorrectly() {
public void searchShouldApplyPagingCorrectly() {
List<SampleEntity> source = IntStream.range(0, 100).mapToObj(it -> randomEntity("entity - " + it))
.collect(Collectors.toList());
@@ -458,7 +463,7 @@ public class ReactiveElasticsearchTemplateTests {
.addSort(Sort.by("message"))//
.setPageable(PageRequest.of(0, 20));
template.find(query, SampleEntity.class).as(StepVerifier::create) //
template.search(query, SampleEntity.class).as(StepVerifier::create) //
.expectNextCount(20) //
.verifyComplete();
}
@@ -475,7 +480,7 @@ public class ReactiveElasticsearchTemplateTests {
.addSort(Sort.by("message"))//
.setPageable(Pageable.unpaged());
template.find(query, SampleEntity.class).as(StepVerifier::create) //
template.search(query, SampleEntity.class).as(StepVerifier::create) //
.expectNextCount(100) //
.verifyComplete();
}
@@ -682,7 +687,7 @@ public class ReactiveElasticsearchTemplateTests {
.withPageable(PageRequest.of(0, 25)) //
.build();
template.find(query, SampleEntity.class, IndexCoordinates.of(DEFAULT_INDEX)) //
template.search(query, SampleEntity.class, IndexCoordinates.of(DEFAULT_INDEX)) //
.as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();

16
src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateUnitTests.java
View File

@@ -108,12 +108,12 @@ public class ReactiveElasticsearchTemplateUnitTests {
}
@Test // DATAES-504, DATAES-518
public void findShouldFallBackToDefaultIndexOptionsIfNotSet() {
public void searchShouldFallBackToDefaultIndexOptionsIfNotSet() {
ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class);
when(client.search(captor.capture())).thenReturn(Flux.empty());
template.find(new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(0, 10)), SampleEntity.class) //
template.search(new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(0, 10)), SampleEntity.class) //
.as(StepVerifier::create) //
.verifyComplete();
@@ -121,7 +121,7 @@ public class ReactiveElasticsearchTemplateUnitTests {
}
@Test // DATAES-504, DATAES-518
public void findShouldApplyIndexOptionsIfSet() {
public void searchShouldApplyIndexOptionsIfSet() {
ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class);
when(client.search(captor.capture())).thenReturn(Flux.empty());
@@ -129,7 +129,7 @@ public class ReactiveElasticsearchTemplateUnitTests {
template.setIndicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN);
Query query = new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(0, 10));
template.find(query, SampleEntity.class, index) //
template.search(query, SampleEntity.class, index) //
.as(StepVerifier::create) //
.verifyComplete();
@@ -137,13 +137,13 @@ public class ReactiveElasticsearchTemplateUnitTests {
}
@Test // DATAES-504
public void findShouldApplyPaginationIfSet() {
public void searchShouldApplyPaginationIfSet() {
ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class);
when(client.search(captor.capture())).thenReturn(Flux.empty());
Query query = new CriteriaQuery(new Criteria("*")).setPageable(PageRequest.of(2, 50));
template.find(query, SampleEntity.class, index) //
template.search(query, SampleEntity.class, index) //
.as(StepVerifier::create) //
.verifyComplete();
@@ -152,12 +152,12 @@ public class ReactiveElasticsearchTemplateUnitTests {
}
@Test // DATAES-504, DATAES-518
public void findShouldUseScrollIfPaginationNotSet() {
public void searchShouldUseScrollIfPaginationNotSet() {
ArgumentCaptor<SearchRequest> captor = ArgumentCaptor.forClass(SearchRequest.class);
when(client.scroll(captor.capture())).thenReturn(Flux.empty());
template.find(new CriteriaQuery(new Criteria("*")).setPageable(Pageable.unpaged()), SampleEntity.class) //
template.search(new CriteriaQuery(new Criteria("*")).setPageable(Pageable.unpaged()), SampleEntity.class) //
.as(StepVerifier::create) //
.verifyComplete();

48
src/test/java/org/springframework/data/elasticsearch/core/geo/ElasticsearchTemplateGeoTests.java
View File

@@ -39,6 +39,8 @@ import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.GeoPointField;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.Criteria;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
@@ -139,12 +141,12 @@ public class ElasticsearchTemplateGeoTests {
new Criteria("location").within(new GeoPoint(45.7806d, 3.0875d), "20km"));
// when
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery,
SearchHits<AuthorMarkerEntity> geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery,
AuthorMarkerEntity.class, authorMarkerIndex);
// then
assertThat(geoAuthorsForGeoCriteria).hasSize(1);
assertThat(geoAuthorsForGeoCriteria.get(0).getName()).isEqualTo("Franck Marchand");
assertThat(geoAuthorsForGeoCriteria.getSearchHit(0).getContent().getName()).isEqualTo("Franck Marchand");
}
@Test
@@ -156,12 +158,12 @@ public class ElasticsearchTemplateGeoTests {
new Criteria("name").is("Mohsin Husen").and("location").within(new GeoPoint(51.5171d, 0.1062d), "20km"));
// when
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria2 = operations.queryForList(geoLocationCriteriaQuery2,
SearchHits<AuthorMarkerEntity> geoAuthorsForGeoCriteria2 = operations.search(geoLocationCriteriaQuery2,
AuthorMarkerEntity.class, authorMarkerIndex);
// then
assertThat(geoAuthorsForGeoCriteria2).hasSize(1);
assertThat(geoAuthorsForGeoCriteria2.get(0).getName()).isEqualTo("Mohsin Husen");
assertThat(geoAuthorsForGeoCriteria2.getSearchHit(0).getContent().getName()).isEqualTo("Mohsin Husen");
}
@Test
@@ -172,7 +174,7 @@ public class ElasticsearchTemplateGeoTests {
CriteriaQuery geoLocationCriteriaQuery = new CriteriaQuery(
new Criteria("locationAsString").within(new GeoPoint(51.000000, 0.100000), "1km"));
// when
List<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery,
SearchHits<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery,
LocationMarkerEntity.class, locationMarkerIndex);
// then
@@ -188,7 +190,7 @@ public class ElasticsearchTemplateGeoTests {
new Criteria("locationAsArray").within(new GeoPoint(51.001000, 0.10100), "1km"));
// when
List<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery,
SearchHits<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery,
LocationMarkerEntity.class, locationMarkerIndex);
// then
@@ -203,7 +205,7 @@ public class ElasticsearchTemplateGeoTests {
CriteriaQuery geoLocationCriteriaQuery = new CriteriaQuery(
new Criteria("locationAsArray").within("51.001000, 0.10100", "1km"));
// when
List<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery,
SearchHits<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery,
LocationMarkerEntity.class, locationMarkerIndex);
// then
@@ -218,7 +220,7 @@ public class ElasticsearchTemplateGeoTests {
CriteriaQuery geoLocationCriteriaQuery = new CriteriaQuery(new Criteria("locationAsArray").within("u1044", "3km"));
// when
List<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.queryForList(geoLocationCriteriaQuery,
SearchHits<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.search(geoLocationCriteriaQuery,
LocationMarkerEntity.class, locationMarkerIndex);
// then
@@ -234,7 +236,7 @@ public class ElasticsearchTemplateGeoTests {
.withFilter(QueryBuilders.geoBoundingBoxQuery("locationAsArray").setCorners(52, -1, 50, 1));
// when
List<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.queryForList(queryBuilder.build(),
SearchHits<LocationMarkerEntity> geoAuthorsForGeoCriteria = operations.search(queryBuilder.build(),
LocationMarkerEntity.class, locationMarkerIndex);
// then
@@ -250,12 +252,12 @@ public class ElasticsearchTemplateGeoTests {
new Criteria("location").boundedBy(new GeoBox(new GeoPoint(53.5171d, 0), new GeoPoint(49.5171d, 0.2062d))));
// when
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3,
SearchHits<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3,
AuthorMarkerEntity.class, authorMarkerIndex);
// then
assertThat(geoAuthorsForGeoCriteria3).hasSize(2);
assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName))
assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName))
.containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees");
}
@@ -268,12 +270,12 @@ public class ElasticsearchTemplateGeoTests {
new Criteria("location").boundedBy(Geohash.stringEncode(0, 53.5171d), Geohash.stringEncode(0.2062d, 49.5171d)));
// when
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3,
SearchHits<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3,
AuthorMarkerEntity.class, authorMarkerIndex);
// then
assertThat(geoAuthorsForGeoCriteria3).hasSize(2);
assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName))
assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName))
.containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees");
}
@@ -286,12 +288,12 @@ public class ElasticsearchTemplateGeoTests {
new Criteria("location").boundedBy(new GeoPoint(53.5171d, 0), new GeoPoint(49.5171d, 0.2062d)));
// when
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3,
SearchHits<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3,
AuthorMarkerEntity.class, authorMarkerIndex);
// then
assertThat(geoAuthorsForGeoCriteria3).hasSize(2);
assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName))
assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName))
.containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees");
}
@@ -304,12 +306,12 @@ public class ElasticsearchTemplateGeoTests {
new Criteria("location").boundedBy(new Point(53.5171d, 0), new Point(49.5171d, 0.2062d)));
// when
List<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.queryForList(geoLocationCriteriaQuery3,
SearchHits<AuthorMarkerEntity> geoAuthorsForGeoCriteria3 = operations.search(geoLocationCriteriaQuery3,
AuthorMarkerEntity.class, authorMarkerIndex);
// then
assertThat(geoAuthorsForGeoCriteria3).hasSize(2);
assertThat(geoAuthorsForGeoCriteria3.stream().map(AuthorMarkerEntity::getName))
assertThat(geoAuthorsForGeoCriteria3.stream().map(SearchHit::getContent).map(AuthorMarkerEntity::getName))
.containsExactlyInAnyOrder("Mohsin Husen", "Rizwan Idrees");
}
@@ -332,17 +334,17 @@ public class ElasticsearchTemplateGeoTests {
.withFilter(QueryBuilders.geoBoundingBoxQuery("locationAsGeoHash").setCorners("u10j46mkfek"));
// when
List<LocationMarkerEntity> result1 = operations.queryForList(location1.build(), LocationMarkerEntity.class,
SearchHits<LocationMarkerEntity> result1 = operations.search(location1.build(), LocationMarkerEntity.class,
locationMarkerIndex);
List<LocationMarkerEntity> result2 = operations.queryForList(location2.build(), LocationMarkerEntity.class,
SearchHits<LocationMarkerEntity> result2 = operations.search(location2.build(), LocationMarkerEntity.class,
locationMarkerIndex);
List<LocationMarkerEntity> result3 = operations.queryForList(location3.build(), LocationMarkerEntity.class,
SearchHits<LocationMarkerEntity> result3 = operations.search(location3.build(), LocationMarkerEntity.class,
locationMarkerIndex);
List<LocationMarkerEntity> result4 = operations.queryForList(location4.build(), LocationMarkerEntity.class,
SearchHits<LocationMarkerEntity> result4 = operations.search(location4.build(), LocationMarkerEntity.class,
locationMarkerIndex);
List<LocationMarkerEntity> result5 = operations.queryForList(location5.build(), LocationMarkerEntity.class,
SearchHits<LocationMarkerEntity> result5 = operations.search(location5.build(), LocationMarkerEntity.class,
locationMarkerIndex);
List<LocationMarkerEntity> result11 = operations.queryForList(location11.build(), LocationMarkerEntity.class,
SearchHits<LocationMarkerEntity> result11 = operations.search(location11.build(), LocationMarkerEntity.class,
locationMarkerIndex);
// then

92
src/test/java/org/springframework/data/elasticsearch/core/index/MappingBuilderTests.java
View File

@@ -51,9 +51,11 @@ import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Transient;
import org.springframework.data.elasticsearch.annotations.*;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.completion.Completion;
import org.springframework.data.elasticsearch.core.geo.GeoPoint;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
@@ -80,28 +82,31 @@ import org.springframework.test.context.ContextConfiguration;
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
public class MappingBuilderTests extends MappingContextBaseTests {
@Autowired private ElasticsearchOperations elasticsearchTemplate;
@Autowired private ElasticsearchOperations operations;
private IndexOperations indexOperations;
@BeforeEach
public void before() {
elasticsearchTemplate.deleteIndex(StockPrice.class);
elasticsearchTemplate.deleteIndex(SimpleRecursiveEntity.class);
elasticsearchTemplate.deleteIndex(StockPrice.class);
elasticsearchTemplate.deleteIndex(SampleInheritedEntity.class);
elasticsearchTemplate.deleteIndex(User.class);
elasticsearchTemplate.deleteIndex(Group.class);
elasticsearchTemplate.deleteIndex(Book.class);
elasticsearchTemplate.deleteIndex(NormalizerEntity.class);
elasticsearchTemplate.deleteIndex(CopyToEntity.class);
indexOperations = operations.getIndexOperations();
indexOperations.deleteIndex(StockPrice.class);
indexOperations.deleteIndex(SimpleRecursiveEntity.class);
indexOperations.deleteIndex(StockPrice.class);
indexOperations.deleteIndex(SampleInheritedEntity.class);
indexOperations.deleteIndex(User.class);
indexOperations.deleteIndex(Group.class);
indexOperations.deleteIndex(Book.class);
indexOperations.deleteIndex(NormalizerEntity.class);
indexOperations.deleteIndex(CopyToEntity.class);
}
@Test
public void shouldNotFailOnCircularReference() {
elasticsearchTemplate.createIndex(SimpleRecursiveEntity.class);
elasticsearchTemplate.putMapping(SimpleRecursiveEntity.class);
elasticsearchTemplate.refresh(SimpleRecursiveEntity.class);
indexOperations.createIndex(SimpleRecursiveEntity.class);
indexOperations.putMapping(SimpleRecursiveEntity.class);
indexOperations.refresh(SimpleRecursiveEntity.class);
}
@Test // DATAES-568
@@ -134,26 +139,26 @@ public class MappingBuilderTests extends MappingContextBaseTests {
// Given
// When
elasticsearchTemplate.createIndex(StockPrice.class);
elasticsearchTemplate.putMapping(StockPrice.class);
indexOperations.createIndex(StockPrice.class);
indexOperations.putMapping(StockPrice.class);
String symbol = "AU";
double price = 2.34;
String id = "abc";
IndexCoordinates index = IndexCoordinates.of("test-index-stock-mapping-builder").withTypes( "price");
elasticsearchTemplate.index(buildIndex(StockPrice.builder() //
IndexCoordinates index = IndexCoordinates.of("test-index-stock-mapping-builder").withTypes("price");
operations.index(buildIndex(StockPrice.builder() //
.id(id) //
.symbol(symbol) //
.price(BigDecimal.valueOf(price)) //
.build()), index);
elasticsearchTemplate.refresh(StockPrice.class);
indexOperations.refresh(StockPrice.class);
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
List<StockPrice> result = elasticsearchTemplate.queryForList(searchQuery, StockPrice.class, index);
SearchHits<StockPrice> result = operations.search(searchQuery, StockPrice.class, index);
// Then
assertThat(result).hasSize(1);
StockPrice entry = result.get(0);
StockPrice entry = result.getSearchHit(0).getContent();
assertThat(entry.getSymbol()).isEqualTo(symbol);
assertThat(entry.getPrice()).isCloseTo(BigDecimal.valueOf(price), Percentage.withPercentage(0.01));
}
@@ -186,24 +191,23 @@ public class MappingBuilderTests extends MappingContextBaseTests {
// given
// when
elasticsearchTemplate.createIndex(SampleInheritedEntity.class);
elasticsearchTemplate.putMapping(SampleInheritedEntity.class);
indexOperations.createIndex(SampleInheritedEntity.class);
indexOperations.putMapping(SampleInheritedEntity.class);
Date createdDate = new Date();
String message = "msg";
String id = "abc";
IndexCoordinates index = IndexCoordinates.of("test-index-sample-inherited-mapping-builder").withTypes( "mapping");
elasticsearchTemplate.index(
new SampleInheritedEntityBuilder(id).createdDate(createdDate).message(message).buildIndex(),
IndexCoordinates index = IndexCoordinates.of("test-index-sample-inherited-mapping-builder").withTypes("mapping");
operations.index(new SampleInheritedEntityBuilder(id).createdDate(createdDate).message(message).buildIndex(),
index);
elasticsearchTemplate.refresh(SampleInheritedEntity.class);
operations.refresh(SampleInheritedEntity.class);
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
List<SampleInheritedEntity> result = elasticsearchTemplate.queryForList(searchQuery, SampleInheritedEntity.class, index);
SearchHits<SampleInheritedEntity> result = operations.search(searchQuery, SampleInheritedEntity.class, index);
// then
assertThat(result).hasSize(1);
SampleInheritedEntity entry = result.get(0);
SampleInheritedEntity entry = result.getSearchHit(0).getContent();
assertThat(entry.getCreatedDate()).isEqualTo(createdDate);
assertThat(entry.getMessage()).isEqualTo(message);
}
@@ -228,10 +232,10 @@ public class MappingBuilderTests extends MappingContextBaseTests {
public void shouldHandleReverseRelationship() {
// given
elasticsearchTemplate.createIndex(User.class);
elasticsearchTemplate.putMapping(User.class);
elasticsearchTemplate.createIndex(Group.class);
elasticsearchTemplate.putMapping(Group.class);
indexOperations.createIndex(User.class);
indexOperations.putMapping(User.class);
indexOperations.createIndex(Group.class);
indexOperations.putMapping(Group.class);
// when
@@ -242,8 +246,8 @@ public class MappingBuilderTests extends MappingContextBaseTests {
public void shouldMapBooks() {
// given
elasticsearchTemplate.createIndex(Book.class);
elasticsearchTemplate.putMapping(Book.class);
indexOperations.createIndex(Book.class);
indexOperations.putMapping(Book.class);
// when
@@ -254,11 +258,11 @@ public class MappingBuilderTests extends MappingContextBaseTests {
public void shouldUseBothAnalyzer() {
// given
elasticsearchTemplate.createIndex(Book.class);
elasticsearchTemplate.putMapping(Book.class);
indexOperations.createIndex(Book.class);
indexOperations.putMapping(Book.class);
// when
Map mapping = elasticsearchTemplate.getMapping(Book.class);
Map mapping = operations.getMapping(Book.class);
Map descriptionMapping = (Map) ((Map) mapping.get("properties")).get("description");
Map prefixDescription = (Map) ((Map) descriptionMapping.get("fields")).get("prefix");
@@ -275,11 +279,11 @@ public class MappingBuilderTests extends MappingContextBaseTests {
public void shouldUseKeywordNormalizer() {
// given
elasticsearchTemplate.createIndex(NormalizerEntity.class);
elasticsearchTemplate.putMapping(NormalizerEntity.class);
operations.createIndex(NormalizerEntity.class);
operations.putMapping(NormalizerEntity.class);
// when
Map mapping = elasticsearchTemplate.getMapping(NormalizerEntity.class);
Map mapping = operations.getMapping(NormalizerEntity.class);
Map properties = (Map) mapping.get("properties");
Map fieldName = (Map) properties.get("name");
Map fieldDescriptionLowerCase = (Map) ((Map) ((Map) properties.get("description")).get("fields")).get("lower_case");
@@ -295,11 +299,11 @@ public class MappingBuilderTests extends MappingContextBaseTests {
public void shouldUseCopyTo() {
// given
elasticsearchTemplate.createIndex(CopyToEntity.class);
elasticsearchTemplate.putMapping(CopyToEntity.class);
operations.createIndex(CopyToEntity.class);
operations.putMapping(CopyToEntity.class);
// when
Map mapping = elasticsearchTemplate.getMapping(CopyToEntity.class);
Map mapping = operations.getMapping(CopyToEntity.class);
Map properties = (Map) mapping.get("properties");
Map fieldFirstName = (Map) properties.get("firstName");
Map fieldLastName = (Map) properties.get("lastName");

45
src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryTests.java
View File

@@ -42,6 +42,7 @@ import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.Score;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
@@ -93,7 +94,7 @@ public class CriteriaQueryTests {
new Criteria("message").contains("test").and("message").contains("some"));
// when
SampleEntity sampleEntity1 = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity1 = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(sampleEntity1).isNotNull();
@@ -136,7 +137,7 @@ public class CriteriaQueryTests {
new Criteria("message").contains("some").or("message").contains("test"));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
@@ -167,7 +168,7 @@ public class CriteriaQueryTests {
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
@@ -198,7 +199,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria().or(new Criteria("message").contains("some")));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
@@ -227,7 +228,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("some message"));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message");
@@ -269,7 +270,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("some message"));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message");
@@ -312,7 +313,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(criteria);
// when
SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message");
@@ -354,7 +355,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(criteria);
// when
SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message");
@@ -395,7 +396,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("contains"));
// when
SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message");
@@ -436,7 +437,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").expression("+elasticsearch || test"));
// when
SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message");
@@ -478,7 +479,7 @@ public class CriteriaQueryTests {
new Criteria("message").startsWith("some").endsWith("search").contains("message").is("some message search"));
// when
SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().getField().getName()).isEqualTo("message");
@@ -519,12 +520,12 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("foo").not());
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(criteriaQuery.getCriteria().isNegating()).isTrue();
assertThat(page).isNotNull();
assertThat(page.iterator().next().getMessage()).doesNotContain("foo");
assertThat(page.iterator().next().getContent().getMessage()).doesNotContain("foo");
}
@Test
@@ -563,7 +564,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(100, 150));
// when
SampleEntity sampleEntity = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(sampleEntity).isNotNull();
@@ -605,7 +606,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(350, null));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
@@ -648,7 +649,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").between(null, 550));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
@@ -691,7 +692,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").lessThanEqual(750));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
@@ -734,7 +735,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("rate").greaterThanEqual(950));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page).isNotNull();
@@ -777,7 +778,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").contains("foo").boost(1));
// when
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page.getTotalElements()).isGreaterThanOrEqualTo(1);
@@ -800,11 +801,11 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(
new Criteria("message").contains("a").or(new Criteria("message").contains("b")));
criteriaQuery.setMinScore(2.0F);
Page<SampleEntity> page = operations.queryForPage(criteriaQuery, SampleEntity.class, index);
Page<SearchHit<SampleEntity>> page = operations.searchForPage(criteriaQuery, SampleEntity.class, index);
// then
assertThat(page.getTotalElements()).isEqualTo(1);
assertThat(page.getContent().get(0).getMessage()).isEqualTo("ab");
assertThat(page.getContent().get(0).getContent().getMessage()).isEqualTo("ab");
}
@Test // DATAES-213
@@ -826,7 +827,7 @@ public class CriteriaQueryTests {
CriteriaQuery criteriaQuery = new CriteriaQuery(new Criteria("message").is("Hello World!"));
// when
SampleEntity sampleEntity1 = operations.queryForObject(criteriaQuery, SampleEntity.class, index);
SearchHit<SampleEntity> sampleEntity1 = operations.searchOne(criteriaQuery, SampleEntity.class, index);
// then
assertThat(sampleEntity1).isNotNull();

14
src/test/java/org/springframework/data/elasticsearch/repositories/custommethod/CustomMethodRepositoryBaseTests.java
View File

@@ -1333,6 +1333,20 @@ public abstract class CustomMethodRepositoryBaseTests {
assertThat(stream.count()).isEqualTo(10L);
}
@Test // DATAES-672
void streamMethodShouldNotReturnSearchHits() {
// given
List<SampleEntity> entities = createSampleEntities("abc", 2);
repository.saveAll(entities);
// when
Stream<SampleEntity> stream = streamingRepository.findByType("abc");
// then
assertThat(stream).isNotNull();
stream.forEach(o -> assertThat(o).isInstanceOf(SampleEntity.class));
}
private List<SampleEntity> createSampleEntities(String type, int numberOfEntities) {
List<SampleEntity> entities = new ArrayList<>();

7
src/test/java/org/springframework/data/elasticsearch/repositories/setting/dynamic/DynamicSettingAndMappingEntityRepositoryTests.java
View File

@@ -17,7 +17,6 @@ package org.springframework.data.elasticsearch.repositories.setting.dynamic;
import static org.assertj.core.api.Assertions.*;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.RandomStringUtils;
@@ -32,6 +31,7 @@ import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Mapping;
import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
@@ -109,13 +109,14 @@ public class DynamicSettingAndMappingEntityRepositoryTests {
IndexCoordinates index = IndexCoordinates.of("test-index-dynamic-setting-and-mapping")
.withTypes("test-setting-type");
long count = operations.count(searchQuery, DynamicSettingAndMappingEntity.class, index);
List<DynamicSettingAndMappingEntity> entityList = operations.queryForList(searchQuery,
SearchHits<DynamicSettingAndMappingEntity> entityList = operations.search(searchQuery,
DynamicSettingAndMappingEntity.class, index);
// then
assertThat(count).isEqualTo(1L);
assertThat(entityList).isNotNull().hasSize(1);
assertThat(entityList.get(0).getEmail()).isEqualTo(dynamicSettingAndMappingEntity1.getEmail());
assertThat(entityList.getSearchHit(0).getContent().getEmail())
.isEqualTo(dynamicSettingAndMappingEntity1.getEmail());
}
@Test

8
src/test/java/org/springframework/data/elasticsearch/repositories/synonym/SynonymRepositoryTests.java
View File

@@ -19,8 +19,6 @@ import static org.assertj.core.api.Assertions.*;
import lombok.Data;
import java.util.List;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -32,6 +30,7 @@ import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Mapping;
import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
@@ -77,12 +76,11 @@ public class SynonymRepositoryTests {
repository.save(entry1);
repository.save(entry2);
// when
// whe
// then
assertThat(repository.count()).isEqualTo(2L);
List<SynonymEntity> synonymEntities = operations.queryForList(
SearchHits<SynonymEntity> synonymEntities = operations.search(
new NativeSearchQueryBuilder().withQuery(QueryBuilders.termQuery("text", "british")).build(),
SynonymEntity.class, IndexCoordinates.of("test-index-synonym").withTypes("synonym-type"));
assertThat(synonymEntities).hasSize(1);