callable/completablefuture as async result types fix jooby-project#490

jknack · jknack · commit e1b4dc330cd2 · 2016-10-02T16:43:23.000-03:00
diff --git a/coverage-report/src/test/java/org/jooby/issues/Issue484b.java b/coverage-report/src/test/java/org/jooby/issues/Issue484b.java
@@ -29,15 +29,13 @@ public void deferredWithExecutorInstance() throws Exception {
     request()
         .get("/484")
         .expect(rsp -> {
-          System.out.println(rsp);
           String[] threads = rsp.split(":");
           assertNotEquals(threads[0], threads[1]);
         });
 
     request()
         .get("/484/promise")
         .expect(rsp -> {
-          System.out.println(rsp);
           String[] threads = rsp.split(":");
           assertNotEquals(threads[0], threads[1]);
         });
diff --git a/coverage-report/src/test/java/org/jooby/issues/Issue484c.java b/coverage-report/src/test/java/org/jooby/issues/Issue484c.java
@@ -38,15 +38,13 @@ public void deferredWithExecutorReference() throws Exception {
     request()
         .get("/484")
         .expect(rsp -> {
-          System.out.println(rsp);
           String[] threads = rsp.split(":");
           assertNotEquals(threads[0], threads[1]);
         });
 
     request()
         .get("/484/promise")
         .expect(rsp -> {
-          System.out.println(rsp);
           String[] threads = rsp.split(":");
           assertNotEquals(threads[0], threads[1]);
         });
diff --git a/coverage-report/src/test/java/org/jooby/issues/Issue490.java b/coverage-report/src/test/java/org/jooby/issues/Issue490.java
@@ -0,0 +1,51 @@
+package org.jooby.issues;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+
+import org.jooby.AsyncMapper;
+import org.jooby.test.ServerFeature;
+import org.junit.Test;
+
+public class Issue490 extends ServerFeature {
+
+  {
+    map(new AsyncMapper());
+
+    get("/490/callable", () -> (Callable<String>) () -> Thread.currentThread().getName());
+
+    get("/490/future", () -> CompletableFuture
+        .supplyAsync(() -> Thread.currentThread().getName()));
+
+    get("/490", () -> "OK");
+
+  }
+
+  @Test
+  public void shouldMapCallbale() throws Exception {
+    request()
+        .get("/490/callable")
+        .expect(rsp -> {
+          assertTrue(rsp.toLowerCase().contains("task"));
+        });
+  }
+
+  @Test
+  public void shouldMapCompletableFuture() throws Exception {
+    request()
+        .get("/490/future")
+        .expect(rsp -> {
+          assertTrue(rsp.toLowerCase().startsWith("forkjoinpool"));
+        });
+  }
+
+  @Test
+  public void shouldSkip() throws Exception {
+    request()
+        .get("/490")
+        .expect("OK");
+  }
+
+}
diff --git a/coverage-report/src/test/java/org/jooby/issues/Issue490b.java b/coverage-report/src/test/java/org/jooby/issues/Issue490b.java
@@ -0,0 +1,47 @@
+package org.jooby.issues;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import org.jooby.AsyncMapper;
+import org.jooby.test.ServerFeature;
+import org.junit.Test;
+
+public class Issue490b extends ServerFeature {
+
+  {
+    map(new AsyncMapper());
+
+    ExecutorService exec = Executors.newSingleThreadExecutor(r -> {
+      Thread thread = new Thread(r);
+      thread.setName("490");
+      return thread;
+    });
+    executor(exec);
+
+    get("/490/callable", () -> (Callable<String>) () -> Thread.currentThread().getName());
+
+    get("/490/future",
+        () -> CompletableFuture.supplyAsync(() -> Thread.currentThread().getName(), exec));
+
+  }
+
+  @Test
+  public void shouldMapCallbale() throws Exception {
+    request()
+        .get("/490/callable")
+        .expect(rsp -> {
+          assertEquals("490", rsp);
+        });
+
+    request()
+        .get("/490/future")
+        .expect(rsp -> {
+          assertEquals("490", rsp);
+        });
+  }
+}
diff --git a/jooby/src/main/java/org/jooby/AsyncMapper.java b/jooby/src/main/java/org/jooby/AsyncMapper.java
@@ -0,0 +1,50 @@
+package org.jooby;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+
+import org.jooby.internal.mapper.CallableMapper;
+import org.jooby.internal.mapper.CompletableFutureMapper;
+
+/**
+ * <h1>async-mapper</h1>
+ * <p>
+ * Map {@link Callable} and {@link CompletableFuture} results to {@link Deferred Deferred API}.
+ * </p>
+ *
+ * <h2>usage</h2>
+ * <pre>{@code
+ * {
+ *   map(new AsyncMapper());
+ *
+ *   get("/callable", () -> {
+ *     return new Callable<String> () {
+ *       public String call() {
+ *         return "OK";
+ *       }
+ *     };
+ *   });
+ *
+ *   get("/completable-future", () -> {
+ *     return CompletableFuture.supplyAsync(() -> "OK");
+ *   });
+ * }
+ * }</pre>
+ *
+ * @author edgar
+ * @since 1.0.0
+ */
+@SuppressWarnings("rawtypes")
+public class AsyncMapper implements Route.Mapper {
+
+  @Override
+  public Object map(final Object value) throws Throwable {
+    if (value instanceof Callable) {
+      return new CallableMapper().map((Callable) value);
+    } else if (value instanceof CompletableFuture) {
+      return new CompletableFutureMapper().map((CompletableFuture) value);
+    }
+    return value;
+  }
+
+}
diff --git a/jooby/src/main/java/org/jooby/internal/mapper/CallableMapper.java b/jooby/src/main/java/org/jooby/internal/mapper/CallableMapper.java
@@ -0,0 +1,22 @@
+package org.jooby.internal.mapper;
+
+import java.util.concurrent.Callable;
+
+import org.jooby.Deferred;
+import org.jooby.Route;
+
+@SuppressWarnings("rawtypes")
+public class CallableMapper implements Route.Mapper<Callable> {
+
+  @Override
+  public Object map(final Callable callable) throws Throwable {
+    return new Deferred(deferred -> {
+      try {
+        deferred.resolve(callable.call());
+      } catch (Throwable x) {
+        deferred.reject(x);
+      }
+    });
+  }
+
+}
diff --git a/jooby/src/main/java/org/jooby/internal/mapper/CompletableFutureMapper.java b/jooby/src/main/java/org/jooby/internal/mapper/CompletableFutureMapper.java
@@ -0,0 +1,25 @@
+package org.jooby.internal.mapper;
+
+import java.util.concurrent.CompletableFuture;
+
+import org.jooby.Deferred;
+import org.jooby.Route;
+
+@SuppressWarnings("rawtypes")
+public class CompletableFutureMapper implements Route.Mapper<CompletableFuture> {
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public Object map(final CompletableFuture future) throws Throwable {
+    return new Deferred(deferred -> {
+      future.whenComplete((value, x) -> {
+        if (x != null) {
+          deferred.reject((Throwable) x);
+        } else {
+          deferred.resolve(value);
+        }
+      });
+    });
+  }
+
+}
diff --git a/jooby/src/test/java/org/jooby/internal/mapper/CallableMapperTest.java b/jooby/src/test/java/org/jooby/internal/mapper/CallableMapperTest.java
@@ -0,0 +1,71 @@
+package org.jooby.internal.mapper;
+
+import static org.easymock.EasyMock.expect;
+
+import java.util.concurrent.Callable;
+
+import org.jooby.Deferred;
+import org.jooby.Deferred.Initializer0;
+import org.jooby.test.MockUnit;
+import org.jooby.test.MockUnit.Block;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({CallableMapper.class, Deferred.class })
+public class CallableMapperTest {
+
+  private Block deferred = unit -> {
+    Deferred deferred = unit.constructor(Deferred.class)
+        .args(Deferred.Initializer0.class)
+        .build(unit.capture(Deferred.Initializer0.class));
+    unit.registerMock(Deferred.class, deferred);
+  };
+
+  private Block init0 = unit -> {
+    Initializer0 next = unit.captured(Deferred.Initializer0.class).iterator().next();
+    next.run(unit.get(Deferred.class));
+  };
+
+  @SuppressWarnings("rawtypes")
+  @Test
+  public void resolve() throws Exception {
+    Object value = new Object();
+    new MockUnit(Callable.class)
+        .expect(deferred)
+        .expect(unit -> {
+          Callable callable = unit.get(Callable.class);
+          expect(callable.call()).andReturn(value);
+        })
+        .expect(unit -> {
+          Deferred deferred = unit.get(Deferred.class);
+          deferred.resolve(value);
+        })
+        .run(unit -> {
+          new CallableMapper()
+              .map(unit.get(Callable.class));
+        }, init0);
+  }
+
+  @SuppressWarnings("rawtypes")
+  @Test
+  public void reject() throws Exception {
+    Exception value = new Exception();
+    new MockUnit(Callable.class)
+        .expect(deferred)
+        .expect(unit -> {
+          Callable callable = unit.get(Callable.class);
+          expect(callable.call()).andThrow(value);
+        })
+        .expect(unit -> {
+          Deferred deferred = unit.get(Deferred.class);
+          deferred.reject(value);
+        })
+        .run(unit -> {
+          new CallableMapper()
+              .map(unit.get(Callable.class));
+        }, init0);
+  }
+}
diff --git a/jooby/src/test/java/org/jooby/internal/mapper/CompletableFutureMapperTest.java b/jooby/src/test/java/org/jooby/internal/mapper/CompletableFutureMapperTest.java
@@ -0,0 +1,78 @@
+package org.jooby.internal.mapper;
+
+import static org.easymock.EasyMock.expect;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.BiConsumer;
+
+import org.jooby.Deferred;
+import org.jooby.Deferred.Initializer0;
+import org.jooby.test.MockUnit;
+import org.jooby.test.MockUnit.Block;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({CompletableFutureMapper.class, Deferred.class })
+public class CompletableFutureMapperTest {
+
+  private Block deferred = unit -> {
+    Deferred deferred = unit.constructor(Deferred.class)
+        .args(Deferred.Initializer0.class)
+        .build(unit.capture(Deferred.Initializer0.class));
+    unit.registerMock(Deferred.class, deferred);
+  };
+
+  @SuppressWarnings({"unchecked", "rawtypes" })
+  private Block future = unit -> {
+    CompletableFuture future = unit.get(CompletableFuture.class);
+    expect(future.whenComplete(unit.capture(BiConsumer.class))).andReturn(future);
+  };
+
+  private Block init0 = unit -> {
+    Initializer0 next = unit.captured(Deferred.Initializer0.class).iterator().next();
+    next.run(unit.get(Deferred.class));
+  };
+
+  @SuppressWarnings({"rawtypes", "unchecked" })
+  @Test
+  public void resolve() throws Exception {
+    Object value = new Object();
+    new MockUnit(CompletableFuture.class)
+        .expect(deferred)
+        .expect(future)
+        .expect(unit -> {
+          Deferred deferred = unit.get(Deferred.class);
+          deferred.resolve(value);
+        })
+        .run(unit -> {
+          new CompletableFutureMapper()
+              .map(unit.get(CompletableFuture.class));
+        }, init0, unit -> {
+          BiConsumer next = unit.captured(BiConsumer.class).iterator().next();
+          next.accept(value, null);
+        });
+  }
+
+  @SuppressWarnings({"rawtypes", "unchecked" })
+  @Test
+  public void reject() throws Exception {
+    Throwable value = new Throwable();
+    new MockUnit(CompletableFuture.class)
+        .expect(deferred)
+        .expect(future)
+        .expect(unit -> {
+          Deferred deferred = unit.get(Deferred.class);
+          deferred.reject(value);
+        })
+        .run(unit -> {
+          new CompletableFutureMapper()
+              .map(unit.get(CompletableFuture.class));
+        }, init0, unit -> {
+          BiConsumer next = unit.captured(BiConsumer.class).iterator().next();
+          next.accept(null, value);
+        });
+  }
+}
