[Kotlin][jvm-spring-webclient] Support accessing basePath & basePathWithoutHost

modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-spring-webclient/api.mustache

@@ -24,14 +24,20 @@ import {{packageName}}.infrastructure.*
 {{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}open {{/nonPublicApi}}class {{classname}}(client: WebClient) : ApiClient(client) {
 
     {{#jackson}}
-    {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}constructor(baseUrl: String) : this(WebClient.builder()
+    {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}constructor(baseUrl: String = ApiClient.BASE_URL) : this(WebClient.builder()
         .baseUrl(baseUrl)
         .codecs {
             it.defaultCodecs().jackson2JsonEncoder(Jackson2JsonEncoder(Serializer.jacksonObjectMapper, MediaType.APPLICATION_JSON))
             it.defaultCodecs().jackson2JsonDecoder(Jackson2JsonDecoder(Serializer.jacksonObjectMapper, MediaType.APPLICATION_JSON))
         }
         .build()
     )
+
+    {{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}companion object {
+        {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}fun createWithBasePath(baseUrl: String, basePath: String = ApiClient.BASE_PATH_WITHOUT_HOST): {{classname}} {
+            return {{classname}}(createUrlWithBasePath(baseUrl, basePath))
+        }
+    }
     {{/jackson}}
 
     {{#operation}}

modules/openapi-generator/src/main/resources/kotlin-client/libraries/jvm-spring-webclient/infrastructure/ApiClient.kt.mustache

@@ -66,6 +66,21 @@ import reactor.core.publisher.Mono
             }
         }
     }
+
+    {{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}companion object {
+        {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}const val BASE_URL: String = "{{{basePath}}}"
+        {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}const val BASE_PATH_WITHOUT_HOST: String = "{{{basePathWithoutHost}}}"
+    }
+}
+
+{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}fun createUrlWithBasePath(baseUrl: String, basePath: String = ApiClient.BASE_PATH_WITHOUT_HOST): String {
+    if(baseUrl.endsWith("/") && basePath.startsWith("/")) {
+        return baseUrl.dropLast(1) + basePath
+    } else if(!baseUrl.endsWith("/") && !basePath.startsWith("/")) {
+        return "$baseUrl/$basePath"
+    } else {
+        return baseUrl + basePath;
+    }
 }
 
 {{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}inline fun <reified T: Any> parseDateToQueryString(value : T): String {
@@ -84,3 +99,4 @@ import reactor.core.publisher.Mono
         return value.toString()
         {{/toJson}}
     }
+

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/AbstractFunctionAssert.java

@@ -0,0 +1,39 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.Assertions;
+import org.jetbrains.kotlin.psi.KtFunction;
+import org.jetbrains.kotlin.psi.KtParameter;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public abstract class AbstractFunctionAssert<SELF extends AbstractFunctionAssert<SELF, PARAM_ASSERT>, PARAM_ASSERT> extends AbstractAssert<SELF, KtFunction> {
+
+    AbstractFunctionAssert(final KtFunction function, final Class<SELF> selfType) {
+        super(function, selfType);
+    }
+
+    abstract PARAM_ASSERT createParameterAssert(final KtParameter parameter);
+
+    public PARAM_ASSERT assertParameter(final String parameterName) {
+        final List<KtParameter> parameters = actual.getValueParameters().stream()
+                .filter(p -> Objects.equals(p.getName(), parameterName))
+                .collect(Collectors.toList());
+        Assertions.assertThat(parameters)
+                .withFailMessage("Expected function to have a single parameter %s, but found %s", parameterName, parameters.size())
+                .hasSize(1);
+
+        return createParameterAssert(parameters.get(0));
+    }
+
+    public SELF hasReturnType(final String expectedReturnType) {
+        final String actualReturnType = actual.getTypeReference() != null ? actual.getTypeReference().getText() : null;
+        Assertions.assertThat(actualReturnType)
+                .withFailMessage("Expected function %s to have return type %s, but was %s", actual.getName(), expectedReturnType, actualReturnType)
+                .isEqualTo(expectedReturnType);
+
+        return myself;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/AbstractParameterAssert.java

@@ -0,0 +1,50 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+import org.jetbrains.kotlin.psi.KtParameter;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+@CanIgnoreReturnValue
+abstract class AbstractParameterAssert<SELF extends AbstractParameterAssert<SELF, ANNOTATION_ASSERT>, ANNOTATION_ASSERT> extends AbstractAssert<SELF, KtParameter> {
+
+    AbstractParameterAssert(final KtParameter parameter, final Class<?> selfType) {
+        super(parameter, selfType);
+    }
+
+    abstract ANNOTATION_ASSERT createAnnotationAssert(final KtAnnotationEntry annotation);
+
+    public ANNOTATION_ASSERT assertParameterAnnotation(final String annotationName) {
+        final List<KtAnnotationEntry> annotations = actual.getAnnotationEntries().stream()
+                .filter(a -> Objects.equals(a.getShortName() != null ? a.getShortName().asString() : null, annotationName))
+                .collect(Collectors.toList());
+        Assertions.assertThat(annotations)
+                .withFailMessage("Expected parameter to have a single annotation %s, but found %s", annotationName, annotations.size())
+                .hasSize(1);
+
+        return createAnnotationAssert(annotations.get(0));
+    }
+
+    public SELF hasType(final String expectedType) {
+        final String actualType = actual.getTypeReference() != null ? actual.getTypeReference().getText() : null;
+        Assertions.assertThat(actualType)
+                .withFailMessage("Expected parameter %s to have type %s, but was %s", actual.getName(), expectedType, actualType)
+                .isEqualTo(expectedType);
+
+        return myself;
+    }
+
+    public SELF hasDefaultValue(final String expectedValue) {
+        final String actualValue = actual.getDefaultValue() != null ? actual.getDefaultValue().getText() : null;
+        Assertions.assertThat(actualValue)
+                .withFailMessage("Expected parameter %s to have default value %s, but was %s", actual.getName(), expectedValue, actualValue)
+                .isEqualTo(expectedValue);
+
+        return myself;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/ClassAssert.java

@@ -6,9 +6,11 @@
 import org.jetbrains.kotlin.psi.KtClass;
 import org.jetbrains.kotlin.psi.KtNamedFunction;
 import org.jetbrains.kotlin.psi.KtParameter;
+import org.jetbrains.kotlin.psi.KtSecondaryConstructor;
 
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 @CanIgnoreReturnValue
@@ -45,6 +47,21 @@ public PrimaryConstructorParameterAssert assertPrimaryConstructorParameter(final
         return new PrimaryConstructorParameterAssert(this, parameters.get(0));
     }
 
+    public ClassAssert assertAnySecondaryConstructorSatisfies(final Consumer<KtSecondaryConstructor> requirements) {
+        Assertions.assertThat(actual.getSecondaryConstructors())
+                .anySatisfy(requirements);
+
+        return this;
+    }
+
+    public CompanionAssert assertCompanion() {
+        Assertions.assertThat(actual.getCompanionObjects())
+                .withFailMessage("Expected class to have a single companion object, but found %s", actual.getCompanionObjects().size())
+                .hasSize(1);
+
+        return new CompanionAssert(this, actual.getCompanionObjects().get(0));
+    }
+
     public KotlinFileAssert toFile() {
         return fileAssert;
     }

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/CompanionAssert.java

@@ -0,0 +1,54 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtObjectDeclaration;
+import org.jetbrains.kotlin.psi.KtProperty;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+@CanIgnoreReturnValue
+public class CompanionAssert extends AbstractAssert<CompanionAssert, KtObjectDeclaration> {
+    private final ClassAssert classAssert;
+
+    CompanionAssert(final ClassAssert classAssert, final KtObjectDeclaration companion) {
+        super(companion, CompanionAssert.class);
+        this.classAssert = classAssert;
+    }
+
+    public CompanionPropertyAssert assertProperty(final String propertyName) {
+        Assertions.assertThat(actual.getBody())
+                .withFailMessage("Expected companion to have a body, but it was null")
+                .isNotNull();
+        final List<KtProperty> properties = actual.getBody().getProperties().stream()
+                .filter(p -> Objects.equals(p.getName(), propertyName))
+                .collect(Collectors.toList());
+        Assertions.assertThat(properties)
+                .withFailMessage("Expected companion object to have a single property %s, but found %s", propertyName, properties.size())
+                .hasSize(1);
+
+        return new CompanionPropertyAssert(this, properties.get(0));
+    }
+
+    public CompanionFunctionAssert assertFunction(final String functionName) {
+        Assertions.assertThat(actual.getBody())
+                .withFailMessage("Expected companion to have a body, but it was null")
+                .isNotNull();
+        final List<KtNamedFunction> functions = actual.getBody().getFunctions().stream()
+                .filter(f -> Objects.equals(f.getName(), functionName))
+                .collect(Collectors.toList());
+        Assertions.assertThat(functions)
+                .withFailMessage("Expected companion object to have a single function %s, but found %s", functionName, functions.size())
+                .hasSize(1);
+
+        return new CompanionFunctionAssert(classAssert, functions.get(0));
+    }
+
+    public ClassAssert toClass() {
+        return classAssert;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/CompanionFunctionAssert.java

@@ -0,0 +1,23 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtParameter;
+
+@CanIgnoreReturnValue
+public class CompanionFunctionAssert extends AbstractFunctionAssert<CompanionFunctionAssert, CompanionFunctionParameterAssert> {
+    private final ClassAssert classAssert;
+
+    CompanionFunctionAssert(final ClassAssert classAssert, final KtNamedFunction function) {
+        super(function, CompanionFunctionAssert.class);
+        this.classAssert = classAssert;
+    }
+
+    CompanionFunctionParameterAssert createParameterAssert(final KtParameter parameter) {
+        return new CompanionFunctionParameterAssert(this, parameter);
+    }
+
+    public ClassAssert toClass() {
+        return classAssert;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/CompanionFunctionParameterAnnotationAssert.java

@@ -0,0 +1,18 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+
+@CanIgnoreReturnValue
+public class CompanionFunctionParameterAnnotationAssert extends AbstractAnnotationAssert<CompanionFunctionParameterAnnotationAssert> {
+    private final CompanionFunctionParameterAssert parameterAssert;
+
+    CompanionFunctionParameterAnnotationAssert(final CompanionFunctionParameterAssert parameterAssert, final KtAnnotationEntry annotationEntry) {
+        super(annotationEntry, CompanionFunctionParameterAnnotationAssert.class);
+        this.parameterAssert = parameterAssert;
+    }
+
+    public CompanionFunctionParameterAssert toParameter() {
+        return parameterAssert;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/CompanionFunctionParameterAssert.java

@@ -0,0 +1,23 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+import org.jetbrains.kotlin.psi.KtParameter;
+
+@CanIgnoreReturnValue
+public class CompanionFunctionParameterAssert extends AbstractParameterAssert<CompanionFunctionParameterAssert, CompanionFunctionParameterAnnotationAssert> {
+    private final CompanionFunctionAssert functionAssert;
+
+    CompanionFunctionParameterAssert(final CompanionFunctionAssert functionAssert, final KtParameter parameter) {
+        super(parameter, CompanionFunctionParameterAssert.class);
+        this.functionAssert = functionAssert;
+    }
+
+    CompanionFunctionParameterAnnotationAssert createAnnotationAssert(final KtAnnotationEntry annotation) {
+        return new CompanionFunctionParameterAnnotationAssert(this, annotation);
+    }
+
+    public CompanionFunctionAssert toFunction() {
+        return functionAssert;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/CompanionPropertyAssert.java

@@ -0,0 +1,37 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.api.AbstractAssert;
+import org.assertj.core.api.Assertions;
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtProperty;
+
+@CanIgnoreReturnValue
+public class CompanionPropertyAssert extends AbstractAssert<CompanionPropertyAssert, KtProperty> {
+    private final CompanionAssert companionAssert;
+
+    CompanionPropertyAssert(final CompanionAssert companionAssert, final KtProperty property) {
+        super(property, CompanionPropertyAssert.class);
+        this.companionAssert = companionAssert;
+    }
+
+    public CompanionPropertyAssert isConst() {
+        Assertions.assertThat(actual.hasModifier(org.jetbrains.kotlin.lexer.KtTokens.CONST_KEYWORD))
+                .withFailMessage("Expected property %s to be const, but it was not", actual.getName())
+                .isTrue();
+
+        return this;
+    }
+
+    public CompanionPropertyAssert hasInitializer(final String expectedValue) {
+        final String actualValue = actual.getInitializer() != null ? actual.getInitializer().getText() : null;
+        Assertions.assertThat(actualValue)
+                .withFailMessage("Expected property %s to have value %s, but was %s", actual.getName(), expectedValue, actualValue)
+                .isEqualTo(expectedValue);
+
+        return this;
+    }
+
+    public CompanionAssert toCompanion() {
+        return companionAssert;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/FunctionAssert.java

@@ -0,0 +1,23 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtNamedFunction;
+import org.jetbrains.kotlin.psi.KtParameter;
+
+@CanIgnoreReturnValue
+public class FunctionAssert extends AbstractFunctionAssert<FunctionAssert, FunctionParameterAssert> {
+    private final KotlinFileAssert fileAssert;
+
+    FunctionAssert(final KotlinFileAssert fileAssert, final KtNamedFunction function) {
+        super(function, FunctionAssert.class);
+        this.fileAssert = fileAssert;
+    }
+
+    FunctionParameterAssert createParameterAssert(final KtParameter parameter) {
+        return new FunctionParameterAssert(this, parameter);
+    }
+
+    public KotlinFileAssert toFile() {
+        return fileAssert;
+    }
+}

modules/openapi-generator/src/test/java/org/openapitools/codegen/kotlin/assertions/FunctionParameterAnnotationAssert.java

@@ -0,0 +1,18 @@
+package org.openapitools.codegen.kotlin.assertions;
+
+import org.assertj.core.util.CanIgnoreReturnValue;
+import org.jetbrains.kotlin.psi.KtAnnotationEntry;
+
+@CanIgnoreReturnValue
+public class FunctionParameterAnnotationAssert extends AbstractAnnotationAssert<FunctionParameterAnnotationAssert> {
+    private final FunctionParameterAssert parameterAssert;
+
+    FunctionParameterAnnotationAssert(final FunctionParameterAssert parameterAssert, final KtAnnotationEntry annotationEntry) {
+        super(annotationEntry, FunctionParameterAnnotationAssert.class);
+        this.parameterAssert = parameterAssert;
+    }
+
+    public FunctionParameterAssert toParameter() {
+        return parameterAssert;
+    }
+}