Renamed to Async to be more in line with other AsyncXXX classes (graphql-java#801)

bbakerman · web-flow · commit a9fb38bb043b · 2017-10-27T17:54:38.000+11:00
diff --git a/docs/execution.rst b/docs/execution.rst
@@ -346,7 +346,7 @@ The graphql-java engine ensures that all the ``CompletableFuture`` objects are c
 that follows the graphql specification.
 
 There is a helpful shortcut in graphql-java to create asynchronous data fetchers. 
-Use ``graphql.schema.AsynchronousDataFetcher.async(DataFetcher<T>)`` to wrap a 
+Use ``graphql.schema.AsyncDataFetcher.async(DataFetcher<T>)`` to wrap a
 ``DataFetcher``. This can be used with static imports to produce more readable code.
 
 .. code-block:: java
diff --git a/src/main/java/graphql/schema/AsyncDataFetcher.java b/src/main/java/graphql/schema/AsyncDataFetcher.java
@@ -1,62 +1,61 @@
 package graphql.schema;
 
-import static graphql.Assert.assertNotNull;
+import graphql.PublicApi;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ForkJoinPool;
 
-import graphql.PublicApi;
+import static graphql.Assert.assertNotNull;
 
 /**
  * A modifier type that indicates the underlying data fetcher is run asynchronously
  */
 @PublicApi
-public class AsynchronousDataFetcher<T> implements DataFetcher<CompletableFuture<T>> {
-    
+public class AsyncDataFetcher<T> implements DataFetcher<CompletableFuture<T>> {
+
     /**
-     * A factory method for creating asynchronous data fetchers so that when used with 
+     * A factory method for creating asynchronous data fetchers so that when used with
      * static imports allows more readable code such as:
      * <p>
      * {@code .dataFetcher(async(fooDataFetcher))}
      * <p>
-     * By default this will run in the {@link ForkJoinPool#commonPool()}. You can set 
-     * your own {@link Executor} with {@link #asyncWithExecutor(DataFetcher, Executor)}
+     * By default this will run in the {@link ForkJoinPool#commonPool()}. You can set
+     * your own {@link Executor} with {@link #async(DataFetcher)} (DataFetcher, Executor)}
      *
      * @param wrappedDataFetcher the data fetcher to run asynchronously
      *
      * @return a {@link DataFetcher} that will run the wrappedDataFetcher asynchronously
      */
-    public static <T> AsynchronousDataFetcher<T> async(DataFetcher<T> wrappedDataFetcher) {
-        return new AsynchronousDataFetcher<>(wrappedDataFetcher);
+    public static <T> AsyncDataFetcher<T> async(DataFetcher<T> wrappedDataFetcher) {
+        return new AsyncDataFetcher<>(wrappedDataFetcher);
     }
-    
+
     /**
-     * A factory method for creating asynchronous data fetchers and setting the 
-     * {@link Executor} they run in so that when used with static imports allows 
+     * A factory method for creating asynchronous data fetchers and setting the
+     * {@link Executor} they run in so that when used with static imports allows
      * more readable code such as:
      * <p>
-     * {@code .dataFetcher(asyncWithExecutor(fooDataFetcher, fooPool))}
+     * {@code .dataFetcher(async(fooDataFetcher, fooExecutor))}
      *
      * @param wrappedDataFetcher the data fetcher to run asynchronously
-     * @param executor to run the asynchronous data fetcher in
+     * @param executor           the executor to run the asynchronous data fetcher in
      *
-     * @return a {@link DataFetcher} that will run the wrappedDataFetcher asynchronously in 
+     * @return a {@link DataFetcher} that will run the wrappedDataFetcher asynchronously in
      * the given {@link Executor}
      */
-    public static <T> AsynchronousDataFetcher<T> asyncWithExecutor(DataFetcher<T> wrappedDataFetcher,
-            Executor executor) {
-        return new AsynchronousDataFetcher<>(wrappedDataFetcher, executor);
+    public static <T> AsyncDataFetcher<T> async(DataFetcher<T> wrappedDataFetcher, Executor executor) {
+        return new AsyncDataFetcher<>(wrappedDataFetcher, executor);
     }
-    
+
     private final DataFetcher<T> wrappedDataFetcher;
     private final Executor executor;
 
-    public AsynchronousDataFetcher(DataFetcher<T> wrappedDataFetcher) {
+    public AsyncDataFetcher(DataFetcher<T> wrappedDataFetcher) {
         this(wrappedDataFetcher, ForkJoinPool.commonPool());
     }
 
-    public AsynchronousDataFetcher(DataFetcher<T> wrappedDataFetcher, Executor executor) {
+    public AsyncDataFetcher(DataFetcher<T> wrappedDataFetcher, Executor executor) {
         this.wrappedDataFetcher = assertNotNull(wrappedDataFetcher, "wrappedDataFetcher can't be null");
         this.executor = assertNotNull(executor, "executor can't be null");
     }
diff --git a/src/test/groovy/graphql/schema/AsyncDataFetcherTest.groovy b/src/test/groovy/graphql/schema/AsyncDataFetcherTest.groovy
@@ -0,0 +1,37 @@
+package graphql.schema
+
+import spock.lang.Specification
+
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+
+class AsyncDataFetcherTest extends Specification {
+
+    DataFetcher wrappedDataFetcher = { env -> "value" }
+
+    def "A data fetcher can be made asynchronous with AsynchronousDataFetcher#async"() {
+        given:
+        DataFetchingEnvironment environment = Mock(DataFetchingEnvironment)
+
+        when:
+        DataFetcher asyncDataFetcher = AsyncDataFetcher.async(wrappedDataFetcher)
+
+        then:
+        asyncDataFetcher.get(environment) instanceof CompletableFuture
+        asyncDataFetcher.get(environment).get() == "value"
+    }
+
+    def "will accept its own executor"() {
+        given:
+        DataFetchingEnvironment environment = Mock(DataFetchingEnvironment)
+
+        when:
+        Executor executor = Executors.newSingleThreadExecutor()
+        DataFetcher asyncDataFetcher = AsyncDataFetcher.async(wrappedDataFetcher, executor)
+
+        then:
+        asyncDataFetcher.get(environment) instanceof CompletableFuture
+        asyncDataFetcher.get(environment).get() == "value"
+    }
+}
diff --git a/src/test/groovy/graphql/schema/AsynchronousDataFetcherTest.groovy b/src/test/groovy/graphql/schema/AsynchronousDataFetcherTest.groovy
