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 redissonCluster;
private static GenericContainer<?> REDIS_CLUSTER;
@BeforeAll
public static void beforeAll() {
Config config = createConfig();
@ -35,51 +39,60 @@ public class RedisDockerTest {
protected static Config createConfig() {
Config config = new Config();
config.setProtocol(Protocol.RESP3);
config.setProtocol(Protocol.RESP2);
config.useSingleServer()
.setAddress("redis://127.0.0.1:" + REDIS.getFirstMappedPort());
return config;
}
protected static RedissonClient createInstance() {
Config config = createConfig();
return Redisson.create(config);
}
protected void testInCluster(Consumer<RedissonClient> redissonCallback) {
GenericContainer<?> redisClusterContainer =
new GenericContainer<>("vishnunair/docker-redis-cluster")
.withExposedPorts(6379, 6380, 6381, 6382, 6383, 6384)
.withStartupCheckStrategy(new MinimumDurationRunningStartupCheckStrategy(Duration.ofSeconds(7)));
redisClusterContainer.start();
if (redissonCluster == null) {
REDIS_CLUSTER = new GenericContainer<>("vishnunair/docker-redis-cluster")
.withExposedPorts(6379, 6380, 6381, 6382, 6383, 6384)
.withStartupCheckStrategy(new MinimumDurationRunningStartupCheckStrategy(Duration.ofSeconds(10)));
REDIS_CLUSTER.start();
Config config = new Config();
config.setProtocol(Protocol.RESP3);
config.useClusterServers()
.setNatMapper(new NatMapper() {
@Override
public RedisURI map(RedisURI uri) {
if (redisClusterContainer.getMappedPort(uri.getPort()) == null) {
return uri;
Config config = new Config();
config.setProtocol(Protocol.RESP2);
config.useClusterServers()
.setNatMapper(new NatMapper() {
@Override
public RedisURI map(RedisURI uri) {
if (REDIS_CLUSTER.getMappedPort(uri.getPort()) == null) {
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:" + redisClusterContainer.getFirstMappedPort());
RedissonClient redisson = Redisson.create(config);
try {
redissonCallback.accept(redisson);
} finally {
redisson.shutdown();
redisClusterContainer.stop();
})
.addNodeAddress("redis://127.0.0.1:" + REDIS_CLUSTER.getFirstMappedPort());
redissonCluster = Redisson.create(config);
}
redissonCallback.accept(redissonCluster);
}
@BeforeEach
public void beforeEach() {
redisson.getKeys().flushall();
if (redissonCluster != null) {
redissonCluster.getKeys().flushall();
}
}
@AfterAll
public static void afterAll() {
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;
public class RedissonAtomicDoubleTest extends BaseTest {
public class RedissonAtomicDoubleTest extends RedisDockerTest {
@Test
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;
public class RedissonAtomicLongTest extends BaseTest {
public class RedissonAtomicLongTest extends RedisDockerTest {
@Test
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;
public class RedissonBitSetTest extends BaseTest {
public class RedissonBitSetTest extends RedisDockerTest {
@Test
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;
public class RedissonDequeTest extends BaseTest {
public class RedissonDequeTest extends RedisDockerTest {
@Test
public void testAddIfExists() {
@ -28,8 +28,6 @@ public class RedissonDequeTest extends BaseTest {
@Test
public void testMove() {
Assumptions.assumeTrue(RedisRunner.getDefaultRedisServerInstance().getRedisVersion().compareTo("6.2.0") > 0);
RDeque<Integer> deque1 = redisson.getDeque("deque1");
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.redisson.api.RDoubleAdder;
public class RedissonDoubleAdderTest extends BaseTest {
public class RedissonDoubleAdderTest extends RedisDockerTest {
@Test
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;
public class RedissonHyperLogLogTest extends BaseTest {
public class RedissonHyperLogLogTest extends RedisDockerTest {
@Test
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
*
*/
public class RedissonIdGeneratorTest extends BaseTest {
public class RedissonIdGeneratorTest extends RedisDockerTest {
@Test
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;
public class RedissonKeysTest extends BaseTest {
public class RedissonKeysTest extends RedisDockerTest {
@Test
public void testReadKeys() {
@ -62,45 +62,22 @@ public class RedissonKeysTest extends BaseTest {
}
@Test
public void testExistsInCluster() throws FailedToStartRedisException, IOException, InterruptedException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave3 = new RedisRunner().randomPort().randomDir().nosave();
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()]));
public void testExistsInCluster() throws FailedToStartRedisException {
testInCluster(redisson -> {
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(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();
process.shutdown();
assertThat(deletedSize).isEqualTo(size);
});
}
@Test
public void testExists() {
redisson.getSet("test").add("1");
@ -127,35 +104,16 @@ public class RedissonKeysTest extends BaseTest {
}
@Test
public void testKeysByPattern() throws FailedToStartRedisException, IOException, InterruptedException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave3 = new RedisRunner().randomPort().randomDir().nosave();
public void testKeysByPattern() throws FailedToStartRedisException {
testInCluster(redisson -> {
int size = 10000;
for (int i = 0; i < size; i++) {
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;
for (int i = 0; i < size; i++) {
redisson.getBucket("test" + i).set(i);
}
assertThat(redisson.getKeys().count()).isEqualTo(size);
Long noOfKeysDeleted = 0L;
assertThat(redisson.getKeys().count()).isEqualTo(size);
Long noOfKeysDeleted = 0L;
int chunkSize = 20;
Iterable<String> keysIterator = redisson.getKeys().getKeysByPattern("test*", chunkSize);
Set<String> keys = new HashSet<>();
@ -173,11 +131,9 @@ public class RedissonKeysTest extends BaseTest {
if (!keys.isEmpty()) {
noOfKeysDeleted += redisson.getKeys().delete(keys.toArray(new String[keys.size()]));
}
assertThat(noOfKeysDeleted).isEqualTo(size);
redisson.shutdown();
process.shutdown();
assertThat(noOfKeysDeleted).isEqualTo(size);
});
}
@ -231,40 +187,19 @@ public class RedissonKeysTest extends BaseTest {
}
@Test
public void testDeleteInCluster() throws FailedToStartRedisException, IOException, InterruptedException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave3 = new RedisRunner().randomPort().randomDir().nosave();
public void testDeleteInCluster() throws FailedToStartRedisException {
testInCluster(redisson -> {
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);
}
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);
}
long deletedSize = redisson.getKeys().delete(list.toArray(new String[list.size()]));
assertThat(deletedSize).isEqualTo(size);
redisson.shutdown();
process.shutdown();
long deletedSize = redisson.getKeys().delete(list.toArray(new String[list.size()]));
assertThat(deletedSize).isEqualTo(size);
});
}
@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;
public class RedissonLexSortedSetTest extends BaseTest {
public class RedissonLexSortedSetTest extends RedisDockerTest {
@Test
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.junit.jupiter.api.Assertions.assertTrue;
public class RedissonListMultimapTest extends BaseTest {
public class RedissonListMultimapTest extends RedisDockerTest {
public static class SimpleKey implements Serializable {
@ -121,10 +121,10 @@ public class RedissonListMultimapTest extends BaseTest {
public void testSizeInMemory() {
RListMultimap<String, String> list = redisson.getListMultimap("test");
list.put("1", "2");
assertThat(list.sizeInMemory()).isEqualTo(159);
assertThat(list.sizeInMemory()).isEqualTo(88);
list.put("1", "3");
assertThat(list.sizeInMemory()).isEqualTo(164);
assertThat(list.sizeInMemory()).isEqualTo(96);
}
@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.redisson.api.RPriorityQueue;
public class RedissonPriorityQueueTest extends BaseTest {
public class RedissonPriorityQueueTest extends RedisDockerTest {
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;
public class RedissonRateLimiterTest extends BaseTest {
public class RedissonRateLimiterTest extends RedisDockerTest {
@Test
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.publisher.Mono;
public class RedissonRemoteServiceTest extends BaseTest {
public class RedissonRemoteServiceTest extends RedisDockerTest {
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.redisson.api.RRingBuffer;
public class RedissonRingBufferTest extends BaseTest {
public class RedissonRingBufferTest extends RedisDockerTest {
@Test
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.codec.StringCodec;
public class RedissonScriptTest extends BaseTest {
public class RedissonScriptTest extends RedisDockerTest {
@Test
public void testMulti() {
RLexSortedSet idx2 = redisson.getLexSortedSet("ABCD17436");
Long l = new Long("1506524856000");
Long l = Long.valueOf("1506524856000");
for (int i = 0; i < 100; i++) {
String s = "DENY" + "\t" + "TESTREDISSON" + "\t"
+ 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.junit.jupiter.api.Assertions.assertTrue;
public class RedissonSetMultimapTest extends BaseTest {
public class RedissonSetMultimapTest extends RedisDockerTest {
public static class SimpleKey implements Serializable {
@ -223,10 +223,10 @@ public class RedissonSetMultimapTest extends BaseTest {
public void testSizeInMemory() {
RSetMultimap<String, String> set = redisson.getSetMultimap("test");
set.put("1", "2");
assertThat(set.sizeInMemory()).isEqualTo(228);
assertThat(set.sizeInMemory()).isEqualTo(88);
set.put("1", "3");
assertThat(set.sizeInMemory()).isEqualTo(257);
assertThat(set.sizeInMemory()).isEqualTo(96);
}
@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.connection.balancer.RandomLoadBalancer;
public class RedissonSetTest extends BaseTest {
public class RedissonSetTest extends RedisDockerTest {
public static class SimpleBean implements Serializable {
@ -569,45 +569,21 @@ public class RedissonSetTest extends BaseTest {
}
@Test
public void testClusteredIterator() throws FailedToStartRedisException, IOException, InterruptedException {
RedisRunner master1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master2 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner master3 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave1 = new RedisRunner().randomPort().randomDir().nosave();
RedisRunner slave2 = new RedisRunner().randomPort().randomDir().nosave();
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);
public void testClusteredIterator() throws FailedToStartRedisException {
testInCluster(redisson -> {
int size = 10000;
RSet<String> set = redisson.getSet("{test");
for (int i = 0; i < size; i++) {
set.add("" + i);
}
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;
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);
Set<String> keys = new HashSet<>();
for (String key : set) {
keys.add(key);
}
redisson.shutdown();
process.shutdown();
assertThat(keys).hasSize(size);
});
}
@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
*
*/
public class RedissonTimeSeriesTest extends BaseTest {
public class RedissonTimeSeriesTest extends RedisDockerTest {
@Test
public void testMultipleValues() {
@ -60,7 +60,7 @@ public class RedissonTimeSeriesTest extends BaseTest {
RTimeSeries<String, Object> t = redisson.getTimeSeries("test");
t.add(1, "10", 1, TimeUnit.SECONDS);
Thread.sleep(5000);
Thread.sleep(6000);
assertThat(redisson.getKeys().count()).isZero();
}

Write Preview
Loading…
Cancel
Save