Add support for multiple verbs in mvc methods

jknack · jknack · commit 723677b87620 · 2014-10-08T23:29:02.000-03:00
diff --git a/jooby-core/src/main/java/jooby/internal/mvc/Routes.java b/jooby-core/src/main/java/jooby/internal/mvc/Routes.java
@@ -4,6 +4,7 @@
 import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -12,12 +13,11 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 
 import jooby.MediaType;
 import jooby.Mode;
 import jooby.Route;
-import jooby.internal.Reflection;
+import jooby.Route.Definition;
 import jooby.mvc.Consumes;
 import jooby.mvc.DELETE;
 import jooby.mvc.GET;
@@ -66,45 +66,52 @@ public static List<Route.Definition> routes(final Mode mode, final Class<?> rout
 
     String rootPath = path(routeClass);
 
-    return Reflection
-        .methods(routeClass)
+    Map<Method, List<Class<?>>> methods = new HashMap<>();
+    for (Method method : routeClass.getDeclaredMethods()) {
+      List<Class<?>> annotations = new ArrayList<>();
+      for (Class annotationType : VERBS) {
+        Annotation annotation = method.getAnnotation(annotationType);
+        if (annotation != null) {
+          annotations.add(annotationType);
+        }
+      }
+      if (annotations.size() > 0) {
+        if (!Modifier.isPublic(method.getModifiers())) {
+          throw new IllegalArgumentException("Not a public method: " + method);
+        }
+        methods.put(method, annotations);
+      }
+    }
+
+    List<Definition> definitions = new ArrayList<>();
+
+    methods
+        .keySet()
         .stream()
-        .filter(
-            m -> {
-              List<Annotation> annotations = new ArrayList<>();
-              for (Class annotationType : VERBS) {
-                Annotation annotation = m.getAnnotation(annotationType);
-                if (annotation != null) {
-                  annotations.add(annotation);
-                }
-              }
-              if (annotations.size() == 0) {
-                return false;
-              }
-              if (annotations.size() > 1) {
-                throw new IllegalStateException("A resource method: " + m
-                    + " should have only one HTTP verb. Found: "
-                    + annotations);
-              }
-              return true;
-            })
         .sorted((m1, m2) -> {
           String k1 = key(m1);
           String k2 = key(m2);
           int l1 = lines.getOrDefault(k1, 0);
           int l2 = lines.getOrDefault(k2, 0);
           return l1 - l2;
         })
-        .map(
-            m -> {
-              String verb = verb(m);
-              String path = rootPath + "/" + path(m);
-              return new Route.Definition(verb, path, new MvcRoute(m, provider))
-                  .produces(produces(m))
-                  .consumes(consumes(m))
-                  .name(routeClass.getSimpleName() + "." + m.getName());
-            })
-        .collect(Collectors.toList());
+        .forEach(
+            method -> {
+              List<Class<?>> verbs = methods.get(method);
+              String path = rootPath + "/" + path(method);
+              String name = routeClass.getSimpleName() + "." + method.getName();
+              for (Class<?> verb : verbs) {
+                Definition definition = new Route.Definition(
+                    verb.getSimpleName(), path, new MvcRoute(method, provider))
+                    .produces(produces(method))
+                    .consumes(consumes(method))
+                    .name(name);
+
+                definitions.add(definition);
+              }
+            });
+
+    return definitions;
   }
 
   private static String key(final Method method) {
@@ -154,16 +161,6 @@ private static List<MediaType> consumes(final Method method) {
             .orElse(ALL));
   }
 
-  @SuppressWarnings("unchecked")
-  private static String verb(final Method method) {
-    for (Class<?> annotation : VERBS) {
-      if (method.isAnnotationPresent((Class<? extends Annotation>) annotation)) {
-        return annotation.getSimpleName();
-      }
-    }
-    throw new IllegalStateException("Couldn't find a HTTP annotation");
-  }
-
   private static String path(final AnnotatedElement owner) {
     Path annotation = owner.getAnnotation(Path.class);
     if (annotation == null) {
diff --git a/jooby-tests/src/test/java/jooby/MvcMethodWithMultipleVerbsFeature.java b/jooby-tests/src/test/java/jooby/MvcMethodWithMultipleVerbsFeature.java
@@ -0,0 +1,58 @@
+package jooby;
+
+import static org.junit.Assert.assertEquals;
+import jooby.FilterFeature.HttpResponseValidator;
+import jooby.mvc.GET;
+import jooby.mvc.POST;
+import jooby.mvc.Path;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.fluent.Request;
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.util.EntityUtils;
+import org.junit.Test;
+
+public class MvcMethodWithMultipleVerbsFeature extends ServerFeature {
+
+  public static class Resource {
+    @GET
+    @POST
+    @Path("/")
+    public String getOrPost(final jooby.Request req) {
+      return req.route().verb().toString();
+    }
+  }
+
+  {
+    route(Resource.class);
+  }
+
+  @Test
+  public void get() throws Exception {
+    assertEquals("GET", execute(GET(uri("/")), (response) -> {
+      assertEquals(200, response.getStatusLine().getStatusCode());
+    }));
+  }
+
+  @Test
+  public void post() throws Exception {
+    assertEquals("POST", execute(POST(uri("/")), (response) -> {
+      assertEquals(200, response.getStatusLine().getStatusCode());
+    }));
+  }
+
+  private static Request GET(final URIBuilder uri) throws Exception {
+    return Request.Get(uri.build());
+  }
+
+  private static Request POST(final URIBuilder uri) throws Exception {
+    return Request.Post(uri.build());
+  }
+
+  private static Object execute(final Request request, final HttpResponseValidator validator)
+      throws Exception {
+    HttpResponse resp = request.execute().returnResponse();
+    validator.validate(resp);
+    return EntityUtils.toString(resp.getEntity());
+  }
+}
