better assets handler initial setup, using onStart callback

jknack · jknack · commit 7684b782c767 · 2016-10-15T13:39:40.000-03:00
diff --git a/coverage-report/src/test/java/org/jooby/EnvConfCallbackFeature.java b/coverage-report/src/test/java/org/jooby/EnvConfCallbackFeature.java
@@ -0,0 +1,26 @@
+package org.jooby;
+
+import org.jooby.test.ServerFeature;
+import org.junit.Test;
+
+import com.google.inject.Key;
+import com.google.inject.name.Names;
+
+public class EnvConfCallbackFeature extends ServerFeature {
+
+  {
+    Key<String> key = Key.get(String.class, Names.named(("envcallback")));
+    on("dev", conf -> {
+      use((env, config, binder) -> {
+        binder.bind(key).toInstance(env.name());
+      });
+    });
+
+    get("/", req -> req.require(key));
+  }
+
+  @Test
+  public void devCallback() throws Exception {
+    request().get("/").expect("dev");
+  }
+}
diff --git a/jooby/src/main/java/org/jooby/Jooby.java b/jooby/src/main/java/org/jooby/Jooby.java
@@ -3129,7 +3129,8 @@ public Route.Definition assets(final String path) {
   @Override
   public Route.Definition assets(final String path, final String location) {
     AssetHandler handler = new AssetHandler(location);
-    on("*", conf -> {
+    onStart(r -> {
+      Config conf = r.require(Config.class);
       handler
           .cdn(conf.getString("assets.cdn"))
           .lastModified(conf.getBoolean("assets.lastModified"))
diff --git a/jooby/src/test/java/org/jooby/JoobyTest.java b/jooby/src/test/java/org/jooby/JoobyTest.java
@@ -524,6 +524,7 @@ public Object m1() {
     expect(injector.getInstance(Route.KEY)).andReturn(Collections.emptySet());
     expect(injector.getInstance(WebSocket.KEY)).andReturn(Collections.emptySet());
     injector.injectMembers(isA(Jooby.class));
+    unit.registerMock(Injector.class, injector);
 
     AppPrinter printer = unit.constructor(AppPrinter.class)
         .args(Set.class, Set.class, Config.class)
@@ -2062,7 +2063,8 @@ public void assets() throws Exception {
         .expect(requestScope)
         .expect(webSockets)
         .expect(tmpdir)
-        .expect(err).expect(executor("deferred"))
+        .expect(err)
+        .expect(executor("deferred"))
         .expect(unit -> {
           Mutant ifModifiedSince = unit.mock(Mutant.class);
           expect(ifModifiedSince.toOptional(Long.class)).andReturn(Optional.empty());
@@ -2084,6 +2086,15 @@ public void assets() throws Exception {
           Route.Chain chain = unit.get(Route.Chain.class);
           chain.next(req, rsp);
         })
+        .expect(unit -> {
+          Config conf = unit.get(Config.class);
+          expect(conf.getString("assets.cdn")).andReturn("").times(2);
+          expect(conf.getBoolean("assets.lastModified")).andReturn(true).times(2);
+          expect(conf.getBoolean("assets.etag")).andReturn(true).times(2);
+
+          Injector injector = unit.get(Injector.class);
+          expect(injector.getInstance(Key.get(Config.class))).andReturn(conf).times(2);
+        })
         .run(unit -> {
           Jooby jooby = new Jooby();
 
@@ -2259,32 +2270,32 @@ public void ws() throws Exception {
         .expect(routeHandler)
         .expect(params)
         .expect(requestScope)
-        .expect(
-            unit -> {
-              Multibinder<WebSocket.Definition> multibinder = unit.mock(Multibinder.class);
+        .expect(unit -> {
+          Multibinder<WebSocket.Definition> multibinder = unit.mock(Multibinder.class);
 
-              LinkedBindingBuilder<WebSocket.Definition> binding = unit
-                  .mock(LinkedBindingBuilder.class);
-              binding.toInstance(unit.capture(WebSocket.Definition.class));
+          LinkedBindingBuilder<WebSocket.Definition> binding = unit
+              .mock(LinkedBindingBuilder.class);
+          binding.toInstance(unit.capture(WebSocket.Definition.class));
 
-              expect(multibinder.addBinding()).andReturn(binding);
+          expect(multibinder.addBinding()).andReturn(binding);
 
-              Binder binder = unit.get(Binder.class);
+          Binder binder = unit.get(Binder.class);
 
-              expect(Multibinder.newSetBinder(binder, WebSocket.Definition.class)).andReturn(
-                  multibinder);
-            })
+          expect(Multibinder.newSetBinder(binder, WebSocket.Definition.class)).andReturn(
+              multibinder);
+        })
         .expect(tmpdir)
-        .expect(err).expect(executor("deferred"))
+        .expect(err)
+        .expect(executor("deferred"))
         .run(unit -> {
 
           Jooby jooby = new Jooby();
 
           WebSocket.Definition ws = jooby.ws("/", (socket) -> {
           });
           assertEquals("/", ws.pattern());
-          assertEquals(MediaType.all, ws.consumes());
-          assertEquals(MediaType.all, ws.produces());
+          assertEquals(MediaType.plain, ws.consumes());
+          assertEquals(MediaType.plain, ws.produces());
           defs.add(ws);
 
           jooby.start();
