Use CompositeFuture.join() instead of CompositeFuture.all()

Author: aschrijver

src/main/java/io/engagingspaces/vertx/dataloader/DataLoader.java

@@ -123,7 +123,7 @@ public Future<V> load(K key) {
      * @return the composite future of the list of values
      */
     public CompositeFuture loadMany(List<K> keys) {
-        return CompositeFuture.all(keys.stream().map(this::load).collect(Collectors.toList()));
+        return CompositeFuture.join(keys.stream().map(this::load).collect(Collectors.toList()));
     }
 
     /**
@@ -135,7 +135,7 @@ public CompositeFuture loadMany(List<K> keys) {
      */
     public CompositeFuture dispatch() {
         if (!loaderOptions.batchingEnabled() || loaderQueue.size() == 0) {
-            return CompositeFuture.all(Collections.emptyList());
+            return CompositeFuture.join(Collections.emptyList());
         }
         CompositeFuture batch = batchLoadFunction.load(loaderQueue.keySet());
         batch.setHandler(rh -> {

src/test/java/io/engagingspaces/vertx/dataloader/DataLoaderTest.java

@@ -64,7 +64,7 @@ public void setUp() {
     public void should_Build_a_really_really_simple_data_loader() {
         AtomicBoolean success = new AtomicBoolean();
         DataLoader<Integer, Integer> identityLoader = new DataLoader<>(keys ->
-            CompositeFuture.all(keys.stream()
+            CompositeFuture.join(keys.stream()
                     .map(Future::succeededFuture)
                     .collect(Collectors.toCollection(ArrayList::new))));
 
@@ -81,7 +81,7 @@ public void should_Build_a_really_really_simple_data_loader() {
     public void should_Support_loading_multiple_keys_in_one_call() {
         AtomicBoolean success = new AtomicBoolean();
         DataLoader<Integer, Integer> identityLoader = new DataLoader<>(keys ->
-                CompositeFuture.all(keys.stream()
+                CompositeFuture.join(keys.stream()
                         .map(Future::succeededFuture)
                         .collect(Collectors.toCollection(ArrayList::new))));
 
@@ -321,20 +321,25 @@ public void should_Resolve_to_error_to_indicate_failure() {
 
     @Test
     public void should_Represent_failures_and_successes_simultaneously() {
+        AtomicBoolean success = new AtomicBoolean();
         ArrayList<Collection> loadCalls = new ArrayList<>();
         DataLoader<Integer, Integer> evenLoader = idLoaderWithErrors(new DataLoaderOptions(), loadCalls);
 
         Future<Integer> future1 = evenLoader.load(1);
         Future<Integer> future2 = evenLoader.load(2);
-        evenLoader.dispatch();
+        Future<Integer> future3 = evenLoader.load(3);
+        Future<Integer> future4 = evenLoader.load(4);
+        CompositeFuture result = evenLoader.dispatch();
+        result.setHandler(rh -> success.set(true));
 
-        await().until(future1::isComplete);
+        await().untilAtomic(success, is(true));
         assertThat(future1.failed(), is(true));
         assertThat(future1.cause(), instanceOf(IllegalStateException.class));
-
-        await().until(future2::isComplete);
         assertThat(future2.result(), equalTo(2));
-        assertThat(loadCalls, equalTo(Collections.singletonList(Arrays.asList(1, 2))));
+        assertThat(future3.failed(), is(true));
+        assertThat(future4.result(), equalTo(4));
+
+        assertThat(loadCalls, equalTo(Collections.singletonList(Arrays.asList(1, 2, 3, 4))));
     }
 
     @Test
@@ -733,7 +738,7 @@ private static <K, V> DataLoader<K, V> idLoader(DataLoaderOptions options, List<
         return new DataLoader<>(keys -> {
             loadCalls.add(new ArrayList(keys));
             List<Future> futures = keys.stream().map(Future::succeededFuture).collect(Collectors.toList());
-            return CompositeFuture.all(futures);
+            return CompositeFuture.join(futures);
         }, options);
     }
 
@@ -745,7 +750,7 @@ private static <K, V> DataLoader<K, V> idLoaderAllErrors(
             List<Future> futures = keys.stream()
                     .map(key -> Future.failedFuture(new IllegalStateException("Error")))
                     .collect(Collectors.toList());
-            return CompositeFuture.all(futures);
+            return CompositeFuture.join(futures);
         }, options);
     }
 
@@ -758,7 +763,7 @@ private static DataLoader<Integer, Integer> idLoaderWithErrors(
                     .map(key -> key % 2 == 0 ? Future.succeededFuture(key) :
                             Future.failedFuture(new IllegalStateException("Error")))
                     .collect(Collectors.toList());
-            return CompositeFuture.all(futures);
+            return CompositeFuture.join(futures);
         }, options);
     }
 }