jooby-apt: @param name attribute is being ignored by MVC APT code generator.

- fix #3466

Author: jknack

modules/jooby-apt/src/main/java/io/jooby/internal/apt/AnnotationSupport.java

@@ -18,6 +18,7 @@
 
 public interface AnnotationSupport {
   Predicate<String> VALUE = "value"::equals;
+  Predicate<String> NAME = "name"::equals;
 
   static List<String> findAnnotationValue(
       AnnotationMirror annotation, Predicate<String> predicate) {

modules/jooby-apt/src/main/java/io/jooby/internal/apt/MvcParameter.java

@@ -5,8 +5,6 @@
  */
 package io.jooby.internal.apt;
 
-import static io.jooby.internal.apt.AnnotationSupport.findAnnotationValue;
-
 import java.util.*;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -47,21 +45,11 @@ public String generateMapping(boolean kt) {
                       : Stream.of(Map.entry(found, it.getValue()));
                 })
             .findFirst();
-    var nameProvider =
-        strategy
-            .filter(
-                it ->
-                    !EnumSet.of(ParameterGenerator.BodyParam, ParameterGenerator.Lookup)
-                        .contains(it.getKey()))
-            .map(Map.Entry::getValue)
-            .orElse(null);
     var defaultParameterName = parameter.getSimpleName().toString();
     var parameterName =
-        nameProvider == null
-            ? defaultParameterName
-            : findAnnotationValue(nameProvider, AnnotationSupport.VALUE).stream()
-                .findFirst()
-                .orElse(defaultParameterName);
+        strategy
+            .map(it -> it.getKey().parameterName(it.getValue(), defaultParameterName))
+            .orElse(defaultParameterName);
     var rawType = type.getRawType();
     var elementType =
         type.getArguments().isEmpty() ? rawType : type.getArguments().get(0).getRawType();

modules/jooby-apt/src/main/java/io/jooby/internal/apt/ParameterGenerator.java

@@ -14,6 +14,7 @@
 import java.time.Period;
 import java.time.ZoneId;
 import java.util.*;
+import java.util.function.Predicate;
 import java.util.stream.Stream;
 
 import javax.lang.model.element.AnnotationMirror;
@@ -51,11 +52,22 @@ public String toSourceCode(
   FlashParam("flash", "io.jooby.annotation.FlashParam"),
   FormParam("form", "io.jooby.annotation.FormParam", "jakarta.ws.rs.FormParam"),
   HeaderParam("header", "io.jooby.annotation.HeaderParam", "jakarta.ws.rs.HeaderParam"),
-  Lookup("lookup", "io.jooby.annotation.Param"),
+  Lookup("lookup", "io.jooby.annotation.Param") {
+    @Override
+    protected Predicate<String> namePredicate() {
+      return AnnotationSupport.NAME;
+    }
+  },
   PathParam("path", "io.jooby.annotation.PathParam", "jakarta.ws.rs.PathParam"),
   QueryParam("query", "io.jooby.annotation.QueryParam", "jakarta.ws.rs.QueryParam"),
   SessionParam("session", "io.jooby.annotation.SessionParam"),
   BodyParam("body") {
+    @Override
+    public String parameterName(AnnotationMirror annotation, String defaultParameterName) {
+      // Body are unnamed
+      return defaultParameterName;
+    }
+
     @Override
     public String toSourceCode(
         boolean kt,
@@ -87,6 +99,16 @@ public String toSourceCode(
     }
   };
 
+  public String parameterName(AnnotationMirror annotation, String defaultParameterName) {
+    return findAnnotationValue(annotation, namePredicate()).stream()
+        .findFirst()
+        .orElse(defaultParameterName);
+  }
+
+  protected Predicate<String> namePredicate() {
+    return AnnotationSupport.VALUE;
+  }
+
   public String toSourceCode(
       boolean kt, AnnotationMirror annotation, TypeDefinition type, String name, boolean nullable) {
     var paramSource = source(annotation);

modules/jooby-apt/src/test/java/tests/i3466/C3466.java

@@ -0,0 +1,26 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package tests.i3466;
+
+import java.util.Map;
+import java.util.UUID;
+
+import io.jooby.ParamSource;
+import io.jooby.annotation.*;
+
+@Path("/simple")
+public class C3466 {
+
+  @POST("/test")
+  public String post(
+      @Param(
+              value = {ParamSource.QUERY, ParamSource.FORM},
+              name = "client_id")
+          UUID clientId,
+      Map<String, Object> ignoredBodyName) {
+    return "hello";
+  }
+}

modules/jooby-apt/src/test/java/tests/i3466/Issue3466.java

@@ -0,0 +1,31 @@
+/*
+ * Jooby https://jooby.io
+ * Apache License Version 2.0 https://jooby.io/LICENSE.txt
+ * Copyright 2014 Edgar Espina
+ */
+package tests.i3466;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+import io.jooby.apt.ProcessorRunner;
+
+public class Issue3466 {
+
+  @Test
+  public void shouldGetNameFromParamLookup() throws Exception {
+    new ProcessorRunner(new C3466())
+        .withRouter(
+            (app, source) -> {
+              assertTrue(
+                  source
+                      .toString()
+                      .contains(
+                          "ctx.lookup(\"client_id\", io.jooby.ParamSource.QUERY,"
+                              + " io.jooby.ParamSource.FORM)"));
+              assertFalse(source.toString().contains("ignoredBodyName"));
+            });
+  }
+}

tests/src/test/java/io/jooby/buffer/LeakAwareDataBufferFactory.java

@@ -101,7 +101,6 @@ public void checkForLeaks(Duration timeout) {
               .map(LeakAwareDataBuffer::leakError)
               .toList();
 
-      errors.forEach(it -> logger.error("Leaked error: ", it));
       throw new AssertionError(errors.size() + " buffer leaks detected (see logs above)");
     }
   }

tests/src/test/java/io/jooby/buffer/LeakAwareDataBufferFactoryTests.java

@@ -6,8 +6,8 @@
 package io.jooby.buffer;
 
 import static io.jooby.buffer.DataBufferUtils.release;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -17,12 +17,12 @@ class LeakAwareDataBufferFactoryTests {
 
   private final LeakAwareDataBufferFactory bufferFactory = new LeakAwareDataBufferFactory();
 
-  @Test
+  @Test()
   @SuppressWarnings("deprecation")
   void leak() {
     DataBuffer dataBuffer = this.bufferFactory.allocateBuffer();
     try {
-      assertThatExceptionOfType(AssertionError.class).isThrownBy(this.bufferFactory::checkForLeaks);
+      Assertions.assertThrows(AssertionError.class, this.bufferFactory::checkForLeaks);
     } finally {
       release(dataBuffer);
     }