Merge pull request #1037 from tsegismont/mutiny-handlers-conversion

Improve conversion of Mutiny handlers

vertx-mutiny-clients/vertx-mutiny-runtime/src/main/java/io/smallrye/mutiny/vertx/MutinyDelegate.java

@@ -0,0 +1,13 @@
+package io.smallrye.mutiny.vertx;
+
+/**
+ * Interface implemented by every generated Mutiny type.
+ */
+public interface MutinyDelegate {
+
+    /**
+     * @return the delegate used by this Mutiny object of generated type
+     */
+    Object getDelegate();
+
+}

vertx-mutiny-clients/vertx-mutiny-runtime/src/main/java/io/smallrye/mutiny/vertx/MutinyHelper.java

@@ -2,13 +2,16 @@
 
 import java.util.concurrent.Executor;
 import java.util.concurrent.Flow.Subscriber;
+import java.util.function.Consumer;
 import java.util.function.Function;
 
 import io.smallrye.mutiny.vertx.impl.WriteStreamSubscriberImpl;
+import io.vertx.core.Handler;
 import io.vertx.core.Vertx;
 import io.vertx.core.WorkerExecutor;
 import io.vertx.core.streams.WriteStream;
 
+@SuppressWarnings({ "unchecked", "rawtypes" })
 public class MutinyHelper {
 
     /**
@@ -94,6 +97,27 @@ public static Class unwrap(Class<?> type) {
         return type;
     }
 
+    /**
+     * Convert a handler for a generated Mutiny type to a handler for the corresponding core type.
+     */
+    public static <BARE, MUTINY> Handler<BARE> convertHandler(Handler<MUTINY> mutinyHandler, Function<BARE, MUTINY> mapper) {
+        if (mutinyHandler instanceof MutinyDelegate) {
+            MutinyDelegate mutinyDelegate = (MutinyDelegate) mutinyHandler;
+            return (Handler<BARE>) mutinyDelegate.getDelegate();
+        }
+        return new DelegatingHandler<>(mutinyHandler, mapper);
+    }
+
+    /**
+     * Convert a consumer for a generated Mutiny type to a handler of the same type.
+     */
+    public static <T> Handler<T> convertConsumer(Consumer<T> mutinyConsumer) {
+        if (mutinyConsumer instanceof MutinyDelegate) {
+            return (Handler<T>) mutinyConsumer;
+        }
+        return mutinyConsumer != null ? new DelegatingConsumerHandler<>(mutinyConsumer) : null;
+    }
+
     /**
      * Adapts a Vert.x {@link WriteStream} to a Mutiny {@link Subscriber}.
      * <p>

vertx-mutiny-clients/vertx-mutiny-web/pom.xml

@@ -163,6 +163,24 @@
                             </optionMap>
                         </configuration>
                     </execution>
+                    <!-- Run the annotation processor on java test sources -->
+                    <execution>
+                        <id>generate-tests</id>
+                        <goals>
+                            <goal>process-test</goal>
+                        </goals>
+                        <phase>generate-test-sources</phase>
+                        <configuration>
+                            <defaultOutputDirectory>${project.build.directory}/generated-test-sources/apt
+                            </defaultOutputDirectory>
+                            <processors>
+                                <processor>io.vertx.codegen.CodeGenProcessor</processor>
+                            </processors>
+                            <optionMap>
+                                <codegen.generators>mutiny</codegen.generators>
+                            </optionMap>
+                        </configuration>
+                    </execution>
                 </executions>
             </plugin>
         </plugins>

vertx-mutiny-clients/vertx-mutiny-web/src/test/java/io/vertx/mutiny/web/RouterTest.java

@@ -12,55 +12,65 @@
 
 import io.smallrye.mutiny.Multi;
 import io.smallrye.mutiny.Uni;
+import io.vertx.core.http.HttpClientOptions;
 import io.vertx.core.http.RequestOptions;
 import io.vertx.mutiny.core.Vertx;
 import io.vertx.mutiny.core.buffer.Buffer;
 import io.vertx.mutiny.core.http.HttpClient;
 import io.vertx.mutiny.core.http.HttpClientRequest;
+import io.vertx.mutiny.core.http.HttpServer;
 import io.vertx.mutiny.ext.web.Router;
 import io.vertx.mutiny.ext.web.client.HttpRequest;
 import io.vertx.mutiny.ext.web.client.HttpResponse;
 import io.vertx.mutiny.ext.web.client.WebClient;
 import io.vertx.mutiny.ext.web.handler.BodyHandler;
 import io.vertx.mutiny.ext.web.handler.StaticHandler;
+import io.vertx.mutiny.mutiny.web.TestRouteHandler;
 
 public class RouterTest {
 
     private Vertx vertx;
+    private Router router;
+    private HttpServer server;
+    private HttpClient client;
 
     @Before
     public void setUp() {
         vertx = Vertx.vertx();
+        router = Router.router(vertx);
+        server = vertx.createHttpServer()
+                .requestHandler(router)
+                .listenAndAwait(0, "localhost");
+        client = vertx.createHttpClient(new HttpClientOptions().setDefaultPort(server.actualPort()));
     }
 
     @After
     public void tearDown() {
+        if (client != null) {
+            client.close().onFailure().recoverWithNull().await().indefinitely();
+        }
+        if (server != null) {
+            server.close().onFailure().recoverWithNull().await().indefinitely();
+        }
         vertx.closeAndAwait();
     }
 
     @Test
     public void testRouter() throws InterruptedException {
-        Router router = Router.router(vertx);
         router.get("/").handler(rc -> {
             rc.response().endAndForget("hello");
         });
         router.get("/assets/*").handler(StaticHandler.create("src/test/resources/assets"));
         router.post().handler(BodyHandler.create());
-        router.post("/post").handler(rc -> rc.response().endAndForget(rc.getBodyAsString()));
-
-        vertx.createHttpServer()
-                .requestHandler(router::handle)
-                .listenAndAwait(8085);
-
-        HttpClient client = vertx.createHttpClient();
+        router.post("/post").handler(rc -> rc.response().endAndForget(rc.body().asString()));
 
         CountDownLatch latch1 = new CountDownLatch(1);
         RequestOptions req1 = new RequestOptions()
-                .setAbsoluteURI("http://localhost:8085");
+                .setAbsoluteURI(String.format("http://localhost:%d", server.actualPort()));
         HttpClientRequest request1 = client.requestAndAwait(req1);
         request1.response().subscribe().with(
                 resp -> resp.toMulti().subscribe().with(buffer -> {
-                    assertEquals(buffer.toString(), "hello");
+                    assertEquals("hello", buffer.toString());
                     latch1.countDown();
                 }));
         request1
@@ -70,12 +80,12 @@ public void testRouter() throws InterruptedException {
 
         CountDownLatch latch2 = new CountDownLatch(1);
         RequestOptions req2 = new RequestOptions()
-                .setAbsoluteURI("http://localhost:8085/assets/test.txt");
+                .setAbsoluteURI(String.format("http://localhost:%d/assets/test.txt", server.actualPort()));
         HttpClientRequest request2 = client.requestAndAwait(req2);
         request2.response().subscribe().with(
                 resp -> {
                     resp.toMulti().subscribe().with(buffer -> {
-                        assertEquals(buffer.toString(), "This is a test.");
+                        assertEquals("This is a test.", buffer.toString());
                         latch2.countDown();
                     });
                 });
@@ -85,17 +95,24 @@ public void testRouter() throws InterruptedException {
         assertTrue(latch2.await(1, TimeUnit.SECONDS));
 
         CountDownLatch latch3 = new CountDownLatch(1);
-        WebClient webClient = WebClient.create(vertx);
-        HttpRequest<Buffer> request3 = webClient.postAbs("http://localhost:8085/post");
+        WebClient webClient = WebClient.wrap(client);
+        HttpRequest<Buffer> request3 = webClient.postAbs(String.format("http://localhost:%d/post", server.actualPort()));
         Uni<HttpResponse<Buffer>> uni = request3
                 .sendStream(Multi.createFrom().items("Hello", " ", "World", "!").map(Buffer::buffer));
 
         uni.subscribe().with(r -> {
-            assertEquals(r.bodyAsString(), "Hello World!");
+            assertEquals("Hello World!", r.bodyAsString());
             latch3.countDown();
         });
 
         assertTrue(latch3.await(1, TimeUnit.SECONDS));
     }
 
+    @Test
+    public void testOrderListenerIsInvoked() {
+        router.get().handler(TestRouteHandler.create());
+        WebClient webClient = WebClient.wrap(client);
+        int statusCode = webClient.get("/").sendAndAwait().statusCode();
+        assertEquals(200, statusCode);
+    }
 }

vertx-mutiny-clients/vertx-mutiny-web/src/test/java/io/vertx/mutiny/web/TestRouteHandler.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2024 Red Hat, Inc.
+ *
+ * Red Hat licenses this file to you under the Apache License, version 2.0
+ * (the "License"); you may not use this file except in compliance with the
+ * License.  You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+package io.vertx.mutiny.web;
+
+import io.vertx.codegen.annotations.VertxGen;
+import io.vertx.core.Handler;
+import io.vertx.ext.web.RoutingContext;
+import io.vertx.mutiny.web.impl.TestRouteHandlerImpl;
+
+@VertxGen
+public interface TestRouteHandler extends Handler<RoutingContext> {
+    static TestRouteHandler create() {
+        return new TestRouteHandlerImpl();
+    }
+}

vertx-mutiny-clients/vertx-mutiny-web/src/test/java/io/vertx/mutiny/web/impl/TestRouteHandlerImpl.java

@@ -0,0 +1,26 @@
+package io.vertx.mutiny.web.impl;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import io.vertx.ext.web.RoutingContext;
+import io.vertx.ext.web.impl.OrderListener;
+import io.vertx.mutiny.web.TestRouteHandler;
+
+public class TestRouteHandlerImpl implements TestRouteHandler, OrderListener {
+
+    private final AtomicBoolean called = new AtomicBoolean();
+
+    @Override
+    public void handle(RoutingContext rc) {
+        if (called.get()) {
+            rc.response().end();
+        } else {
+            rc.fail(500);
+        }
+    }
+
+    @Override
+    public void onOrder(int order) {
+        called.set(true);
+    }
+}

vertx-mutiny-clients/vertx-mutiny-web/src/test/java/io/vertx/mutiny/web/package-info.java

@@ -0,0 +1,4 @@
+@ModuleGen(name = "webtest", groupPackage = "io.vertx")
+package io.vertx.mutiny.web;
+
+import io.vertx.codegen.annotations.ModuleGen;

vertx-mutiny-generator/src/main/java/io/smallrye/mutiny/vertx/codegen/lang/ClassDeclarationCodeWriter.java

@@ -32,6 +32,7 @@ public void generate(ClassModel model, PrintWriter writer) {
         }
 
         List<String> interfaces = new ArrayList<>();
+        interfaces.add("io.smallrye.mutiny.vertx.MutinyDelegate");
         if ("io.vertx.core.buffer.Buffer".equals(type.getName())) {
             interfaces.add("io.vertx.core.shareddata.impl.ClusterSerializable");
         }

vertx-mutiny-generator/src/main/java/io/smallrye/mutiny/vertx/codegen/lang/CodeGenHelper.java

@@ -190,15 +190,15 @@ public static String genConvParam(Map<MethodInfo, Map<TypeInfo, String>> methodT
                 ClassKind eventKind = eventType.getKind();
                 if (eventKind == ASYNC_RESULT) {
                     TypeInfo resultType = ((ParameterizedTypeInfo) eventType).getArg(0);
-                    return "new io.smallrye.mutiny.vertx.DelegatingHandler<>(" + expr + ", ar -> ar.map(event -> " + genConvReturn(methodTypeArgMap, resultType, method, "event") + "))";
+                    return "io.smallrye.mutiny.vertx.MutinyHelper.convertHandler(" + expr + ", ar -> ar.map(event -> " + genConvReturn(methodTypeArgMap, resultType, method, "event") + "))";
                 } else if (eventType.isParameterized() && eventType.getRaw().getName().equals(Promise.class.getName())) {
                     return "new Handler<" + genTypeName(eventType) + ">() {\n" +
                             "          public void handle(" + genTypeName(eventType) + " event) {\n" +
                             "            " + expr + ".subscribe().with(it -> event.complete(it), failure -> event.fail(failure));\n" +
                             "          }\n" +
                             "      }";
                 } else {
-                    return "new io.smallrye.mutiny.vertx.DelegatingHandler<>(" + expr + ", event -> " + genConvReturn(methodTypeArgMap, eventType, method, "event") + ")";
+                    return "io.smallrye.mutiny.vertx.MutinyHelper.convertHandler(" + expr + ", event -> " + genConvReturn(methodTypeArgMap, eventType, method, "event") + ")";
                 }
             } else if (kind == FUNCTION) {
                 TypeInfo argType = parameterizedTypeInfo.getArg(0);

vertx-mutiny-generator/src/main/java/io/smallrye/mutiny/vertx/codegen/lang/GetDelegateMethodCodeWriter.java

@@ -7,6 +7,7 @@
 public class GetDelegateMethodCodeWriter implements ConditionalCodeWriter {
     @Override
     public void generate(ClassModel model, PrintWriter writer) {
+        writer.println("  @Override");
         writer.print("  public ");
         writer.print(model.getType().getName());
         writer.println(" getDelegate() {");

vertx-mutiny-generator/src/main/java/io/smallrye/mutiny/vertx/codegen/methods/ConsumerMethodGenerator.java

@@ -60,7 +60,7 @@ private void generateBody(MutinyMethodDescriptor descriptor) {
                 } else if(param.getType().getName().equals(Runnable.class.getName())) {
                     writer.println("ignored -> " + param.getName() + ".run()");
                 } else {
-                    writer.print(param.getName() + " != null ? new io.smallrye.mutiny.vertx.DelegatingConsumerHandler(" + param.getName() + ") : null");
+                    writer.print("io.smallrye.mutiny.vertx.MutinyHelper.convertConsumer(" + param.getName() + ")");
                 }
             }
         }