From 77f6582aeea7e43676981fddc26649fc949e17f7 Mon Sep 17 00:00:00 2001 From: Oliver Drotbohm Date: Thu, 14 Mar 2019 14:19:54 +0100 Subject: [PATCH] DATAREDIS-944 - Move off deprecations in Spring Data Commons. Related ticket: DATACMNS-1496. --- .../connection/ReactiveStringCommands.java | 3 +- ...RedisRepositoryConfigurationExtension.java | 206 +++++++----------- .../LettuceReactiveZSetCommandsTests.java | 85 ++++---- ...eactiveZSetOperationsIntegrationTests.java | 75 ++++--- 4 files changed, 164 insertions(+), 205 deletions(-) diff --git a/src/main/java/org/springframework/data/redis/connection/ReactiveStringCommands.java b/src/main/java/org/springframework/data/redis/connection/ReactiveStringCommands.java index b79f9b0d6..9f7a21c33 100644 --- a/src/main/java/org/springframework/data/redis/connection/ReactiveStringCommands.java +++ b/src/main/java/org/springframework/data/redis/connection/ReactiveStringCommands.java @@ -888,7 +888,8 @@ public interface ReactiveStringCommands { Assert.notNull(key, "Key must not be null!"); - return bitCount(Mono.just(BitCountCommand.bitCount(key).within(new Range<>(start, end)))).next() + return bitCount(Mono.just(BitCountCommand.bitCount(key).within(Range.open(start, end)))) // + .next() // .map(NumericResponse::getOutput); } diff --git a/src/main/java/org/springframework/data/redis/repository/configuration/RedisRepositoryConfigurationExtension.java b/src/main/java/org/springframework/data/redis/repository/configuration/RedisRepositoryConfigurationExtension.java index f48c68299..8067fea35 100644 --- a/src/main/java/org/springframework/data/redis/repository/configuration/RedisRepositoryConfigurationExtension.java +++ b/src/main/java/org/springframework/data/redis/repository/configuration/RedisRepositoryConfigurationExtension.java @@ -19,19 +19,15 @@ import java.lang.annotation.Annotation; import java.util.Collection; import java.util.Collections; -import org.springframework.beans.DirectFieldAccessor; -import org.springframework.beans.MutablePropertyValues; import org.springframework.beans.factory.config.BeanDefinition; -import org.springframework.beans.factory.config.ConstructorArgumentValues; -import org.springframework.beans.factory.config.RuntimeBeanReference; import org.springframework.beans.factory.support.AbstractBeanDefinition; +import org.springframework.beans.factory.support.BeanDefinitionBuilder; import org.springframework.beans.factory.support.BeanDefinitionRegistry; -import org.springframework.beans.factory.support.GenericBeanDefinition; import org.springframework.beans.factory.support.RootBeanDefinition; -import org.springframework.core.annotation.AnnotationAttributes; import org.springframework.data.keyvalue.repository.config.KeyValueRepositoryConfigurationExtension; import org.springframework.data.redis.core.RedisHash; import org.springframework.data.redis.core.RedisKeyValueAdapter; +import org.springframework.data.redis.core.RedisKeyValueAdapter.EnableKeyspaceEvents; import org.springframework.data.redis.core.RedisKeyValueTemplate; import org.springframework.data.redis.core.convert.MappingConfiguration; import org.springframework.data.redis.core.convert.MappingRedisConverter; @@ -82,107 +78,39 @@ public class RedisRepositoryConfigurationExtension extends KeyValueRepositoryCon return "redisKeyValueTemplate"; } + /* + * (non-Javadoc) + * @see org.springframework.data.keyvalue.repository.config.KeyValueRepositoryConfigurationExtension#registerBeansForRoot(org.springframework.beans.factory.support.BeanDefinitionRegistry, org.springframework.data.repository.config.RepositoryConfigurationSource) + */ @Override - public void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource) { + public void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configuration) { - String redisTemplateRef = configurationSource.getAttribute("redisTemplateRef").get(); + String redisTemplateRef = configuration.getAttribute("redisTemplateRef").get(); - RootBeanDefinition mappingContextDefinition = createRedisMappingContext(configurationSource); - mappingContextDefinition.setSource(configurationSource.getSource()); - - registerIfNotAlreadyRegistered(mappingContextDefinition, registry, MAPPING_CONTEXT_BEAN_NAME, configurationSource); - - // register coustom conversions - RootBeanDefinition customConversions = new RootBeanDefinition(RedisCustomConversions.class); - registerIfNotAlreadyRegistered(customConversions, registry, REDIS_CUSTOM_CONVERSIONS_BEAN_NAME, - configurationSource); - - // Register referenceResolver - RootBeanDefinition redisReferenceResolver = createRedisReferenceResolverDefinition(redisTemplateRef); - redisReferenceResolver.setSource(configurationSource.getSource()); - registerIfNotAlreadyRegistered(redisReferenceResolver, registry, REDIS_REFERENCE_RESOLVER_BEAN_NAME, - configurationSource); - - // Register converter - RootBeanDefinition redisConverterDefinition = createRedisConverterDefinition(); - redisConverterDefinition.setSource(configurationSource.getSource()); - - registerIfNotAlreadyRegistered(redisConverterDefinition, registry, REDIS_CONVERTER_BEAN_NAME, configurationSource); - - // register Adapter - RootBeanDefinition redisKeyValueAdapterDefinition = new RootBeanDefinition(RedisKeyValueAdapter.class); - - ConstructorArgumentValues constructorArgumentValuesForRedisKeyValueAdapter = new ConstructorArgumentValues(); - if (StringUtils.hasText(redisTemplateRef)) { - - constructorArgumentValuesForRedisKeyValueAdapter.addIndexedArgumentValue(0, - new RuntimeBeanReference(redisTemplateRef)); + if (!StringUtils.hasText(redisTemplateRef)) { + throw new IllegalStateException( + "@EnableRedisRepositories(redisTemplateRef = … ) must be configured to a non empty value!"); } - constructorArgumentValuesForRedisKeyValueAdapter.addIndexedArgumentValue(1, - new RuntimeBeanReference(REDIS_CONVERTER_BEAN_NAME)); + registerIfNotAlreadyRegistered(() -> createRedisMappingContext(configuration), registry, MAPPING_CONTEXT_BEAN_NAME, + configuration.getSource()); - redisKeyValueAdapterDefinition.setConstructorArgumentValues(constructorArgumentValuesForRedisKeyValueAdapter); + // Register custom conversions + registerIfNotAlreadyRegistered(() -> new RootBeanDefinition(RedisCustomConversions.class), registry, + REDIS_CUSTOM_CONVERSIONS_BEAN_NAME, configuration.getSource()); - DirectFieldAccessor fieldAccessor = new DirectFieldAccessor(configurationSource); - AnnotationAttributes attributes = (AnnotationAttributes) fieldAccessor.getPropertyValue("attributes"); + // Register referenceResolver + registerIfNotAlreadyRegistered(() -> createRedisReferenceResolverDefinition(redisTemplateRef), registry, + REDIS_REFERENCE_RESOLVER_BEAN_NAME, configuration.getSource()); - MutablePropertyValues redisKeyValueAdapterProps = new MutablePropertyValues(); - redisKeyValueAdapterProps.add("enableKeyspaceEvents", attributes.getEnum("enableKeyspaceEvents")); - redisKeyValueAdapterProps.add("keyspaceNotificationsConfigParameter", - attributes.getString("keyspaceNotificationsConfigParameter")); - redisKeyValueAdapterDefinition.setPropertyValues(redisKeyValueAdapterProps); + // Register converter + registerIfNotAlreadyRegistered(() -> createRedisConverterDefinition(), registry, REDIS_CONVERTER_BEAN_NAME, + configuration.getSource()); - registerIfNotAlreadyRegistered(redisKeyValueAdapterDefinition, registry, REDIS_ADAPTER_BEAN_NAME, - configurationSource); + registerIfNotAlreadyRegistered(() -> createRedisKeyValueAdapter(configuration), registry, REDIS_ADAPTER_BEAN_NAME, + configuration.getSource()); - super.registerBeansForRoot(registry, configurationSource); - } - - private RootBeanDefinition createRedisReferenceResolverDefinition(String redisTemplateRef) { - - RootBeanDefinition beanDef = new RootBeanDefinition(); - beanDef.setBeanClassName("org.springframework.data.redis.core.convert.ReferenceResolverImpl"); - - ConstructorArgumentValues constructorArgs = new ConstructorArgumentValues(); - constructorArgs.addIndexedArgumentValue(0, new RuntimeBeanReference(redisTemplateRef)); - - beanDef.setConstructorArgumentValues(constructorArgs); - - return beanDef; - } - - private RootBeanDefinition createRedisMappingContext(RepositoryConfigurationSource configurationSource) { - - ConstructorArgumentValues mappingContextArgs = new ConstructorArgumentValues(); - mappingContextArgs.addIndexedArgumentValue(0, createMappingConfigBeanDef(configurationSource)); - - RootBeanDefinition mappingContextBeanDef = new RootBeanDefinition(RedisMappingContext.class); - mappingContextBeanDef.setConstructorArgumentValues(mappingContextArgs); - - return mappingContextBeanDef; - } - - private BeanDefinition createMappingConfigBeanDef(RepositoryConfigurationSource configurationSource) { - - DirectFieldAccessor dfa = new DirectFieldAccessor(configurationSource); - AnnotationAttributes aa = (AnnotationAttributes) dfa.getPropertyValue("attributes"); - - GenericBeanDefinition indexConfiguration = new GenericBeanDefinition(); - indexConfiguration.setBeanClass(aa.getClass("indexConfiguration")); - - GenericBeanDefinition keyspaceConfig = new GenericBeanDefinition(); - keyspaceConfig.setBeanClass(aa.getClass("keyspaceConfiguration")); - - ConstructorArgumentValues mappingConfigArgs = new ConstructorArgumentValues(); - mappingConfigArgs.addIndexedArgumentValue(0, indexConfiguration); - mappingConfigArgs.addIndexedArgumentValue(1, keyspaceConfig); - - GenericBeanDefinition mappingConfigBeanDef = new GenericBeanDefinition(); - mappingConfigBeanDef.setBeanClass(MappingConfiguration.class); - mappingConfigBeanDef.setConstructorArgumentValues(mappingConfigArgs); - - return mappingConfigBeanDef; + super.registerBeansForRoot(registry, configuration); } /* @@ -193,34 +121,10 @@ public class RedisRepositoryConfigurationExtension extends KeyValueRepositoryCon protected AbstractBeanDefinition getDefaultKeyValueTemplateBeanDefinition( RepositoryConfigurationSource configurationSource) { - RootBeanDefinition keyValueTemplateDefinition = new RootBeanDefinition(RedisKeyValueTemplate.class); - - ConstructorArgumentValues constructorArgumentValuesForKeyValueTemplate = new ConstructorArgumentValues(); - constructorArgumentValuesForKeyValueTemplate.addIndexedArgumentValue(0, - new RuntimeBeanReference(REDIS_ADAPTER_BEAN_NAME)); - constructorArgumentValuesForKeyValueTemplate.addIndexedArgumentValue(1, - new RuntimeBeanReference(MAPPING_CONTEXT_BEAN_NAME)); - - keyValueTemplateDefinition.setConstructorArgumentValues(constructorArgumentValuesForKeyValueTemplate); - - return keyValueTemplateDefinition; - } - - private RootBeanDefinition createRedisConverterDefinition() { - - RootBeanDefinition beanDef = new RootBeanDefinition(); - beanDef.setBeanClass(MappingRedisConverter.class); - - ConstructorArgumentValues args = new ConstructorArgumentValues(); - args.addIndexedArgumentValue(0, new RuntimeBeanReference(MAPPING_CONTEXT_BEAN_NAME)); - beanDef.setConstructorArgumentValues(args); - - MutablePropertyValues props = new MutablePropertyValues(); - props.add("referenceResolver", new RuntimeBeanReference(REDIS_REFERENCE_RESOLVER_BEAN_NAME)); - props.add("customConversions", new RuntimeBeanReference(REDIS_CUSTOM_CONVERSIONS_BEAN_NAME)); - beanDef.setPropertyValues(props); - - return beanDef; + return BeanDefinitionBuilder.rootBeanDefinition(RedisKeyValueTemplate.class) // + .addConstructorArgReference(REDIS_ADAPTER_BEAN_NAME) // + .addConstructorArgReference(MAPPING_CONTEXT_BEAN_NAME) // + .getBeanDefinition(); } /* @@ -229,7 +133,57 @@ public class RedisRepositoryConfigurationExtension extends KeyValueRepositoryCon */ @Override protected Collection> getIdentifyingAnnotations() { - return Collections.> singleton(RedisHash.class); + return Collections.singleton(RedisHash.class); } + private static AbstractBeanDefinition createRedisKeyValueAdapter(RepositoryConfigurationSource configuration) { + + return BeanDefinitionBuilder.rootBeanDefinition(RedisKeyValueAdapter.class) // + .addConstructorArgReference(configuration.getRequiredAttribute("redisTemplateRef", String.class)) // + .addConstructorArgReference(REDIS_CONVERTER_BEAN_NAME) // + .addPropertyValue("enableKeyspaceEvents", + configuration.getRequiredAttribute("enableKeyspaceEvents", EnableKeyspaceEvents.class)) // + .addPropertyValue("keyspaceNotificationsConfigParameter", + configuration.getRequiredAttribute("keyspaceNotificationsConfigParameter", String.class)) // + .getBeanDefinition(); + } + + private static AbstractBeanDefinition createRedisReferenceResolverDefinition(String redisTemplateRef) { + + return BeanDefinitionBuilder.rootBeanDefinition("org.springframework.data.redis.core.convert.ReferenceResolverImpl") // + .addConstructorArgReference(redisTemplateRef) // + .getBeanDefinition(); + } + + private static AbstractBeanDefinition createRedisMappingContext(RepositoryConfigurationSource configurationSource) { + + return BeanDefinitionBuilder.rootBeanDefinition(RedisMappingContext.class) // + .addConstructorArgValue(createMappingConfigBeanDef(configurationSource)) // + .getBeanDefinition(); + } + + private static BeanDefinition createMappingConfigBeanDef(RepositoryConfigurationSource configuration) { + + BeanDefinition indexDefinition = BeanDefinitionBuilder + .genericBeanDefinition(configuration.getRequiredAttribute("indexConfiguration", Class.class)) // + .getBeanDefinition(); + + BeanDefinition keyspaceDefinition = BeanDefinitionBuilder + .genericBeanDefinition(configuration.getRequiredAttribute("keyspaceConfiguration", Class.class)) // + .getBeanDefinition(); + + return BeanDefinitionBuilder.genericBeanDefinition(MappingConfiguration.class) // + .addConstructorArgValue(indexDefinition) // + .addConstructorArgValue(keyspaceDefinition) // + .getBeanDefinition(); + } + + private static AbstractBeanDefinition createRedisConverterDefinition() { + + return BeanDefinitionBuilder.rootBeanDefinition(MappingRedisConverter.class) // + .addConstructorArgReference(MAPPING_CONTEXT_BEAN_NAME) // + .addPropertyReference("referenceResolver", REDIS_REFERENCE_RESOLVER_BEAN_NAME) // + .addPropertyReference("customConversions", REDIS_CUSTOM_CONVERSIONS_BEAN_NAME) // + .getBeanDefinition(); + } } diff --git a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommandsTests.java b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommandsTests.java index ecc9b5d08..4a24cbba8 100644 --- a/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommandsTests.java +++ b/src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommandsTests.java @@ -18,6 +18,7 @@ package org.springframework.data.redis.connection.lettuce; import static org.hamcrest.core.Is.*; import static org.junit.Assert.*; import static org.junit.Assume.*; +import static org.springframework.data.domain.Range.Bound.*; import reactor.test.StepVerifier; @@ -39,6 +40,12 @@ import org.springframework.data.redis.core.ScanOptions; */ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTestsBase { + private static final Range ONE_TO_TWO = Range.closed(1L, 2L); + + private static final Range TWO_TO_THREE_ALL_INCLUSIVE = Range.closed(2D, 3D); + private static final Range TWO_INCLUSIVE_TO_THREE_EXCLUSIVE = Range.rightOpen(2D, 3D); + private static final Range TWO_EXCLUSIVE_TO_THREE_INCLUSIVE = Range.leftOpen(2D, 3D); + @Test // DATAREDIS-525 public void zAddShouldAddValuesWithScores() { assertThat(connection.zSetCommands().zAdd(KEY_1_BBUFFER, 3.5D, VALUE_1_BBUFFER).block(), is(1L)); @@ -90,7 +97,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRange(KEY_1_BBUFFER, new Range<>(1L, 2L))) // + StepVerifier.create(connection.zSetCommands().zRange(KEY_1_BBUFFER, ONE_TO_TWO)) // .expectNext(VALUE_2_BBUFFER, VALUE_3_BBUFFER) // .verifyComplete(); } @@ -102,7 +109,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRangeWithScores(KEY_1_BBUFFER, new Range<>(1L, 2L))) // + StepVerifier.create(connection.zSetCommands().zRangeWithScores(KEY_1_BBUFFER, ONE_TO_TWO)) // .expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D), new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) // .verifyComplete(); } @@ -114,7 +121,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRevRange(KEY_1_BBUFFER, new Range<>(1L, 2L))) // + StepVerifier.create(connection.zSetCommands().zRevRange(KEY_1_BBUFFER, ONE_TO_TWO)) // .expectNext(VALUE_2_BBUFFER, VALUE_1_BBUFFER) // .verifyComplete(); } @@ -126,7 +133,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRevRangeWithScores(KEY_1_BBUFFER, new Range<>(1L, 2L))) // + StepVerifier.create(connection.zSetCommands().zRevRangeWithScores(KEY_1_BBUFFER, ONE_TO_TWO)) // .expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D), new DefaultTuple(VALUE_1_BBUFFER.array(), 1D)) // .verifyComplete(); } @@ -138,7 +145,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D))) // + StepVerifier.create(connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, Range.closed(2D, 3D))) // .expectNext(VALUE_2_BBUFFER, VALUE_3_BBUFFER) // .verifyComplete(); } @@ -178,7 +185,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D, false, true))) // + StepVerifier.create(connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) // .expectNext(VALUE_3_BBUFFER) // .verifyComplete(); } @@ -190,7 +197,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D, true, false))) // + StepVerifier.create(connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) // .expectNext(VALUE_2_BBUFFER) // .verifyComplete(); } @@ -202,7 +209,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, new Range<>(2D, 3D))) // + StepVerifier.create(connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, TWO_TO_THREE_ALL_INCLUSIVE)) // .expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D), new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) // .verifyComplete(); } @@ -215,7 +222,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 3D, VALUE_3); StepVerifier - .create(connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, new Range<>(2D, 3D, false, true))) // + .create(connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) // .expectNext(new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) // .verifyComplete(); } @@ -228,7 +235,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 3D, VALUE_3); StepVerifier - .create(connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, new Range<>(2D, 3D, true, false))) // + .create(connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) // .expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D)) // .verifyComplete(); } @@ -240,7 +247,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D))) // + StepVerifier.create(connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, TWO_TO_THREE_ALL_INCLUSIVE)) // .expectNext(VALUE_3_BBUFFER, VALUE_2_BBUFFER) // .verifyComplete(); } @@ -252,7 +259,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D, false, true))) // + StepVerifier.create(connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) // .expectNext(VALUE_3_BBUFFER) // .verifyComplete(); } @@ -264,7 +271,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D, true, false))) // + StepVerifier.create(connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) // .expectNext(VALUE_2_BBUFFER) // .verifyComplete(); } @@ -276,7 +283,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - StepVerifier.create(connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, new Range<>(2D, 3D))) // + StepVerifier.create(connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, TWO_TO_THREE_ALL_INCLUSIVE)) // .expectNext(new DefaultTuple(VALUE_3_BBUFFER.array(), 3D), new DefaultTuple(VALUE_2_BBUFFER.array(), 2D)) // .verifyComplete(); } @@ -289,7 +296,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 3D, VALUE_3); StepVerifier - .create(connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, new Range<>(2D, 3D, false, true))) // + .create(connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) // .expectNext(new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) // .verifyComplete(); } @@ -302,7 +309,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 3D, VALUE_3); StepVerifier - .create(connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, new Range<>(2D, 3D, true, false))) // + .create(connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) // .expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D)) // .verifyComplete(); } @@ -330,7 +337,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, new Range<>(2D, 3D)).block(), is(2L)); + assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, TWO_TO_THREE_ALL_INCLUSIVE).block(), is(2L)); } @Test // DATAREDIS-525 @@ -340,7 +347,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, new Range<>(2D, 3D, false, true)).block(), is(1L)); + assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE).block(), is(1L)); } @Test // DATAREDIS-525 @@ -350,7 +357,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, new Range<>(2D, 3D, true, false)).block(), is(1L)); + assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE).block(), is(1L)); } @Test // DATAREDIS-525 @@ -360,8 +367,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, new Range<>(Double.NEGATIVE_INFINITY, 2D)).block(), - is(2L)); + assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, Range.leftUnbounded(inclusive(2D))).block(), is(2L)); } @Test // DATAREDIS-525 @@ -371,8 +377,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, new Range<>(2D, Double.POSITIVE_INFINITY)).block(), - is(2L)); + assertThat(connection.zSetCommands().zCount(KEY_1_BBUFFER, Range.rightUnbounded(inclusive(2D))).block(), is(2L)); } @Test // DATAREDIS-525 @@ -400,7 +405,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zRemRangeByRank(KEY_1_BBUFFER, new Range<>(1L, 2L)).block(), is(2L)); + assertThat(connection.zSetCommands().zRemRangeByRank(KEY_1_BBUFFER, ONE_TO_TWO).block(), is(2L)); } @Test // DATAREDIS-525 @@ -410,7 +415,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, new Range<>(1D, 2D)).block(), is(2L)); + assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, Range.closed(1D, 2D)).block(), is(2L)); } @Test // DATAREDIS-525 @@ -420,8 +425,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat( - connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, new Range<>(Double.NEGATIVE_INFINITY, 2D)).block(), + assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, Range.leftUnbounded(inclusive(2D))).block(), is(2L)); } @@ -432,8 +436,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat( - connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, new Range<>(2D, Double.POSITIVE_INFINITY)).block(), + assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, Range.rightUnbounded(inclusive(2D))).block(), is(2L)); } @@ -444,7 +447,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D, false, true)).block(), + assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE).block(), is(1L)); } @@ -455,7 +458,7 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 2D, VALUE_2); nativeCommands.zadd(KEY_1, 3D, VALUE_3); - assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, new Range<>(2D, 3D, true, false)).block(), + assertThat(connection.zSetCommands().zRemRangeByScore(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE).block(), is(1L)); } @@ -504,17 +507,16 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 0D, "f"); nativeCommands.zadd(KEY_1, 0D, "g"); - assertThat(connection.zSetCommands().zRangeByLex(KEY_1_BBUFFER, new Range<>("", "c")).collectList().block(), + Range emptyToC = Range.closed("", "c"); + + assertThat(connection.zSetCommands().zRangeByLex(KEY_1_BBUFFER, emptyToC).collectList().block(), IsIterableContainingInOrder.contains(ByteBuffer.wrap("a".getBytes()), ByteBuffer.wrap("b".getBytes()), ByteBuffer.wrap("c".getBytes()))); - assertThat( - connection.zSetCommands().zRangeByLex(KEY_1_BBUFFER, new Range<>("", "c", true, false)).collectList().block(), + assertThat(connection.zSetCommands().zRangeByLex(KEY_1_BBUFFER, Range.rightOpen("", "c")).collectList().block(), IsIterableContainingInOrder.contains(ByteBuffer.wrap("a".getBytes()), ByteBuffer.wrap("b".getBytes()))); - assertThat( - connection.zSetCommands().zRangeByLex(KEY_1_BBUFFER, new Range<>("aaa", "g", true, false)).collectList() - .block(), + assertThat(connection.zSetCommands().zRangeByLex(KEY_1_BBUFFER, Range.rightOpen("aaa", "g")).collectList().block(), IsIterableContainingInOrder.contains(ByteBuffer.wrap("b".getBytes()), ByteBuffer.wrap("c".getBytes()), ByteBuffer.wrap("d".getBytes()), ByteBuffer.wrap("e".getBytes()), ByteBuffer.wrap("f".getBytes()))); } @@ -530,18 +532,15 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes nativeCommands.zadd(KEY_1, 0D, "f"); nativeCommands.zadd(KEY_1, 0D, "g"); - assertThat(connection.zSetCommands().zRevRangeByLex(KEY_1_BBUFFER, new Range<>("", "c")).collectList().block(), + assertThat(connection.zSetCommands().zRevRangeByLex(KEY_1_BBUFFER, Range.closed("", "c")).collectList().block(), IsIterableContainingInOrder.contains(ByteBuffer.wrap("c".getBytes()), ByteBuffer.wrap("b".getBytes()), ByteBuffer.wrap("a".getBytes()))); - assertThat( - connection.zSetCommands().zRevRangeByLex(KEY_1_BBUFFER, new Range<>("", "c", true, false)).collectList() - .block(), + assertThat(connection.zSetCommands().zRevRangeByLex(KEY_1_BBUFFER, Range.rightOpen("", "c")).collectList().block(), IsIterableContainingInOrder.contains(ByteBuffer.wrap("b".getBytes()), ByteBuffer.wrap("a".getBytes()))); assertThat( - connection.zSetCommands().zRevRangeByLex(KEY_1_BBUFFER, new Range<>("aaa", "g", true, false)).collectList() - .block(), + connection.zSetCommands().zRevRangeByLex(KEY_1_BBUFFER, Range.rightOpen("aaa", "g")).collectList().block(), IsIterableContainingInOrder.contains(ByteBuffer.wrap("f".getBytes()), ByteBuffer.wrap("e".getBytes()), ByteBuffer.wrap("d".getBytes()), ByteBuffer.wrap("c".getBytes()), ByteBuffer.wrap("b".getBytes()))); } diff --git a/src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java b/src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java index 5e84f4656..def605f90 100644 --- a/src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java +++ b/src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java @@ -53,6 +53,12 @@ import org.springframework.data.redis.serializer.StringRedisSerializer; @SuppressWarnings("unchecked") public class DefaultReactiveZSetOperationsIntegrationTests { + private static final Range ZERO_RANGE = Range.just(0L); + private static final Range ZERO_TO_FIVE = Range.closed(0L, 5L); + + private static final Range ZERO_TO_HUNDRED_DOUBLE = Range.closed(0d, 100d); + private static final Range NINE_TO_ELEVEN_DOUBLE = Range.closed(9d, 11d); + private final ReactiveRedisTemplate redisTemplate; private final ReactiveZSetOperations zSetOperations; @@ -188,7 +194,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.range(key, new Range<>(0L, 0L))) // + StepVerifier.create(zSetOperations.range(key, ZERO_RANGE)) // .expectNext(value2) // .verifyComplete(); @@ -206,7 +212,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.rangeWithScores(key, new Range<>(0L, 0L))) // + StepVerifier.create(zSetOperations.rangeWithScores(key, ZERO_RANGE)) // .expectNext(new DefaultTypedTuple<>(value2, 10d)) // .verifyComplete(); } @@ -223,7 +229,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.rangeByScore(key, new Range<>(9d, 11d))) // + StepVerifier.create(zSetOperations.rangeByScore(key, NINE_TO_ELEVEN_DOUBLE)) // .expectNext(value2) // .verifyComplete(); } @@ -240,7 +246,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.rangeByScoreWithScores(key, new Range<>(9d, 11d))) // + StepVerifier.create(zSetOperations.rangeByScoreWithScores(key, NINE_TO_ELEVEN_DOUBLE)) // .expectNext(new DefaultTypedTuple<>(value2, 10d)) // .verifyComplete(); } @@ -257,9 +263,8 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier - .create(zSetOperations.rangeByScore(key, new Range<>(0d, 100d), // - Limit.limit().offset(1).count(10))) // + StepVerifier.create(zSetOperations.rangeByScore(key, ZERO_TO_HUNDRED_DOUBLE, // + Limit.limit().offset(1).count(10))) // .expectNext(value1) // .verifyComplete(); } @@ -276,9 +281,8 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier - .create(zSetOperations.rangeByScoreWithScores(key, new Range<>(0d, 100d), // - Limit.limit().offset(1).count(10))) // + StepVerifier.create(zSetOperations.rangeByScoreWithScores(key, ZERO_TO_HUNDRED_DOUBLE, // + Limit.limit().offset(1).count(10))) // .expectNext(new DefaultTypedTuple<>(value1, 42.1)) // .verifyComplete(); } @@ -295,7 +299,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.reverseRange(key, new Range<>(0L, 0L))) // + StepVerifier.create(zSetOperations.reverseRange(key, ZERO_RANGE)) // .expectNext(value1) // .verifyComplete(); @@ -313,7 +317,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.reverseRangeWithScores(key, new Range<>(0L, 0L))) // + StepVerifier.create(zSetOperations.reverseRangeWithScores(key, ZERO_RANGE)) // .expectNext(new DefaultTypedTuple<>(value1, 42.1)) // .verifyComplete(); } @@ -330,7 +334,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.reverseRangeByScore(key, new Range<>(9d, 11d))) // + StepVerifier.create(zSetOperations.reverseRangeByScore(key, NINE_TO_ELEVEN_DOUBLE)) // .expectNext(value2) // .verifyComplete(); } @@ -347,7 +351,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.reverseRangeByScoreWithScores(key, new Range<>(9d, 11d))) // + StepVerifier.create(zSetOperations.reverseRangeByScoreWithScores(key, NINE_TO_ELEVEN_DOUBLE)) // .expectNext(new DefaultTypedTuple<>(value2, 10d)) // .verifyComplete(); } @@ -364,9 +368,8 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier - .create(zSetOperations.reverseRangeByScore(key, new Range<>(0d, 100d), // - Limit.limit().offset(1).count(10))) // + StepVerifier.create(zSetOperations.reverseRangeByScore(key, ZERO_TO_HUNDRED_DOUBLE, // + Limit.limit().offset(1).count(10))) // .expectNext(value2) // .verifyComplete(); } @@ -383,9 +386,8 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier - .create(zSetOperations.reverseRangeByScoreWithScores(key, new Range<>(0d, 100d), // - Limit.limit().offset(1).count(10))) // + StepVerifier.create(zSetOperations.reverseRangeByScoreWithScores(key, ZERO_TO_HUNDRED_DOUBLE, // + Limit.limit().offset(1).count(10))) // .expectNext(new DefaultTypedTuple<>(value2, 10d)) // .verifyComplete(); } @@ -423,9 +425,8 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.count(key, new Range<>(0d, 100d))).expectNext(2L).expectComplete() - .verify(); - StepVerifier.create(zSetOperations.count(key, new Range<>(0d, 10d))).expectNext(1L).verifyComplete(); + StepVerifier.create(zSetOperations.count(key, ZERO_TO_HUNDRED_DOUBLE)).expectNext(2L).expectComplete().verify(); + StepVerifier.create(zSetOperations.count(key, Range.closed(0d, 10d))).expectNext(1L).verifyComplete(); } @Test // DATAREDIS-602 @@ -467,8 +468,8 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.removeRange(key, new Range<>(0L, 0L))).expectNext(1L).verifyComplete(); - StepVerifier.create(zSetOperations.range(key, new Range<>(0L, 5L))).expectNext(value1).verifyComplete(); + StepVerifier.create(zSetOperations.removeRange(key, ZERO_RANGE)).expectNext(1L).verifyComplete(); + StepVerifier.create(zSetOperations.range(key, ZERO_TO_FIVE)).expectNext(value1).verifyComplete(); } @Test // DATAREDIS-602 @@ -483,9 +484,9 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.removeRangeByScore(key, new Range<>(9d, 11d))).expectNext(1L).expectComplete() + StepVerifier.create(zSetOperations.removeRangeByScore(key, NINE_TO_ELEVEN_DOUBLE)).expectNext(1L).expectComplete() .verify(); - StepVerifier.create(zSetOperations.range(key, new Range<>(0L, 5L))) // + StepVerifier.create(zSetOperations.range(key, ZERO_TO_FIVE)) // .expectNext(value1) // .verifyComplete(); } @@ -508,7 +509,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(otherKey, shared, 11)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.unionAndStore(key, otherKey, destKey)).expectNext(3L).verifyComplete(); - StepVerifier.create(zSetOperations.range(destKey, new Range<>(0L, 100L))).expectNextCount(3).verifyComplete(); + StepVerifier.create(zSetOperations.range(destKey, Range.closed(0L, 100L))).expectNextCount(3).verifyComplete(); } @Test // DATAREDIS-746 @@ -558,7 +559,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.intersectAndStore(key, otherKey, destKey)).expectNext(1L).expectComplete() .verify(); - StepVerifier.create(zSetOperations.range(destKey, new Range<>(0L, 5L))) // + StepVerifier.create(zSetOperations.range(destKey, ZERO_TO_FIVE)) // .expectNextCount(1) // .verifyComplete(); } @@ -608,7 +609,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.rangeByLex(key, new Range<>("a", "a"))) // + StepVerifier.create(zSetOperations.rangeByLex(key, Range.just("a"))) // .expectNext(a) // .verifyComplete(); @@ -626,11 +627,13 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.rangeByLex(key, new Range<>("a", "z"), Limit.limit().offset(0).count(10))) // + Range aToZ = Range.closed("a", "z"); + + StepVerifier.create(zSetOperations.rangeByLex(key, aToZ, Limit.limit().offset(0).count(10))) // .expectNext(a, b) // .verifyComplete(); - StepVerifier.create(zSetOperations.rangeByLex(key, new Range<>("a", "z"), Limit.limit().offset(1).count(10))) // + StepVerifier.create(zSetOperations.rangeByLex(key, aToZ, Limit.limit().offset(1).count(10))) // .expectNext(b) // .verifyComplete(); } @@ -647,7 +650,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.reverseRangeByLex(key, new Range<>("a", "a"))) // + StepVerifier.create(zSetOperations.reverseRangeByLex(key, Range.just("a"))) // .expectNext(a) // .verifyComplete(); } @@ -664,11 +667,13 @@ public class DefaultReactiveZSetOperationsIntegrationTests { StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete(); StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete(); - StepVerifier.create(zSetOperations.reverseRangeByLex(key, new Range<>("a", "z"), Limit.limit().offset(0).count(10))) // + Range aToZ = Range.closed("a", "z"); + + StepVerifier.create(zSetOperations.reverseRangeByLex(key, aToZ, Limit.limit().offset(0).count(10))) // .expectNext(b, a) // .verifyComplete(); - StepVerifier.create(zSetOperations.reverseRangeByLex(key, new Range<>("a", "z"), Limit.limit().offset(1).count(10))) // + StepVerifier.create(zSetOperations.reverseRangeByLex(key, aToZ, Limit.limit().offset(1).count(10))) // .expectNext(a) // .verifyComplete(); }