From 3c2b870568b2b4a4094c43210f0f23d6016c23f9 Mon Sep 17 00:00:00 2001 From: Marcin Grzejszczak Date: Tue, 27 Aug 2019 17:37:21 +0200 Subject: [PATCH] Refactord buildsystem --- .../buildsystem/BomConstants.java} | 8 +- .../buildsystem/SpringCloudBomParser.java | 141 +++++++++ .../release/internal/ReleaserProperties.java | 12 +- .../internal/buildsystem/BomParser.java | 92 +----- .../internal/buildsystem/CustomBomParser.java | 103 ++++++ .../internal/buildsystem/PomReader.java | 23 +- .../internal/buildsystem/PomUpdater.java | 73 +++-- .../release/internal/buildsystem/Project.java | 65 ++++ .../buildsystem/ProjectPomUpdater.java | 34 +- .../internal/buildsystem/ProjectVersion.java | 3 +- .../internal/buildsystem/Versions.java | 297 ------------------ .../internal/buildsystem/VersionsFromBom.java | 178 +++++++++++ .../release/internal/project/Projects.java | 6 + .../main/resources/META-INF/spring.factories | 2 + .../internal/PomUpdateAcceptanceTests.java | 13 +- .../internal/buildsystem/BomParserTests.java | 27 +- .../internal/buildsystem/PomReaderTests.java | 14 +- .../internal/buildsystem/PomUpdaterTests.java | 120 +++---- .../PropertyVersionChangerTests.java | 6 +- .../internal/buildsystem/TestPomReader.java | 34 -- .../buildsystem/VersionsFromBomTests.java | 290 +++++++++++++++++ .../internal/buildsystem/VersionsTests.java | 265 ---------------- .../postrelease/PostReleaseActionsTests.java | 14 +- ....java => VersionsFromBomFetcherTests.java} | 17 +- .../internal/buildsystem/TestPomReader.java | 4 +- 25 files changed, 993 insertions(+), 848 deletions(-) rename spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/{internal/buildsystem/SpringCloudConstants.java => cloud/buildsystem/BomConstants.java} (86%) create mode 100644 spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomParser.java create mode 100644 spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CustomBomParser.java create mode 100644 spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Project.java delete mode 100644 spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Versions.java create mode 100644 spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBom.java create mode 100644 spring-cloud-release-tools-core/src/main/resources/META-INF/spring.factories delete mode 100644 spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java create mode 100644 spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomTests.java delete mode 100644 spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsTests.java rename spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/{VersionsFetcherTests.java => VersionsFromBomFetcherTests.java} (92%) diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/SpringCloudConstants.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/BomConstants.java similarity index 86% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/SpringCloudConstants.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/BomConstants.java index 6b2f1c3a..442c8181 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/SpringCloudConstants.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/BomConstants.java @@ -5,7 +5,7 @@ * 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 + * http://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, @@ -14,12 +14,12 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.buildsystem; +package org.springframework.cloud.release.cloud.buildsystem; /** * @author Marcin Grzejszczak */ -final class SpringCloudConstants { +final class BomConstants { static final String SPRING_BOOT = "spring-boot"; static final String BOOT_STARTER_ARTIFACT_ID = "spring-boot-starter"; @@ -29,7 +29,7 @@ final class SpringCloudConstants { static final String CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID = "spring-cloud-dependencies-parent"; static final String BUILD_ARTIFACT_ID = "spring-cloud-build"; - private SpringCloudConstants() { + private BomConstants() { throw new IllegalStateException("Don't instantiate a utility class"); } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomParser.java new file mode 100644 index 00000000..19fa47e5 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomParser.java @@ -0,0 +1,141 @@ +/* + * Copyright 2013-2019 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 + * + * http://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 org.springframework.cloud.release.cloud.buildsystem; + +import java.io.File; +import java.util.LinkedHashSet; +import java.util.Set; + +import org.apache.maven.model.Model; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.buildsystem.CustomBomParser; +import org.springframework.cloud.release.internal.buildsystem.PomReader; +import org.springframework.cloud.release.internal.buildsystem.Project; +import org.springframework.cloud.release.internal.buildsystem.VersionsFromBom; + +import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.BOOT_DEPENDENCIES_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.BUILD_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.SPRING_BOOT; + +public class SpringCloudBomParser implements CustomBomParser { + + private static final Logger log = LoggerFactory.getLogger(SpringCloudBomParser.class); + + @Override + public boolean isApplicable(File root, ReleaserProperties properties, + Set projects) { + return root.getName().startsWith("spring-cloud") || projects.stream() + .anyMatch(project -> BUILD_ARTIFACT_ID.equals(project.name)); + } + + @Override + public VersionsFromBom parseBom(File root, ReleaserProperties properties) { + VersionsFromBom springCloudBuild = springCloudBuild(root, properties); + VersionsFromBom boot = bootVersion(root, properties); + return new VersionsFromBom(properties, springCloudBuild, boot); + } + + private VersionsFromBom springCloudBuild(File root, ReleaserProperties properties) { + Model model = PomReader.pom(root, properties.getPom().getThisTrainBom()); + String buildArtifact = model.getParent().getArtifactId(); + log.debug("[{}] artifact id is equal to [{}]", + CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildArtifact); + if (!CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID.equals(buildArtifact)) { + throw new IllegalStateException( + "The pom doesn't have a [spring-cloud-dependencies-parent] artifact id"); + } + String buildVersion = model.getParent().getVersion(); + log.debug("Spring Cloud Build version is equal to [{}]", buildVersion); + VersionsFromBom scBuild = new VersionsFromBom(properties); + scBuild.add(BUILD_ARTIFACT_ID, buildVersion); + scBuild.add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildVersion); + return scBuild; + } + + VersionsFromBom bootVersion(File root, ReleaserProperties properties) { + String pomWithBootStarterParent = properties.getPom() + .getPomWithBootStarterParent(); + Model model = PomReader.pom(root, pomWithBootStarterParent); + if (model == null) { + return VersionsFromBom.EMPTY_VERSION; + } + String bootArtifactId = model.getParent().getArtifactId(); + log.debug("Boot artifact id is equal to [{}]", bootArtifactId); + if (!BomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID.equals(bootArtifactId)) { + if (log.isDebugEnabled()) { + throw new IllegalStateException("The pom doesn't have a [" + + BomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID + "] artifact id"); + } + return VersionsFromBom.EMPTY_VERSION; + } + String bootVersion = model.getParent().getVersion(); + log.debug("Boot version is equal to [{}]", bootVersion); + VersionsFromBom versionsFromBom = new VersionsFromBom(properties); + versionsFromBom.add(SPRING_BOOT, bootVersion); + versionsFromBom.add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion); + versionsFromBom.add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion); + return versionsFromBom; + } + + @Override + public Set setVersion(Set projects, String projectName, + String version) { + Set newProjects = new LinkedHashSet<>(projects); + switch (projectName) { + case SPRING_BOOT: + case BOOT_STARTER_PARENT_ARTIFACT_ID: + case BOOT_DEPENDENCIES_ARTIFACT_ID: + updateBootVersions(newProjects, version); + break; + case BUILD_ARTIFACT_ID: + case CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID: + updateBuildVersions(newProjects, version); + break; + } + return newProjects; + } + + private void updateBootVersions(Set newProjects, String version) { + remove(newProjects, SPRING_BOOT); + remove(newProjects, BOOT_DEPENDENCIES_ARTIFACT_ID); + remove(newProjects, BOOT_STARTER_PARENT_ARTIFACT_ID); + add(newProjects, SPRING_BOOT, version); + add(newProjects, BOOT_STARTER_PARENT_ARTIFACT_ID, version); + add(newProjects, BOOT_DEPENDENCIES_ARTIFACT_ID, version); + } + + private void updateBuildVersions(Set newProjects, String version) { + remove(newProjects, BUILD_ARTIFACT_ID); + remove(newProjects, CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID); + add(newProjects, BUILD_ARTIFACT_ID, version); + add(newProjects, CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, version); + } + + private void add(Set projects, String key, String value) { + projects.add(new Project(key, value)); + } + + private void remove(Set projects, String expectedProjectName) { + projects.removeIf(project -> expectedProjectName.equals(project.name)); + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/ReleaserProperties.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/ReleaserProperties.java index c075907b..bf0909ad 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/ReleaserProperties.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/ReleaserProperties.java @@ -67,8 +67,8 @@ public class ReleaserProperties implements Serializable { private Versions versions = new Versions(); /** - * Project name to its version - overrides all versions retrieved from a repository - * like Spring Cloud Release. + * Project name to its version - overrides all versions retrieved from a release train + * repository like Spring Cloud Release. */ private Map fixedVersions = new LinkedHashMap<>(); @@ -273,7 +273,7 @@ public class ReleaserProperties implements Serializable { public static class Git implements Serializable { /** - * URL to Spring Cloud Release Git repository. + * URL to a release train repository. */ private String releaseTrainBomUrl = "https://github.com/spring-cloud/spring-cloud-release"; @@ -283,7 +283,7 @@ public class ReleaserProperties implements Serializable { private String documentationUrl = "https://github.com/spring-cloud/spring-cloud-static"; /** - * URL to main release train project repository. + * URL to the release train project page repository. */ private String springProjectUrl = "https://github.com/spring-projects/spring-cloud"; @@ -329,8 +329,8 @@ public class ReleaserProperties implements Serializable { private String releaseTrainWikiPagePrefix = "Spring-Cloud"; /** - * Where should the Spring Cloud Release repo get cloned to. If {@code null} - * defaults to a temporary directory. + * Where should the release train repo get cloned to. If {@code null} defaults to + * a temporary directory. */ private String cloneDestinationDir; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/BomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/BomParser.java index e239240d..4290cac5 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/BomParser.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/BomParser.java @@ -17,7 +17,6 @@ package org.springframework.cloud.release.internal.buildsystem; import java.io.File; -import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.function.Function; @@ -32,11 +31,6 @@ import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_DEPENDENCIES_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.SPRING_BOOT; - /** * Parses the poms for a given project and populates versions from a release train. * @@ -48,11 +42,7 @@ class BomParser { private final File thisProjectRoot; - private final String pomWithBootStarterParent; - - private final String thisTrainBom; - - private final PomReader pomReader = new PomReader(); + private final String thisTrainBomLocation; private final Pattern versionPattern; @@ -60,88 +50,36 @@ class BomParser { BomParser(ReleaserProperties properties, File thisProjectRoot) { this.thisProjectRoot = thisProjectRoot; - this.pomWithBootStarterParent = properties.getPom().getPomWithBootStarterParent(); - this.thisTrainBom = properties.getPom().getThisTrainBom(); + this.thisTrainBomLocation = properties.getPom().getThisTrainBom(); this.versionPattern = Pattern.compile(properties.getPom().getBomVersionPattern()); this.properties = properties; } - Versions allVersions() { - Versions boot = bootVersion(); - Versions cloud = versionsFromBom(); - return new Versions(this.properties, allProjects(boot, cloud)); - } - - private Set allProjects(Versions boot, Versions cloud) { - Set allProjects = new HashSet<>(); - allProjects.addAll(boot.projects); - allProjects.addAll(cloud.projects); - return allProjects; - } - - // TODO: [SPRING CLOUD] - Versions bootVersion() { - Model model = pom(this.pomWithBootStarterParent); - if (model == null) { - return Versions.EMPTY_VERSION; - } - String bootArtifactId = model.getParent().getArtifactId(); - log.debug("Boot artifact id is equal to [{}]", bootArtifactId); - if (!SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID - .equals(bootArtifactId)) { - throw new IllegalStateException("The pom doesn't have a [" - + SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID - + "] artifact id"); - } - String bootVersion = model.getParent().getVersion(); - log.debug("Boot version is equal to [{}]", bootVersion); - Versions versions = new Versions(this.properties); - versions.add(SPRING_BOOT, bootVersion); - versions.add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion); - versions.add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion); - return versions; - } - - private Model pom(String pom) { - if (pom == null) { - throw new IllegalStateException("Pom is not present"); - } - File pomFile = new File(this.thisProjectRoot, pom); - if (!pomFile.exists()) { - throw new IllegalStateException("Pom is not present"); - } - return this.pomReader.readPom(pomFile); - } - // the BOM contains all versions of projects and its parent MUST be Spring Cloud // Dependencies Parent - Versions versionsFromBom() { - Model model = pom(this.thisTrainBom); + VersionsFromBom versionsFromBom() { + Model model = PomReader.pom(thisProjectRoot, this.thisTrainBomLocation); if (model == null) { - return Versions.EMPTY_VERSION; + return VersionsFromBom.EMPTY_VERSION; } - // TODO: [SPRING CLOUD] - String buildArtifact = model.getParent().getArtifactId(); - log.debug("[{}] artifact id is equal to [{}]", - CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildArtifact); - if (!CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID.equals(buildArtifact)) { - throw new IllegalStateException("The pom doesn't have a [" - + CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID + "] artifact id"); - } - String buildVersion = model.getParent().getVersion(); - log.debug("Spring Cloud Build version is equal to [{}]", buildVersion); Set projects = model.getProperties().entrySet().stream() - .filter(propertyMatchesSCPattern()).map(toProject()) + .filter(propertyMatchesVersionPattern()).map(toProject()) .collect(Collectors.toSet()); String releaseTrainProjectVersion = model.getVersion(); projects.add( new Project(this.properties.getMetaRelease().getReleaseTrainProjectName(), releaseTrainProjectVersion)); - projects.add(new Project("spring-cloud-build", buildVersion)); - return new Versions(this.properties, projects); + VersionsFromBom bomVersions = new VersionsFromBom(this.properties, projects); + return new VersionsFromBom(properties, bomVersions, customVersions(projects)); } - private Predicate> propertyMatchesSCPattern() { + private VersionsFromBom customVersions(Set projects) { + CustomBomParser parser = CustomBomParser.parser(this.thisProjectRoot, + this.properties, projects); + return parser.parseBom(this.thisProjectRoot, this.properties); + } + + private Predicate> propertyMatchesVersionPattern() { return entry -> this.versionPattern.matcher(entry.getKey().toString()).matches(); } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CustomBomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CustomBomParser.java new file mode 100644 index 00000000..fb9a78e7 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CustomBomParser.java @@ -0,0 +1,103 @@ +/* + * Copyright 2013-2019 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 + * + * http://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 org.springframework.cloud.release.internal.buildsystem; + +import java.io.File; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; + +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.core.io.support.SpringFactoriesLoader; + +/** + * Allows to pass in some additional BOM model to Versions mapping. + */ +public interface CustomBomParser { + + /** + * Different projects can have different parsers. This method will tell whether the + * current parser should be applied or not. + * @param thisProjectRoot - location of the cloned project + * @param properties - releaser properties + * @param projects - parsed projects from the BOM + * @return {@code true} if the parser should be applied. + */ + boolean isApplicable(File thisProjectRoot, ReleaserProperties properties, + Set projects); + + /** + * When parsing a part of the BOM pom, one can add custom logic to perform project + * specific parsing. + * @param thisProjectRoot - location of the cloned project + * @param properties - releaser properties + * @return - versions retrieved from the BOM. Can be + * {@link VersionsFromBom#EMPTY_VERSION} if nothing was found. + */ + VersionsFromBom parseBom(File thisProjectRoot, ReleaserProperties properties); + + /** + * Allows to hook in custom logic for versions setting. + * @param projects - set of projects + * @param projectName - name of the project + * @param version - version of the project + * @return - a new collection with the modified versions from bom + */ + default Set setVersion(Set projects, String projectName, + String version) { + return new LinkedHashSet<>(projects); + } + + List PARSERS = SpringFactoriesLoader + .loadFactories(CustomBomParser.class, null); + + CustomBomParser NO_OP = new CustomBomParser() { + @Override + public boolean isApplicable(File thisProjectRoot, ReleaserProperties properties, + Set projects) { + return true; + } + + @Override + public VersionsFromBom parseBom(File thisProjectRoot, + ReleaserProperties properties) { + return VersionsFromBom.EMPTY_VERSION; + } + + }; + + static CustomBomParser parser(File thisProjectRoot, ReleaserProperties properties, + Set projects) { + for (CustomBomParser parser : PARSERS) { + if (parser.isApplicable(thisProjectRoot, properties, projects)) { + return parser; + } + } + return NO_OP; + } + + static CustomBomParser parser(ReleaserProperties properties) { + return parser(new File(properties.getWorkingDir()), properties, + Collections.emptySet()); + } + + static CustomBomParser parser(ReleaserProperties properties, Set projects) { + return parser(new File(properties.getWorkingDir()), properties, projects); + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomReader.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomReader.java index 2c6e595e..69da44ee 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomReader.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomReader.java @@ -27,14 +27,22 @@ import org.apache.maven.model.io.xpp3.MavenXpp3Reader; import org.codehaus.plexus.util.xml.pull.XmlPullParserException; /** + * Class that reads poms as {@link Model}. + * * @author Marcin Grzejszczak */ -class PomReader { +public final class PomReader { + + private PomReader() { + throw new IllegalStateException("Shouldn't instantiate a utility class"); + } /** * Returns a parsed POM. + * @param file location to the pom + * @return parsed model */ - Model readPom(File file) { + public static Model readPom(File file) { File pom = file; if (file.isDirectory()) { pom = new File(file, "pom.xml"); @@ -60,4 +68,15 @@ class PomReader { } } + public static Model pom(File projectRoot, String pom) { + if (pom == null) { + throw new IllegalStateException("Pom is not present"); + } + File pomFile = new File(projectRoot, pom); + if (!pomFile.exists()) { + throw new IllegalStateException("Pom is not present"); + } + return PomReader.readPom(pomFile); + } + } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java index 844afd30..8d56f07f 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java @@ -52,29 +52,27 @@ class PomUpdater { private static final Logger log = LoggerFactory.getLogger(PomUpdater.class); - private final PomReader pomReader = new PomReader(); - private final PomWriter pomWriter = new PomWriter(); /** * Basing on the contents of the root pom and the versions will decide whether the * project should be updated or not. * @param rootFolder - root folder of the project - * @param versions - list of dependencies to be updated + * @param versionsFromBom - list of dependencies to be updated * @return {@code true} if the project is on the list of projects to be updated */ - boolean shouldProjectBeUpdated(File rootFolder, Versions versions) { + boolean shouldProjectBeUpdated(File rootFolder, VersionsFromBom versionsFromBom) { File rootPom = rootPom(rootFolder); if (!rootPom.exists()) { return false; } - Model model = this.pomReader.readPom(rootPom); + Model model = PomReader.readPom(rootPom); if (model == null) { log.info("Failed to read the model"); return false; } String artifactId = artifactId(model); - if (!versions.shouldBeUpdated(artifactId)) { + if (!versionsFromBom.shouldBeUpdated(artifactId)) { log.info( "Skipping project [{}] since it's not on the list of projects to update", model.getArtifactId()); @@ -136,22 +134,25 @@ class PomUpdater { } ModelWrapper readModel(File pom) { - return new ModelWrapper(this.pomReader.readPom(pom)); + return new ModelWrapper(PomReader.readPom(pom)); } /** * Updates the root / child module model. * @param rootPom - root project model * @param pom - file with the pom - * @param versions - versions to update + * @param versionsFromBom - versions to update * @return updated model */ - ModelWrapper updateModel(ModelWrapper rootPom, File pom, Versions versions) { - Model model = this.pomReader.readPom(pom); + ModelWrapper updateModel(ModelWrapper rootPom, File pom, + VersionsFromBom versionsFromBom) { + Model model = PomReader.readPom(pom); List sourceChanges = new ArrayList<>(); - sourceChanges = updateParentIfPossible(rootPom, versions, model, sourceChanges); - sourceChanges = updateVersionIfPossible(rootPom, versions, model, sourceChanges); - return new ModelWrapper(model, sourceChanges, versions); + sourceChanges = updateParentIfPossible(rootPom, versionsFromBom, model, + sourceChanges); + sourceChanges = updateVersionIfPossible(rootPom, versionsFromBom, model, + sourceChanges); + return new ModelWrapper(model, sourceChanges, versionsFromBom); } /** @@ -159,17 +160,19 @@ class PomUpdater { * changes in the model. * @return - the pom file */ - File overwritePomIfDirty(ModelWrapper updatedPomModel, Versions versions, File pom) { + File overwritePomIfDirty(ModelWrapper updatedPomModel, + VersionsFromBom versionsFromBom, File pom) { if (updatedPomModel.isDirty()) { log.debug("There were changes in the pom so file will be overridden"); - this.pomWriter.write(updatedPomModel, versions, pom); + this.pomWriter.write(updatedPomModel, versionsFromBom, pom); log.info("Successfully stored [{}]", pom); } return pom; } private List updateParentIfPossible(ModelWrapper wrapper, - Versions versions, Model model, List sourceChanges) { + VersionsFromBom versionsFromBom, Model model, + List sourceChanges) { String rootProjectName = wrapper.projectName(); List changes = new ArrayList<>(sourceChanges); if (model.getParent() == null || isEmpty(model.getParent().getVersion())) { @@ -181,11 +184,11 @@ class PomUpdater { log.debug("Searching for a version of parent [{}:{}]", parentGroupId, parentArtifactId); String oldVersion = model.getParent().getVersion(); - String version = versions.versionForProject(parentArtifactId); + String version = versionsFromBom.versionForProject(parentArtifactId); log.debug("Found version is [{}]", version); if (isEmpty(version)) { if (hasText(model.getParent().getRelativePath())) { - version = versions.versionForProject(rootProjectName); + version = versionsFromBom.versionForProject(rootProjectName); } else { log.warn("There is no info on the [{}:{}] version", parentGroupId, @@ -209,7 +212,8 @@ class PomUpdater { } private List updateVersionIfPossible(ModelWrapper wrapper, - Versions versions, Model model, List sourceChanges) { + VersionsFromBom versionsFromBom, Model model, + List sourceChanges) { String rootProjectName = wrapper.projectName(); String rootProjectGroupId = wrapper.groupId(); List changes = new ArrayList<>(sourceChanges); @@ -224,7 +228,7 @@ class PomUpdater { } log.debug("Searching for a version [{}:{}]", groupId, artifactId); String oldVersion = model.getVersion(); - String version = versions.versionForProject(rootProjectName); + String version = versionsFromBom.versionForProject(rootProjectName); log.debug("Found version is [{}]", version); if (isEmpty(version) || isEmpty(model.getVersion())) { log.debug( @@ -259,19 +263,20 @@ class ModelWrapper { final Model model; - final Versions versions; + final VersionsFromBom versionsFromBom; final List sourceChanges = new ArrayList<>(); - ModelWrapper(Model model, List sourceChanges, Versions versions) { + ModelWrapper(Model model, List sourceChanges, + VersionsFromBom versionsFromBom) { this.model = model; - this.versions = versions; + this.versionsFromBom = versionsFromBom; this.sourceChanges.addAll(sourceChanges); } ModelWrapper(Model model) { this.model = model; - this.versions = Versions.EMPTY_VERSION; + this.versionsFromBom = VersionsFromBom.EMPTY_VERSION; } String projectName() { @@ -287,7 +292,7 @@ class ModelWrapper { boolean isDirty() { return !this.sourceChanges.isEmpty() - || this.versions.shouldSetProperty(this.model.getProperties()); + || this.versionsFromBom.shouldSetProperty(this.model.getProperties()); } } @@ -296,7 +301,7 @@ class PomWriter { private static final Logger log = LoggerFactory.getLogger(PomWriter.class); - void write(ModelWrapper wrapper, Versions versions, File pom) { + void write(ModelWrapper wrapper, VersionsFromBom versionsFromBom, File pom) { try { VersionChangerFactory versionChangerFactory = new VersionChangerFactory(); StringBuilder input = PomHelper.readXmlFile(pom); @@ -314,8 +319,8 @@ class PomWriter { changer.apply(versionChange); } log.debug("Applying properties changes to the pom [{}]", pom); - new PropertyVersionChanger(wrapper, versions, parsedPom, loggerToMavenLog) - .apply(null); + new PropertyVersionChanger(wrapper, versionsFromBom, parsedPom, + loggerToMavenLog).apply(null); try (BufferedWriter bw = new BufferedWriter(new FileWriter(pom))) { bw.write(input.toString()); } @@ -349,27 +354,27 @@ class PomWriter { class PropertyVersionChanger extends AbstractVersionChanger { - private final Versions versions; + private final VersionsFromBom versionsFromBom; private final PropertyStorer propertyStorer; - PropertyVersionChanger(ModelWrapper wrapper, Versions versions, + PropertyVersionChanger(ModelWrapper wrapper, VersionsFromBom versionsFromBom, ModifiedPomXMLEventReader pom, Log log) { super(wrapper.model, pom, log); - this.versions = versions; + this.versionsFromBom = versionsFromBom; this.propertyStorer = new PropertyStorer(log, pom); } - PropertyVersionChanger(ModelWrapper wrapper, Versions versions, + PropertyVersionChanger(ModelWrapper wrapper, VersionsFromBom versionsFromBom, ModifiedPomXMLEventReader pom, Log log, PropertyStorer propertyStorer) { super(wrapper.model, pom, log); - this.versions = versions; + this.versionsFromBom = versionsFromBom; this.propertyStorer = propertyStorer; } @Override public void apply(final VersionChange versionChange) { - this.versions.projects.stream().filter(project -> { + this.versionsFromBom.projects.stream().filter(project -> { Properties properties = getModel().getProperties(); String projectVersionKey = propertyName(project); if (!properties.containsKey(projectVersionKey)) { diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Project.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Project.java new file mode 100644 index 00000000..496fd8f8 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Project.java @@ -0,0 +1,65 @@ +/* + * Copyright 2013-2019 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 + * + * http://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 org.springframework.cloud.release.internal.buildsystem; + +/** + * Represents a single project. + * + * @author Marcin Grzejszczak + */ +public class Project { + + public static Project EMPTY_PROJECT = new Project("", ""); + + public final String name; + + public final String version; + + public Project(String name, String version) { + this.name = name; + this.version = version; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Project project = (Project) o; + if (this.name != null ? !this.name.equals(project.name) : project.name != null) { + return false; + } + return this.version != null ? this.version.equals(project.version) + : project.version == null; + } + + @Override + public int hashCode() { + int result = this.name != null ? this.name.hashCode() : 0; + result = 31 * result + (this.version != null ? this.version.hashCode() : 0); + return result; + } + + @Override + public String toString() { + return "name=[" + this.name + "], version=[" + this.version + ']'; + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java index f5195e28..71611cd2 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java @@ -54,7 +54,7 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { private static final boolean UPDATE_FIXED_VERSIONS = true; - private static final Map CACHE = new ConcurrentHashMap<>(); + private static final Map CACHE = new ConcurrentHashMap<>(); private final ProjectGitHandler gitRepo; @@ -93,33 +93,32 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { // TODO: I don't like this flag but don't have a better idea public Projects retrieveVersionsFromReleaseTrainBom(String branch, boolean updateFixedVersions) { - Versions versions = CACHE.computeIfAbsent(branch, s -> { + VersionsFromBom versionsFromBom = CACHE.computeIfAbsent(branch, s -> { File clonedBom = this.gitRepo.cloneReleaseTrainProject(); this.gitRepo.checkout(clonedBom, branch); BomParser releaseTrainBomParser = new BomParser(this.properties, clonedBom); - return releaseTrainBomParser.allVersions(); + return releaseTrainBomParser.versionsFromBom(); }); if (updateFixedVersions) { log.info("Will update the following versions manually [{}]", this.properties.getFixedVersions()); - this.properties.getFixedVersions().forEach(versions::setVersion); + this.properties.getFixedVersions().forEach(versionsFromBom::setVersion); } - log.info("Retrieved the following versions\n{}", versions); - return versions.toProjectVersions(); + log.info("Retrieved the following versions\n{}", versionsFromBom); + return versionsFromBom.toProjectVersions(); } /** * @return map of fixed versions */ public Projects fixedVersions() { - Set projectVersions = this.properties.getFixedVersions() - .entrySet().stream() - .map(entry -> new ProjectVersion(entry.getKey(), entry.getValue())) + Set projects = this.properties.getFixedVersions().entrySet().stream() + .map(entry -> new Project(entry.getKey(), entry.getValue())) .collect(Collectors.toSet()); if (log.isDebugEnabled()) { - log.debug("Will apply the following fixed versions {}", projectVersions); + log.debug("Will apply the following fixed versions {}", projects); } - return new Versions(projectVersions, this.properties).toProjectVersions(); + return new VersionsFromBom(this.properties, projects).toProjectVersions(); } /** @@ -134,8 +133,9 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { */ public void updateProjectFromReleaseTrain(File projectRoot, Projects projects, ProjectVersion versionFromReleaseTrain, boolean assertVersions) { - Versions versions = new Versions(projects, this.properties); - if (!this.pomUpdater.shouldProjectBeUpdated(projectRoot, versions)) { + VersionsFromBom versionsFromBom = new VersionsFromBom(this.properties, + projects.asProjects()); + if (!this.pomUpdater.shouldProjectBeUpdated(projectRoot, versionsFromBom)) { log.info("Skipping project updating"); return; } @@ -174,7 +174,7 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { private final ModelWrapper rootPom; - private final Versions versions; + private final VersionsFromBom versionsFromBom; private final PomUpdater pomUpdater; @@ -190,7 +190,7 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { ReleaserProperties properties, ProjectVersion versionFromScRelease, boolean assertVersions) { this.rootPom = rootPom; - this.versions = new Versions(projects, properties); + this.versionsFromBom = new VersionsFromBom(properties, projects.asProjects()); this.pomUpdater = pomUpdater; this.properties = properties; List unacceptableVersionPatterns = versionFromScRelease @@ -212,8 +212,8 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { return FileVisitResult.CONTINUE; } ModelWrapper model = this.pomUpdater.updateModel(this.rootPom, file, - this.versions); - this.pomUpdater.overwritePomIfDirty(model, this.versions, file); + this.versionsFromBom); + this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, file); if (this.assertVersions && !this.skipVersionAssert && !this.pomUpdater.hasSkipDeployment(model.model)) { log.debug( diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersion.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersion.java index 2ddfb58f..9b7c413d 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersion.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersion.java @@ -81,8 +81,7 @@ public class ProjectVersion implements Comparable { this.artifactId = projectName; } else { - PomReader pomReader = new PomReader(); - Model model = pomReader.readPom(project); + Model model = PomReader.readPom(project); if (model != null) { this.projectName = nameWithoutParent(model.getArtifactId()); this.version = model.getVersion(); diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Versions.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Versions.java deleted file mode 100644 index 6efe75c3..00000000 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Versions.java +++ /dev/null @@ -1,297 +0,0 @@ -/* - * Copyright 2013-2019 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 org.springframework.cloud.release.internal.buildsystem; - -import java.io.File; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Properties; -import java.util.Set; -import java.util.stream.Collectors; - -import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.project.Projects; - -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_DEPENDENCIES_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BUILD_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.SPRING_BOOT; - -/** - * Represents versions taken out from Spring Cloud Release pom. - * - * @author Marcin Grzejszczak - */ -class Versions { - - static final Versions EMPTY_VERSION = new Versions(); - - String bootVersion; - - String scBuildVersion; - - Set projects = new HashSet<>(); - - ReleaserProperties properties; - - private Versions() { - this.properties = new ReleaserProperties(); - } - - Versions(ReleaserProperties releaserProperties) { - this.properties = releaserProperties; - } - - Versions(String bootVersion) { - this.bootVersion = bootVersion; - add(SPRING_BOOT, bootVersion); - add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion); - add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion); - this.properties = new ReleaserProperties(); - } - - Versions(String scBuildVersion, Set projects) { - this.scBuildVersion = scBuildVersion; - add(BUILD_ARTIFACT_ID, scBuildVersion); - add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, scBuildVersion); - this.projects.addAll(projects); - this.properties = new ReleaserProperties(); - } - - Versions(ReleaserProperties releaserProperties, Set projects) { - this.projects.addAll(projects); - this.properties = releaserProperties; - } - - Versions(String bootVersion, String scBuildVersion, Set projects) { - this(new ReleaserProperties(), bootVersion, scBuildVersion, projects); - } - - Versions(ReleaserProperties properties, String bootVersion, String scBuildVersion, - Set projects) { - this.properties = properties; - this.bootVersion = bootVersion; - this.scBuildVersion = scBuildVersion; - add(SPRING_BOOT, bootVersion); - add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion); - add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion); - add(BUILD_ARTIFACT_ID, scBuildVersion); - add(dependenciesParentArtifactId(), scBuildVersion); - this.projects.addAll(projects); - } - - Versions(Set versions, ReleaserProperties properties) { - this.properties = properties; - this.bootVersion = versions.stream() - .filter(projectVersion -> SPRING_BOOT.equals(projectVersion.projectName)) - .findFirst().orElse(new ProjectVersion(SPRING_BOOT, "")).version; - this.scBuildVersion = versions.stream().filter( - projectVersion -> BUILD_ARTIFACT_ID.equals(projectVersion.projectName)) - .findFirst().orElse(new ProjectVersion(BUILD_ARTIFACT_ID, "")).version; - versions.forEach(projectVersion -> setVersion(projectVersion.projectName, - projectVersion.version)); - } - - private String bomProjectName() { - return this.properties.getMetaRelease().getReleaseTrainProjectName(); - } - - private String dependenciesArtifactId() { - String artifactId = this.properties.getPom().getThisTrainBom(); - return artifactId.split(File.separator)[0]; - } - - private String dependenciesParentArtifactId() { - return dependenciesArtifactId() + "-parent"; - } - - String versionForProject(String projectName) { - return this.projects.stream().filter(project -> nameMatches(projectName, project)) - .findFirst().orElse(Project.EMPTY_PROJECT).version; - } - - boolean shouldBeUpdated(String projectName) { - return this.projects.stream() - .anyMatch(project -> nameMatches(projectName, project)); - } - - boolean shouldSetProperty(Properties properties) { - return this.projects.stream() - .anyMatch(project -> properties.containsKey(project.name + ".version")); - } - - Projects toProjectVersions() { - return this.projects.stream() - .map(project -> new ProjectVersion(project.name, project.version)) - .collect(Collectors.toCollection(Projects::new)); - } - - /** - * The only exception is spring-cloud-dependencies (e.g. Greenwich.RELEASE) and - * spring-cloud-dependencies-parent (e.g. 2.1.0.RELEASE) - */ - private boolean nameMatches(String projectName, Project project) { - if (project.name.equals(projectName)) { - return true; - } - boolean parent = matchesNameWithSuffix(projectName, "-parent", project); - boolean bomArtifactId = comparisonOfBomArtifactAndParent(projectName, project); - return !bomArtifactId && (parent - || matchesNameWithSuffix(projectName, "-dependencies", project)); - } - - private boolean comparisonOfBomArtifactAndParent(String projectName, - Project project) { - return artifactOrParent(projectName, project.name) - || artifactOrParent(project.name, projectName); - } - - private boolean artifactOrParent(String projectName, String otherProjectName) { - return projectName.equals(dependenciesArtifactId()) - && otherProjectName.equals(dependenciesParentArtifactId()); - } - - private boolean matchesNameWithSuffix(String projectName, String suffix, - Project project) { - boolean containsSuffix = projectName.endsWith(suffix); - if (!containsSuffix) { - return false; - } - String withoutSuffix = projectName.substring(0, projectName.indexOf(suffix)); - return project.name.equals(withoutSuffix); - } - - Versions setVersion(String projectName, String version) { - switch (projectName) { - case SPRING_BOOT: - case BOOT_STARTER_PARENT_ARTIFACT_ID: - case BOOT_DEPENDENCIES_ARTIFACT_ID: - updateBootVersions(version); - break; - case BUILD_ARTIFACT_ID: - case CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID: - updateBuildVersions(version); - break; - default: - if (bomVersionProjectNames().contains(projectName)) { - updateBomVersions(version); - } - else { - remove(projectName); - add(projectName, version); - } - } - return this; - } - - private List bomVersionProjectNames() { - List names = new ArrayList<>( - this.properties.getMetaRelease().getReleaseTrainDependencyNames()); - names.add(this.properties.getMetaRelease().getReleaseTrainProjectName()); - return names; - } - - private void updateBuildVersions(String version) { - this.scBuildVersion = version; - remove(BUILD_ARTIFACT_ID); - remove(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID); - add(BUILD_ARTIFACT_ID, version); - add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, version); - } - - private void updateBootVersions(String version) { - this.bootVersion = version; - remove(SPRING_BOOT); - remove(BOOT_DEPENDENCIES_ARTIFACT_ID); - remove(BOOT_STARTER_PARENT_ARTIFACT_ID); - add(SPRING_BOOT, version); - add(BOOT_STARTER_PARENT_ARTIFACT_ID, version); - add(BOOT_DEPENDENCIES_ARTIFACT_ID, version); - } - - private void updateBomVersions(String version) { - remove(bomProjectName()); - bomVersionProjectNames().forEach(this::remove); - add(bomProjectName(), version); - bomVersionProjectNames().forEach(s -> add(s, version)); - } - - public void add(String key, String value) { - this.projects.add(new Project(key, value)); - } - - public void remove(String expectedProjectName) { - this.projects.removeIf(project -> expectedProjectName.equals(project.name)); - } - - @Override - public String toString() { - return "Spring Boot Version=[" + this.bootVersion + ']' - + "\nSpring Cloud Build Version=[" + this.scBuildVersion + ']' - + "\nProjects=\n\t" + this.projects.stream().map(Object::toString) - .collect(Collectors.joining("\n\t")); - } - -} - -/** - * @author Marcin Grzejszczak - */ -class Project { - - static Project EMPTY_PROJECT = new Project("", ""); - - final String name; - - final String version; - - Project(String name, String version) { - this.name = name; - this.version = version; - } - - @Override - public boolean equals(Object o) { - if (this == o) { - return true; - } - if (o == null || getClass() != o.getClass()) { - return false; - } - Project project = (Project) o; - if (this.name != null ? !this.name.equals(project.name) : project.name != null) { - return false; - } - return this.version != null ? this.version.equals(project.version) - : project.version == null; - } - - @Override - public int hashCode() { - int result = this.name != null ? this.name.hashCode() : 0; - result = 31 * result + (this.version != null ? this.version.hashCode() : 0); - return result; - } - - @Override - public String toString() { - return "name=[" + this.name + "], version=[" + this.version + ']'; - } - -} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBom.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBom.java new file mode 100644 index 00000000..43a81cdf --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBom.java @@ -0,0 +1,178 @@ +/* + * Copyright 2013-2019 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 org.springframework.cloud.release.internal.buildsystem; + +import java.io.File; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Properties; +import java.util.Set; +import java.util.stream.Collectors; + +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.project.Projects; + +/** + * Represents versions taken out from a release train POM. + * + * @author Marcin Grzejszczak + */ +public class VersionsFromBom { + + public static final VersionsFromBom EMPTY_VERSION = new VersionsFromBom(); + + Set projects = new HashSet<>(); + + ReleaserProperties properties; + + private VersionsFromBom() { + this.properties = new ReleaserProperties(); + } + + public VersionsFromBom(ReleaserProperties releaserProperties) { + this.properties = releaserProperties; + } + + public VersionsFromBom(ReleaserProperties releaserProperties, Set projects) { + this.properties = releaserProperties; + projects.forEach(project -> setVersion(project.name, project.version)); + } + + public VersionsFromBom(ReleaserProperties releaserProperties, + VersionsFromBom... projects) { + this.properties = releaserProperties; + Arrays.stream(projects).forEach(p -> this.projects.addAll(p.projects)); + } + + private String bomProjectName() { + return this.properties.getMetaRelease().getReleaseTrainProjectName(); + } + + private String dependenciesArtifactId() { + String artifactId = this.properties.getPom().getThisTrainBom(); + return artifactId.split(File.separator)[0]; + } + + private String dependenciesParentArtifactId() { + return dependenciesArtifactId() + "-parent"; + } + + public String versionForProject(String projectName) { + return this.projects.stream().filter(project -> nameMatches(projectName, project)) + .findFirst().orElse(Project.EMPTY_PROJECT).version; + } + + public boolean shouldBeUpdated(String projectName) { + return this.projects.stream() + .anyMatch(project -> nameMatches(projectName, project)); + } + + public boolean shouldSetProperty(Properties properties) { + return this.projects.stream() + .anyMatch(project -> properties.containsKey(project.name + ".version")); + } + + public Projects toProjectVersions() { + return this.projects.stream() + .map(project -> new ProjectVersion(project.name, project.version)) + .collect(Collectors.toCollection(Projects::new)); + } + + /** + * The only exception is spring-cloud-dependencies (e.g. Greenwich.RELEASE) and + * spring-cloud-dependencies-parent (e.g. 2.1.0.RELEASE) + */ + private boolean nameMatches(String projectName, Project project) { + if (project.name.equals(projectName)) { + return true; + } + boolean parent = matchesNameWithSuffix(projectName, "-parent", project); + boolean bomArtifactId = comparisonOfBomArtifactAndParent(projectName, project); + return !bomArtifactId && (parent + || matchesNameWithSuffix(projectName, "-dependencies", project)); + } + + private boolean comparisonOfBomArtifactAndParent(String projectName, + Project project) { + return artifactOrParent(projectName, project.name) + || artifactOrParent(project.name, projectName); + } + + private boolean artifactOrParent(String projectName, String otherProjectName) { + return projectName.equals(dependenciesArtifactId()) + && otherProjectName.equals(dependenciesParentArtifactId()); + } + + private boolean matchesNameWithSuffix(String projectName, String suffix, + Project project) { + boolean containsSuffix = projectName.endsWith(suffix); + if (!containsSuffix) { + return false; + } + String withoutSuffix = projectName.substring(0, projectName.indexOf(suffix)); + return project.name.equals(withoutSuffix); + } + + public VersionsFromBom setVersion(String projectName, String version) { + CustomBomParser parser = CustomBomParser.parser(this.properties); + Set projects = parser.setVersion(this.projects, projectName, version); + if (!projects.equals(this.projects)) { + this.projects.clear(); + this.projects.addAll(projects); + return this; + } + if (bomVersionProjectNames().contains(projectName)) { + updateBomVersions(version); + } + else { + remove(projectName); + add(projectName, version); + } + return this; + } + + private List bomVersionProjectNames() { + List names = new ArrayList<>( + this.properties.getMetaRelease().getReleaseTrainDependencyNames()); + names.add(this.properties.getMetaRelease().getReleaseTrainProjectName()); + return names; + } + + private void updateBomVersions(String version) { + remove(bomProjectName()); + bomVersionProjectNames().forEach(this::remove); + add(bomProjectName(), version); + bomVersionProjectNames().forEach(s -> add(s, version)); + } + + public void add(String key, String value) { + this.projects.add(new Project(key, value)); + } + + public void remove(String expectedProjectName) { + this.projects.removeIf(project -> expectedProjectName.equals(project.name)); + } + + @Override + public String toString() { + return "Projects=\n\t" + this.projects.stream().map(Object::toString) + .collect(Collectors.joining("\n\t")); + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java index 3aacbf15..4337ea37 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java @@ -26,6 +26,7 @@ import java.util.Set; import java.util.stream.Collectors; import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.buildsystem.Project; import org.springframework.cloud.release.internal.buildsystem.ProjectVersion; /** @@ -152,6 +153,11 @@ public class Projects extends HashSet { .collect(Collectors.joining(",")); } + public Set asProjects() { + return this.stream().map(projectVersion -> new Project(projectVersion.projectName, + projectVersion.version)).collect(Collectors.toSet()); + } + @Override public String toString() { return stream().map(v -> "[" + v.projectName + "=>" + v.version + "]") diff --git a/spring-cloud-release-tools-core/src/main/resources/META-INF/spring.factories b/spring-cloud-release-tools-core/src/main/resources/META-INF/spring.factories new file mode 100644 index 00000000..9a8479b0 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/resources/META-INF/spring.factories @@ -0,0 +1,2 @@ +org.springframework.cloud.release.internal.buildsystem.CustomBomParser=\ +org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomParser diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/PomUpdateAcceptanceTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/PomUpdateAcceptanceTests.java index de6a0ee7..da2ea8d0 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/PomUpdateAcceptanceTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/PomUpdateAcceptanceTests.java @@ -28,9 +28,9 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; +import org.springframework.cloud.release.internal.buildsystem.PomReader; import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; import org.springframework.cloud.release.internal.buildsystem.ProjectVersion; -import org.springframework.cloud.release.internal.buildsystem.TestPomReader; import org.springframework.cloud.release.internal.buildsystem.TestUtils; import org.springframework.cloud.release.internal.project.Projects; import org.springframework.util.FileSystemUtils; @@ -45,8 +45,6 @@ public class PomUpdateAcceptanceTests { @Rule public TemporaryFolder tmp = new TemporaryFolder(); - TestPomReader testPomReader = new TestPomReader(); - File temporaryFolder; @Before @@ -68,13 +66,12 @@ public class PomUpdateAcceptanceTests { projects.forFile(project), true); then(this.temporaryFolder).exists(); - Model rootPom = this.testPomReader - .readPom(tmpFile("/spring-cloud-sleuth/pom.xml")); - Model depsPom = this.testPomReader.readPom( + Model rootPom = PomReader.readPom(tmpFile("/spring-cloud-sleuth/pom.xml")); + Model depsPom = PomReader.readPom( tmpFile("/spring-cloud-sleuth/spring-cloud-sleuth-dependencies/pom.xml")); - Model corePom = this.testPomReader.readPom( + Model corePom = PomReader.readPom( tmpFile("/spring-cloud-sleuth/spring-cloud-sleuth-core/pom.xml")); - Model zipkinStreamPom = this.testPomReader.readPom(tmpFile( + Model zipkinStreamPom = PomReader.readPom(tmpFile( "/spring-cloud-sleuth/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin-stream/pom.xml")); then(rootPom.getVersion()).isEqualTo("1.2.0.BUILD-SNAPSHOT"); then(rootPom.getProperties()) diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/BomParserTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/BomParserTests.java index 54e591eb..61fac89d 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/BomParserTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/BomParserTests.java @@ -47,7 +47,7 @@ public class BomParserTests { public void should_throw_exception_when_boot_pom_is_missing() { BomParser parser = new BomParser(this.properties, new File(".")); - thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class) + thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class) .hasMessageContaining("Pom is not present"); } @@ -57,17 +57,16 @@ public class BomParserTests { this.properties.getPom().setThisTrainBom(null); BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); - thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class) + thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class) .hasMessageContaining("Pom is not present"); } @Test public void should_throw_exception_when_boot_version_is_missing_in_pom() { this.properties.getPom().setPomWithBootStarterParent("pom.xml"); - this.properties.getPom().setThisTrainBom(null); BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); - thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class) + thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class) .hasMessageContaining( "The pom doesn't have a [spring-boot-starter-parent] artifact id"); } @@ -76,7 +75,7 @@ public class BomParserTests { public void should_populate_sc_release_version() { BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); - String scReleaseVersion = parser.allVersions() + String scReleaseVersion = parser.versionsFromBom() .versionForProject("spring-cloud-release"); then(scReleaseVersion).isEqualTo("Dalston.BUILD-SNAPSHOT"); @@ -86,7 +85,7 @@ public class BomParserTests { public void should_populate_boot_version() { BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); - String bootVersion = parser.bootVersion().versionForProject("spring-boot"); + String bootVersion = parser.versionsFromBom().versionForProject("spring-boot"); then(bootVersion).isEqualTo("1.5.1.BUILD-SNAPSHOT"); } @@ -111,7 +110,7 @@ public class BomParserTests { @Test public void should_throw_exception_when_cloud_version_is_missing_in_pom() { - this.properties.getPom().setPomWithBootStarterParent(null); + this.properties.getPom().setPomWithBootStarterParent("pom.xml"); this.properties.getPom().setThisTrainBom("pom.xml"); BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); @@ -124,24 +123,24 @@ public class BomParserTests { public void should_populate_cloud_version() { BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); - Versions cloudVersions = parser.versionsFromBom(); + VersionsFromBom cloudVersionsFromBom = parser.versionsFromBom(); - then(cloudVersions.versionForProject("spring-cloud-build")) + then(cloudVersionsFromBom.versionForProject("spring-cloud-build")) .isEqualTo("1.3.1.BUILD-SNAPSHOT"); - then(cloudVersions.projects).contains(allProjects()); + then(cloudVersionsFromBom.projects).contains(allProjects()); } @Test public void should_populate_boot_and_cloud_version() { BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); - Versions cloudVersions = parser.allVersions(); + VersionsFromBom cloudVersionsFromBom = parser.versionsFromBom(); - then(cloudVersions.versionForProject("spring-boot")) + then(cloudVersionsFromBom.versionForProject("spring-boot")) .isEqualTo("1.5.1.BUILD-SNAPSHOT"); - then(cloudVersions.versionForProject("spring-cloud-build")) + then(cloudVersionsFromBom.versionForProject("spring-cloud-build")) .isEqualTo("1.3.1.BUILD-SNAPSHOT"); - then(cloudVersions.projects).contains(allProjects()); + then(cloudVersionsFromBom.projects).contains(allProjects()); } private Project[] allProjects() { diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java index 5ef8513f..3bfe6a33 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java @@ -36,8 +36,6 @@ import static org.assertj.core.api.BDDAssertions.thenThrownBy; */ public class PomReaderTests { - PomReader pomReader = new PomReader(); - File springCloudReleaseProjectPom; File springCloudReleaseProject; @@ -59,7 +57,7 @@ public class PomReaderTests { @Test public void should_parse_a_valid_pom() { - Model pom = this.pomReader.readPom(this.springCloudReleaseProjectPom); + Model pom = PomReader.readPom(this.springCloudReleaseProjectPom); then(pom).isNotNull(); then(pom.getArtifactId()).isEqualTo("spring-cloud-starter-build"); @@ -67,7 +65,7 @@ public class PomReaderTests { @Test public void should_parse_a_valid_pom_when_passing_direcory() { - Model pom = this.pomReader.readPom(this.springCloudReleaseProject); + Model pom = PomReader.readPom(this.springCloudReleaseProject); then(pom).isNotNull(); then(pom.getArtifactId()).isEqualTo("spring-cloud-starter-build"); @@ -75,20 +73,20 @@ public class PomReaderTests { @Test public void should_return_null_when_file_is_missing() { - then(this.pomReader.readPom(new File("foo/bar"))).isNull(); + then(PomReader.readPom(new File("foo/bar"))).isNull(); } @Test public void should_throw_exception_when_file_is_invalid() { - thenThrownBy(() -> this.pomReader.readPom(this.licenseFile)) + thenThrownBy(() -> PomReader.readPom(this.licenseFile)) .hasMessageStartingWith("Failed to read file: ") .hasCauseInstanceOf(XmlPullParserException.class); } @Test public void should_throw_exception_when_file_is_empty() { - thenThrownBy(() -> this.pomReader.readPom(this.empty)) - .hasMessageStartingWith("File [").hasMessageContaining("] is empty") + thenThrownBy(() -> PomReader.readPom(this.empty)).hasMessageStartingWith("File [") + .hasMessageContaining("] is empty") .hasCauseInstanceOf(EOFException.class); } diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java index 6a07852f..a46c7b68 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java @@ -31,6 +31,7 @@ import org.junit.Test; import org.junit.rules.TemporaryFolder; import org.springframework.boot.test.rule.OutputCapture; +import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.git.GitRepoTests; import org.springframework.util.FileSystemUtils; @@ -45,12 +46,11 @@ public class PomUpdaterTests { @Rule public TemporaryFolder tmp = new TemporaryFolder(); - Versions versions = new Versions("0.0.1", "0.0.2", projects()); + VersionsFromBom versionsFromBom = new VersionsFromBom(new ReleaserProperties(), + projects()); PomUpdater pomUpdater = new PomUpdater(); - PomReader pomReader = new PomReader(); - File temporaryFolder; @Before @@ -65,7 +65,7 @@ public class PomUpdaterTests { File springCloudReleasePom = file("/projects/spring-cloud-release"); BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudReleasePom, - this.versions)).isFalse(); + this.versionsFromBom)).isFalse(); } @Test @@ -73,8 +73,8 @@ public class PomUpdaterTests { throws Exception { File springCloud = pom("/projects/project", "pom_with_parent_suffix.xml"); - BDDAssertions - .then(this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versions)) + BDDAssertions.then( + this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versionsFromBom)) .isFalse(); } @@ -84,8 +84,8 @@ public class PomUpdaterTests { File springCloud = pom("/projects/project", "pom_matching_with_parent_suffix.xml"); - BDDAssertions - .then(this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versions)) + BDDAssertions.then( + this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versionsFromBom)) .isTrue(); } @@ -95,7 +95,7 @@ public class PomUpdaterTests { File springCloudSleuthPom = file("/projects/spring-cloud-sleuth"); BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudSleuthPom, - this.versions)).isTrue(); + this.versionsFromBom)).isTrue(); } @Test @@ -104,7 +104,7 @@ public class PomUpdaterTests { File springCloudSleuthPom = file("/projects/spring-cloud-sleuth/empty-folder"); BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudSleuthPom, - this.versions)).isFalse(); + this.versionsFromBom)).isFalse(); } @Test @@ -113,9 +113,9 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/pom.xml"); ModelWrapper rootPom = model("foo"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isEqualTo(asString(originalPom)); @@ -128,13 +128,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/pom_matching_artifact.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.3.BUILD-SNAPSHOT"); } @@ -146,13 +146,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/pom_matching_parent_v2.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(originalPom)).isNotEqualTo(asString(storedPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.3.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -166,13 +166,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/pom_matching_parent.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.3.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -185,7 +185,7 @@ public class PomUpdaterTests { File springCloudReleasePom = file("/projects/spring-cloud-release"); BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudReleasePom, - this.versions)).isFalse(); + this.versionsFromBom)).isFalse(); } @Test @@ -194,7 +194,7 @@ public class PomUpdaterTests { File springCloudSleuthPom = file("/projects/spring-cloud-sleuth"); BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudSleuthPom, - this.versions)).isTrue(); + this.versionsFromBom)).isTrue(); } @Test @@ -205,13 +205,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/children/pom_matching_parent_v2.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.3.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -230,13 +230,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/children/pom_different_group_boot_parent.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.3.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -252,13 +252,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/children/pom_different_group.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("1.2.2.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -277,13 +277,13 @@ public class PomUpdaterTests { "/project/children/pom_different_group_skip_deployment_prop.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("1.2.2.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -302,13 +302,13 @@ public class PomUpdaterTests { "/project/children/pom_different_group_skip_deployment_plugin.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("1.2.2.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -327,13 +327,13 @@ public class PomUpdaterTests { "/project/children/pom_different_group_skip_deployment_plugin_mngmnt.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("1.2.2.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -352,13 +352,13 @@ public class PomUpdaterTests { ModelWrapper rootPom = model("spring-cloud-contract", "org.springframework.cloud"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) .isEqualTo("0.0.1"); @@ -371,13 +371,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/children/pom_matching_parent.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.3.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -395,13 +395,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/children/pom_matching_properties.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.3.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -418,10 +418,10 @@ public class PomUpdaterTests { "pom_matching_properties.xml"); File afterProcessing = tmpFile("/project/children/pom_matching_properties.xml"); ModelWrapper model = this.pomUpdater.updateModel(model("spring-cloud-sleuth"), - afterProcessing, this.versions); + afterProcessing, this.versionsFromBom); File processedPom = this.pomUpdater.overwritePomIfDirty(model, - Versions.EMPTY_VERSION, afterProcessing); + VersionsFromBom.EMPTY_VERSION, afterProcessing); String processedPomText = asString(processedPom); String beforeProcessingText = asString(beforeProcessing); @@ -434,10 +434,10 @@ public class PomUpdaterTests { File beforeProcessing = pom("/projects/project/"); File afterProcessing = tmpFile("/project/pom.xml"); ModelWrapper model = this.pomUpdater.updateModel(model("foo"), afterProcessing, - this.versions); + this.versionsFromBom); File processedPom = this.pomUpdater.overwritePomIfDirty(model, - Versions.EMPTY_VERSION, afterProcessing); + VersionsFromBom.EMPTY_VERSION, afterProcessing); BDDAssertions.then(asString(processedPom)).isEqualTo(asString(beforeProcessing)); } @@ -449,13 +449,13 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/spring-cloud-contract/pom.xml"); ModelWrapper rootPom = model("spring-cloud-contract-parent"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom)); - Model overriddenPomModel = this.pomReader.readPom(storedPom); + Model overriddenPomModel = PomReader.readPom(storedPom); BDDAssertions.then(overriddenPomModel.getVersion()) .isEqualTo("0.0.2.BUILD-SNAPSHOT"); BDDAssertions.then(overriddenPomModel.getParent().getVersion()) @@ -470,9 +470,9 @@ public class PomUpdaterTests { File pomInTemp = tmpFile("/project/pom_matching_artifact_same_version.xml"); ModelWrapper rootPom = model("spring-cloud-sleuth"); ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp, - this.versions); + this.versionsFromBom); - File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions, + File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, pomInTemp); BDDAssertions.then(asString(storedPom)).isEqualTo(asString(originalPom)); @@ -480,6 +480,8 @@ public class PomUpdaterTests { Set projects() { Set projects = new HashSet<>(); + projects.add(new Project("spring-boot", "0.0.1")); + projects.add(new Project("spring-cloud-build", "0.0.2")); projects.add(new Project("spring-cloud-contract", "0.0.2.BUILD-SNAPSHOT")); projects.add(new Project("spring-cloud-sleuth", "0.0.3.BUILD-SNAPSHOT")); projects.add(new Project("spring-cloud-vault", "0.0.4.BUILD-SNAPSHOT")); diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java index c0b78dde..dc84825b 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java @@ -27,6 +27,8 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.cloud.release.internal.ReleaserProperties; + import static org.mockito.ArgumentMatchers.any; import static org.mockito.BDDMockito.then; import static org.mockito.Mockito.never; @@ -75,8 +77,8 @@ public class PropertyVersionChangerTests { .setPropertyVersionIfApplicable(any(Project.class)); } - Versions versions() { - return new Versions("", "", allProjects()); + VersionsFromBom versions() { + return new VersionsFromBom(new ReleaserProperties(), allProjects()); } @SuppressWarnings("unchecked") diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java deleted file mode 100644 index dcb452f6..00000000 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright 2013-2019 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 org.springframework.cloud.release.internal.buildsystem; - -import java.io.File; - -import org.apache.maven.model.Model; - -/** - * @author Marcin Grzejszczak - */ -public class TestPomReader { - - PomReader pomReader = new PomReader(); - - public Model readPom(File pom) { - return this.pomReader.readPom(pom); - } - -} diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomTests.java new file mode 100644 index 00000000..0de0c36d --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomTests.java @@ -0,0 +1,290 @@ +/* + * Copyright 2013-2019 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 org.springframework.cloud.release.internal.buildsystem; + +import java.util.Collections; +import java.util.HashSet; +import java.util.Properties; +import java.util.Set; + +import org.junit.Test; + +import org.springframework.cloud.release.internal.ReleaserProperties; + +import static org.assertj.core.api.BDDAssertions.then; + +/** + * @author Marcin Grzejszczak + */ +public class VersionsFromBomTests { + + VersionsFromBom versionsFromBom = new VersionsFromBom(new ReleaserProperties(), + projects()); + + @Test + public void should_add_boot_to_versions_when_version_is_created() { + VersionsFromBom versionsFromBom = new VersionsFromBom(new ReleaserProperties()); + versionsFromBom.setVersion("spring-boot", "1.2.3.RELEASE"); + + then(versionsFromBom.projects).contains( + new Project("spring-boot", "1.2.3.RELEASE"), + new Project("spring-boot-starter-parent", "1.2.3.RELEASE"), + new Project("spring-boot-dependencies", "1.2.3.RELEASE")); + } + + @Test + public void should_return_true_when_project_is_on_the_list() { + then(this.versionsFromBom.shouldBeUpdated("foo")).isTrue(); + } + + @Test + public void should_return_true_when_project_has_a_parent_suffix_and_project_is_on_the_list() { + then(this.versionsFromBom.shouldBeUpdated("foo-parent")).isTrue(); + } + + @Test + public void should_return_true_when_project_has_a_dependencies_suffix_and_project_is_on_the_list() { + then(this.versionsFromBom.shouldBeUpdated("foo-dependencies")).isTrue(); + } + + @Test + public void should_return_false_when_project_is_not_on_the_list() { + then(this.versionsFromBom.shouldBeUpdated("missing")).isFalse(); + } + + @Test + public void should_return_version_for_present_project() { + then(this.versionsFromBom.versionForProject("foo")).isEqualTo("bar"); + } + + @Test + public void should_return_empty_string_for_missing_project() { + then(this.versionsFromBom.versionForProject("missing")).isEmpty(); + } + + @Test + public void should_return_true_if_properties_contains_project_key() { + then(this.versionsFromBom.shouldSetProperty(validProps())).isTrue(); + } + + @Test + public void should_return_false_if_properties_does_not_contain_project_key() { + then(this.versionsFromBom.shouldSetProperty(missingProps())).isFalse(); + } + + @Test + public void should_update_projects_for_boot() { + VersionsFromBom versionsFromBom = mixedVersions().setVersion("spring-boot", + "3.0.0"); + + then(versionsFromBom.versionForProject("spring-boot")).isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-boot-starter-parent")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-boot-dependencies")) + .isEqualTo("3.0.0"); + + versionsFromBom = mixedVersions().setVersion("spring-boot-starter-parent", + "3.0.0"); + + then(versionsFromBom.versionForProject("spring-boot")).isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-boot-starter-parent")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-boot-dependencies")) + .isEqualTo("3.0.0"); + + versionsFromBom = mixedVersions().setVersion("spring-boot-dependencies", "3.0.0"); + + then(versionsFromBom.versionForProject("spring-boot")).isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-boot-starter-parent")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-boot-dependencies")) + .isEqualTo("3.0.0"); + } + + @Test + public void should_update_projects_for_build() { + VersionsFromBom versionsFromBom = mixedVersions().setVersion("spring-cloud-build", + "3.0.0"); + + then(versionsFromBom.versionForProject("spring-cloud-build")).isEqualTo("3.0.0"); + + versionsFromBom = mixedVersions().setVersion("spring-cloud-build", "3.0.0"); + + then(versionsFromBom.versionForProject("spring-cloud-dependencies-parent")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.RELEASE"); + + versionsFromBom = mixedVersions().setVersion("spring-cloud-dependencies-parent", + "3.0.0"); + + then(versionsFromBom.versionForProject("spring-cloud-build")).isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-dependencies-parent")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.RELEASE"); + } + + @Test + public void should_update_projects_for_spring_cloud_release() { + VersionsFromBom versionsFromBom = mixedVersions().setVersion("spring-cloud", + "3.0.0"); + + then(versionsFromBom.versionForProject("spring-cloud")).isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-release")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-starter")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("3.0.0"); + + versionsFromBom = mixedVersions().setVersion("spring-cloud-release", "3.0.0"); + + then(versionsFromBom.versionForProject("spring-cloud")).isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-release")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-starter")) + .isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("3.0.0"); + + versionsFromBom = mixedVersions().setVersion("spring-cloud-release", + "Greenwich.SR8"); + + then(versionsFromBom.versionForProject("spring-cloud")) + .isEqualTo("Greenwich.SR8"); + then(versionsFromBom.versionForProject("spring-cloud-release")) + .isEqualTo("Greenwich.SR8"); + then(versionsFromBom.versionForProject("spring-cloud-starter")) + .isEqualTo("Greenwich.SR8"); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.SR8"); + + versionsFromBom = mixedVersions().setVersion("spring-cloud-dependencies", + "Greenwich.SR8"); + + then(versionsFromBom.versionForProject("spring-cloud")) + .isEqualTo("Greenwich.SR8"); + then(versionsFromBom.versionForProject("spring-cloud-release")) + .isEqualTo("Greenwich.SR8"); + then(versionsFromBom.versionForProject("spring-cloud-starter")) + .isEqualTo("Greenwich.SR8"); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.SR8"); + } + + @Test + public void should_update_projects_for_custom_bom_only() { + VersionsFromBom versionsFromBom = mixedVersions(customBom()) + .setVersion("spring-cloud", "3.0.0"); + + then(versionsFromBom.versionForProject("spring-cloud")).isEqualTo("3.0.0"); + then(versionsFromBom.versionForProject("spring-cloud-stream-starters")) + .isEqualTo("Fishtown.RELEASE"); + then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty(); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.RELEASE"); + + versionsFromBom = mixedVersions(customBom()) + .setVersion("spring-cloud-stream-starters", "Fishtown.SR4"); + + then(versionsFromBom.versionForProject("spring-cloud")).isEmpty(); + then(versionsFromBom.versionForProject("spring-cloud-stream-starters")) + .isEqualTo("Fishtown.SR4"); + then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty(); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.RELEASE"); + + versionsFromBom = mixedVersions(customBom()).setVersion("spring-cloud-release", + "Greenwich.SR8"); + + then(versionsFromBom.versionForProject("spring-cloud-release")) + .isEqualTo("Greenwich.SR8"); + then(versionsFromBom.versionForProject("spring-cloud-stream-starters")) + .isEqualTo("Fishtown.RELEASE"); + then(versionsFromBom.versionForProject("spring-cloud")).isEmpty(); + then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty(); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.RELEASE"); + + versionsFromBom = mixedVersions(customBom()) + .setVersion("spring-cloud-dependencies", "Greenwich.SR8"); + + then(versionsFromBom.versionForProject("spring-cloud")).isEmpty(); + then(versionsFromBom.versionForProject("spring-cloud-stream-starters")) + .isEqualTo("Fishtown.RELEASE"); + then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty(); + then(versionsFromBom.versionForProject("spring-cloud-dependencies")) + .isEqualTo("Greenwich.SR8"); + } + + @Test + public void should_update_projects_for_custom_project() { + VersionsFromBom versionsFromBom = mixedVersions().setVersion("foo", "3.0.0"); + + then(versionsFromBom.versionForProject("foo")).isEqualTo("3.0.0"); + } + + private VersionsFromBom mixedVersions() { + return new VersionsFromBom(new ReleaserProperties(), mixedProjects()); + } + + private VersionsFromBom mixedVersions(ReleaserProperties properties) { + return new VersionsFromBom(properties, mixedProjects()); + } + + private ReleaserProperties customBom() { + ReleaserProperties properties = new ReleaserProperties(); + properties.getMetaRelease() + .setReleaseTrainDependencyNames(Collections.emptyList()); + properties.getMetaRelease() + .setReleaseTrainProjectName("spring-cloud-stream-starters"); + properties.getPom().setThisTrainBom("spring-cloud-stream-dependencies"); + return properties; + } + + Set projects() { + Set projects = new HashSet<>(); + projects.add(new Project("foo", "bar")); + return projects; + } + + Set mixedProjects() { + Set projects = new HashSet<>(); + projects.add(new Project("foo", "1.0.0.BUILD-SNAPSHOT")); + projects.add(new Project("fooBar", "1.0.0.RELEASE")); + projects.add(new Project("spring-boot", "1.0.0")); + projects.add(new Project("spring-cloud-build", "2.0.0")); + projects.add(new Project("spring-cloud-release", "Greenwich.RELEASE")); + projects.add(new Project("spring-cloud-dependencies", "Greenwich.RELEASE")); + projects.add(new Project("spring-cloud-stream-starters", "Fishtown.RELEASE")); + return projects; + } + + Properties validProps() { + Properties properties = new Properties(); + properties.setProperty("foo.version", "1.0.0"); + return properties; + } + + Properties missingProps() { + Properties properties = new Properties(); + properties.setProperty("missing.version", "1.0.0"); + return properties; + } + +} diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsTests.java deleted file mode 100644 index ab9abc4d..00000000 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsTests.java +++ /dev/null @@ -1,265 +0,0 @@ -/* - * Copyright 2013-2019 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 org.springframework.cloud.release.internal.buildsystem; - -import java.util.Collections; -import java.util.HashSet; -import java.util.Properties; -import java.util.Set; - -import org.junit.Test; - -import org.springframework.cloud.release.internal.ReleaserProperties; - -import static org.assertj.core.api.BDDAssertions.then; - -/** - * @author Marcin Grzejszczak - */ -public class VersionsTests { - - Versions versions = new Versions(new ReleaserProperties(), projects()); - - @Test - public void should_add_boot_to_versions_when_version_is_created() { - then(new Versions("1.2.3.RELEASE").projects).contains( - new Project("spring-boot", "1.2.3.RELEASE"), - new Project("spring-boot-starter-parent", "1.2.3.RELEASE"), - new Project("spring-boot-dependencies", "1.2.3.RELEASE")); - } - - @Test - public void should_return_true_when_project_is_on_the_list() { - then(this.versions.shouldBeUpdated("foo")).isTrue(); - } - - @Test - public void should_return_true_when_project_has_a_parent_suffix_and_project_is_on_the_list() { - then(this.versions.shouldBeUpdated("foo-parent")).isTrue(); - } - - @Test - public void should_return_true_when_project_has_a_dependencies_suffix_and_project_is_on_the_list() { - then(this.versions.shouldBeUpdated("foo-dependencies")).isTrue(); - } - - @Test - public void should_return_false_when_project_is_not_on_the_list() { - then(this.versions.shouldBeUpdated("missing")).isFalse(); - } - - @Test - public void should_return_version_for_present_project() { - then(this.versions.versionForProject("foo")).isEqualTo("bar"); - } - - @Test - public void should_return_empty_string_for_missing_project() { - then(this.versions.versionForProject("missing")).isEmpty(); - } - - @Test - public void should_return_true_if_properties_contains_project_key() { - then(this.versions.shouldSetProperty(validProps())).isTrue(); - } - - @Test - public void should_return_false_if_properties_does_not_contain_project_key() { - then(this.versions.shouldSetProperty(missingProps())).isFalse(); - } - - @Test - public void should_update_projects_for_boot() { - Versions versions = mixedVersions().setVersion("spring-boot", "3.0.0"); - - then(versions.versionForProject("spring-boot")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-boot-starter-parent")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-boot-dependencies")).isEqualTo("3.0.0"); - - versions = mixedVersions().setVersion("spring-boot-starter-parent", "3.0.0"); - - then(versions.versionForProject("spring-boot")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-boot-starter-parent")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-boot-dependencies")).isEqualTo("3.0.0"); - - versions = mixedVersions().setVersion("spring-boot-dependencies", "3.0.0"); - - then(versions.versionForProject("spring-boot")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-boot-starter-parent")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-boot-dependencies")).isEqualTo("3.0.0"); - } - - @Test - public void should_update_projects_for_build() { - Versions versions = mixedVersions().setVersion("spring-cloud-build", "3.0.0"); - - then(versions.versionForProject("spring-cloud-build")).isEqualTo("3.0.0"); - - versions = mixedVersions().setVersion("spring-cloud-build", "3.0.0"); - - then(versions.versionForProject("spring-cloud-dependencies-parent")) - .isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.RELEASE"); - - versions = mixedVersions().setVersion("spring-cloud-dependencies-parent", - "3.0.0"); - - then(versions.versionForProject("spring-cloud-build")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-dependencies-parent")) - .isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.RELEASE"); - } - - @Test - public void should_update_projects_for_spring_cloud_release() { - Versions versions = mixedVersions().setVersion("spring-cloud", "3.0.0"); - - then(versions.versionForProject("spring-cloud")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-release")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-starter")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-dependencies")).isEqualTo("3.0.0"); - - versions = mixedVersions().setVersion("spring-cloud-release", "3.0.0"); - - then(versions.versionForProject("spring-cloud")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-release")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-starter")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-dependencies")).isEqualTo("3.0.0"); - - versions = mixedVersions().setVersion("spring-cloud-release", "Greenwich.SR8"); - - then(versions.versionForProject("spring-cloud")).isEqualTo("Greenwich.SR8"); - then(versions.versionForProject("spring-cloud-release")) - .isEqualTo("Greenwich.SR8"); - then(versions.versionForProject("spring-cloud-starter")) - .isEqualTo("Greenwich.SR8"); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.SR8"); - - versions = mixedVersions().setVersion("spring-cloud-dependencies", - "Greenwich.SR8"); - - then(versions.versionForProject("spring-cloud")).isEqualTo("Greenwich.SR8"); - then(versions.versionForProject("spring-cloud-release")) - .isEqualTo("Greenwich.SR8"); - then(versions.versionForProject("spring-cloud-starter")) - .isEqualTo("Greenwich.SR8"); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.SR8"); - } - - @Test - public void should_update_projects_for_custom_bom_only() { - Versions versions = mixedVersions(customBom()).setVersion("spring-cloud", - "3.0.0"); - - then(versions.versionForProject("spring-cloud")).isEqualTo("3.0.0"); - then(versions.versionForProject("spring-cloud-stream-starters")) - .isEqualTo("Fishtown.RELEASE"); - then(versions.versionForProject("spring-cloud-starter")).isEmpty(); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.RELEASE"); - - versions = mixedVersions(customBom()).setVersion("spring-cloud-stream-starters", - "Fishtown.SR4"); - - then(versions.versionForProject("spring-cloud")).isEmpty(); - then(versions.versionForProject("spring-cloud-stream-starters")) - .isEqualTo("Fishtown.SR4"); - then(versions.versionForProject("spring-cloud-starter")).isEmpty(); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.RELEASE"); - - versions = mixedVersions(customBom()).setVersion("spring-cloud-release", - "Greenwich.SR8"); - - then(versions.versionForProject("spring-cloud-release")) - .isEqualTo("Greenwich.SR8"); - then(versions.versionForProject("spring-cloud-stream-starters")) - .isEqualTo("Fishtown.RELEASE"); - then(versions.versionForProject("spring-cloud")).isEmpty(); - then(versions.versionForProject("spring-cloud-starter")).isEmpty(); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.RELEASE"); - - versions = mixedVersions(customBom()).setVersion("spring-cloud-dependencies", - "Greenwich.SR8"); - - then(versions.versionForProject("spring-cloud")).isEmpty(); - then(versions.versionForProject("spring-cloud-stream-starters")) - .isEqualTo("Fishtown.RELEASE"); - then(versions.versionForProject("spring-cloud-starter")).isEmpty(); - then(versions.versionForProject("spring-cloud-dependencies")) - .isEqualTo("Greenwich.SR8"); - } - - @Test - public void should_update_projects_for_custom_project() { - Versions versions = mixedVersions().setVersion("foo", "3.0.0"); - - then(versions.versionForProject("foo")).isEqualTo("3.0.0"); - } - - private Versions mixedVersions() { - return new Versions("1.0.0", "2.0.0", mixedProjects()); - } - - private Versions mixedVersions(ReleaserProperties properties) { - return new Versions(properties, "1.0.0", "2.0.0", mixedProjects()); - } - - private ReleaserProperties customBom() { - ReleaserProperties properties = new ReleaserProperties(); - properties.getMetaRelease() - .setReleaseTrainDependencyNames(Collections.emptyList()); - properties.getMetaRelease() - .setReleaseTrainProjectName("spring-cloud-stream-starters"); - properties.getPom().setThisTrainBom("spring-cloud-stream-dependencies"); - return properties; - } - - Set projects() { - Set projects = new HashSet<>(); - projects.add(new Project("foo", "bar")); - return projects; - } - - Set mixedProjects() { - Set projects = new HashSet<>(); - projects.add(new Project("foo", "1.0.0.BUILD-SNAPSHOT")); - projects.add(new Project("fooBar", "1.0.0.RELEASE")); - projects.add(new Project("spring-cloud-release", "Greenwich.RELEASE")); - projects.add(new Project("spring-cloud-dependencies", "Greenwich.RELEASE")); - projects.add(new Project("spring-cloud-stream-starters", "Fishtown.RELEASE")); - return projects; - } - - Properties validProps() { - Properties properties = new Properties(); - properties.setProperty("foo.version", "1.0.0"); - return properties; - } - - Properties missingProps() { - Properties properties = new Properties(); - properties.setProperty("missing.version", "1.0.0"); - return properties; - } - -} diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java index c2bd585e..703cd49d 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java @@ -38,9 +38,9 @@ import org.mockito.BDDMockito; import org.springframework.cloud.release.internal.PomUpdateAcceptanceTests; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.buildsystem.GradleUpdater; +import org.springframework.cloud.release.internal.buildsystem.PomReader; import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; import org.springframework.cloud.release.internal.buildsystem.ProjectVersion; -import org.springframework.cloud.release.internal.buildsystem.TestPomReader; import org.springframework.cloud.release.internal.buildsystem.TestUtils; import org.springframework.cloud.release.internal.git.GitTestUtils; import org.springframework.cloud.release.internal.git.ProjectGitHandler; @@ -61,8 +61,6 @@ public class PostReleaseActionsTests { File temporaryFolder; - TestPomReader testPomReader = new TestPomReader(); - GradleUpdater gradleUpdater = BDDMockito.mock(GradleUpdater.class); ReleaserProperties properties = new ReleaserProperties(); @@ -143,7 +141,7 @@ public class PostReleaseActionsTests { actions.runUpdatedTests(currentGa()); - Model rootPom = this.testPomReader.readPom(new File(this.cloned, "pom.xml")); + Model rootPom = PomReader.readPom(new File(this.cloned, "pom.xml")); BDDAssertions.then(rootPom.getVersion()).isEqualTo("Finchley.SR1"); BDDAssertions.then(rootPom.getParent().getVersion()).isEqualTo("2.0.4.RELEASE"); BDDAssertions.then(sleuthParentPomVersion()).isEqualTo("2.0.4.RELEASE"); @@ -193,7 +191,7 @@ public class PostReleaseActionsTests { actions.generateReleaseTrainDocumentation(currentGa()); - Model rootPom = this.testPomReader.readPom(new File(this.cloned, "pom.xml")); + Model rootPom = PomReader.readPom(new File(this.cloned, "pom.xml")); BDDAssertions.then(rootPom.getVersion()).isEqualTo("Finchley.SR1"); BDDAssertions.then(rootPom.getParent().getVersion()).isEqualTo("2.0.4.RELEASE"); BDDAssertions.then(sleuthParentPomVersion()).isEqualTo("2.0.4.RELEASE"); @@ -252,7 +250,7 @@ public class PostReleaseActionsTests { .filter(s -> s.getKey().contains("spring-cloud-core-tests")).findFirst() .orElseThrow(() -> new IllegalStateException("Not found")); File clonedFile = entry.getValue().get(0); - Model pomWithCloud = this.testPomReader + Model pomWithCloud = PomReader .readPom(new File(clonedFile, "zuul-proxy-eureka/pom.xml")); Git git = GitTestUtils.openGitProject(clonedFile); BDDAssertions @@ -343,8 +341,8 @@ public class PostReleaseActionsTests { } private String sleuthParentPomVersion() { - return this.testPomReader.readPom(new File(this.cloned, "sleuth/pom.xml")) - .getParent().getVersion(); + return PomReader.readPom(new File(this.cloned, "sleuth/pom.xml")).getParent() + .getVersion(); } Projects currentGa() { diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFetcherTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFromBomFetcherTests.java similarity index 92% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFetcherTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFromBomFetcherTests.java index 4680a0f9..a3b8d05e 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFetcherTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFromBomFetcherTests.java @@ -33,7 +33,7 @@ import org.springframework.cloud.release.internal.buildsystem.TestUtils; import org.springframework.cloud.release.internal.project.Projects; import org.springframework.util.FileSystemUtils; -class VersionsFetcherTests { +class VersionsFromBomFetcherTests { File temporaryFolder; @@ -52,8 +52,8 @@ class VersionsFetcherTests { throws URISyntaxException { ProjectVersion projectVersion = new ProjectVersion("spring-cloud-contract", "2.5.0.RELEASE"); - URI initilizrUri = VersionsFetcherTests.class.getResource("/raw/initializr.yml") - .toURI(); + URI initilizrUri = VersionsFromBomFetcherTests.class + .getResource("/raw/initializr.yml").toURI(); ReleaserProperties properties = new ReleaserProperties(); properties.getVersions().setAllVersionsFileUrl(initilizrUri.toString()); properties.getGit().setReleaseTrainBomUrl( @@ -71,8 +71,8 @@ class VersionsFetcherTests { throws URISyntaxException { ProjectVersion projectVersion = new ProjectVersion("spring-cloud-contract", "1.0.0.RELEASE"); - URI initilizrUri = VersionsFetcherTests.class.getResource("/raw/initializr.yml") - .toURI(); + URI initilizrUri = VersionsFromBomFetcherTests.class + .getResource("/raw/initializr.yml").toURI(); ReleaserProperties properties = new ReleaserProperties(); properties.getVersions().setAllVersionsFileUrl(initilizrUri.toString()); properties.getGit().setReleaseTrainBomUrl( @@ -90,8 +90,8 @@ class VersionsFetcherTests { throws URISyntaxException { ProjectVersion projectVersion = new ProjectVersion("spring-cloud-non-existant", "1.0.0.RELEASE"); - URI initilizrUri = VersionsFetcherTests.class.getResource("/raw/initializr.yml") - .toURI(); + URI initilizrUri = VersionsFromBomFetcherTests.class + .getResource("/raw/initializr.yml").toURI(); ReleaserProperties properties = new ReleaserProperties(); properties.getVersions().setAllVersionsFileUrl(initilizrUri.toString()); properties.getGit().setReleaseTrainBomUrl( @@ -137,7 +137,8 @@ class VersionsFetcherTests { } private File localFile(String relativePath) throws URISyntaxException { - return new File(VersionsFetcherTests.class.getResource(relativePath).toURI()); + return new File( + VersionsFromBomFetcherTests.class.getResource(relativePath).toURI()); } private File file(String relativePath) { diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java index dcb452f6..cce28b6a 100644 --- a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java @@ -25,10 +25,8 @@ import org.apache.maven.model.Model; */ public class TestPomReader { - PomReader pomReader = new PomReader(); - public Model readPom(File pom) { - return this.pomReader.readPom(pom); + return PomReader.readPom(pom); } }