diff --git a/src/main/asciidoc/reference/elasticsearch-auditing.adoc b/src/main/asciidoc/reference/elasticsearch-auditing.adoc index 63726588e..f465e4e74 100644 --- a/src/main/asciidoc/reference/elasticsearch-auditing.adoc +++ b/src/main/asciidoc/reference/elasticsearch-auditing.adoc @@ -3,7 +3,7 @@ === Preparing entities -In order for the auditing code to be able to decide wether an entity instance is new, the entity must implement the `Persistable` interface which is defined as follows: +In order for the auditing code to be able to decide whether an entity instance is new, the entity must implement the `Persistable` interface which is defined as follows: [source,java] ---- @@ -52,7 +52,7 @@ public class Person implements Persistable { === Activating auditing -After the entities have been set up and providing the `AuditorAware` the Auditing must be activated by setting the `@EnableElasticsearchAuditing` on a configuration class: +After the entities have been set up and providing the `AuditorAware` - or `ReactiveAuditorAware` - the Auditing must be activated by setting the `@EnableElasticsearchAuditing` on a configuration class: [source,java] ---- @@ -64,5 +64,16 @@ class MyConfiguration { } ---- +When using the reactive stack this must be: +[source,java] +---- +@Configuration +@EnableReactiveElasticsearchRepositories +@EnableReactiveElasticsearchAuditing +class MyConfiguration { + // configuration code +} +---- + If your code contains more than one `AuditorAware` bean for different types, you must provide the name of the bean to use as an argument to the `auditorAwareRef` parameter of the `@EnableElasticsearchAuditing` annotation. diff --git a/src/main/java/org/springframework/data/elasticsearch/config/ElasticsearchAuditingRegistrar.java b/src/main/java/org/springframework/data/elasticsearch/config/ElasticsearchAuditingRegistrar.java index 1b9b765f2..a52dbc193 100644 --- a/src/main/java/org/springframework/data/elasticsearch/config/ElasticsearchAuditingRegistrar.java +++ b/src/main/java/org/springframework/data/elasticsearch/config/ElasticsearchAuditingRegistrar.java @@ -17,24 +17,16 @@ package org.springframework.data.elasticsearch.config; import java.lang.annotation.Annotation; -import org.springframework.beans.factory.FactoryBean; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.AbstractBeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; import org.springframework.context.annotation.ImportBeanDefinitionRegistrar; -import org.springframework.core.type.AnnotationMetadata; import org.springframework.data.auditing.IsNewAwareAuditingHandler; import org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport; import org.springframework.data.auditing.config.AuditingConfiguration; import org.springframework.data.config.ParsingUtils; -import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter; import org.springframework.data.elasticsearch.core.event.AuditingEntityCallback; -import org.springframework.data.elasticsearch.core.event.ReactiveAuditingEntityCallback; -import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity; -import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentProperty; -import org.springframework.data.mapping.context.MappingContext; -import org.springframework.data.repository.util.ReactiveWrappers; import org.springframework.util.Assert; /** @@ -45,41 +37,16 @@ import org.springframework.util.Assert; */ class ElasticsearchAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport { - /* - * (non-Javadoc) - * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAnnotation() - */ @Override protected Class getAnnotation() { return EnableElasticsearchAuditing.class; } - /* - * (non-Javadoc) - * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditingHandlerBeanName() - */ @Override protected String getAuditingHandlerBeanName() { return "elasticsearchAuditingHandler"; } - /* - * (non-Javadoc) - * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#registerBeanDefinitions(org.springframework.core.type.AnnotationMetadata, org.springframework.beans.factory.support.BeanDefinitionRegistry) - */ - @Override - public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) { - - Assert.notNull(annotationMetadata, "AnnotationMetadata must not be null!"); - Assert.notNull(registry, "BeanDefinitionRegistry must not be null!"); - - super.registerBeanDefinitions(annotationMetadata, registry); - } - - /* - * (non-Javadoc) - * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditHandlerBeanDefinitionBuilder(org.springframework.data.auditing.config.AuditingConfiguration) - */ @Override protected BeanDefinitionBuilder getAuditHandlerBeanDefinitionBuilder(AuditingConfiguration configuration) { @@ -87,18 +54,13 @@ class ElasticsearchAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupp BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(IsNewAwareAuditingHandler.class); - BeanDefinitionBuilder definition = BeanDefinitionBuilder - .genericBeanDefinition(ElasticsearchMappingContextLookup.class); + BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(PersistentEntitiesFactoryBean.class); definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR); builder.addConstructorArgValue(definition.getBeanDefinition()); return configureDefaultAuditHandlerAttributes(configuration, builder); } - /* - * (non-Javadoc) - * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#registerAuditListener(org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.support.BeanDefinitionRegistry) - */ @Override protected void registerAuditListenerBeanDefinition(BeanDefinition auditingHandlerDefinition, BeanDefinitionRegistry registry) { @@ -106,76 +68,9 @@ class ElasticsearchAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupp Assert.notNull(auditingHandlerDefinition, "BeanDefinition must not be null!"); Assert.notNull(registry, "BeanDefinitionRegistry must not be null!"); - BeanDefinitionBuilder listenerBeanDefinitionBuilder = BeanDefinitionBuilder - .rootBeanDefinition(AuditingEntityCallback.class); - listenerBeanDefinitionBuilder - .addConstructorArgValue(ParsingUtils.getObjectFactoryBeanDefinition(getAuditingHandlerBeanName(), registry)); - - registerInfrastructureBeanWithId(listenerBeanDefinitionBuilder.getBeanDefinition(), - AuditingEntityCallback.class.getName(), registry); - - if (ReactiveWrappers.isAvailable(ReactiveWrappers.ReactiveLibrary.PROJECT_REACTOR)) { - registerReactiveAuditingEntityCallback(registry, auditingHandlerDefinition.getSource()); - } - } - - private void registerReactiveAuditingEntityCallback(BeanDefinitionRegistry registry, Object source) { - - BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(ReactiveAuditingEntityCallback.class); - + BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(AuditingEntityCallback.class); builder.addConstructorArgValue(ParsingUtils.getObjectFactoryBeanDefinition(getAuditingHandlerBeanName(), registry)); - builder.getRawBeanDefinition().setSource(source); - registerInfrastructureBeanWithId(builder.getBeanDefinition(), ReactiveAuditingEntityCallback.class.getName(), - registry); - } - - /** - * Simple helper to be able to wire the {@link MappingContext} from a {@link MappingElasticsearchConverter} bean - * available in the application context. - * - * @author Oliver Gierke - */ - static class ElasticsearchMappingContextLookup implements - FactoryBean, ElasticsearchPersistentProperty>> { - - private final MappingElasticsearchConverter converter; - - /** - * Creates a new {@link ElasticsearchMappingContextLookup} for the given {@link MappingElasticsearchConverter}. - * - * @param converter must not be {@literal null}. - */ - public ElasticsearchMappingContextLookup(MappingElasticsearchConverter converter) { - this.converter = converter; - } - - /* - * (non-Javadoc) - * @see org.springframework.beans.factory.FactoryBean#getObject() - */ - @Override - public MappingContext, ElasticsearchPersistentProperty> getObject() - throws Exception { - return converter.getMappingContext(); - } - - /* - * (non-Javadoc) - * @see org.springframework.beans.factory.FactoryBean#getObjectType() - */ - @Override - public Class getObjectType() { - return MappingContext.class; - } - - /* - * (non-Javadoc) - * @see org.springframework.beans.factory.FactoryBean#isSingleton() - */ - @Override - public boolean isSingleton() { - return true; - } + registerInfrastructureBeanWithId(builder.getBeanDefinition(), AuditingEntityCallback.class.getName(), registry); } } diff --git a/src/main/java/org/springframework/data/elasticsearch/config/EnableReactiveElasticsearchAuditing.java b/src/main/java/org/springframework/data/elasticsearch/config/EnableReactiveElasticsearchAuditing.java new file mode 100644 index 000000000..4420ed105 --- /dev/null +++ b/src/main/java/org/springframework/data/elasticsearch/config/EnableReactiveElasticsearchAuditing.java @@ -0,0 +1,70 @@ +/* + * Copyright 2020 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.config; + +import java.lang.annotation.Documented; +import java.lang.annotation.ElementType; +import java.lang.annotation.Inherited; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +import org.springframework.context.annotation.Import; +import org.springframework.data.auditing.DateTimeProvider; +import org.springframework.data.domain.AuditorAware; + +/** + * Annotation to enable auditing in Elasticsearch using reactive infrastructure via annotation configuration. + * + * @author Peter-Josef Meisch + * @since 4.1 + */ +@Inherited +@Documented +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@Import(ReactiveElasticsearchAuditingRegistrar.class) +public @interface EnableReactiveElasticsearchAuditing { + + /** + * Configures the {@link AuditorAware} bean to be used to lookup the current principal. + * + * @return + */ + String auditorAwareRef() default ""; + + /** + * Configures whether the creation and modification dates are set. Defaults to {@literal true}. + * + * @return + */ + boolean setDates() default true; + + /** + * Configures whether the entity shall be marked as modified on creation. Defaults to {@literal true}. + * + * @return + */ + boolean modifyOnCreate() default true; + + /** + * Configures a {@link DateTimeProvider} bean name that allows customizing the {@link org.joda.time.DateTime} to be + * used for setting creation and modification dates. + * + * @return + */ + String dateTimeProviderRef() default ""; +} diff --git a/src/main/java/org/springframework/data/elasticsearch/config/PersistentEntitiesFactoryBean.java b/src/main/java/org/springframework/data/elasticsearch/config/PersistentEntitiesFactoryBean.java new file mode 100644 index 000000000..17ad8c333 --- /dev/null +++ b/src/main/java/org/springframework/data/elasticsearch/config/PersistentEntitiesFactoryBean.java @@ -0,0 +1,54 @@ +/* + * Copyright 2020 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.config; + +import org.springframework.beans.factory.FactoryBean; +import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter; +import org.springframework.data.mapping.context.PersistentEntities; + +/** + * Simple helper to be able to wire the {@link PersistentEntities} from a {@link MappingElasticsearchConverter} bean + * available in the application context. + * + * @author Oliver Gierke + * @author Mark Paluch + * @author Christoph Strobl + * @author Peter-Josef Meisch + * @since 4.1 + */ +class PersistentEntitiesFactoryBean implements FactoryBean { + + private final MappingElasticsearchConverter converter; + + /** + * Creates a new {@link PersistentEntitiesFactoryBean} for the given {@link MappingElasticsearchConverter}. + * + * @param converter must not be {@literal null}. + */ + public PersistentEntitiesFactoryBean(MappingElasticsearchConverter converter) { + this.converter = converter; + } + + @Override + public PersistentEntities getObject() { + return PersistentEntities.of(converter.getMappingContext()); + } + + @Override + public Class getObjectType() { + return PersistentEntities.class; + } +} diff --git a/src/main/java/org/springframework/data/elasticsearch/config/ReactiveElasticsearchAuditingRegistrar.java b/src/main/java/org/springframework/data/elasticsearch/config/ReactiveElasticsearchAuditingRegistrar.java new file mode 100644 index 000000000..e74bcf1a2 --- /dev/null +++ b/src/main/java/org/springframework/data/elasticsearch/config/ReactiveElasticsearchAuditingRegistrar.java @@ -0,0 +1,77 @@ +/* + * Copyright 2020 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.config; + +import java.lang.annotation.Annotation; + +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.beans.factory.support.AbstractBeanDefinition; +import org.springframework.beans.factory.support.BeanDefinitionBuilder; +import org.springframework.beans.factory.support.BeanDefinitionRegistry; +import org.springframework.context.annotation.ImportBeanDefinitionRegistrar; +import org.springframework.data.auditing.ReactiveIsNewAwareAuditingHandler; +import org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport; +import org.springframework.data.auditing.config.AuditingConfiguration; +import org.springframework.data.config.ParsingUtils; +import org.springframework.data.elasticsearch.core.event.ReactiveAuditingEntityCallback; +import org.springframework.util.Assert; + +/** + * {@link ImportBeanDefinitionRegistrar} to enable {@link EnableReactiveElasticsearchAuditing} annotation. + * + * @author Peter-Josef Meisch + * @since 4.1 + */ +class ReactiveElasticsearchAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport { + + @Override + protected Class getAnnotation() { + return EnableReactiveElasticsearchAuditing.class; + } + + @Override + protected String getAuditingHandlerBeanName() { + return "reactiveElasticsearchAuditingHandler"; + } + + @Override + protected BeanDefinitionBuilder getAuditHandlerBeanDefinitionBuilder(AuditingConfiguration configuration) { + + Assert.notNull(configuration, "AuditingConfiguration must not be null!"); + + BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(ReactiveIsNewAwareAuditingHandler.class); + + BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(PersistentEntitiesFactoryBean.class); + definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR); + + builder.addConstructorArgValue(definition.getBeanDefinition()); + return configureDefaultAuditHandlerAttributes(configuration, builder); + } + + @Override + protected void registerAuditListenerBeanDefinition(BeanDefinition auditingHandlerDefinition, + BeanDefinitionRegistry registry) { + + Assert.notNull(auditingHandlerDefinition, "BeanDefinition must not be null!"); + Assert.notNull(registry, "BeanDefinitionRegistry must not be null!"); + + BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(ReactiveAuditingEntityCallback.class); + builder.addConstructorArgValue(ParsingUtils.getObjectFactoryBeanDefinition(getAuditingHandlerBeanName(), registry)); + + registerInfrastructureBeanWithId(builder.getBeanDefinition(), ReactiveAuditingEntityCallback.class.getName(), + registry); + } +} diff --git a/src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallback.java b/src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallback.java index 69a803684..213d02f24 100644 --- a/src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallback.java +++ b/src/main/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallback.java @@ -19,7 +19,7 @@ import reactor.core.publisher.Mono; import org.springframework.beans.factory.ObjectFactory; import org.springframework.core.Ordered; -import org.springframework.data.auditing.IsNewAwareAuditingHandler; +import org.springframework.data.auditing.ReactiveIsNewAwareAuditingHandler; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.mapping.callback.EntityCallback; import org.springframework.util.Assert; @@ -33,15 +33,15 @@ import org.springframework.util.Assert; */ public class ReactiveAuditingEntityCallback implements ReactiveBeforeConvertCallback, Ordered { - private final ObjectFactory auditingHandlerFactory; + private final ObjectFactory auditingHandlerFactory; /** - * Creates a new {@link ReactiveAuditingEntityCallback} using the given {@link IsNewAwareAuditingHandler} provided by - * the given {@link ObjectFactory}. + * Creates a new {@link ReactiveAuditingEntityCallback} using the given {@link ReactiveIsNewAwareAuditingHandler} + * provided by the given {@link ObjectFactory}. * * @param auditingHandlerFactory must not be {@literal null}. */ - public ReactiveAuditingEntityCallback(ObjectFactory auditingHandlerFactory) { + public ReactiveAuditingEntityCallback(ObjectFactory auditingHandlerFactory) { Assert.notNull(auditingHandlerFactory, "IsNewAwareAuditingHandler must not be null!"); @@ -50,7 +50,7 @@ public class ReactiveAuditingEntityCallback implements ReactiveBeforeConvertCall @Override public Mono onBeforeConvert(Object entity, IndexCoordinates index) { - return Mono.just(auditingHandlerFactory.getObject().markAudited(entity)); + return auditingHandlerFactory.getObject().markAudited(entity); } @Override diff --git a/src/test/java/org/springframework/data/elasticsearch/config/ReactiveAuditingIntegrationTest.java b/src/test/java/org/springframework/data/elasticsearch/config/ReactiveAuditingIntegrationTest.java index 29436c001..4a83ffc07 100644 --- a/src/test/java/org/springframework/data/elasticsearch/config/ReactiveAuditingIntegrationTest.java +++ b/src/test/java/org/springframework/data/elasticsearch/config/ReactiveAuditingIntegrationTest.java @@ -17,8 +17,9 @@ package org.springframework.data.elasticsearch.config; import static org.assertj.core.api.Assertions.*; +import reactor.core.publisher.Mono; + import java.time.LocalDateTime; -import java.util.Optional; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; @@ -30,8 +31,8 @@ import org.springframework.data.annotation.CreatedDate; import org.springframework.data.annotation.Id; import org.springframework.data.annotation.LastModifiedBy; import org.springframework.data.annotation.LastModifiedDate; -import org.springframework.data.domain.AuditorAware; import org.springframework.data.domain.Persistable; +import org.springframework.data.domain.ReactiveAuditorAware; import org.springframework.data.elasticsearch.core.event.ReactiveBeforeConvertCallback; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext; @@ -49,23 +50,23 @@ import org.springframework.test.context.ContextConfiguration; @ContextConfiguration(classes = { ReactiveAuditingIntegrationTest.Config.class }) public class ReactiveAuditingIntegrationTest { - public static AuditorAware auditorProvider() { - return new AuditorAware() { + public static ReactiveAuditorAware auditorProvider() { + return new ReactiveAuditorAware() { int count = 0; @Override - public Optional getCurrentAuditor() { - return Optional.of("Auditor " + (++count)); + public Mono getCurrentAuditor() { + return Mono.just("Auditor " + (++count)); } }; } @Import({ ReactiveElasticsearchRestTemplateConfiguration.class }) - @EnableElasticsearchAuditing(auditorAwareRef = "auditorAware") + @EnableReactiveElasticsearchAuditing(auditorAwareRef = "auditorAware") static class Config { @Bean - public AuditorAware auditorAware() { + public ReactiveAuditorAware auditorAware() { return auditorProvider(); } } diff --git a/src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallbackTests.java b/src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallbackTests.java index 364b2b9af..a6e43416f 100644 --- a/src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallbackTests.java +++ b/src/test/java/org/springframework/data/elasticsearch/core/event/ReactiveAuditingEntityCallbackTests.java @@ -18,6 +18,7 @@ package org.springframework.data.elasticsearch.core.event; import static org.assertj.core.api.Assertions.*; import static org.mockito.Mockito.*; +import reactor.core.publisher.Mono; import reactor.test.StepVerifier; import java.time.LocalDateTime; @@ -31,7 +32,7 @@ import org.springframework.data.annotation.CreatedBy; import org.springframework.data.annotation.CreatedDate; import org.springframework.data.annotation.Id; import org.springframework.data.annotation.LastModifiedDate; -import org.springframework.data.auditing.IsNewAwareAuditingHandler; +import org.springframework.data.auditing.ReactiveIsNewAwareAuditingHandler; import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates; import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext; import org.springframework.data.mapping.context.PersistentEntities; @@ -44,14 +45,14 @@ import org.springframework.lang.Nullable; @ExtendWith(MockitoExtension.class) class ReactiveAuditingEntityCallbackTests { - IsNewAwareAuditingHandler handler; + ReactiveIsNewAwareAuditingHandler handler; ReactiveAuditingEntityCallback callback; @BeforeEach void setUp() { SimpleElasticsearchMappingContext context = new SimpleElasticsearchMappingContext(); context.getPersistentEntity(Sample.class); - handler = spy(new IsNewAwareAuditingHandler(PersistentEntities.of(context))); + handler = spy(new ReactiveIsNewAwareAuditingHandler(PersistentEntities.of(context))); callback = new ReactiveAuditingEntityCallback(() -> handler); } @@ -81,13 +82,10 @@ class ReactiveAuditingEntityCallbackTests { sample1.setId("1"); Sample sample2 = new Sample(); sample2.setId("2"); - doReturn(sample2).when(handler).markAudited(any()); + doReturn(Mono.just(sample2)).when(handler).markAudited(any()); callback.onBeforeConvert(sample1, IndexCoordinates.of("index")) // - .as(StepVerifier::create) // - .consumeNextWith(it -> { // - assertThat(it).isSameAs(sample2); // - }).verifyComplete(); + .as(StepVerifier::create).expectNext(sample2).verifyComplete(); } static class Sample { diff --git a/src/test/java/org/springframework/data/elasticsearch/junit/jupiter/ClusterConnection.java b/src/test/java/org/springframework/data/elasticsearch/junit/jupiter/ClusterConnection.java index 825636d00..eb5d624b6 100644 --- a/src/test/java/org/springframework/data/elasticsearch/junit/jupiter/ClusterConnection.java +++ b/src/test/java/org/springframework/data/elasticsearch/junit/jupiter/ClusterConnection.java @@ -30,9 +30,9 @@ import org.springframework.util.StringUtils; /** * This class manages the connection to an Elasticsearch Cluster, starting a local one if necessary. The information - * about the ClusterConnection is stored botha s a varaible in the instance for direct aaces from JUnit 5 and in a - * static ThreadLocal acessible with the {@link ClusterConnection#clusterConnectionInfo()} method - * to be integrated in the Spring setup + * about the ClusterConnection is stored both as a variable in the instance for direct access from JUnit 5 and in a + * static ThreadLocal accessible with the {@link ClusterConnection#clusterConnectionInfo()} + * method to be integrated in the Spring setup * * @author Peter-Josef Meisch */