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

Polishing.

Browse Source 
Add reactive ZRANGESTORE support. Support rangeAndStore in RedisZSet.

Refine assertion messages. Refine overloads.

Original pull request: #2370.
See #2345
This commit is contained in:
Mark Paluch
2022-09-23 12:05:42 +02:00
parent 40d078f66d
commit 62932e2b47
21 changed files with 1420 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java
View File

@@ -4070,14 +4070,33 @@ public abstract class AbstractConnectionIntegrationTests {
}
@Test //GH-2345
public void zRangeStoreStoresKeysCreatedByZAddByScore() {
final String dstKey = KEY_2;
final String srcKey = KEY_1;
public void zRangeStoreByScoreStoresKeys() {
String dstKey = KEY_2;
String srcKey = KEY_1;
actual.add(connection.zAdd(srcKey, 1, VALUE_1));
actual.add(connection.zAdd(srcKey, 2, VALUE_2));
actual.add(connection.zAdd(srcKey, 3, VALUE_3));
actual.add(connection.zAdd(srcKey, 4, VALUE_4));
actual.add(connection.zRangeStoreByScore(dstKey, srcKey, 3, 4));
actual.add(connection.zRangeStoreByScore(dstKey, srcKey, Range.closed(3, 4)));
actual.add(connection.zRange(dstKey, 0, -1));
List<Object> result = getResults();
assertThat(result.get(0)).isEqualTo(true);
assertThat(result.get(1)).isEqualTo(true);
assertThat(result.get(2)).isEqualTo(true);
assertThat(result.get(3)).isEqualTo(true);
assertThat(result.get(4)).isEqualTo(2L);
assertThat((LinkedHashSet<Object>) result.get(5)).containsSequence(VALUE_3, VALUE_4);
}
@Test // GH-2345
public void zRangeStoreRevByScoreStoresKeys() {
String dstKey = KEY_2;
String srcKey = KEY_1;
actual.add(connection.zAdd(srcKey, 1, VALUE_1));
actual.add(connection.zAdd(srcKey, 2, VALUE_2));
actual.add(connection.zAdd(srcKey, 3, VALUE_3));
actual.add(connection.zAdd(srcKey, 4, VALUE_4));
actual.add(connection.zRangeStoreRevByScore(dstKey, srcKey, Range.closed(3, 4)));
actual.add(connection.zRange(dstKey, 0, -1));
List<Object> result = getResults();
assertThat(result.get(0)).isEqualTo(true);
@@ -4089,9 +4108,9 @@ public abstract class AbstractConnectionIntegrationTests {
}
@Test //GH-2345
public void zRangeStoreStoresKeysCreatedByZAddByLex() {
final String dstKey = KEY_2;
final String srcKey = KEY_1;
public void zRangeStoreByLexStoresKeys() {
String dstKey = KEY_2;
String srcKey = KEY_1;
actual.add(connection.zAdd(srcKey, 0, VALUE_3));
actual.add(connection.zAdd(srcKey, 0, VALUE_1));
actual.add(connection.zAdd(srcKey, 0, VALUE_4));
@@ -4107,6 +4126,25 @@ public abstract class AbstractConnectionIntegrationTests {
assertThat((LinkedHashSet<Object>) result.get(5)).containsSequence(VALUE_3, VALUE_4);
}
@Test // GH-2345
public void zRangeStoreRevByLexStoresKeys() {
String dstKey = KEY_2;
String srcKey = KEY_1;
actual.add(connection.zAdd(srcKey, 0, VALUE_3));
actual.add(connection.zAdd(srcKey, 0, VALUE_1));
actual.add(connection.zAdd(srcKey, 0, VALUE_4));
actual.add(connection.zAdd(srcKey, 0, VALUE_2));
actual.add(connection.zRangeStoreRevByLex(dstKey, srcKey, Range.rightUnbounded(Bound.inclusive(VALUE_3))));
actual.add(connection.zRange(dstKey, 0, -1));
List<Object> result = getResults();
assertThat(result.get(0)).isEqualTo(true);
assertThat(result.get(1)).isEqualTo(true);
assertThat(result.get(2)).isEqualTo(true);
assertThat(result.get(3)).isEqualTo(true);
assertThat(result.get(4)).isEqualTo(2L);
assertThat((LinkedHashSet<Object>) result.get(5)).containsSequence(VALUE_3, VALUE_4);
}
protected void verifyResults(List<Object> expected) {
assertThat(getResults()).isEqualTo(expected);
}

96
src/test/java/org/springframework/data/redis/core/DefaultReactiveZSetOperationsIntegrationTests.java
View File

@@ -420,6 +420,96 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
.verifyComplete();
}
@ParameterizedRedisTest // GH-2345
void rangeAndStoreByLex() {
assumeThat(serializer instanceof StringRedisSerializer).isTrue();
K key = keyFactory.instance();
K destKey = keyFactory.instance();
V a = (V) "a";
V b = (V) "b";
V c = (V) "c";
zSetOperations.add(key, a, 1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 2).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, c, 3).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.rangeAndStoreByLex(key, destKey, Range.closed("a", "b")).as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
}
@ParameterizedRedisTest // GH-2345
void rangeAndStoreByScore() {
assumeThat(valueFactory instanceof ByteBufferObjectFactory).isFalse();
K key = keyFactory.instance();
K destKey = keyFactory.instance();
V a = valueFactory.instance();
V b = valueFactory.instance();
V c = valueFactory.instance();
zSetOperations.add(key, a, 1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 2).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, c, 3).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.rangeAndStoreByScore(key, destKey, Range.closed(1.0, 2.0)).as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
zSetOperations.range(destKey, Range.unbounded()).as(StepVerifier::create) //
.expectNext(a) //
.expectNext(b) //
.verifyComplete();
}
@ParameterizedRedisTest // GH-2345
void reverseRangeAndStoreByLex() {
assumeThat(serializer instanceof StringRedisSerializer).isTrue();
K key = keyFactory.instance();
K destKey = keyFactory.instance();
V a = (V) "a";
V b = (V) "b";
V c = (V) "c";
zSetOperations.add(key, a, 1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 2).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, c, 3).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.reverseRangeAndStoreByLex(key, destKey, Range.closed("a", "b")).as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
}
@ParameterizedRedisTest // GH-2345
void reverseRangeAndStoreByScore() {
assumeThat(valueFactory instanceof ByteBufferObjectFactory).isFalse();
K key = keyFactory.instance();
K destKey = keyFactory.instance();
V a = valueFactory.instance();
V b = valueFactory.instance();
V c = valueFactory.instance();
zSetOperations.add(key, a, 1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 2).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, c, 3).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.reverseRangeAndStoreByScore(key, destKey, Range.closed(1.0, 2.0)).as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
zSetOperations.range(destKey, Range.unbounded()).as(StepVerifier::create) //
.expectNext(a) //
.expectNext(b) //
.verifyComplete();
}
@ParameterizedRedisTest // DATAREDIS-743
void scan() {
@@ -594,8 +684,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.removeRangeByScore(key, NINE_TO_ELEVEN_DOUBLE).as(StepVerifier::create).expectNext(1L)
.expectComplete()
.verify();
.expectComplete().verify();
zSetOperations.range(key, ZERO_TO_FIVE).as(StepVerifier::create) //
.expectNext(value1) //
.verifyComplete();
@@ -806,8 +895,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
zSetOperations.score(destKey, shared).as(StepVerifier::create).expectNext(22d).verifyComplete();
zSetOperations.unionAndStore(key, Collections.singleton(otherKey), destKey, Aggregate.SUM, Weights.of(2, 1))
.as(StepVerifier::create)
.expectNext(3L).verifyComplete();
.as(StepVerifier::create).expectNext(3L).verifyComplete();
zSetOperations.score(destKey, shared).as(StepVerifier::create).expectNext(33d).verifyComplete();
}

68
src/test/java/org/springframework/data/redis/support/collections/AbstractRedisZSetTestIntegration.java
View File

@@ -572,6 +572,74 @@ public abstract class AbstractRedisZSetTestIntegration<T> extends AbstractRedisC
assertThat(tuple2.getScore()).isEqualTo(Double.valueOf(3));
}
@ParameterizedRedisTest // GH-2345
void testRangeAndStoreByLex() {
assumeThat(factory).isOfAnyClassIn(DoubleObjectFactory.class, DoubleAsStringObjectFactory.class,
LongAsStringObjectFactory.class, LongObjectFactory.class);
T t1 = getT();
T t2 = getT();
T t3 = getT();
zSet.add(t1, 1);
zSet.add(t2, 2);
zSet.add(t3, 3);
RedisZSet<T> tuples = zSet.rangeAndStoreByLex("dest", Range.closed(t2.toString(), t3.toString()));
assertThat(tuples).hasSize(2).containsSequence(t2, t3);
}
@ParameterizedRedisTest // GH-2345
void testRangeAndStoreRevByLex() {
assumeThat(factory).isOfAnyClassIn(DoubleObjectFactory.class, DoubleAsStringObjectFactory.class,
LongAsStringObjectFactory.class, LongObjectFactory.class);
T t1 = getT();
T t2 = getT();
T t3 = getT();
zSet.add(t1, 1);
zSet.add(t2, 2);
zSet.add(t3, 3);
RedisZSet<T> tuples = zSet.reverseRangeAndStoreByLex("dest", Range.closed(t1.toString(), t3.toString()),
Limit.limit().count(2).offset(1));
assertThat(tuples).hasSize(2).containsSequence(t1, t2);
}
@ParameterizedRedisTest // GH-2345
void testRangeAndStoreByScore() {
T t1 = getT();
T t2 = getT();
T t3 = getT();
zSet.add(t1, 1);
zSet.add(t2, 2);
zSet.add(t3, 3);
RedisZSet<T> tuples = zSet.rangeAndStoreByScore("dest", Range.closed(2, 3));
assertThat(tuples).hasSize(2).containsSequence(t2, t3);
}
@ParameterizedRedisTest // GH-2345
void testRangeAndStoreRevByScore() {
T t1 = getT();
T t2 = getT();
T t3 = getT();
zSet.add(t1, 1);
zSet.add(t2, 2);
zSet.add(t3, 3);
RedisZSet<T> tuples = zSet.reverseRangeAndStoreByScore("dest", Range.closed(1, 3),
Limit.limit().count(2).offset(0));
assertThat(tuples).hasSize(2).containsSequence(t2, t3);
}
@ParameterizedRedisTest
void testRemove() {
T t1 = getT();