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/5457/head
Nikita Koksharov 1 year ago
parent 1d4a9c87a6
commit 2c1ab3df94
6 changed files with 713 additions and 786 deletions
Show Stats Download Patch File Download Diff File

182
redisson/src/test/java/org/redisson/RedissonBucketsTest.java
Unescape Escape View File

@ -1,123 +1,95 @@
package org.redisson;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.junit.jupiter.api.Test;
import org.redisson.ClusterRunner.ClusterProcesses;
import org.redisson.RedisRunner.FailedToStartRedisException;
import org.redisson.api.NameMapper;
import org.redisson.api.RBucket;
import org.redisson.api.RBuckets;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;
import org.redisson.connection.balancer.RandomLoadBalancer;
import org.redisson.config.ReadMode;
public class RedissonBucketsTest extends BaseTest {
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
public class RedissonBucketsTest extends RedisDockerTest {
@Test
public void testGetInClusterNameMapper() 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()
.setNameMapper(new NameMapper() {
@Override
public String map(String name) {
return "test::" + name;
}
@Override
public String unmap(String name) {
return name.replace("test::", "");
}
})
.setLoadBalancer(new RandomLoadBalancer())
.addNodeAddress(process.getNodes().stream().findAny().get().getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
int size = 10000;
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.put("test" + i, i);
}
for (int i = 10; i < size; i++) {
map.put("test" + i + "{" + (i%100)+ "}", i);
}
redisson.getBuckets().set(map);
Set<String> queryKeys = new HashSet<>(map.keySet());
queryKeys.add("test_invalid");
Map<String, Integer> buckets = redisson.getBuckets().get(queryKeys.toArray(new String[map.size()]));
assertThat(buckets).isEqualTo(map);
for (int i = 0; i < 10; i++) {
assertThat(redisson.getBucket("test" + i).get()).isEqualTo(i);
}
redisson.shutdown();
process.shutdown();
public void testGetInClusterNameMapper() {
testInCluster(client -> {
Config config = client.getConfig();
config.useClusterServers()
.setReadMode(ReadMode.MASTER)
.setNameMapper(new NameMapper() {
@Override
public String map(String name) {
return "test::" + name;
}
@Override
public String unmap(String name) {
return name.replace("test::", "");
}
});
RedissonClient redisson = Redisson.create(config);
int size = 10000;
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.put("test" + i, i);
}
for (int i = 10; i < size; i++) {
map.put("test" + i + "{" + (i % 100) + "}", i);
}
redisson.getBuckets().set(map);
Set<String> queryKeys = new HashSet<>(map.keySet());
queryKeys.add("test_invalid");
Map<String, Integer> buckets = redisson.getBuckets().get(queryKeys.toArray(new String[map.size()]));
assertThat(buckets).isEqualTo(map);
for (int i = 0; i < 10; i++) {
assertThat(redisson.getBucket("test" + i).get()).isEqualTo(i);
}
redisson.shutdown();
});
}
@Test
public void testGetInCluster() 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;
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.put("test" + i, i);
}
for (int i = 10; i < size; i++) {
map.put("test" + i + "{" + (i%100)+ "}", i);
}
redisson.getBuckets().set(map);
Set<String> queryKeys = new HashSet<>(map.keySet());
queryKeys.add("test_invalid");
Map<String, Integer> buckets = redisson.getBuckets().get(queryKeys.toArray(new String[map.size()]));
assertThat(buckets).isEqualTo(map);
redisson.shutdown();
process.shutdown();
public void testGetInCluster() {
testInCluster(client -> {
Config config = client.getConfig();
config.useClusterServers()
.setReadMode(ReadMode.MASTER);
RedissonClient redisson = Redisson.create(config);
int size = 10000;
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.put("test" + i, i);
}
for (int i = 10; i < size; i++) {
map.put("test" + i + "{" + (i%100)+ "}", i);
}
redisson.getBuckets().set(map);
Set<String> queryKeys = new HashSet<>(map.keySet());
queryKeys.add("test_invalid");
Map<String, Integer> buckets = redisson.getBuckets().get(queryKeys.toArray(new String[map.size()]));
assertThat(buckets).isEqualTo(map);
redisson.shutdown();
});
}
@Test

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

@ -14,7 +14,7 @@ import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
public class RedissonCollectionMapReduceTest extends BaseTest {
public class RedissonCollectionMapReduceTest extends RedisDockerTest {
public static class WordMapper implements RCollectionMapper<String, String, Integer> {
@ -208,7 +208,7 @@ public class RedissonCollectionMapReduceTest extends BaseTest {
if (RList.class.isAssignableFrom(mapClass)) {
list = redisson.getList("list");
} else if (RQueue.class.isAssignableFrom(mapClass)) {
list = (RList<String>) redisson.<String>getQueue("queue");
list = redisson.getList("queue");
}
return list;
}

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

@ -14,7 +14,7 @@ import java.util.concurrent.atomic.AtomicInteger;
import static org.assertj.core.api.Assertions.assertThat;
public class RedissonCountDownLatchTest extends BaseTest {
public class RedissonCountDownLatchTest extends RedisDockerTest {
@Test
public void testAwaitTimeout() throws InterruptedException {

1086
redisson/src/test/java/org/redisson/RedissonTopicTest.java
View File

File diff suppressed because it is too large Load Diff

15
redisson/src/test/java/org/redisson/RedissonTransferQueueTest.java
Unescape Escape View File

@ -1,9 +1,11 @@
package org.redisson;
import org.awaitility.Awaitility;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.redisson.api.RTransferQueue;
import java.time.Duration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
@ -15,7 +17,7 @@ import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Nikita Koksharov
*/
public class RedissonTransferQueueTest extends BaseTest {
public class RedissonTransferQueueTest extends RedisDockerTest {
@Test
public void testTryTransferWithDelay() throws InterruptedException, ExecutionException {
@ -93,12 +95,11 @@ public class RedissonTransferQueueTest extends BaseTest {
assertThat(res2).isFalse();
}, 4, TimeUnit.SECONDS);
long s = System.currentTimeMillis();
int l = queue1.take();
takeExecuted.set(true);
Assertions.assertEquals(3, l);
Assertions.assertTrue(System.currentTimeMillis() - s > 3900);
Awaitility.await().atLeast(Duration.ofMillis(3900)).untilAsserted(() -> {
int l = queue1.take();
takeExecuted.set(true);
assertThat(l).isEqualTo(3);
});
f.get();
assertThat(queue1.size()).isZero();
assertThat(queue1.peek()).isNull();

210
redisson/src/test/java/org/redisson/jcache/JCacheTest.java
Unescape Escape View File

@ -1,61 +1,67 @@
package org.redisson.jcache;
import static java.util.concurrent.TimeUnit.*;
import static org.assertj.core.api.Assertions.assertThat;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.redisson.RedisRunner.FailedToStartRedisException;
import org.redisson.Redisson;
import org.redisson.api.CacheAsync;
import org.redisson.api.CacheReactive;
import org.redisson.api.CacheRx;
import org.redisson.api.RedissonClient;
import org.redisson.codec.TypedJsonJacksonCodec;
import org.redisson.config.Config;
import org.redisson.jcache.configuration.RedissonConfiguration;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import javax.cache.Cache;
import javax.cache.Caching;
import javax.cache.configuration.*;
import javax.cache.event.*;
import javax.cache.expiry.CreatedExpiryPolicy;
import javax.cache.expiry.Duration;
import javax.cache.integration.CacheLoader;
import javax.cache.integration.CacheLoaderException;
import java.io.IOException;
import java.io.Serializable;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import javax.cache.Cache;
import javax.cache.Caching;
import javax.cache.configuration.*;
import javax.cache.event.CacheEntryEvent;
import javax.cache.event.CacheEntryExpiredListener;
import javax.cache.event.CacheEntryListenerException;
import javax.cache.event.CacheEntryRemovedListener;
import javax.cache.event.CacheEntryUpdatedListener;
import javax.cache.expiry.CreatedExpiryPolicy;
import javax.cache.expiry.Duration;
import javax.cache.integration.CacheLoader;
import javax.cache.integration.CacheLoaderException;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.assertj.core.api.Assertions.assertThat;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.redisson.BaseTest;
import org.redisson.RedisRunner;
import org.redisson.RedisRunner.FailedToStartRedisException;
import org.redisson.RedisRunner.RedisProcess;
import org.redisson.api.CacheAsync;
import org.redisson.api.CacheReactive;
import org.redisson.api.CacheRx;
import org.redisson.codec.TypedJsonJacksonCodec;
import org.redisson.config.Config;
import org.redisson.jcache.configuration.RedissonConfiguration;
@Testcontainers
public class JCacheTest {
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
@Container
private static final GenericContainer<?> REDIS =
new GenericContainer<>("redis:7.2")
.withCreateContainerCmdModifier(cmd -> {
cmd.withCmd("redis-server", "--save", "''");
})
.withExposedPorts(6379);
public class JCacheTest extends BaseTest {
static {
REDIS.setPortBindings(Arrays.asList("6311:6379"));
}
@BeforeEach
public void beforeEach() throws IOException, InterruptedException {
org.testcontainers.containers.Container.ExecResult r = REDIS.execInContainer("redis-cli", "flushall");
assertThat(r.getExitCode()).isEqualTo(0);
}
@Test
public void testCreatedExpiryPolicy() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -80,17 +86,10 @@ public class JCacheTest extends BaseTest {
assertThat(cache.get("1")).isEqualTo("5");
cache.close();
runner.stop();
}
@Test
public void testClear() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -103,17 +102,10 @@ public class JCacheTest extends BaseTest {
assertThat(cache.get("1")).isNull();
cache.close();
runner.stop();
}
@Test
public void testAsync() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -126,17 +118,10 @@ public class JCacheTest extends BaseTest {
assertThat(async.getAsync("1").get()).isEqualTo("2");
cache.close();
runner.stop();
}
@Test
public void testReactive() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -149,17 +134,10 @@ public class JCacheTest extends BaseTest {
assertThat(reactive.get("1").block()).isEqualTo("2");
cache.close();
runner.stop();
}
@Test
public void testRx() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -172,17 +150,10 @@ public class JCacheTest extends BaseTest {
assertThat(rx.get("1").blockingGet()).isEqualTo("2");
cache.close();
runner.stop();
}
@Test
public void testPutAll() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -204,17 +175,10 @@ public class JCacheTest extends BaseTest {
}
cache.close();
runner.stop();
}
@Test
public void testRemoveAll() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -235,17 +199,10 @@ public class JCacheTest extends BaseTest {
assertThat(cache.containsKey("5")).isFalse();
cache.close();
runner.stop();
}
@Test
public void testGetAllHighVolume() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -263,17 +220,10 @@ public class JCacheTest extends BaseTest {
assertThat(entries).isEqualTo(m);
cache.close();
runner.stop();
}
@Test
public void testGetAll() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -291,17 +241,10 @@ public class JCacheTest extends BaseTest {
assertThat(entries).isEqualTo(expected);
cache.close();
runner.stop();
}
@Test
public void testGetAllCacheLoader() throws Exception {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -343,17 +286,10 @@ public class JCacheTest extends BaseTest {
assertThat(entries).isEqualTo(expected);
cache.close();
runner.stop();
}
@Test
public void testJson() throws InterruptedException, IllegalArgumentException, URISyntaxException, IOException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
ObjectMapper objectMapper = new ObjectMapper();
@ -369,17 +305,10 @@ public class JCacheTest extends BaseTest {
Assertions.assertEquals(t, cache.get("1"));
cache.close();
runner.stop();
}
@Test
public void testRedissonConfig() throws InterruptedException, IllegalArgumentException, IOException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
@ -401,17 +330,10 @@ public class JCacheTest extends BaseTest {
Assertions.assertNull(cache.get("key"));
cache.close();
runner.stop();
}
@Test
public void testScriptCache() throws IOException, InterruptedException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
URL configUrl = getClass().getResource("redisson-jcache.yaml");
Config cfg = Config.fromYAML(configUrl);
cfg.setUseScriptCache(true);
@ -424,11 +346,13 @@ public class JCacheTest extends BaseTest {
Assertions.assertEquals("2", cache.get("1"));
cache.close();
runner.stop();
}
@Test
public void testRedissonInstance() throws IllegalArgumentException {
Config cfg = new Config();
cfg.useSingleServer().setAddress("redis://127.0.0.1:6311");
RedissonClient redisson = Redisson.create(cfg);
Configuration<String, String> config = RedissonConfiguration.fromInstance(redisson);
Cache<String, String> cache = Caching.getCachingProvider().getCacheManager()
.createCache("test", config);
@ -437,16 +361,11 @@ public class JCacheTest extends BaseTest {
Assertions.assertEquals("2", cache.get("1"));
cache.close();
redisson.shutdown();
}
@Test
public void testExpiration() throws InterruptedException, IllegalArgumentException, URISyntaxException, FailedToStartRedisException, IOException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
MutableConfiguration<String, String> config = new MutableConfiguration<>();
config.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 1)));
config.setStoreByValue(true);
@ -471,17 +390,10 @@ public class JCacheTest extends BaseTest {
Assertions.assertNull(cache.get(key));
cache.close();
runner.stop();
}
@Test
public void testUpdate() throws IOException, InterruptedException, URISyntaxException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
MutableConfiguration<String, String> config = new MutableConfiguration<>();
config.setStoreByValue(true);
@ -508,17 +420,10 @@ public class JCacheTest extends BaseTest {
assertThat(cache.get(key)).isNotNull();
cache.close();
runner.stop();
}
@Test
public void testUpdateAsync() throws IOException, InterruptedException, URISyntaxException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
MutableConfiguration<String, String> config = new MutableConfiguration<>();
config.setStoreByValue(true);
@ -550,17 +455,10 @@ public class JCacheTest extends BaseTest {
assertThat(cache.get(key)).isNotNull();
cache.close();
runner.stop();
}
@Test
public void testUpdateWithoutOldValue() throws IOException, InterruptedException, URISyntaxException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
MutableConfiguration<String, String> config = new MutableConfiguration<>();
config.setStoreByValue(true);
@ -587,17 +485,10 @@ public class JCacheTest extends BaseTest {
assertThat(cache.get(key)).isNotNull();
cache.close();
runner.stop();
}
@Test
public void testRemoveListener() throws IOException, InterruptedException, URISyntaxException {
RedisProcess runner = new RedisRunner()
.nosave()
.randomDir()
.port(6311)
.run();
MutableConfiguration<String, String> config = new MutableConfiguration<>();
config.setStoreByValue(true);
@ -624,7 +515,6 @@ public class JCacheTest extends BaseTest {
assertThat(cache.get(key)).isNull();
cache.close();
runner.stop();
}
public static class ExpiredListener implements CacheEntryExpiredListener<String, String>, Serializable {

Write Preview
Loading…
Cancel
Save