Cwikius-Spring/spring-data-elasticsearch
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-data-elasticsearch.git synced 2025-06-29 07:12:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introduce IndexOperationsAdapter.

Browse Source 
Original Pull Request #2724
Closes #2723
This commit is contained in:
Peter-Josef Meisch 2023-10-08 13:13:09 +02:00 committed by GitHub
parent ccb7d2387f
commit 0b33d7fe57
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 372 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

214
src/main/java/org/springframework/data/elasticsearch/core/IndexOperationsAdapter.java Normal file
View File

@ -0,0 +1,214 @@
/*
* Copyright 2023 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.core;
import reactor.core.publisher.Mono;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.index.*;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* Adapter for creating synchronous calls for a reactive {@link ReactiveIndexOperations}.
*
* @author Peter-Josef Meisch
* @since 5.2
*/
public interface IndexOperationsAdapter extends IndexOperations {
static IndexOperationsAdapter blocking(ReactiveIndexOperations reactiveIndexOperations) {
Assert.notNull(reactiveIndexOperations, "reactiveIndexOperations must not be null");
return new IndexOperationsAdapter() {
@Override
public boolean create() {
return Boolean.TRUE.equals(reactiveIndexOperations.create().block());
}
@Override
public boolean create(Map<String, Object> settings) {
return Boolean.TRUE.equals(reactiveIndexOperations.create(settings).block());
}
@Override
public boolean create(Map<String, Object> settings, Document mapping) {
return Boolean.TRUE.equals(reactiveIndexOperations.create(settings, mapping).block());
}
@Override
public boolean createWithMapping() {
return Boolean.TRUE.equals(reactiveIndexOperations.createWithMapping().block());
}
@Override
public boolean delete() {
return Boolean.TRUE.equals(reactiveIndexOperations.delete().block());
}
@Override
public boolean exists() {
return Boolean.TRUE.equals(reactiveIndexOperations.exists().block());
}
@Override
public void refresh() {
reactiveIndexOperations.refresh().block();
}
@Override
public Document createMapping() {
return Objects.requireNonNull(reactiveIndexOperations.createMapping().block());
}
@Override
public Document createMapping(Class<?> clazz) {
return Objects.requireNonNull(reactiveIndexOperations.createMapping(clazz).block());
}
@Override
public boolean putMapping(Document mapping) {
return Boolean.TRUE.equals(reactiveIndexOperations.putMapping(Mono.just(mapping)).block());
}
@Override
public Map<String, Object> getMapping() {
return Objects.requireNonNull(reactiveIndexOperations.getMapping().block());
}
@Override
public Settings createSettings() {
return Objects.requireNonNull(reactiveIndexOperations.createSettings().block());
}
@Override
public Settings createSettings(Class<?> clazz) {
return Objects.requireNonNull(reactiveIndexOperations.createSettings(clazz).block());
}
@Override
public Settings getSettings() {
return Objects.requireNonNull(reactiveIndexOperations.getSettings().block());
}
@Override
public Settings getSettings(boolean includeDefaults) {
return Objects.requireNonNull(reactiveIndexOperations.getSettings(includeDefaults).block());
}
@Override
public boolean alias(AliasActions aliasActions) {
return Boolean.TRUE.equals(reactiveIndexOperations.alias(aliasActions).block());
}
@Override
public Map<String, Set<AliasData>> getAliases(String... aliasNames) {
return Objects.requireNonNull(reactiveIndexOperations.getAliases(aliasNames).block());
}
@Override
public Map<String, Set<AliasData>> getAliasesForIndex(String... indexNames) {
return Objects.requireNonNull(reactiveIndexOperations.getAliasesForIndex(indexNames).block());
}
@Deprecated
@Override
public boolean putTemplate(PutTemplateRequest putTemplateRequest) {
return Boolean.TRUE.equals(reactiveIndexOperations.putTemplate(putTemplateRequest).block());
}
@Override
public boolean putIndexTemplate(PutIndexTemplateRequest putIndexTemplateRequest) {
return Boolean.TRUE.equals(reactiveIndexOperations.putIndexTemplate(putIndexTemplateRequest).block());
}
@Override
public boolean putComponentTemplate(PutComponentTemplateRequest putComponentTemplateRequest) {
return Boolean.TRUE.equals(reactiveIndexOperations.putComponentTemplate(putComponentTemplateRequest).block());
}
@Override
public boolean existsComponentTemplate(ExistsComponentTemplateRequest existsComponentTemplateRequest) {
return Boolean.TRUE
.equals(reactiveIndexOperations.existsComponentTemplate(existsComponentTemplateRequest).block());
}
@Override
public List<TemplateResponse> getComponentTemplate(GetComponentTemplateRequest getComponentTemplateRequest) {
return Objects.requireNonNull(
reactiveIndexOperations.getComponentTemplate(getComponentTemplateRequest).collectList().block());
}
@Override
public boolean deleteComponentTemplate(DeleteComponentTemplateRequest deleteComponentTemplateRequest) {
return Boolean.TRUE
.equals(reactiveIndexOperations.deleteComponentTemplate(deleteComponentTemplateRequest).block());
}
@Deprecated
@Nullable
@Override
public TemplateData getTemplate(GetTemplateRequest getTemplateRequest) {
return Objects.requireNonNull(reactiveIndexOperations).getTemplate(getTemplateRequest).block();
}
@Deprecated
@Override
public boolean existsTemplate(ExistsTemplateRequest existsTemplateRequest) {
return Boolean.TRUE.equals(reactiveIndexOperations.existsTemplate(existsTemplateRequest).block());
}
@Override
public boolean existsIndexTemplate(ExistsIndexTemplateRequest existsTemplateRequest) {
return Boolean.TRUE.equals(reactiveIndexOperations.existsIndexTemplate(existsTemplateRequest).block());
}
@Override
public List<TemplateResponse> getIndexTemplate(GetIndexTemplateRequest getIndexTemplateRequest) {
return Objects
.requireNonNull(reactiveIndexOperations.getIndexTemplate(getIndexTemplateRequest).collectList().block());
}
@Override
public boolean deleteIndexTemplate(DeleteIndexTemplateRequest deleteIndexTemplateRequest) {
return Boolean.TRUE.equals(reactiveIndexOperations.deleteIndexTemplate(deleteIndexTemplateRequest).block());
}
@Deprecated
@Override
public boolean deleteTemplate(DeleteTemplateRequest deleteTemplateRequest) {
return Boolean.TRUE.equals(reactiveIndexOperations.deleteTemplate(deleteTemplateRequest).block());
}
@Override
public List<IndexInformation> getInformation(IndexCoordinates index) {
return Objects.requireNonNull(reactiveIndexOperations.getInformation(index).collectList().block());
}
@Override
public IndexCoordinates getIndexCoordinates() {
return reactiveIndexOperations.getIndexCoordinates();
}
};
}
}

12
src/main/java/org/springframework/data/elasticsearch/repository/support/SimpleReactiveElasticsearchRepository.java
View File

@ -15,6 +15,8 @@
*/
package org.springframework.data.elasticsearch.repository.support;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@ -62,12 +64,14 @@ public class SimpleReactiveElasticsearchRepository<T, ID> implements ReactiveEla
private void createIndexAndMappingIfNeeded() {
var blockingIndexOperations = blocking(indexOperations);
if (shouldCreateIndexAndMapping()) {
indexOperations.exists() //
.flatMap(exists -> exists ? Mono.empty() : indexOperations.createWithMapping()) //
.block();
if (!blockingIndexOperations.exists()) {
blockingIndexOperations.createWithMapping();
}
} else if (shouldAlwaysWriteMapping()) {
indexOperations.putMapping().block();
blockingIndexOperations.putMapping();
}
}

21
src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchIntegrationTests.java
View File

@ -18,6 +18,7 @@ package org.springframework.data.elasticsearch.core;
import static java.util.Collections.*;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.annotations.FieldType.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import static org.springframework.data.elasticsearch.core.query.StringQuery.*;
import reactor.core.publisher.Flux;
@ -105,14 +106,14 @@ public abstract class ReactiveElasticsearchIntegrationTests {
public void beforeEach() {
indexNameProvider.increment();
operations.indexOps(SampleEntity.class).createWithMapping().block();
operations.indexOps(IndexedIndexNameEntity.class).createWithMapping().block();
blocking(operations.indexOps(SampleEntity.class)).createWithMapping();
blocking(operations.indexOps(IndexedIndexNameEntity.class)).createWithMapping();
}
@Test
@Order(java.lang.Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
// endregion
@ -625,7 +626,8 @@ public abstract class ReactiveElasticsearchIntegrationTests {
.as(StepVerifier::create)//
.verifyComplete();
operations.indexOps(thisIndex).refresh().then(operations.indexOps(thatIndex).refresh()).block();
blocking(operations.indexOps(thisIndex)).refresh();
blocking(operations.indexOps(thatIndex)).refresh();
Query query = getBuilderWithTermQuery("message", "test").build();
@ -651,7 +653,8 @@ public abstract class ReactiveElasticsearchIntegrationTests {
.as(StepVerifier::create)//
.verifyComplete();
operations.indexOps(thisIndex).refresh().then(operations.indexOps(thatIndex).refresh()).block();
blocking(operations.indexOps(thisIndex)).refresh();
blocking(operations.indexOps(thatIndex)).refresh();
Query query = getBuilderWithTermQuery("message", "negative").build();
@ -876,7 +879,7 @@ public abstract class ReactiveElasticsearchIntegrationTests {
original.setMessage("It's fine");
OptimisticEntity saved = operations.save(original).block();
operations.indexOps(OptimisticEntity.class).refresh().block();
blocking(operations.indexOps(OptimisticEntity.class)).refresh();
operations
.search(searchQueryForOne(saved.getId()), OptimisticEntity.class,
@ -1081,14 +1084,16 @@ public abstract class ReactiveElasticsearchIntegrationTests {
String indexName = indexNameProvider.indexName();
String aliasName = indexName + "-alias";
ReactiveIndexOperations indexOps = operations.indexOps(EntityWithSettingsAndMappingsReactive.class);
var blockingIndexOps = blocking(indexOps);
// beforeEach uses SampleEntity, so recreate the index here
indexOps.delete().then(indexOps.createWithMapping()).block();
blockingIndexOps.delete();
blockingIndexOps.createWithMapping();
AliasActionParameters parameters = AliasActionParameters.builder().withAliases(aliasName).withIndices(indexName)
.withIsHidden(false).withIsWriteIndex(false).withRouting("indexrouting").withSearchRouting("searchrouting")
.build();
indexOps.alias(new AliasActions(new AliasAction.Add(parameters))).block();
blockingIndexOps.alias(new AliasActions(new AliasAction.Add(parameters)));
indexOps.getInformation().as(StepVerifier::create).consumeNextWith(indexInformation -> {
assertThat(indexInformation.getName()).isEqualTo(indexName);

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

@ -16,6 +16,7 @@
package org.springframework.data.elasticsearch.core;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import java.time.Duration;
import java.util.List;
@ -49,19 +50,17 @@ public abstract class ReactivePointInTimeIntegrationTests {
@Autowired ReactiveElasticsearchOperations operations;
@Autowired IndexNameProvider indexNameProvider;
@Nullable ReactiveIndexOperations indexOperations;
@BeforeEach
void setUp() {
indexNameProvider.increment();
indexOperations = operations.indexOps(SampleEntity.class);
indexOperations.createWithMapping().block();
blocking(operations.indexOps(SampleEntity.class)).createWithMapping();
}
@Test
@Order(Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*')).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // #1684

5
src/test/java/org/springframework/data/elasticsearch/core/ReactiveReindexIntegrationTests.java
View File

@ -16,6 +16,7 @@
package org.springframework.data.elasticsearch.core;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import static org.springframework.data.elasticsearch.utils.IdGenerator.*;
import reactor.test.StepVerifier;
@ -54,13 +55,13 @@ public abstract class ReactiveReindexIntegrationTests {
public void beforeEach() {
indexNameProvider.increment();
operations.indexOps(Entity.class).createWithMapping().block();
blocking(operations.indexOps(Entity.class)).createWithMapping();
}
@Test
@Order(java.lang.Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test

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

@ -17,6 +17,7 @@ package org.springframework.data.elasticsearch.core;
import static org.assertj.core.api.Assertions.*;
import static org.skyscreamer.jsonassert.JSONAssert.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.test.StepVerifier;
@ -74,19 +75,17 @@ public abstract class ReactiveSearchTemplateIntegrationTests {
@Autowired ReactiveElasticsearchOperations operations;
@Autowired IndexNameProvider indexNameProvider;
@Nullable ReactiveIndexOperations indexOperations;
@BeforeEach
void setUp() {
indexNameProvider.increment();
indexOperations = operations.indexOps(Person.class);
indexOperations.createWithMapping().block();
blocking(operations.indexOps(Person.class)).createWithMapping();
}
@Test
@Order(Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*')).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // #1891

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

@ -16,6 +16,7 @@
package org.springframework.data.elasticsearch.core.event;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
@ -29,7 +30,6 @@ import org.springframework.context.annotation.Configuration;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ReactiveIndexOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexNameProvider;
@ -76,14 +76,13 @@ public abstract class ReactiveCallbackIntegrationTests {
@BeforeEach
void setUp() {
indexNameProvider.increment();
ReactiveIndexOperations indexOps = operations.indexOps(SampleEntity.class);
indexOps.createWithMapping().block();
blocking(operations.indexOps(SampleEntity.class)).createWithMapping();
}
@Test
@Order(java.lang.Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // DATES-68

36
src/test/java/org/springframework/data/elasticsearch/core/index/ReactiveIndexOperationsIntegrationTests.java
View File

@ -17,6 +17,7 @@ package org.springframework.data.elasticsearch.core.index;
import static org.assertj.core.api.Assertions.*;
import static org.skyscreamer.jsonassert.JSONAssert.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
@ -36,7 +37,7 @@ import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.Mapping;
import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.core.AbstractReactiveElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ReactiveIndexOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
@ -53,17 +54,19 @@ public abstract class ReactiveIndexOperationsIntegrationTests {
@Autowired private ReactiveElasticsearchOperations operations;
@Autowired private IndexNameProvider indexNameProvider;
private ReactiveIndexOperations indexOperations;
private IndexOperations blockingIndexOperations;
@BeforeEach
void setUp() {
indexNameProvider.increment();
indexOperations = operations.indexOps(IndexCoordinates.of(indexNameProvider.indexName()));
blockingIndexOperations = blocking(indexOperations);
}
@Test
@Order(java.lang.Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // DATAES-678
@ -167,41 +170,28 @@ public abstract class ReactiveIndexOperationsIntegrationTests {
@Test // DATAES-678
void shouldDeleteIfItExists() {
indexOperations.create().block();
blockingIndexOperations.create();
indexOperations.delete() //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
assertThat(blockingIndexOperations.delete()).isTrue();
}
@Test // DATAES-678
void shouldReturnFalseOnDeleteIfItDoesNotExist() {
indexOperations.delete() //
.as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
assertThat(blockingIndexOperations.delete()).isFalse();
}
@Test // DATAES-678
void shouldReturnExistsTrueIfIndexDoesExist() {
indexOperations.create().block();
blockingIndexOperations.create();
indexOperations.exists() //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
assertThat(blockingIndexOperations.exists()).isTrue();
}
@Test // DATAES-678
void shouldReturnExistsFalseIfIndexDoesNotExist() {
indexOperations.exists() //
.as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
assertThat(blockingIndexOperations.exists()).isFalse();
}
@Test // DATAES-678
@ -344,8 +334,8 @@ public abstract class ReactiveIndexOperationsIntegrationTests {
aliasActions.add(new AliasAction.Add(AliasActionParameters.builder()
.withIndices(indexOperations.getIndexCoordinates().getIndexNames()).withAliases("aliasA", "aliasB").build()));
assertThat(indexOperations.create().block()).isTrue();
assertThat(indexOperations.alias(aliasActions).block()).isTrue();
assertThat(blockingIndexOperations.create()).isTrue();
assertThat(blockingIndexOperations.alias(aliasActions)).isTrue();
indexOperations.getAliases("aliasA") //
.as(StepVerifier::create) //

125
src/test/java/org/springframework/data/elasticsearch/core/index/ReactiveIndexTemplateIntegrationTests.java
View File

@ -17,6 +17,7 @@ package org.springframework.data.elasticsearch.core.index;
import static org.assertj.core.api.Assertions.*;
import static org.skyscreamer.jsonassert.JSONAssert.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.test.StepVerifier;
@ -36,7 +37,7 @@ import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.core.AbstractReactiveElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ReactiveIndexOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
@ -56,25 +57,27 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
@Autowired private ReactiveElasticsearchOperations operations;
@Autowired private IndexNameProvider indexNameProvider;
private ReactiveIndexOperations indexOperations;
private IndexOperations blockingIndexOperations;
@BeforeEach
void setUp() {
indexNameProvider.increment();
indexOperations = operations.indexOps(IndexCoordinates.of(indexNameProvider.indexName()));
blockingIndexOperations = blocking(indexOperations);
}
@Test
@Order(Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // DATAES-612
void shouldPutTemplate() {
org.springframework.data.elasticsearch.core.document.Document mapping = indexOperations
.createMapping(TemplateClass.class).block();
Settings settings = indexOperations.createSettings(TemplateClass.class).block();
org.springframework.data.elasticsearch.core.document.Document mapping = blockingIndexOperations
.createMapping(TemplateClass.class);
Settings settings = blockingIndexOperations.createSettings(TemplateClass.class);
AliasActions aliasActions = new AliasActions(
new AliasAction.Add(AliasActionParameters.builderForTemplate().withAliases("alias1", "alias2").build()));
@ -86,7 +89,7 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.withVersion(42) //
.build();
Boolean acknowledged = indexOperations.putTemplate(putTemplateRequest).block();
Boolean acknowledged = blockingIndexOperations.putTemplate(putTemplateRequest);
assertThat(acknowledged).isTrue();
}
@ -94,11 +97,11 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
@DisplayName("should create component template")
void shouldCreateComponentTemplate() {
ReactiveIndexOperations indexOps = operations.indexOps(IndexCoordinates.of("dont-care"));
var blockingIndexOps = blocking(operations.indexOps(IndexCoordinates.of("dont-care")));
org.springframework.data.elasticsearch.core.document.Document mapping = indexOps.createMapping(TemplateClass.class)
.block();
Settings settings = indexOps.createSettings(TemplateClass.class).block();
org.springframework.data.elasticsearch.core.document.Document mapping = blockingIndexOps
.createMapping(TemplateClass.class);
Settings settings = blockingIndexOps.createSettings(TemplateClass.class);
AliasActions aliasActions = new AliasActions( //
new AliasAction.Add(AliasActionParameters.builderForTemplate() //
@ -115,7 +118,7 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.build() //
).build();
boolean acknowledged = indexOps.putComponentTemplate(putComponentTemplateRequest).block();
boolean acknowledged = blockingIndexOps.putComponentTemplate(putComponentTemplateRequest);
assertThat(acknowledged).isTrue();
}
@ -123,11 +126,11 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
@Test // #1458
@DisplayName("should get component template")
void shouldGetComponentTemplate() throws JSONException {
ReactiveIndexOperations indexOps = operations.indexOps(IndexCoordinates.of("dont-care"));
var blockingIndexOps = blocking(operations.indexOps(IndexCoordinates.of("dont-care")));
org.springframework.data.elasticsearch.core.document.Document mapping = indexOps.createMapping(TemplateClass.class)
.block();
Settings settings = indexOps.createSettings(TemplateClass.class).block();
org.springframework.data.elasticsearch.core.document.Document mapping = blockingIndexOps
.createMapping(TemplateClass.class);
Settings settings = blockingIndexOps.createSettings(TemplateClass.class);
var filterQuery = CriteriaQuery.builder(Criteria.where("message").is("foo")).build();
AliasActions aliasActions = new AliasActions(new AliasAction.Add(AliasActionParameters.builderForTemplate() //
@ -145,12 +148,12 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.build()) //
.build();
boolean acknowledged = indexOps.putComponentTemplate(putComponentTemplateRequest).block();
boolean acknowledged = blockingIndexOps.putComponentTemplate(putComponentTemplateRequest);
assertThat(acknowledged).isTrue();
GetComponentTemplateRequest getComponentTemplateRequest = new GetComponentTemplateRequest(
putComponentTemplateRequest.name());
var componentTemplates = indexOps.getComponentTemplate(getComponentTemplateRequest).collectList().block();
var componentTemplates = blockingIndexOps.getComponentTemplate(getComponentTemplateRequest);
assertThat(componentTemplates).isNotNull().hasSize(1);
var returnedComponentTemplate = componentTemplates.iterator().next();
@ -173,26 +176,26 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
@DisplayName("should delete component template")
void shouldDeleteComponentTemplate() {
ReactiveIndexOperations indexOps = operations.indexOps(IndexCoordinates.of("dont-care"));
var blockingIndexOps = blocking(operations.indexOps(IndexCoordinates.of("dont-care")));
String templateName = "template" + UUID.randomUUID().toString();
var putComponentTemplateRequest = PutComponentTemplateRequest.builder() //
.withName(templateName) //
.withTemplateData(ComponentTemplateRequestData.builder() //
.withSettings(indexOps.createSettings(TemplateClass.class).block()) //
.withSettings(blockingIndexOps.createSettings(TemplateClass.class)) //
.build() //
).build();
ExistsComponentTemplateRequest existsComponentTemplateRequest = new ExistsComponentTemplateRequest(templateName);
boolean acknowledged = indexOps.putComponentTemplate(putComponentTemplateRequest).block();
boolean acknowledged = blockingIndexOps.putComponentTemplate(putComponentTemplateRequest);
assertThat(acknowledged).isTrue();
boolean exists = indexOps.existsComponentTemplate(existsComponentTemplateRequest).block();
boolean exists = blockingIndexOps.existsComponentTemplate(existsComponentTemplateRequest);
assertThat(exists).isTrue();
acknowledged = indexOps.deleteComponentTemplate(new DeleteComponentTemplateRequest(templateName)).block();
acknowledged = blockingIndexOps.deleteComponentTemplate(new DeleteComponentTemplateRequest(templateName));
assertThat(acknowledged).isTrue();
exists = indexOps.existsComponentTemplate(existsComponentTemplateRequest).block();
exists = blockingIndexOps.existsComponentTemplate(existsComponentTemplateRequest);
assertThat(exists).isFalse();
}
@ -200,10 +203,10 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
@DisplayName("should put, get and delete index template with template")
void shouldPutGetAndDeleteIndexTemplateWithTemplate() {
ReactiveIndexOperations indexOps = operations.indexOps(IndexCoordinates.of("dont-care"));
org.springframework.data.elasticsearch.core.document.Document mapping = indexOps.createMapping(TemplateClass.class)
.block();
Settings settings = indexOps.createSettings(TemplateClass.class).block();
var blockingIndexOps = blocking(operations.indexOps(IndexCoordinates.of("dont-care")));
org.springframework.data.elasticsearch.core.document.Document mapping = blockingIndexOps
.createMapping(TemplateClass.class);
Settings settings = blockingIndexOps.createSettings(TemplateClass.class);
AliasActions aliasActions = new AliasActions( //
new AliasAction.Add(AliasActionParameters.builderForTemplate() //
@ -219,20 +222,20 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.withAliasActions(aliasActions) //
.build();
Boolean acknowledged = indexOps.putIndexTemplate(putIndexTemplateRequest).block();
Boolean acknowledged = blockingIndexOps.putIndexTemplate(putIndexTemplateRequest);
assertThat(acknowledged).isTrue();
var exists = indexOps.existsIndexTemplate(indexTemplateName).block();
var exists = blockingIndexOps.existsIndexTemplate(indexTemplateName);
assertThat(exists).isTrue();
var indexTemplates = indexOps.getIndexTemplate(indexTemplateName).collectList().block();
var indexTemplates = blockingIndexOps.getIndexTemplate(indexTemplateName);
assertThat(indexTemplates).hasSize(1);
// delete template
acknowledged = indexOps.deleteIndexTemplate(indexTemplateName).block();
acknowledged = blockingIndexOps.deleteIndexTemplate(indexTemplateName);
assertThat(acknowledged).isTrue();
exists = indexOps.existsIndexTemplate(indexTemplateName).block();
exists = blockingIndexOps.existsIndexTemplate(indexTemplateName);
assertThat(exists).isFalse();
}
@ -240,11 +243,11 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
@DisplayName("should put, get and delete index template of components")
void shouldPutGetAndDeleteIndexTemplateOfComponents() {
ReactiveIndexOperations indexOps = operations.indexOps(IndexCoordinates.of("dont-care"));
var blockingIndexOps = blocking(operations.indexOps(IndexCoordinates.of("dont-care")));
org.springframework.data.elasticsearch.core.document.Document mapping = indexOps.createMapping(TemplateClass.class)
.block();
Settings settings = indexOps.createSettings(TemplateClass.class).block();
org.springframework.data.elasticsearch.core.document.Document mapping = blockingIndexOps
.createMapping(TemplateClass.class);
Settings settings = blockingIndexOps.createSettings(TemplateClass.class);
var filterQuery = CriteriaQuery.builder(Criteria.where("message").is("foo")).build();
AliasActions aliasActions = new AliasActions(new AliasAction.Add(AliasActionParameters.builderForTemplate() //
@ -260,7 +263,7 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.build()) //
.build();
Boolean acknowledged = indexOps.putComponentTemplate(putComponentTemplateRequestMapping).block();
Boolean acknowledged = blockingIndexOps.putComponentTemplate(putComponentTemplateRequestMapping);
assertThat(acknowledged).isTrue();
PutComponentTemplateRequest putComponentTemplateRequestSettings = PutComponentTemplateRequest.builder() //
@ -271,7 +274,7 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.build()) //
.build();
acknowledged = indexOps.putComponentTemplate(putComponentTemplateRequestSettings).block();
acknowledged = blockingIndexOps.putComponentTemplate(putComponentTemplateRequestSettings);
assertThat(acknowledged).isTrue();
PutComponentTemplateRequest putComponentTemplateRequestAliases = PutComponentTemplateRequest.builder() //
@ -282,7 +285,7 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.build()) //
.build();
acknowledged = indexOps.putComponentTemplate(putComponentTemplateRequestAliases).block();
acknowledged = blockingIndexOps.putComponentTemplate(putComponentTemplateRequestAliases);
assertThat(acknowledged).isTrue();
var indexTemplateName = "test-index-template";
@ -294,24 +297,24 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.withComposedOf(composedOf) //
.build();
acknowledged = indexOps.putIndexTemplate(putIndexTemplateRequest).block();
acknowledged = blockingIndexOps.putIndexTemplate(putIndexTemplateRequest);
assertThat(acknowledged).isTrue();
var indexTemplates = indexOps.getIndexTemplate(indexTemplateName).collectList().block();
var indexTemplates = blockingIndexOps.getIndexTemplate(indexTemplateName);
assertThat(indexTemplates).hasSize(1);
assertThat(indexTemplates.get(0).templateData().composedOf()).isEqualTo(composedOf);
// delete template and components
acknowledged = indexOps.deleteIndexTemplate(indexTemplateName).block();
acknowledged = blockingIndexOps.deleteIndexTemplate(indexTemplateName);
assertThat(acknowledged).isTrue();
acknowledged = indexOps
.deleteComponentTemplate(new DeleteComponentTemplateRequest("test-component-template-mapping")).block();
acknowledged = blockingIndexOps
.deleteComponentTemplate(new DeleteComponentTemplateRequest("test-component-template-mapping"));
assertThat(acknowledged).isTrue();
acknowledged = indexOps
.deleteComponentTemplate(new DeleteComponentTemplateRequest("test-component-template-settings")).block();
acknowledged = blockingIndexOps
.deleteComponentTemplate(new DeleteComponentTemplateRequest("test-component-template-settings"));
assertThat(acknowledged).isTrue();
acknowledged = indexOps
.deleteComponentTemplate(new DeleteComponentTemplateRequest("test-component-template-aliases")).block();
acknowledged = blockingIndexOps
.deleteComponentTemplate(new DeleteComponentTemplateRequest("test-component-template-aliases"));
assertThat(acknowledged).isTrue();
}
@ -329,9 +332,11 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
@Test // DATAES-612
void shouldGetTemplate() throws JSONException {
org.springframework.data.elasticsearch.core.document.Document mapping = indexOperations
.createMapping(TemplateClass.class).block();
Settings settings = indexOperations.createSettings(TemplateClass.class).block();
var blockingIndexOperations = blocking(indexOperations);
org.springframework.data.elasticsearch.core.document.Document mapping = blockingIndexOperations
.createMapping(TemplateClass.class);
Settings settings = blockingIndexOperations.createSettings(TemplateClass.class);
AliasActions aliasActions = new AliasActions(
new AliasAction.Add(AliasActionParameters.builderForTemplate().withAliases("alias1", "alias2").build()));
@ -343,11 +348,11 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.withVersion(42) //
.build();
Boolean acknowledged = indexOperations.putTemplate(putTemplateRequest).block();
Boolean acknowledged = blockingIndexOperations.putTemplate(putTemplateRequest);
assertThat(acknowledged).isTrue();
GetTemplateRequest getTemplateRequest = new GetTemplateRequest(putTemplateRequest.getName());
TemplateData templateData = indexOperations.getTemplate(getTemplateRequest).block();
TemplateData templateData = blockingIndexOperations.getTemplate(getTemplateRequest);
SoftAssertions softly = new SoftAssertions();
softly.assertThat(templateData).isNotNull();
@ -371,7 +376,7 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
String templateName = "template" + UUID.randomUUID().toString();
ExistsTemplateRequest existsTemplateRequest = new ExistsTemplateRequest(templateName);
boolean exists = indexOperations.existsTemplate(existsTemplateRequest).block();
boolean exists = blockingIndexOperations.existsTemplate(existsTemplateRequest);
assertThat(exists).isFalse();
PutTemplateRequest putTemplateRequest = PutTemplateRequest.builder(templateName, "log-*") //
@ -379,10 +384,10 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.withVersion(42) //
.build();
boolean acknowledged = indexOperations.putTemplate(putTemplateRequest).block();
boolean acknowledged = blockingIndexOperations.putTemplate(putTemplateRequest);
assertThat(acknowledged).isTrue();
exists = indexOperations.existsTemplate(existsTemplateRequest).block();
exists = blockingIndexOperations.existsTemplate(existsTemplateRequest);
assertThat(exists).isTrue();
}
@ -397,16 +402,16 @@ public abstract class ReactiveIndexTemplateIntegrationTests {
.withVersion(42) //
.build();
boolean acknowledged = indexOperations.putTemplate(putTemplateRequest).block();
boolean acknowledged = blockingIndexOperations.putTemplate(putTemplateRequest);
assertThat(acknowledged).isTrue();
boolean exists = indexOperations.existsTemplate(existsTemplateRequest).block();
boolean exists = blockingIndexOperations.existsTemplate(existsTemplateRequest);
assertThat(exists).isTrue();
acknowledged = indexOperations.deleteTemplate(new DeleteTemplateRequest(templateName)).block();
acknowledged = blockingIndexOperations.deleteTemplate(new DeleteTemplateRequest(templateName));
assertThat(acknowledged).isTrue();
exists = indexOperations.existsTemplate(existsTemplateRequest).block();
exists = blockingIndexOperations.existsTemplate(existsTemplateRequest);
assertThat(exists).isFalse();
}

11
src/test/java/org/springframework/data/elasticsearch/core/mapping/ReactiveFieldNamingStrategyIntegrationTests.java
View File

@ -15,6 +15,8 @@
*/
package org.springframework.data.elasticsearch.core.mapping;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.test.StepVerifier;
import org.junit.jupiter.api.BeforeEach;
@ -27,7 +29,6 @@ import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ReactiveIndexOperations;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexNameProvider;
@ -45,15 +46,15 @@ public abstract class ReactiveFieldNamingStrategyIntegrationTests {
@BeforeEach
void setUp() {
indexNameProvider.increment();
ReactiveIndexOperations indexOps = this.operations.indexOps(Entity.class);
indexOps.delete() //
.then(indexOps.createWithMapping()).block();
var indexOps = blocking(operations.indexOps(Entity.class));
indexOps.delete();
indexOps.createWithMapping();
}
@Test
@Order(java.lang.Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // #1565

5
src/test/java/org/springframework/data/elasticsearch/core/paginating/ReactiveSearchAfterIntegrationTests.java
View File

@ -16,6 +16,7 @@
package org.springframework.data.elasticsearch.core.paginating;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.core.publisher.Mono;
@ -57,13 +58,13 @@ public abstract class ReactiveSearchAfterIntegrationTests {
public void beforeEach() {
indexNameProvider.increment();
operations.indexOps(Entity.class).createWithMapping().block();
blocking(operations.indexOps(Entity.class)).createWithMapping();
}
@Test
@Order(java.lang.Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // #1143

9
src/test/java/org/springframework/data/elasticsearch/core/query/scriptedandruntimefields/ReactiveScriptedAndRuntimeFieldsIntegrationTests.java
View File

@ -16,6 +16,7 @@
package org.springframework.data.elasticsearch.core.query.scriptedandruntimefields;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import reactor.core.publisher.Flux;
@ -66,15 +67,15 @@ public abstract class ReactiveScriptedAndRuntimeFieldsIntegrationTests {
void setUp() {
indexNameProvider.increment();
operations.indexOps(SomethingToBuy.class).createWithMapping().block();
operations.indexOps(Person.class).createWithMapping().block();
operations.indexOps(SAREntity.class).createWithMapping().block();
blocking(operations.indexOps(SomethingToBuy.class)).createWithMapping();
blocking(operations.indexOps(Person.class)).createWithMapping();
blocking(operations.indexOps(SAREntity.class)).createWithMapping();
}
@Test
@Order(Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*')).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // #1971

9
src/test/java/org/springframework/data/elasticsearch/repository/support/SimpleReactiveElasticsearchRepositoryIntegrationTests.java
View File

@ -16,6 +16,7 @@
package org.springframework.data.elasticsearch.repository.support;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import static org.springframework.data.elasticsearch.core.query.Query.*;
import static org.springframework.data.elasticsearch.utils.IdGenerator.*;
@ -75,13 +76,13 @@ abstract class SimpleReactiveElasticsearchRepositoryIntegrationTests {
@BeforeEach
void before() {
indexNameProvider.increment();
operations.indexOps(SampleEntity.class).createWithMapping().block();
blocking(operations.indexOps(SampleEntity.class)).createWithMapping();
}
@Test
@org.junit.jupiter.api.Order(Integer.MAX_VALUE)
public void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test // DATAES-519
@ -114,7 +115,7 @@ abstract class SimpleReactiveElasticsearchRepositoryIntegrationTests {
@Test // DATAES-519, DATAES-767, DATAES-822
void findByIdShouldErrorIfIndexDoesNotExist() {
operations.indexOps(SampleEntity.class).delete().block();
blocking(operations.indexOps(SampleEntity.class)).delete();
repository.findById("id-two") //
.as(StepVerifier::create) //
.expectError(NoSuchIndexException.class) //
@ -272,7 +273,7 @@ abstract class SimpleReactiveElasticsearchRepositoryIntegrationTests {
@Test // DATAES-519, DATAES-767, DATAES-822
void countShouldErrorWhenIndexDoesNotExist() {
operations.indexOps(SampleEntity.class).delete().block();
blocking(operations.indexOps(SampleEntity.class)).delete();
repository.count() //
.as(StepVerifier::create) //
.expectError(NoSuchIndexException.class) //

3
src/test/java/org/springframework/data/elasticsearch/repository/support/querybyexample/ReactiveQueryByExampleElasticsearchExecutorIntegrationTests.java
View File

@ -16,6 +16,7 @@
package org.springframework.data.elasticsearch.repository.support.querybyexample;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.elasticsearch.core.IndexOperationsAdapter.*;
import static org.springframework.data.elasticsearch.utils.IdGenerator.*;
import reactor.test.StepVerifier;
@ -66,7 +67,7 @@ abstract class ReactiveQueryByExampleElasticsearchExecutorIntegrationTests {
@Test // #2418
@Order(Integer.MAX_VALUE)
void cleanup() {
operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + "*")).delete().block();
blocking(operations.indexOps(IndexCoordinates.of(indexNameProvider.getPrefix() + '*'))).delete();
}
@Test