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

Merge pull request #616 from jackygurui/test-timeout

Browse Source 
Test optimisations
pull/626/head
Nikita Koksharov 8 years ago committed by GitHub
parent e90557c147 4e5cf320c2
commit d8c26e6741
16 changed files with 284 additions and 137 deletions
Show Stats Download Patch File Download Diff File

4
redisson/src/main/java/org/redisson/client/RedisClient.java
Unescape Escape View File

@ -90,6 +90,10 @@ public class RedisClient {
public RedisClient(Timer timer, ExecutorService executor, EventLoopGroup group, String host, int port) {
this(timer, executor, group, NioSocketChannel.class, host, port, 10000, 10000);
}
public RedisClient(String host, int port, int connectTimeout, int commandTimeout) {
this(new HashedWheelTimer(), new NioEventLoopGroup(), NioSocketChannel.class, host, port, connectTimeout, commandTimeout);
}
public RedisClient(final Timer timer, ExecutorService executor, EventLoopGroup group, Class<? extends SocketChannel> socketChannelClass, String host, int port,
int connectTimeout, int commandTimeout) {

17
redisson/src/test/java/org/redisson/BaseTest.java
Unescape Escape View File

@ -6,11 +6,10 @@ import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.redisson.api.RedissonClient;
import org.redisson.codec.MsgPackJacksonCodec;
import org.redisson.config.Config;
public abstract class BaseTest {
protected RedissonClient redisson;
protected static RedissonClient defaultRedisson;
@ -52,15 +51,19 @@ public abstract class BaseTest {
}
public static Config createConfig() {
String redisAddress = System.getProperty("redisAddress");
if (redisAddress == null) {
redisAddress = "127.0.0.1:6379";
}
// String redisAddress = System.getProperty("redisAddress");
// if (redisAddress == null) {
// redisAddress = "127.0.0.1:6379";
// }
Config config = new Config();
// config.setCodec(new MsgPackJacksonCodec());
// config.useSentinelServers().setMasterName("mymaster").addSentinelAddress("127.0.0.1:26379", "127.0.0.1:26389");
// config.useClusterServers().addNodeAddress("127.0.0.1:7004", "127.0.0.1:7001", "127.0.0.1:7000");
config.useSingleServer().setAddress(redisAddress);
config.useSingleServer()
.setAddress(RedisRunner.getDefaultRedisServerBindAddressAndPort())
.setConnectTimeout(1000000)
.setTimeout(1000000);
config.setThreads(10);
// .setPassword("mypass1");
// config.useMasterSlaveConnection()
// .setMasterAddress("127.0.0.1:6379")

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

@ -33,7 +33,6 @@ import org.redisson.misc.RPromise;
import org.redisson.misc.RedissonPromise;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.concurrent.ImmediateEventExecutor;
public class RedisClientTest {
@ -67,7 +66,7 @@ public class RedisClientTest {
@Test
public void testConnectAsync() throws InterruptedException {
RedisClient c = new RedisClient("localhost", 6379);
RedisClient c = new RedisClient(RedisRunner.getDefaultRedisServerBindAddressAndPort());
RFuture<RedisConnection> f = c.connectAsync();
final CountDownLatch l = new CountDownLatch(1);
f.addListener((FutureListener<RedisConnection>) future -> {
@ -80,7 +79,7 @@ public class RedisClientTest {
@Test
public void testSubscribe() throws InterruptedException {
RedisClient c = new RedisClient("localhost", 6379);
RedisClient c = new RedisClient(RedisRunner.getDefaultRedisServerBindAddressAndPort());
RedisPubSubConnection pubSubConnection = c.connectPubSub();
final CountDownLatch latch = new CountDownLatch(2);
pubSubConnection.addListener(new RedisPubSubListener<Object>() {
@ -108,7 +107,9 @@ public class RedisClientTest {
@Test
public void test() throws InterruptedException {
RedisClient c = new RedisClient("localhost", 6379);
RedisClient c = new RedisClient(RedisRunner.getDefaultRedisServerInstance().getRedisServerBindAddress(),
RedisRunner.getDefaultRedisServerInstance().getRedisServerPort(),
1000000, 1000000);
final RedisConnection conn = c.connect();
conn.sync(StringCodec.INSTANCE, RedisCommands.SET, "test", 0);
@ -130,7 +131,7 @@ public class RedisClientTest {
@Test
public void testPipeline() throws InterruptedException, ExecutionException {
RedisClient c = new RedisClient("localhost", 6379);
RedisClient c = new RedisClient(RedisRunner.getDefaultRedisServerBindAddressAndPort());
RedisConnection conn = c.connect();
conn.sync(StringCodec.INSTANCE, RedisCommands.SET, "test", 0);
@ -158,7 +159,7 @@ public class RedisClientTest {
@Test
public void testBigRequest() throws InterruptedException, ExecutionException {
RedisClient c = new RedisClient("localhost", 6379);
RedisClient c = new RedisClient(RedisRunner.getDefaultRedisServerBindAddressAndPort());
RedisConnection conn = c.connect();
for (int i = 0; i < 50; i++) {
@ -173,7 +174,7 @@ public class RedisClientTest {
@Test
public void testPipelineBigResponse() throws InterruptedException, ExecutionException {
RedisClient c = new RedisClient("localhost", 6379);
RedisClient c = new RedisClient(RedisRunner.getDefaultRedisServerBindAddressAndPort());
RedisConnection conn = c.connect();
List<CommandData<?, ?>> commands = new ArrayList<CommandData<?, ?>>();

95
redisson/src/test/java/org/redisson/RedisRunner.java
Unescape Escape View File

@ -5,6 +5,7 @@ import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Inet4Address;
import java.net.ServerSocket;
import java.net.URL;
import java.nio.file.Paths;
import java.util.ArrayList;
@ -179,6 +180,8 @@ public class RedisRunner {
private boolean randomDir = false;
private ArrayList<String> bindAddr = new ArrayList<>();
private int port = 6379;
private int retryCount = Integer.MAX_VALUE;
private boolean randomPort = false;
{
this.options.put(REDIS_OPTIONS.BINARY_PATH, RedissonRuntimeEnvironment.redisBinaryPath);
@ -228,11 +231,31 @@ public class RedisRunner {
return new RedisProcess(p, runner);
}
public RedisProcess run() throws IOException, InterruptedException {
public RedisProcess run() throws IOException, InterruptedException, FailedToStartRedisException {
if (!options.containsKey(REDIS_OPTIONS.DIR)) {
options.put(REDIS_OPTIONS.DIR, defaultDir);
addConfigOption(REDIS_OPTIONS.DIR, defaultDir);
}
return runWithOptions(this, options.values().toArray(new String[0]));
if (randomPort) {
for (int i = 0; i < retryCount; i++) {
this.port = findFreePort();
addConfigOption(REDIS_OPTIONS.PORT, this.port);
try {
return runAndCheck();
} catch (FailedToStartRedisException e) {
}
}
throw new FailedToStartRedisException();
} else {
return runAndCheck();
}
}
public RedisProcess runAndCheck() throws IOException, InterruptedException, FailedToStartRedisException {
RedisProcess rp = runWithOptions(this, options.values().toArray(new String[0]));
if (rp.redisProcess.waitFor(1000, TimeUnit.MILLISECONDS)) {
throw new FailedToStartRedisException();
}
return rp;
}
private void addConfigOption(REDIS_OPTIONS option, Object... args) {
@ -266,9 +289,21 @@ public class RedisRunner {
public RedisRunner port(int port) {
this.port = port;
this.randomPort = false;
addConfigOption(REDIS_OPTIONS.PORT, port);
return this;
}
public RedisRunner randomPort() {
return randomPort(Integer.MAX_VALUE);
}
public RedisRunner randomPort(int retryCount) {
this.randomPort = true;
this.retryCount = retryCount;
options.remove(REDIS_OPTIONS.PORT);
return this;
}
public int getPort() {
return this.port;
@ -743,13 +778,24 @@ public class RedisRunner {
}
return redisVersion;
}
public int getRedisServerPort() {
return runner.getPort();
}
public String getRedisServerBindAddress() {
return runner.getInitialBindAddr();
}
public String getRedisServerAddressAndPort() {
return getRedisServerBindAddress() + ":" + getRedisServerPort();
}
}
public static RedisRunner.RedisProcess startDefaultRedisServerInstance() throws IOException, InterruptedException {
public static RedisRunner.RedisProcess startDefaultRedisServerInstance() throws IOException, InterruptedException, FailedToStartRedisException {
if (defaultRedisInstance == null) {
System.out.println("REDIS RUNNER: Starting up default instance...");
defaultRedisInstance = new RedisRunner().nosave().randomDir().run();
defaultRedisInstance = new RedisRunner().nosave().randomDir().randomPort().run();
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
try {
shutDownDefaultRedisServerInstance();
@ -785,4 +831,41 @@ public class RedisRunner {
public static RedisRunner.RedisProcess getDefaultRedisServerInstance() {
return defaultRedisInstance;
}
public static String getDefaultRedisServerBindAddressAndPort() {
return defaultRedisInstance.getRedisServerBindAddress()
+ ":"
+ defaultRedisInstance.getRedisServerPort();
}
public static int findFreePort() {
ServerSocket socket = null;
try {
socket = new ServerSocket(0);
socket.setReuseAddress(true);
int port = socket.getLocalPort();
try {
socket.close();
} catch (IOException e) {
// Ignore IOException on close()
}
return port;
} catch (IOException e) {
} finally {
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
}
}
}
throw new IllegalStateException("Could not find a free TCP/IP port.");
}
public static class FailedToStartRedisException extends RuntimeException {
private FailedToStartRedisException() {
}
}
}

22
redisson/src/test/java/org/redisson/RedissonBlockingQueueTest.java
Unescape Escape View File

@ -31,13 +31,13 @@ public class RedissonBlockingQueueTest extends BaseTest {
@Test
public void testPollWithBrokenConnection() throws IOException, InterruptedException, ExecutionException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
final RBlockingQueue<Integer> queue1 = redisson.getBlockingQueue("queue:pollTimeout");
RFuture<Integer> f = queue1.pollAsync(5, TimeUnit.SECONDS);
@ -53,13 +53,13 @@ public class RedissonBlockingQueueTest extends BaseTest {
@Test
public void testPollReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
final AtomicBoolean executed = new AtomicBoolean();
@ -85,7 +85,7 @@ public class RedissonBlockingQueueTest extends BaseTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();
@ -105,13 +105,13 @@ public class RedissonBlockingQueueTest extends BaseTest {
@Test
public void testPollAsyncReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
RBlockingQueue<Integer> queue1 = redisson.getBlockingQueue("queue:pollany");
@ -120,7 +120,7 @@ public class RedissonBlockingQueueTest extends BaseTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();
@ -141,13 +141,13 @@ public class RedissonBlockingQueueTest extends BaseTest {
@Test
public void testTakeReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
RBlockingQueue<Integer> queue1 = redisson.getBlockingQueue("testTakeReattach");
RFuture<Integer> f = queue1.takeAsync();
@ -155,7 +155,7 @@ public class RedissonBlockingQueueTest extends BaseTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();

22
redisson/src/test/java/org/redisson/RedissonBoundedBlockingQueueTest.java
Unescape Escape View File

@ -220,13 +220,13 @@ public class RedissonBoundedBlockingQueueTest extends BaseTest {
@Test
public void testPollWithBrokenConnection() throws IOException, InterruptedException, ExecutionException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
final RBoundedBlockingQueue<Integer> queue1 = redisson.getBoundedBlockingQueue("bounded-queue:pollTimeout");
assertThat(queue1.trySetCapacity(5)).isTrue();
@ -243,13 +243,13 @@ public class RedissonBoundedBlockingQueueTest extends BaseTest {
@Test
public void testPollReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
redisson.getKeys().flushall();
@ -277,7 +277,7 @@ public class RedissonBoundedBlockingQueueTest extends BaseTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();
@ -298,13 +298,13 @@ public class RedissonBoundedBlockingQueueTest extends BaseTest {
@Test
public void testPollAsyncReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
RBoundedBlockingQueue<Integer> queue1 = redisson.getBoundedBlockingQueue("queue:pollany");
@ -313,7 +313,7 @@ public class RedissonBoundedBlockingQueueTest extends BaseTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();
@ -335,13 +335,13 @@ public class RedissonBoundedBlockingQueueTest extends BaseTest {
@Test
public void testTakeReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
redisson.getKeys().flushall();
@ -352,7 +352,7 @@ public class RedissonBoundedBlockingQueueTest extends BaseTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();

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

@ -373,9 +373,9 @@ public class RedissonMapCacheReactiveTest extends BaseReactiveTest {
@Test
public void testEmptyRemove() {
RMapCacheReactive<Integer, Integer> map = redisson.getMapCache("simple");
assertThat(sync(map.remove(1, 3))).isEqualTo(0);
assertThat(sync(map.remove(1, 3))).isEqualTo(Boolean.FALSE);
sync(map.put(4, 5));
assertThat(sync(map.remove(4, 5))).isEqualTo(1);
assertThat(sync(map.remove(4, 5))).isEqualTo(Boolean.TRUE);
}
@Test

20
redisson/src/test/java/org/redisson/RedissonMultiLockTest.java
Unescape Escape View File

@ -19,10 +19,10 @@ public class RedissonMultiLockTest {
@Test
public void testMultiThreads() throws IOException, InterruptedException {
RedisProcess redis1 = redisTestMultilockInstance(6320);
RedisProcess redis1 = redisTestMultilockInstance();
Config config1 = new Config();
config1.useSingleServer().setAddress("127.0.0.1:6320");
config1.useSingleServer().setAddress(redis1.getRedisServerAddressAndPort());
RedissonClient client = Redisson.create(config1);
RLock lock1 = client.getLock("lock1");
@ -54,15 +54,15 @@ public class RedissonMultiLockTest {
@Test
public void test() throws IOException, InterruptedException {
RedisProcess redis1 = redisTestMultilockInstance(6320);
RedisProcess redis2 = redisTestMultilockInstance(6321);
RedisProcess redis3 = redisTestMultilockInstance(6322);
RedisProcess redis1 = redisTestMultilockInstance();
RedisProcess redis2 = redisTestMultilockInstance();
RedisProcess redis3 = redisTestMultilockInstance();
NioEventLoopGroup group = new NioEventLoopGroup();
RedissonClient client1 = createClient(group, "127.0.0.1:6320");
RedissonClient client2 = createClient(group, "127.0.0.1:6321");
RedissonClient client3 = createClient(group, "127.0.0.1:6322");
RedissonClient client1 = createClient(group, redis1.getRedisServerAddressAndPort());
RedissonClient client2 = createClient(group, redis2.getRedisServerAddressAndPort());
RedissonClient client3 = createClient(group, redis3.getRedisServerAddressAndPort());
final RLock lock1 = client1.getLock("lock1");
final RLock lock2 = client2.getLock("lock2");
@ -109,11 +109,11 @@ public class RedissonMultiLockTest {
return client1;
}
private RedisProcess redisTestMultilockInstance(int port) throws IOException, InterruptedException {
private RedisProcess redisTestMultilockInstance() throws IOException, InterruptedException {
return new RedisRunner()
.nosave()
.randomDir()
.port(port)
.randomPort()
.run();
}

44
redisson/src/test/java/org/redisson/RedissonRedLockTest.java
Unescape Escape View File

@ -21,11 +21,11 @@ public class RedissonRedLockTest {
@Test
public void testLockFailed() throws IOException, InterruptedException {
RedisProcess redis1 = redisTestMultilockInstance(6320);
RedisProcess redis2 = redisTestMultilockInstance(6321);
RedisProcess redis1 = redisTestMultilockInstance();
RedisProcess redis2 = redisTestMultilockInstance();
RedissonClient client1 = createClient("127.0.0.1:6320");
RedissonClient client2 = createClient("127.0.0.1:6321");
RedissonClient client1 = createClient(redis1.getRedisServerAddressAndPort());
RedissonClient client2 = createClient(redis2.getRedisServerAddressAndPort());
RLock lock1 = client1.getLock("lock1");
RLock lock2 = client1.getLock("lock2");
@ -59,11 +59,11 @@ public class RedissonRedLockTest {
@Test
public void testLockSuccess() throws IOException, InterruptedException {
RedisProcess redis1 = redisTestMultilockInstance(6320);
RedisProcess redis2 = redisTestMultilockInstance(6321);
RedisProcess redis1 = redisTestMultilockInstance();
RedisProcess redis2 = redisTestMultilockInstance();
RedissonClient client1 = createClient("127.0.0.1:6320");
RedissonClient client2 = createClient("127.0.0.1:6321");
RedissonClient client1 = createClient(redis1.getRedisServerAddressAndPort());
RedissonClient client2 = createClient(redis2.getRedisServerAddressAndPort());
RLock lock1 = client1.getLock("lock1");
RLock lock2 = client1.getLock("lock2");
@ -105,11 +105,11 @@ public class RedissonRedLockTest {
@Test
public void testConnectionFailed() throws IOException, InterruptedException {
RedisProcess redis1 = redisTestMultilockInstance(6320);
RedisProcess redis2 = redisTestMultilockInstance(6321);
RedisProcess redis1 = redisTestMultilockInstance();
RedisProcess redis2 = redisTestMultilockInstance();
RedissonClient client1 = createClient("127.0.0.1:6320");
RedissonClient client2 = createClient("127.0.0.1:6321");
RedissonClient client1 = createClient(redis1.getRedisServerAddressAndPort());
RedissonClient client2 = createClient(redis2.getRedisServerAddressAndPort());
RLock lock1 = client1.getLock("lock1");
RLock lock2 = client1.getLock("lock2");
@ -142,10 +142,10 @@ public class RedissonRedLockTest {
// @Test
public void testMultiThreads() throws IOException, InterruptedException {
RedisProcess redis1 = redisTestMultilockInstance(6320);
RedisProcess redis1 = redisTestMultilockInstance();
Config config1 = new Config();
config1.useSingleServer().setAddress("127.0.0.1:6320");
config1.useSingleServer().setAddress(redis1.getRedisServerAddressAndPort());
RedissonClient client = Redisson.create(config1);
RLock lock1 = client.getLock("lock1");
@ -177,15 +177,15 @@ public class RedissonRedLockTest {
// @Test
public void test() throws IOException, InterruptedException {
RedisProcess redis1 = redisTestMultilockInstance(6320);
RedisProcess redis2 = redisTestMultilockInstance(6321);
RedisProcess redis3 = redisTestMultilockInstance(6322);
RedisProcess redis1 = redisTestMultilockInstance();
RedisProcess redis2 = redisTestMultilockInstance();
RedisProcess redis3 = redisTestMultilockInstance();
NioEventLoopGroup group = new NioEventLoopGroup();
RedissonClient client1 = createClient(group, "127.0.0.1:6320");
RedissonClient client2 = createClient(group, "127.0.0.1:6321");
RedissonClient client3 = createClient(group, "127.0.0.1:6322");
RedissonClient client1 = createClient(group, redis1.getRedisServerAddressAndPort());
RedissonClient client2 = createClient(group, redis2.getRedisServerAddressAndPort());
RedissonClient client3 = createClient(group, redis3.getRedisServerAddressAndPort());
final RLock lock1 = client1.getLock("lock1");
final RLock lock2 = client2.getLock("lock2");
@ -232,11 +232,11 @@ public class RedissonRedLockTest {
return client1;
}
private RedisProcess redisTestMultilockInstance(int port) throws IOException, InterruptedException {
private RedisProcess redisTestMultilockInstance() throws IOException, InterruptedException {
return new RedisRunner()
.nosave()
.randomDir()
.port(port)
.randomPort()
.run();
}

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

@ -249,7 +249,7 @@ public class RedissonSemaphoreTest extends BaseConcurrentTest {
@Test
public void testConcurrency_MultiInstance_10_permits() throws InterruptedException {
Assume.assumeFalse(Boolean.valueOf(System.getProperty("travisEnv")));
Assume.assumeFalse(RedissonRuntimeEnvironment.isTravis);
int iterations = 100;
final AtomicInteger lockedCounter = new AtomicInteger();

45
redisson/src/test/java/org/redisson/RedissonTest.java
Unescape Escape View File

@ -24,7 +24,6 @@ import org.redisson.api.RedissonClient;
import org.redisson.client.RedisConnectionException;
import org.redisson.client.RedisException;
import org.redisson.client.RedisOutOfMemoryException;
import org.redisson.client.WriteRedisConnectionException;
import org.redisson.client.protocol.decoder.ListScanResult;
import org.redisson.codec.SerializationCodec;
import org.redisson.config.Config;
@ -109,7 +108,7 @@ public class RedissonTest {
@Test(expected = RedisException.class)
public void testSer() {
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6379");
config.useSingleServer().setAddress(RedisRunner.getDefaultRedisServerBindAddressAndPort());
config.setCodec(new SerializationCodec());
RedissonClient r = Redisson.create(config);
r.getMap("test").put("1", new Dummy());
@ -120,7 +119,7 @@ public class RedissonTest {
RedisProcess p = redisTestSmallMemory();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319").setTimeout(100000);
config.useSingleServer().setAddress(p.getRedisServerAddressAndPort()).setTimeout(100000);
try {
RedissonClient r = Redisson.create(config);
@ -138,7 +137,7 @@ public class RedissonTest {
RedisProcess p = redisTestSmallMemory();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319").setTimeout(100000);
config.useSingleServer().setAddress(p.getRedisServerAddressAndPort()).setTimeout(100000);
try {
RedissonClient r = Redisson.create(config);
@ -155,7 +154,7 @@ public class RedissonTest {
public void testConfigValidation() {
Config redissonConfig = new Config();
redissonConfig.useSingleServer()
.setAddress("127.0.0.1:6379")
.setAddress(RedisRunner.getDefaultRedisServerBindAddressAndPort())
.setConnectionPoolSize(2);
Redisson.create(redissonConfig);
}
@ -163,13 +162,13 @@ public class RedissonTest {
@Test
public void testConnectionListener() throws IOException, InterruptedException, TimeoutException {
RedisProcess p = redisTestConnection();
final RedisProcess p = redisTestConnection();
final AtomicInteger connectCounter = new AtomicInteger();
final AtomicInteger disconnectCounter = new AtomicInteger();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(p.getRedisServerAddressAndPort());
RedissonClient r = Redisson.create(config);
@ -177,13 +176,13 @@ public class RedissonTest {
@Override
public void onDisconnect(InetSocketAddress addr) {
assertThat(addr).isEqualTo(new InetSocketAddress("127.0.0.1", 6319));
assertThat(addr).isEqualTo(new InetSocketAddress(p.getRedisServerBindAddress(), p.getRedisServerPort()));
disconnectCounter.incrementAndGet();
}
@Override
public void onConnect(InetSocketAddress addr) {
assertThat(addr).isEqualTo(new InetSocketAddress("127.0.0.1", 6319));
assertThat(addr).isEqualTo(new InetSocketAddress(p.getRedisServerBindAddress(), p.getRedisServerPort()));
connectCounter.incrementAndGet();
}
});
@ -198,13 +197,17 @@ public class RedissonTest {
} catch (Exception e) {
}
p = redisTestConnection();
RedisProcess pp = new RedisRunner()
.nosave()
.port(p.getRedisServerPort())
.randomDir()
.run();
r.getBucket("1").get();
r.shutdown();
Assert.assertEquals(0, p.stop());
Assert.assertEquals(0, pp.stop());
await().atMost(1, TimeUnit.SECONDS).until(() -> assertThat(connectCounter.get()).isEqualTo(1));
await().until(() -> assertThat(disconnectCounter.get()).isEqualTo(1));
@ -213,7 +216,7 @@ public class RedissonTest {
@Test
public void testShutdown() {
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6379");
config.useSingleServer().setAddress(RedisRunner.getDefaultRedisServerBindAddressAndPort());
RedissonClient r = Redisson.create(config);
Assert.assertFalse(r.isShuttingDown());
@ -292,7 +295,7 @@ public class RedissonTest {
@Test(expected = RedisConnectionException.class)
public void testSingleConnectionFail() throws InterruptedException {
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:1111");
config.useSingleServer().setAddress("127.99.0.1:1111");
Redisson.create(config);
Thread.sleep(1500);
@ -301,7 +304,7 @@ public class RedissonTest {
@Test(expected = RedisConnectionException.class)
public void testClusterConnectionFail() throws InterruptedException {
Config config = new Config();
config.useClusterServers().addNodeAddress("127.0.0.1:1111");
config.useClusterServers().addNodeAddress("127.99.0.1:1111");
Redisson.create(config);
Thread.sleep(1500);
@ -310,7 +313,7 @@ public class RedissonTest {
@Test(expected = RedisConnectionException.class)
public void testElasticacheConnectionFail() throws InterruptedException {
Config config = new Config();
config.useElasticacheServers().addNodeAddress("127.0.0.1:1111");
config.useElasticacheServers().addNodeAddress("127.99.0.1:1111");
Redisson.create(config);
Thread.sleep(1500);
@ -319,7 +322,7 @@ public class RedissonTest {
@Test(expected = RedisConnectionException.class)
public void testMasterSlaveConnectionFail() throws InterruptedException {
Config config = new Config();
config.useMasterSlaveServers().setMasterAddress("127.0.0.1:1111");
config.useMasterSlaveServers().setMasterAddress("127.99.0.1:1111");
Redisson.create(config);
Thread.sleep(1500);
@ -328,7 +331,7 @@ public class RedissonTest {
@Test(expected = RedisConnectionException.class)
public void testSentinelConnectionFail() throws InterruptedException {
Config config = new Config();
config.useSentinelServers().addSentinelAddress("127.0.0.1:1111");
config.useSentinelServers().addSentinelAddress("127.99.0.1:1111");
Redisson.create(config);
Thread.sleep(1500);
@ -336,12 +339,12 @@ public class RedissonTest {
@Test
public void testManyConnections() {
Assume.assumeFalse(Boolean.valueOf(System.getProperty("travisEnv")));
Assume.assumeFalse(RedissonRuntimeEnvironment.isTravis);
Config redisConfig = new Config();
redisConfig.useSingleServer()
.setConnectionMinimumIdleSize(10000)
.setConnectionPoolSize(10000)
.setAddress("localhost:6379");
.setAddress(RedisRunner.getDefaultRedisServerBindAddressAndPort());
RedissonClient r = Redisson.create(redisConfig);
r.shutdown();
}
@ -351,7 +354,7 @@ public class RedissonTest {
.maxmemory("1mb")
.nosave()
.randomDir()
.port(6319)
.randomPort()
.run();
}
@ -359,7 +362,7 @@ public class RedissonTest {
return new RedisRunner()
.nosave()
.randomDir()
.port(6319)
.randomPort()
.run();
}

8
redisson/src/test/java/org/redisson/RedissonTopicPatternTest.java
Unescape Escape View File

@ -25,10 +25,8 @@ import org.redisson.api.RPatternTopic;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.redisson.api.listener.BasePatternStatusListener;
import org.redisson.api.listener.MessageListener;
import org.redisson.api.listener.PatternMessageListener;
import org.redisson.api.listener.PatternStatusListener;
import org.redisson.api.listener.StatusListener;
import org.redisson.config.Config;
public class RedissonTopicPatternTest {
@ -272,13 +270,13 @@ public class RedissonTopicPatternTest {
@Test
public void testReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
final AtomicBoolean executed = new AtomicBoolean();
@ -296,7 +294,7 @@ public class RedissonTopicPatternTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();

9
redisson/src/test/java/org/redisson/RedissonTopicTest.java
Unescape Escape View File

@ -23,7 +23,6 @@ import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.redisson.RedisRunner.RedisProcess;
import org.redisson.api.RBlockingQueue;
import org.redisson.api.RSet;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
@ -225,7 +224,9 @@ public class RedissonTopicTest {
CountDownLatch latch = new CountDownLatch(1);
topic.addListener((channel, msg) -> {
for (int j = 0; j < 1000; j++) {
System.out.println("start: " + j);
redissonSet.contains("" + j);
System.out.println("end: " + j);
}
latch.countDown();
});
@ -427,13 +428,13 @@ public class RedissonTopicTest {
@Test
public void testReattach() throws InterruptedException, IOException, ExecutionException, TimeoutException {
RedisProcess runner = new RedisRunner()
.port(6319)
.nosave()
.randomDir()
.randomPort()
.run();
Config config = new Config();
config.useSingleServer().setAddress("127.0.0.1:6319");
config.useSingleServer().setAddress(runner.getRedisServerAddressAndPort());
RedissonClient redisson = Redisson.create(config);
final AtomicBoolean executed = new AtomicBoolean();
@ -451,7 +452,7 @@ public class RedissonTopicTest {
runner.stop();
runner = new RedisRunner()
.port(6319)
.port(runner.getRedisServerPort())
.nosave()
.randomDir()
.run();

19
redisson/src/test/java/org/redisson/connection/balancer/WeightedRoundRobinBalancerTest.java
Unescape Escape View File

@ -1,12 +1,10 @@
package org.redisson.connection.balancer;
import static com.jayway.awaitility.Awaitility.await;
import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.redisson.RedisRunner;
@ -24,18 +22,18 @@ public class WeightedRoundRobinBalancerTest {
RedisProcess slave = null;
RedissonClient client = null;
try {
master = redisTestInstance(6379);
slave = redisTestInstance(6380);
master = redisTestInstance();
slave = redisTestInstance();
Map<String, Integer> weights = new HashMap<>();
weights.put("127.0.0.1:6379", 1);
weights.put("127.0.0.1:6380", 2);
weights.put(master.getRedisServerAddressAndPort(), 1);
weights.put(slave.getRedisServerAddressAndPort(), 2);
Config config = new Config();
config.useMasterSlaveServers()
.setReadMode(ReadMode.SLAVE)
.setMasterAddress("127.0.0.1:6379")
.addSlaveAddress("127.0.0.1:6380")
.setMasterAddress(master.getRedisServerAddressAndPort())
.addSlaveAddress(slave.getRedisServerAddressAndPort())
.setLoadBalancer(new WeightedRoundRobinBalancer(weights, 1));
client = Redisson.create(config);
@ -60,10 +58,11 @@ public class WeightedRoundRobinBalancerTest {
}
}
private RedisProcess redisTestInstance(int port) throws IOException, InterruptedException {
private RedisProcess redisTestInstance() throws IOException, InterruptedException {
return new RedisRunner()
.nosave()
.randomDir()
.port(port).run();
.randomPort()
.run();
}
}

48
redisson/src/test/java/org/redisson/executor/RedissonExecutorServiceTest.java
Unescape Escape View File

@ -14,12 +14,16 @@ import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.redisson.BaseTest;
import static org.redisson.BaseTest.createConfig;
import org.redisson.RedissonNode;
import org.redisson.RedissonRuntimeEnvironment;
import org.redisson.api.RExecutorService;
import org.redisson.api.RScheduledExecutorService;
import org.redisson.config.Config;
@ -31,22 +35,46 @@ public class RedissonExecutorServiceTest extends BaseTest {
@BeforeClass
public static void beforeClass() throws IOException, InterruptedException {
BaseTest.beforeClass();
Config config = createConfig();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
if (!RedissonRuntimeEnvironment.isTravis) {
BaseTest.beforeClass();
Config config = createConfig();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
}
}
@AfterClass
public static void afterClass() throws IOException, InterruptedException {
BaseTest.afterClass();
node.shutdown();
if (!RedissonRuntimeEnvironment.isTravis) {
BaseTest.afterClass();
node.shutdown();
}
}
@Before
@Override
public void before() throws IOException, InterruptedException {
if (RedissonRuntimeEnvironment.isTravis) {
super.before();
Config config = createConfig();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
}
}
@After
@Override
public void after() throws InterruptedException {
if (RedissonRuntimeEnvironment.isTravis) {
super.after();
node.shutdown();
}
}
private void cancel(ScheduledFuture<?> future1) throws InterruptedException, ExecutionException {
assertThat(future1.cancel(true)).isTrue();
boolean canceled = false;

47
redisson/src/test/java/org/redisson/executor/RedissonScheduledExecutorServiceTest.java
Unescape Escape View File

@ -8,13 +8,16 @@ import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.redisson.BaseTest;
import org.redisson.CronSchedule;
import org.redisson.RedissonNode;
import org.redisson.RedissonRuntimeEnvironment;
import org.redisson.api.RScheduledExecutorService;
import org.redisson.api.RScheduledFuture;
import org.redisson.config.Config;
@ -26,20 +29,44 @@ public class RedissonScheduledExecutorServiceTest extends BaseTest {
@BeforeClass
public static void beforeClass() throws IOException, InterruptedException {
BaseTest.beforeClass();
Config config = createConfig();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
if (!RedissonRuntimeEnvironment.isTravis) {
BaseTest.beforeClass();
Config config = createConfig();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
}
}
@AfterClass
public static void afterClass() throws IOException, InterruptedException {
BaseTest.afterClass();
node.shutdown();
if (!RedissonRuntimeEnvironment.isTravis) {
BaseTest.afterClass();
node.shutdown();
}
}
@Before
@Override
public void before() throws IOException, InterruptedException {
if (RedissonRuntimeEnvironment.isTravis) {
super.before();
Config config = createConfig();
RedissonNodeConfig nodeConfig = new RedissonNodeConfig(config);
nodeConfig.setExecutorServiceWorkers(Collections.singletonMap("test", 1));
node = RedissonNode.create(nodeConfig);
node.start();
}
}
@After
@Override
public void after() throws InterruptedException {
if (RedissonRuntimeEnvironment.isTravis) {
super.after();
node.shutdown();
}
}
@Test

Write Preview
Loading…
Cancel
Save