OpenAPI: fix handling of paths given in configuration

Fixes #26870

Signed-off-by: Michael Edgar <[email protected]>

Author: MikeEdgar

extensions/smallrye-openapi/deployment/pom.xml

@@ -65,6 +65,8 @@
       <groupId>io.smallrye</groupId>
       <artifactId>smallrye-open-api-vertx</artifactId>
     </dependency>
+
+    <!-- Test -->
     <dependency>
       <groupId>io.quarkus</groupId>
       <artifactId>quarkus-resteasy-deployment</artifactId>
@@ -85,6 +87,16 @@
       <artifactId>rest-assured</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>jakarta.ws.rs</groupId>
+      <artifactId>jakarta.ws.rs-api</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 
   <build>

extensions/smallrye-openapi/deployment/src/main/java/io/quarkus/smallrye/openapi/deployment/CustomPathExtension.java

@@ -1,8 +1,19 @@
 package io.quarkus.smallrye.openapi.deployment;
 
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
+import org.jboss.jandex.AnnotationInstance;
+import org.jboss.jandex.AnnotationValue;
 import org.jboss.jandex.ClassInfo;
+import org.jboss.jandex.DotName;
 
 import io.smallrye.openapi.runtime.scanner.AnnotationScannerExtension;
 import io.smallrye.openapi.runtime.scanner.spi.AnnotationScanner;
@@ -12,14 +23,59 @@
  */
 public class CustomPathExtension implements AnnotationScannerExtension {
 
-    private final String defaultPath;
+    static final Set<DotName> APPLICATION_PATH = new TreeSet<>(Arrays.asList(
+            DotName.createSimple("jakarta.ws.rs.ApplicationPath"),
+            DotName.createSimple("javax.ws.rs.ApplicationPath")));
 
-    public CustomPathExtension(String defaultPath) {
-        this.defaultPath = defaultPath;
+    private final String rootPath;
+    private final String appPath;
+
+    public CustomPathExtension(String rootPath, String appPath) {
+        this.rootPath = rootPath;
+        this.appPath = appPath;
     }
 
     @Override
     public void processScannerApplications(AnnotationScanner scanner, Collection<ClassInfo> applications) {
-        scanner.setContextRoot(defaultPath);
+        Optional<String> appPathAnnotationValue = applications.stream()
+                .flatMap(app -> APPLICATION_PATH.stream().map(app::declaredAnnotation))
+                .filter(Objects::nonNull)
+                .map(AnnotationInstance::value)
+                .map(AnnotationValue::asString)
+                .findFirst();
+
+        /*
+         * If the @ApplicationPath was found, ignore the appPath given in configuration and only
+         * use the rootPath for the contextRoot.
+         */
+        String contextRoot = appPathAnnotationValue.map(path -> buildContextRpot(rootPath))
+                .orElseGet(() -> buildContextRpot(rootPath, this.appPath));
+
+        if (!"/".equals(contextRoot)) {
+            scanner.setContextRoot(contextRoot);
+        }
+    }
+
+    static String buildContextRpot(String... segments) {
+        String path = Stream.of(segments)
+                .filter(Objects::nonNull)
+                .map(CustomPathExtension::stripSlashes)
+                .filter(Predicate.not(String::isEmpty))
+                .map("/"::concat)
+                .collect(Collectors.joining());
+
+        return path.isEmpty() ? "/" : path;
+    }
+
+    static String stripSlashes(String segment) {
+        if (segment.startsWith("/")) {
+            segment = segment.substring(1);
+        }
+
+        if (segment.endsWith("/")) {
+            segment = segment.substring(0, segment.length() - 1);
+        }
+
+        return segment;
     }
 }

extensions/smallrye-openapi/deployment/src/main/java/io/quarkus/smallrye/openapi/deployment/SmallRyeOpenApiProcessor.java

@@ -23,7 +23,6 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.regex.Matcher;
@@ -79,7 +78,6 @@
 import io.quarkus.deployment.util.IoUtil;
 import io.quarkus.resteasy.common.spi.ResteasyDotNames;
 import io.quarkus.resteasy.server.common.spi.AllowedJaxRsAnnotationPrefixBuildItem;
-import io.quarkus.resteasy.server.common.spi.ResteasyJaxrsConfigBuildItem;
 import io.quarkus.runtime.LaunchMode;
 import io.quarkus.runtime.util.ClassPathUtils;
 import io.quarkus.security.Authenticated;
@@ -689,7 +687,6 @@ public void build(BuildProducer<FeatureBuildItem> feature,
             HttpRootPathBuildItem httpRootPathBuildItem,
             OutputTargetBuildItem out,
             SmallRyeOpenApiConfig smallRyeOpenApiConfig,
-            Optional<ResteasyJaxrsConfigBuildItem> resteasyJaxrsConfig,
             OutputTargetBuildItem outputTargetBuildItem,
             List<IgnoreStaticDocumentBuildItem> ignoreStaticDocumentBuildItems) throws Exception {
         FilteredIndexView index = openApiFilteredIndexViewBuildItem.getIndex();
@@ -710,8 +707,7 @@ public void build(BuildProducer<FeatureBuildItem> feature,
         OpenAPI annotationModel;
 
         if (shouldScanAnnotations(capabilities, index)) {
-            annotationModel = generateAnnotationModel(index, capabilities, httpRootPathBuildItem, resteasyJaxrsConfig, config,
-                    openApiConfig);
+            annotationModel = generateAnnotationModel(index, capabilities, httpRootPathBuildItem, config, openApiConfig);
         } else {
             annotationModel = new OpenAPIImpl();
         }
@@ -827,29 +823,24 @@ private OpenAPI generateStaticModel(SmallRyeOpenApiConfig smallRyeOpenApiConfig,
 
     private OpenAPI generateAnnotationModel(IndexView indexView, Capabilities capabilities,
             HttpRootPathBuildItem httpRootPathBuildItem,
-            Optional<ResteasyJaxrsConfigBuildItem> resteasyJaxrsConfig, Config config, OpenApiConfig openApiConfig) {
+            Config config, OpenApiConfig openApiConfig) {
 
         List<AnnotationScannerExtension> extensions = new ArrayList<>();
 
         // Add the RESTEasy extension if the capability is present
-        String defaultPath = httpRootPathBuildItem.getRootPath();
+        String rootPath = httpRootPathBuildItem.getRootPath();
+        String appPath = "";
+
         if (capabilities.isPresent(Capability.RESTEASY)) {
             extensions.add(new RESTEasyExtension(indexView));
-            if (resteasyJaxrsConfig.isPresent()) {
-                defaultPath = resteasyJaxrsConfig.get().getRootPath();
-            }
+            appPath = config.getOptionalValue("quarkus.resteasy.path", String.class).orElse("");
         } else if (capabilities.isPresent(Capability.RESTEASY_REACTIVE)) {
             extensions.add(new RESTEasyExtension(indexView));
             openApiConfig.doAllowNakedPathParameter();
-            Optional<String> maybePath = config.getOptionalValue("quarkus.resteasy-reactive.path", String.class);
-            if (maybePath.isPresent()) {
-                defaultPath = maybePath.get();
-            }
+            appPath = config.getOptionalValue("quarkus.resteasy-reactive.path", String.class).orElse("");
         }
 
-        if (defaultPath != null && !"/".equals(defaultPath)) {
-            extensions.add(new CustomPathExtension(defaultPath));
-        }
+        extensions.add(new CustomPathExtension(rootPath, appPath));
 
         OpenApiAnnotationScanner openApiAnnotationScanner = new OpenApiAnnotationScanner(openApiConfig, indexView, extensions);
         return openApiAnnotationScanner.scan(getScanners(capabilities, indexView));

extensions/smallrye-openapi/deployment/src/test/java/io/quarkus/smallrye/openapi/deployment/CustomPathExtensionTest.java

@@ -0,0 +1,63 @@
+package io.quarkus.smallrye.openapi.deployment;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+import org.jboss.jandex.Index;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.mockito.Mockito;
+
+import io.smallrye.openapi.runtime.scanner.spi.AnnotationScanner;
+
+class CustomPathExtensionTest {
+
+    AnnotationScanner scanner;
+
+    @BeforeEach
+    void setup() {
+        scanner = Mockito.mock(AnnotationScanner.class);
+    }
+
+    @Test
+    void testContextPathNotInvokedForEmptyPaths() {
+        CustomPathExtension ext = new CustomPathExtension("/", "");
+        ext.processScannerApplications(scanner, Collections.emptyList());
+        Mockito.verify(scanner, Mockito.never()).setContextRoot(Mockito.anyString());
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "'/root', 'app-from-config'  , '/root/app-from-config'",
+            "'/'    , '/app-from-config/', '/app-from-config'",
+            "''     , '/app-from-config/', '/app-from-config'",
+            "       , 'app-from-config'  , '/app-from-config'",
+    })
+    void testContextPathGenerationWithoutApplicationPathAnnotation(String rootPath, String appPath, String expected) {
+        CustomPathExtension ext = new CustomPathExtension(rootPath, appPath);
+        ext.processScannerApplications(scanner, Collections.emptyList());
+        Mockito.verify(scanner).setContextRoot(expected);
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+            "'/root', 'app-from-config'  , 1, '/root'",
+            "'/'    , '/app-from-config/', 0, ",
+            "''     , '/app-from-config/', 0, ",
+            "       , 'app-from-config'  , 0, ",
+    })
+    void testContextPathGenerationWithApplicationPathAnnotation(String rootPath, String appPath, int times, String expected)
+            throws IOException {
+        @jakarta.ws.rs.ApplicationPath("app-path-from-anno")
+        class TestApp extends jakarta.ws.rs.core.Application {
+        }
+
+        CustomPathExtension ext = new CustomPathExtension(rootPath, appPath);
+        ext.processScannerApplications(scanner, List.of(Index.of(TestApp.class).getClassByName(TestApp.class)));
+        Mockito.verify(scanner, Mockito.times(times)).setContextRoot(times > 0 ? expected : Mockito.anyString());
+    }
+
+}