diff --git a/initializr-generator-test/src/main/java/io/spring/initializr/generator/test/InitializrMetadataTestBuilder.java b/initializr-generator-test/src/main/java/io/spring/initializr/generator/test/InitializrMetadataTestBuilder.java index 627ec2f0..70fcc547 100644 --- a/initializr-generator-test/src/main/java/io/spring/initializr/generator/test/InitializrMetadataTestBuilder.java +++ b/initializr-generator-test/src/main/java/io/spring/initializr/generator/test/InitializrMetadataTestBuilder.java @@ -26,6 +26,7 @@ import io.spring.initializr.metadata.Dependency; import io.spring.initializr.metadata.DependencyGroup; import io.spring.initializr.metadata.InitializrConfiguration.Env.Kotlin; import io.spring.initializr.metadata.InitializrConfiguration.Env.Maven.ParentPom; +import io.spring.initializr.metadata.InitializrConfiguration.Platform; import io.spring.initializr.metadata.InitializrMetadata; import io.spring.initializr.metadata.InitializrMetadataBuilder; import io.spring.initializr.metadata.Repository; @@ -188,7 +189,16 @@ public class InitializrMetadataTestBuilder { public InitializrMetadataTestBuilder setPlatformCompatibilityRange(String platformCompatibilityRange) { this.builder.withCustomizer( - (it) -> it.getConfiguration().getEnv().setPlatformCompatibilityRange(platformCompatibilityRange)); + (it) -> it.getConfiguration().getEnv().getPlatform().setCompatibilityRange(platformCompatibilityRange)); + return this; + } + + public InitializrMetadataTestBuilder setPlatformVersionFormatCompatibilityRange(String v1Range, String v2Range) { + this.builder.withCustomizer((it) -> { + Platform platform = it.getConfiguration().getEnv().getPlatform(); + platform.setV1FormatCompatibilityRange(v1Range); + platform.setV2FormatCompatibilityRange(v2Range); + }); return this; } diff --git a/initializr-metadata/src/main/java/io/spring/initializr/metadata/InitializrConfiguration.java b/initializr-metadata/src/main/java/io/spring/initializr/metadata/InitializrConfiguration.java index ab70810e..f8260f58 100644 --- a/initializr-metadata/src/main/java/io/spring/initializr/metadata/InitializrConfiguration.java +++ b/initializr-metadata/src/main/java/io/spring/initializr/metadata/InitializrConfiguration.java @@ -30,6 +30,7 @@ import javax.lang.model.SourceVersion; import com.fasterxml.jackson.annotation.JsonIgnore; import io.spring.initializr.generator.version.InvalidVersionException; import io.spring.initializr.generator.version.Version; +import io.spring.initializr.generator.version.Version.Format; import io.spring.initializr.generator.version.VersionParser; import io.spring.initializr.generator.version.VersionRange; @@ -210,16 +211,6 @@ public class InitializrConfiguration { */ private boolean forceSsl; - /** - * Compatibility range of supported platform versions. Requesting metadata or - * project generation with a platform version that does not match this range is - * not supported. - */ - private String platformCompatibilityRange; - - @JsonIgnore - private VersionRange compatibilityRange; - /** * The "BillOfMaterials" that are referenced in this instance, identified by an * arbitrary identifier that can be used in the dependencies definition. @@ -250,6 +241,12 @@ public class InitializrConfiguration { @NestedConfigurationProperty private final Maven maven = new Maven(); + /** + * Platform-specific settings. + */ + @NestedConfigurationProperty + private final Platform platform = new Platform(); + public Env() { try { this.repositories.put("spring-snapshots", @@ -310,14 +307,6 @@ public class InitializrConfiguration { this.forceSsl = forceSsl; } - public String getPlatformCompatibilityRange() { - return this.platformCompatibilityRange; - } - - public void setPlatformCompatibilityRange(String platformCompatibilityRange) { - this.platformCompatibilityRange = platformCompatibilityRange; - } - public String getArtifactRepository() { return this.artifactRepository; } @@ -342,6 +331,10 @@ public class InitializrConfiguration { return this.maven; } + public Platform getPlatform() { + return this.platform; + } + public void setArtifactRepository(String artifactRepository) { if (!artifactRepository.endsWith("/")) { artifactRepository = artifactRepository + "/"; @@ -359,8 +352,7 @@ public class InitializrConfiguration { public void updateCompatibilityRange(VersionParser versionParser) { this.getBoms().values().forEach((it) -> it.updateCompatibilityRange(versionParser)); this.getKotlin().updateCompatibilityRange(versionParser); - this.compatibilityRange = (this.platformCompatibilityRange != null) - ? versionParser.parseRange(this.platformCompatibilityRange) : null; + this.getPlatform().updateCompatibilityRange(versionParser); } public void merge(Env other) { @@ -370,29 +362,14 @@ public class InitializrConfiguration { this.fallbackApplicationName = other.fallbackApplicationName; this.invalidApplicationNames = other.invalidApplicationNames; this.forceSsl = other.forceSsl; - this.platformCompatibilityRange = other.platformCompatibilityRange; - this.compatibilityRange = other.compatibilityRange; this.gradle.merge(other.gradle); this.kotlin.merge(other.kotlin); this.maven.merge(other.maven); + this.platform.merge(other.platform); other.boms.forEach(this.boms::putIfAbsent); other.repositories.forEach(this.repositories::putIfAbsent); } - /** - * Specify whether the specified {@linkplain Version platform version} is - * supported. - * @param platformVersion the platform version to check - * @return {@code true} if this version is supported, {@code false} otherwise - */ - public boolean isCompatiblePlatformVersion(Version platformVersion) { - return (this.compatibilityRange == null || this.compatibilityRange.match(platformVersion)); - } - - public String determinePlatformCompatibilityRangeRequirement() { - return this.compatibilityRange.toString(); - } - /** * Gradle details. */ @@ -662,4 +639,112 @@ public class InitializrConfiguration { } + /** + * Platform-specific settings. + */ + public static class Platform { + + /** + * Compatibility range of supported platform versions. Requesting metadata or + * project generation with a platform version that does not match this range is + * not supported. + */ + private String compatibilityRange; + + @JsonIgnore + private VersionRange range; + + /** + * Compatibility range of platform versions using the first version format. + */ + private String v1FormatCompatibilityRange; + + @JsonIgnore + private VersionRange v1FormatRange; + + /** + * Compatibility range of platform versions using the second version format. + */ + private String v2FormatCompatibilityRange; + + @JsonIgnore + private VersionRange v2FormatRange; + + public void updateCompatibilityRange(VersionParser versionParser) { + this.range = (this.compatibilityRange != null) ? versionParser.parseRange(this.compatibilityRange) : null; + this.v1FormatRange = (this.v1FormatCompatibilityRange != null) + ? versionParser.parseRange(this.v1FormatCompatibilityRange) : null; + this.v2FormatRange = (this.v2FormatCompatibilityRange != null) + ? versionParser.parseRange(this.v2FormatCompatibilityRange) : null; + } + + private void merge(Platform other) { + this.compatibilityRange = other.compatibilityRange; + this.range = other.range; + this.v1FormatCompatibilityRange = other.v1FormatCompatibilityRange; + this.v1FormatRange = other.v1FormatRange; + this.v2FormatCompatibilityRange = other.v2FormatCompatibilityRange; + this.v2FormatRange = other.v2FormatRange; + } + + /** + * Specify whether the specified {@linkplain Version platform version} is + * supported. + * @param platformVersion the platform version to check + * @return {@code true} if this version is supported, {@code false} otherwise + */ + public boolean isCompatibleVersion(Version platformVersion) { + return (this.range == null || this.range.match(platformVersion)); + } + + public String determineCompatibilityRangeRequirement() { + return this.range.toString(); + } + + /** + * Format the expected {@link Version platform version}. + * @param platformVersion a platform version + * @return a platform version in the suitable format + */ + public Version formatPlatformVersion(Version platformVersion) { + Format format = getExpectedVersionFormat(platformVersion); + return platformVersion.format(format); + } + + private Format getExpectedVersionFormat(Version version) { + if (this.v2FormatRange != null && this.v2FormatRange.match(version)) { + return Format.V2; + } + if (this.v1FormatRange != null && this.v1FormatRange.match(version)) { + return Format.V1; + } + return version.getFormat(); + } + + public String getCompatibilityRange() { + return this.compatibilityRange; + } + + public void setCompatibilityRange(String compatibilityRange) { + this.compatibilityRange = compatibilityRange; + } + + public String getV1FormatCompatibilityRange() { + return this.v1FormatCompatibilityRange; + } + + public void setV1FormatCompatibilityRange(String v1FormatCompatibilityRange) { + this.v1FormatCompatibilityRange = v1FormatCompatibilityRange; + } + + public String getV2FormatCompatibilityRange() { + return this.v2FormatCompatibilityRange; + } + + public void setV2FormatCompatibilityRange(String v2FormatCompatibilityRange) { + this.v2FormatCompatibilityRange = v2FormatCompatibilityRange; + } + + } + } diff --git a/initializr-web/src/main/java/io/spring/initializr/web/autoconfigure/InitializrAutoConfiguration.java b/initializr-web/src/main/java/io/spring/initializr/web/autoconfigure/InitializrAutoConfiguration.java index 552fc3bd..5b2c6f92 100644 --- a/initializr-web/src/main/java/io/spring/initializr/web/autoconfigure/InitializrAutoConfiguration.java +++ b/initializr-web/src/main/java/io/spring/initializr/web/autoconfigure/InitializrAutoConfiguration.java @@ -38,9 +38,11 @@ import io.spring.initializr.web.controller.DefaultProjectGenerationController; import io.spring.initializr.web.controller.ProjectGenerationController; import io.spring.initializr.web.controller.ProjectMetadataController; import io.spring.initializr.web.controller.SpringCliDistributionController; +import io.spring.initializr.web.project.DefaultProjectRequestPlatformVersionTransformer; import io.spring.initializr.web.project.DefaultProjectRequestToDescriptionConverter; import io.spring.initializr.web.project.ProjectGenerationInvoker; import io.spring.initializr.web.project.ProjectRequest; +import io.spring.initializr.web.project.ProjectRequestPlatformVersionTransformer; import io.spring.initializr.web.support.DefaultDependencyMetadataProvider; import io.spring.initializr.web.support.DefaultInitializrMetadataProvider; import io.spring.initializr.web.support.DefaultInitializrMetadataUpdateStrategy; @@ -144,9 +146,12 @@ public class InitializrAutoConfiguration { @Bean @ConditionalOnMissingBean ProjectGenerationController projectGenerationController( - InitializrMetadataProvider metadataProvider, ApplicationContext applicationContext) { + InitializrMetadataProvider metadataProvider, + ObjectProvider platformVersionTransformer, + ApplicationContext applicationContext) { ProjectGenerationInvoker projectGenerationInvoker = new ProjectGenerationInvoker<>( - applicationContext, new DefaultProjectRequestToDescriptionConverter()); + applicationContext, new DefaultProjectRequestToDescriptionConverter(platformVersionTransformer + .getIfAvailable(DefaultProjectRequestPlatformVersionTransformer::new))); return new DefaultProjectGenerationController(metadataProvider, projectGenerationInvoker); } diff --git a/initializr-web/src/main/java/io/spring/initializr/web/controller/ProjectMetadataController.java b/initializr-web/src/main/java/io/spring/initializr/web/controller/ProjectMetadataController.java index c5ec6691..692d9fec 100644 --- a/initializr-web/src/main/java/io/spring/initializr/web/controller/ProjectMetadataController.java +++ b/initializr-web/src/main/java/io/spring/initializr/web/controller/ProjectMetadataController.java @@ -24,7 +24,7 @@ import javax.servlet.http.HttpServletResponse; import io.spring.initializr.generator.version.Version; import io.spring.initializr.metadata.DependencyMetadata; import io.spring.initializr.metadata.DependencyMetadataProvider; -import io.spring.initializr.metadata.InitializrConfiguration.Env; +import io.spring.initializr.metadata.InitializrConfiguration.Platform; import io.spring.initializr.metadata.InitializrMetadata; import io.spring.initializr.metadata.InitializrMetadataProvider; import io.spring.initializr.metadata.InvalidInitializrMetadataException; @@ -126,10 +126,10 @@ public class ProjectMetadataController extends AbstractMetadataController { InitializrMetadata metadata = this.metadataProvider.get(); Version v = (bootVersion != null) ? Version.parse(bootVersion) : Version.parse(metadata.getBootVersions().getDefault().getId()); - Env env = metadata.getConfiguration().getEnv(); - if (!env.isCompatiblePlatformVersion(v)) { + Platform platform = metadata.getConfiguration().getEnv().getPlatform(); + if (!platform.isCompatibleVersion(v)) { throw new InvalidProjectRequestException("Invalid Spring Boot version '" + bootVersion - + "', Spring Boot compatibility range is " + env.determinePlatformCompatibilityRangeRequirement()); + + "', Spring Boot compatibility range is " + platform.determineCompatibilityRangeRequirement()); } DependencyMetadata dependencyMetadata = this.dependencyMetadataProvider.get(metadata, v); String content = new DependencyMetadataV21JsonMapper().write(dependencyMetadata); diff --git a/initializr-web/src/main/java/io/spring/initializr/web/project/DefaultProjectRequestPlatformVersionTransformer.java b/initializr-web/src/main/java/io/spring/initializr/web/project/DefaultProjectRequestPlatformVersionTransformer.java new file mode 100644 index 00000000..cc9299e6 --- /dev/null +++ b/initializr-web/src/main/java/io/spring/initializr/web/project/DefaultProjectRequestPlatformVersionTransformer.java @@ -0,0 +1,35 @@ +/* + * Copyright 2012-2020 the original author or authors. + * + * Licensed 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 + * + * https://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.spring.initializr.web.project; + +import io.spring.initializr.generator.version.Version; +import io.spring.initializr.metadata.InitializrMetadata; + +/** + * A default {@link DefaultProjectRequestPlatformVersionTransformer} that uses configured + * ranges to format the version if necessary. + * + * @author Stephane Nicoll + */ +public class DefaultProjectRequestPlatformVersionTransformer implements ProjectRequestPlatformVersionTransformer { + + @Override + public Version transform(Version platformVersion, InitializrMetadata metadata) { + return metadata.getConfiguration().getEnv().getPlatform().formatPlatformVersion(platformVersion); + } + +} diff --git a/initializr-web/src/main/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverter.java b/initializr-web/src/main/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverter.java index d5b93870..a066b504 100644 --- a/initializr-web/src/main/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverter.java +++ b/initializr-web/src/main/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverter.java @@ -27,22 +27,38 @@ import io.spring.initializr.generator.project.ProjectDescription; import io.spring.initializr.generator.version.Version; import io.spring.initializr.metadata.DefaultMetadataElement; import io.spring.initializr.metadata.Dependency; -import io.spring.initializr.metadata.InitializrConfiguration.Env; +import io.spring.initializr.metadata.InitializrConfiguration.Platform; import io.spring.initializr.metadata.InitializrMetadata; import io.spring.initializr.metadata.Type; import io.spring.initializr.metadata.support.MetadataBuildItemMapper; +import org.springframework.util.Assert; + /** * A default {@link ProjectRequestToDescriptionConverter} implementation that uses the * {@link InitializrMetadata metadata} to set default values for missing attributes if - * necessary. + * necessary. Transparently transform the platform version if necessary using a + * {@link ProjectRequestPlatformVersionTransformer}. * * @author Madhura Bhave * @author HaiTao Zhang + * @author Stephane Nicoll */ public class DefaultProjectRequestToDescriptionConverter implements ProjectRequestToDescriptionConverter { + private final ProjectRequestPlatformVersionTransformer platformVersionTransformer; + + public DefaultProjectRequestToDescriptionConverter() { + this((version, metadata) -> version); + } + + public DefaultProjectRequestToDescriptionConverter( + ProjectRequestPlatformVersionTransformer platformVersionTransformer) { + Assert.notNull(platformVersionTransformer, "PlatformVersionTransformer must not be null"); + this.platformVersionTransformer = platformVersionTransformer; + } + @Override public ProjectDescription convert(ProjectRequest request, InitializrMetadata metadata) { MutableProjectDescription description = new MutableProjectDescription(); @@ -60,9 +76,9 @@ public class DefaultProjectRequestToDescriptionConverter */ public void convert(ProjectRequest request, MutableProjectDescription description, InitializrMetadata metadata) { validate(request, metadata); - String springBootVersion = getSpringBootVersion(request, metadata); - List resolvedDependencies = getResolvedDependencies(request, springBootVersion, metadata); - validateDependencyRange(springBootVersion, resolvedDependencies); + Version platformVersion = getPlatformVersion(request, metadata); + List resolvedDependencies = getResolvedDependencies(request, platformVersion, metadata); + validateDependencyRange(platformVersion, resolvedDependencies); description.setApplicationName(request.getApplicationName()); description.setArtifactId(request.getArtifactId()); @@ -74,26 +90,26 @@ public class DefaultProjectRequestToDescriptionConverter description.setName(request.getName()); description.setPackageName(request.getPackageName()); description.setPackaging(Packaging.forId(request.getPackaging())); - description.setPlatformVersion(Version.parse(springBootVersion)); + description.setPlatformVersion(platformVersion); description.setVersion(request.getVersion()); resolvedDependencies.forEach((dependency) -> description.addDependency(dependency.getId(), MetadataBuildItemMapper.toDependency(dependency))); } private void validate(ProjectRequest request, InitializrMetadata metadata) { - validateSpringBootVersion(request, metadata); + validatePlatformVersion(request, metadata); validateType(request.getType(), metadata); validateLanguage(request.getLanguage(), metadata); validatePackaging(request.getPackaging(), metadata); validateDependencies(request, metadata); } - private void validateSpringBootVersion(ProjectRequest request, InitializrMetadata metadata) { - Version bootVersion = Version.safeParse(request.getBootVersion()); - Env env = metadata.getConfiguration().getEnv(); - if (bootVersion != null && !env.isCompatiblePlatformVersion(bootVersion)) { - throw new InvalidProjectRequestException("Invalid Spring Boot version '" + bootVersion - + "', Spring Boot compatibility range is " + env.determinePlatformCompatibilityRangeRequirement()); + private void validatePlatformVersion(ProjectRequest request, InitializrMetadata metadata) { + Version platformVersion = Version.safeParse(request.getBootVersion()); + Platform platform = metadata.getConfiguration().getEnv().getPlatform(); + if (platformVersion != null && !platform.isCompatibleVersion(platformVersion)) { + throw new InvalidProjectRequestException("Invalid Spring Boot version '" + platformVersion + + "', Spring Boot compatibility range is " + platform.determineCompatibilityRangeRequirement()); } } @@ -139,11 +155,11 @@ public class DefaultProjectRequestToDescriptionConverter }); } - private void validateDependencyRange(String springBootVersion, List resolvedDependencies) { + private void validateDependencyRange(Version platformVersion, List resolvedDependencies) { resolvedDependencies.forEach((dep) -> { - if (!dep.match(Version.parse(springBootVersion))) { - throw new InvalidProjectRequestException("Dependency '" + dep.getId() + "' is not compatible " - + "with Spring Boot " + springBootVersion); + if (!dep.match(platformVersion)) { + throw new InvalidProjectRequestException( + "Dependency '" + dep.getId() + "' is not compatible " + "with Spring Boot " + platformVersion); } }); } @@ -153,18 +169,19 @@ public class DefaultProjectRequestToDescriptionConverter return BuildSystem.forId(typeFromMetadata.getTags().get("build")); } - private String getSpringBootVersion(ProjectRequest request, InitializrMetadata metadata) { - return (request.getBootVersion() != null) ? request.getBootVersion() + private Version getPlatformVersion(ProjectRequest request, InitializrMetadata metadata) { + String versionText = (request.getBootVersion() != null) ? request.getBootVersion() : metadata.getBootVersions().getDefault().getId(); + Version version = Version.parse(versionText); + return this.platformVersionTransformer.transform(version, metadata); } - private List getResolvedDependencies(ProjectRequest request, String springBootVersion, + private List getResolvedDependencies(ProjectRequest request, Version platformVersion, InitializrMetadata metadata) { List depIds = request.getDependencies(); - Version requestedVersion = Version.parse(springBootVersion); return depIds.stream().map((it) -> { Dependency dependency = metadata.getDependencies().get(it); - return dependency.resolve(requestedVersion); + return dependency.resolve(platformVersion); }).collect(Collectors.toList()); } diff --git a/initializr-web/src/main/java/io/spring/initializr/web/project/ProjectRequestPlatformVersionTransformer.java b/initializr-web/src/main/java/io/spring/initializr/web/project/ProjectRequestPlatformVersionTransformer.java new file mode 100644 index 00000000..45538bf0 --- /dev/null +++ b/initializr-web/src/main/java/io/spring/initializr/web/project/ProjectRequestPlatformVersionTransformer.java @@ -0,0 +1,38 @@ +/* + * Copyright 2012-2020 the original author or authors. + * + * Licensed 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 + * + * https://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.spring.initializr.web.project; + +import io.spring.initializr.generator.version.Version; +import io.spring.initializr.metadata.InitializrMetadata; + +/** + * Strategy interface to transform the platform version of a {@link ProjectRequest}. + * + * @author Stephane Nicoll + */ +@FunctionalInterface +public interface ProjectRequestPlatformVersionTransformer { + + /** + * Transform the platform version of a {@link ProjectRequest} if necessary. + * @param platformVersion the candidate platform version + * @param metadata the metadata instance to use + * @return the platform version to use + */ + Version transform(Version platformVersion, InitializrMetadata metadata); + +} diff --git a/initializr-web/src/test/java/io/spring/initializr/web/controller/ProjectGenerationControllerCustomEnvIntegrationTests.java b/initializr-web/src/test/java/io/spring/initializr/web/controller/ProjectGenerationControllerCustomEnvIntegrationTests.java index b0c07e7a..e6be8d59 100755 --- a/initializr-web/src/test/java/io/spring/initializr/web/controller/ProjectGenerationControllerCustomEnvIntegrationTests.java +++ b/initializr-web/src/test/java/io/spring/initializr/web/controller/ProjectGenerationControllerCustomEnvIntegrationTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2019 the original author or authors. + * Copyright 2012-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/initializr-web/src/test/java/io/spring/initializr/web/controller/ProjectGenerationControllerCustomVersionTransformerIntegrationTests.java b/initializr-web/src/test/java/io/spring/initializr/web/controller/ProjectGenerationControllerCustomVersionTransformerIntegrationTests.java new file mode 100644 index 00000000..92294949 --- /dev/null +++ b/initializr-web/src/test/java/io/spring/initializr/web/controller/ProjectGenerationControllerCustomVersionTransformerIntegrationTests.java @@ -0,0 +1,45 @@ +/* + * Copyright 2012-2020 the original author or authors. + * + * Licensed 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 + * + * https://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.spring.initializr.web.controller; + +import io.spring.initializr.generator.test.project.ProjectStructure; +import io.spring.initializr.web.AbstractInitializrControllerIntegrationTests; +import org.junit.jupiter.api.Test; + +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.TestPropertySource; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Integration tests for {@link ProjectGenerationController} with a custom platform + * version compatibility range. + * + * @author Stephane Nicoll + */ +@ActiveProfiles("test-default") +@TestPropertySource(properties = "initializr.env.platform.v2-format-compatibility-range=2.4.0-M1") +class ProjectGenerationControllerCustomVersionTransformerIntegrationTests + extends AbstractInitializrControllerIntegrationTests { + + @Test + void projectGenerationInvokeProjectRequestVersionTransformer() { + ProjectStructure project = downloadZip("/starter.zip?bootVersion=2.4.0.RELEASE"); + assertThat(project).mavenBuild().hasParent("org.springframework.boot", "spring-boot-starter-parent", "2.4.0"); + } + +} diff --git a/initializr-web/src/test/java/io/spring/initializr/web/project/DefaultProjectRequestPlatformVersionTransformerTests.java b/initializr-web/src/test/java/io/spring/initializr/web/project/DefaultProjectRequestPlatformVersionTransformerTests.java new file mode 100644 index 00000000..886f52f8 --- /dev/null +++ b/initializr-web/src/test/java/io/spring/initializr/web/project/DefaultProjectRequestPlatformVersionTransformerTests.java @@ -0,0 +1,80 @@ +/* + * Copyright 2012-2020 the original author or authors. + * + * Licensed 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 + * + * https://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.spring.initializr.web.project; + +import io.spring.initializr.generator.test.InitializrMetadataTestBuilder; +import io.spring.initializr.generator.version.Version; +import io.spring.initializr.metadata.InitializrMetadata; +import org.junit.jupiter.api.Test; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * Tests for {@link DefaultProjectRequestPlatformVersionTransformer}. + * + * @author Stephane Nicoll + */ +class DefaultProjectRequestPlatformVersionTransformerTests { + + private final DefaultProjectRequestPlatformVersionTransformer transformer = new DefaultProjectRequestPlatformVersionTransformer(); + + @Test + void formatV1WhenV2IsExpected() { + InitializrMetadata metadata = InitializrMetadataTestBuilder.withDefaults() + .setPlatformVersionFormatCompatibilityRange("[2.0.0.RELEASE,2.4.0-M1)", "2.4.0-M1").build(); + assertThat(this.transformer.transform(Version.parse("2.4.0.RELEASE"), metadata)).hasToString("2.4.0"); + } + + @Test + void formatV1WhenV1IsExpected() { + InitializrMetadata metadata = InitializrMetadataTestBuilder.withDefaults() + .setPlatformVersionFormatCompatibilityRange("[2.0.0.RELEASE,2.4.0-M1)", "2.4.0-M1").build(); + Version version = Version.parse("2.2.0.RELEASE"); + assertThat(this.transformer.transform(version, metadata)).isSameAs(version); + } + + @Test + void formatV2WhenV1IsExpected() { + InitializrMetadata metadata = InitializrMetadataTestBuilder.withDefaults() + .setPlatformVersionFormatCompatibilityRange("[2.0.0.RELEASE,2.4.0-M1)", "2.4.0-M1").build(); + assertThat(this.transformer.transform(Version.parse("2.3.0-SNAPSHOT"), metadata)) + .hasToString("2.3.0.BUILD-SNAPSHOT"); + } + + @Test + void formatV2WhenV2IsExpected() { + InitializrMetadata metadata = InitializrMetadataTestBuilder.withDefaults() + .setPlatformVersionFormatCompatibilityRange("[2.0.0.RELEASE,2.4.0-M1)", "2.4.0-M1").build(); + Version version = Version.parse("2.4.0"); + assertThat(this.transformer.transform(version, metadata)).isSameAs(version); + } + + @Test + void formatV1WhenNoRangeIsConfigured() { + InitializrMetadata metadata = InitializrMetadataTestBuilder.withDefaults().build(); + Version version = Version.parse("2.4.0.RELEASE"); + assertThat(this.transformer.transform(version, metadata)).isSameAs(version); + } + + @Test + void formatV2WhenNoRangeIsConfigured() { + InitializrMetadata metadata = InitializrMetadataTestBuilder.withDefaults().build(); + Version version = Version.parse("2.2.0-SNAPSHOT"); + assertThat(this.transformer.transform(version, metadata)).isSameAs(version); + } + +} diff --git a/initializr-web/src/test/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverterTests.java b/initializr-web/src/test/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverterTests.java index bd2b1902..f6d42b5f 100644 --- a/initializr-web/src/test/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverterTests.java +++ b/initializr-web/src/test/java/io/spring/initializr/web/project/DefaultProjectRequestToDescriptionConverterTests.java @@ -1,5 +1,5 @@ /* - * Copyright 2012-2019 the original author or authors. + * Copyright 2012-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -30,6 +30,9 @@ import org.junit.jupiter.api.Test; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatExceptionOfType; +import static org.mockito.BDDMockito.given; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; /** * Tests for {@link DefaultProjectRequestToDescriptionConverter}. @@ -74,6 +77,19 @@ class DefaultProjectRequestToDescriptionConverterTests { .isEqualTo(Version.parse("1.5.9.RELEASE")); } + @Test + void convertShouldCallProjectRequestVersionTransformer() { + ProjectRequestPlatformVersionTransformer transformer = mock(ProjectRequestPlatformVersionTransformer.class); + Version v1Format = Version.parse("2.4.0.RELEASE"); + given(transformer.transform(v1Format, this.metadata)).willReturn(Version.parse("2.4.0")); + ProjectRequest request = createProjectRequest(); + request.setBootVersion("2.4.0.RELEASE"); + ProjectDescription description = new DefaultProjectRequestToDescriptionConverter(transformer).convert(request, + this.metadata); + assertThat(description.getPlatformVersion()).hasToString("2.4.0"); + verify(transformer).transform(v1Format, this.metadata); + } + @Test void convertWhenSpringBootVersionInvalidShouldThrowException() { this.metadata = InitializrMetadataTestBuilder.withDefaults() diff --git a/initializr-web/src/test/resources/application-test-custom-env.yml b/initializr-web/src/test/resources/application-test-custom-env.yml index 8676d91f..de11a9cb 100644 --- a/initializr-web/src/test/resources/application-test-custom-env.yml +++ b/initializr-web/src/test/resources/application-test-custom-env.yml @@ -5,6 +5,7 @@ initializr: fallbackApplicationName: FooBarApplication invalidApplicationNames: - InvalidApplication - platform-compatibility-range: "2.0.0.RELEASE" kotlin: - default-version: 1.0.0-beta-2423 \ No newline at end of file + default-version: 1.0.0-beta-2423 + platform: + compatibility-range: "2.0.0.RELEASE" diff --git a/initializr-web/src/test/resources/metadata/config/test-default.json b/initializr-web/src/test/resources/metadata/config/test-default.json index f81d0648..da57c7a6 100644 --- a/initializr-web/src/test/resources/metadata/config/test-default.json +++ b/initializr-web/src/test/resources/metadata/config/test-default.json @@ -33,7 +33,6 @@ "artifactRepository": "https://repo.spring.io/release/", "fallbackApplicationName": "Application", "forceSsl": false, - "platformCompatibilityRange": null, "gradle": { "dependencyManagementPluginVersion": "1.0.0.RELEASE" }, @@ -58,6 +57,11 @@ "includeSpringBootBom": false } }, + "platform": { + "compatibilityRange": null, + "v1FormatCompatibilityRange": null, + "v2FormatCompatibilityRange": null + }, "googleAnalyticsTrackingCode": null, "invalidApplicationNames": [ "SpringApplication",