github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

refactoring

Browse Source
pull/5436/head
Nikita Koksharov 1 year ago
parent b88567a188
commit cea6dc44aa
19 changed files with 111 additions and 189 deletions
Show Stats Download Patch File Download Diff File

63
redisson/src/test/java/org/redisson/RedisDockerTest.java
Unescape Escape View File

@ -27,6 +27,10 @@ public class RedisDockerTest {
protected static RedissonClient redisson; protected static RedissonClient redisson;
protected static RedissonClient redissonCluster;
private static GenericContainer<?> REDIS_CLUSTER;
@BeforeAll @BeforeAll
public static void beforeAll() { public static void beforeAll() {
Config config = createConfig(); Config config = createConfig();
@ -35,51 +39,60 @@ public class RedisDockerTest {
protected static Config createConfig() { protected static Config createConfig() {
Config config = new Config(); Config config = new Config();
config.setProtocol(Protocol.RESP3); config.setProtocol(Protocol.RESP2);
config.useSingleServer() config.useSingleServer()
.setAddress("redis://127.0.0.1:" + REDIS.getFirstMappedPort()); .setAddress("redis://127.0.0.1:" + REDIS.getFirstMappedPort());
return config; return config;
} }
protected static RedissonClient createInstance() {
Config config = createConfig();
return Redisson.create(config);
}
protected void testInCluster(Consumer<RedissonClient> redissonCallback) { protected void testInCluster(Consumer<RedissonClient> redissonCallback) {
GenericContainer<?> redisClusterContainer = if (redissonCluster == null) {
new GenericContainer<>("vishnunair/docker-redis-cluster") REDIS_CLUSTER = new GenericContainer<>("vishnunair/docker-redis-cluster")
.withExposedPorts(6379, 6380, 6381, 6382, 6383, 6384) .withExposedPorts(6379, 6380, 6381, 6382, 6383, 6384)
.withStartupCheckStrategy(new MinimumDurationRunningStartupCheckStrategy(Duration.ofSeconds(7))); .withStartupCheckStrategy(new MinimumDurationRunningStartupCheckStrategy(Duration.ofSeconds(10)));
redisClusterContainer.start(); REDIS_CLUSTER.start();
Config config = new Config(); Config config = new Config();
config.setProtocol(Protocol.RESP3); config.setProtocol(Protocol.RESP2);
config.useClusterServers() config.useClusterServers()
.setNatMapper(new NatMapper() { .setNatMapper(new NatMapper() {
@Override @Override
public RedisURI map(RedisURI uri) { public RedisURI map(RedisURI uri) {
if (redisClusterContainer.getMappedPort(uri.getPort()) == null) { if (REDIS_CLUSTER.getMappedPort(uri.getPort()) == null) {
return uri; return uri;
}
return new RedisURI(uri.getScheme(), REDIS_CLUSTER.getHost(), REDIS_CLUSTER.getMappedPort(uri.getPort()));
} }
return new RedisURI(uri.getScheme(), redisClusterContainer.getHost(), redisClusterContainer.getMappedPort(uri.getPort())); })
} .addNodeAddress("redis://127.0.0.1:" + REDIS_CLUSTER.getFirstMappedPort());
}) redissonCluster = Redisson.create(config);
.addNodeAddress("redis://127.0.0.1:" + redisClusterContainer.getFirstMappedPort());
RedissonClient redisson = Redisson.create(config);
try {
redissonCallback.accept(redisson);
} finally {
redisson.shutdown();
redisClusterContainer.stop();
} }
redissonCallback.accept(redissonCluster);
} }
@BeforeEach @BeforeEach
public void beforeEach() { public void beforeEach() {
redisson.getKeys().flushall(); redisson.getKeys().flushall();
if (redissonCluster != null) {
redissonCluster.getKeys().flushall();
}
} }
@AfterAll @AfterAll
public static void afterAll() { public static void afterAll() {
redisson.shutdown(); redisson.shutdown();
if (redissonCluster != null) {
redissonCluster.shutdown();
}
if (REDIS_CLUSTER != null) {
REDIS_CLUSTER.stop();
}
} }
} }

2
redisson/src/test/java/org/redisson/RedissonAtomicDoubleTest.java
Unescape Escape View File

@ -7,7 +7,7 @@ import java.math.BigDecimal;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class RedissonAtomicDoubleTest extends BaseTest { public class RedissonAtomicDoubleTest extends RedisDockerTest {
@Test @Test
public void testGetAndSet() { public void testGetAndSet() {

2
redisson/src/test/java/org/redisson/RedissonAtomicLongTest.java
Unescape Escape View File

@ -6,7 +6,7 @@ import org.redisson.api.RAtomicLong;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class RedissonAtomicLongTest extends BaseTest { public class RedissonAtomicLongTest extends RedisDockerTest {
@Test @Test
public void testGetAndSet() { public void testGetAndSet() {

2
redisson/src/test/java/org/redisson/RedissonBitSetTest.java
Unescape Escape View File

@ -9,7 +9,7 @@ import java.util.Random;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class RedissonBitSetTest extends BaseTest { public class RedissonBitSetTest extends RedisDockerTest {
@Test @Test
public void testUnsigned() { public void testUnsigned() {

4
redisson/src/test/java/org/redisson/RedissonDequeTest.java
Unescape Escape View File

@ -12,7 +12,7 @@ import java.util.Deque;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class RedissonDequeTest extends BaseTest { public class RedissonDequeTest extends RedisDockerTest {
@Test @Test
public void testAddIfExists() { public void testAddIfExists() {
@ -28,8 +28,6 @@ public class RedissonDequeTest extends BaseTest {
@Test @Test
public void testMove() { public void testMove() {
Assumptions.assumeTrue(RedisRunner.getDefaultRedisServerInstance().getRedisVersion().compareTo("6.2.0") > 0);
RDeque<Integer> deque1 = redisson.getDeque("deque1"); RDeque<Integer> deque1 = redisson.getDeque("deque1");
RDeque<Integer> deque2 = redisson.getDeque("deque2"); RDeque<Integer> deque2 = redisson.getDeque("deque2");

2
redisson/src/test/java/org/redisson/RedissonDoubleAdderTest.java
Unescape Escape View File

@ -4,7 +4,7 @@ import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.redisson.api.RDoubleAdder; import org.redisson.api.RDoubleAdder;
public class RedissonDoubleAdderTest extends BaseTest { public class RedissonDoubleAdderTest extends RedisDockerTest {
@Test @Test
public void testSum() { public void testSum() {

2
redisson/src/test/java/org/redisson/RedissonHyperLogLogTest.java
Unescape Escape View File

@ -6,7 +6,7 @@ import org.redisson.api.RHyperLogLog;
import java.util.Arrays; import java.util.Arrays;
public class RedissonHyperLogLogTest extends BaseTest { public class RedissonHyperLogLogTest extends RedisDockerTest {
@Test @Test
public void testAddAll() { public void testAddAll() {

2
redisson/src/test/java/org/redisson/RedissonIdGeneratorTest.java
Unescape Escape View File

@ -10,7 +10,7 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Nikita Koksharov * @author Nikita Koksharov
* *
*/ */
public class RedissonIdGeneratorTest extends BaseTest { public class RedissonIdGeneratorTest extends RedisDockerTest {
@Test @Test
public void testEmpty() { public void testEmpty() {

139
redisson/src/test/java/org/redisson/RedissonKeysTest.java
Unescape Escape View File

@ -13,7 +13,7 @@ import java.util.*;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class RedissonKeysTest extends BaseTest { public class RedissonKeysTest extends RedisDockerTest {
@Test @Test
public void testReadKeys() { public void testReadKeys() {
@ -62,45 +62,22 @@ public class RedissonKeysTest extends BaseTest {
} }
@Test @Test
public void testExistsInCluster() throws FailedToStartRedisException, IOException, InterruptedException { public void testExistsInCluster() throws FailedToStartRedisException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave(); testInCluster(redisson -> {
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave(); int size = 10000;
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave(); List<String> list = new ArrayList<>();
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave(); for (int i = 0; i < size; i++) {
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave(); list.add("test" + i);
RedisRunner slave3 = new RedisRunner().randomPort().randomDir().nosave(); redisson.getBucket("test" + i).set(i);
}
ClusterRunner clusterRunner = new ClusterRunner()
.addNode(master1, slave1)
.addNode(master2, slave2)
.addNode(master3, slave3);
ClusterProcesses process = clusterRunner.run();
Config config = new Config();
config.useClusterServers()
.setLoadBalancer(new RandomLoadBalancer())
.addNodeAddress(process.getNodes().stream().findAny().get().getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
int size = 10000;
List<String> list = new ArrayList<>();
for (int i = 0; i < size; i++) {
list.add("test" + i);
redisson.getBucket("test" + i).set(i);
}
assertThat(redisson.getKeys().countExists("test1", "test2", "test34", "test45", "asdfl;jasf")).isEqualTo(4);
long deletedSize = redisson.getKeys().delete(list.toArray(new String[list.size()]));
assertThat(deletedSize).isEqualTo(size); assertThat(redisson.getKeys().countExists("test1", "test2", "test34", "test45", "asdfl;jasf")).isEqualTo(4);
long deletedSize = redisson.getKeys().delete(list.toArray(new String[list.size()]));
redisson.shutdown(); assertThat(deletedSize).isEqualTo(size);
process.shutdown(); });
} }
@Test @Test
public void testExists() { public void testExists() {
redisson.getSet("test").add("1"); redisson.getSet("test").add("1");
@ -127,35 +104,16 @@ public class RedissonKeysTest extends BaseTest {
} }
@Test @Test
public void testKeysByPattern() throws FailedToStartRedisException, IOException, InterruptedException { public void testKeysByPattern() throws FailedToStartRedisException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave(); testInCluster(redisson -> {
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave(); int size = 10000;
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave(); for (int i = 0; i < size; i++) {
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave(); redisson.getBucket("test" + i).set(i);
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave(); }
RedisRunner slave3 = new RedisRunner().randomPort().randomDir().nosave();
assertThat(redisson.getKeys().count()).isEqualTo(size);
ClusterRunner clusterRunner = new ClusterRunner()
.addNode(master1, slave1) Long noOfKeysDeleted = 0L;
.addNode(master2, slave2)
.addNode(master3, slave3);
ClusterProcesses process = clusterRunner.run();
Config config = new Config();
config.useClusterServers()
.setLoadBalancer(new RandomLoadBalancer())
.addNodeAddress(process.getNodes().stream().findAny().get().getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
int size = 10000;
for (int i = 0; i < size; i++) {
redisson.getBucket("test" + i).set(i);
}
assertThat(redisson.getKeys().count()).isEqualTo(size);
Long noOfKeysDeleted = 0L;
int chunkSize = 20; int chunkSize = 20;
Iterable<String> keysIterator = redisson.getKeys().getKeysByPattern("test*", chunkSize); Iterable<String> keysIterator = redisson.getKeys().getKeysByPattern("test*", chunkSize);
Set<String> keys = new HashSet<>(); Set<String> keys = new HashSet<>();
@ -173,11 +131,9 @@ public class RedissonKeysTest extends BaseTest {
if (!keys.isEmpty()) { if (!keys.isEmpty()) {
noOfKeysDeleted += redisson.getKeys().delete(keys.toArray(new String[keys.size()])); noOfKeysDeleted += redisson.getKeys().delete(keys.toArray(new String[keys.size()]));
} }
assertThat(noOfKeysDeleted).isEqualTo(size); assertThat(noOfKeysDeleted).isEqualTo(size);
});
redisson.shutdown();
process.shutdown();
} }
@ -231,40 +187,19 @@ public class RedissonKeysTest extends BaseTest {
} }
@Test @Test
public void testDeleteInCluster() throws FailedToStartRedisException, IOException, InterruptedException { public void testDeleteInCluster() throws FailedToStartRedisException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave(); testInCluster(redisson -> {
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave(); int size = 10000;
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave(); List<String> list = new ArrayList<>();
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave(); for (int i = 0; i < size; i++) {
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave(); list.add("test" + i);
RedisRunner slave3 = new RedisRunner().randomPort().randomDir().nosave(); redisson.getBucket("test" + i).set(i);
}
long deletedSize = redisson.getKeys().delete(list.toArray(new String[list.size()]));
ClusterRunner clusterRunner = new ClusterRunner()
.addNode(master1, slave1) assertThat(deletedSize).isEqualTo(size);
.addNode(master2, slave2) });
.addNode(master3, slave3);
ClusterProcesses process = clusterRunner.run();
Config config = new Config();
config.useClusterServers()
.setLoadBalancer(new RandomLoadBalancer())
.addNodeAddress(process.getNodes().stream().findAny().get().getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
int size = 10000;
List<String> list = new ArrayList<>();
for (int i = 0; i < size; i++) {
list.add("test" + i);
redisson.getBucket("test" + i).set(i);
}
long deletedSize = redisson.getKeys().delete(list.toArray(new String[list.size()]));
assertThat(deletedSize).isEqualTo(size);
redisson.shutdown();
process.shutdown();
} }
@Test @Test

2
redisson/src/test/java/org/redisson/RedissonLexSortedSetTest.java
Unescape Escape View File

@ -8,7 +8,7 @@ import java.util.Arrays;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class RedissonLexSortedSetTest extends BaseTest { public class RedissonLexSortedSetTest extends RedisDockerTest {
@Test @Test
public void testAll() { public void testAll() {

6
redisson/src/test/java/org/redisson/RedissonListMultimapTest.java
Unescape Escape View File

@ -13,7 +13,7 @@ import java.util.stream.IntStream;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class RedissonListMultimapTest extends BaseTest { public class RedissonListMultimapTest extends RedisDockerTest {
public static class SimpleKey implements Serializable { public static class SimpleKey implements Serializable {
@ -121,10 +121,10 @@ public class RedissonListMultimapTest extends BaseTest {
public void testSizeInMemory() { public void testSizeInMemory() {
RListMultimap<String, String> list = redisson.getListMultimap("test"); RListMultimap<String, String> list = redisson.getListMultimap("test");
list.put("1", "2"); list.put("1", "2");
assertThat(list.sizeInMemory()).isEqualTo(159); assertThat(list.sizeInMemory()).isEqualTo(88);
list.put("1", "3"); list.put("1", "3");
assertThat(list.sizeInMemory()).isEqualTo(164); assertThat(list.sizeInMemory()).isEqualTo(96);
} }
@Test @Test

2
redisson/src/test/java/org/redisson/RedissonPriorityQueueTest.java
Unescape Escape View File

@ -13,7 +13,7 @@ import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.redisson.api.RPriorityQueue; import org.redisson.api.RPriorityQueue;
public class RedissonPriorityQueueTest extends BaseTest { public class RedissonPriorityQueueTest extends RedisDockerTest {
public static class Entry implements Comparable<Entry>, Serializable { public static class Entry implements Comparable<Entry>, Serializable {

2
redisson/src/test/java/org/redisson/RedissonRateLimiterTest.java
Unescape Escape View File

@ -16,7 +16,7 @@ import java.util.concurrent.atomic.AtomicLong;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class RedissonRateLimiterTest extends BaseTest { public class RedissonRateLimiterTest extends RedisDockerTest {
@Test @Test
public void testExpire2() throws InterruptedException { public void testExpire2() throws InterruptedException {

2
redisson/src/test/java/org/redisson/RedissonRemoteServiceTest.java
Unescape Escape View File

@ -38,7 +38,7 @@ import io.reactivex.rxjava3.core.Single;
import reactor.core.Disposable; import reactor.core.Disposable;
import reactor.core.publisher.Mono; import reactor.core.publisher.Mono;
public class RedissonRemoteServiceTest extends BaseTest { public class RedissonRemoteServiceTest extends RedisDockerTest {
public static class Pojo { public static class Pojo {

2
redisson/src/test/java/org/redisson/RedissonRingBufferTest.java
Unescape Escape View File

@ -8,7 +8,7 @@ import java.util.List;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import org.redisson.api.RRingBuffer; import org.redisson.api.RRingBuffer;
public class RedissonRingBufferTest extends BaseTest { public class RedissonRingBufferTest extends RedisDockerTest {
@Test @Test
public void testSetCapacity() { public void testSetCapacity() {

4
redisson/src/test/java/org/redisson/RedissonScriptTest.java
Unescape Escape View File

@ -16,13 +16,13 @@ import org.redisson.api.RScript.Mode;
import org.redisson.client.RedisException; import org.redisson.client.RedisException;
import org.redisson.client.codec.StringCodec; import org.redisson.client.codec.StringCodec;
public class RedissonScriptTest extends BaseTest { public class RedissonScriptTest extends RedisDockerTest {
@Test @Test
public void testMulti() { public void testMulti() {
RLexSortedSet idx2 = redisson.getLexSortedSet("ABCD17436"); RLexSortedSet idx2 = redisson.getLexSortedSet("ABCD17436");
Long l = new Long("1506524856000"); Long l = Long.valueOf("1506524856000");
for (int i = 0; i < 100; i++) { for (int i = 0; i < 100; i++) {
String s = "DENY" + "\t" + "TESTREDISSON" + "\t" String s = "DENY" + "\t" + "TESTREDISSON" + "\t"
+ Long.valueOf(l) + "\t" + "helloworld_hongqin"; + Long.valueOf(l) + "\t" + "helloworld_hongqin";

6
redisson/src/test/java/org/redisson/RedissonSetMultimapTest.java
Unescape Escape View File

@ -15,7 +15,7 @@ import java.util.stream.IntStream;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
public class RedissonSetMultimapTest extends BaseTest { public class RedissonSetMultimapTest extends RedisDockerTest {
public static class SimpleKey implements Serializable { public static class SimpleKey implements Serializable {
@ -223,10 +223,10 @@ public class RedissonSetMultimapTest extends BaseTest {
public void testSizeInMemory() { public void testSizeInMemory() {
RSetMultimap<String, String> set = redisson.getSetMultimap("test"); RSetMultimap<String, String> set = redisson.getSetMultimap("test");
set.put("1", "2"); set.put("1", "2");
assertThat(set.sizeInMemory()).isEqualTo(228); assertThat(set.sizeInMemory()).isEqualTo(88);
set.put("1", "3"); set.put("1", "3");
assertThat(set.sizeInMemory()).isEqualTo(257); assertThat(set.sizeInMemory()).isEqualTo(96);
} }
@Test @Test

52
redisson/src/test/java/org/redisson/RedissonSetTest.java
Unescape Escape View File

@ -32,7 +32,7 @@ import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config; import org.redisson.config.Config;
import org.redisson.connection.balancer.RandomLoadBalancer; import org.redisson.connection.balancer.RandomLoadBalancer;
public class RedissonSetTest extends BaseTest { public class RedissonSetTest extends RedisDockerTest {
public static class SimpleBean implements Serializable { public static class SimpleBean implements Serializable {
@ -569,45 +569,21 @@ public class RedissonSetTest extends BaseTest {
} }
@Test @Test
public void testClusteredIterator() throws FailedToStartRedisException, IOException, InterruptedException { public void testClusteredIterator() throws FailedToStartRedisException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave(); testInCluster(redisson -> {
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave(); int size = 10000;
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave(); RSet<String> set = redisson.getSet("{test");
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave(); for (int i = 0; i < size; i++) {
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave(); set.add("" + i);
RedisRunner slave3 = new RedisRunner().randomPort().randomDir().nosave(); }
RedisRunner slave4 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave5 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave6 = new RedisRunner().randomPort().randomDir().nosave();
ClusterRunner clusterRunner = new ClusterRunner()
.addNode(master1, slave1, slave4)
.addNode(master2, slave2, slave5)
.addNode(master3, slave3, slave6);
ClusterProcesses process = clusterRunner.run(); Set<String> keys = new HashSet<>();
for (String key : set) {
Config config = new Config(); keys.add(key);
config.useClusterServers() }
.setLoadBalancer(new RandomLoadBalancer())
.addNodeAddress(process.getNodes().stream().findAny().get().getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
int size = 10000;
RSet<String> set = redisson.getSet("{test");
for (int i = 0; i < size; i++) {
set.add("" + i);
}
Set<String> keys = new HashSet<>();
for (String key : set) {
keys.add(key);
}
assertThat(keys).hasSize(size);
redisson.shutdown(); assertThat(keys).hasSize(size);
process.shutdown(); });
} }
@Test @Test

4
redisson/src/test/java/org/redisson/RedissonTimeSeriesTest.java
Unescape Escape View File

@ -19,7 +19,7 @@ import static org.redisson.RedisRunner.KEYSPACE_EVENTS_OPTIONS.s;
* @author Nikita Koksharov * @author Nikita Koksharov
* *
*/ */
public class RedissonTimeSeriesTest extends BaseTest { public class RedissonTimeSeriesTest extends RedisDockerTest {
@Test @Test
public void testMultipleValues() { public void testMultipleValues() {
@ -60,7 +60,7 @@ public class RedissonTimeSeriesTest extends BaseTest {
RTimeSeries<String, Object> t = redisson.getTimeSeries("test"); RTimeSeries<String, Object> t = redisson.getTimeSeries("test");
t.add(1, "10", 1, TimeUnit.SECONDS); t.add(1, "10", 1, TimeUnit.SECONDS);
Thread.sleep(5000); Thread.sleep(6000);
assertThat(redisson.getKeys().count()).isZero(); assertThat(redisson.getKeys().count()).isZero();
} }

Write Preview
Loading…
Cancel
Save