use(Jooby) missing onStart and onStop fix jooby-project#421

jknack · jknack · commit dbaac5a9e794 · 2016-07-15T14:03:46.000-03:00
diff --git a/coverage-report/src/test/java/org/jooby/issues/Issue421.java b/coverage-report/src/test/java/org/jooby/issues/Issue421.java
@@ -0,0 +1,85 @@
+package org.jooby.issues;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import org.jooby.Jooby;
+import org.jooby.netty.Netty;
+import org.jooby.test.OnServer;
+import org.jooby.test.ServerFeature;
+import org.junit.AfterClass;
+import org.junit.Test;
+
+@OnServer(Netty.class)
+public class Issue421 extends ServerFeature {
+
+  private static CountDownLatch latch = new CountDownLatch(4);
+
+  private static List<String> values = new ArrayList<>();
+
+  public static class Foo extends Jooby {
+
+    {
+      onStart(() -> {
+        values.add("Start:" + getClass().getSimpleName());
+        latch.countDown();
+      });
+      onStop(() -> {
+        values.add("Stop:" + getClass().getSimpleName());
+        latch.countDown();
+      });
+
+      map(v -> "foo");
+    }
+  }
+
+  {
+    onStart(() -> {
+      values.add("Before:" + getClass().getSimpleName());
+      latch.countDown();
+    });
+    onStop(() -> {
+      values.add("StopBefore:" + getClass().getSimpleName());
+      latch.countDown();
+    });
+
+    use(new Foo());
+
+    onStart(() -> {
+      values.add("After:" + getClass().getSimpleName());
+      latch.countDown();
+    });
+    onStop(() -> {
+      values.add("StopAfter:" + getClass().getSimpleName());
+      latch.countDown();
+    });
+
+    ScheduledExecutorService exe = Executors.newSingleThreadScheduledExecutor();
+    get("/421", () -> {
+      exe.schedule(this::stop, 500L, TimeUnit.MILLISECONDS);
+      return "bar";
+    });
+  }
+
+  @Test
+  public void shouldImportStartStopCallback() throws Exception {
+    request()
+        .get("/421")
+        .expect("foo");
+  }
+
+  @AfterClass
+  public static void onStop() throws InterruptedException {
+    latch.await();
+    assertEquals(
+        "[Before:Issue421, Start:Foo, After:Issue421, StopBefore:Issue421, Stop:Foo, StopAfter:Issue421]",
+        values.toString());
+  }
+
+}
diff --git a/jooby/src/main/java/org/jooby/Jooby.java b/jooby/src/main/java/org/jooby/Jooby.java
@@ -659,11 +659,8 @@ public Jooby(final String prefix) {
   }
 
   /**
-   * Import ALL the direct routes from the given app.
-   *
-   * <p>
-   * PLEASE NOTE: that ONLY routes are imported.
-   * </p>
+   * Import content from provide application (routes, parsers/renderers, start/stop callbacks, ...
+   * etc.).
    *
    * @param app Routes provider.
    * @return This jooby instance.
@@ -673,11 +670,8 @@ public Jooby use(final Jooby app) {
   }
 
   /**
-   * Import ALL the direct routes from the given app, under the given path.
-   *
-   * <p>
-   * PLEASE NOTE: that ONLY routes are imported.
-   * </p>
+   * Import content from provide application (routes, parsers/renderers, start/stop callbacks, ...
+   * etc.). Routes will be mounted at the provided path.
    *
    * @param path Path to mount the given app.
    * @param app Routes provider.
@@ -719,10 +713,18 @@ private Jooby use(final Optional<String> path, final Jooby app) {
         Object routes = path.<Object> map(p -> new MvcClass(((MvcClass) it).routeClass, p))
             .orElse(it);
         this.bag.add(routes);
-      } else if (it instanceof EnvDep) {
+      } else {
+        // everything else
         this.bag.add(it);
       }
     });
+    // start/stop callback
+    app.onStart.forEach(this.onStart::add);
+    app.onStop.forEach(this.onStop::add);
+    // mapper
+    if (app.mapper != null) {
+      this.map(app.mapper);
+    }
     return this;
   }
 
diff --git a/jooby/src/test/java/org/jooby/test/JoobySuite.java b/jooby/src/test/java/org/jooby/test/JoobySuite.java
@@ -1,13 +1,17 @@
 package org.jooby.test;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
 import org.junit.runner.Runner;
 import org.junit.runners.Suite;
 import org.junit.runners.model.InitializationError;
 
+import com.google.common.base.Predicate;
+import com.google.common.base.Predicates;
+
 public class JoobySuite extends Suite {
 
   private List<Runner> runners;
@@ -19,17 +23,26 @@ public class JoobySuite extends Suite {
   public JoobySuite(final Class<?> klass) throws InitializationError {
     super(klass, Collections.emptyList());
 
-    runners = runners();
+    runners = runners(klass);
   }
 
-  private List<Runner> runners() throws InitializationError {
+  @SuppressWarnings("rawtypes")
+  private List<Runner> runners(final Class<?> klass) throws InitializationError {
     List<Runner> runners = new ArrayList<>();
+    Predicate<Class> filter = Predicates.alwaysTrue();
+    OnServer onserver = klass.getAnnotation(OnServer.class);
+    if (onserver != null) {
+      List<Class<?>> server = Arrays.asList(onserver.value());
+      filter = server::contains;
+    }
     String[] servers = {"org.jooby.undertow.Undertow", "org.jooby.jetty.Jetty",
         "org.jooby.netty.Netty" };
     for (String server : servers) {
       try {
         Class<?> serverClass = getClass().getClassLoader().loadClass(server);
-        runners.add(new JoobyRunner(getTestClass().getJavaClass(), serverClass));
+        if (filter.apply(serverClass)) {
+          runners.add(new JoobyRunner(getTestClass().getJavaClass(), serverClass));
+        }
       } catch (ClassNotFoundException ex) {
         // do nothing
       }
diff --git a/jooby/src/test/java/org/jooby/test/OnServer.java b/jooby/src/test/java/org/jooby/test/OnServer.java
@@ -0,0 +1,12 @@
+package org.jooby.test;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface OnServer {
+  Class<?>[] value();
+}
