Add timeouts to all resource access in tests.

atomix · Feb 10, 2016 · f03c1e7 · f03c1e7
1 parent c054a8b
commit f03c1e7
Show file tree

Hide file tree

Showing 11 changed files with 49 additions and 37 deletions.
diff --git a/core/src/test/java/io/atomix/AbstractAtomixTest.java b/core/src/test/java/io/atomix/AbstractAtomixTest.java
@@ -28,6 +28,8 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.function.Function;
 
 /**
@@ -81,8 +83,8 @@ protected void cleanup() throws Throwable {
   protected <T extends Resource> Function<Atomix, T> get(String key, Class<? super T> type) {
     return a -> {
       try {
-        return a.get(key, type).get();
-      } catch (InterruptedException | ExecutionException e) {
+        return a.get(key, type).get(5, TimeUnit.SECONDS);
+      } catch (InterruptedException | ExecutionException | TimeoutException e) {
         throw new RuntimeException(e);
       }
     };
@@ -143,7 +145,7 @@ protected List<Atomix> createReplicas(int nodes, int quorumHint, int backupCount
       replicas.add(atomix);
     }
 
-    await(10000 * nodes, nodes);
+    await(30000 * nodes, nodes);
     return replicas;
   }
 

diff --git a/core/src/test/java/io/atomix/AtomixClientTest.java b/core/src/test/java/io/atomix/AtomixClientTest.java
@@ -28,6 +28,7 @@
 import org.testng.annotations.Test;
 
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Client server test.
@@ -76,7 +77,7 @@ private void testSubmitCommand(Consistency consistency) throws Throwable {
 
     Atomix client = createClient();
 
-    TestResource resource = client.get("test", TestResource.class).get();
+    TestResource resource = client.get("test", TestResource.class).get(5, TimeUnit.SECONDS);
 
     resource.with(consistency).command("Hello world!").thenAccept(result -> {
       threadAssertEquals(result, "Hello world!");
@@ -115,7 +116,7 @@ private void testSubmitQuery(Consistency consistency) throws Throwable {
 
     Atomix client = createClient();
 
-    TestResource resource = client.get("test", TestResource.class).get();
+    TestResource resource = client.get("test", TestResource.class).get(5, TimeUnit.SECONDS);
 
     resource.with(consistency).query("Hello world!").thenAccept(result -> {
       threadAssertEquals(result, "Hello world!");
@@ -134,8 +135,8 @@ public void testGetConcurrency() throws Throwable {
     Atomix client1 = createClient();
     Atomix client2 = createClient();
 
-    ValueResource resource1 = client1.get("test", ValueResource.class).get();
-    ValueResource resource2 = client2.get("test", ValueResource.class).get();
+    ValueResource resource1 = client1.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
+    ValueResource resource2 = client2.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
 
     resource1.set("Hello world!").join();
 
@@ -155,8 +156,8 @@ public void testCreateConcurrency() throws Throwable {
     Atomix client1 = createClient();
     Atomix client2 = createClient();
 
-    ValueResource resource1 = client1.get("test", ValueResource.class).get();
-    ValueResource resource2 = client2.get("test", ValueResource.class).get();
+    ValueResource resource1 = client1.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
+    ValueResource resource2 = client2.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
 
     resource1.set("Hello world!").join();
 
@@ -176,8 +177,8 @@ public void testGetCreateConcurrency() throws Throwable {
     Atomix client1 = createClient();
     Atomix client2 = createClient();
 
-    ValueResource resource1 = client1.get("test", ValueResource.class).get();
-    ValueResource resource2 = client2.get("test", ValueResource.class).get();
+    ValueResource resource1 = client1.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
+    ValueResource resource2 = client2.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
 
     resource1.set("Hello world!").join();
 
@@ -201,14 +202,14 @@ public void testGetResourceKeys() throws Throwable {
     });
     await(10000);
 
-    client.get("test", TestResource.class).get();
+    client.get("test", TestResource.class).get(5, TimeUnit.SECONDS);
     client.keys().thenAccept(result -> {
       threadAssertTrue(result.size() == 1 && result.contains("test"));
       resume();
     });
     await(10000);
 
-    client.get("value", ValueResource.class).get();
+    client.get("value", ValueResource.class).get(5, TimeUnit.SECONDS);
     client.keys().thenAccept(result -> {
       threadAssertTrue(result.size() == 2 && result.contains("test") && result.contains("value"));
       resume();

diff --git a/core/src/test/java/io/atomix/AtomixGroupTest.java b/core/src/test/java/io/atomix/AtomixGroupTest.java
@@ -20,6 +20,7 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 import static org.testng.Assert.*;
@@ -53,7 +54,7 @@ private void testGroup(Atomix client1, Atomix client2, Function<Atomix, Distribu
     DistributedGroup group1 = factory.apply(client1);
     DistributedGroup group2 = factory.apply(client2);
 
-    LocalGroupMember localMember = group2.join().get();
+    LocalGroupMember localMember = group2.join().get(5, TimeUnit.SECONDS);
     assertEquals(group2.members().size(), 1);
 
     group1.join().thenRun(() -> {

diff --git a/core/src/test/java/io/atomix/AtomixLongTest.java b/core/src/test/java/io/atomix/AtomixLongTest.java
@@ -19,6 +19,7 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 /**
@@ -48,7 +49,7 @@ public void testReplicaLongGet() throws Throwable {
    */
   private void testLong(Atomix client1, Atomix client2, Function<Atomix, DistributedLong> factory) throws Throwable {
     DistributedLong value1 = factory.apply(client1);
-    value1.set(10L).join();
+    value1.set(10L).get(5, TimeUnit.SECONDS);
     value1.getAndIncrement().thenAccept(result -> {
       threadAssertEquals(result, 10L);
       resume();

diff --git a/core/src/test/java/io/atomix/AtomixMapTest.java b/core/src/test/java/io/atomix/AtomixMapTest.java
@@ -19,6 +19,7 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 /**
@@ -48,7 +49,7 @@ public void testReplicaMapGet() throws Throwable {
    */
   private void testMap(Atomix client1, Atomix client2, Function<Atomix, DistributedMap<String, String>> factory) throws Throwable {
     DistributedMap<String, String> map1 = factory.apply(client1);
-    map1.put("foo", "Hello world!").join();
+    map1.put("foo", "Hello world!").get(5, TimeUnit.SECONDS);
     map1.get("foo").thenAccept(result -> {
       threadAssertEquals(result, "Hello world!");
       resume();

diff --git a/core/src/test/java/io/atomix/AtomixMessageBusTest.java b/core/src/test/java/io/atomix/AtomixMessageBusTest.java
@@ -20,6 +20,7 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 /**
@@ -51,8 +52,8 @@ private void testMessageBus(Atomix client1, Atomix client2, Function<Atomix, Dis
     DistributedMessageBus bus1 = factory.apply(client1);
     DistributedMessageBus bus2 = factory.apply(client2);
 
-    bus1.open(new Address("localhost", 6000)).join();
-    bus2.open(new Address("localhost", 6001)).join();
+    bus1.open(new Address("localhost", 6000)).get(5, TimeUnit.SECONDS);
+    bus2.open(new Address("localhost", 6001)).get(5, TimeUnit.SECONDS);
 
     bus1.<String>consumer("test", message -> {
       threadAssertEquals(message, "Hello world!");

diff --git a/core/src/test/java/io/atomix/AtomixMultiMapTest.java b/core/src/test/java/io/atomix/AtomixMultiMapTest.java
@@ -19,6 +19,7 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 /**
@@ -48,8 +49,8 @@ public void testReplicaMultiMapGet() throws Throwable {
    */
   private void testMultiMap(Atomix client1, Atomix client2, Function<Atomix, DistributedMultiMap<String, String>> factory) throws Throwable {
     DistributedMultiMap<String, String> map1 = factory.apply(client1);
-    map1.put("foo", "Hello world!").join();
-    map1.put("foo", "Hello world again!").join();
+    map1.put("foo", "Hello world!").get(5, TimeUnit.SECONDS);
+    map1.put("foo", "Hello world again!").get(5, TimeUnit.SECONDS);
     map1.get("foo").thenAccept(result -> {
       threadAssertTrue(result.contains("Hello world!"));
       threadAssertTrue(result.contains("Hello world again!"));

diff --git a/core/src/test/java/io/atomix/AtomixQueueTest.java b/core/src/test/java/io/atomix/AtomixQueueTest.java
@@ -19,6 +19,7 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 /**
@@ -48,8 +49,8 @@ public void testReplicaQueueGet() throws Throwable {
    */
   private void testQueue(Atomix client1, Atomix client2, Function<Atomix, DistributedQueue<String>> factory) throws Throwable {
     DistributedQueue<String> queue1 = factory.apply(client1);
-    queue1.offer("Hello world!").join();
-    queue1.offer("Hello world again!").join();
+    queue1.offer("Hello world!").get(5, TimeUnit.SECONDS);
+    queue1.offer("Hello world again!").get(5, TimeUnit.SECONDS);
     queue1.poll().thenAccept(result -> {
       threadAssertEquals(result, "Hello world!");
       resume();

diff --git a/core/src/test/java/io/atomix/AtomixReplicaTest.java b/core/src/test/java/io/atomix/AtomixReplicaTest.java
@@ -29,6 +29,7 @@
 
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
 
 import static org.testng.Assert.assertEquals;
 
@@ -77,7 +78,7 @@ public void testSubmitCommandWithAtomicConsistency() throws Throwable {
   private void testSubmitCommand(Consistency consistency) throws Throwable {
     Atomix replica = createReplicas(8, 3, 1).iterator().next();
 
-    TestResource resource = replica.get("test", TestResource.class).get();
+    TestResource resource = replica.get("test", TestResource.class).get(5, TimeUnit.SECONDS);
 
     resource.with(consistency).command("Hello world!").thenAccept(result -> {
       threadAssertEquals(result, "Hello world!");
@@ -114,7 +115,7 @@ public void testSubmitQueryWithAtomicConsistency() throws Throwable {
   private void testSubmitQuery(Consistency consistency) throws Throwable {
     Atomix replica = createReplicas(8, 3, 1).iterator().next();
 
-    TestResource resource = replica.get("test", TestResource.class).get();
+    TestResource resource = replica.get("test", TestResource.class).get(5, TimeUnit.SECONDS);
 
     resource.with(consistency).query("Hello world!").thenAccept(result -> {
       threadAssertEquals(result, "Hello world!");
@@ -131,12 +132,12 @@ public void testSubmitAll() throws Throwable {
     List<Atomix> replicas = createReplicas(8, 3, 1);
 
     for (Atomix replica : replicas) {
-      ValueResource resource = replica.get("test", ValueResource.class).get();
+      ValueResource resource = replica.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
       resource.set("Hello world!").thenRun(this::resume);
       await(10000);
     }
 
-    ValueResource resource = replicas.get(0).get("test", ValueResource.class).get();
+    ValueResource resource = replicas.get(0).get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
     resource.get().thenAccept(result -> {
       threadAssertEquals("Hello world!", result);
       resume();
@@ -153,8 +154,8 @@ public void testGetConcurrency() throws Throwable {
     Atomix replica1 = replicas.get(0);
     Atomix replica2 = replicas.get(1);
 
-    ValueResource resource1 = replica1.get("test", ValueResource.class).get();
-    ValueResource resource2 = replica2.get("test", ValueResource.class).get();
+    ValueResource resource1 = replica1.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
+    ValueResource resource2 = replica2.get("test", ValueResource.class).get(5, TimeUnit.SECONDS);
 
     resource1.set("Hello world!").join();
 
@@ -174,10 +175,10 @@ public void testOperateMany() throws Throwable {
     Atomix replica1 = replicas.get(0);
     Atomix replica2 = replicas.get(1);
 
-    ValueResource resource11 = replica1.get("test1", ValueResource.class).get();
-    ValueResource resource12 = replica2.get("test1", ValueResource.class).get();
-    ValueResource resource21 = replica1.get("test2", ValueResource.class).get();
-    ValueResource resource22 = replica2.get("test2", ValueResource.class).get();
+    ValueResource resource11 = replica1.get("test1", ValueResource.class).get(5, TimeUnit.SECONDS);
+    ValueResource resource12 = replica2.get("test1", ValueResource.class).get(5, TimeUnit.SECONDS);
+    ValueResource resource21 = replica1.get("test2", ValueResource.class).get(5, TimeUnit.SECONDS);
+    ValueResource resource22 = replica2.get("test2", ValueResource.class).get(5, TimeUnit.SECONDS);
 
     resource11.set("foo").join();
     assertEquals(resource12.get().get(), "foo");

diff --git a/core/src/test/java/io/atomix/AtomixSetTest.java b/core/src/test/java/io/atomix/AtomixSetTest.java
@@ -19,6 +19,7 @@
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 
+import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
 /**
@@ -49,8 +50,8 @@ public void testReplicaSetGet() throws Throwable {
    */
   private void testSet(Atomix client1, Atomix client2, Function<Atomix, DistributedSet<String>> factory) throws Throwable {
     DistributedSet<String> set1 = factory.apply(client1);
-    set1.add("Hello world!").join();
-    set1.add("Hello world again!").join();
+    set1.add("Hello world!").get(5, TimeUnit.SECONDS);
+    set1.add("Hello world again!").get(5, TimeUnit.SECONDS);
     set1.contains("Hello world!").thenAccept(result -> {
       threadAssertTrue(result);
       resume();

diff --git a/core/src/test/java/io/atomix/ResourceRecoveryTest.java b/core/src/test/java/io/atomix/ResourceRecoveryTest.java
@@ -21,6 +21,7 @@
 import org.testng.annotations.Test;
 
 import java.util.UUID;
+import java.util.concurrent.TimeUnit;
 
 /**
  * Atomix resource recovery test.
@@ -50,16 +51,16 @@ private void testRecoverResources(Atomix atomix) throws Throwable {
     String id = UUID.randomUUID().toString();
 
     DistributedMap<String, String> map = atomix.get("test-map-" + id, DistributedMap.class).get();
-    map.put("foo", "Hello world!").join();
-    map.put("bar", "Hello world again!").join();
+    map.put("foo", "Hello world!").get(5, TimeUnit.SECONDS);
+    map.put("bar", "Hello world again!").get(5, TimeUnit.SECONDS);
     map.get("foo").thenAccept(result -> {
       threadAssertEquals(result, "Hello world!");
       resume();
     });
     await(1000);
 
     DistributedSet<String> set = atomix.get("test-set-" + id, DistributedSet.class).get();
-    set.add("Hello world!").join();
+    set.add("Hello world!").get(5, TimeUnit.SECONDS);
 
     atomix.client.client().recover().whenComplete((result, error) -> {
       threadAssertNull(error);