fix: Fix for #187 - swagger 2.0 parser was adding a trailing / in base path

Author: en-milie

src/main/java/com/endava/cats/args/ApiArguments.java

@@ -121,6 +121,15 @@ public void validateValidServer(CommandLine.Model.CommandSpec spec, OpenAPI open
             }
         }
 
+        this.validateURL(spec);
+
+        if (this.server.endsWith("/")) {
+            this.server = this.server.substring(0, this.server.length() - 1);
+        }
+        log.debug("Final server URL: {}", this.server);
+    }
+
+    private void validateURL(CommandLine.Model.CommandSpec spec) {
         if (this.server == null) {
             throw new CommandLine.ParameterException(spec.commandLine(),
                     "Missing required option --server=<server>");

src/main/java/com/endava/cats/io/ServiceCaller.java

@@ -262,10 +262,11 @@ public CatsResponse call(ServiceData data) {
      *
      * @param data             the service data context
      * @param processedPayload current payload
-     * @return an url with path params replaced by urlParams or refData + additional query params
+     * @return a url with path params replaced by urlParams or refData + additional query params
      */
     String constructUrl(ServiceData data, String processedPayload) {
         String decodedUrl = CatsUtil.unescapeCurlyBrackets(apiArguments.getServer() + data.getRelativePath());
+        logger.debug("Decoded URL: {}", decodedUrl);
         if (!data.isReplaceUrlParams()) {
             String actualUrl = this.replacePathParams(decodedUrl, processedPayload, data);
             return this.replaceRemovedParams(actualUrl);
@@ -279,6 +280,7 @@ String constructUrl(ServiceData data, String processedPayload) {
         }
         url = this.addPathParamsIfNotReplaced(url, data.getPathParamsPayload());
         url = this.addAdditionalQueryParams(url, data.getRelativePath());
+        logger.debug("Replaced URL: {}", url);
         return url;
     }
 

src/main/java/com/endava/cats/util/CatsUtil.java

@@ -318,7 +318,6 @@ public static Faker faker() {
     public static boolean isValidURL(String urlString) {
         try {
             URI.create(urlString).toURL();
-
             return true;
         } catch (Exception _) {
             return false;

src/test/java/com/endava/cats/args/ApiArgumentsTest.java

@@ -4,11 +4,15 @@
 import io.swagger.v3.oas.models.OpenAPI;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.Mockito;
 import org.springframework.test.util.ReflectionTestUtils;
 import picocli.CommandLine;
 
 import java.util.Collections;
+import java.util.stream.Stream;
 
 @QuarkusTest
 class ApiArgumentsTest {
@@ -66,54 +70,30 @@ void shouldThrowExceptionWhenServerAndOpenApiNull() {
                 .hasMessageContaining("server");
     }
 
-    @Test
-    void shouldSetServerFromOpenApiWhenServerIsNull() {
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("serverResolutionArguments")
+    void shouldResolveServerAccordingToPriority(String description, String initialServer, String openApiServerUrl, String expectedServer) {
         CommandLine.Model.CommandSpec spec = Mockito.mock(CommandLine.Model.CommandSpec.class);
         Mockito.when(spec.commandLine()).thenReturn(Mockito.mock(CommandLine.class));
         ApiArguments args = new ApiArguments();
-        args.setServer(null);
+        args.setServer(initialServer);
 
         OpenAPI openAPI = new OpenAPI();
         openAPI.setServers(Collections.singletonList(
-                new io.swagger.v3.oas.models.servers.Server().url("http://fromopenapi.com")
+                new io.swagger.v3.oas.models.servers.Server().url(openApiServerUrl)
         ));
 
         args.validateValidServer(spec, openAPI);
-        Assertions.assertThat(args.getServer()).isEqualTo("http://fromopenapi.com");
-    }
-
-    @Test
-    void shouldReplaceServerPlaceholder() {
-        CommandLine.Model.CommandSpec spec = Mockito.mock(CommandLine.Model.CommandSpec.class);
-        Mockito.when(spec.commandLine()).thenReturn(Mockito.mock(CommandLine.class));
-        ApiArguments args = new ApiArguments();
-        args.setServer("http://api.com");
 
-        OpenAPI openAPI = new OpenAPI();
-        openAPI.setServers(Collections.singletonList(
-                new io.swagger.v3.oas.models.servers.Server().url("{apiRoot}/v2")
-        ));
-        args.validateValidServer(spec, openAPI);
-        // The placeholder should be replaced
-        Assertions.assertThat(args.getServer()).isEqualTo("http://api.com/v2");
+        Assertions.assertThat(args.getServer()).isEqualTo(expectedServer);
     }
 
-    @Test
-    void shouldPreferCliServerOverOpenApiConcreteServer() {
-        CommandLine.Model.CommandSpec spec = Mockito.mock(CommandLine.Model.CommandSpec.class);
-        Mockito.when(spec.commandLine()).thenReturn(Mockito.mock(CommandLine.class));
-        ApiArguments args = new ApiArguments();
-        args.setServer("http://localhost:8080");
-
-        OpenAPI openAPI = new OpenAPI();
-        openAPI.setServers(Collections.singletonList(
-                new io.swagger.v3.oas.models.servers.Server().url("https://api.example.com")
-        ));
-
-        args.validateValidServer(spec, openAPI);
-
-        // CLI server should take priority over concrete OpenAPI server
-        Assertions.assertThat(args.getServer()).isEqualTo("http://localhost:8080");
+    private static Stream<Arguments> serverResolutionArguments() {
+        return Stream.of(
+                Arguments.of("should set server from OpenAPI when CLI server is null", null, "http://fromopenapi.com", "http://fromopenapi.com"),
+                Arguments.of("should replace OpenAPI placeholder with CLI server", "http://api.com", "{apiRoot}/v2", "http://api.com/v2"),
+                Arguments.of("should prefer CLI server over concrete OpenAPI server", "http://localhost:8080", "https://api.example.com", "http://localhost:8080")
+        );
     }
 
     @Test
@@ -138,4 +118,12 @@ void shouldPassWhenServerIsValidUrl() {
         Assertions.assertThatCode(() -> args.validateValidServer(spec, null))
                 .doesNotThrowAnyException();
     }
+
+    @Test
+    void shouldRemoveTrailingSlashFromServer() {
+        ApiArguments args = new ApiArguments();
+        args.setServer("http://api.com/");
+        args.validateValidServer(null, null);
+        Assertions.assertThat(args.getServer()).isEqualTo("http://api.com");
+    }
 }

src/test/java/com/endava/cats/factory/FuzzingDataFactoryTest.java

@@ -875,12 +875,7 @@ void shouldParseOpenApi311WithNullAndStringSchema() throws Exception {
         Assertions.assertThat(dataList).hasSize(1);
         Assertions.assertThat(dataList.getFirst().getMethod()).isEqualTo(HttpMethod.POST);
         String example = dataList.getFirst().getPayload();
-        Assertions.assertThat(example).contains("title");
-        Assertions.assertThat(example).contains("departmentId");
-        Assertions.assertThat(example).contains("deadlineDate");
-        Assertions.assertThat(example).contains("locationId");
-        Assertions.assertThat(example).contains("messageTemplateId");
-        Assertions.assertThat(example).contains("vacancyTemplateId");
+        Assertions.assertThat(example).contains("title", "deadlineDate", "locationId", "messageTemplateId", "vacancyTemplateId");
     }
 
     @Test

src/test/java/com/endava/cats/util/SimpleJsonFormatterTest.java

@@ -63,8 +63,6 @@ void shouldHandleMalformedJsonWithExtraClosingSquareBrackets() {
     void shouldHandleNestedStructures() {
         String input = "{\"outer\":{\"inner\":{\"deep\":\"value\"}}}";
         String result = SimpleJsonFormatter.formatJson(input);
-        assertThat(result).contains("\"outer\":");
-        assertThat(result).contains("\"inner\":");
-        assertThat(result).contains("\"deep\": \"value\"");
+        assertThat(result).contains("\"outer\":", "\"inner\":", "\"deep\": \"value\"");
     }
 }