Skip to content

Commit 3c618ed

Browse files
svenallerssvenallers
committed
[Kotlin][jvm-spring-webclient] Support accessing basePath & basePathWithoutHost 
1 parent f3a21a8 commit 3c618ed

25 files changed

Lines changed: 629 additions & 73 deletions

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

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,14 +24,20 @@ import {{packageName}}.infrastructure.*
2424
{{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}open {{/nonPublicApi}}class {{classname}}(client: WebClient) : ApiClient(client) {
2525
2626
{{#jackson}}
27-
{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}constructor(baseUrl: String) : this(WebClient.builder()
27+
{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}constructor(baseUrl: String = ApiClient.BASE_URL) : this(WebClient.builder()
2828
.baseUrl(baseUrl)
2929
.codecs {
3030
it.defaultCodecs().jackson2JsonEncoder(Jackson2JsonEncoder(Serializer.jacksonObjectMapper, MediaType.APPLICATION_JSON))
3131
it.defaultCodecs().jackson2JsonDecoder(Jackson2JsonDecoder(Serializer.jacksonObjectMapper, MediaType.APPLICATION_JSON))
3232
}
3333
.build()
3434
)
35+
36+
{{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}companion object {
37+
{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}fun createWithBasePath(baseUrl: String, basePath: String = ApiClient.BASE_PATH_WITHOUT_HOST): {{classname}} {
38+
return {{classname}}(createUrlWithBasePath(baseUrl, basePath))
39+
}
40+
}
3541
{{/jackson}}
3642

3743
{{#operation}}

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

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,20 @@ import reactor.core.publisher.Mono
6666
}
6767
}
6868
}
69+
70+
{{#nonPublicApi}}internal {{/nonPublicApi}}{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}companion object {
71+
{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}const val BASE_URL: String = "{{{basePath}}}"
72+
{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}const val BASE_PATH_WITHOUT_HOST: String = "{{{basePathWithoutHost}}}"
73+
}
74+
}
75+
76+
{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}fun createUrlWithBasePath(baseUrl: String, basePath: String = ApiClient.BASE_PATH_WITHOUT_HOST): String {
77+
if(baseUrl.endsWith("/") && basePath.startsWith("/")) {
78+
return baseUrl.dropLast(1) + basePath
79+
} else if(!baseUrl.endsWith("/") && !basePath.startsWith("/")) {
80+
return "$baseUrl/$basePath"
81+
}
82+
return baseUrl + basePath
6983
}
7084

7185
{{^nonPublicApi}}{{#explicitApi}}public {{/explicitApi}}{{/nonPublicApi}}inline fun <reified T: Any> parseDateToQueryString(value : T): String {
@@ -84,3 +98,4 @@ import reactor.core.publisher.Mono
8498
return value.toString()
8599
{{/toJson}}
86100
}
101+

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

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
package org.openapitools.codegen.kotlin.assertions;
2+
3+
import org.assertj.core.api.AbstractAssert;
4+
import org.assertj.core.api.Assertions;
5+
import org.jetbrains.kotlin.psi.KtFunction;
6+
import org.jetbrains.kotlin.psi.KtParameter;
7+
8+
import java.util.List;
9+
import java.util.Objects;
10+
import java.util.stream.Collectors;
11+
12+
public abstract class AbstractFunctionAssert<SELF extends AbstractFunctionAssert<SELF, PARAM_ASSERT>, PARAM_ASSERT> extends AbstractAssert<SELF, KtFunction> {
13+
14+
AbstractFunctionAssert(final KtFunction function, final Class<SELF> selfType) {
15+
super(function, selfType);
16+
}
17+
18+
abstract PARAM_ASSERT createParameterAssert(final KtParameter parameter);
19+
20+
public PARAM_ASSERT assertParameter(final String parameterName) {
21+
final List<KtParameter> parameters = actual.getValueParameters().stream()
22+
.filter(p -> Objects.equals(p.getName(), parameterName))
23+
.collect(Collectors.toList());
24+
Assertions.assertThat(parameters)
25+
.withFailMessage("Expected function to have a single parameter %s, but found %s", parameterName, parameters.size())
26+
.hasSize(1);
27+
28+
return createParameterAssert(parameters.get(0));
29+
}
30+
31+
public SELF hasReturnType(final String expectedReturnType) {
32+
final String actualReturnType = actual.getTypeReference() != null ? actual.getTypeReference().getText() : null;
33+
Assertions.assertThat(actualReturnType)
34+
.withFailMessage("Expected function %s to have return type %s, but was %s", actual.getName(), expectedReturnType, actualReturnType)
35+
.isEqualTo(expectedReturnType);
36+
37+
return myself;
38+
}
39+
}

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

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
package org.openapitools.codegen.kotlin.assertions;
2+
3+
import org.assertj.core.api.AbstractAssert;
4+
import org.assertj.core.api.Assertions;
5+
import org.assertj.core.util.CanIgnoreReturnValue;
6+
import org.jetbrains.kotlin.psi.KtAnnotationEntry;
7+
import org.jetbrains.kotlin.psi.KtParameter;
8+
9+
import java.util.List;
10+
import java.util.Objects;
11+
import java.util.stream.Collectors;
12+
13+
@CanIgnoreReturnValue
14+
abstract class AbstractParameterAssert<SELF extends AbstractParameterAssert<SELF, ANNOTATION_ASSERT>, ANNOTATION_ASSERT> extends AbstractAssert<SELF, KtParameter> {
15+
16+
AbstractParameterAssert(final KtParameter parameter, final Class<?> selfType) {
17+
super(parameter, selfType);
18+
}
19+
20+
abstract ANNOTATION_ASSERT createAnnotationAssert(final KtAnnotationEntry annotation);
21+
22+
public ANNOTATION_ASSERT assertParameterAnnotation(final String annotationName) {
23+
final List<KtAnnotationEntry> annotations = actual.getAnnotationEntries().stream()
24+
.filter(a -> Objects.equals(a.getShortName() != null ? a.getShortName().asString() : null, annotationName))
25+
.collect(Collectors.toList());
26+
Assertions.assertThat(annotations)
27+
.withFailMessage("Expected parameter to have a single annotation %s, but found %s", annotationName, annotations.size())
28+
.hasSize(1);
29+
30+
return createAnnotationAssert(annotations.get(0));
31+
}
32+
33+
public SELF hasType(final String expectedType) {
34+
final String actualType = actual.getTypeReference() != null ? actual.getTypeReference().getText() : null;
35+
Assertions.assertThat(actualType)
36+
.withFailMessage("Expected parameter %s to have type %s, but was %s", actual.getName(), expectedType, actualType)
37+
.isEqualTo(expectedType);
38+
39+
return myself;
40+
}
41+
42+
public SELF hasDefaultValue(final String expectedValue) {
43+
final String actualValue = actual.getDefaultValue() != null ? actual.getDefaultValue().getText() : null;
44+
Assertions.assertThat(actualValue)
45+
.withFailMessage("Expected parameter %s to have default value %s, but was %s", actual.getName(), expectedValue, actualValue)
46+
.isEqualTo(expectedValue);
47+
48+
return myself;
49+
}
50+
}

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

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,11 @@
66
import org.jetbrains.kotlin.psi.KtClass;
77
import org.jetbrains.kotlin.psi.KtNamedFunction;
88
import org.jetbrains.kotlin.psi.KtParameter;
9+
import org.jetbrains.kotlin.psi.KtSecondaryConstructor;
910

1011
import java.util.List;
1112
import java.util.Objects;
13+
import java.util.function.Consumer;
1214
import java.util.stream.Collectors;
1315

1416
@CanIgnoreReturnValue
@@ -45,6 +47,21 @@ public PrimaryConstructorParameterAssert assertPrimaryConstructorParameter(final
4547
return new PrimaryConstructorParameterAssert(this, parameters.get(0));
4648
}
4749

50+
public ClassAssert assertAnySecondaryConstructorSatisfies(final Consumer<KtSecondaryConstructor> requirements) {
51+
Assertions.assertThat(actual.getSecondaryConstructors())
52+
.anySatisfy(requirements);
53+
54+
return this;
55+
}
56+
57+
public CompanionAssert assertCompanion() {
58+
Assertions.assertThat(actual.getCompanionObjects())
59+
.withFailMessage("Expected class to have a single companion object, but found %s", actual.getCompanionObjects().size())
60+
.hasSize(1);
61+
62+
return new CompanionAssert(this, actual.getCompanionObjects().get(0));
63+
}
64+
4865
public KotlinFileAssert toFile() {
4966
return fileAssert;
5067
}

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

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
package org.openapitools.codegen.kotlin.assertions;
2+
3+
import org.assertj.core.api.AbstractAssert;
4+
import org.assertj.core.api.Assertions;
5+
import org.assertj.core.util.CanIgnoreReturnValue;
6+
import org.jetbrains.kotlin.psi.KtNamedFunction;
7+
import org.jetbrains.kotlin.psi.KtObjectDeclaration;
8+
import org.jetbrains.kotlin.psi.KtProperty;
9+
10+
import java.util.List;
11+
import java.util.Objects;
12+
import java.util.stream.Collectors;
13+
14+
@CanIgnoreReturnValue
15+
public class CompanionAssert extends AbstractAssert<CompanionAssert, KtObjectDeclaration> {
16+
private final ClassAssert classAssert;
17+
18+
CompanionAssert(final ClassAssert classAssert, final KtObjectDeclaration companion) {
19+
super(companion, CompanionAssert.class);
20+
this.classAssert = classAssert;
21+
}
22+
23+
public CompanionPropertyAssert assertProperty(final String propertyName) {
24+
Assertions.assertThat(actual.getBody())
25+
.withFailMessage("Expected companion to have a body, but it was null")
26+
.isNotNull();
27+
final List<KtProperty> properties = actual.getBody().getProperties().stream()
28+
.filter(p -> Objects.equals(p.getName(), propertyName))
29+
.collect(Collectors.toList());
30+
Assertions.assertThat(properties)
31+
.withFailMessage("Expected companion object to have a single property %s, but found %s", propertyName, properties.size())
32+
.hasSize(1);
33+
34+
return new CompanionPropertyAssert(this, properties.get(0));
35+
}
36+
37+
public CompanionFunctionAssert assertFunction(final String functionName) {
38+
Assertions.assertThat(actual.getBody())
39+
.withFailMessage("Expected companion to have a body, but it was null")
40+
.isNotNull();
41+
final List<KtNamedFunction> functions = actual.getBody().getFunctions().stream()
42+
.filter(f -> Objects.equals(f.getName(), functionName))
43+
.collect(Collectors.toList());
44+
Assertions.assertThat(functions)
45+
.withFailMessage("Expected companion object to have a single function %s, but found %s", functionName, functions.size())
46+
.hasSize(1);
47+
48+
return new CompanionFunctionAssert(classAssert, functions.get(0));
49+
}
50+
51+
public ClassAssert toClass() {
52+
return classAssert;
53+
}
54+
}

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

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
package org.openapitools.codegen.kotlin.assertions;
2+
3+
import org.assertj.core.util.CanIgnoreReturnValue;
4+
import org.jetbrains.kotlin.psi.KtNamedFunction;
5+
import org.jetbrains.kotlin.psi.KtParameter;
6+
7+
@CanIgnoreReturnValue
8+
public class CompanionFunctionAssert extends AbstractFunctionAssert<CompanionFunctionAssert, CompanionFunctionParameterAssert> {
9+
private final ClassAssert classAssert;
10+
11+
CompanionFunctionAssert(final ClassAssert classAssert, final KtNamedFunction function) {
12+
super(function, CompanionFunctionAssert.class);
13+
this.classAssert = classAssert;
14+
}
15+
16+
CompanionFunctionParameterAssert createParameterAssert(final KtParameter parameter) {
17+
return new CompanionFunctionParameterAssert(this, parameter);
18+
}
19+
20+
public ClassAssert toClass() {
21+
return classAssert;
22+
}
23+
}

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

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
package org.openapitools.codegen.kotlin.assertions;
2+
3+
import org.assertj.core.util.CanIgnoreReturnValue;
4+
import org.jetbrains.kotlin.psi.KtAnnotationEntry;
5+
6+
@CanIgnoreReturnValue
7+
public class CompanionFunctionParameterAnnotationAssert extends AbstractAnnotationAssert<CompanionFunctionParameterAnnotationAssert> {
8+
private final CompanionFunctionParameterAssert parameterAssert;
9+
10+
CompanionFunctionParameterAnnotationAssert(final CompanionFunctionParameterAssert parameterAssert, final KtAnnotationEntry annotationEntry) {
11+
super(annotationEntry, CompanionFunctionParameterAnnotationAssert.class);
12+
this.parameterAssert = parameterAssert;
13+
}
14+
15+
public CompanionFunctionParameterAssert toParameter() {
16+
return parameterAssert;
17+
}
18+
}

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

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
package org.openapitools.codegen.kotlin.assertions;
2+
3+
import org.assertj.core.util.CanIgnoreReturnValue;
4+
import org.jetbrains.kotlin.psi.KtAnnotationEntry;
5+
import org.jetbrains.kotlin.psi.KtParameter;
6+
7+
@CanIgnoreReturnValue
8+
public class CompanionFunctionParameterAssert extends AbstractParameterAssert<CompanionFunctionParameterAssert, CompanionFunctionParameterAnnotationAssert> {
9+
private final CompanionFunctionAssert functionAssert;
10+
11+
CompanionFunctionParameterAssert(final CompanionFunctionAssert functionAssert, final KtParameter parameter) {
12+
super(parameter, CompanionFunctionParameterAssert.class);
13+
this.functionAssert = functionAssert;
14+
}
15+
16+
CompanionFunctionParameterAnnotationAssert createAnnotationAssert(final KtAnnotationEntry annotation) {
17+
return new CompanionFunctionParameterAnnotationAssert(this, annotation);
18+
}
19+
20+
public CompanionFunctionAssert toFunction() {
21+
return functionAssert;
22+
}
23+
}

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

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
package org.openapitools.codegen.kotlin.assertions;
2+
3+
import org.assertj.core.api.AbstractAssert;
4+
import org.assertj.core.api.Assertions;
5+
import org.assertj.core.util.CanIgnoreReturnValue;
6+
import org.jetbrains.kotlin.psi.KtProperty;
7+
8+
@CanIgnoreReturnValue
9+
public class CompanionPropertyAssert extends AbstractAssert<CompanionPropertyAssert, KtProperty> {
10+
private final CompanionAssert companionAssert;
11+
12+
CompanionPropertyAssert(final CompanionAssert companionAssert, final KtProperty property) {
13+
super(property, CompanionPropertyAssert.class);
14+
this.companionAssert = companionAssert;
15+
}
16+
17+
public CompanionPropertyAssert isConst() {
18+
Assertions.assertThat(actual.hasModifier(org.jetbrains.kotlin.lexer.KtTokens.CONST_KEYWORD))
19+
.withFailMessage("Expected property %s to be const, but it was not", actual.getName())
20+
.isTrue();
21+
22+
return this;
23+
}
24+
25+
public CompanionPropertyAssert hasInitializer(final String expectedValue) {
26+
final String actualValue = actual.getInitializer() != null ? actual.getInitializer().getText() : null;
27+
Assertions.assertThat(actualValue)
28+
.withFailMessage("Expected property %s to have value %s, but was %s", actual.getName(), expectedValue, actualValue)
29+
.isEqualTo(expectedValue);
30+
31+
return this;
32+
}
33+
34+
public CompanionAssert toCompanion() {
35+
return companionAssert;
36+
}
37+
}

0 commit comments

Comments
 (0)