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

DATAREDIS-1122 - Consistently use as(StepVerivier::create) in tests.

Browse Source 
Original pull request: #523.
This commit is contained in:
Mark Paluch
2020-04-20 11:03:55 +02:00
parent 649b579fe8
commit 0d2e4474f8
25 changed files with 844 additions and 768 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveClusterServerCommandsTests.java
View File

@@ -36,66 +36,64 @@ public class LettuceReactiveClusterServerCommandsTests extends LettuceReactiveCl
@Test // DATAREDIS-659
public void pingShouldRespondCorrectly() {
StepVerifier.create(connection.ping(NODE1)).expectNext("PONG").verifyComplete();
connection.ping(NODE1).as(StepVerifier::create).expectNext("PONG").verifyComplete();
}
@Test // DATAREDIS-659
public void lastSaveShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().lastSave(NODE1)).expectNextCount(1).verifyComplete();
connection.serverCommands().lastSave(NODE1).as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659
public void saveShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().save(NODE1)).expectNext("OK").verifyComplete();
connection.serverCommands().save(NODE1).as(StepVerifier::create).expectNext("OK").verifyComplete();
}
@Test // DATAREDIS-659
public void dbSizeShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().dbSize(NODE1)).expectNextCount(1).verifyComplete();
connection.serverCommands().dbSize(NODE1).as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659
public void flushDbShouldRespondCorrectly() {
StepVerifier
.create(connection.serverCommands().flushDb() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER)) //
.then(connection.stringCommands().set(KEY_2_BBUFFER, VALUE_2_BBUFFER))) //
connection.serverCommands().flushDb() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER)) //
.then(connection.stringCommands().set(KEY_2_BBUFFER, VALUE_2_BBUFFER)).as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE1)).expectNext(1L).verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE3)).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize(NODE1).as(StepVerifier::create).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize(NODE3).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(connection.serverCommands().flushDb(NODE1)).expectNext("OK").verifyComplete();
connection.serverCommands().flushDb(NODE1).as(StepVerifier::create).expectNext("OK").verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE1)).expectNext(0L).verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE3)).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize(NODE1).as(StepVerifier::create).expectNext(0L).verifyComplete();
connection.serverCommands().dbSize(NODE3).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-659
public void flushAllShouldRespondCorrectly() {
StepVerifier
.create(connection.serverCommands().flushAll() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER)) //
.then(connection.stringCommands().set(KEY_2_BBUFFER, VALUE_2_BBUFFER))) //
connection.serverCommands().flushAll() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER)) //
.then(connection.stringCommands().set(KEY_2_BBUFFER, VALUE_2_BBUFFER)).as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE1)).expectNext(1L).verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE3)).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize(NODE1).as(StepVerifier::create).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize(NODE3).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(connection.serverCommands().flushAll(NODE1)).expectNext("OK").verifyComplete();
connection.serverCommands().flushAll(NODE1).as(StepVerifier::create).expectNext("OK").verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE1)).expectNext(0L).verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize(NODE3)).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize(NODE1).as(StepVerifier::create).expectNext(0L).verifyComplete();
connection.serverCommands().dbSize(NODE3).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-659
public void infoShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().info(NODE1)) //
connection.serverCommands().info(NODE1).as(StepVerifier::create) //
.consumeNextWith(properties -> assertThat(properties).containsKey("tcp_port")) //
.verifyComplete();
}
@@ -103,7 +101,7 @@ public class LettuceReactiveClusterServerCommandsTests extends LettuceReactiveCl
@Test // DATAREDIS-659
public void standaloneInfoWithSectionShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().info(NODE1, "server")) //
connection.serverCommands().info(NODE1, "server").as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsKey("tcp_port").doesNotContainKey("role");
}) //
@@ -113,7 +111,7 @@ public class LettuceReactiveClusterServerCommandsTests extends LettuceReactiveCl
@Test // DATAREDIS-659
public void getConfigShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().getConfig(NODE1, "*")) //
connection.serverCommands().getConfig(NODE1, "*").as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsEntry("databases", "16");
}) //
@@ -133,21 +131,21 @@ public class LettuceReactiveClusterServerCommandsTests extends LettuceReactiveCl
}).block().toString();
try {
StepVerifier.create(connection.serverCommands().setConfig(slowLogKey, resetValue)) //
connection.serverCommands().setConfig(slowLogKey, resetValue).as(StepVerifier::create) //
.expectNext("OK") //
.verifyComplete();
StepVerifier.create(connection.serverCommands().setConfig(NODE1, slowLogKey, "127")) //
connection.serverCommands().setConfig(NODE1, slowLogKey, "127").as(StepVerifier::create) //
.expectNext("OK") //
.verifyComplete();
StepVerifier.create(connection.serverCommands().getConfig(NODE1, slowLogKey)) //
connection.serverCommands().getConfig(NODE1, slowLogKey).as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsEntry(slowLogKey, "127");
}) //
.verifyComplete();
StepVerifier.create(connection.serverCommands().getConfig(NODE2, slowLogKey)) //
connection.serverCommands().getConfig(NODE2, slowLogKey).as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsEntry(slowLogKey, resetValue);
}) //
@@ -159,16 +157,16 @@ public class LettuceReactiveClusterServerCommandsTests extends LettuceReactiveCl
@Test // DATAREDIS-659
public void configResetstatShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().resetConfigStats(NODE1)).expectNext("OK").verifyComplete();
connection.serverCommands().resetConfigStats(NODE1).as(StepVerifier::create).expectNext("OK").verifyComplete();
}
@Test // DATAREDIS-659
public void timeShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().time(NODE1)).expectNextCount(1).verifyComplete();
connection.serverCommands().time(NODE1).as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659
public void getClientListShouldReportClient() {
StepVerifier.create(connection.serverCommands().getClientList(NODE1)).expectNextCount(1).thenCancel().verify();
connection.serverCommands().getClientList(NODE1).as(StepVerifier::create).expectNextCount(1).thenCancel().verify();
}
}

42
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveGeoCommandsTests.java
View File

@@ -147,15 +147,13 @@ public class LettuceReactiveGeoCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.geoadd(KEY_1, CATANIA.getPoint().getX(), CATANIA.getPoint().getY(), CATANIA_MEMBER_NAME);
nativeCommands.geoadd(KEY_1, ARIGENTO.getPoint().getX(), ARIGENTO.getPoint().getY(), ARIGENTO_MEMBER_NAME);
StepVerifier
.create(connection.geoCommands().geoRadius(KEY_1_BBUFFER,
new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)))) //
connection.geoCommands().geoRadius(KEY_1_BBUFFER, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)))
.as(StepVerifier::create) //
.expectNextCount(3) //
.expectComplete();
StepVerifier
.create(connection.geoCommands().geoRadius(KEY_1_BBUFFER,
new Circle(new Point(15D, 37D), new Distance(150D, KILOMETERS)))) //
connection.geoCommands().geoRadius(KEY_1_BBUFFER, new Circle(new Point(15D, 37D), new Distance(150D, KILOMETERS)))
.as(StepVerifier::create) //
.expectNextCount(2) //
.expectComplete();
}
@@ -167,9 +165,10 @@ public class LettuceReactiveGeoCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.geoadd(KEY_1, CATANIA.getPoint().getX(), CATANIA.getPoint().getY(), CATANIA_MEMBER_NAME);
nativeCommands.geoadd(KEY_1, ARIGENTO.getPoint().getX(), ARIGENTO.getPoint().getY(), ARIGENTO_MEMBER_NAME);
StepVerifier
.create(connection.geoCommands().geoRadius(KEY_1_BBUFFER,
new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)), newGeoRadiusArgs().includeDistance())) //
connection.geoCommands()
.geoRadius(KEY_1_BBUFFER, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)),
newGeoRadiusArgs().includeDistance())
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getDistance().getValue()).isCloseTo(130.423D, offset(0.005));
@@ -185,9 +184,10 @@ public class LettuceReactiveGeoCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.geoadd(KEY_1, CATANIA.getPoint().getX(), CATANIA.getPoint().getY(), CATANIA_MEMBER_NAME);
nativeCommands.geoadd(KEY_1, ARIGENTO.getPoint().getX(), ARIGENTO.getPoint().getY(), ARIGENTO_MEMBER_NAME);
StepVerifier
.create(connection.geoCommands().geoRadius(KEY_1_BBUFFER,
new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)), newGeoRadiusArgs().limit(2))) //
connection.geoCommands()
.geoRadius(KEY_1_BBUFFER, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)),
newGeoRadiusArgs().limit(2))
.as(StepVerifier::create) //
.expectNextCount(2) //
.expectComplete();
}
@@ -199,9 +199,8 @@ public class LettuceReactiveGeoCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.geoadd(KEY_1, CATANIA.getPoint().getX(), CATANIA.getPoint().getY(), CATANIA_MEMBER_NAME);
nativeCommands.geoadd(KEY_1, ARIGENTO.getPoint().getX(), ARIGENTO.getPoint().getY(), ARIGENTO_MEMBER_NAME);
StepVerifier
.create(connection.geoCommands().geoRadiusByMember(KEY_1_BBUFFER, ARIGENTO.getName(),
new Distance(100, KILOMETERS))) //
connection.geoCommands().geoRadiusByMember(KEY_1_BBUFFER, ARIGENTO.getName(), new Distance(100, KILOMETERS))
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getContent().getName()).isEqualTo(ARIGENTO.getName());
}) //
@@ -218,9 +217,10 @@ public class LettuceReactiveGeoCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.geoadd(KEY_1, CATANIA.getPoint().getX(), CATANIA.getPoint().getY(), CATANIA_MEMBER_NAME);
nativeCommands.geoadd(KEY_1, ARIGENTO.getPoint().getX(), ARIGENTO.getPoint().getY(), ARIGENTO_MEMBER_NAME);
StepVerifier
.create(connection.geoCommands().geoRadiusByMember(KEY_1_BBUFFER, PALERMO.getName(),
new Distance(100, KILOMETERS), newGeoRadiusArgs().includeDistance())) //
connection.geoCommands()
.geoRadiusByMember(KEY_1_BBUFFER, PALERMO.getName(), new Distance(100, KILOMETERS),
newGeoRadiusArgs().includeDistance())
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getDistance().getValue()).isCloseTo(90.978D, offset(0.005));
@@ -238,9 +238,9 @@ public class LettuceReactiveGeoCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.geoadd(KEY_1, CATANIA.getPoint().getX(), CATANIA.getPoint().getY(), CATANIA_MEMBER_NAME);
nativeCommands.geoadd(KEY_1, ARIGENTO.getPoint().getX(), ARIGENTO.getPoint().getY(), ARIGENTO_MEMBER_NAME);
StepVerifier
.create(connection.geoCommands().geoRadiusByMember(KEY_1_BBUFFER, PALERMO.getName(),
new Distance(200, KILOMETERS), newGeoRadiusArgs().limit(2))) //
connection.geoCommands()
.geoRadiusByMember(KEY_1_BBUFFER, PALERMO.getName(), new Distance(200, KILOMETERS), newGeoRadiusArgs().limit(2))
.as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();
}

51
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveHashCommandsTests.java
View File

@@ -53,13 +53,13 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
@Test // DATAREDIS-525
public void hSetShouldOperateCorrectly() {
StepVerifier.create(connection.hashCommands().hSet(KEY_1_BBUFFER, FIELD_1_BBUFFER, VALUE_1_BBUFFER))
connection.hashCommands().hSet(KEY_1_BBUFFER, FIELD_1_BBUFFER, VALUE_1_BBUFFER).as(StepVerifier::create)
.expectNext(true).verifyComplete();
}
@Test // DATAREDIS-525
public void hSetNxShouldOperateCorrectly() {
StepVerifier.create(connection.hashCommands().hSetNX(KEY_1_BBUFFER, FIELD_1_BBUFFER, VALUE_1_BBUFFER))
connection.hashCommands().hSetNX(KEY_1_BBUFFER, FIELD_1_BBUFFER, VALUE_1_BBUFFER).as(StepVerifier::create)
.expectNext(true).verifyComplete();
}
@@ -68,7 +68,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_1, VALUE_1);
StepVerifier.create(connection.hashCommands().hSetNX(KEY_1_BBUFFER, FIELD_1_BBUFFER, VALUE_1_BBUFFER))
connection.hashCommands().hSetNX(KEY_1_BBUFFER, FIELD_1_BBUFFER, VALUE_1_BBUFFER).as(StepVerifier::create)
.expectNext(false).verifyComplete();
}
@@ -79,7 +79,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hGet(KEY_1_BBUFFER, FIELD_1_BBUFFER)).expectNext(VALUE_1_BBUFFER)
connection.hashCommands().hGet(KEY_1_BBUFFER, FIELD_1_BBUFFER).as(StepVerifier::create).expectNext(VALUE_1_BBUFFER)
.verifyComplete();
}
@@ -88,7 +88,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_1, VALUE_1);
StepVerifier.create(connection.hashCommands().hGet(KEY_1_BBUFFER, FIELD_2_BBUFFER)).verifyComplete();
connection.hashCommands().hGet(KEY_1_BBUFFER, FIELD_2_BBUFFER).as(StepVerifier::create).verifyComplete();
}
@Test // DATAREDIS-525
@@ -98,7 +98,8 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hMGet(KEY_1_BBUFFER, Arrays.asList(FIELD_1_BBUFFER, FIELD_3_BBUFFER)))
connection.hashCommands().hMGet(KEY_1_BBUFFER, Arrays.asList(FIELD_1_BBUFFER, FIELD_3_BBUFFER))
.as(StepVerifier::create)
.consumeNextWith(actual -> {
assertThat(actual).contains(VALUE_1_BBUFFER, VALUE_3_BBUFFER);
@@ -112,9 +113,8 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_1, VALUE_1);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier
.create(connection.hashCommands().hMGet(KEY_1_BBUFFER,
Arrays.asList(FIELD_1_BBUFFER, FIELD_2_BBUFFER, FIELD_3_BBUFFER)))
connection.hashCommands().hMGet(KEY_1_BBUFFER, Arrays.asList(FIELD_1_BBUFFER, FIELD_2_BBUFFER, FIELD_3_BBUFFER))
.as(StepVerifier::create)
.expectNext(Arrays.asList(VALUE_1_BBUFFER, null, VALUE_3_BBUFFER)).verifyComplete();
}
@@ -125,7 +125,8 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
fieldValues.put(FIELD_1_BBUFFER, VALUE_1_BBUFFER);
fieldValues.put(FIELD_2_BBUFFER, VALUE_2_BBUFFER);
StepVerifier.create(connection.hashCommands().hMSet(KEY_1_BBUFFER, fieldValues)).expectNext(true).verifyComplete();
connection.hashCommands().hMSet(KEY_1_BBUFFER, fieldValues).as(StepVerifier::create).expectNext(true)
.verifyComplete();
assertThat(nativeCommands.hget(KEY_1, FIELD_1)).isEqualTo(VALUE_1);
assertThat(nativeCommands.hget(KEY_1, FIELD_2)).isEqualTo(VALUE_2);
}
@@ -136,12 +137,13 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
Map<ByteBuffer, ByteBuffer> fieldValues = new LinkedHashMap<>();
fieldValues.put(FIELD_1_BBUFFER, VALUE_1_BBUFFER);
StepVerifier.create(connection.hashCommands().hMSet(KEY_1_BBUFFER, fieldValues)).expectNext(true).verifyComplete();
connection.hashCommands().hMSet(KEY_1_BBUFFER, fieldValues).as(StepVerifier::create).expectNext(true)
.verifyComplete();
Map<ByteBuffer, ByteBuffer> overwriteFieldValues = new LinkedHashMap<>();
overwriteFieldValues.put(FIELD_1_BBUFFER, VALUE_2_BBUFFER);
StepVerifier.create(connection.hashCommands().hMSet(KEY_1_BBUFFER, overwriteFieldValues)).expectNext(true)
connection.hashCommands().hMSet(KEY_1_BBUFFER, overwriteFieldValues).as(StepVerifier::create).expectNext(true)
.verifyComplete();
assertThat(nativeCommands.hget(KEY_1, FIELD_1)).isEqualTo(VALUE_2);
}
@@ -151,13 +153,13 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_1, VALUE_1);
StepVerifier.create(connection.hashCommands().hExists(KEY_1_BBUFFER, FIELD_1_BBUFFER)).expectNext(true)
connection.hashCommands().hExists(KEY_1_BBUFFER, FIELD_1_BBUFFER).as(StepVerifier::create).expectNext(true)
.verifyComplete();
}
@Test // DATAREDIS-525
public void hExistsShouldReturnFalseForNonExistingField() {
StepVerifier.create(connection.hashCommands().hExists(KEY_1_BBUFFER, FIELD_1_BBUFFER)).expectNext(false)
connection.hashCommands().hExists(KEY_1_BBUFFER, FIELD_1_BBUFFER).as(StepVerifier::create).expectNext(false)
.verifyComplete();
}
@@ -168,7 +170,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hDel(KEY_1_BBUFFER, FIELD_2_BBUFFER)).expectNext(true)
connection.hashCommands().hDel(KEY_1_BBUFFER, FIELD_2_BBUFFER).as(StepVerifier::create).expectNext(true)
.verifyComplete();
}
@@ -179,7 +181,8 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hDel(KEY_1_BBUFFER, Arrays.asList(FIELD_1_BBUFFER, FIELD_3_BBUFFER)))
connection.hashCommands().hDel(KEY_1_BBUFFER, Arrays.asList(FIELD_1_BBUFFER, FIELD_3_BBUFFER))
.as(StepVerifier::create)
.expectNext(2L).verifyComplete();
}
@@ -190,7 +193,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hLen(KEY_1_BBUFFER)).expectNext(3L).verifyComplete();
connection.hashCommands().hLen(KEY_1_BBUFFER).as(StepVerifier::create).expectNext(3L).verifyComplete();
}
@Test // DATAREDIS-525
@@ -200,7 +203,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hKeys(KEY_1_BBUFFER)) //
connection.hashCommands().hKeys(KEY_1_BBUFFER).as(StepVerifier::create) //
.expectNext(FIELD_1_BBUFFER, FIELD_2_BBUFFER, FIELD_3_BBUFFER) //
.verifyComplete();
}
@@ -212,7 +215,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hVals(KEY_1_BBUFFER))
connection.hashCommands().hVals(KEY_1_BBUFFER).as(StepVerifier::create)
.expectNext(VALUE_1_BBUFFER, VALUE_2_BBUFFER, VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -229,7 +232,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
expected.put(FIELD_2_BBUFFER, VALUE_2_BBUFFER);
expected.put(FIELD_3_BBUFFER, VALUE_3_BBUFFER);
StepVerifier.create(connection.hashCommands().hGetAll(KEY_1_BBUFFER).buffer(3)) //
connection.hashCommands().hGetAll(KEY_1_BBUFFER).buffer(3).as(StepVerifier::create) //
.consumeNextWith(list -> {
assertThat(list.containsAll(expected.entrySet())).isTrue();
}) //
@@ -243,7 +246,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
nativeCommands.hset(KEY_1, FIELD_3, VALUE_3);
StepVerifier.create(connection.hashCommands().hScan(KEY_1_BBUFFER, ScanOptions.scanOptions().count(1).build())) //
connection.hashCommands().hScan(KEY_1_BBUFFER, ScanOptions.scanOptions().count(1).build()).as(StepVerifier::create) //
.expectNextCount(3) //
.verifyComplete();
}
@@ -254,7 +257,7 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_1, VALUE_1);
nativeCommands.hset(KEY_1, FIELD_2, VALUE_2);
StepVerifier.create(connection.hashCommands().hStrLen(KEY_1_BBUFFER, FIELD_1_BBUFFER))
connection.hashCommands().hStrLen(KEY_1_BBUFFER, FIELD_1_BBUFFER).as(StepVerifier::create)
.expectNext(Long.valueOf(VALUE_1.length())) //
.verifyComplete();
}
@@ -264,14 +267,14 @@ public class LettuceReactiveHashCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.hset(KEY_1, FIELD_2, VALUE_3);
StepVerifier.create(connection.hashCommands().hStrLen(KEY_1_BBUFFER, FIELD_1_BBUFFER)).expectNext(0L) //
connection.hashCommands().hStrLen(KEY_1_BBUFFER, FIELD_1_BBUFFER).as(StepVerifier::create).expectNext(0L) //
.verifyComplete();
}
@Test // DATAREDIS-698
public void hStrLenReturnsZeroWhenKeyDoesNotExist() {
StepVerifier.create(connection.hashCommands().hStrLen(KEY_1_BBUFFER, FIELD_1_BBUFFER)).expectNext(0L) //
connection.hashCommands().hStrLen(KEY_1_BBUFFER, FIELD_1_BBUFFER).as(StepVerifier::create).expectNext(0L) //
.verifyComplete();
}
}

66
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveKeyCommandsTests.java
View File

@@ -57,12 +57,12 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.keyCommands().exists(KEY_1_BBUFFER)).expectNext(true).verifyComplete();
connection.keyCommands().exists(KEY_1_BBUFFER).as(StepVerifier::create).expectNext(true).verifyComplete();
}
@Test // DATAREDIS-525
public void existsShouldReturnFalseForNonExistingKeys() {
StepVerifier.create(connection.keyCommands().exists(KEY_1_BBUFFER)).expectNext(false).verifyComplete();
connection.keyCommands().exists(KEY_1_BBUFFER).as(StepVerifier::create).expectNext(false).verifyComplete();
}
@Test // DATAREDIS-525
@@ -72,9 +72,9 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_2, VALUE_2);
nativeCommands.hset(KEY_3, KEY_1, VALUE_1);
StepVerifier.create(connection.keyCommands().type(KEY_1_BBUFFER)).expectNext(DataType.STRING).verifyComplete();
StepVerifier.create(connection.keyCommands().type(KEY_2_BBUFFER)).expectNext(DataType.SET).verifyComplete();
StepVerifier.create(connection.keyCommands().type(KEY_3_BBUFFER)).expectNext(DataType.HASH).verifyComplete();
connection.keyCommands().type(KEY_1_BBUFFER).as(StepVerifier::create).expectNext(DataType.STRING).verifyComplete();
connection.keyCommands().type(KEY_2_BBUFFER).as(StepVerifier::create).expectNext(DataType.SET).verifyComplete();
connection.keyCommands().type(KEY_3_BBUFFER).as(StepVerifier::create).expectNext(DataType.HASH).verifyComplete();
}
@Test // DATAREDIS-525
@@ -88,11 +88,11 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(VALUE_2, KEY_2);
nativeCommands.set(VALUE_3, KEY_3);
StepVerifier.create(connection.keyCommands().keys(ByteBuffer.wrap("*".getBytes())).flatMapIterable(it -> it)) //
connection.keyCommands().keys(ByteBuffer.wrap("*".getBytes())).flatMapIterable(it -> it).as(StepVerifier::create) //
.expectNextCount(6) //
.verifyComplete();
StepVerifier.create(connection.keyCommands().keys(ByteBuffer.wrap("key*".getBytes())).flatMapIterable(it -> it)) //
connection.keyCommands().keys(ByteBuffer.wrap("key*".getBytes())).flatMapIterable(it -> it).as(StepVerifier::create) //
.expectNextCount(3).verifyComplete();
}
@@ -107,11 +107,11 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(VALUE_2, KEY_2);
nativeCommands.set(VALUE_3, KEY_3);
StepVerifier.create(connection.keyCommands().scan(ScanOptions.scanOptions().count(2).build())) //
connection.keyCommands().scan(ScanOptions.scanOptions().count(2).build()).as(StepVerifier::create) //
.expectNextCount(6) //
.verifyComplete();
StepVerifier.create(connection.keyCommands().scan(ScanOptions.scanOptions().count(2).match("key*").build())) //
connection.keyCommands().scan(ScanOptions.scanOptions().count(2).match("key*").build()).as(StepVerifier::create) //
.expectNextCount(3) //
.verifyComplete();
}
@@ -123,12 +123,12 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_2, VALUE_2);
nativeCommands.set(KEY_3, VALUE_3);
StepVerifier.create(connection.keyCommands().randomKey()).expectNextCount(1).verifyComplete();
connection.keyCommands().randomKey().as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-525
public void randomKeyShouldReturnNullWhenNoKeyExists() {
StepVerifier.create(connection.keyCommands().randomKey()).verifyComplete();
connection.keyCommands().randomKey().as(StepVerifier::create).verifyComplete();
}
@Test // DATAREDIS-525
@@ -136,7 +136,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_2);
StepVerifier.create(connection.keyCommands().rename(KEY_1_BBUFFER, KEY_2_BBUFFER)).expectNext(true)
connection.keyCommands().rename(KEY_1_BBUFFER, KEY_2_BBUFFER).as(StepVerifier::create).expectNext(true)
.verifyComplete();
assertThat(nativeCommands.exists(KEY_2)).isEqualTo(1L);
assertThat(nativeCommands.exists(KEY_1)).isEqualTo(0L);
@@ -145,7 +145,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
@Test // DATAREDIS-525
public void renameShouldThrowErrorWhenKeyDoesNotExist() {
StepVerifier.create(connection.keyCommands().rename(KEY_1_BBUFFER, KEY_2_BBUFFER))
connection.keyCommands().rename(KEY_1_BBUFFER, KEY_2_BBUFFER).as(StepVerifier::create)
.expectError(RedisSystemException.class).verify();
}
@@ -154,7 +154,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_2);
StepVerifier.create(connection.keyCommands().renameNX(KEY_1_BBUFFER, KEY_2_BBUFFER)).expectNext(true)
connection.keyCommands().renameNX(KEY_1_BBUFFER, KEY_2_BBUFFER).as(StepVerifier::create).expectNext(true)
.verifyComplete();
assertThat(nativeCommands.exists(KEY_2)).isEqualTo(1L);
@@ -167,7 +167,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_2);
nativeCommands.set(KEY_2, VALUE_2);
StepVerifier.create(connection.keyCommands().renameNX(KEY_1_BBUFFER, KEY_2_BBUFFER)).expectNext(false)
connection.keyCommands().renameNX(KEY_1_BBUFFER, KEY_2_BBUFFER).as(StepVerifier::create).expectNext(false)
.verifyComplete();
}
@@ -176,7 +176,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.keyCommands().del(KEY_1_BBUFFER)).expectNext(1L).verifyComplete();
connection.keyCommands().del(KEY_1_BBUFFER).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-525
@@ -188,7 +188,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
Flux<NumericResponse<KeyCommand, Long>> result = connection.keyCommands()
.del(Flux.fromIterable(Arrays.asList(new KeyCommand(KEY_1_BBUFFER), new KeyCommand(KEY_2_BBUFFER))));
StepVerifier.create(result).expectNextCount(2).verifyComplete();
result.as(StepVerifier::create).expectNextCount(2).verifyComplete();
}
@Test // DATAREDIS-525
@@ -199,7 +199,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
Mono<Long> result = connection.keyCommands().mDel(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER));
StepVerifier.create(result).expectNext(2L).verifyComplete();
result.as(StepVerifier::create).expectNext(2L).verifyComplete();
}
@Test // DATAREDIS-525
@@ -213,7 +213,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
Flux<Long> result = connection.keyCommands().mDel(input).map(NumericResponse::getOutput);
StepVerifier.create(result).expectNextCount(2).verifyComplete();
result.as(StepVerifier::create).expectNextCount(2).verifyComplete();
}
@Test // DATAREDIS-693
@@ -222,7 +222,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.keyCommands().unlink(KEY_1_BBUFFER)).expectNext(1L).verifyComplete();
connection.keyCommands().unlink(KEY_1_BBUFFER).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-693
@@ -235,7 +235,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
Flux<NumericResponse<KeyCommand, Long>> result = connection.keyCommands()
.unlink(Flux.fromIterable(Arrays.asList(new KeyCommand(KEY_1_BBUFFER), new KeyCommand(KEY_2_BBUFFER))));
StepVerifier.create(result).expectNextCount(2).verifyComplete();
result.as(StepVerifier::create).expectNextCount(2).verifyComplete();
}
@Test // DATAREDIS-693
@@ -247,7 +247,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
Mono<Long> result = connection.keyCommands().mUnlink(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER));
StepVerifier.create(result).expectNext(2L).verifyComplete();
result.as(StepVerifier::create).expectNext(2L).verifyComplete();
}
@Test // DATAREDIS-693
@@ -262,7 +262,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
Flux<Long> result = connection.keyCommands().mUnlink(input).map(NumericResponse::getOutput);
StepVerifier.create(result).expectNextCount(2).verifyComplete();
result.as(StepVerifier::create).expectNextCount(2).verifyComplete();
}
@Test // DATAREDIS-602
@@ -270,7 +270,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.keyCommands().expire(KEY_1_BBUFFER, Duration.ofSeconds(10))) //
connection.keyCommands().expire(KEY_1_BBUFFER, Duration.ofSeconds(10)).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
@@ -283,7 +283,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.keyCommands().pExpire(KEY_1_BBUFFER, Duration.ofSeconds(10))) //
connection.keyCommands().pExpire(KEY_1_BBUFFER, Duration.ofSeconds(10)).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
@@ -297,7 +297,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
Instant expireAt = Instant.now().plus(Duration.ofSeconds(10));
StepVerifier.create(connection.keyCommands().expireAt(KEY_1_BBUFFER, expireAt)) //
connection.keyCommands().expireAt(KEY_1_BBUFFER, expireAt).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
@@ -311,7 +311,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
Instant expireAt = Instant.now().plus(Duration.ofSeconds(10));
StepVerifier.create(connection.keyCommands().pExpireAt(KEY_1_BBUFFER, expireAt)) //
connection.keyCommands().pExpireAt(KEY_1_BBUFFER, expireAt).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
@@ -324,7 +324,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1, SetArgs.Builder.ex(10));
StepVerifier.create(connection.keyCommands().ttl(KEY_1_BBUFFER)) //
connection.keyCommands().ttl(KEY_1_BBUFFER).as(StepVerifier::create) //
.expectNextMatches(actual -> {
assertThat(nativeCommands.ttl(KEY_1)).isGreaterThan(8L);
return true;
@@ -338,7 +338,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1, SetArgs.Builder.ex(10));
StepVerifier.create(connection.keyCommands().pTtl(KEY_1_BBUFFER)) //
connection.keyCommands().pTtl(KEY_1_BBUFFER).as(StepVerifier::create) //
.expectNextMatches(actual -> {
assertThat(actual).isGreaterThan(8000L);
return true;
@@ -352,7 +352,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1, SetArgs.Builder.ex(10));
StepVerifier.create(connection.keyCommands().persist(KEY_1_BBUFFER)) //
connection.keyCommands().persist(KEY_1_BBUFFER).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
@@ -367,7 +367,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.keyCommands().move(KEY_1_BBUFFER, 5)) //
connection.keyCommands().move(KEY_1_BBUFFER, 5).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
@@ -380,7 +380,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.set(KEY_1, VALUE_1);
nativeCommands.set(KEY_2, VALUE_2);
StepVerifier.create(connection.keyCommands().touch(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)))
connection.keyCommands().touch(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)).as(StepVerifier::create)
.expectNext(2L) //
.verifyComplete();
}
@@ -388,7 +388,7 @@ public class LettuceReactiveKeyCommandsTests extends LettuceReactiveCommandsTest
@Test // DATAREDIS-694
public void touchReturnsZeroIfNoKeysTouched() {
StepVerifier.create(connection.keyCommands().touch(Collections.singletonList(KEY_1_BBUFFER))) //
connection.keyCommands().touch(Collections.singletonList(KEY_1_BBUFFER)).as(StepVerifier::create) //
.expectNext(0L) //
.verifyComplete();
}

10
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveListCommandTests.java
View File

@@ -114,7 +114,8 @@ public class LettuceReactiveListCommandTests extends LettuceReactiveCommandsTest
RangeCommand rangeCommand = RangeCommand.key(KEY_1_BBUFFER).within(Range.of(unbounded(), inclusive(1L)));
StepVerifier.create(connection.listCommands().lRange(Mono.just(rangeCommand)).flatMap(CommandResponse::getOutput)) //
connection.listCommands().lRange(Mono.just(rangeCommand)).flatMap(CommandResponse::getOutput)
.as(StepVerifier::create) //
.expectNext(VALUE_1_BBUFFER).expectNext(VALUE_2_BBUFFER).verifyComplete();
}
@@ -125,7 +126,8 @@ public class LettuceReactiveListCommandTests extends LettuceReactiveCommandsTest
RangeCommand rangeCommand = RangeCommand.key(KEY_1_BBUFFER).within(Range.of(inclusive(1L), unbounded()));
StepVerifier.create(connection.listCommands().lRange(Mono.just(rangeCommand)).flatMap(CommandResponse::getOutput)) //
connection.listCommands().lRange(Mono.just(rangeCommand)).flatMap(CommandResponse::getOutput)
.as(StepVerifier::create) //
.expectNext(VALUE_2_BBUFFER).expectNext(VALUE_3_BBUFFER).verifyComplete();
}
@@ -145,7 +147,7 @@ public class LettuceReactiveListCommandTests extends LettuceReactiveCommandsTest
RangeCommand rangeCommand = RangeCommand.key(KEY_1_BBUFFER).within(Range.of(unbounded(), inclusive(1L)));
StepVerifier.create(connection.listCommands().lTrim(Mono.just(rangeCommand))) //
connection.listCommands().lTrim(Mono.just(rangeCommand)).as(StepVerifier::create) //
.expectNext(new ReactiveRedisConnection.BooleanResponse<>(rangeCommand, true)) //
.verifyComplete();
}
@@ -157,7 +159,7 @@ public class LettuceReactiveListCommandTests extends LettuceReactiveCommandsTest
RangeCommand rangeCommand = RangeCommand.key(KEY_1_BBUFFER).within(Range.of(inclusive(1L), unbounded()));
StepVerifier.create(connection.listCommands().lTrim(Mono.just(rangeCommand))) //
connection.listCommands().lTrim(Mono.just(rangeCommand)).as(StepVerifier::create) //
.expectNext(new ReactiveRedisConnection.BooleanResponse<>(rangeCommand, true)) //
.verifyComplete();
}

4
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveRedisClusterConnectionUnitTests.java
View File

@@ -75,7 +75,7 @@ public class LettuceReactiveRedisClusterConnectionUnitTests {
when(reactiveNodeCommands.bgrewriteaof()).thenReturn(Mono.just("OK"));
StepVerifier.create(connection.serverCommands().bgReWriteAof(NODE1)).expectNextCount(1).verifyComplete();
connection.serverCommands().bgReWriteAof(NODE1).as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659, DATAREDIS-708
@@ -86,6 +86,6 @@ public class LettuceReactiveRedisClusterConnectionUnitTests {
when(reactiveNodeCommands.bgsave()).thenReturn(Mono.just("OK"));
StepVerifier.create(connection.serverCommands().bgSave(NODE1)).expectNextCount(1).verifyComplete();
connection.serverCommands().bgSave(NODE1).as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
}

27
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveRedisConnectionUnitTests.java
View File

@@ -28,7 +28,6 @@ import reactor.test.StepVerifier;
import java.nio.ByteBuffer;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
@@ -39,6 +38,7 @@ import org.mockito.Answers;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.data.redis.RedisConnectionFailureException;
import org.springframework.data.redis.connection.ReactiveStreamCommands.AddStreamRecord;
import org.springframework.data.redis.connection.stream.ByteBufferRecord;
@@ -77,7 +77,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(connectionProvider);
StepVerifier.create(connection.execute(cmd -> Mono.just("foo"))).expectNext("foo").verifyComplete();
connection.execute(cmd -> Mono.just("foo")).as(StepVerifier::create).expectNext("foo").verifyComplete();
verify(connectionProvider).getConnectionAsync(StatefulConnection.class);
}
@@ -87,7 +87,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(connectionProvider);
StepVerifier.create(connection.executeDedicated(cmd -> Mono.just("foo"))).expectNext("foo").verifyComplete();
connection.executeDedicated(cmd -> Mono.just("foo")).as(StepVerifier::create).expectNext("foo").verifyComplete();
verify(connectionProvider).getConnectionAsync(StatefulConnection.class);
}
@@ -98,7 +98,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(sharedConnection,
connectionProvider);
StepVerifier.create(connection.execute(cmd -> Mono.just("foo"))).expectNext("foo").verifyComplete();
connection.execute(cmd -> Mono.just("foo")).as(StepVerifier::create).expectNext("foo").verifyComplete();
verifyZeroInteractions(connectionProvider);
}
@@ -109,7 +109,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(sharedConnection,
connectionProvider);
StepVerifier.create(connection.executeDedicated(cmd -> Mono.just("foo"))).expectNext("foo").verifyComplete();
connection.executeDedicated(cmd -> Mono.just("foo")).as(StepVerifier::create).expectNext("foo").verifyComplete();
verify(connectionProvider).getConnectionAsync(StatefulConnection.class);
}
@@ -119,7 +119,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(connectionProvider);
StepVerifier.create(connection.getConnection()).expectNextCount(1).verifyComplete();
connection.getConnection().as(StepVerifier::create).expectNextCount(1).verifyComplete();
verify(connectionProvider).getConnectionAsync(StatefulConnection.class);
}
@@ -130,8 +130,8 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(sharedConnection,
connectionProvider);
StepVerifier.create(connection.getConnection()).expectNextCount(1).verifyComplete();
StepVerifier.create(connection.getDedicatedConnection()).expectNextCount(1).verifyComplete();
connection.getConnection().as(StepVerifier::create).expectNextCount(1).verifyComplete();
connection.getDedicatedConnection().as(StepVerifier::create).expectNextCount(1).verifyComplete();
connection.close();
@@ -144,7 +144,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(connectionProvider);
StepVerifier.create(connection.getConnection()).expectNextCount(1).verifyComplete();
connection.getConnection().as(StepVerifier::create).expectNextCount(1).verifyComplete();
connection.close();
connection.close();
@@ -190,7 +190,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(connectionProvider);
StepVerifier.create(connection.getConnection()).expectError(RedisConnectionFailureException.class).verify();
connection.getConnection().as(StepVerifier::create).expectError(RedisConnectionFailureException.class).verify();
}
@Test // DATAREDIS-720, DATAREDIS-721
@@ -199,7 +199,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
LettuceReactiveRedisConnection connection = new LettuceReactiveRedisConnection(connectionProvider);
connection.close();
StepVerifier.create(connection.getConnection()).expectError(IllegalStateException.class).verify();
connection.getConnection().as(StepVerifier::create).expectError(IllegalStateException.class).verify();
}
@Test // DATAREDIS-659, DATAREDIS-708
@@ -209,7 +209,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
when(reactiveCommands.bgrewriteaof()).thenReturn(Mono.just("OK"));
StepVerifier.create(connection.serverCommands().bgReWriteAof()).expectNextCount(1).verifyComplete();
connection.serverCommands().bgReWriteAof().as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659, DATAREDIS-667, DATAREDIS-708
@@ -219,7 +219,7 @@ public class LettuceReactiveRedisConnectionUnitTests {
when(reactiveCommands.bgsave()).thenReturn(Mono.just("OK"));
StepVerifier.create(connection.serverCommands().bgSave()).expectNextCount(1).verifyComplete();
connection.serverCommands().bgSave().as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-1122
@@ -230,7 +230,6 @@ public class LettuceReactiveRedisConnectionUnitTests {
ArgumentCaptor<XAddArgs> args = ArgumentCaptor.forClass(XAddArgs.class);
when(reactiveCommands.xadd(any(ByteBuffer.class), args.capture(), anyMap())).thenReturn(Mono.just("1-1"));
MapRecord<ByteBuffer, ByteBuffer, ByteBuffer> record = MapRecord.create(ByteBuffer.wrap("key".getBytes()),
Collections.emptyMap());

36
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveScriptingCommandsTests.java
View File

@@ -47,7 +47,7 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
String sha1 = nativeCommands.scriptLoad("return KEYS[1]");
StepVerifier.create(connection.scriptingCommands().scriptExists(Arrays.asList("foo", sha1))) //
connection.scriptingCommands().scriptExists(Arrays.asList("foo", sha1)).as(StepVerifier::create) //
.expectNext(false) //
.expectNext(true) //
.verifyComplete();
@@ -60,15 +60,15 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
String sha1 = nativeCommands.scriptLoad("return KEYS[1]");
StepVerifier.create(connection.scriptingCommands().scriptExists(sha1)) //
connection.scriptingCommands().scriptExists(sha1).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(connection.scriptingCommands().scriptFlush()) //
connection.scriptingCommands().scriptFlush().as(StepVerifier::create) //
.expectNext("OK") //
.verifyComplete();
StepVerifier.create(connection.scriptingCommands().scriptExists(sha1)) //
connection.scriptingCommands().scriptExists(sha1).as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
}
@@ -80,9 +80,9 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
String sha1 = nativeCommands.scriptLoad("return KEYS[1]");
StepVerifier
.create(connection.scriptingCommands().evalSha(sha1, ReturnType.VALUE, 2, SAME_SLOT_KEY_1_BBUFFER.duplicate(),
SAME_SLOT_KEY_2_BBUFFER.duplicate())) //
connection.scriptingCommands()
.evalSha(sha1, ReturnType.VALUE, 2, SAME_SLOT_KEY_1_BBUFFER.duplicate(), SAME_SLOT_KEY_2_BBUFFER.duplicate())
.as(StepVerifier::create) //
.expectNext(SAME_SLOT_KEY_1_BBUFFER) //
.verifyComplete();
}
@@ -94,9 +94,9 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
String sha1 = nativeCommands.scriptLoad("return {KEYS[1],ARGV[1]}");
StepVerifier
.create(connection.scriptingCommands().evalSha(sha1, ReturnType.MULTI, 1, SAME_SLOT_KEY_1_BBUFFER.duplicate(),
SAME_SLOT_KEY_2_BBUFFER.duplicate())) //
connection.scriptingCommands()
.evalSha(sha1, ReturnType.MULTI, 1, SAME_SLOT_KEY_1_BBUFFER.duplicate(), SAME_SLOT_KEY_2_BBUFFER.duplicate())
.as(StepVerifier::create) //
.expectNext(Arrays.asList(SAME_SLOT_KEY_1_BBUFFER, SAME_SLOT_KEY_2_BBUFFER)) //
.verifyComplete();
}
@@ -106,8 +106,8 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
assumeFalse(connection instanceof ReactiveRedisClusterConnection);
StepVerifier
.create(connection.scriptingCommands().evalSha("foo", ReturnType.VALUE, 1, SAME_SLOT_KEY_1_BBUFFER.duplicate())) //
connection.scriptingCommands().evalSha("foo", ReturnType.VALUE, 1, SAME_SLOT_KEY_1_BBUFFER.duplicate())
.as(StepVerifier::create) //
.expectError(RedisSystemException.class) //
.verify();
}
@@ -117,8 +117,8 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
ByteBuffer script = wrap(String.format("return redis.call('set','%s','ghk')", SAME_SLOT_KEY_1));
StepVerifier
.create(connection.scriptingCommands().eval(script, ReturnType.STATUS, 1, SAME_SLOT_KEY_1_BBUFFER.duplicate())) //
connection.scriptingCommands().eval(script, ReturnType.STATUS, 1, SAME_SLOT_KEY_1_BBUFFER.duplicate())
.as(StepVerifier::create) //
.expectNext("OK") //
.verifyComplete();
}
@@ -128,7 +128,7 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
ByteBuffer script = wrap("return false");
StepVerifier.create(connection.scriptingCommands().eval(script, ReturnType.BOOLEAN, 0)) //
connection.scriptingCommands().eval(script, ReturnType.BOOLEAN, 0).as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
}
@@ -138,7 +138,7 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
ByteBuffer script = wrap("return {1,2}");
StepVerifier.create(connection.scriptingCommands().eval(script, ReturnType.MULTI, 0)) //
connection.scriptingCommands().eval(script, ReturnType.MULTI, 0).as(StepVerifier::create) //
.expectNext(Arrays.asList(1L, 2L)) //
.verifyComplete();
}
@@ -148,7 +148,7 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
ByteBuffer script = wrap("return {1,2");
StepVerifier.create(connection.scriptingCommands().eval(script, ReturnType.MULTI, 0)) //
connection.scriptingCommands().eval(script, ReturnType.MULTI, 0).as(StepVerifier::create) //
.expectError(RedisSystemException.class) //
.verify();
}
@@ -172,7 +172,7 @@ public class LettuceReactiveScriptingCommandsTests extends LettuceReactiveComman
sync.await(2, TimeUnit.SECONDS);
Thread.sleep(200);
StepVerifier.create(connection.scriptingCommands().scriptKill()).expectNext("OK").verifyComplete();
connection.scriptingCommands().scriptKill().as(StepVerifier::create).expectNext("OK").verifyComplete();
assertThat(waitFor(scriptDead::get, 3000L)).isTrue();
}

56
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveServerCommandsTests.java
View File

@@ -30,12 +30,12 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-659
public void pingShouldRespondCorrectly() {
StepVerifier.create(connection.ping()).expectNext("PONG").verifyComplete();
connection.ping().as(StepVerifier::create).expectNext("PONG").verifyComplete();
}
@Test // DATAREDIS-659
public void lastSaveShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().lastSave()).expectNextCount(1).verifyComplete();
connection.serverCommands().lastSave().as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659, DATAREDIS-667
@@ -43,42 +43,42 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
assumeTrue(connectionProvider instanceof StandaloneConnectionProvider);
StepVerifier.create(connection.serverCommands().save()).expectNext("OK").verifyComplete();
connection.serverCommands().save().as(StepVerifier::create).expectNext("OK").verifyComplete();
}
@Test // DATAREDIS-659
public void dbSizeShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().dbSize()).expectNextCount(1).verifyComplete();
connection.serverCommands().dbSize().as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659
public void flushDbShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().flushDb() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER))) //
connection.serverCommands().flushDb() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER)).as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize()).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize().as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(connection.serverCommands().flushDb()).expectNext("OK").verifyComplete();
connection.serverCommands().flushDb().as(StepVerifier::create).expectNext("OK").verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize()).expectNext(0L).verifyComplete();
connection.serverCommands().dbSize().as(StepVerifier::create).expectNext(0L).verifyComplete();
}
@Test // DATAREDIS-659
public void flushAllShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().flushAll() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER))) //
connection.serverCommands().flushAll() //
.then(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER)).as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize()).expectNext(1L).verifyComplete();
connection.serverCommands().dbSize().as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(connection.serverCommands().flushAll()).expectNext("OK").verifyComplete();
connection.serverCommands().flushAll().as(StepVerifier::create).expectNext("OK").verifyComplete();
StepVerifier.create(connection.serverCommands().dbSize()).expectNext(0L).verifyComplete();
connection.serverCommands().dbSize().as(StepVerifier::create).expectNext(0L).verifyComplete();
}
@Test // DATAREDIS-659
@@ -86,7 +86,7 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
if (connection instanceof LettuceReactiveRedisClusterConnection) {
StepVerifier.create(connection.serverCommands().info()) //
connection.serverCommands().info().as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties) //
@@ -96,7 +96,7 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
.verifyComplete();
} else {
StepVerifier.create(connection.serverCommands().info()) //
connection.serverCommands().info().as(StepVerifier::create) //
.consumeNextWith(properties -> assertThat(properties).containsKey("tcp_port")) //
.verifyComplete();
}
@@ -107,7 +107,7 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
if (connection instanceof LettuceReactiveRedisClusterConnection) {
StepVerifier.create(connection.serverCommands().info("server")) //
connection.serverCommands().info("server").as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).isNotEmpty() //
.containsKey("127.0.0.1:7379.tcp_port") //
@@ -116,7 +116,7 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
.verifyComplete();
} else {
StepVerifier.create(connection.serverCommands().info("server")) //
connection.serverCommands().info("server").as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsKey("tcp_port").doesNotContainKey("role");
}) //
@@ -129,7 +129,7 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
if (connection instanceof LettuceReactiveRedisClusterConnection) {
StepVerifier.create(connection.serverCommands().getConfig("*")) //
connection.serverCommands().getConfig("*").as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsEntry("127.0.0.1:7379.databases", "16");
@@ -137,7 +137,7 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
.verifyComplete();
} else {
StepVerifier.create(connection.serverCommands().getConfig("*")) //
connection.serverCommands().getConfig("*").as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsEntry("databases", "16");
}) //
@@ -158,18 +158,18 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
}).block().toString();
try {
StepVerifier.create(connection.serverCommands().setConfig(slowLogKey, "127")) //
connection.serverCommands().setConfig(slowLogKey, "127").as(StepVerifier::create) //
.expectNext("OK") //
.verifyComplete();
if (connection instanceof LettuceReactiveRedisClusterConnection) {
StepVerifier.create(connection.serverCommands().getConfig(slowLogKey)) //
connection.serverCommands().getConfig(slowLogKey).as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsEntry("127.0.0.1:7379." + slowLogKey, "127");
}) //
.verifyComplete();
} else {
StepVerifier.create(connection.serverCommands().getConfig(slowLogKey)) //
connection.serverCommands().getConfig(slowLogKey).as(StepVerifier::create) //
.consumeNextWith(properties -> {
assertThat(properties).containsEntry(slowLogKey, "127");
}) //
@@ -182,12 +182,12 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-659
public void configResetstatShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().resetConfigStats()).expectNext("OK").verifyComplete();
connection.serverCommands().resetConfigStats().as(StepVerifier::create).expectNext("OK").verifyComplete();
}
@Test // DATAREDIS-659
public void timeShouldRespondCorrectly() {
StepVerifier.create(connection.serverCommands().time()).expectNextCount(1).verifyComplete();
connection.serverCommands().time().as(StepVerifier::create).expectNextCount(1).verifyComplete();
}
@Test // DATAREDIS-659
@@ -196,12 +196,12 @@ public class LettuceReactiveServerCommandsTests extends LettuceReactiveCommandsT
// see lettuce-io/lettuce-core#563
assumeFalse(connection instanceof LettuceReactiveRedisClusterConnection);
StepVerifier.create(connection.serverCommands().setClientName("foo")).expectNextCount(1).verifyComplete();
StepVerifier.create(connection.serverCommands().getClientName()).expectNext("foo").verifyComplete();
connection.serverCommands().setClientName("foo").as(StepVerifier::create).expectNextCount(1).verifyComplete();
connection.serverCommands().getClientName().as(StepVerifier::create).expectNext("foo").verifyComplete();
}
@Test // DATAREDIS-659
public void getClientListShouldReportClient() {
StepVerifier.create(connection.serverCommands().getClientList()).expectNextCount(1).thenCancel().verify();
connection.serverCommands().getClientList().as(StepVerifier::create).expectNextCount(1).thenCancel().verify();
}
}

22
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveSetCommandsTests.java
View File

@@ -77,7 +77,7 @@ public class LettuceReactiveSetCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_1, VALUE_1, VALUE_2, VALUE_3);
StepVerifier.create(connection.setCommands().sPop(KEY_1_BBUFFER, 2)).expectNextCount(2).verifyComplete();
connection.setCommands().sPop(KEY_1_BBUFFER, 2).as(StepVerifier::create).expectNextCount(2).verifyComplete();
}
@Test // DATAREDIS-525
@@ -147,11 +147,11 @@ public class LettuceReactiveSetCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_2, VALUE_2, VALUE_3);
nativeCommands.sadd(KEY_3, VALUE_1, VALUE_3);
StepVerifier.create(connection.setCommands().sInter(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER))) //
connection.setCommands().sInter(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create) //
.expectNext(VALUE_2_BBUFFER) //
.verifyComplete();
StepVerifier.create(connection.setCommands().sInter(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER))) //
connection.setCommands().sInter(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)).as(StepVerifier::create) //
.verifyComplete();
}
@@ -172,7 +172,7 @@ public class LettuceReactiveSetCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_1, VALUE_1, VALUE_2);
nativeCommands.sadd(KEY_2, VALUE_2, VALUE_3);
StepVerifier.create(connection.setCommands().sUnion(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER))) //
connection.setCommands().sUnion(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create) //
.expectNextCount(3) //
.expectComplete();
}
@@ -194,11 +194,11 @@ public class LettuceReactiveSetCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_2, VALUE_2, VALUE_3);
nativeCommands.sadd(KEY_3, VALUE_2, VALUE_1);
StepVerifier.create(connection.setCommands().sDiff(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER))) //
connection.setCommands().sDiff(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create) //
.expectNext(VALUE_1_BBUFFER) //
.verifyComplete();
StepVerifier.create(connection.setCommands().sDiff(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER))) //
connection.setCommands().sDiff(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)).as(StepVerifier::create) //
.verifyComplete();
}
@@ -217,7 +217,7 @@ public class LettuceReactiveSetCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_1, VALUE_1, VALUE_2, VALUE_3);
StepVerifier.create(connection.setCommands().sMembers(KEY_1_BBUFFER).buffer(3)) //
connection.setCommands().sMembers(KEY_1_BBUFFER).buffer(3).as(StepVerifier::create) //
.consumeNextWith(list -> assertThat(list).contains(VALUE_1_BBUFFER, VALUE_2_BBUFFER, VALUE_3_BBUFFER)) //
.verifyComplete();
}
@@ -227,12 +227,12 @@ public class LettuceReactiveSetCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_1, VALUE_1, VALUE_2, VALUE_3);
StepVerifier.create(connection.setCommands().sScan(KEY_1_BBUFFER)) //
connection.setCommands().sScan(KEY_1_BBUFFER).as(StepVerifier::create) //
.expectNextCount(3) //
.verifyComplete();
StepVerifier
.create(connection.setCommands().sScan(KEY_1_BBUFFER, ScanOptions.scanOptions().match("value-3").build())) //
connection.setCommands().sScan(KEY_1_BBUFFER, ScanOptions.scanOptions().match("value-3").build())
.as(StepVerifier::create) //
.expectNext(VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -251,7 +251,7 @@ public class LettuceReactiveSetCommandsTests extends LettuceReactiveCommandsTest
nativeCommands.sadd(KEY_1, VALUE_1, VALUE_2, VALUE_3);
StepVerifier.create(connection.setCommands().sRandMember(KEY_1_BBUFFER, 2L)) //
connection.setCommands().sRandMember(KEY_1_BBUFFER, 2L).as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();
}

128
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveStringCommandsTests.java
View File

@@ -65,7 +65,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().getSet(KEY_1_BBUFFER, VALUE_2_BBUFFER)) //
connection.stringCommands().getSet(KEY_1_BBUFFER, VALUE_2_BBUFFER).as(StepVerifier::create) //
.expectNext(VALUE_1_BBUFFER) //
.verifyComplete();
@@ -75,7 +75,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-525, DATAREDIS-645
public void getSetShouldNotEmitPreviousValueCorrectlyWhenNotExists() {
StepVerifier.create(connection.stringCommands().getSet(KEY_1_BBUFFER, VALUE_2_BBUFFER)).verifyComplete();
connection.stringCommands().getSet(KEY_1_BBUFFER, VALUE_2_BBUFFER).as(StepVerifier::create).verifyComplete();
assertThat(nativeCommands.get(KEY_1)).isEqualTo(VALUE_2);
}
@@ -83,7 +83,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-525
public void setShouldAddValueCorrectly() {
StepVerifier.create(connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER)) //
connection.stringCommands().set(KEY_1_BBUFFER, VALUE_1_BBUFFER).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
@@ -96,7 +96,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
List<SetCommand> setCommands = Arrays.asList(SetCommand.set(KEY_1_BBUFFER).value(VALUE_1_BBUFFER),
SetCommand.set(KEY_2_BBUFFER).value(VALUE_2_BBUFFER));
StepVerifier.create(connection.stringCommands().set(Flux.fromIterable(setCommands))) //
connection.stringCommands().set(Flux.fromIterable(setCommands)).as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();
@@ -109,12 +109,13 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().get(KEY_1_BBUFFER)).expectNext(VALUE_1_BBUFFER).verifyComplete();
connection.stringCommands().get(KEY_1_BBUFFER).as(StepVerifier::create).expectNext(VALUE_1_BBUFFER)
.verifyComplete();
}
@Test // DATAREDIS-525, DATAREDIS-645
public void getShouldNotEmitValueValueIfAbsent() {
StepVerifier.create(connection.stringCommands().get(KEY_1_BBUFFER)).verifyComplete();
connection.stringCommands().get(KEY_1_BBUFFER).as(StepVerifier::create).verifyComplete();
}
@Test // DATAREDIS-525
@@ -126,7 +127,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
Stream<KeyCommand> stream = Stream.of(new KeyCommand(KEY_1_BBUFFER), new KeyCommand(KEY_2_BBUFFER));
Flux<ByteBufferResponse<KeyCommand>> result = connection.stringCommands().get(Flux.fromStream(stream));
StepVerifier.create(result.map(CommandResponse::getOutput).map(ByteUtils::getBytes).map(String::new)) //
result.map(CommandResponse::getOutput).map(ByteUtils::getBytes).map(String::new).as(StepVerifier::create) //
.expectNext(new String(ByteUtils.getBytes(VALUE_1_BBUFFER)), new String(ByteUtils.getBytes(VALUE_2_BBUFFER))) //
.verifyComplete();
}
@@ -141,7 +142,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
new KeyCommand(KEY_3_BBUFFER));
Flux<ByteBufferResponse<KeyCommand>> result = connection.stringCommands().get(Flux.fromStream(stream));
StepVerifier.create(result.map(CommandResponse::isPresent)) //
result.map(CommandResponse::isPresent).as(StepVerifier::create) //
.expectNext(true, false, true) //
.verifyComplete();
@@ -153,7 +154,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
nativeCommands.set(KEY_2, VALUE_2);
StepVerifier.create(connection.stringCommands().mGet(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER))) //
connection.stringCommands().mGet(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create) //
.consumeNextWith(byteBuffers -> assertThat(byteBuffers).containsExactly(VALUE_1_BBUFFER, VALUE_2_BBUFFER))//
.verifyComplete();
@@ -186,7 +187,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
expected.add(Arrays.asList(VALUE_1_BBUFFER, VALUE_2_BBUFFER));
expected.add(Collections.singletonList(VALUE_2_BBUFFER));
StepVerifier.create(result.collect(Collectors.toSet())) //
result.collect(Collectors.toSet()).as(StepVerifier::create) //
.expectNext(expected) //
.verifyComplete();
}
@@ -194,7 +195,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-525
public void setNXshouldOnlySetValueWhenNotPresent() {
StepVerifier.create(connection.stringCommands().setNX(KEY_1_BBUFFER, VALUE_1_BBUFFER)) //
connection.stringCommands().setNX(KEY_1_BBUFFER, VALUE_1_BBUFFER).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
}
@@ -204,7 +205,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.setnx(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().setNX(KEY_1_BBUFFER, VALUE_2_BBUFFER)) //
connection.stringCommands().setNX(KEY_1_BBUFFER, VALUE_2_BBUFFER).as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
}
@@ -212,7 +213,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-525
public void setEXshouldSetKeyAndExpirationTime() {
StepVerifier.create(connection.stringCommands().setEX(KEY_1_BBUFFER, VALUE_1_BBUFFER, Expiration.seconds(3))) //
connection.stringCommands().setEX(KEY_1_BBUFFER, VALUE_1_BBUFFER, Expiration.seconds(3)).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
@@ -222,8 +223,8 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-525
public void pSetEXshouldSetKeyAndExpirationTime() {
StepVerifier
.create(connection.stringCommands().pSetEX(KEY_1_BBUFFER, VALUE_1_BBUFFER, Expiration.milliseconds(600))) //
connection.stringCommands().pSetEX(KEY_1_BBUFFER, VALUE_1_BBUFFER, Expiration.milliseconds(600))
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
@@ -237,7 +238,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
map.put(KEY_1_BBUFFER, VALUE_1_BBUFFER);
map.put(KEY_2_BBUFFER, VALUE_2_BBUFFER);
StepVerifier.create(connection.stringCommands().mSet(map)).expectNext(true).verifyComplete();
connection.stringCommands().mSet(map).as(StepVerifier::create).expectNext(true).verifyComplete();
assertThat(nativeCommands.get(KEY_1)).isEqualTo(VALUE_1);
assertThat(nativeCommands.get(KEY_2)).isEqualTo(VALUE_2);
@@ -252,7 +253,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
map.put(KEY_1_BBUFFER, VALUE_1_BBUFFER);
map.put(KEY_2_BBUFFER, VALUE_2_BBUFFER);
StepVerifier.create(connection.stringCommands().mSetNX(map)).expectNext(true).verifyComplete();
connection.stringCommands().mSetNX(map).as(StepVerifier::create).expectNext(true).verifyComplete();
assertThat(nativeCommands.get(KEY_1)).isEqualTo(VALUE_1);
assertThat(nativeCommands.get(KEY_2)).isEqualTo(VALUE_2);
@@ -269,7 +270,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
map.put(KEY_1_BBUFFER, VALUE_1_BBUFFER);
map.put(KEY_2_BBUFFER, VALUE_2_BBUFFER);
StepVerifier.create(connection.stringCommands().mSetNX(map)).expectNext(false).verifyComplete();
connection.stringCommands().mSetNX(map).as(StepVerifier::create).expectNext(false).verifyComplete();
assertThat(nativeCommands.exists(KEY_1)).isEqualTo(0L);
assertThat(nativeCommands.get(KEY_2)).isEqualTo(VALUE_2);
@@ -278,11 +279,11 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-525
public void appendShouldDoItsThing() {
StepVerifier.create(connection.stringCommands().append(KEY_1_BBUFFER, VALUE_1_BBUFFER)) //
connection.stringCommands().append(KEY_1_BBUFFER, VALUE_1_BBUFFER).as(StepVerifier::create) //
.expectNext(7L) //
.verifyComplete();
StepVerifier.create(connection.stringCommands().append(KEY_1_BBUFFER, VALUE_2_BBUFFER)) //
connection.stringCommands().append(KEY_1_BBUFFER, VALUE_2_BBUFFER).as(StepVerifier::create) //
.expectNext(14L) //
.verifyComplete();
}
@@ -292,7 +293,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().getRange(KEY_1_BBUFFER, 2, 3)) //
connection.stringCommands().getRange(KEY_1_BBUFFER, 2, 3).as(StepVerifier::create) //
.expectNext(ByteBuffer.wrap("lu".getBytes())) //
.verifyComplete();
}
@@ -305,7 +306,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
RangeCommand rangeCommand = RangeCommand.key(KEY_1_BBUFFER)
.within(Range.of(Bound.unbounded(), Bound.inclusive(2L)));
StepVerifier.create(connection.stringCommands().getRange(Mono.just(rangeCommand))) //
connection.stringCommands().getRange(Mono.just(rangeCommand)).as(StepVerifier::create) //
.expectNext(new ReactiveRedisConnection.ByteBufferResponse<>(rangeCommand, ByteBuffer.wrap("val".getBytes())))
.verifyComplete();
}
@@ -318,7 +319,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
RangeCommand rangeCommand = RangeCommand.key(KEY_1_BBUFFER)
.within(Range.of(Bound.inclusive(0L), Bound.unbounded()));
StepVerifier.create(connection.stringCommands().getRange(Mono.just(rangeCommand))) //
connection.stringCommands().getRange(Mono.just(rangeCommand)).as(StepVerifier::create) //
.expectNext(new ReactiveRedisConnection.ByteBufferResponse<>(rangeCommand, ByteBuffer.wrap(VALUE_1.getBytes())))
.verifyComplete();
}
@@ -328,7 +329,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().setRange(KEY_1_BBUFFER, VALUE_2_BBUFFER, 3)) //
connection.stringCommands().setRange(KEY_1_BBUFFER, VALUE_2_BBUFFER, 3).as(StepVerifier::create) //
.expectNext(10L) //
.verifyComplete();
}
@@ -338,11 +339,11 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().getBit(KEY_1_BBUFFER, 1)) //
connection.stringCommands().getBit(KEY_1_BBUFFER, 1).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(connection.stringCommands().getBit(KEY_1_BBUFFER, 7)) //
connection.stringCommands().getBit(KEY_1_BBUFFER, 7).as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
}
@@ -352,7 +353,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().setBit(KEY_1_BBUFFER, 1, false)) //
connection.stringCommands().setBit(KEY_1_BBUFFER, 1, false).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
@@ -364,7 +365,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().bitCount(KEY_1_BBUFFER)) //
connection.stringCommands().bitCount(KEY_1_BBUFFER).as(StepVerifier::create) //
.expectNext(28L) //
.verifyComplete();
}
@@ -374,7 +375,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().bitCount(KEY_1_BBUFFER, 2, 4)) //
connection.stringCommands().bitCount(KEY_1_BBUFFER, 2, 4).as(StepVerifier::create) //
.expectNext(13L) //
.verifyComplete();
}
@@ -382,57 +383,58 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
@Test // DATAREDIS-562
public void bitFieldSetShouldWorkCorrectly() {
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER, create().set(INT_8).valueAt(offset(0L)).to(10L)))
connection.stringCommands().bitField(KEY_1_BBUFFER, create().set(INT_8).valueAt(offset(0L)).to(10L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(0L)).verifyComplete();
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER, create().set(INT_8).valueAt(offset(0L)).to(20L)))
connection.stringCommands().bitField(KEY_1_BBUFFER, create().set(INT_8).valueAt(offset(0L)).to(20L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(10L)).verifyComplete();
}
@Test // DATAREDIS-562
public void bitFieldGetShouldWorkCorrectly() {
StepVerifier.create(connection.stringCommands().bitField(KEY_1_BBUFFER, create().get(INT_8).valueAt(offset(0L))))
connection.stringCommands().bitField(KEY_1_BBUFFER, create().get(INT_8).valueAt(offset(0L)))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(0L)).verifyComplete();
}
@Test // DATAREDIS-562
public void bitFieldIncrByShouldWorkCorrectly() {
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER, create().incr(INT_8).valueAt(offset(100L)).by(1L)))
connection.stringCommands().bitField(KEY_1_BBUFFER, create().incr(INT_8).valueAt(offset(100L)).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(1L)).verifyComplete();
}
@Test // DATAREDIS-562
public void bitFieldIncrByWithOverflowShouldWorkCorrectly() {
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER,
create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
connection.stringCommands()
.bitField(KEY_1_BBUFFER, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(1L)).verifyComplete();
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER,
create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
connection.stringCommands()
.bitField(KEY_1_BBUFFER, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(2L)).verifyComplete();
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER,
create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
connection.stringCommands()
.bitField(KEY_1_BBUFFER, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(3L)).verifyComplete();
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER,
create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
connection.stringCommands()
.bitField(KEY_1_BBUFFER, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(null)).verifyComplete();
}
@Test // DATAREDIS-562
public void bitfieldShouldAllowMultipleSubcommands() {
StepVerifier
.create(connection.stringCommands().bitField(KEY_1_BBUFFER,
create().incr(signed(5)).valueAt(offset(100L)).by(1L).get(unsigned(4)).valueAt(0L)))
connection.stringCommands()
.bitField(KEY_1_BBUFFER, create().incr(signed(5)).valueAt(offset(100L)).by(1L).get(unsigned(4)).valueAt(0L))
.as(StepVerifier::create)
.expectNext(Arrays.asList(1L, 0L)).verifyComplete();
}
@@ -444,9 +446,8 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
nativeCommands.set(KEY_2, VALUE_2);
StepVerifier
.create(connection.stringCommands().bitOp(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER), BitOperation.AND,
KEY_3_BBUFFER)) //
connection.stringCommands().bitOp(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER), BitOperation.AND, KEY_3_BBUFFER)
.as(StepVerifier::create) //
.expectNext(7L) //
.verifyComplete();
@@ -461,9 +462,8 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
nativeCommands.set(KEY_2, VALUE_2);
StepVerifier
.create(connection.stringCommands().bitOp(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER), BitOperation.OR,
KEY_3_BBUFFER)) //
connection.stringCommands().bitOp(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER), BitOperation.OR, KEY_3_BBUFFER)
.as(StepVerifier::create) //
.expectNext(7L) //
.verifyComplete();
@@ -475,9 +475,8 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
assumeTrue(connectionProvider instanceof StandaloneConnectionProvider);
StepVerifier
.create(connection.stringCommands().bitOp(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER), BitOperation.NOT,
KEY_3_BBUFFER)) //
connection.stringCommands().bitOp(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER), BitOperation.NOT, KEY_3_BBUFFER)
.as(StepVerifier::create) //
.expectError(IllegalArgumentException.class) //
.verify();
}
@@ -487,7 +486,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeCommands.set(KEY_1, VALUE_1);
StepVerifier.create(connection.stringCommands().strLen(KEY_1_BBUFFER)) //
connection.stringCommands().strLen(KEY_1_BBUFFER).as(StepVerifier::create) //
.expectNext(7L) //
.verifyComplete();
}
@@ -497,7 +496,7 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeBinaryCommands.set(KEY_1_BBUFFER, ByteBuffer.wrap(HexStringUtils.hexToBytes("fff000")));
StepVerifier.create(connection.stringCommands().bitPos(KEY_1_BBUFFER, false)).expectNext(12L).verifyComplete();
connection.stringCommands().bitPos(KEY_1_BBUFFER, false).as(StepVerifier::create).expectNext(12L).verifyComplete();
}
@Test // DATAREDIS-697
@@ -505,9 +504,8 @@ public class LettuceReactiveStringCommandsTests extends LettuceReactiveCommandsT
nativeBinaryCommands.set(KEY_1_BBUFFER, ByteBuffer.wrap(HexStringUtils.hexToBytes("fff0f0")));
StepVerifier
.create(connection.stringCommands().bitPos(KEY_1_BBUFFER, true,
org.springframework.data.domain.Range.of(Bound.inclusive(2L), Bound.unbounded())))
connection.stringCommands().bitPos(KEY_1_BBUFFER, true, Range.of(Bound.inclusive(2L), Bound.unbounded()))
.as(StepVerifier::create)
.expectNext(16L).verifyComplete();
}

32
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveSubscriptionUnitTests.java
View File

@@ -67,7 +67,7 @@ public class LettuceReactiveSubscriptionUnitTests {
assertThat(subscription.getChannels()).isEmpty();
StepVerifier.create(subscribe).verifyComplete();
subscribe.as(StepVerifier::create).verifyComplete();
assertThat(subscription.getChannels()).containsOnly(getByteBuffer("foo"), getByteBuffer("bar"));
assertThat(subscription.getPatterns()).isEmpty();
@@ -80,7 +80,7 @@ public class LettuceReactiveSubscriptionUnitTests {
Mono<Void> subscribe = subscription.subscribe(getByteBuffer("foo"), getByteBuffer("bar"));
StepVerifier.create(subscribe).expectError(RedisSystemException.class).verify();
subscribe.as(StepVerifier::create).expectError(RedisSystemException.class).verify();
}
@Test // DATAREDIS-612
@@ -92,7 +92,7 @@ public class LettuceReactiveSubscriptionUnitTests {
assertThat(subscription.getPatterns()).isEmpty();
StepVerifier.create(subscribe).verifyComplete();
subscribe.as(StepVerifier::create).verifyComplete();
assertThat(subscription.getPatterns()).containsOnly(getByteBuffer("foo"), getByteBuffer("bar"));
assertThat(subscription.getChannels()).isEmpty();
@@ -103,9 +103,9 @@ public class LettuceReactiveSubscriptionUnitTests {
when(commandsMock.subscribe(any())).thenReturn(Mono.empty());
when(commandsMock.unsubscribe(any())).thenReturn(Mono.empty());
StepVerifier.create(subscription.subscribe(getByteBuffer("foo"), getByteBuffer("bar"))).verifyComplete();
subscription.subscribe(getByteBuffer("foo"), getByteBuffer("bar")).as(StepVerifier::create).verifyComplete();
StepVerifier.create(subscription.unsubscribe()).verifyComplete();
subscription.unsubscribe().as(StepVerifier::create).verifyComplete();
assertThat(subscription.getChannels()).isEmpty();
verify(commandsMock).unsubscribe(any());
@@ -116,9 +116,9 @@ public class LettuceReactiveSubscriptionUnitTests {
when(commandsMock.psubscribe(any())).thenReturn(Mono.empty());
when(commandsMock.punsubscribe(any())).thenReturn(Mono.empty());
StepVerifier.create(subscription.pSubscribe(getByteBuffer("foo"), getByteBuffer("bar"))).verifyComplete();
subscription.pSubscribe(getByteBuffer("foo"), getByteBuffer("bar")).as(StepVerifier::create).verifyComplete();
StepVerifier.create(subscription.pUnsubscribe()).verifyComplete();
subscription.pUnsubscribe().as(StepVerifier::create).verifyComplete();
assertThat(subscription.getPatterns()).isEmpty();
verify(commandsMock).punsubscribe(any());
@@ -128,14 +128,14 @@ public class LettuceReactiveSubscriptionUnitTests {
public void shouldEmitChannelMessage() {
when(commandsMock.subscribe(any())).thenReturn(Mono.empty());
StepVerifier.create(subscription.subscribe(getByteBuffer("foo"), getByteBuffer("bar"))).verifyComplete();
subscription.subscribe(getByteBuffer("foo"), getByteBuffer("bar")).as(StepVerifier::create).verifyComplete();
DirectProcessor<io.lettuce.core.pubsub.api.reactive.ChannelMessage<ByteBuffer, ByteBuffer>> emitter = DirectProcessor
.create();
when(commandsMock.observeChannels()).thenReturn(emitter);
when(commandsMock.observePatterns()).thenReturn(Flux.empty());
StepVerifier.create(subscription.receive()).then(() -> {
subscription.receive().as(StepVerifier::create).then(() -> {
emitter.onNext(createChannelMessage("other", "body"));
emitter.onNext(createChannelMessage("foo", "body"));
@@ -148,14 +148,14 @@ public class LettuceReactiveSubscriptionUnitTests {
public void shouldEmitPatternMessage() {
when(commandsMock.psubscribe(any())).thenReturn(Mono.empty());
StepVerifier.create(subscription.pSubscribe(getByteBuffer("foo*"), getByteBuffer("bar*"))).verifyComplete();
subscription.pSubscribe(getByteBuffer("foo*"), getByteBuffer("bar*")).as(StepVerifier::create).verifyComplete();
DirectProcessor<io.lettuce.core.pubsub.api.reactive.PatternMessage<ByteBuffer, ByteBuffer>> emitter = DirectProcessor
.create();
when(commandsMock.observeChannels()).thenReturn(Flux.empty());
when(commandsMock.observePatterns()).thenReturn(emitter);
StepVerifier.create(subscription.receive()).then(() -> {
subscription.receive().as(StepVerifier::create).then(() -> {
emitter.onNext(createPatternMessage("other*", "channel", "body"));
emitter.onNext(createPatternMessage("foo*", "foo", "body"));
@@ -170,14 +170,14 @@ public class LettuceReactiveSubscriptionUnitTests {
public void shouldEmitError() {
when(commandsMock.subscribe(any())).thenReturn(Mono.empty());
StepVerifier.create(subscription.subscribe(getByteBuffer("foo"), getByteBuffer("bar"))).verifyComplete();
subscription.subscribe(getByteBuffer("foo"), getByteBuffer("bar")).as(StepVerifier::create).verifyComplete();
DirectProcessor<io.lettuce.core.pubsub.api.reactive.ChannelMessage<ByteBuffer, ByteBuffer>> emitter = DirectProcessor
.create();
when(commandsMock.observeChannels()).thenReturn(emitter);
when(commandsMock.observePatterns()).thenReturn(Flux.empty());
StepVerifier.create(subscription.receive()).then(() -> {
subscription.receive().as(StepVerifier::create).then(() -> {
emitter.onError(new RedisConnectionException("foo"));
}).expectError(RedisSystemException.class).verify();
@@ -188,12 +188,12 @@ public class LettuceReactiveSubscriptionUnitTests {
when(commandsMock.psubscribe(any())).thenReturn(Mono.empty());
when(commandsMock.punsubscribe(any())).thenReturn(Mono.empty());
StepVerifier.create(subscription.pSubscribe(getByteBuffer("foo*"))).verifyComplete();
subscription.pSubscribe(getByteBuffer("foo*")).as(StepVerifier::create).verifyComplete();
when(commandsMock.observeChannels()).thenReturn(Flux.never());
when(commandsMock.observePatterns()).thenReturn(Flux.never());
StepVerifier.create(subscription.receive()).then(() -> {
subscription.receive().as(StepVerifier::create).then(() -> {
subscription.cancel().subscribe();
}).expectError(CancellationException.class).verify();
@@ -207,7 +207,7 @@ public class LettuceReactiveSubscriptionUnitTests {
.create();
when(commandsMock.psubscribe(any())).thenReturn(Mono.empty());
StepVerifier.create(subscription.pSubscribe(getByteBuffer("foo*"))).verifyComplete();
subscription.pSubscribe(getByteBuffer("foo*")).as(StepVerifier::create).verifyComplete();
when(commandsMock.observeChannels()).thenReturn(Flux.never());
when(commandsMock.observePatterns()).thenReturn(emitter);

58
src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveZSetCommandsTests.java
View File

@@ -96,7 +96,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, ONE_TO_TWO)) //
connection.zSetCommands().zRange(KEY_1_BBUFFER, ONE_TO_TWO).as(StepVerifier::create) //
.expectNext(VALUE_2_BBUFFER, VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -108,7 +108,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, ONE_TO_TWO)) //
connection.zSetCommands().zRangeWithScores(KEY_1_BBUFFER, ONE_TO_TWO).as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D), new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) //
.verifyComplete();
}
@@ -120,7 +120,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, ONE_TO_TWO)) //
connection.zSetCommands().zRevRange(KEY_1_BBUFFER, ONE_TO_TWO).as(StepVerifier::create) //
.expectNext(VALUE_2_BBUFFER, VALUE_1_BBUFFER) //
.verifyComplete();
}
@@ -132,7 +132,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, ONE_TO_TWO)) //
connection.zSetCommands().zRevRangeWithScores(KEY_1_BBUFFER, ONE_TO_TWO).as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D), new DefaultTuple(VALUE_1_BBUFFER.array(), 1D)) //
.verifyComplete();
}
@@ -144,7 +144,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, Range.closed(2D, 3D))) //
connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, Range.closed(2D, 3D)).as(StepVerifier::create) //
.expectNext(VALUE_2_BBUFFER, VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -156,9 +156,8 @@ 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,
Range.of(Range.Bound.unbounded(), Range.Bound.inclusive(3D)))) //
connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, Range.of(Range.Bound.unbounded(), Range.Bound.inclusive(3D)))
.as(StepVerifier::create) //
.expectNext(VALUE_1_BBUFFER, VALUE_2_BBUFFER, VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -170,9 +169,8 @@ 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,
Range.of(Range.Bound.inclusive(0D), Range.Bound.unbounded()))) //
connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, Range.of(Range.Bound.inclusive(0D), Range.Bound.unbounded()))
.as(StepVerifier::create) //
.expectNext(VALUE_1_BBUFFER, VALUE_2_BBUFFER, VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -184,7 +182,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, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) //
connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE).as(StepVerifier::create) //
.expectNext(VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -196,7 +194,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, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) //
connection.zSetCommands().zRangeByScore(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE).as(StepVerifier::create) //
.expectNext(VALUE_2_BBUFFER) //
.verifyComplete();
}
@@ -208,7 +206,8 @@ 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, TWO_TO_THREE_ALL_INCLUSIVE)) //
connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, TWO_TO_THREE_ALL_INCLUSIVE)
.as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D), new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) //
.verifyComplete();
}
@@ -220,8 +219,8 @@ 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, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) //
connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)
.as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) //
.verifyComplete();
}
@@ -233,8 +232,8 @@ 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, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) //
connection.zSetCommands().zRangeByScoreWithScores(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)
.as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D)) //
.verifyComplete();
}
@@ -246,7 +245,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, TWO_TO_THREE_ALL_INCLUSIVE)) //
connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, TWO_TO_THREE_ALL_INCLUSIVE).as(StepVerifier::create) //
.expectNext(VALUE_3_BBUFFER, VALUE_2_BBUFFER) //
.verifyComplete();
}
@@ -258,7 +257,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, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) //
connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE).as(StepVerifier::create) //
.expectNext(VALUE_3_BBUFFER) //
.verifyComplete();
}
@@ -270,7 +269,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, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) //
connection.zSetCommands().zRevRangeByScore(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE).as(StepVerifier::create) //
.expectNext(VALUE_2_BBUFFER) //
.verifyComplete();
}
@@ -282,7 +281,8 @@ 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, TWO_TO_THREE_ALL_INCLUSIVE)) //
connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, TWO_TO_THREE_ALL_INCLUSIVE)
.as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_3_BBUFFER.array(), 3D), new DefaultTuple(VALUE_2_BBUFFER.array(), 2D)) //
.verifyComplete();
}
@@ -294,8 +294,8 @@ 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, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)) //
connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, TWO_EXCLUSIVE_TO_THREE_INCLUSIVE)
.as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_3_BBUFFER.array(), 3D)) //
.verifyComplete();
}
@@ -307,8 +307,8 @@ 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, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)) //
connection.zSetCommands().zRevRangeByScoreWithScores(KEY_1_BBUFFER, TWO_INCLUSIVE_TO_THREE_EXCLUSIVE)
.as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D)) //
.verifyComplete();
}
@@ -320,11 +320,11 @@ public class LettuceReactiveZSetCommandsTests extends LettuceReactiveCommandsTes
nativeCommands.zadd(KEY_1, 2D, VALUE_2);
nativeCommands.zadd(KEY_1, 3D, VALUE_3);
StepVerifier.create(connection.zSetCommands().zScan(KEY_1_BBUFFER, ScanOptions.scanOptions().count(1).build())) //
connection.zSetCommands().zScan(KEY_1_BBUFFER, ScanOptions.scanOptions().count(1).build()).as(StepVerifier::create) //
.expectNextCount(3).verifyComplete();
StepVerifier
.create(connection.zSetCommands().zScan(KEY_1_BBUFFER, ScanOptions.scanOptions().match(VALUE_2).build())) //
connection.zSetCommands().zScan(KEY_1_BBUFFER, ScanOptions.scanOptions().match(VALUE_2).build())
.as(StepVerifier::create) //
.expectNext(new DefaultTuple(VALUE_2_BBUFFER.array(), 2D)) //
.verifyComplete();
}

66
src/test/java/org/springframework/data/redis/core/DefaultReactiveGeoOperationsIntegrationTests.java
View File

@@ -115,7 +115,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(geoOperations.add(key, POINT_PALERMO, value)).expectNext(1L).verifyComplete();
geoOperations.add(key, POINT_PALERMO, value) //
.as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602, DATAREDIS-614
@@ -124,7 +125,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(geoOperations.add(key, new GeoLocation<>(value, POINT_PALERMO))) //
geoOperations.add(key, new GeoLocation<>(value, POINT_PALERMO)) //
.as(StepVerifier::create) //
.expectNext(1L) //
.expectComplete() //
.verify();
@@ -139,7 +141,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
memberCoordinateMap.put(valueFactory.instance(), POINT_PALERMO);
memberCoordinateMap.put(valueFactory.instance(), POINT_CATANIA);
StepVerifier.create(geoOperations.add(key, memberCoordinateMap)) //
geoOperations.add(key, memberCoordinateMap) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
}
@@ -152,7 +155,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
List<GeoLocation<V>> geoLocations = Arrays.asList(new GeoLocation<>(valueFactory.instance(), POINT_ARIGENTO),
new GeoLocation<>(valueFactory.instance(), POINT_PALERMO));
StepVerifier.create(geoOperations.add(key, geoLocations)) //
geoOperations.add(key, geoLocations) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
}
@@ -169,7 +173,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
Flux<List<GeoLocation<V>>> geoLocations = Flux.just(batch1, batch2);
StepVerifier.create(geoOperations.add(key, geoLocations)).expectNext(2L) //
geoOperations.add(key, geoLocations) //
.as(StepVerifier::create).expectNext(2L) //
.expectNext(1L) //
.verifyComplete();
}
@@ -184,7 +189,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, member1).block();
geoOperations.add(key, POINT_CATANIA, member2).block();
StepVerifier.create(geoOperations.distance(key, member1, member2)) //
geoOperations.distance(key, member1, member2) //
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getValue()).isCloseTo(DISTANCE_PALERMO_CATANIA_METERS, offset(0.005));
@@ -203,7 +209,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, member1).block();
geoOperations.add(key, POINT_CATANIA, member2).block();
StepVerifier.create(geoOperations.distance(key, member1, member2, Metrics.KILOMETERS)) //
geoOperations.distance(key, member1, member2, Metrics.KILOMETERS) //
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getValue()).isCloseTo(DISTANCE_PALERMO_CATANIA_KILOMETERS, offset(0.005));
@@ -220,7 +227,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, v1).block();
StepVerifier.create(geoOperations.hash(key, v1)) //
geoOperations.hash(key, v1) //
.as(StepVerifier::create) //
.expectNext("sqc8b49rny0") //
.verifyComplete();
}
@@ -236,7 +244,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, v1).block();
geoOperations.add(key, POINT_CATANIA, v2).block();
StepVerifier.create(geoOperations.hash(key, v1, v3, v2)) //
geoOperations.hash(key, v1, v3, v2) //
.as(StepVerifier::create) //
.expectNext(Arrays.asList("sqc8b49rny0", null, "sqdtr74hyu0")) //
.verifyComplete();
}
@@ -249,7 +258,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, v1).block();
StepVerifier.create(geoOperations.position(key, v1)) //
geoOperations.position(key, v1) //
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getX()).isCloseTo(POINT_PALERMO.getX(), offset(0.005));
@@ -269,7 +279,8 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, v1).block();
geoOperations.add(key, POINT_CATANIA, v2).block();
StepVerifier.create(geoOperations.position(key, v1, v3, v2)) //
geoOperations.position(key, v1, v3, v2) //
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.get(0).getX()).isCloseTo(POINT_PALERMO.getX(), offset(0.005));
@@ -291,7 +302,7 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, member1).block();
geoOperations.add(key, POINT_CATANIA, member2).block();
StepVerifier.create(geoOperations.radius(key, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)))) //
geoOperations.radius(key, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS))).as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();
}
@@ -306,9 +317,10 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, member1).block();
geoOperations.add(key, POINT_CATANIA, member2).block();
StepVerifier
.create(geoOperations.radius(key, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)),
newGeoRadiusArgs().includeDistance().sortDescending())) //
geoOperations
.radius(key, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)),
newGeoRadiusArgs().includeDistance().sortDescending())
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getDistance().getValue()).isCloseTo(190.4424d, offset(0.005));
@@ -332,7 +344,7 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, member1).block();
geoOperations.add(key, POINT_CATANIA, member2).block();
StepVerifier.create(geoOperations.radius(key, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS)))) //
geoOperations.radius(key, new Circle(new Point(15D, 37D), new Distance(200D, KILOMETERS))).as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();
}
@@ -349,7 +361,7 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_CATANIA, member2).block();
geoOperations.add(key, POINT_ARIGENTO, member3).block();
StepVerifier.create(geoOperations.radius(key, member3, 100_000)) //
geoOperations.radius(key, member3, 100_000).as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getContent().getName()).isEqualTo(member3);
}) //
@@ -371,7 +383,7 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_CATANIA, member2).block();
geoOperations.add(key, POINT_ARIGENTO, member3).block();
StepVerifier.create(geoOperations.radius(key, member3, new Distance(100D, KILOMETERS))) //
geoOperations.radius(key, member3, new Distance(100D, KILOMETERS)).as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getContent().getName()).isEqualTo(member3);
}) //
@@ -393,9 +405,9 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_CATANIA, member2).block();
geoOperations.add(key, POINT_ARIGENTO, member3).block();
StepVerifier
.create(geoOperations.radius(key, member3, new Distance(100D, KILOMETERS),
newGeoRadiusArgs().includeDistance().sortDescending())) //
geoOperations
.radius(key, member3, new Distance(100D, KILOMETERS), newGeoRadiusArgs().includeDistance().sortDescending())
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.getDistance().getValue()).isCloseTo(90.9778, offset(0.005));
@@ -419,10 +431,12 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, member1).block();
geoOperations.add(key, POINT_CATANIA, member2).block();
StepVerifier.create(geoOperations.remove(key, member1)) //
geoOperations.remove(key, member1) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
StepVerifier.create(geoOperations.position(key, member1)) //
geoOperations.position(key, member1) //
.as(StepVerifier::create) //
.verifyComplete();
}
@@ -434,10 +448,12 @@ public class DefaultReactiveGeoOperationsIntegrationTests<K, V> {
geoOperations.add(key, POINT_PALERMO, member1).block();
StepVerifier.create(geoOperations.delete(key)) //
geoOperations.delete(key) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(geoOperations.position(key, member1)) //
geoOperations.position(key, member1) //
.as(StepVerifier::create) //
.verifyComplete();
}
}

78
src/test/java/org/springframework/data/redis/core/DefaultReactiveHashOperationsIntegrationTests.java
View File

@@ -125,7 +125,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
putAll(key, hashkey1, hashvalue1, hashkey2, hashvalue2);
StepVerifier.create(hashOperations.remove(key, hashkey1, hashkey2)) //
hashOperations.remove(key, hashkey1, hashkey2) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
}
@@ -137,15 +138,18 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
HK hashkey = hashKeyFactory.instance();
HV hashvalue = hashValueFactory.instance();
StepVerifier.create(hashOperations.put(key, hashkey, hashvalue)) //
hashOperations.put(key, hashkey, hashvalue) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.hasKey(key, hashkey)) //
hashOperations.hasKey(key, hashkey) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.hasKey(key, hashKeyFactory.instance())) //
hashOperations.hasKey(key, hashKeyFactory.instance()) //
.as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
}
@@ -157,11 +161,13 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
HK hashkey = hashKeyFactory.instance();
HV hashvalue = hashValueFactory.instance();
StepVerifier.create(hashOperations.put(key, hashkey, hashvalue)) //
hashOperations.put(key, hashkey, hashvalue) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.get(key, hashkey)) //
hashOperations.get(key, hashkey) //
.as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
}
@@ -216,15 +222,18 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
HK hashkey = hashKeyFactory.instance();
HV hashvalue = (HV) "1";
StepVerifier.create(hashOperations.put(key, hashkey, hashvalue)) //
hashOperations.put(key, hashkey, hashvalue) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.increment(key, hashkey, 1L)) //
hashOperations.increment(key, hashkey, 1L) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
StepVerifier.create(hashOperations.get(key, hashkey)) //
hashOperations.get(key, hashkey) //
.as(StepVerifier::create) //
.expectNext((HV) "2") //
.verifyComplete();
}
@@ -239,15 +248,18 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
HK hashkey = hashKeyFactory.instance();
HV hashvalue = (HV) "1";
StepVerifier.create(hashOperations.put(key, hashkey, hashvalue)) //
hashOperations.put(key, hashkey, hashvalue) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.increment(key, hashkey, 1.1d)) //
hashOperations.increment(key, hashkey, 1.1d) //
.as(StepVerifier::create) //
.expectNext(2.1d) //
.verifyComplete();
StepVerifier.create(hashOperations.get(key, hashkey)) //
hashOperations.get(key, hashkey) //
.as(StepVerifier::create) //
.expectNext((HV) "2.1") //
.verifyComplete();
}
@@ -266,7 +278,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
putAll(key, hashkey1, hashvalue1, hashkey2, hashvalue2);
StepVerifier.create(hashOperations.keys(key).buffer(2)) //
hashOperations.keys(key).buffer(2) //
.as(StepVerifier::create) //
.consumeNextWith(list -> assertThat(list).containsExactlyInAnyOrder(hashkey1, hashkey2)) //
.verifyComplete();
}
@@ -283,7 +296,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
putAll(key, hashkey1, hashvalue1, hashkey2, hashvalue2);
StepVerifier.create(hashOperations.size(key)) //
hashOperations.size(key) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
}
@@ -300,11 +314,13 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
putAll(key, hashkey1, hashvalue1, hashkey2, hashvalue2);
StepVerifier.create(hashOperations.hasKey(key, hashkey1)) //
hashOperations.hasKey(key, hashkey1) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.hasKey(key, hashkey2)) //
hashOperations.hasKey(key, hashkey2) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
}
@@ -316,7 +332,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
HK hashkey = hashKeyFactory.instance();
HV hashvalue = hashValueFactory.instance();
StepVerifier.create(hashOperations.put(key, hashkey, hashvalue)) //
hashOperations.put(key, hashkey, hashvalue) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
}
@@ -329,11 +346,13 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
HV hashvalue = hashValueFactory.instance();
HV hashvalue2 = hashValueFactory.instance();
StepVerifier.create(hashOperations.putIfAbsent(key, hashkey, hashvalue)) //
hashOperations.putIfAbsent(key, hashkey, hashvalue) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.putIfAbsent(key, hashkey, hashvalue2)) //
hashOperations.putIfAbsent(key, hashkey, hashvalue2) //
.as(StepVerifier::create) //
.expectNext(false) //
.verifyComplete();
}
@@ -352,7 +371,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
putAll(key, hashkey1, hashvalue1, hashkey2, hashvalue2);
StepVerifier.create(hashOperations.values(key)) //
hashOperations.values(key) //
.as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();
}
@@ -371,7 +391,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
putAll(key, hashkey1, hashvalue1, hashkey2, hashvalue2);
StepVerifier.create(hashOperations.entries(key).buffer(2)) //
hashOperations.entries(key).buffer(2) //
.as(StepVerifier::create) //
.consumeNextWith(list -> {
Entry<HK, HV> entry1 = Collections.singletonMap(hashkey1, hashvalue1).entrySet().iterator().next();
@@ -396,7 +417,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
putAll(key, hashkey1, hashvalue1, hashkey2, hashvalue2);
StepVerifier.create(hashOperations.scan(key).buffer(2)) //
hashOperations.scan(key).buffer(2) //
.as(StepVerifier::create) //
.consumeNextWith(list -> {
Entry<HK, HV> entry1 = Collections.singletonMap(hashkey1, hashvalue1).entrySet().iterator().next();
@@ -414,15 +436,18 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
HK hashkey = hashKeyFactory.instance();
HV hashvalue = hashValueFactory.instance();
StepVerifier.create(hashOperations.put(key, hashkey, hashvalue)) //
hashOperations.put(key, hashkey, hashvalue) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.delete(key)) //
hashOperations.delete(key) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(hashOperations.size(key)) //
hashOperations.size(key) //
.as(StepVerifier::create) //
.expectNext(0L) //
.verifyComplete();
}
@@ -433,7 +458,8 @@ public class DefaultReactiveHashOperationsIntegrationTests<K, HK, HV> {
map.put(hashkey1, hashvalue1);
map.put(hashkey2, hashvalue2);
StepVerifier.create(hashOperations.putAll(key, map)) //
hashOperations.putAll(key, map) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
}

18
src/test/java/org/springframework/data/redis/core/DefaultReactiveHyperLogLogOperationsIntegrationTests.java
View File

@@ -90,9 +90,9 @@ public class DefaultReactiveHyperLogLogOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(hyperLogLogOperations.add(key, value1, value2)).expectNext(1L).verifyComplete();
hyperLogLogOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(hyperLogLogOperations.size(key)).expectNext(2L).verifyComplete();
hyperLogLogOperations.size(key).as(StepVerifier::create).expectNext(2L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -107,11 +107,11 @@ public class DefaultReactiveHyperLogLogOperationsIntegrationTests<K, V> {
K key2 = keyFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(hyperLogLogOperations.add(key1, value1, sharedValue)).expectNext(1L).verifyComplete();
StepVerifier.create(hyperLogLogOperations.add(key2, value2, sharedValue)).expectNext(1L).verifyComplete();
hyperLogLogOperations.add(key1, value1, sharedValue).as(StepVerifier::create).expectNext(1L).verifyComplete();
hyperLogLogOperations.add(key2, value2, sharedValue).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(hyperLogLogOperations.union(mergedKey, key1, key2)).expectNext(true).verifyComplete();
StepVerifier.create(hyperLogLogOperations.size(mergedKey)).expectNext(3L).verifyComplete();
hyperLogLogOperations.union(mergedKey, key1, key2).as(StepVerifier::create).expectNext(true).verifyComplete();
hyperLogLogOperations.size(mergedKey).as(StepVerifier::create).expectNext(3L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -121,9 +121,9 @@ public class DefaultReactiveHyperLogLogOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(hyperLogLogOperations.add(key, value1, value2)).expectNext(1L).verifyComplete();
StepVerifier.create(hyperLogLogOperations.delete(key)).expectNext(true).verifyComplete();
hyperLogLogOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(1L).verifyComplete();
hyperLogLogOperations.delete(key).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(hyperLogLogOperations.size(key)).expectNext(0L).verifyComplete();
hyperLogLogOperations.size(key).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
}

142
src/test/java/org/springframework/data/redis/core/DefaultReactiveListOperationsIntegrationTests.java
View File

@@ -94,15 +94,18 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)) //
listOperations.rightPushAll(key, value1, value2) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
StepVerifier.create(listOperations.trim(key, 0, 0)) //
listOperations.trim(key, 0, 0) //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(listOperations.size(key)) //
listOperations.size(key) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
}
@@ -113,15 +116,18 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value1 = valueFactory.instance();
StepVerifier.create(listOperations.size(key)) //
listOperations.size(key) //
.as(StepVerifier::create) //
.expectNext(0L) //
.verifyComplete();
StepVerifier.create(listOperations.rightPush(key, value1)) //
listOperations.rightPush(key, value1) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
StepVerifier.create(listOperations.size(key)) //
listOperations.size(key) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
}
@@ -135,15 +141,18 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.leftPush(key, value1)) //
listOperations.leftPush(key, value1) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
StepVerifier.create(listOperations.leftPush(key, value2)) //
listOperations.leftPush(key, value2) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value2) //
.expectNext(value1) //
.verifyComplete();
@@ -158,11 +167,13 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.leftPushAll(key, value1, value2)) //
listOperations.leftPushAll(key, value1, value2) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value2) //
.expectNext(value1) //
.verifyComplete();
@@ -175,15 +186,18 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.leftPushIfPresent(key, value1)) //
listOperations.leftPushIfPresent(key, value1) //
.as(StepVerifier::create) //
.expectNext(0L) //
.verifyComplete();
StepVerifier.create(listOperations.leftPush(key, value1)) //
listOperations.leftPush(key, value1) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
StepVerifier.create(listOperations.leftPushIfPresent(key, value2)) //
listOperations.leftPushIfPresent(key, value2) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
}
@@ -198,15 +212,18 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value2 = valueFactory.instance();
V value3 = valueFactory.instance();
StepVerifier.create(listOperations.leftPushAll(key, value1, value2)) //
listOperations.leftPushAll(key, value1, value2) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
StepVerifier.create(listOperations.leftPush(key, value1, value3)) //
listOperations.leftPush(key, value1, value3) //
.as(StepVerifier::create) //
.expectNext(3L) //
.verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value2) //
.expectNext(value3) //
.expectNext(value1) //
@@ -222,14 +239,17 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPush(key, value1)) //
listOperations.rightPush(key, value1) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
StepVerifier.create(listOperations.rightPush(key, value2)) //
listOperations.rightPush(key, value2) //
.as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value1) //
.expectNext(value2) //
.verifyComplete();
@@ -244,9 +264,10 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value1) //
.expectNext(value2) //
.verifyComplete();
@@ -259,9 +280,9 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushIfPresent(key, value1)).expectNext(0L).verifyComplete();
StepVerifier.create(listOperations.rightPush(key, value1)).expectNext(1L).verifyComplete();
StepVerifier.create(listOperations.rightPushIfPresent(key, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushIfPresent(key, value1).as(StepVerifier::create).expectNext(0L).verifyComplete();
listOperations.rightPush(key, value1).as(StepVerifier::create).expectNext(1L).verifyComplete();
listOperations.rightPushIfPresent(key, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -274,11 +295,15 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value2 = valueFactory.instance();
V value3 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.rightPush(key, value1, value3)).expectNext(3L).verifyComplete();
listOperations.rightPush(key, value1, value3) //
.as(StepVerifier::create) //
.expectNext(3L) //
.verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value1) //
.expectNext(value3) //
.expectNext(value2) //
@@ -294,11 +319,12 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.set(key, 1, value1)).expectNext(true).verifyComplete();
listOperations.set(key, 1, value1).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value1) //
.expectNext(value1) //
.verifyComplete();
@@ -313,11 +339,15 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.remove(key, 1, value1)).expectNext(1L).verifyComplete();
listOperations.remove(key, 1, value1) //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
StepVerifier.create(listOperations.range(key, 0, -1)) //
listOperations.range(key, 0, -1) //
.as(StepVerifier::create) //
.expectNext(value2) //
.verifyComplete();
}
@@ -331,9 +361,9 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.index(key, 1)).expectNext(value2).verifyComplete();
listOperations.index(key, 1).as(StepVerifier::create).expectNext(value2).verifyComplete();
}
@Test // DATAREDIS-602
@@ -345,9 +375,9 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.leftPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.leftPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.leftPop(key)).expectNext(value2).verifyComplete();
listOperations.leftPop(key).as(StepVerifier::create).expectNext(value2).verifyComplete();
}
@Test // DATAREDIS-602
@@ -359,9 +389,9 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.rightPop(key)).expectNext(value2).verifyComplete();
listOperations.rightPop(key).as(StepVerifier::create).expectNext(value2).verifyComplete();
}
@Test // DATAREDIS-602
@@ -373,9 +403,9 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.leftPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.leftPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.leftPop(key, Duration.ZERO)).expectNext(value2).verifyComplete();
listOperations.leftPop(key, Duration.ZERO).as(StepVerifier::create).expectNext(value2).verifyComplete();
}
@Test(expected = IllegalArgumentException.class) // DATAREDIS-602
@@ -395,9 +425,9 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(listOperations.rightPushAll(key, value1, value2)).expectNext(2L).verifyComplete();
listOperations.rightPushAll(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(listOperations.rightPop(key, Duration.ZERO)).expectNext(value2).verifyComplete();
listOperations.rightPop(key, Duration.ZERO).as(StepVerifier::create).expectNext(value2).verifyComplete();
}
@Test // DATAREDIS-602
@@ -409,12 +439,12 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
K target = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(listOperations.rightPush(source, value)).expectNext(1L).verifyComplete();
listOperations.rightPush(source, value).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(listOperations.rightPopAndLeftPush(source, target)).expectNext(value).verifyComplete();
listOperations.rightPopAndLeftPush(source, target).as(StepVerifier::create).expectNext(value).verifyComplete();
StepVerifier.create(listOperations.size(source)).expectNext(0L).verifyComplete();
StepVerifier.create(listOperations.size(target)).expectNext(1L).verifyComplete();
listOperations.size(source).as(StepVerifier::create).expectNext(0L).verifyComplete();
listOperations.size(target).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -426,16 +456,16 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
K target = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(listOperations.rightPopAndLeftPush(source, target, Duration.ofSeconds(1))).expectComplete()
listOperations.rightPopAndLeftPush(source, target, Duration.ofSeconds(1)).as(StepVerifier::create).expectComplete()
.verify();
StepVerifier.create(listOperations.rightPush(source, value)).expectNext(1L).verifyComplete();
listOperations.rightPush(source, value).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(listOperations.rightPopAndLeftPush(source, target, Duration.ZERO)).expectNext(value)
listOperations.rightPopAndLeftPush(source, target, Duration.ZERO).as(StepVerifier::create).expectNext(value)
.verifyComplete();
StepVerifier.create(listOperations.size(source)).expectNext(0L).verifyComplete();
StepVerifier.create(listOperations.size(target)).expectNext(1L).verifyComplete();
listOperations.size(source).as(StepVerifier::create).expectNext(0L).verifyComplete();
listOperations.size(target).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -444,9 +474,9 @@ public class DefaultReactiveListOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value1 = valueFactory.instance();
StepVerifier.create(listOperations.rightPush(key, value1)).expectNext(1L).verifyComplete();
StepVerifier.create(listOperations.delete(key)).expectNext(true).verifyComplete();
listOperations.rightPush(key, value1).as(StepVerifier::create).expectNext(1L).verifyComplete();
listOperations.delete(key).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(listOperations.size(key)).expectNext(0L).verifyComplete();
listOperations.size(key).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
}

130
src/test/java/org/springframework/data/redis/core/DefaultReactiveSetOperationsIntegrationTests.java
View File

@@ -95,8 +95,8 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1)).expectNext(1L).verifyComplete();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(1L).verifyComplete();
setOperations.add(key, value1).as(StepVerifier::create).expectNext(1L).verifyComplete();
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -108,11 +108,11 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.size(key)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.remove(key, value2)).expectNext(1L).verifyComplete();
StepVerifier.create(setOperations.size(key)).expectNext(1L).verifyComplete();
StepVerifier.create(setOperations.remove(key, value1, value2)).expectNext(1L).verifyComplete();
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.size(key).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.remove(key, value2).as(StepVerifier::create).expectNext(1L).verifyComplete();
setOperations.size(key).as(StepVerifier::create).expectNext(1L).verifyComplete();
setOperations.remove(key, value1, value2).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -124,8 +124,8 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.pop(key)).consumeNextWith(actual -> {
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.pop(key).as(StepVerifier::create).consumeNextWith(actual -> {
assertThat(actual).isIn(value1, value2);
}).verifyComplete();
}
@@ -140,9 +140,9 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value2 = valueFactory.instance();
V value3 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2, value3)).expectNext(3L).verifyComplete();
StepVerifier.create(setOperations.pop(key, 2)).expectNextCount(2).verifyComplete();
StepVerifier.create(setOperations.size(key)).expectNext(1L).verifyComplete();
setOperations.add(key, value1, value2, value3).as(StepVerifier::create).expectNext(3L).verifyComplete();
setOperations.pop(key, 2).as(StepVerifier::create).expectNextCount(2).verifyComplete();
setOperations.size(key).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -153,10 +153,10 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.move(key, value1, otherKey)).expectNext(true).verifyComplete();
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.move(key, value1, otherKey).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(setOperations.size(otherKey)).expectNext(1L).verifyComplete();
setOperations.size(otherKey).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -168,8 +168,8 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.isMember(key, value1)).expectNext(true).verifyComplete();
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.isMember(key, value1).as(StepVerifier::create).expectNext(true).verifyComplete();
}
@Test // DATAREDIS-602, DATAREDIS-873
@@ -184,16 +184,16 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(setOperations.add(key, onlyInKey, shared)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.add(otherKey, onlyInOtherKey, shared)).expectNext(2L).verifyComplete();
setOperations.add(key, onlyInKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.add(otherKey, onlyInOtherKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.intersect(key, otherKey)) //
setOperations.intersect(key, otherKey).as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual).isEqualTo(shared);
}) //
.verifyComplete();
StepVerifier.create(setOperations.intersect(Arrays.asList(key, otherKey))) //
setOperations.intersect(Arrays.asList(key, otherKey)).as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual).isEqualTo(shared);
}) //
@@ -211,20 +211,20 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(setOperations.add(key, onlyInKey, shared)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.add(otherKey, onlyInOtherKey, shared)).expectNext(2L).verifyComplete();
setOperations.add(key, onlyInKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.add(otherKey, onlyInOtherKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.intersectAndStore(key, otherKey, destKey)).expectNext(1L).expectComplete()
setOperations.intersectAndStore(key, otherKey, destKey).as(StepVerifier::create).expectNext(1L).expectComplete()
.verify();
StepVerifier.create(setOperations.isMember(destKey, shared)).expectNext(true).verifyComplete();
setOperations.isMember(destKey, shared).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(setOperations.delete(destKey)).expectNext(true).verifyComplete();
setOperations.delete(destKey).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(setOperations.intersectAndStore(Arrays.asList(key, otherKey), destKey)).expectNext(1L)
.expectComplete().verify();
setOperations.intersectAndStore(Arrays.asList(key, otherKey), destKey).as(StepVerifier::create).expectNext(1L)
.verifyComplete();
StepVerifier.create(setOperations.isMember(destKey, shared)).expectNext(true).verifyComplete();
setOperations.isMember(destKey, shared).as(StepVerifier::create).expectNext(true).verifyComplete();
}
@Test // DATAREDIS-602, DATAREDIS-873
@@ -239,16 +239,16 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(setOperations.add(key, onlyInKey, shared)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.add(otherKey, onlyInOtherKey, shared)).expectNext(2L).verifyComplete();
setOperations.add(key, onlyInKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.add(otherKey, onlyInOtherKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.difference(key, otherKey)) //
setOperations.difference(key, otherKey).as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual).isEqualTo(onlyInKey);
}) //
.verifyComplete();
StepVerifier.create(setOperations.difference(Arrays.asList(key, otherKey))) //
setOperations.difference(Arrays.asList(key, otherKey)).as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual).isEqualTo(onlyInKey);
}) //
@@ -266,16 +266,16 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(setOperations.add(key, onlyInKey, shared)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.add(otherKey, onlyInOtherKey, shared)).expectNext(2L).verifyComplete();
setOperations.add(key, onlyInKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.add(otherKey, onlyInOtherKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.differenceAndStore(key, otherKey, destKey)).expectNext(1L).expectComplete()
setOperations.differenceAndStore(key, otherKey, destKey).as(StepVerifier::create).expectNext(1L).expectComplete()
.verify();
StepVerifier.create(setOperations.differenceAndStore(Arrays.asList(key, otherKey), destKey)).expectNext(1L)
.expectComplete().verify();
setOperations.differenceAndStore(Arrays.asList(key, otherKey), destKey).as(StepVerifier::create).expectNext(1L)
.verifyComplete();
StepVerifier.create(setOperations.isMember(destKey, onlyInKey)).expectNext(true).verifyComplete();
setOperations.isMember(destKey, onlyInKey).as(StepVerifier::create).expectNext(true).verifyComplete();
}
@Test // DATAREDIS-602, DATAREDIS-873
@@ -290,14 +290,16 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(setOperations.add(key, onlyInKey, shared)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.add(otherKey, onlyInOtherKey, shared)).expectNext(2L).verifyComplete();
setOperations.add(key, onlyInKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.add(otherKey, onlyInOtherKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.union(key, otherKey)) //
setOperations.union(key, otherKey) //
.as(StepVerifier::create) //
.expectNextCount(3) //
.verifyComplete();
StepVerifier.create(setOperations.union(Arrays.asList(key, otherKey))) //
setOperations.union(Arrays.asList(key, otherKey)) //
.as(StepVerifier::create) //
.expectNextCount(3) //
.verifyComplete();
}
@@ -313,19 +315,19 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(setOperations.add(key, onlyInKey, shared)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.add(otherKey, onlyInOtherKey, shared)).expectNext(2L).verifyComplete();
setOperations.add(key, onlyInKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.add(otherKey, onlyInOtherKey, shared).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.unionAndStore(key, otherKey, destKey)).expectNext(3L).verifyComplete();
setOperations.unionAndStore(key, otherKey, destKey).as(StepVerifier::create).expectNext(3L).verifyComplete();
StepVerifier.create(setOperations.delete(destKey)).expectNext(true).verifyComplete();
setOperations.delete(destKey).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(setOperations.unionAndStore(Arrays.asList(key, otherKey), destKey)).expectNext(3L)
setOperations.unionAndStore(Arrays.asList(key, otherKey), destKey).as(StepVerifier::create).expectNext(3L)
.verifyComplete();
StepVerifier.create(setOperations.isMember(destKey, onlyInKey)).expectNext(true).verifyComplete();
StepVerifier.create(setOperations.isMember(destKey, shared)).expectNext(true).verifyComplete();
StepVerifier.create(setOperations.isMember(destKey, onlyInOtherKey)).expectNext(true).verifyComplete();
setOperations.isMember(destKey, onlyInKey).as(StepVerifier::create).expectNext(true).verifyComplete();
setOperations.isMember(destKey, shared).as(StepVerifier::create).expectNext(true).verifyComplete();
setOperations.isMember(destKey, onlyInOtherKey).as(StepVerifier::create).expectNext(true).verifyComplete();
}
@Test // DATAREDIS-602
@@ -337,8 +339,8 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.members(key)) //
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
setOperations.members(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isIn(value1, value2)).expectNextCount(1).verifyComplete();
}
@@ -351,11 +353,11 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)) //
setOperations.add(key, value1, value2).as(StepVerifier::create) //
.expectNext(2L) //
.verifyComplete();
StepVerifier.create(setOperations.scan(key)) //
setOperations.scan(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isIn(value1, value2)) //
.expectNextCount(1) //
.verifyComplete();
@@ -370,9 +372,9 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.randomMember(key)).consumeNextWith(actual -> {
setOperations.randomMember(key).as(StepVerifier::create).consumeNextWith(actual -> {
assertThat(actual).isIn(value1, value2);
}).verifyComplete();
}
@@ -386,9 +388,9 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.randomMembers(key, 3)).expectNextCount(3).verifyComplete();
setOperations.randomMembers(key, 3).as(StepVerifier::create).expectNextCount(3).verifyComplete();
}
@Test // DATAREDIS-602
@@ -400,9 +402,9 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value1, value2)).expectNext(2L).verifyComplete();
setOperations.add(key, value1, value2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(setOperations.distinctRandomMembers(key, 2)) //
setOperations.distinctRandomMembers(key, 2).as(StepVerifier::create) //
.expectNextCount(2) //
.verifyComplete();
}
@@ -413,10 +415,10 @@ public class DefaultReactiveSetOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(setOperations.add(key, value)).expectNext(1L).verifyComplete();
setOperations.add(key, value).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(setOperations.delete(key)).expectNext(true).verifyComplete();
setOperations.delete(key).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(setOperations.size(key)).expectNext(0L).verifyComplete();
setOperations.size(key).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
}

150
src/test/java/org/springframework/data/redis/core/DefaultReactiveValueOperationsIntegrationTests.java
View File

@@ -107,9 +107,9 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.get(key)).expectNext(value).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext(value).verifyComplete();
}
@Test // DATAREDIS-602
@@ -118,12 +118,12 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.set(key, value, Duration.ofSeconds(10))).expectNext(true).expectComplete()
valueOperations.set(key, value, Duration.ofSeconds(10)).as(StepVerifier::create).expectNext(true).expectComplete()
.verify();
StepVerifier.create(valueOperations.get(key)).expectNext(value).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext(value).verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)) //
redisTemplate.getExpire(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isGreaterThan(Duration.ofSeconds(8))) //
.expectComplete() //
.verify();
@@ -135,9 +135,9 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.setIfAbsent(key, value)).expectNext(true).verifyComplete();
valueOperations.setIfAbsent(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.setIfAbsent(key, value)).expectNext(false).verifyComplete();
valueOperations.setIfAbsent(key, value).as(StepVerifier::create).expectNext(false).verifyComplete();
}
@Test // DATAREDIS-782
@@ -146,14 +146,14 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.setIfAbsent(key, value, Duration.ofSeconds(5))).expectNext(true)
valueOperations.setIfAbsent(key, value, Duration.ofSeconds(5)).as(StepVerifier::create).expectNext(true)
.expectComplete().verify();
StepVerifier.create(valueOperations.setIfAbsent(key, value)).expectNext(false).verifyComplete();
StepVerifier.create(valueOperations.setIfAbsent(key, value, Duration.ofSeconds(5))).expectNext(false)
valueOperations.setIfAbsent(key, value).as(StepVerifier::create).expectNext(false).verifyComplete();
valueOperations.setIfAbsent(key, value, Duration.ofSeconds(5)).as(StepVerifier::create).expectNext(false)
.verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)) //
redisTemplate.getExpire(key).as(StepVerifier::create) //
.assertNext(actual -> {
assertThat(actual).isBetween(Duration.ofMillis(1), Duration.ofSeconds(5));
@@ -167,13 +167,13 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
V value = valueFactory.instance();
V laterValue = valueFactory.instance();
StepVerifier.create(valueOperations.setIfPresent(key, value)).expectNext(false).verifyComplete();
valueOperations.setIfPresent(key, value).as(StepVerifier::create).expectNext(false).verifyComplete();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.setIfPresent(key, laterValue)).expectNext(true).verifyComplete();
valueOperations.setIfPresent(key, laterValue).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.get(key)).expectNext(laterValue).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext(laterValue).verifyComplete();
}
@Test // DATAREDIS-782
@@ -183,17 +183,17 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
V value = valueFactory.instance();
V laterValue = valueFactory.instance();
StepVerifier.create(valueOperations.setIfPresent(key, value, Duration.ofSeconds(5))).expectNext(false)
valueOperations.setIfPresent(key, value, Duration.ofSeconds(5)).as(StepVerifier::create).expectNext(false)
.verifyComplete();
StepVerifier.create(valueOperations.set(key, value, Duration.ofSeconds(5))).expectNext(true).verifyComplete();
valueOperations.set(key, value, Duration.ofSeconds(5)).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.setIfPresent(key, laterValue, Duration.ofSeconds(5))).expectNext(true)
valueOperations.setIfPresent(key, laterValue, Duration.ofSeconds(5)).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(valueOperations.get(key)).expectNext(laterValue).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext(laterValue).verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)) //
redisTemplate.getExpire(key).as(StepVerifier::create) //
.assertNext(actual -> {
assertThat(actual).isBetween(Duration.ofMillis(1), Duration.ofSeconds(5));
@@ -212,10 +212,10 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
map.put(key1, value1);
map.put(key2, value2);
StepVerifier.create(valueOperations.multiSet(map)).expectNext(true).verifyComplete();
valueOperations.multiSet(map).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.get(key1)).expectNext(value1).verifyComplete();
StepVerifier.create(valueOperations.get(key2)).expectNext(value2).verifyComplete();
valueOperations.get(key1).as(StepVerifier::create).expectNext(value1).verifyComplete();
valueOperations.get(key2).as(StepVerifier::create).expectNext(value2).verifyComplete();
}
@Test // DATAREDIS-602
@@ -230,13 +230,13 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
map.put(key1, value1);
StepVerifier.create(valueOperations.multiSetIfAbsent(map)).expectNext(true).verifyComplete();
valueOperations.multiSetIfAbsent(map).as(StepVerifier::create).expectNext(true).verifyComplete();
map.put(key2, value2);
StepVerifier.create(valueOperations.multiSetIfAbsent(map)).expectNext(false).verifyComplete();
valueOperations.multiSetIfAbsent(map).as(StepVerifier::create).expectNext(false).verifyComplete();
StepVerifier.create(valueOperations.get(key1)).expectNext(value1).verifyComplete();
StepVerifier.create(valueOperations.get(key2)).expectNextCount(0).verifyComplete();
valueOperations.get(key1).as(StepVerifier::create).expectNext(value1).verifyComplete();
valueOperations.get(key2).as(StepVerifier::create).expectNextCount(0).verifyComplete();
}
@Test // DATAREDIS-602
@@ -245,11 +245,11 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.get(key)).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).verifyComplete();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.get(key)).expectNext(value).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext(value).verifyComplete();
}
@Test // DATAREDIS-602
@@ -259,13 +259,13 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
V value = valueFactory.instance();
V nextValue = valueFactory.instance();
StepVerifier.create(valueOperations.getAndSet(key, nextValue)).verifyComplete();
valueOperations.getAndSet(key, nextValue).as(StepVerifier::create).verifyComplete();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.getAndSet(key, nextValue)).expectNext(value).verifyComplete();
valueOperations.getAndSet(key, nextValue).as(StepVerifier::create).expectNext(value).verifyComplete();
StepVerifier.create(valueOperations.get(key)).expectNext(nextValue).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext(nextValue).verifyComplete();
}
@Test // DATAREDIS-602
@@ -289,9 +289,9 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
map.put(key1, value1);
map.put(key2, value2);
StepVerifier.create(valueOperations.multiSet(map)).expectNext(true).verifyComplete();
valueOperations.multiSet(map).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.multiGet(Arrays.asList(key2, key1, absent)))
valueOperations.multiGet(Arrays.asList(key2, key1, absent)).as(StepVerifier::create)
.expectNext(Arrays.asList(value2, value1, absentValue)).verifyComplete();
}
@@ -303,11 +303,11 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.append(key, "foo")).expectNextCount(1).verifyComplete();
valueOperations.append(key, "foo").as(StepVerifier::create).expectNextCount(1).verifyComplete();
StepVerifier.create(valueOperations.get(key)).expectNext((V) (value + "foo")).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext((V) (value + "foo")).verifyComplete();
}
@Test // DATAREDIS-602
@@ -318,11 +318,11 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
String substring = value.toString().substring(1, 5);
StepVerifier.create(valueOperations.get(key, 1, 4)).expectNext(substring).verifyComplete();
valueOperations.get(key, 1, 4).as(StepVerifier::create).expectNext(substring).verifyComplete();
}
@Test // DATAREDIS-602
@@ -333,10 +333,10 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.set(key, (V) "boo", 2)).expectNextCount(1).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
valueOperations.set(key, (V) "boo", 2).as(StepVerifier::create).expectNextCount(1).verifyComplete();
StepVerifier.create(valueOperations.get(key)).consumeNextWith(actual -> {
valueOperations.get(key).as(StepVerifier::create).consumeNextWith(actual -> {
String string = (String) actual;
String prefix = value.toString().substring(0, 2);
@@ -353,8 +353,8 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.size(key)).expectNext((long) value.toString().length()).expectComplete()
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
valueOperations.size(key).as(StepVerifier::create).expectNext((long) value.toString().length()).expectComplete()
.verify();
}
@@ -363,8 +363,8 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(valueOperations.setBit(key, 0, true)).expectNext(false).expectComplete();
StepVerifier.create(valueOperations.setBit(key, 2, true)).expectNext(false).expectComplete();
valueOperations.setBit(key, 0, true).as(StepVerifier::create).expectNext(false).expectComplete();
valueOperations.setBit(key, 2, true).as(StepVerifier::create).expectNext(false).expectComplete();
}
@Test // DATAREDIS-602
@@ -372,9 +372,9 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(valueOperations.setBit(key, 0, true)).expectNext(false).expectComplete();
StepVerifier.create(valueOperations.getBit(key, 0)).expectNext(true).expectComplete();
StepVerifier.create(valueOperations.getBit(key, 1)).expectNext(false).expectComplete();
valueOperations.setBit(key, 0, true).as(StepVerifier::create).expectNext(false).expectComplete();
valueOperations.getBit(key, 0).as(StepVerifier::create).expectNext(true).expectComplete();
valueOperations.getBit(key, 1).as(StepVerifier::create).expectNext(false).expectComplete();
}
@Test // DATAREDIS-562
@@ -382,17 +382,17 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier
.create(valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(1L)).verifyComplete();
StepVerifier
.create(valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(2L)).verifyComplete();
StepVerifier
.create(valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(3L)).verifyComplete();
StepVerifier
.create(valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L)))
valueOperations.bitField(key, create().incr(unsigned(2)).valueAt(offset(102L)).overflow(FAIL).by(1L))
.as(StepVerifier::create)
.expectNext(Collections.singletonList(null)).verifyComplete();
}
@@ -402,11 +402,11 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.delete(key)).expectNext(true).verifyComplete();
valueOperations.delete(key).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.size(key)).expectNext(0L).verifyComplete();
valueOperations.size(key).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
@Test // DATAREDIS-784
@@ -414,9 +414,9 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(valueOperations.increment(key)).expectNext(1L).verifyComplete();
valueOperations.increment(key).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(valueOperations.increment(key)).expectNext(2L).verifyComplete();
valueOperations.increment(key).as(StepVerifier::create).expectNext(2L).verifyComplete();
}
@Test // DATAREDIS-784
@@ -424,11 +424,11 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(valueOperations.increment(key, 2L)).expectNext(2L).verifyComplete();
valueOperations.increment(key, 2L).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(valueOperations.increment(key, -3L)).expectNext(-1L).verifyComplete();
valueOperations.increment(key, -3L).as(StepVerifier::create).expectNext(-1L).verifyComplete();
StepVerifier.create(valueOperations.increment(key, 1L)).expectNext(0L).verifyComplete();
valueOperations.increment(key, 1L).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
@Test // DATAREDIS-784
@@ -436,11 +436,11 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(valueOperations.increment(key, 0.1)).expectNext(0.1).verifyComplete();
valueOperations.increment(key, 0.1).as(StepVerifier::create).expectNext(0.1).verifyComplete();
StepVerifier.create(valueOperations.increment(key, -0.3)).expectNext(-0.2).verifyComplete();
valueOperations.increment(key, -0.3).as(StepVerifier::create).expectNext(-0.2).verifyComplete();
StepVerifier.create(valueOperations.increment(key, 0.2)).expectNext(0.0).verifyComplete();
valueOperations.increment(key, 0.2).as(StepVerifier::create).expectNext(0.0).verifyComplete();
}
@Test // DATAREDIS-784
@@ -448,9 +448,9 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(valueOperations.decrement(key)).expectNext(-1L).verifyComplete();
valueOperations.decrement(key).as(StepVerifier::create).expectNext(-1L).verifyComplete();
StepVerifier.create(valueOperations.decrement(key)).expectNext(-2L).verifyComplete();
valueOperations.decrement(key).as(StepVerifier::create).expectNext(-2L).verifyComplete();
}
@Test // DATAREDIS-784
@@ -458,10 +458,10 @@ public class DefaultReactiveValueOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(valueOperations.decrement(key, 2L)).expectNext(-2L).verifyComplete();
valueOperations.decrement(key, 2L).as(StepVerifier::create).expectNext(-2L).verifyComplete();
StepVerifier.create(valueOperations.decrement(key, -3L)).expectNext(1L).verifyComplete();
valueOperations.decrement(key, -3L).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(valueOperations.decrement(key, 1L)).expectNext(0L).verifyComplete();
valueOperations.decrement(key, 1L).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
}

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

@@ -110,7 +110,7 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value, 42.1)).expectNext(true).verifyComplete();
zSetOperations.add(key, value, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
}
@Test // DATAREDIS-602
@@ -123,13 +123,13 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
List<DefaultTypedTuple<V>> tuples = Arrays.asList(new DefaultTypedTuple<>(value1, 42.1d),
new DefaultTypedTuple<>(value2, 10d));
StepVerifier.create(zSetOperations.addAll(key, tuples)).expectNext(2L).verifyComplete();
zSetOperations.addAll(key, tuples).as(StepVerifier::create).expectNext(2L).verifyComplete();
List<DefaultTypedTuple<V>> updated = Arrays.asList(new DefaultTypedTuple<>(value1, 52.1d),
new DefaultTypedTuple<>(value2, 10d));
StepVerifier.create(zSetOperations.addAll(key, updated)).expectNext(0L).verifyComplete();
StepVerifier.create(zSetOperations.score(key, value1)).expectNext(52.1d).verifyComplete();
zSetOperations.addAll(key, updated).as(StepVerifier::create).expectNext(0L).verifyComplete();
zSetOperations.score(key, value1).as(StepVerifier::create).expectNext(52.1d).verifyComplete();
}
@Test // DATAREDIS-602
@@ -138,11 +138,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value, 42.1)).expectNext(true).verifyComplete();
zSetOperations.add(key, value, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.remove(key, value)).expectNext(1L).verifyComplete();
zSetOperations.remove(key, value).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(zSetOperations.remove(key, value)).expectNext(0L).verifyComplete();
zSetOperations.remove(key, value).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -151,9 +151,9 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value, 42.1)).expectNext(true).verifyComplete();
zSetOperations.add(key, value, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.incrementScore(key, value, 1.1)).expectNext(43.2).verifyComplete();
zSetOperations.incrementScore(key, value, 1.1).as(StepVerifier::create).expectNext(43.2).verifyComplete();
}
@Test // DATAREDIS-602
@@ -163,10 +163,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.rank(key, value1)).expectNext(1L).verifyComplete();
zSetOperations.rank(key, value1).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -176,10 +176,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRank(key, value1)).expectNext(0L).verifyComplete();
zSetOperations.reverseRank(key, value1).as(StepVerifier::create).expectNext(0L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -191,10 +191,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.range(key, ZERO_RANGE)) //
zSetOperations.range(key, ZERO_RANGE).as(StepVerifier::create) //
.expectNext(value2) //
.verifyComplete();
@@ -209,10 +209,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.rangeWithScores(key, ZERO_RANGE)) //
zSetOperations.rangeWithScores(key, ZERO_RANGE).as(StepVerifier::create) //
.expectNext(new DefaultTypedTuple<>(value2, 10d)) //
.verifyComplete();
}
@@ -226,10 +226,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.rangeByScore(key, NINE_TO_ELEVEN_DOUBLE)) //
zSetOperations.rangeByScore(key, NINE_TO_ELEVEN_DOUBLE).as(StepVerifier::create) //
.expectNext(value2) //
.verifyComplete();
}
@@ -243,10 +243,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.rangeByScoreWithScores(key, NINE_TO_ELEVEN_DOUBLE)) //
zSetOperations.rangeByScoreWithScores(key, NINE_TO_ELEVEN_DOUBLE).as(StepVerifier::create) //
.expectNext(new DefaultTypedTuple<>(value2, 10d)) //
.verifyComplete();
}
@@ -260,11 +260,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.rangeByScore(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10))) //
zSetOperations.rangeByScore(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10)).as(StepVerifier::create) //
.expectNext(value1) //
.verifyComplete();
}
@@ -278,11 +278,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.rangeByScoreWithScores(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10))) //
zSetOperations.rangeByScoreWithScores(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10)).as(StepVerifier::create) //
.expectNext(new DefaultTypedTuple<>(value1, 42.1)) //
.verifyComplete();
}
@@ -296,10 +296,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRange(key, ZERO_RANGE)) //
zSetOperations.reverseRange(key, ZERO_RANGE).as(StepVerifier::create) //
.expectNext(value1) //
.verifyComplete();
@@ -314,10 +314,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRangeWithScores(key, ZERO_RANGE)) //
zSetOperations.reverseRangeWithScores(key, ZERO_RANGE).as(StepVerifier::create) //
.expectNext(new DefaultTypedTuple<>(value1, 42.1)) //
.verifyComplete();
}
@@ -331,10 +331,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRangeByScore(key, NINE_TO_ELEVEN_DOUBLE)) //
zSetOperations.reverseRangeByScore(key, NINE_TO_ELEVEN_DOUBLE).as(StepVerifier::create) //
.expectNext(value2) //
.verifyComplete();
}
@@ -348,10 +348,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRangeByScoreWithScores(key, NINE_TO_ELEVEN_DOUBLE)) //
zSetOperations.reverseRangeByScoreWithScores(key, NINE_TO_ELEVEN_DOUBLE).as(StepVerifier::create) //
.expectNext(new DefaultTypedTuple<>(value2, 10d)) //
.verifyComplete();
}
@@ -365,11 +365,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRangeByScore(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10))) //
zSetOperations.reverseRangeByScore(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10)).as(StepVerifier::create) //
.expectNext(value2) //
.verifyComplete();
}
@@ -383,11 +383,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRangeByScoreWithScores(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10))) //
zSetOperations.reverseRangeByScoreWithScores(key, ZERO_TO_HUNDRED_DOUBLE, //
Limit.limit().offset(1).count(10)).as(StepVerifier::create) //
.expectNext(new DefaultTypedTuple<>(value2, 10d)) //
.verifyComplete();
}
@@ -401,14 +401,14 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)) //
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)) //
zSetOperations.add(key, value2, 10).as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StepVerifier.create(zSetOperations.scan(key)) //
zSetOperations.scan(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isIn(new DefaultTypedTuple<>(value1, 42.1),
new DefaultTypedTuple<>(value2, 10d))) //
.expectNextCount(1) //
@@ -422,11 +422,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).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();
zSetOperations.count(key, ZERO_TO_HUNDRED_DOUBLE).as(StepVerifier::create).expectNext(2L).expectComplete().verify();
zSetOperations.count(key, Range.closed(0d, 10d)).as(StepVerifier::create).expectNext(1L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -436,10 +436,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.size(key)).expectNext(2L).verifyComplete();
zSetOperations.size(key).as(StepVerifier::create).expectNext(2L).verifyComplete();
}
@Test // DATAREDIS-602
@@ -449,11 +449,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.score(key, value1)).expectNext(42.1d).verifyComplete();
StepVerifier.create(zSetOperations.score(key, value2)).expectNext(10d).verifyComplete();
zSetOperations.score(key, value1).as(StepVerifier::create).expectNext(42.1d).verifyComplete();
zSetOperations.score(key, value2).as(StepVerifier::create).expectNext(10d).verifyComplete();
}
@Test // DATAREDIS-602
@@ -465,11 +465,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.removeRange(key, ZERO_RANGE)).expectNext(1L).verifyComplete();
StepVerifier.create(zSetOperations.range(key, ZERO_TO_FIVE)).expectNext(value1).verifyComplete();
zSetOperations.removeRange(key, ZERO_RANGE).as(StepVerifier::create).expectNext(1L).verifyComplete();
zSetOperations.range(key, ZERO_TO_FIVE).as(StepVerifier::create).expectNext(value1).verifyComplete();
}
@Test // DATAREDIS-602
@@ -481,12 +481,13 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V value1 = valueFactory.instance();
V value2 = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value1, 42.1)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, value2, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value1, 42.1).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, value2, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.removeRangeByScore(key, NINE_TO_ELEVEN_DOUBLE)).expectNext(1L).expectComplete()
zSetOperations.removeRangeByScore(key, NINE_TO_ELEVEN_DOUBLE).as(StepVerifier::create).expectNext(1L)
.expectComplete()
.verify();
StepVerifier.create(zSetOperations.range(key, ZERO_TO_FIVE)) //
zSetOperations.range(key, ZERO_TO_FIVE).as(StepVerifier::create) //
.expectNext(value1) //
.verifyComplete();
}
@@ -502,14 +503,14 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, onlyInKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, onlyInKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, onlyInOtherKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, onlyInOtherKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.unionAndStore(key, otherKey, destKey)).expectNext(3L).verifyComplete();
StepVerifier.create(zSetOperations.range(destKey, Range.closed(0L, 100L))).expectNextCount(3).verifyComplete();
zSetOperations.unionAndStore(key, otherKey, destKey).as(StepVerifier::create).expectNext(3L).verifyComplete();
zSetOperations.range(destKey, Range.closed(0L, 100L)).as(StepVerifier::create).expectNextCount(3).verifyComplete();
}
@Test // DATAREDIS-746
@@ -523,20 +524,20 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, onlyInKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, onlyInKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, onlyInOtherKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, onlyInOtherKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.unionAndStore(key, Collections.singleton(otherKey), destKey, Aggregate.SUM))
zSetOperations.unionAndStore(key, Collections.singleton(otherKey), destKey, Aggregate.SUM).as(StepVerifier::create)
.expectNext(3L).verifyComplete();
StepVerifier.create(zSetOperations.score(destKey, shared)).expectNext(22d).verifyComplete();
zSetOperations.score(destKey, shared).as(StepVerifier::create).expectNext(22d).verifyComplete();
StepVerifier.create(
zSetOperations.unionAndStore(key, Collections.singleton(otherKey), destKey, Aggregate.SUM, Weights.of(2, 1)))
zSetOperations.unionAndStore(key, Collections.singleton(otherKey), destKey, Aggregate.SUM, Weights.of(2, 1))
.as(StepVerifier::create)
.expectNext(3L).verifyComplete();
StepVerifier.create(zSetOperations.score(destKey, shared)).expectNext(33d).verifyComplete();
zSetOperations.score(destKey, shared).as(StepVerifier::create).expectNext(33d).verifyComplete();
}
@Test // DATAREDIS-602
@@ -550,16 +551,16 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, onlyInKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, onlyInKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, onlyInOtherKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, onlyInOtherKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.intersectAndStore(key, otherKey, destKey)).expectNext(1L).expectComplete()
zSetOperations.intersectAndStore(key, otherKey, destKey).as(StepVerifier::create).expectNext(1L).expectComplete()
.verify();
StepVerifier.create(zSetOperations.range(destKey, ZERO_TO_FIVE)) //
zSetOperations.range(destKey, ZERO_TO_FIVE).as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
}
@@ -575,24 +576,24 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V shared = valueFactory.instance();
V onlyInOtherKey = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, onlyInKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, onlyInKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, onlyInOtherKey, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(otherKey, shared, 11)).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, onlyInOtherKey, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(otherKey, shared, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier
.create(zSetOperations.intersectAndStore(key, Collections.singletonList(otherKey), destKey, Aggregate.SUM))
zSetOperations.intersectAndStore(key, Collections.singletonList(otherKey), destKey, Aggregate.SUM)
.as(StepVerifier::create)
.expectNext(1L).expectComplete().verify();
StepVerifier.create(zSetOperations.score(destKey, shared)) //
zSetOperations.score(destKey, shared).as(StepVerifier::create) //
.expectNext(22d) //
.verifyComplete();
StepVerifier.create(zSetOperations.intersectAndStore(key, Collections.singletonList(otherKey), destKey,
Aggregate.SUM, Weights.of(1, 2))).expectNext(1L).expectComplete().verify();
zSetOperations.intersectAndStore(key, Collections.singletonList(otherKey), destKey, Aggregate.SUM, Weights.of(1, 2))
.as(StepVerifier::create).expectNext(1L).expectComplete().verify();
StepVerifier.create(zSetOperations.score(destKey, shared)) //
zSetOperations.score(destKey, shared).as(StepVerifier::create) //
.expectNext(33d) //
.verifyComplete();
}
@@ -606,10 +607,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V a = (V) "a";
V b = (V) "b";
StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, a, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.rangeByLex(key, Range.just("a"))) //
zSetOperations.rangeByLex(key, Range.just("a")).as(StepVerifier::create) //
.expectNext(a) //
.verifyComplete();
@@ -624,16 +625,16 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V a = (V) "a";
V b = (V) "b";
StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, a, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
Range<String> aToZ = Range.closed("a", "z");
StepVerifier.create(zSetOperations.rangeByLex(key, aToZ, Limit.limit().offset(0).count(10))) //
zSetOperations.rangeByLex(key, aToZ, Limit.limit().offset(0).count(10)).as(StepVerifier::create) //
.expectNext(a, b) //
.verifyComplete();
StepVerifier.create(zSetOperations.rangeByLex(key, aToZ, Limit.limit().offset(1).count(10))) //
zSetOperations.rangeByLex(key, aToZ, Limit.limit().offset(1).count(10)).as(StepVerifier::create) //
.expectNext(b) //
.verifyComplete();
}
@@ -647,10 +648,10 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V a = (V) "a";
V b = (V) "b";
StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, a, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.reverseRangeByLex(key, Range.just("a"))) //
zSetOperations.reverseRangeByLex(key, Range.just("a")).as(StepVerifier::create) //
.expectNext(a) //
.verifyComplete();
}
@@ -664,16 +665,16 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
V a = (V) "a";
V b = (V) "b";
StepVerifier.create(zSetOperations.add(key, a, 10)).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.add(key, b, 11)).expectNext(true).verifyComplete();
zSetOperations.add(key, a, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
zSetOperations.add(key, b, 11).as(StepVerifier::create).expectNext(true).verifyComplete();
Range<String> aToZ = Range.closed("a", "z");
StepVerifier.create(zSetOperations.reverseRangeByLex(key, aToZ, Limit.limit().offset(0).count(10))) //
zSetOperations.reverseRangeByLex(key, aToZ, Limit.limit().offset(0).count(10)).as(StepVerifier::create) //
.expectNext(b, a) //
.verifyComplete();
StepVerifier.create(zSetOperations.reverseRangeByLex(key, aToZ, Limit.limit().offset(1).count(10))) //
zSetOperations.reverseRangeByLex(key, aToZ, Limit.limit().offset(1).count(10)).as(StepVerifier::create) //
.expectNext(a) //
.verifyComplete();
}
@@ -684,11 +685,11 @@ public class DefaultReactiveZSetOperationsIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(zSetOperations.add(key, value, 10)).expectNext(true).verifyComplete();
zSetOperations.add(key, value, 10).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.delete(key)).expectNext(true).verifyComplete();
zSetOperations.delete(key).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(zSetOperations.size(key)) //
zSetOperations.size(key).as(StepVerifier::create) //
.expectNext(0L) //
.verifyComplete();
}

128
src/test/java/org/springframework/data/redis/core/ReactiveRedisTemplateIntegrationTests.java
View File

@@ -111,12 +111,12 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(redisTemplate.hasKey(key)).expectNext(false).verifyComplete();
redisTemplate.hasKey(key).as(StepVerifier::create).expectNext(false).verifyComplete();
StepVerifier.create(redisTemplate.opsForValue().set(key, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key)).expectNext(true).verifyComplete();
redisTemplate.hasKey(key).as(StepVerifier::create).expectNext(true).verifyComplete();
}
@Test // DATAREDIS-743
@@ -129,9 +129,9 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
tuples.put(keyFactory.instance(), valueFactory.instance());
tuples.put(keyFactory.instance(), valueFactory.instance());
StepVerifier.create(redisTemplate.opsForValue().multiSet(tuples)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().multiSet(tuples).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.scan().collectList()) //
redisTemplate.scan().collectList().as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).containsAll(tuples.keySet())) //
.verifyComplete();
}
@@ -141,12 +141,12 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(redisTemplate.type(key)).expectNext(DataType.NONE).verifyComplete();
redisTemplate.type(key).as(StepVerifier::create).expectNext(DataType.NONE).verifyComplete();
StepVerifier.create(redisTemplate.opsForValue().set(key, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.type(key)).expectNext(DataType.STRING).verifyComplete();
redisTemplate.type(key).as(StepVerifier::create).expectNext(DataType.STRING).verifyComplete();
}
@Test // DATAREDIS-602
@@ -155,10 +155,10 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K oldName = keyFactory.instance();
K newName = keyFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(oldName, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(oldName, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.rename(oldName, newName)) //
redisTemplate.rename(oldName, newName).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
@@ -171,20 +171,20 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K existing = keyFactory.instance();
K newName = keyFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(oldName, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(oldName, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.opsForValue().set(existing, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(existing, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.renameIfAbsent(oldName, newName)) //
redisTemplate.renameIfAbsent(oldName, newName).as(StepVerifier::create) //
.expectNext(true) //
.expectComplete() //
.verify();
StepVerifier.create(redisTemplate.opsForValue().set(existing, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(existing, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.renameIfAbsent(newName, existing)).expectNext(false) //
redisTemplate.renameIfAbsent(newName, existing).as(StepVerifier::create).expectNext(false) //
.expectComplete() //
.verify();
}
@@ -194,12 +194,12 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K single = keyFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(single, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(single, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.unlink(single)).expectNext(1L).verifyComplete();
redisTemplate.unlink(single).as(StepVerifier::create).expectNext(1L).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(single)).expectNext(false).verifyComplete();
redisTemplate.hasKey(single).as(StepVerifier::create).expectNext(false).verifyComplete();
}
@Test // DATAREDIS-693
@@ -208,15 +208,15 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key1 = keyFactory.instance();
K key2 = keyFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(key1, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key1, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.opsForValue().set(key2, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key2, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.unlink(key1, key2)).expectNext(2L).verifyComplete();
redisTemplate.unlink(key1, key2).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key1)).expectNext(false).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key2)).expectNext(false).verifyComplete();
redisTemplate.hasKey(key1).as(StepVerifier::create).expectNext(false).verifyComplete();
redisTemplate.hasKey(key2).as(StepVerifier::create).expectNext(false).verifyComplete();
}
@Test // DATAREDIS-913
@@ -227,15 +227,15 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
assumeTrue(key1 instanceof String && valueFactory instanceof StringObjectFactory);
StepVerifier.create(redisTemplate.opsForValue().set(key1, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key1, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.opsForValue().set(key2, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key2, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.unlink(redisTemplate.keys((K) "*"))).expectNext(2L).verifyComplete();
redisTemplate.unlink(redisTemplate.keys((K) "*")).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key1)).expectNext(false).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key2)).expectNext(false).verifyComplete();
redisTemplate.hasKey(key1).as(StepVerifier::create).expectNext(false).verifyComplete();
redisTemplate.hasKey(key2).as(StepVerifier::create).expectNext(false).verifyComplete();
}
@Test // DATAREDIS-913
@@ -246,15 +246,15 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
assumeTrue(key1 instanceof String && valueFactory instanceof StringObjectFactory);
StepVerifier.create(redisTemplate.opsForValue().set(key1, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key1, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.opsForValue().set(key2, valueFactory.instance())).expectNext(true)
redisTemplate.opsForValue().set(key2, valueFactory.instance()).as(StepVerifier::create).expectNext(true)
.verifyComplete();
StepVerifier.create(redisTemplate.delete(redisTemplate.keys((K) "*"))).expectNext(2L).verifyComplete();
redisTemplate.delete(redisTemplate.keys((K) "*")).as(StepVerifier::create).expectNext(2L).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key1)).expectNext(false).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key2)).expectNext(false).verifyComplete();
redisTemplate.hasKey(key1).as(StepVerifier::create).expectNext(false).verifyComplete();
redisTemplate.hasKey(key2).as(StepVerifier::create).expectNext(false).verifyComplete();
}
@Test // DATAREDIS-683
@@ -266,13 +266,13 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
assumeFalse(value instanceof Long);
StepVerifier.create(redisTemplate.opsForValue().set(key, value)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
Flux<V> execute = redisTemplate.execute(
new DefaultRedisScript<>("return redis.call('get', KEYS[1])", (Class<V>) value.getClass()),
Collections.singletonList(key));
StepVerifier.create(execute).expectNext(value).verifyComplete();
execute.as(StepVerifier::create).expectNext(value).verifyComplete();
}
@Test // DATAREDIS-683
@@ -287,17 +287,17 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
assumeFalse(value instanceof Long);
Person person = new Person("Walter", "White", 51);
StepVerifier
.create(
redisTemplate.execute(new DefaultRedisScript<>("return redis.call('set', KEYS[1], ARGV[1])", String.class),
Collections.singletonList(key), Collections.singletonList(person), json.getWriter(), resultReader))
redisTemplate
.execute(new DefaultRedisScript<>("return redis.call('set', KEYS[1], ARGV[1])", String.class),
Collections.singletonList(key), Collections.singletonList(person), json.getWriter(), resultReader)
.as(StepVerifier::create)
.expectNext("OK").verifyComplete();
Flux<Person> execute = redisTemplate.execute(
new DefaultRedisScript<>("return redis.call('get', KEYS[1])", Person.class), Collections.singletonList(key),
Collections.emptyList(), json.getWriter(), json.getReader());
StepVerifier.create(execute).expectNext(person).verifyComplete();
execute.as(StepVerifier::create).expectNext(person).verifyComplete();
}
@Test // DATAREDIS-602
@@ -306,11 +306,11 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(key, value)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.expire(key, Duration.ofSeconds(10))).expectNext(true).verifyComplete();
redisTemplate.expire(key, Duration.ofSeconds(10)).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)) //
redisTemplate.getExpire(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isGreaterThan(Duration.ofSeconds(8))).verifyComplete();
}
@@ -320,11 +320,11 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(key, value)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.expire(key, Duration.ofMillis(10_001))).expectNext(true).verifyComplete();
redisTemplate.expire(key, Duration.ofMillis(10_001)).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)) //
redisTemplate.getExpire(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isGreaterThan(Duration.ofSeconds(8))).verifyComplete();
}
@@ -334,13 +334,13 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(key, value)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
Instant expireAt = Instant.ofEpochSecond(Instant.now().plus(Duration.ofSeconds(10)).getEpochSecond());
StepVerifier.create(redisTemplate.expireAt(key, expireAt)).expectNext(true).verifyComplete();
redisTemplate.expireAt(key, expireAt).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)) //
redisTemplate.getExpire(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isGreaterThan(Duration.ofSeconds(8))) //
.verifyComplete();
}
@@ -351,13 +351,13 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(key, value)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
Instant expireAt = Instant.ofEpochSecond(Instant.now().plus(Duration.ofSeconds(10)).getEpochSecond(), 5);
StepVerifier.create(redisTemplate.expireAt(key, expireAt)).expectNext(true).verifyComplete();
redisTemplate.expireAt(key, expireAt).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)) //
redisTemplate.getExpire(key).as(StepVerifier::create) //
.consumeNextWith(actual -> assertThat(actual).isGreaterThan(Duration.ofSeconds(8))) //
.verifyComplete();
}
@@ -367,7 +367,7 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
StepVerifier.create(redisTemplate.getExpire(key)).verifyComplete();
redisTemplate.getExpire(key).as(StepVerifier::create).verifyComplete();
}
@Test // DATAREDIS-602
@@ -376,9 +376,9 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(key, value)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.getExpire(key)).expectNext(Duration.ZERO).verifyComplete();
redisTemplate.getExpire(key).as(StepVerifier::create).expectNext(Duration.ZERO).verifyComplete();
}
@Test // DATAREDIS-602
@@ -397,11 +397,11 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
K key = keyFactory.instance();
V value = valueFactory.instance();
StepVerifier.create(redisTemplate.opsForValue().set(key, value)).expectNext(true).verifyComplete();
redisTemplate.opsForValue().set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.move(key, 5)).expectNext(true).verifyComplete();
redisTemplate.move(key, 5).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(redisTemplate.hasKey(key)).expectNext(false).verifyComplete();
redisTemplate.hasKey(key).as(StepVerifier::create).expectNext(false).verifyComplete();
}
@Test // DATAREDIS-602
@@ -420,9 +420,9 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
ReactiveValueOperations<Object, Object> valueOperations = redisTemplate.opsForValue(objectSerializers);
StepVerifier.create(valueOperations.set(key, value)).expectNext(true).verifyComplete();
valueOperations.set(key, value).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(valueOperations.get(key)).expectNext(value).verifyComplete();
valueOperations.get(key).as(StepVerifier::create).expectNext(value).verifyComplete();
}
@Test // DATAREDIS-602
@@ -443,9 +443,9 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
ReactiveHashOperations<K, String, Object> hashOperations = redisTemplate.opsForHash(objectSerializers);
StepVerifier.create(hashOperations.put(key, hashField, hashValue)).expectNext(true).verifyComplete();
hashOperations.put(key, hashField, hashValue).as(StepVerifier::create).expectNext(true).verifyComplete();
StepVerifier.create(hashOperations.get(key, hashField)).expectNext(hashValue).verifyComplete();
hashOperations.get(key, hashField).as(StepVerifier::create).expectNext(hashValue).verifyComplete();
}
@Test // DATAREDIS-612
@@ -455,7 +455,7 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
V message = valueFactory.instance();
StepVerifier.create(redisTemplate.listenToChannel(channel)) //
redisTemplate.listenToChannel(channel).as(StepVerifier::create) //
.thenAwait(Duration.ofMillis(500)) // just make sure we the subscription completed
.then(() -> redisTemplate.convertAndSend(channel, message).block()) //
.assertNext(received -> {
@@ -479,7 +479,7 @@ public class ReactiveRedisTemplateIntegrationTests<K, V> {
Flux<? extends Message<String, V>> stream = redisTemplate.listenToPattern(pattern);
StepVerifier.create(stream) //
stream.as(StepVerifier::create) //
.thenAwait(Duration.ofMillis(500)) // just make sure we the subscription completed
.then(() -> redisTemplate.convertAndSend(channel, message).block()) //
.assertNext(received -> {

6
src/test/java/org/springframework/data/redis/core/ReactiveStringRedisTemplateIntegrationTests.java
View File

@@ -53,14 +53,14 @@ public class ReactiveStringRedisTemplateIntegrationTests {
template = new ReactiveStringRedisTemplate(connectionFactory);
StepVerifier.create(template.execute(connection -> connection.serverCommands().flushDb())).expectNext("OK")
template.execute(connection -> connection.serverCommands().flushDb()).as(StepVerifier::create).expectNext("OK")
.verifyComplete();
}
@Test // DATAREDIS-643
public void shouldSetAndGetKeys() {
StepVerifier.create(template.opsForValue().set("key", "value")).expectNext(true).verifyComplete();
StepVerifier.create(template.opsForValue().get("key")).expectNext("value").verifyComplete();
template.opsForValue().set("key", "value").as(StepVerifier::create).expectNext(true).verifyComplete();
template.opsForValue().get("key").as(StepVerifier::create).expectNext("value").verifyComplete();
}
}

22
src/test/java/org/springframework/data/redis/core/script/DefaultReactiveScriptExecutorTests.java
View File

@@ -99,11 +99,11 @@ public class DefaultReactiveScriptExecutorTests {
script.setLocation(new ClassPathResource("org/springframework/data/redis/core/script/increment.lua"));
script.setResultType(Long.class);
StepVerifier.create(stringScriptExecutor.execute(script, Collections.singletonList("mykey"))).verifyComplete();
stringScriptExecutor.execute(script, Collections.singletonList("mykey")).as(StepVerifier::create).verifyComplete();
stringTemplate.opsForValue().set("mykey", "2");
StepVerifier.create(stringScriptExecutor.execute(script, Collections.singletonList("mykey"))).expectNext(3L)
stringScriptExecutor.execute(script, Collections.singletonList("mykey")).as(StepVerifier::create).expectNext(3L)
.verifyComplete();
}
@@ -123,10 +123,10 @@ public class DefaultReactiveScriptExecutorTests {
stringTemplate.opsForValue().set("counter", "0");
StepVerifier.create(scriptExecutor.execute(script, Collections.singletonList("counter"), Arrays.asList(0, 3)))
scriptExecutor.execute(script, Collections.singletonList("counter"), Arrays.asList(0, 3)).as(StepVerifier::create)
.expectNext(true).verifyComplete();
StepVerifier.create(scriptExecutor.execute(script, Collections.singletonList("counter"), Arrays.asList(0, 3)))
scriptExecutor.execute(script, Collections.singletonList("counter"), Arrays.asList(0, 3)).as(StepVerifier::create)
.expectNext(false).verifyComplete();
}
@@ -144,7 +144,7 @@ public class DefaultReactiveScriptExecutorTests {
Collections.singletonList(1L), RedisElementWriter.from(new GenericToStringSerializer<>(Long.class)),
(RedisElementReader) RedisElementReader.from(StringRedisSerializer.UTF_8));
StepVerifier.create(mylist).expectNext(Collections.singletonList("a")).verifyComplete();
mylist.as(StepVerifier::create).expectNext(Collections.singletonList("a")).verifyComplete();
}
@Test // DATAREDIS-711
@@ -154,12 +154,12 @@ public class DefaultReactiveScriptExecutorTests {
script.setLocation(new ClassPathResource("org/springframework/data/redis/core/script/popandlength.lua"));
script.setResultType(List.class);
StepVerifier.create(stringScriptExecutor.execute(script, Collections.singletonList("mylist")))
stringScriptExecutor.execute(script, Collections.singletonList("mylist")).as(StepVerifier::create)
.expectNext(Arrays.asList(null, 0L)).verifyComplete();
stringTemplate.boundListOps("mylist").leftPushAll("a", "b");
StepVerifier.create(stringScriptExecutor.execute(script, Collections.singletonList("mylist")))
stringScriptExecutor.execute(script, Collections.singletonList("mylist")).as(StepVerifier::create)
.expectNext(Arrays.asList("a", 1L)).verifyComplete();
}
@@ -174,7 +174,7 @@ public class DefaultReactiveScriptExecutorTests {
Flux<String> foo = stringScriptExecutor.execute(script, Collections.singletonList("foo"));
StepVerifier.create(foo).expectNext("bar").expectNext();
foo.as(StepVerifier::create).expectNext("bar").expectNext();
}
@Test // DATAREDIS-711
@@ -217,7 +217,7 @@ public class DefaultReactiveScriptExecutorTests {
Collections.singletonList(joe), RedisElementWriter.from(personSerializer),
RedisElementReader.from(StringRedisSerializer.UTF_8));
StepVerifier.create(result).expectNext("FOO").verifyComplete();
result.as(StepVerifier::create).expectNext("FOO").verifyComplete();
assertThat(template.opsForValue().get("bar")).isEqualTo(joe);
}
@@ -235,14 +235,14 @@ public class DefaultReactiveScriptExecutorTests {
(RedisCallback<List<Boolean>>) connection -> connection.scriptingCommands().scriptExists(script.getSha1())))
.containsExactly(false);
StepVerifier.create(stringScriptExecutor.execute(script, Collections.emptyList())).expectNext("HELLO")
stringScriptExecutor.execute(script, Collections.emptyList()).as(StepVerifier::create).expectNext("HELLO")
.verifyComplete();
assertThat(stringTemplate.execute(
(RedisCallback<List<Boolean>>) connection -> connection.scriptingCommands().scriptExists(script.getSha1())))
.containsExactly(true);
StepVerifier.create(stringScriptExecutor.execute(script, Collections.emptyList())).expectNext("HELLO")
stringScriptExecutor.execute(script, Collections.emptyList()).as(StepVerifier::create).expectNext("HELLO")
.verifyComplete();
}
}

8
src/test/java/org/springframework/data/redis/listener/ReactiveRedisMessageListenerContainerIntegrationTests.java
View File

@@ -98,7 +98,7 @@ public class ReactiveRedisMessageListenerContainerIntegrationTests {
ReactiveRedisMessageListenerContainer container = new ReactiveRedisMessageListenerContainer(connectionFactory);
StepVerifier.create(container.receive(ChannelTopic.of(CHANNEL1))) //
container.receive(ChannelTopic.of(CHANNEL1)).as(StepVerifier::create) //
.then(awaitSubscription(container::getActiveSubscriptions))
.then(() -> connection.publish(CHANNEL1.getBytes(), MESSAGE.getBytes())) //
.assertNext(c -> {
@@ -116,7 +116,7 @@ public class ReactiveRedisMessageListenerContainerIntegrationTests {
ReactiveRedisMessageListenerContainer container = new ReactiveRedisMessageListenerContainer(connectionFactory);
StepVerifier.create(container.receive(PatternTopic.of(PATTERN1))) //
container.receive(PatternTopic.of(PATTERN1)).as(StepVerifier::create) //
.then(awaitSubscription(container::getActiveSubscriptions))
.then(() -> connection.publish(CHANNEL1.getBytes(), MESSAGE.getBytes())) //
.assertNext(c -> {
@@ -162,7 +162,7 @@ public class ReactiveRedisMessageListenerContainerIntegrationTests {
ReactiveRedisTemplate<String, String> template = new ReactiveRedisTemplate<>(connectionFactory,
RedisSerializationContext.string());
StepVerifier.create(template.listenToChannel(CHANNEL1)) //
template.listenToChannel(CHANNEL1).as(StepVerifier::create) //
.thenAwait(Duration.ofMillis(100)) // just make sure we the subscription completed
.then(() -> connection.publish(CHANNEL1.getBytes(), MESSAGE.getBytes())) //
.assertNext(message -> {
@@ -181,7 +181,7 @@ public class ReactiveRedisMessageListenerContainerIntegrationTests {
ReactiveRedisTemplate<String, String> template = new ReactiveRedisTemplate<>(connectionFactory,
RedisSerializationContext.string());
StepVerifier.create(template.listenToPattern(PATTERN1)) //
template.listenToPattern(PATTERN1).as(StepVerifier::create) //
.thenAwait(Duration.ofMillis(100)) // just make sure we the subscription completed
.then(() -> connection.publish(CHANNEL1.getBytes(), MESSAGE.getBytes())) //
.assertNext(message -> {

19
src/test/java/org/springframework/data/redis/listener/ReactiveRedisMessageListenerContainerUnitTests.java
View File

@@ -76,7 +76,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
container = createContainer();
StepVerifier.create(container.receive(PatternTopic.of("foo*"))).thenAwait().thenCancel().verify();
container.receive(PatternTopic.of("foo*")).as(StepVerifier::create).thenAwait().thenCancel().verify();
verify(subscriptionMock).pSubscribe(getByteBuffer("foo*"));
}
@@ -87,7 +87,8 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
when(subscriptionMock.receive()).thenReturn(Flux.never());
container = createContainer();
StepVerifier.create(container.receive(PatternTopic.of("foo*"), PatternTopic.of("bar*"))).thenRequest(1).thenAwait()
container.receive(PatternTopic.of("foo*"), PatternTopic.of("bar*")).as(StepVerifier::create).thenRequest(1)
.thenAwait()
.thenCancel().verify();
verify(subscriptionMock).pSubscribe(getByteBuffer("foo*"), getByteBuffer("bar*"));
@@ -99,7 +100,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
when(subscriptionMock.receive()).thenReturn(Flux.never());
container = createContainer();
StepVerifier.create(container.receive(ChannelTopic.of("foo"))).thenAwait().thenCancel().verify();
container.receive(ChannelTopic.of("foo")).as(StepVerifier::create).thenAwait().thenCancel().verify();
verify(subscriptionMock).subscribe(getByteBuffer("foo"));
}
@@ -110,7 +111,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
when(subscriptionMock.receive()).thenReturn(Flux.never());
container = createContainer();
StepVerifier.create(container.receive(ChannelTopic.of("foo"), ChannelTopic.of("bar"))).thenAwait().thenCancel()
container.receive(ChannelTopic.of("foo"), ChannelTopic.of("bar")).as(StepVerifier::create).thenAwait().thenCancel()
.verify();
verify(subscriptionMock).subscribe(getByteBuffer("foo"), getByteBuffer("bar"));
@@ -126,7 +127,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
Flux<Message<String, String>> messageStream = container.receive(ChannelTopic.of("foo"));
StepVerifier.create(messageStream).then(() -> {
messageStream.as(StepVerifier::create).then(() -> {
processor.onNext(createChannelMessage("foo", "message"));
}).assertNext(msg -> {
@@ -145,7 +146,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
Flux<PatternMessage<String, String, String>> messageStream = container.receive(PatternTopic.of("foo*"));
StepVerifier.create(messageStream).then(() -> {
messageStream.as(StepVerifier::create).then(() -> {
processor.onNext(createPatternMessage("foo*", "foo", "message"));
}).assertNext(msg -> {
@@ -210,7 +211,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
Flux<PatternMessage<String, String, String>> messageStream = container.receive(PatternTopic.of("foo*"));
StepVerifier.create(messageStream).then(() -> {
messageStream.as(StepVerifier::create).then(() -> {
// Then required to trigger cancel.
@@ -234,7 +235,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
Flux<PatternMessage<String, String, String>> messageStream = container.receive(PatternTopic.of("foo*"));
StepVerifier.create(messageStream).then(() -> {
messageStream.as(StepVerifier::create).then(() -> {
container.destroy();
}).verifyError(CancellationException.class);
}
@@ -249,7 +250,7 @@ public class ReactiveRedisMessageListenerContainerUnitTests {
Flux<PatternMessage<String, String, String>> messageStream = container.receive(PatternTopic.of("foo*"));
StepVerifier.create(messageStream).then(() -> {
messageStream.as(StepVerifier::create).then(() -> {
assertThat(processor.hasDownstreams()).isTrue();
processor.onNext(createPatternMessage("foo*", "foo", "message"));
}).expectNextCount(1).thenCancel().verify();