diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/SpringCloudConstants.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomConstants.java similarity index 65% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/SpringCloudConstants.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomConstants.java index bae04b89..299bc141 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/SpringCloudConstants.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomConstants.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 + * 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, @@ -14,22 +14,32 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.cloud.buildsystem; /** * @author Marcin Grzejszczak */ -final class SpringCloudConstants { +final class SpringCloudBomConstants { + // boot static final String SPRING_BOOT = "spring-boot"; static final String BOOT_STARTER_ARTIFACT_ID = "spring-boot-starter"; static final String BOOT_STARTER_PARENT_ARTIFACT_ID = BOOT_STARTER_ARTIFACT_ID + "-parent"; static final String BOOT_DEPENDENCIES_ARTIFACT_ID = "spring-boot-dependencies"; + + // sc-build static final String CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID = "spring-cloud-dependencies-parent"; static final String BUILD_ARTIFACT_ID = "spring-cloud-build"; - private SpringCloudConstants() { + // sc-release + static final String CLOUD_DEPENDENCIES_ARTIFACT_ID = "spring-cloud-dependencies"; + static final String CLOUD_ARTIFACT_ID = "spring-cloud"; + static final String CLOUD_RELEASE_ARTIFACT_ID = "spring-cloud-release"; + static final String CLOUD_STARTER_ARTIFACT_ID = "spring-cloud-starter"; + static final String CLOUD_STARTER_PARENT_ARTIFACT_ID = "spring-cloud-starter-parent"; + + private SpringCloudBomConstants() { 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/SpringCloudMavenBomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudMavenBomParser.java new file mode 100644 index 00000000..af60995b --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudMavenBomParser.java @@ -0,0 +1,213 @@ +/* + * 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.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.VersionsFromBom; +import org.springframework.cloud.release.internal.buildsystem.VersionsFromBomBuilder; +import org.springframework.cloud.release.internal.project.Project; +import org.springframework.cloud.release.internal.tech.PomReader; +import org.springframework.util.StringUtils; + +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.BOOT_DEPENDENCIES_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.BOOT_STARTER_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.BUILD_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.CLOUD_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.CLOUD_DEPENDENCIES_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.CLOUD_RELEASE_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.CLOUD_STARTER_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.CLOUD_STARTER_PARENT_ARTIFACT_ID; +import static org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomConstants.SPRING_BOOT; + +class SpringCloudMavenBomParser implements CustomBomParser { + + private static final Logger log = LoggerFactory + .getLogger(SpringCloudMavenBomParser.class); + + @Override + public boolean isApplicable(File root, ReleaserProperties properties, + Set projects) { + return isMaven(root) && 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); + if (log.isDebugEnabled()) { + log.debug("Added Spring Cloud Build [{}] and boot versions [{}]", + springCloudBuild, boot); + } + return new VersionsFromBomBuilder().thisProjectRoot(root) + .releaserProperties(properties).projects(springCloudBuild, boot).merged(); + } + + private VersionsFromBom springCloudBuild(File root, ReleaserProperties properties) { + String buildVersion = buildVersion(root, properties); + if (StringUtils.isEmpty(buildVersion)) { + return VersionsFromBom.EMPTY_VERSION; + } + VersionsFromBom scBuild = new VersionsFromBomBuilder().thisProjectRoot(root) + .releaserProperties(properties).merged(); + scBuild.add(BUILD_ARTIFACT_ID, buildVersion); + scBuild.add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildVersion); + return scBuild; + } + + private String buildVersion(File root, ReleaserProperties properties) { + String buildVersion = properties.getFixedVersions().get(BUILD_ARTIFACT_ID); + if (StringUtils.hasText(buildVersion)) { + return buildVersion; + } + File pom = new File(root, properties.getPom().getThisTrainBom()); + if (!pom.exists()) { + return ""; + } + 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"); + } + buildVersion = model.getParent().getVersion(); + log.debug("Spring Cloud Build version is equal to [{}]", buildVersion); + return buildVersion; + } + + private String boot(File root, ReleaserProperties properties) { + String bootVersion = properties.getFixedVersions().get(SPRING_BOOT); + if (StringUtils.hasText(bootVersion)) { + return bootVersion; + } + String pomWithBootStarterParent = properties.getPom() + .getPomWithBootStarterParent(); + File pom = new File(root, pomWithBootStarterParent); + if (!pom.exists()) { + return ""; + } + Model model = PomReader.pom(root, pomWithBootStarterParent); + if (model == null) { + return ""; + } + String bootArtifactId = model.getParent().getArtifactId(); + log.debug("Boot artifact id is equal to [{}]", bootArtifactId); + if (!SpringCloudBomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID + .equals(bootArtifactId)) { + if (log.isDebugEnabled()) { + throw new IllegalStateException("The pom doesn't have a [" + + SpringCloudBomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID + + "] artifact id"); + } + return ""; + } + return model.getParent().getVersion(); + } + + VersionsFromBom bootVersion(File root, ReleaserProperties properties) { + String bootVersion = boot(root, properties); + if (StringUtils.isEmpty(bootVersion)) { + return VersionsFromBom.EMPTY_VERSION; + } + log.debug("Boot version is equal to [{}]", bootVersion); + VersionsFromBom versionsFromBom = new VersionsFromBomBuilder() + .thisProjectRoot(root).releaserProperties(properties).merged(); + 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_ARTIFACT_ID: + 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; + case CLOUD_ARTIFACT_ID: + case CLOUD_DEPENDENCIES_ARTIFACT_ID: + case CLOUD_RELEASE_ARTIFACT_ID: + case CLOUD_STARTER_ARTIFACT_ID: + case CLOUD_STARTER_PARENT_ARTIFACT_ID: + updateSpringCloudVersions(newProjects, version); + break; + } + return newProjects; + } + + private void updateBootVersions(Set newProjects, String version) { + remove(newProjects, SPRING_BOOT); + remove(newProjects, BOOT_STARTER_ARTIFACT_ID); + remove(newProjects, BOOT_STARTER_PARENT_ARTIFACT_ID); + remove(newProjects, BOOT_DEPENDENCIES_ARTIFACT_ID); + add(newProjects, SPRING_BOOT, version); + add(newProjects, BOOT_STARTER_ARTIFACT_ID, 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 updateSpringCloudVersions(Set newProjects, String version) { + remove(newProjects, CLOUD_DEPENDENCIES_ARTIFACT_ID); + remove(newProjects, CLOUD_ARTIFACT_ID); + remove(newProjects, CLOUD_RELEASE_ARTIFACT_ID); + remove(newProjects, CLOUD_STARTER_ARTIFACT_ID); + remove(newProjects, CLOUD_STARTER_PARENT_ARTIFACT_ID); + add(newProjects, CLOUD_DEPENDENCIES_ARTIFACT_ID, version); + add(newProjects, CLOUD_ARTIFACT_ID, version); + add(newProjects, CLOUD_RELEASE_ARTIFACT_ID, version); + add(newProjects, CLOUD_STARTER_ARTIFACT_ID, version); + add(newProjects, CLOUD_STARTER_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/cloud/docs/SpringCloudCustomProjectDocumentationUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/docs/SpringCloudCustomProjectDocumentationUpdater.java new file mode 100644 index 00000000..c764ffe2 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/docs/SpringCloudCustomProjectDocumentationUpdater.java @@ -0,0 +1,160 @@ +/* + * 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.cloud.docs; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.springframework.cloud.release.internal.docs.CustomProjectDocumentationUpdater; +import org.springframework.cloud.release.internal.git.ProjectGitHandler; +import org.springframework.cloud.release.internal.project.ProjectVersion; + +/** + * @author Marcin Grzejszczak + */ +class SpringCloudCustomProjectDocumentationUpdater + implements CustomProjectDocumentationUpdater { + + private static final String HTTP_SC_STATIC_URL = "http://cloud.spring.io/spring-cloud-static/"; + + private static final String HTTPS_SC_STATIC_URL = "https://cloud.spring.io/spring-cloud-static/"; + + private static final Logger log = LoggerFactory + .getLogger(SpringCloudCustomProjectDocumentationUpdater.class); + + private final ProjectGitHandler gitHandler; + + SpringCloudCustomProjectDocumentationUpdater(ProjectGitHandler gitHandler) { + this.gitHandler = gitHandler; + } + + @Override + public boolean isApplicable(File clonedDocumentationProject, + ProjectVersion currentProject, String bomBranch) { + return clonedDocumentationProject.getName().startsWith("spring-cloud") + || currentProject.projectName.startsWith("spring-cloud"); + } + + /** + * Updates the documentation repository if current release train version is greater or + * equal than the one stored in the repo. + * @param currentProject project to update the docs repo for + * @param bomBranch the bom project branch + * @return {@link File cloned temporary directory} - {@code null} if wrong version is + * used + */ + @Override + public File updateDocsRepo(File clonedDocumentationProject, + ProjectVersion currentProject, String bomBranch) { + log.debug("Cloning the doc project to [{}]", clonedDocumentationProject); + String pathToIndexHtml = "current/index.html"; + File indexHtml = indexHtml(clonedDocumentationProject, pathToIndexHtml); + if (!indexHtml.exists()) { + throw new IllegalStateException( + "index.html is not present at [" + pathToIndexHtml + "]"); + } + return updateTheDocsRepo(bomBranch, clonedDocumentationProject, indexHtml); + } + + File indexHtml(File clonedDocumentationProject, String pathToIndexHtml) { + return new File(clonedDocumentationProject, pathToIndexHtml); + } + + private File updateTheDocsRepo(String springCloudReleaseBranch, + File documentationProject, File indexHtml) { + try { + String indexHtmlText = readIndexHtmlContents(indexHtml); + int httpIndex = indexHtmlText.indexOf(HTTP_SC_STATIC_URL); + int httpsIndex = indexHtmlText.indexOf(HTTPS_SC_STATIC_URL); + if (httpIndex == -1 && httpsIndex == -1) { + throw new IllegalStateException( + "The URL to the documentation repo not found in the index.html file"); + } + int beginIndex = beginIndex(httpIndex, httpsIndex); + String storedReleaseTrainLine = indexHtmlText.substring(beginIndex); + String storedReleaseTrain = storedReleaseTrainLine.substring(0, + storedReleaseTrainLine.indexOf("/")); + String firstLetterOfReleaseTrain = String + .valueOf(storedReleaseTrain.charAt(0)); + String currentReleaseTrainVersion = branchToReleaseVersion( + springCloudReleaseBranch); + String firstLetterOfCurrentReleaseTrain = String + .valueOf(currentReleaseTrainVersion.charAt(0)); + boolean newerOrEqualReleaseTrain = isNewerOrEqualReleaseTrain( + storedReleaseTrain, firstLetterOfReleaseTrain, + currentReleaseTrainVersion, firstLetterOfCurrentReleaseTrain); + if (!newerOrEqualReleaseTrain) { + log.info( + "Current release train [{}] is not newer than the stored one [{}]", + currentReleaseTrainVersion, storedReleaseTrain); + return documentationProject; + } + return pushCommitedChanges(currentReleaseTrainVersion, documentationProject, + indexHtml, indexHtmlText, storedReleaseTrain); + } + catch (IOException e) { + throw new IllegalStateException(e); + } + } + + boolean isNewerOrEqualReleaseTrain(String storedReleaseTrain, + String firstLetterOfReleaseTrain, String currentReleaseTrainVersion, + String firstLetterOfCurrentReleaseTrain) { + return (!storedReleaseTrain.equals(currentReleaseTrainVersion)) + && firstLetterOfCurrentReleaseTrain + .compareToIgnoreCase(firstLetterOfReleaseTrain) >= 0; + } + + private int beginIndex(int httpIndex, int httpsIndex) { + if (httpIndex != -1) { + return httpIndex + HTTP_SC_STATIC_URL.length(); + } + return httpsIndex + HTTPS_SC_STATIC_URL.length(); + } + + private String branchToReleaseVersion(String springCloudReleaseBranch) { + if (springCloudReleaseBranch.startsWith("v")) { + return springCloudReleaseBranch.substring(1); + } + return springCloudReleaseBranch; + } + + private File pushCommitedChanges(String currentReleaseTrainVersion, + File documentationProject, File indexHtml, String indexHtmlText, + String storedReleaseTrain) throws IOException { + String replacedIndexHtml = indexHtmlText.replace(storedReleaseTrain, + currentReleaseTrainVersion); + Files.write(indexHtml.toPath(), replacedIndexHtml.getBytes()); + log.info("Stored the release train [{}] in [{}]", currentReleaseTrainVersion, + indexHtml.getAbsolutePath()); + this.gitHandler.commit(documentationProject, + "Updating the link to the current version to [" + + currentReleaseTrainVersion + "]"); + this.gitHandler.pushCurrentBranch(documentationProject); + log.info("Committed and pushed changes to the documentation project"); + return documentationProject; + } + + String readIndexHtmlContents(File indexHtml) throws IOException { + return new String(Files.readAllBytes(indexHtml.toPath())); + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/Releaser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/Releaser.java index c9c4ab85..43cd075c 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/Releaser.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/Releaser.java @@ -22,15 +22,16 @@ import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.cloud.release.internal.buildsystem.GradleUpdater; +import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; import org.springframework.cloud.release.internal.docs.DocumentationUpdater; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.gradle.GradleUpdater; -import org.springframework.cloud.release.internal.pom.ProcessedProject; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.post.PostReleaseActions; -import org.springframework.cloud.release.internal.project.ProjectBuilder; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.postrelease.PostReleaseActions; +import org.springframework.cloud.release.internal.project.ProcessedProject; +import org.springframework.cloud.release.internal.project.ProjectCommandExecutor; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.sagan.SaganUpdater; import org.springframework.cloud.release.internal.tech.MakeBuildUnstableException; import org.springframework.cloud.release.internal.template.TemplateGenerator; @@ -47,14 +48,14 @@ public class Releaser implements ReleaserPropertiesAware { private static boolean SKIP_SNAPSHOT_ASSERTION = false; - private ReleaserProperties releaserProperties; - private final ProjectPomUpdater projectPomUpdater; - private final ProjectBuilder projectBuilder; + private final ProjectCommandExecutor projectCommandExecutor; private final ProjectGitHandler projectGitHandler; + private final ProjectGitHubHandler projectGitHubHandler; + private final TemplateGenerator templateGenerator; private final GradleUpdater gradleUpdater; @@ -65,16 +66,21 @@ public class Releaser implements ReleaserPropertiesAware { private final PostReleaseActions postReleaseActions; + private ReleaserProperties releaserProperties; + public Releaser(ReleaserProperties releaserProperties, - ProjectPomUpdater projectPomUpdater, ProjectBuilder projectBuilder, - ProjectGitHandler projectGitHandler, TemplateGenerator templateGenerator, - GradleUpdater gradleUpdater, SaganUpdater saganUpdater, - DocumentationUpdater documentationUpdater, + ProjectPomUpdater projectPomUpdater, + ProjectCommandExecutor projectCommandExecutor, + ProjectGitHandler projectGitHandler, + ProjectGitHubHandler projectGitHubHandler, + TemplateGenerator templateGenerator, GradleUpdater gradleUpdater, + SaganUpdater saganUpdater, DocumentationUpdater documentationUpdater, PostReleaseActions postReleaseActions) { this.releaserProperties = releaserProperties; this.projectPomUpdater = projectPomUpdater; - this.projectBuilder = projectBuilder; + this.projectCommandExecutor = projectCommandExecutor; this.projectGitHandler = projectGitHandler; + this.projectGitHubHandler = projectGitHubHandler; this.templateGenerator = templateGenerator; this.gradleUpdater = gradleUpdater; this.saganUpdater = saganUpdater; @@ -86,7 +92,7 @@ public class Releaser implements ReleaserPropertiesAware { return this.projectGitHandler.cloneProjectFromOrg(projectName); } - public Projects retrieveVersionsFromSCRelease() { + public Projects retrieveVersionsFromBom() { return this.projectPomUpdater.retrieveVersionsFromReleaseTrainBom(); } @@ -110,7 +116,7 @@ public class Releaser implements ReleaserPropertiesAware { } public void buildProject(ProjectVersion versionFromScRelease) { - this.projectBuilder.build(versionFromScRelease); + this.projectCommandExecutor.build(versionFromScRelease); log.info("\nProject was successfully built"); } @@ -120,12 +126,12 @@ public class Releaser implements ReleaserPropertiesAware { } public void deploy(ProjectVersion versionFromScRelease) { - this.projectBuilder.deploy(versionFromScRelease); + this.projectCommandExecutor.deploy(versionFromScRelease); log.info("\nThe artifact was deployed successfully"); } public void publishDocs(ProjectVersion changedVersion) { - this.projectBuilder.publishDocs(changedVersion.version); + this.projectCommandExecutor.publishDocs(changedVersion.version); log.info("\nThe docs were published successfully"); } @@ -181,7 +187,7 @@ public class Releaser implements ReleaserPropertiesAware { return; } try { - this.projectGitHandler.closeMilestone(releaseVersion); + this.projectGitHubHandler.closeMilestone(releaseVersion); log.info("\nSuccessfully closed milestone"); } catch (Exception ex) { @@ -267,7 +273,7 @@ public class Releaser implements ReleaserPropertiesAware { private Exception createIssueInSpringGuides(ProjectVersion releaseVersion, Projects projects) { try { - this.projectGitHandler.createIssueInSpringGuides(projects, releaseVersion); + this.projectGitHubHandler.createIssueInSpringGuides(projects, releaseVersion); log.info("\nSuccessfully created an issue in Spring Guides"); return null; } @@ -281,7 +287,8 @@ public class Releaser implements ReleaserPropertiesAware { private Exception createIssueInStartSpringIo(ProjectVersion releaseVersion, Projects projects) { try { - this.projectGitHandler.createIssueInStartSpringIo(projects, releaseVersion); + this.projectGitHubHandler.createIssueInStartSpringIo(projects, + releaseVersion); log.info("\nSuccessfully created an issue in start.spring.io"); return null; } 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 f0389ae8..ef71a922 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 @@ -23,6 +23,7 @@ import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; +import java.util.StringJoiner; import org.apache.commons.lang.SerializationUtils; @@ -55,6 +56,8 @@ public class ReleaserProperties implements Serializable { private Maven maven = new Maven(); + private Bash bash = new Bash(); + private Gradle gradle = new Gradle(); private Sagan sagan = new Sagan(); @@ -64,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<>(); @@ -112,6 +115,14 @@ public class ReleaserProperties implements Serializable { this.gradle = gradle; } + public Bash getBash() { + return bash; + } + + public void setBash(Bash bash) { + this.bash = bash; + } + public Map getFixedVersions() { return this.fixedVersions; } @@ -262,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"; @@ -272,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"; @@ -318,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; @@ -840,8 +851,128 @@ public class ReleaserProperties implements Serializable { } + public static class Bash implements Serializable { + + /** + * Placeholder for system properties. + */ + public static final String SYSTEM_PROPS_PLACEHOLDER = "{{systemProps}}"; + + /** + * Command to be executed to build the project. + */ + private String buildCommand = "echo \"{{systemProps}}\""; + + /** + * Command to be executed to deploy a built project. + */ + private String deployCommand = "echo \"{{systemProps}}\""; + + /** + * Command to be executed to build and deploy guides project only. + */ + private String deployGuidesCommand = "echo \"{{systemProps}}\""; + + /** + * Command to be executed to publish documentation. If present "{{version}}" will + * be replaced by the provided version. + */ + private String[] publishDocsCommands = { "mkdir -p target", + "echo \"{{version}}\"" }; + + /** + * Command to be executed to generate release train documentation. + */ + private String generateReleaseTrainDocsCommand = "echo \"{{version}}\""; + + /** + * Additional system properties that should be passed to the build / deploy + * commands. If present in other commands "{{systemProps}}" will be substituted + * with this property. + */ + private String systemProperties = ""; + + /** + * Max wait time in minutes for the process to finish. + */ + private long waitTimeInMinutes = 20; + + public String getBuildCommand() { + return this.buildCommand; + } + + public void setBuildCommand(String buildCommand) { + this.buildCommand = buildCommand; + } + + public long getWaitTimeInMinutes() { + return this.waitTimeInMinutes; + } + + public void setWaitTimeInMinutes(long waitTimeInMinutes) { + this.waitTimeInMinutes = waitTimeInMinutes; + } + + public String getDeployCommand() { + return this.deployCommand; + } + + public void setDeployCommand(String deployCommand) { + this.deployCommand = deployCommand; + } + + public String getDeployGuidesCommand() { + return this.deployGuidesCommand; + } + + public void setDeployGuidesCommand(String deployGuidesCommand) { + this.deployGuidesCommand = deployGuidesCommand; + } + + public String[] getPublishDocsCommands() { + return this.publishDocsCommands; + } + + public void setPublishDocsCommands(String[] publishDocsCommands) { + this.publishDocsCommands = publishDocsCommands; + } + + public String getGenerateReleaseTrainDocsCommand() { + return this.generateReleaseTrainDocsCommand; + } + + public void setGenerateReleaseTrainDocsCommand( + String generateReleaseTrainDocsCommand) { + this.generateReleaseTrainDocsCommand = generateReleaseTrainDocsCommand; + } + + public String getSystemProperties() { + return this.systemProperties; + } + + public void setSystemProperties(String systemProperties) { + this.systemProperties = systemProperties; + } + + @Override + public String toString() { + return "Maven{" + "buildCommand='" + this.buildCommand + '\'' + + ", deployCommand='" + this.deployCommand + '\'' + + ", publishDocsCommands=" + Arrays.toString(this.publishDocsCommands) + + "generateReleaseTrainDocsCommand='" + + this.generateReleaseTrainDocsCommand + '\'' + ", waitTimeInMinutes=" + + this.waitTimeInMinutes + '}'; + } + + } + public static class Gradle implements Serializable { + /** + * Placeholder for system properties. + */ + public static final String SYSTEM_PROPS_PLACEHOLDER = "{{systemProps}}"; + /** * A mapping that should be applied to {@code gradle.properties} in order to * perform a substitution of properties. The mapping is from a property inside @@ -872,6 +1003,101 @@ public class ReleaserProperties implements Serializable { "^.*spring-cloud-contract-maven-plugin/target/.*$", "^.*samples/standalone/[a-z]+/.*$"); + /** + * Command to be executed to build the project. + */ + private String buildCommand = "./gradlew clean build publishToMavenLocal {{systemProps}}"; + + /** + * Command to be executed to deploy a built project. + */ + private String deployCommand = "./gradlew clean build publish {{systemProps}}"; + + /** + * Command to be executed to build and deploy guides project only. + */ + private String deployGuidesCommand = "./gradlew clean build deployGuides {{systemProps}}"; + + /** + * Command to be executed to publish documentation. If present "{{version}}" will + * be replaced by the provided version. + */ + private String[] publishDocsCommands = { "echo 'TODO'" }; + + /** + * Command to be executed to generate release train documentation. + */ + private String generateReleaseTrainDocsCommand = "echo 'TODO'"; + + /** + * Additional system properties that should be passed to the build / deploy + * commands. If present in other commands "{{systemProps}}" will be substituted + * with this property. + */ + private String systemProperties = ""; + + /** + * Max wait time in minutes for the process to finish. + */ + private long waitTimeInMinutes = 20; + + public String getBuildCommand() { + return this.buildCommand; + } + + public void setBuildCommand(String buildCommand) { + this.buildCommand = buildCommand; + } + + public long getWaitTimeInMinutes() { + return this.waitTimeInMinutes; + } + + public void setWaitTimeInMinutes(long waitTimeInMinutes) { + this.waitTimeInMinutes = waitTimeInMinutes; + } + + public String getDeployCommand() { + return this.deployCommand; + } + + public void setDeployCommand(String deployCommand) { + this.deployCommand = deployCommand; + } + + public String getDeployGuidesCommand() { + return this.deployGuidesCommand; + } + + public void setDeployGuidesCommand(String deployGuidesCommand) { + this.deployGuidesCommand = deployGuidesCommand; + } + + public String[] getPublishDocsCommands() { + return this.publishDocsCommands; + } + + public void setPublishDocsCommands(String[] publishDocsCommands) { + this.publishDocsCommands = publishDocsCommands; + } + + public String getGenerateReleaseTrainDocsCommand() { + return this.generateReleaseTrainDocsCommand; + } + + public void setGenerateReleaseTrainDocsCommand( + String generateReleaseTrainDocsCommand) { + this.generateReleaseTrainDocsCommand = generateReleaseTrainDocsCommand; + } + + public String getSystemProperties() { + return this.systemProperties; + } + + public void setSystemProperties(String systemProperties) { + this.systemProperties = systemProperties; + } + public Map getGradlePropsSubstitution() { return this.gradlePropsSubstitution; } @@ -891,8 +1117,17 @@ public class ReleaserProperties implements Serializable { @Override public String toString() { - return "Gradle{" + "gradlePropsSubstitution=" + this.gradlePropsSubstitution - + ", ignoredGradleRegex=" + this.ignoredGradleRegex + '}'; + return new StringJoiner(", ", Gradle.class.getSimpleName() + "[", "]") + .add("gradlePropsSubstitution=" + gradlePropsSubstitution) + .add("ignoredGradleRegex=" + ignoredGradleRegex) + .add("buildCommand='" + buildCommand + "'") + .add("deployCommand='" + deployCommand + "'") + .add("deployGuidesCommand='" + deployGuidesCommand + "'") + .add("publishDocsCommands=" + Arrays.toString(publishDocsCommands)) + .add("generateReleaseTrainDocsCommand='" + + generateReleaseTrainDocsCommand + "'") + .add("systemProperties='" + systemProperties + "'") + .add("waitTimeInMinutes=" + waitTimeInMinutes).toString(); } } 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 new file mode 100644 index 00000000..d907f07f --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/BomParser.java @@ -0,0 +1,44 @@ +/* + * 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.List; + +/** + * Parses the bom and returns all parsed versions. + */ +public interface BomParser { + + /** + * @param clonedBom - location of the cloned BOM repository + * @return {@code true} - when this BOM parser can be applied + */ + boolean isApplicable(File clonedBom); + + /** + * @param thisProjectRoot - root of the clone project + * @return versions from BOM + */ + VersionsFromBom versionsFromBom(File thisProjectRoot); + + /** + * @return a list of available custom bom parsers + */ + List customBomParsers(); + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CompositeBomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CompositeBomParser.java new file mode 100644 index 00000000..78786326 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CompositeBomParser.java @@ -0,0 +1,53 @@ +/* + * 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.List; +import java.util.stream.Collectors; + +class CompositeBomParser implements BomParser { + + private final List parsers; + + CompositeBomParser(List parsers) { + this.parsers = parsers; + } + + @Override + public boolean isApplicable(File clonedBom) { + return this.parsers.stream().anyMatch(b -> b.isApplicable(clonedBom)); + } + + @Override + public VersionsFromBom versionsFromBom(File thisProjectRoot) { + return firstMatching(thisProjectRoot).versionsFromBom(thisProjectRoot); + } + + private BomParser firstMatching(File thisProjectRoot) { + return this.parsers.stream().filter(b -> b.isApplicable(thisProjectRoot)) + .findFirst().orElseThrow( + () -> new IllegalStateException("Can't find a matching parser")); + } + + @Override + public List customBomParsers() { + return this.parsers.stream().flatMap(b -> b.customBomParsers().stream()) + .collect(Collectors.toList()); + } + +} 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..3ba01489 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CustomBomParser.java @@ -0,0 +1,88 @@ +/* + * 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.LinkedHashSet; +import java.util.Set; + +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.project.Project; +import org.springframework.lang.Nullable; + +/** + * Allows to pass in some additional gradle files parser. + */ +public interface CustomBomParser { + + 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; + } + + }; + + /** + * 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, + @Nullable 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); + } + + default boolean isMaven(File thisProjectRoot) { + return new File(thisProjectRoot, "pom.xml").exists(); + } + + default boolean isGradle(File thisProjectRoot) { + return new File(thisProjectRoot, "build.gradle").exists(); + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/GradleBomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/GradleBomParser.java new file mode 100644 index 00000000..deb4945f --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/GradleBomParser.java @@ -0,0 +1,105 @@ +/* + * 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.io.FileInputStream; +import java.io.IOException; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.springframework.cloud.release.internal.ReleaserProperties; + +class GradleBomParser implements BomParser { + + private static final Pattern VERSION_PATTERN = Pattern + .compile("^([a-zA-Z0-9]+)Version$"); + + private final ReleaserProperties properties; + + private final List customParsers; + + GradleBomParser(ReleaserProperties releaserProperties, + List customParsers) { + this.properties = releaserProperties; + this.customParsers = customParsers; + } + + @Override + public boolean isApplicable(File clonedBom) { + return file(clonedBom, "build.gradle").exists(); + } + + File file(File clonedBom, String child) { + return new File(clonedBom, child); + } + + @Override + public VersionsFromBom versionsFromBom(File thisProjectRoot) { + File gradleProperties = file(thisProjectRoot, "gradle.properties"); + if (!gradleProperties.exists()) { + return VersionsFromBom.EMPTY_VERSION; + } + Properties properties = loadProps(gradleProperties); + final Map substitution = this.properties.getGradle() + .getGradlePropsSubstitution(); + VersionsFromBom versionsFromBom = new VersionsFromBomBuilder() + .thisProjectRoot(thisProjectRoot).releaserProperties(this.properties) + .parsers(this.customParsers).retrieveFromBom(); + properties.forEach((key, value) -> { + String projectName = projectName(substitution, key); + versionsFromBom.setVersion(projectName, value.toString()); + }); + return versionsFromBom; + } + + private String projectName(Map substitution, Object key) { + String projectName = key.toString(); + if (substitution.containsKey(key)) { + projectName = substitution.get(key); + } + else { + Matcher matcher = VERSION_PATTERN.matcher(projectName); + boolean versionMatches = matcher.matches(); + if (versionMatches) { + projectName = matcher.group(1); + } + } + projectName = projectName.replaceAll("([A-Z])", "-$1").toLowerCase(); + return projectName; + } + + Properties loadProps(File file) { + Properties props = new Properties(); + try { + props.load(new FileInputStream(file)); + } + catch (IOException e) { + throw new IllegalStateException(e); + } + return props; + } + + @Override + public List customBomParsers() { + return this.customParsers; + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/gradle/GradleUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/GradleUpdater.java similarity index 95% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/gradle/GradleUpdater.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/GradleUpdater.java index 6b0bfe5a..986ebfd1 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/gradle/GradleUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/GradleUpdater.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.gradle; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.io.FileInputStream; @@ -37,8 +37,8 @@ import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak @@ -69,10 +69,10 @@ public class GradleUpdater implements ReleaserPropertiesAware { } private void processAllGradleProps(File projectRoot, Projects projects, - ProjectVersion versionFromScRelease, boolean assertVersions) { + ProjectVersion versionFromBom, boolean assertVersions) { try { Files.walkFileTree(projectRoot.toPath(), new GradlePropertiesWalker( - this.properties, projects, versionFromScRelease, assertVersions)); + this.properties, projects, versionFromBom, assertVersions)); } catch (IOException e) { throw new IllegalStateException(e); @@ -175,6 +175,12 @@ public class GradleUpdater implements ReleaserPropertiesAware { } } + private boolean pathIgnored(File file) { + String path = file.getPath(); + return this.assertVersions && this.properties.getGradle() + .getIgnoredGradleRegex().stream().anyMatch(path::matches); + } + private Properties loadProps(File file) { Properties props = new Properties(); try { @@ -186,12 +192,6 @@ public class GradleUpdater implements ReleaserPropertiesAware { return props; } - private boolean pathIgnored(File file) { - String path = file.getPath(); - return this.assertVersions && this.properties.getGradle() - .getIgnoredGradleRegex().stream().anyMatch(path::matches); - } - private String asString(Path path) { try { return new String(Files.readAllBytes(path)); diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParser.java new file mode 100644 index 00000000..25ec023e --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParser.java @@ -0,0 +1,110 @@ +/* + * 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.List; +import java.util.Map; +import java.util.Set; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +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.project.Project; +import org.springframework.cloud.release.internal.tech.PomReader; + +/** + * Parses the poms for a given project and populates versions from a release train. + * + * @author Marcin Grzejszczak + */ +class MavenBomParser implements BomParser { + + private static final Logger log = LoggerFactory.getLogger(MavenBomParser.class); + + private final String thisTrainBomLocation; + + private final Pattern versionPattern; + + private final ReleaserProperties properties; + + private final List customParsers; + + MavenBomParser(ReleaserProperties properties, List customParsers) { + this.thisTrainBomLocation = properties.getPom().getThisTrainBom(); + this.versionPattern = Pattern.compile(properties.getPom().getBomVersionPattern()); + this.properties = properties; + this.customParsers = customParsers; + } + + @Override + public boolean isApplicable(File clonedBom) { + return new File(clonedBom, "pom.xml").exists(); + } + + // the BOM contains all versions of projects and its parent MUST be Spring Cloud + // Dependencies Parent + @Override + public VersionsFromBom versionsFromBom(File thisProjectRoot) { + Model model = PomReader.pom(thisProjectRoot, this.thisTrainBomLocation); + if (model == null) { + return VersionsFromBom.EMPTY_VERSION; + } + Set projects = model.getProperties().entrySet().stream() + .filter(propertyMatchesVersionPattern()).map(toProject()) + .collect(Collectors.toSet()); + String releaseTrainProjectVersion = model.getVersion(); + projects.add( + new Project(this.properties.getMetaRelease().getReleaseTrainProjectName(), + releaseTrainProjectVersion)); + // @formatter:off + return new VersionsFromBomBuilder() + .thisProjectRoot(thisProjectRoot) + .releaserProperties(this.properties) + .parsers(this.customParsers) + .projects(projects) + .retrieveFromBom(); + // @formatter:on + } + + private Predicate> propertyMatchesVersionPattern() { + return entry -> this.versionPattern.matcher(entry.getKey().toString()).matches(); + } + + private Function, Project> toProject() { + return entry -> { + Matcher matcher = this.versionPattern.matcher(entry.getKey().toString()); + // you have to first match to get info about the group + matcher.matches(); + String name = matcher.group(1); + return new Project(name, entry.getValue().toString()); + }; + } + + @Override + public List customBomParsers() { + return this.customParsers; + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/PomUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java similarity index 84% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/PomUpdater.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java index df4d7797..a44d21f4 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/PomUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.BufferedWriter; import java.io.File; @@ -40,6 +40,8 @@ import org.codehaus.stax2.XMLInputFactory2; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.cloud.release.internal.project.Project; +import org.springframework.cloud.release.internal.tech.PomReader; import org.springframework.util.StringUtils; import static org.springframework.util.StringUtils.hasText; @@ -52,29 +54,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 +136,25 @@ class PomUpdater { } ModelWrapper readModel(File pom) { - return new ModelWrapper(this.pomReader.readPom(pom)); + return new ModelWrapper(PomReader.readPom(pom), 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, pom); } /** @@ -159,17 +162,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 +186,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 +214,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 +230,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 +265,30 @@ class ModelWrapper { final Model model; - final Versions versions; + final VersionsFromBom versionsFromBom; final List sourceChanges = new ArrayList<>(); - ModelWrapper(Model model, List sourceChanges, Versions versions) { + final File rootFile; + + ModelWrapper(Model model, List sourceChanges, + VersionsFromBom versionsFromBom, File rootFile) { this.model = model; - this.versions = versions; + this.versionsFromBom = versionsFromBom; this.sourceChanges.addAll(sourceChanges); + this.rootFile = rootFile; + } + + ModelWrapper(Model model, File rootFile) { + this.model = model; + this.versionsFromBom = VersionsFromBom.EMPTY_VERSION; + this.rootFile = rootFile; } ModelWrapper(Model model) { this.model = model; - this.versions = Versions.EMPTY_VERSION; + this.versionsFromBom = VersionsFromBom.EMPTY_VERSION; + this.rootFile = null; } String projectName() { @@ -287,7 +304,7 @@ class ModelWrapper { boolean isDirty() { return !this.sourceChanges.isEmpty() - || this.versions.shouldSetProperty(this.model.getProperties()); + || this.versionsFromBom.shouldSetProperty(this.model.getProperties()); } } @@ -296,7 +313,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 +331,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 +366,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/pom/ProjectPomUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java similarity index 75% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProjectPomUpdater.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java index 83190709..bdf607c0 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProjectPomUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.io.IOException; @@ -38,6 +38,9 @@ import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; import org.springframework.cloud.release.internal.git.ProjectGitHandler; +import org.springframework.cloud.release.internal.project.Project; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak @@ -53,22 +56,20 @@ 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; private final PomUpdater pomUpdater = new PomUpdater(); + private final List bomParsers; + private ReleaserProperties properties; - public ProjectPomUpdater(ReleaserProperties properties) { + public ProjectPomUpdater(ReleaserProperties properties, List bomParsers) { this.properties = properties; this.gitRepo = new ProjectGitHandler(properties); - } - - ProjectPomUpdater(ReleaserProperties properties, ProjectGitHandler gitRepo) { - this.properties = properties; - this.gitRepo = gitRepo; + this.bomParsers = bomParsers; } /** @@ -92,34 +93,41 @@ 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 -> { - File clonedScRelease = this.gitRepo.cloneReleaseTrainProject(); - this.gitRepo.checkout(clonedScRelease, branch); - BomParser sCReleasePomParser = new BomParser(this.properties, - clonedScRelease); - return sCReleasePomParser.allVersions(); - }); + VersionsFromBom versionsFromBom = cachedVersionFromBom(branch); 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(); + } + + private VersionsFromBom cachedVersionFromBom(String branch) { + return CACHE.computeIfAbsent(branch, s -> { + File clonedBom = this.gitRepo.cloneReleaseTrainProject(); + this.gitRepo.checkout(clonedBom, branch); + return compositeBomParser().versionsFromBom(clonedBom); + }); + } + + private CompositeBomParser compositeBomParser() { + return new CompositeBomParser(this.bomParsers); } /** * @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 VersionsFromBomBuilder().releaserProperties(this.properties) + .parsers(compositeBomParser().customBomParsers()).projects(projects) + .merged().toProjectVersions(); } /** @@ -134,15 +142,17 @@ 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 VersionsFromBomBuilder() + .thisProjectRoot(projectRoot).releaserProperties(this.properties) + .projects(projects.asProjects()).merged(); + if (!this.pomUpdater.shouldProjectBeUpdated(projectRoot, versionsFromBom)) { log.info("Skipping project updating"); return; } - updatePoms(projectRoot, projects, versionFromReleaseTrain, assertVersions); + updatePoms(projectRoot, versionsFromBom, versionFromReleaseTrain, assertVersions); } - private void updatePoms(File projectRoot, Projects projects, + private void updatePoms(File projectRoot, VersionsFromBom projects, ProjectVersion versionFromScRelease, boolean assertVersions) { File rootPom = new File(projectRoot, "pom.xml"); if (!rootPom.exists()) { @@ -174,7 +184,7 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { private final ModelWrapper rootPom; - private final Versions versions; + private final VersionsFromBom versionsFromBom; private final PomUpdater pomUpdater; @@ -186,11 +196,11 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { private final List unacceptableVersionPatterns; - private PomWalker(ModelWrapper rootPom, Projects projects, PomUpdater pomUpdater, - ReleaserProperties properties, ProjectVersion versionFromScRelease, - boolean assertVersions) { + private PomWalker(ModelWrapper rootPom, VersionsFromBom projects, + PomUpdater pomUpdater, ReleaserProperties properties, + ProjectVersion versionFromScRelease, boolean assertVersions) { this.rootPom = rootPom; - this.versions = new Versions(projects, properties); + this.versionsFromBom = projects; this.pomUpdater = pomUpdater; this.properties = properties; List unacceptableVersionPatterns = versionFromScRelease @@ -212,13 +222,14 @@ 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( "Update is a non-snapshot one. Checking if no snapshot versions remained in the pom"); - Scanner scanner = new Scanner(asString(path)); + String text = asString(path); + Scanner scanner = new Scanner(text); int lineNumber = 0; while (scanner.hasNextLine()) { String line = scanner.nextLine(); @@ -230,6 +241,9 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware { && pattern.matcher(line).matches()) .findFirst().orElse(null); if (matchingPattern != null) { + if (log.isDebugEnabled()) { + log.debug("File text \n" + text); + } throw new IllegalStateException("The file [" + path + "] matches the [ " + matchingPattern.pattern() + "] pattern in line number [" + lineNumber + "]\n\n" 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..1fccac33 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBom.java @@ -0,0 +1,189 @@ +/* + * 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.Project; +import org.springframework.cloud.release.internal.project.ProjectVersion; +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; + + CustomBomParser parser; + + private VersionsFromBom() { + this.properties = new ReleaserProperties(); + } + + VersionsFromBom(ReleaserProperties releaserProperties, CustomBomParser parser) { + this.properties = releaserProperties; + this.parser = parser; + } + + VersionsFromBom(ReleaserProperties releaserProperties, CustomBomParser parser, + Set projects) { + this.properties = releaserProperties; + this.parser = parser; + projects.forEach(project -> setVersion(project.name, project.version)); + } + + VersionsFromBom(ReleaserProperties releaserProperties, CustomBomParser parser, + VersionsFromBom... projects) { + this.properties = releaserProperties; + this.parser = parser; + 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) { + 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)); + } + + public Set projects() { + return this.projects; + } + + @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/buildsystem/VersionsFromBomBuilder.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomBuilder.java new file mode 100644 index 00000000..106e4cab --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomBuilder.java @@ -0,0 +1,121 @@ +/* + * 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.Set; + +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.project.Project; + +public class VersionsFromBomBuilder { + + private ReleaserProperties releaserProperties; + + private Set projects = new HashSet<>(); + + private VersionsFromBom[] versionsFromBom = new VersionsFromBom[0]; + + private List parsers = new ArrayList<>(); + + private File thisProjectRoot; + + public VersionsFromBomBuilder thisProjectRoot(File thisProjectRoot) { + this.thisProjectRoot = thisProjectRoot; + return this; + } + + public VersionsFromBomBuilder releaserProperties( + ReleaserProperties releaserProperties) { + this.releaserProperties = releaserProperties; + return this; + } + + public VersionsFromBomBuilder projects(Set projects) { + this.projects = projects; + return this; + } + + public VersionsFromBomBuilder projects(VersionsFromBom... versionsFromBom) { + this.versionsFromBom = versionsFromBom; + return this; + } + + public VersionsFromBomBuilder parsers(List parsers) { + this.parsers = parsers; + return this; + } + + public VersionsFromBom merged() { + File thisProjectRoot = thisProjectRoot(); + CustomBomParser bomParser = parser(thisProjectRoot); + if (!this.projects.isEmpty()) { + return new VersionsFromBom(this.releaserProperties, bomParser, this.projects); + } + return new VersionsFromBom(this.releaserProperties, bomParser, + this.versionsFromBom); + } + + public VersionsFromBom retrieveFromBom() { + File thisProjectRoot = thisProjectRoot(); + CustomBomParser bomParser = parser(thisProjectRoot); + VersionsFromBom versionsFromBom = versionsFromBom(bomParser); + VersionsFromBom customParsing = customParsing(thisProjectRoot, this.projects); + return new VersionsFromBom(this.releaserProperties, bomParser, versionsFromBom, + customParsing); + } + + private File thisProjectRoot() { + return this.thisProjectRoot != null ? this.thisProjectRoot + : new File(this.releaserProperties.getWorkingDir()); + } + + private CustomBomParser parser(File thisProjectRoot) { + return this.parsers + .stream().filter(p -> p.isApplicable(thisProjectRoot, + this.releaserProperties, this.projects)) + .findFirst().orElse(CustomBomParser.NO_OP); + } + + private VersionsFromBom versionsFromBom(CustomBomParser bomParser) { + if (!this.projects.isEmpty()) { + return new VersionsFromBom(this.releaserProperties, bomParser, this.projects); + } + else if (this.versionsFromBom.length != 0) { + return new VersionsFromBom(this.releaserProperties, bomParser, + this.versionsFromBom); + } + return new VersionsFromBom(this.releaserProperties, bomParser); + } + + private VersionsFromBom customParsing(File thisProjectRoot, Set projects) { + return this.parsers.stream() + .filter(p -> p.isApplicable(thisProjectRoot, this.releaserProperties, + projects)) + .map(p -> p.parseBom(thisProjectRoot, this.releaserProperties)) + .reduce((versionsFromBom, + versionsFromBom2) -> new VersionsFromBomBuilder() + .parsers(this.parsers).thisProjectRoot(thisProjectRoot) + .releaserProperties(this.releaserProperties) + .projects(versionsFromBom, versionsFromBom2).merged()) + .orElse(VersionsFromBom.EMPTY_VERSION); + } + +} \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/CustomProjectDocumentationUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/CustomProjectDocumentationUpdater.java new file mode 100644 index 00000000..b0e0410e --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/CustomProjectDocumentationUpdater.java @@ -0,0 +1,68 @@ +/* + * 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.docs; + +import java.io.File; + +import org.springframework.cloud.release.internal.project.ProjectVersion; + +/** + * @author Marcin Grzejszczak + */ +public interface CustomProjectDocumentationUpdater { + + /** + * NO OP implementation of the updater. + */ + CustomProjectDocumentationUpdater NO_OP = new CustomProjectDocumentationUpdater() { + @Override + public boolean isApplicable(File clonedDocumentationProject, + ProjectVersion currentProject, String bomBranch) { + return true; + } + + @Override + public File updateDocsRepo(File clonedDocumentationProject, + ProjectVersion currentProject, String bomBranch) { + return clonedDocumentationProject; + } + }; + + /** + * Different projects can have different documentation updaters. This method will tell + * whether the current updater should be applied or not. Updates the documentation + * repository. + * @param clonedDocumentationProject path to the cloned documentation project + * @param currentProject project to update the docs repo for + * @param bomBranch the bom project branch + * @return {@code true} if the parser should be applied. + */ + boolean isApplicable(File clonedDocumentationProject, ProjectVersion currentProject, + String bomBranch); + + /** + * Updates the documentation repository. + * @param clonedDocumentationProject path to the cloned documentation project + * @param currentProject project to update the docs repo for + * @param bomBranch the bom project branch + * @return {@link File cloned temporary directory} - {@code null} if wrong version is + * used + */ + File updateDocsRepo(File clonedDocumentationProject, ProjectVersion currentProject, + String bomBranch); + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/DocumentationUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/DocumentationUpdater.java index 8c37e16a..35484bb3 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/DocumentationUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/DocumentationUpdater.java @@ -17,12 +17,13 @@ package org.springframework.cloud.release.internal.docs; import java.io.File; +import java.util.List; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.template.TemplateGenerator; /** @@ -37,10 +38,11 @@ public class DocumentationUpdater implements ReleaserPropertiesAware { private ReleaserProperties properties; public DocumentationUpdater(ProjectGitHandler gitHandler, - ReleaserProperties properties, TemplateGenerator templateGenerator) { + ReleaserProperties properties, TemplateGenerator templateGenerator, + List updaters) { this.properties = properties; - this.projectDocumentationUpdater = new ProjectDocumentationUpdater( - this.properties, gitHandler); + this.projectDocumentationUpdater = new ProjectDocumentationUpdater(properties, + gitHandler, updaters); this.releaseTrainContentsUpdater = new ReleaseTrainContentsUpdater( this.properties, gitHandler, templateGenerator); } @@ -92,8 +94,8 @@ public class DocumentationUpdater implements ReleaserPropertiesAware { @Override public void setReleaserProperties(ReleaserProperties properties) { this.properties = properties; - this.projectDocumentationUpdater.setReleaserProperties(properties); this.releaseTrainContentsUpdater.setReleaserProperties(properties); + this.projectDocumentationUpdater.setReleaserProperties(properties); } } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdater.java index 1325c52a..fef25238 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdater.java @@ -17,8 +17,7 @@ package org.springframework.cloud.release.internal.docs; import java.io.File; -import java.io.IOException; -import java.nio.file.Files; +import java.util.List; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -26,39 +25,31 @@ import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.ProjectVersion; +import org.springframework.cloud.release.internal.project.ProjectVersion; /** * @author Marcin Grzejszczak */ class ProjectDocumentationUpdater implements ReleaserPropertiesAware { - private static final String HTTP_SC_STATIC_URL = "http://cloud.spring.io/spring-cloud-static/"; - - private static final String HTTPS_SC_STATIC_URL = "https://cloud.spring.io/spring-cloud-static/"; - private static final Logger log = LoggerFactory .getLogger(ProjectDocumentationUpdater.class); private final ProjectGitHandler gitHandler; + private final List updaters; + private ReleaserProperties properties; ProjectDocumentationUpdater(ReleaserProperties properties, - ProjectGitHandler gitHandler) { + ProjectGitHandler gitHandler, + List updaters) { this.gitHandler = gitHandler; this.properties = properties; + this.updaters = updaters; } - /** - * Updates the documentation repository if current release train version is greater or - * equal than the one stored in the repo. - * @param currentProject project to update the docs repo for - * @param bomBranch the bom project branch - * @return {@link File cloned temporary directory} - {@code null} if wrong version is - * used - */ - File updateDocsRepo(ProjectVersion currentProject, String bomBranch) { + public File updateDocsRepo(ProjectVersion currentProject, String bomBranch) { if (!this.properties.getGit().isUpdateDocumentationRepo()) { log.info( "Will not update documentation repository, since the switch to do so " @@ -73,85 +64,10 @@ class ProjectDocumentationUpdater implements ReleaserPropertiesAware { } File documentationProject = this.gitHandler.cloneDocumentationProject(); log.debug("Cloning the doc project to [{}]", documentationProject); - String pathToIndexHtml = "current/index.html"; - File indexHtml = new File(documentationProject, pathToIndexHtml); - if (!indexHtml.exists()) { - throw new IllegalStateException( - "index.html is not present at [" + pathToIndexHtml + "]"); - } - return updateTheDocsRepo(bomBranch, documentationProject, indexHtml); - } - - private File updateTheDocsRepo(String springCloudReleaseBranch, - File documentationProject, File indexHtml) { - try { - String indexHtmlText = readIndexHtmlContents(indexHtml); - int httpIndex = indexHtmlText.indexOf(HTTP_SC_STATIC_URL); - int httpsIndex = indexHtmlText.indexOf(HTTPS_SC_STATIC_URL); - if (httpIndex == -1 && httpsIndex == -1) { - throw new IllegalStateException( - "The URL to the documentation repo not found in the index.html file"); - } - int beginIndex = beginIndex(httpIndex, httpsIndex); - String storedReleaseTrainLine = indexHtmlText.substring(beginIndex); - String storedReleaseTrain = storedReleaseTrainLine.substring(0, - storedReleaseTrainLine.indexOf("/")); - String firstLetterOfReleaseTrain = String - .valueOf(storedReleaseTrain.charAt(0)); - String currentReleaseTrainVersion = branchToReleaseVersion( - springCloudReleaseBranch); - String firstLetterOfCurrentReleaseTrain = String - .valueOf(currentReleaseTrainVersion.charAt(0)); - boolean newerOrEqualReleaseTrain = (!storedReleaseTrain - .equals(currentReleaseTrainVersion)) - && firstLetterOfCurrentReleaseTrain - .compareToIgnoreCase(firstLetterOfReleaseTrain) >= 0; - if (!newerOrEqualReleaseTrain) { - log.info( - "Current release train [{}] is not newer than the stored one [{}]", - currentReleaseTrainVersion, storedReleaseTrain); - return documentationProject; - } - return pushCommitedChanges(currentReleaseTrainVersion, documentationProject, - indexHtml, indexHtmlText, storedReleaseTrain); - } - catch (IOException e) { - throw new IllegalStateException(e); - } - } - - private int beginIndex(int httpIndex, int httpsIndex) { - if (httpIndex != -1) { - return httpIndex + HTTP_SC_STATIC_URL.length(); - } - return httpsIndex + HTTPS_SC_STATIC_URL.length(); - } - - private String branchToReleaseVersion(String springCloudReleaseBranch) { - if (springCloudReleaseBranch.startsWith("v")) { - return springCloudReleaseBranch.substring(1); - } - return springCloudReleaseBranch; - } - - private File pushCommitedChanges(String currentReleaseTrainVersion, - File documentationProject, File indexHtml, String indexHtmlText, - String storedReleaseTrain) throws IOException { - String replacedIndexHtml = indexHtmlText.replace(storedReleaseTrain, - currentReleaseTrainVersion); - Files.write(indexHtml.toPath(), replacedIndexHtml.getBytes()); - log.info("Stored the release train [{}] in [{}]", currentReleaseTrainVersion, - indexHtml.getAbsolutePath()); - this.gitHandler.commit(documentationProject, - "Updating the link to the current version to [" - + currentReleaseTrainVersion + "]"); - this.gitHandler.pushCurrentBranch(documentationProject); - log.info("Committed and pushed changes to the documentation project"); - return documentationProject; - } - - String readIndexHtmlContents(File indexHtml) throws IOException { - return new String(Files.readAllBytes(indexHtml.toPath())); + CustomProjectDocumentationUpdater updater = this.updaters.stream().filter( + u -> u.isApplicable(documentationProject, currentProject, bomBranch)) + .findFirst().orElse(CustomProjectDocumentationUpdater.NO_OP); + return updater.updateDocsRepo(documentationProject, currentProject, bomBranch); } @Override diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdater.java index ecf432c1..d37e667d 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdater.java @@ -33,8 +33,8 @@ import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.tech.HandlebarsHelper; import org.springframework.cloud.release.internal.template.TemplateGenerator; import org.springframework.util.StringUtils; @@ -42,6 +42,7 @@ import org.springframework.util.StringUtils; /** * @author Marcin Grzejszczak */ +// TODO: [SPRING-CLOUD] class ReleaseTrainContentsUpdater implements ReleaserPropertiesAware { private static final Logger log = LoggerFactory diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/Row.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/Row.java index f85e1e5f..b9b8d4a5 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/Row.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/docs/Row.java @@ -21,8 +21,8 @@ import java.util.List; import java.util.Objects; import java.util.stream.Collectors; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/ProjectGitHandler.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/ProjectGitHandler.java index 4bea131e..a3fa22be 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/ProjectGitHandler.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/ProjectGitHandler.java @@ -27,13 +27,12 @@ import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; import org.springframework.cloud.release.internal.tech.TemporaryFileStorage; import org.springframework.util.StringUtils; /** - * Contains business logic around Git & Github operations. + * Contains business logic around Git operations. * * @author Marcin Grzejszczak */ @@ -51,19 +50,17 @@ public class ProjectGitHandler implements ReleaserPropertiesAware { private static final String POST_RELEASE_BUMP_MSG = "Bumping versions to %s after release"; - private final GithubMilestones githubMilestones; - - private final GithubIssues githubIssues; - private ReleaserProperties properties; public ProjectGitHandler(ReleaserProperties properties) { this.properties = properties; - this.githubMilestones = new GithubMilestones(properties); - this.githubIssues = new GithubIssues(properties); registerShutdownHook(); } + static void clearCache() { + CACHE.clear(); + } + private void registerShutdownHook() { Runtime.getRuntime().addShutdownHook(new Thread(TemporaryFileStorage::cleanup)); } @@ -267,22 +264,6 @@ public class ProjectGitHandler implements ReleaserPropertiesAware { gitRepo(project).pushCurrentBranch(); } - public void closeMilestone(ProjectVersion releaseVersion) { - this.githubMilestones.closeMilestone(releaseVersion); - } - - public void createIssueInSpringGuides(Projects projects, ProjectVersion version) { - this.githubIssues.fileIssueInSpringGuides(projects, version); - } - - public void createIssueInStartSpringIo(Projects projects, ProjectVersion version) { - this.githubIssues.fileIssueInStartSpringIo(projects, version); - } - - public String milestoneUrl(ProjectVersion releaseVersion) { - return this.githubMilestones.milestoneUrl(releaseVersion); - } - public String currentBranch(File project) { return gitRepo(project).currentBranch(); } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/CachingGithub.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/CachingGithub.java similarity index 99% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/CachingGithub.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/CachingGithub.java index 834c1804..7a52bfdb 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/CachingGithub.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/CachingGithub.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.git; +package org.springframework.cloud.release.internal.github; import java.io.IOException; import java.util.Map; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/GithubIssues.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/GithubIssues.java similarity index 96% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/GithubIssues.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/GithubIssues.java index daa04a07..f4db3caa 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/GithubIssues.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/GithubIssues.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.git; +package org.springframework.cloud.release.internal.github; import java.io.IOException; import java.util.HashMap; @@ -30,8 +30,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.util.Assert; import org.springframework.util.StringUtils; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/GithubMilestones.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/GithubMilestones.java similarity index 98% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/GithubMilestones.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/GithubMilestones.java index ac3918f8..455c522f 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/git/GithubMilestones.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/GithubMilestones.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.git; +package org.springframework.cloud.release.internal.github; import java.io.IOException; import java.net.URL; @@ -32,7 +32,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; +import org.springframework.cloud.release.internal.project.ProjectVersion; import org.springframework.util.Assert; import org.springframework.util.StringUtils; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/ProjectGitHubHandler.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/ProjectGitHubHandler.java new file mode 100644 index 00000000..468ffcc5 --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/github/ProjectGitHubHandler.java @@ -0,0 +1,75 @@ +/* + * 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.github; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.ReleaserPropertiesAware; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; +import org.springframework.cloud.release.internal.tech.TemporaryFileStorage; + +/** + * Contains business logic around Github operations. + * + * @author Marcin Grzejszczak + */ +public class ProjectGitHubHandler implements ReleaserPropertiesAware { + + private static final Logger log = LoggerFactory.getLogger(ProjectGitHubHandler.class); + + private final GithubMilestones githubMilestones; + + private final GithubIssues githubIssues; + + private ReleaserProperties properties; + + public ProjectGitHubHandler(ReleaserProperties properties) { + this.properties = properties; + this.githubMilestones = new GithubMilestones(properties); + this.githubIssues = new GithubIssues(properties); + registerShutdownHook(); + } + + private void registerShutdownHook() { + Runtime.getRuntime().addShutdownHook(new Thread(TemporaryFileStorage::cleanup)); + } + + public void closeMilestone(ProjectVersion releaseVersion) { + this.githubMilestones.closeMilestone(releaseVersion); + } + + public void createIssueInSpringGuides(Projects projects, ProjectVersion version) { + this.githubIssues.fileIssueInSpringGuides(projects, version); + } + + public void createIssueInStartSpringIo(Projects projects, ProjectVersion version) { + this.githubIssues.fileIssueInStartSpringIo(projects, version); + } + + public String milestoneUrl(ProjectVersion releaseVersion) { + return this.githubMilestones.milestoneUrl(releaseVersion); + } + + @Override + public void setReleaserProperties(ReleaserProperties properties) { + this.properties = properties; + } + +} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/BomParser.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/BomParser.java deleted file mode 100644 index 642e8514..00000000 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/BomParser.java +++ /dev/null @@ -1,149 +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.pom; - -import java.io.File; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; -import java.util.function.Function; -import java.util.function.Predicate; -import java.util.regex.Matcher; -import java.util.regex.Pattern; -import java.util.stream.Collectors; - -import org.apache.maven.model.Model; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import org.springframework.cloud.release.internal.ReleaserProperties; - -import static org.springframework.cloud.release.internal.pom.SpringCloudConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID; - -/** - * Parses the poms for a given project and populates versions from a release train. - * - * @author Marcin Grzejszczak - */ -class BomParser { - - private static final Logger log = LoggerFactory.getLogger(BomParser.class); - - private final File thisProjectRoot; - - private final String pomWithBootStarterParent; - - private final String thisTrainBom; - - private final PomReader pomReader = new PomReader(); - - private final Pattern versionPattern; - - private final ReleaserProperties properties; - - BomParser(ReleaserProperties properties, File thisProjectRoot) { - this.thisProjectRoot = thisProjectRoot; - this.pomWithBootStarterParent = properties.getPom().getPomWithBootStarterParent(); - this.thisTrainBom = properties.getPom().getThisTrainBom(); - this.versionPattern = Pattern.compile(properties.getPom().getBomVersionPattern()); - this.properties = properties; - } - - Versions allVersions() { - Versions boot = bootVersion(); - Versions cloud = versionsFromBom(); - return new Versions(boot.bootVersion, cloud.scBuildVersion, - allProjects(boot, cloud)); - } - - private Set allProjects(Versions boot, Versions cloud) { - Set allProjects = new HashSet<>(); - allProjects.addAll(boot.projects); - allProjects.addAll(cloud.projects); - return allProjects; - } - - 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); - return new Versions(bootVersion); - } - - 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); - if (model == null) { - return Versions.EMPTY_VERSION; - } - 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()) - .collect(Collectors.toSet()); - String releaseTrainProjectVersion = model.getVersion(); - projects.add( - new Project(this.properties.getMetaRelease().getReleaseTrainProjectName(), - releaseTrainProjectVersion)); - return new Versions(buildVersion, projects); - } - - private Predicate> propertyMatchesSCPattern() { - return entry -> this.versionPattern.matcher(entry.getKey().toString()).matches(); - } - - private Function, Project> toProject() { - return entry -> { - Matcher matcher = this.versionPattern.matcher(entry.getKey().toString()); - // you have to first match to get info about the group - matcher.matches(); - String name = matcher.group(1); - return new Project(name, entry.getValue().toString()); - }; - } - -} diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/Versions.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/Versions.java deleted file mode 100644 index ebe915eb..00000000 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/Versions.java +++ /dev/null @@ -1,286 +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.pom; - -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 static org.springframework.cloud.release.internal.pom.SpringCloudConstants.BOOT_DEPENDENCIES_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.pom.SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.pom.SpringCloudConstants.BUILD_ARTIFACT_ID; -import static org.springframework.cloud.release.internal.pom.SpringCloudConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID; - -/** - * Represents versions taken out from Spring Cloud Release pom. - * - * @author Marcin Grzejszczak - */ -class Versions { - - static final Versions EMPTY_VERSION = new Versions(""); - - private static final String SPRING_BOOT_PROJECT_NAME = "spring-boot"; - - String bootVersion; - - String scBuildVersion; - - Set projects = new HashSet<>(); - - ReleaserProperties properties; - - Versions(String bootVersion) { - this.bootVersion = bootVersion; - add(SPRING_BOOT_PROJECT_NAME, 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(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_PROJECT_NAME, 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_PROJECT_NAME - .equals(projectVersion.projectName)) - .findFirst() - .orElse(new ProjectVersion(SPRING_BOOT_PROJECT_NAME, "")).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_PROJECT_NAME: - 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_PROJECT_NAME); - remove(BOOT_DEPENDENCIES_ARTIFACT_ID); - remove(BOOT_STARTER_PARENT_ARTIFACT_ID); - add(SPRING_BOOT_PROJECT_NAME, 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)); - } - - private void add(String key, String value) { - this.projects.add(new Project(key, value)); - } - - private 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/post/PostReleaseActions.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActions.java similarity index 92% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/post/PostReleaseActions.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActions.java index 75a533bd..82834fd2 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/post/PostReleaseActions.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActions.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.post; +package org.springframework.cloud.release.internal.postrelease; import java.io.Closeable; import java.io.File; @@ -32,13 +32,13 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.buildsystem.GradleUpdater; +import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.gradle.GradleUpdater; -import org.springframework.cloud.release.internal.pom.ProcessedProject; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.project.ProjectBuilder; +import org.springframework.cloud.release.internal.project.ProcessedProject; +import org.springframework.cloud.release.internal.project.ProjectCommandExecutor; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.versions.VersionsFetcher; import org.springframework.core.NestedExceptionUtils; import org.springframework.util.StringUtils; @@ -58,7 +58,7 @@ public class PostReleaseActions implements Closeable { private final GradleUpdater gradleUpdater; - private final ProjectBuilder projectBuilder; + private final ProjectCommandExecutor projectCommandExecutor; private final ReleaserProperties properties; @@ -66,12 +66,12 @@ public class PostReleaseActions implements Closeable { public PostReleaseActions(ProjectGitHandler projectGitHandler, ProjectPomUpdater projectPomUpdater, GradleUpdater gradleUpdater, - ProjectBuilder projectBuilder, ReleaserProperties properties, + ProjectCommandExecutor projectCommandExecutor, ReleaserProperties properties, VersionsFetcher versionsFetcher) { this.projectGitHandler = projectGitHandler; this.projectPomUpdater = projectPomUpdater; this.gradleUpdater = gradleUpdater; - this.projectBuilder = projectBuilder; + this.projectCommandExecutor = projectCommandExecutor; this.properties = properties; this.versionsFetcher = versionsFetcher; } @@ -117,7 +117,7 @@ public class PostReleaseActions implements Closeable { Projects newProjects = addVersionForTestsProject(projects, projectVersion, releaseTrainVersion); updateWithVersions(file, newProjects); - this.projectBuilder.build(projectVersion, file.getAbsolutePath()); + this.projectCommandExecutor.build(projectVersion, file.getAbsolutePath()); } /** @@ -177,8 +177,8 @@ public class PostReleaseActions implements Closeable { .map(this::getSingleResult).collect(Collectors.toList()); } - ProjectBuilder projectBuilder(ProcessedProject processedProject) { - return new ProjectBuilder(processedProject.propertiesForProject); + ProjectCommandExecutor projectBuilder(ProcessedProject processedProject) { + return new ProjectCommandExecutor(processedProject.propertiesForProject); } private Future> updateAllProjects(Projects projects, @@ -296,7 +296,7 @@ public class PostReleaseActions implements Closeable { Projects newProjects = addVersionForTestsProject(projects, projectVersion, releaseTrainVersion); updateWithVersions(file, newProjects); - this.projectBuilder.generateReleaseTrainDocs(releaseTrainVersion, + this.projectCommandExecutor.generateReleaseTrainDocs(releaseTrainVersion, file.getAbsolutePath()); } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProcessedProject.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProcessedProject.java similarity index 96% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProcessedProject.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProcessedProject.java index c4072a88..4e3004ae 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProcessedProject.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProcessedProject.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.project; import org.springframework.cloud.release.internal.ReleaserProperties; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Project.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Project.java new file mode 100644 index 00000000..15bcec9c --- /dev/null +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Project.java @@ -0,0 +1,74 @@ +/* + * 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.project; + +/** + * Represents a single project. + * + * @author Marcin Grzejszczak + */ +public class Project { + + /** + * An empty project. + */ + public static Project EMPTY_PROJECT = new Project("", ""); + + /** + * Project name. + */ + public final String name; + + /** + * Project version. + */ + 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/project/ProjectBuilder.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectCommandExecutor.java similarity index 50% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectBuilder.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectCommandExecutor.java index 6f770726..aa9c4144 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectBuilder.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectCommandExecutor.java @@ -18,6 +18,7 @@ package org.springframework.cloud.release.internal.project; import java.io.File; import java.io.IOException; +import java.io.InputStream; import java.nio.file.FileVisitResult; import java.nio.file.Files; import java.nio.file.Path; @@ -27,77 +28,75 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; +import java.util.Scanner; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.stream.Collectors; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; -import org.springframework.cloud.release.internal.pom.ProjectVersion; import org.springframework.util.StringUtils; /** * @author Marcin Grzejszczak */ -public class ProjectBuilder implements ReleaserPropertiesAware { +public class ProjectCommandExecutor implements ReleaserPropertiesAware { - /** - * Enumeration over commonly used Maven profiles. - */ - private enum Profile { - - /** - * Profile used for milestone versions. - */ - MILESTONE, - - /** - * Profile used for ga versions. - */ - CENTRAL, - - /** - * Profile used to run integration tests. - */ - INTEGRATION, - - /** - * Profile used to run guides publishing. - */ - GUIDES; - - /** - * Converts the profile to lowercase, maven command line property. - * @return profile with prepended -P - */ - public String asMavenProfile() { - return "-P" + this.name().toLowerCase(); - } - - } - - private static final Logger log = LoggerFactory.getLogger(ProjectBuilder.class); + private static final Logger log = LoggerFactory + .getLogger(ProjectCommandExecutor.class); private static final String VERSION_MUSTACHE = "{{version}}"; private ReleaserProperties properties; - public ProjectBuilder(ReleaserProperties properties) { + public ProjectCommandExecutor(ReleaserProperties properties) { this.properties = properties; } + // If you want to call commands that are not parameterized via the props + public ProjectCommandExecutor() { + this.properties = new ReleaserProperties(); + } + public void build(ProjectVersion versionFromReleaseTrain) { build(versionFromReleaseTrain, this.properties.getWorkingDir()); } + public String version() { + return executeCommand( + new CommandPicker(this.properties, this.properties.getWorkingDir()) + .version()); + } + + public String groupId() { + return executeCommand( + new CommandPicker(this.properties, this.properties.getWorkingDir()) + .groupId()); + } + + private String executeCommand(String command) { + try { + String projectRoot = this.properties.getWorkingDir(); + String[] commands = command.split(" "); + return runCommand(projectRoot, commands); + } + catch (IllegalStateException e) { + throw e; + } + catch (Exception e) { + throw new IllegalStateException(e); + } + } + public void build(ProjectVersion versionFromReleaseTrain, String projectRoot) { try { - String[] commands = commandWithSystemProps( - this.properties.getMaven().getBuildCommand(), versionFromReleaseTrain) - .split(" "); + String[] commands = new CommandPicker(this.properties, projectRoot) + .buildCommand(versionFromReleaseTrain).split(" "); runCommand(projectRoot, commands); assertNoHtmlFilesInDocsContainUnresolvedTags(projectRoot); log.info("No HTML files from docs contain unresolved tags"); @@ -109,8 +108,9 @@ public class ProjectBuilder implements ReleaserPropertiesAware { public void generateReleaseTrainDocs(String version, String projectRoot) { try { - String updatedCommand = this.properties.getMaven() - .getGenerateReleaseTrainDocsCommand() + String updatedCommand = new CommandPicker(properties, projectRoot) + .generateReleaseTrainDocsCommand( + new ProjectVersion(new File(projectRoot))) .replace(VERSION_MUSTACHE, version); runCommand(projectRoot, updatedCommand.split(" ")); assertNoHtmlFilesInDocsContainUnresolvedTags(this.properties.getWorkingDir()); @@ -121,39 +121,6 @@ public class ProjectBuilder implements ReleaserPropertiesAware { } } - private String commandWithSystemProps(String command, ProjectVersion version, - Profile... profiles) { - if (command.contains(ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER)) { - return appendProfile(command, version, profiles); - } - return appendProfile(command, version, profiles) + " " - + ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER; - } - - private String appendProfile(String command, ProjectVersion version, - Profile... profiles) { - String trimmedCommand = command.trim(); - if (version.isMilestone() || version.isRc()) { - log.info("Adding the milestone profile to the Maven build"); - return trimmedCommand + " " + Profile.MILESTONE.asMavenProfile() - + profilesToString(profiles); - } - else if (version.isRelease() || version.isServiceRelease()) { - log.info("Adding the central profile to the Maven build"); - return trimmedCommand + " " + Profile.CENTRAL.asMavenProfile() - + profilesToString(profiles); - } - else { - log.info("The build is a snapshot one - will not add any profiles"); - } - return trimmedCommand; - } - - private String profilesToString(Profile... profiles) { - return Arrays.stream(profiles).map(profile -> "-P" + profile) - .collect(Collectors.joining(" ")); - } - private void assertNoHtmlFilesInDocsContainUnresolvedTags(String workingDir) { try { File docs = new File(workingDir, "docs"); @@ -168,18 +135,18 @@ public class ProjectBuilder implements ReleaserPropertiesAware { } public void deploy(ProjectVersion version) { - doDeploy(version, this.properties.getMaven().getDeployCommand()); + doDeploy(new CommandPicker(properties, this.properties.getWorkingDir()) + .deployCommand(version)); } public void deployGuides(ProjectVersion version) { - doDeploy(version, this.properties.getMaven().getDeployGuidesCommand(), - Profile.GUIDES, Profile.INTEGRATION); + doDeploy(new CommandPicker(properties, this.properties.getWorkingDir()) + .deployGuidesCommand(version)); } - private void doDeploy(ProjectVersion version, String command, Profile... profiles) { + private void doDeploy(String command) { try { - String[] commands = commandWithSystemProps(command, version, profiles) - .split(" "); + String[] commands = command.split(" "); runCommand(commands); log.info("The project has successfully been deployed"); } @@ -192,10 +159,11 @@ public class ProjectBuilder implements ReleaserPropertiesAware { runCommand(this.properties.getWorkingDir(), commands); } - private void runCommand(String projectRoot, String[] commands) { + private String runCommand(String projectRoot, String[] commands) { String[] substitutedCommands = substituteSystemProps(commands); - long waitTimeInMinutes = this.properties.getMaven().getWaitTimeInMinutes(); - executor(projectRoot).runCommand(substitutedCommands, waitTimeInMinutes); + long waitTimeInMinutes = new CommandPicker(properties, projectRoot) + .waitTimeInMinutes(); + return executor(projectRoot).runCommand(substitutedCommands, waitTimeInMinutes); } ProcessExecutor executor(String workDir) { @@ -204,7 +172,7 @@ public class ProjectBuilder implements ReleaserPropertiesAware { public void publishDocs(String version) { try { - for (String command : this.properties.getMaven().getPublishDocsCommands()) { + for (String command : new CommandPicker(properties).publishDocsCommands()) { command = command.replace(VERSION_MUSTACHE, version); String[] commands = command.split(" "); runCommand(commands); @@ -221,10 +189,12 @@ public class ProjectBuilder implements ReleaserPropertiesAware { * just pasting the String that contains these values. */ private String[] substituteSystemProps(String... commands) { - boolean containsSystemProps = this.properties.getMaven().getSystemProperties() - .contains("-D"); - String[] splitSystemProps = StringUtils.delimitedListToStringArray( - this.properties.getMaven().getSystemProperties(), "-D"); + String systemProperties = new CommandPicker(this.properties).systemProperties(); + String systemPropertiesPlaceholder = new CommandPicker(this.properties) + .systemPropertiesPlaceholder(); + boolean containsSystemProps = systemProperties.contains("-D"); + String[] splitSystemProps = StringUtils + .delimitedListToStringArray(systemProperties, "-D"); // first element might be empty even though the second one contains values if (splitSystemProps.length > 1) { splitSystemProps = StringUtils.isEmpty(splitSystemProps[0]) @@ -237,7 +207,7 @@ public class ProjectBuilder implements ReleaserPropertiesAware { : splitSystemProps; final AtomicInteger index = new AtomicInteger(-1); for (int i = 0; i < commands.length; i++) { - if (commands[i].contains(ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER)) { + if (commands[i].contains(systemPropertiesPlaceholder)) { index.set(i); break; } @@ -282,7 +252,7 @@ class ProcessExecutor implements ReleaserPropertiesAware { this.workingDir = workingDir; } - void runCommand(String[] commands, long waitTimeInMinutes) { + String runCommand(String[] commands, long waitTimeInMinutes) { try { String workingDir = this.workingDir; log.info( @@ -302,12 +272,18 @@ class ProcessExecutor implements ReleaserPropertiesAware { throw new IllegalStateException("The process has exited with exit code [" + process.exitValue() + "]"); } + return convertStreamToString(process.getInputStream()); } catch (InterruptedException | IOException e) { throw new IllegalStateException(e); } } + private String convertStreamToString(InputStream is) { + Scanner scanner = new Scanner(is).useDelimiter("\\A"); + return scanner.hasNext() ? scanner.next() : ""; + } + Process startProcess(ProcessBuilder builder) throws IOException { return builder.start(); } @@ -323,6 +299,238 @@ class ProcessExecutor implements ReleaserPropertiesAware { } +class CommandPicker { + + private static final Log log = LogFactory.getLog(CommandPicker.class); + + private final ReleaserProperties releaserProperties; + + private final ProjectType projectType; + + CommandPicker(ReleaserProperties releaserProperties, String projectRoot) { + this.releaserProperties = releaserProperties; + this.projectType = guessProjectType(projectRoot); + } + + CommandPicker(ReleaserProperties releaserProperties) { + this.releaserProperties = releaserProperties; + String projectRoot = releaserProperties.getWorkingDir(); + this.projectType = guessProjectType(projectRoot); + } + + private ProjectType guessProjectType(String projectRoot) { + if (new File(projectRoot, "pom.xml").exists()) { + return ProjectType.MAVEN; + } + else if (new File(projectRoot, "build.gradle").exists()) { + return ProjectType.GRADLE; + } + return ProjectType.BASH; + } + + String systemProperties() { + if (projectType == ProjectType.GRADLE) { + return releaserProperties.getGradle().getSystemProperties(); + } + else if (projectType == ProjectType.MAVEN) { + return releaserProperties.getMaven().getSystemProperties(); + } + return releaserProperties.getBash().getSystemProperties(); + } + + public String[] publishDocsCommands() { + if (projectType == ProjectType.GRADLE) { + return releaserProperties.getGradle().getPublishDocsCommands(); + } + else if (projectType == ProjectType.MAVEN) { + return releaserProperties.getMaven().getPublishDocsCommands(); + } + return releaserProperties.getBash().getPublishDocsCommands(); + } + + String systemPropertiesPlaceholder() { + if (projectType == ProjectType.GRADLE) { + return ReleaserProperties.Gradle.SYSTEM_PROPS_PLACEHOLDER; + } + else if (projectType == ProjectType.MAVEN) { + return ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER; + } + return ReleaserProperties.Bash.SYSTEM_PROPS_PLACEHOLDER; + } + + String buildCommand(ProjectVersion version) { + if (projectType == ProjectType.GRADLE) { + return gradleCommandWithSystemProps( + releaserProperties.getGradle().getBuildCommand()); + } + else if (projectType == ProjectType.MAVEN) { + return mavenCommandWithSystemProps( + releaserProperties.getMaven().getBuildCommand(), version); + } + return bashCommandWithSystemProps(releaserProperties.getBash().getBuildCommand()); + } + + String version() { + // makes more sense to use PomReader + if (projectType == ProjectType.GRADLE) { + return "./gradlew properties | grep version: | awk '{print $2}'"; + } + return "./mvnw -q" + " -Dexec.executable=\"echo\"" + + " -Dexec.args=\"\\${project.version}\"" + " --non-recursive" + + " org.codehaus.mojo:exec-maven-plugin:1.3.1:exec | tail -1"; + } + + String groupId() { + // makes more sense to use PomReader + if (projectType == ProjectType.GRADLE) { + return "./gradlew groupId | tail -1"; + } + return "./mvnw -q" + " -Dexec.executable=\"echo\"" + + " -Dexec.args=\"\\${project.groupId}\"" + " --non-recursive" + + " org.codehaus.mojo:exec-maven-plugin:1.3.1:exec | tail -1"; + } + + String generateReleaseTrainDocsCommand(ProjectVersion version) { + if (projectType == ProjectType.GRADLE) { + return gradleCommandWithSystemProps( + releaserProperties.getGradle().getGenerateReleaseTrainDocsCommand()); + } + else if (projectType == ProjectType.MAVEN) { + return mavenCommandWithSystemProps( + releaserProperties.getMaven().getGenerateReleaseTrainDocsCommand(), + version); + } + return bashCommandWithSystemProps( + releaserProperties.getBash().getGenerateReleaseTrainDocsCommand()); + } + + String deployCommand(ProjectVersion version) { + if (projectType == ProjectType.GRADLE) { + return gradleCommandWithSystemProps( + releaserProperties.getGradle().getDeployCommand()); + } + else if (projectType == ProjectType.MAVEN) { + return mavenCommandWithSystemProps( + releaserProperties.getMaven().getDeployCommand(), version); + } + return bashCommandWithSystemProps( + releaserProperties.getBash().getDeployCommand()); + } + + String deployGuidesCommand(ProjectVersion version) { + if (projectType == ProjectType.GRADLE) { + return gradleCommandWithSystemProps( + releaserProperties.getGradle().getDeployGuidesCommand()); + } + else if (projectType == ProjectType.MAVEN) { + return mavenCommandWithSystemProps( + releaserProperties.getMaven().getDeployGuidesCommand(), version, + MavenProfile.GUIDES, MavenProfile.INTEGRATION); + } + return bashCommandWithSystemProps( + releaserProperties.getBash().getDeployGuidesCommand()); + } + + long waitTimeInMinutes() { + if (projectType == ProjectType.GRADLE) { + return releaserProperties.getGradle().getWaitTimeInMinutes(); + } + else if (projectType == ProjectType.MAVEN) { + return releaserProperties.getMaven().getWaitTimeInMinutes(); + } + return releaserProperties.getBash().getWaitTimeInMinutes(); + } + + private String gradleCommandWithSystemProps(String command) { + if (command.contains(ReleaserProperties.Gradle.SYSTEM_PROPS_PLACEHOLDER)) { + return command; + } + return command + " " + ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER; + } + + private String mavenCommandWithSystemProps(String command, ProjectVersion version, + MavenProfile... profiles) { + if (command.contains(ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER)) { + return appendMavenProfile(command, version, profiles); + } + return appendMavenProfile(command, version, profiles) + " " + + ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER; + } + + private String bashCommandWithSystemProps(String command) { + if (command.contains(ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER)) { + return command; + } + return command + " " + ReleaserProperties.Maven.SYSTEM_PROPS_PLACEHOLDER; + } + + private String appendMavenProfile(String command, ProjectVersion version, + MavenProfile... profiles) { + String trimmedCommand = command.trim(); + if (version.isMilestone() || version.isRc()) { + log.info("Adding the milestone profile to the Maven build"); + return trimmedCommand + " " + MavenProfile.MILESTONE.asMavenProfile() + + profilesToString(profiles); + } + else if (version.isRelease() || version.isServiceRelease()) { + log.info("Adding the central profile to the Maven build"); + return trimmedCommand + " " + MavenProfile.CENTRAL.asMavenProfile() + + profilesToString(profiles); + } + else { + log.info("The build is a snapshot one - will not add any profiles"); + } + return trimmedCommand; + } + + private String profilesToString(MavenProfile... profiles) { + return Arrays.stream(profiles).map(profile -> "-P" + profile) + .collect(Collectors.joining(" ")); + } + + private enum ProjectType { + + MAVEN, GRADLE, BASH; + + } + + /** + * Enumeration over commonly used Maven profiles. + */ + private enum MavenProfile { + + /** + * Profile used for milestone versions. + */ + MILESTONE, + + /** + * Profile used for ga versions. + */ + CENTRAL, + + /** + * Profile used to run integration tests. + */ + INTEGRATION, + + /** + * Profile used to run guides publishing. + */ + GUIDES; + + /** + * Converts the profile to lowercase, maven command line property. + * @return profile with prepended -P + */ + public String asMavenProfile() { + return "-P" + this.name().toLowerCase(); + } + + } + +} + class HtmlFileWalker extends SimpleFileVisitor { private static final String HTML_EXTENSION = ".html"; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProjectVersion.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectVersion.java similarity index 89% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProjectVersion.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectVersion.java index 9d5c8273..7dc57493 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/ProjectVersion.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/ProjectVersion.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.project; import java.io.File; import java.util.Arrays; @@ -25,6 +25,7 @@ import java.util.regex.Pattern; import org.apache.maven.model.Model; +import org.springframework.cloud.release.internal.tech.PomReader; import org.springframework.util.StringUtils; /** @@ -60,27 +61,40 @@ public class ProjectVersion implements Comparable { */ public final String version; - private final Model model; + private final String groupId; + + private final String artifactId; public ProjectVersion(String projectName, String version) { - this.projectName = nameWithoutParent(projectName); + this.projectName = projectName; this.version = version; - this.model = null; + this.groupId = ""; + this.artifactId = ""; } public ProjectVersion(File project) { if (new File(project, "build.gradle").exists()) { - ProjectVersion projectVersion = notMavenProject(project); + ProjectVersion projectVersion = gradleProject(project); this.projectName = projectVersion.projectName; this.version = projectVersion.version; - this.model = null; + this.groupId = new ProjectCommandExecutor().groupId(); + this.artifactId = projectName; } else { - PomReader pomReader = new PomReader(); - Model model = pomReader.readPom(project); - this.projectName = nameWithoutParent(model.getArtifactId()); - this.version = model.getVersion(); - this.model = model; + Model model = PomReader.readPom(project); + if (model != null) { + this.projectName = nameWithoutParent(model.getArtifactId()); + this.version = model.getVersion(); + this.groupId = groupId(model); + this.artifactId = model.getArtifactId(); + } + else { + ProjectVersion projectVersion = notMavenProject(project); + this.projectName = projectVersion.projectName; + this.version = projectVersion.version; + this.groupId = projectVersion.groupId; + this.artifactId = projectVersion.artifactId; + } } } @@ -91,6 +105,13 @@ public class ProjectVersion implements Comparable { return new ProjectVersion(nameWithoutParent(name), version); } + public static ProjectVersion gradleProject(File file) { + File parentFolder = file.getParentFile() != null ? file.getParentFile() : file; + String name = parentFolder.getName(); + String version = new ProjectCommandExecutor().version(); + return new ProjectVersion(nameWithoutParent(name), version); + } + private static String nameWithoutParent(String projectName) { boolean containsParent = projectName.endsWith("-parent"); if (!containsParent) { @@ -99,6 +120,20 @@ public class ProjectVersion implements Comparable { return projectName.substring(0, projectName.indexOf("-parent")); } + private String groupId(Model model) { + if (model == null) { + return ""; + } + if (StringUtils.hasText(model.getGroupId())) { + return model.getGroupId(); + } + if (model.getParent() != null + && StringUtils.hasText(model.getParent().getGroupId())) { + return model.getParent().getGroupId(); + } + return ""; + } + public String bumpedVersion() { return bumpedVersion(assertVersion()).print(); } @@ -192,17 +227,7 @@ public class ProjectVersion implements Comparable { } public String groupId() { - if (this.model == null) { - return ""; - } - if (StringUtils.hasText(this.model.getGroupId())) { - return this.model.getGroupId(); - } - if (this.model.getParent() != null - && StringUtils.hasText(this.model.getParent().getGroupId())) { - return this.model.getParent().getGroupId(); - } - return ""; + return this.groupId; } public boolean isValid() { @@ -363,13 +388,6 @@ public class ProjectVersion implements Comparable { assertIfValid(); } - private void assertIfValid() { - if (isInvalid()) { - throw new IllegalStateException( - "Version is invalid. Should be of format [1.2.3.A] / [1.2.3-A] or [A.B] / [A-B]"); - } - } - // Hoxton.RELEASE // Hoxton-RELEASE private SplitVersion(String major, String delimiter, String suffix) { @@ -385,6 +403,39 @@ public class ProjectVersion implements Comparable { assertIfValid(); } + private static String orDefault(String[] args, int argIndex) { + return args.length > argIndex ? args[argIndex] : ""; + } + + static SplitVersion hyphen(String major, String suffix) { + return new SplitVersion(major, HYPHEN, suffix); + } + + static SplitVersion hyphen(String[] args) { + return version(args, HYPHEN); + } + + static SplitVersion dot(String[] args) { + return version(args, DOT); + } + + private static SplitVersion version(String[] args, String delimiter) { + if (args.length == 2) { + return new SplitVersion(args[0], "", "", delimiter, args[1]); + } + else if (args.length == 3) { + return new SplitVersion(args[0], args[1], "", delimiter, args[2]); + } + return new SplitVersion(args, delimiter); + } + + private void assertIfValid() { + if (isInvalid()) { + throw new IllegalStateException( + "Version is invalid. Should be of format [1.2.3.A] / [1.2.3-A] or [A.B] / [A-B]"); + } + } + private boolean isInvalid() { return wrongReleaseTrainVersion() || wrongLibraryVersion() || wrongDelimiter() || noSuffix(); @@ -442,32 +493,6 @@ public class ProjectVersion implements Comparable { BUILD_SNAPSHOT_SUFFIX); } - private static String orDefault(String[] args, int argIndex) { - return args.length > argIndex ? args[argIndex] : ""; - } - - static SplitVersion hyphen(String major, String suffix) { - return new SplitVersion(major, HYPHEN, suffix); - } - - static SplitVersion hyphen(String[] args) { - return version(args, HYPHEN); - } - - static SplitVersion dot(String[] args) { - return version(args, DOT); - } - - private static SplitVersion version(String[] args, String delimiter) { - if (args.length == 2) { - return new SplitVersion(args[0], "", "", delimiter, args[1]); - } - else if (args.length == 3) { - return new SplitVersion(args[0], args[1], "", delimiter, args[2]); - } - return new SplitVersion(args, delimiter); - } - } } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/Projects.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java similarity index 95% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/Projects.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java index b082caf8..5c1811fc 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/Projects.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.project; import java.io.File; import java.util.Arrays; @@ -151,6 +151,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/java/org/springframework/cloud/release/internal/sagan/SaganUpdater.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/sagan/SaganUpdater.java index d11d8e87..bb11fd38 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/sagan/SaganUpdater.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/sagan/SaganUpdater.java @@ -28,7 +28,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; +import org.springframework.cloud.release.internal.project.ProjectVersion; import org.springframework.util.StringUtils; /** diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/PomReader.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/tech/PomReader.java similarity index 71% rename from spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/PomReader.java rename to spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/tech/PomReader.java index 4b16b32e..e7e6e0ba 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/pom/PomReader.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/tech/PomReader.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.tech; import java.io.File; import java.io.FileReader; @@ -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/template/BlogTemplateGenerator.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/BlogTemplateGenerator.java index 3b068f50..e8170dad 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/BlogTemplateGenerator.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/BlogTemplateGenerator.java @@ -27,8 +27,8 @@ import com.google.common.collect.ImmutableMap; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak @@ -55,7 +55,7 @@ class BlogTemplateGenerator { private final NotesGenerator notesGenerator; BlogTemplateGenerator(Template template, String releaseVersion, File blogOutput, - Projects projects, ProjectGitHandler handler) { + Projects projects, ProjectGitHubHandler handler) { this.template = template; this.releaseVersion = releaseVersion; this.blogOutput = blogOutput; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/NotesGenerator.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/NotesGenerator.java index 71208c2d..83c83913 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/NotesGenerator.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/NotesGenerator.java @@ -20,8 +20,8 @@ import java.util.Arrays; import java.util.Set; import java.util.stream.Collectors; -import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.util.StringUtils; /** @@ -29,9 +29,9 @@ import org.springframework.util.StringUtils; */ class NotesGenerator { - private final ProjectGitHandler handler; + private final ProjectGitHubHandler handler; - NotesGenerator(ProjectGitHandler handler) { + NotesGenerator(ProjectGitHubHandler handler) { this.handler = handler; } diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/ReleaseNotesTemplateGenerator.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/ReleaseNotesTemplateGenerator.java index 206a5109..ebb30bfe 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/ReleaseNotesTemplateGenerator.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/ReleaseNotesTemplateGenerator.java @@ -25,20 +25,15 @@ import java.util.Map; import com.github.jknack.handlebars.Template; import com.google.common.collect.ImmutableMap; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak */ class ReleaseNotesTemplateGenerator { - private static final Logger log = LoggerFactory - .getLogger(ReleaseNotesTemplateGenerator.class); - private final Template template; private final String releaseVersion; @@ -50,7 +45,7 @@ class ReleaseNotesTemplateGenerator { private final NotesGenerator notesGenerator; ReleaseNotesTemplateGenerator(Template template, String releaseVersion, - File blogOutput, Projects projects, ProjectGitHandler handler) { + File blogOutput, Projects projects, ProjectGitHubHandler handler) { this.template = template; this.releaseVersion = releaseVersion; this.blogOutput = blogOutput; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/TemplateGenerator.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/TemplateGenerator.java index 70db2400..dce216dc 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/TemplateGenerator.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/template/TemplateGenerator.java @@ -23,8 +23,8 @@ import com.github.jknack.handlebars.Template; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; -import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.tech.HandlebarsHelper; /** @@ -48,11 +48,11 @@ public class TemplateGenerator implements ReleaserPropertiesAware { private final File releaseNotesOutput; - private final ProjectGitHandler handler; + private final ProjectGitHubHandler handler; private ReleaserProperties props; - public TemplateGenerator(ReleaserProperties props, ProjectGitHandler handler) { + public TemplateGenerator(ReleaserProperties props, ProjectGitHubHandler handler) { this.props = props; this.handler = handler; this.emailOutput = new File("target/email.txt"); @@ -61,7 +61,8 @@ public class TemplateGenerator implements ReleaserPropertiesAware { this.releaseNotesOutput = new File("target/notes.md"); } - TemplateGenerator(ReleaserProperties props, File output, ProjectGitHandler handler) { + TemplateGenerator(ReleaserProperties props, File output, + ProjectGitHubHandler handler) { this.props = props; this.emailOutput = output; this.blogOutput = output; diff --git a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/versions/VersionsFetcher.java b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/versions/VersionsFetcher.java index 4787a79a..7a2093db 100644 --- a/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/versions/VersionsFetcher.java +++ b/spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/versions/VersionsFetcher.java @@ -38,9 +38,9 @@ import org.springframework.boot.context.properties.bind.Binder; import org.springframework.boot.context.properties.source.MapConfigurationPropertySource; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.core.io.InputStreamResource; import org.springframework.util.StringUtils; @@ -54,12 +54,12 @@ public class VersionsFetcher implements ReleaserPropertiesAware { private static final Logger log = LoggerFactory.getLogger(VersionsFetcher.class); - private ReleaserProperties properties; - private final ProjectPomUpdater projectPomUpdater; private final ToPropertiesConverter toPropertiesConverter; + private ReleaserProperties properties; + public VersionsFetcher(ReleaserProperties properties, ProjectPomUpdater projectPomUpdater) { this.properties = properties; diff --git a/spring-cloud-release-tools-core/src/main/resources/templates/cloud/blog.hbs b/spring-cloud-release-tools-core/src/main/resources/templates/cloud/blog.hbs index 6777775a..d3aff91c 100644 --- a/spring-cloud-release-tools-core/src/main/resources/templates/cloud/blog.hbs +++ b/spring-cloud-release-tools-core/src/main/resources/templates/cloud/blog.hbs @@ -2,16 +2,17 @@ On behalf of the community, I am pleased to announce that the {{ availability }} ## Notable Changes in the {{ releaseName }} Release Train {{#each projects}} -### {{ name }} + ### {{ name }} -Some text related to project + Some text related to project {{/each}} The following modules were updated as part of {{ releaseVersion }}: -| Module | Version | Issues -|--- |--- |--- |--- -{{#each projects}}| {{name}} | {{version}} | {{#if closedMilestoneUrl}}([issues]({{{ closedMilestoneUrl }}})){{/if}}{{^closedMilestoneUrl}} {{/closedMilestoneUrl}} +| Module | Version | Issues +|--- |--- |--- |--- +{{#each projects}}| {{name}} | {{version}} | {{#if + closedMilestoneUrl}}([issues]({{{ closedMilestoneUrl }}})){{/if}}{{^closedMilestoneUrl}} {{/closedMilestoneUrl}} {{/each}} As always, we welcome feedback on [GitHub](https://github.com/spring-cloud/), on [Gitter](https://gitter.im/spring-cloud/spring-cloud), on [Stack Overflow](https://stackoverflow.com/questions/tagged/spring-cloud), or on [Twitter](https://twitter.com/SpringCloud). @@ -19,16 +20,17 @@ As always, we welcome feedback on [GitHub](https://github.com/spring-cloud/), on To get started with Maven with a BOM (dependency management only): ``` -{{#if nonRelease}} - - spring-milestones - Spring Milestones - https://repo.spring.io/milestone - - false - - -{{/if}} +{{#if nonRelease}} + + + spring-milestones + Spring Milestones + https://repo.spring.io/milestone + + false + + + {{/if}} @@ -57,28 +59,28 @@ or with Gradle: ``` buildscript { - dependencies { - classpath "io.spring.gradle:dependency-management-plugin:1.0.2.RELEASE" - } +dependencies { +classpath "io.spring.gradle:dependency-management-plugin:1.0.2.RELEASE" +} } {{#if nonRelease}}repositories { - maven { - url 'https://repo.spring.io/milestone' - } +maven { +url 'https://repo.spring.io/milestone' +} }{{/if}} apply plugin: "io.spring.dependency-management" dependencyManagement { - imports { - mavenBom 'org.springframework.cloud:spring-cloud-dependencies:{{ releaseVersion }}' - } +imports { +mavenBom 'org.springframework.cloud:spring-cloud-dependencies:{{ releaseVersion }}' +} } dependencies { - compile 'org.springframework.cloud:spring-cloud-starter-config' - compile 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client' - ... +compile 'org.springframework.cloud:spring-cloud-starter-config' +compile 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client' +... } ``` diff --git a/spring-cloud-release-tools-core/src/main/resources/templates/cloud/spring-project.hbs b/spring-cloud-release-tools-core/src/main/resources/templates/cloud/spring-project.hbs index b59e2769..6e45b488 100644 --- a/spring-cloud-release-tools-core/src/main/resources/templates/cloud/spring-project.hbs +++ b/spring-cloud-release-tools-core/src/main/resources/templates/cloud/spring-project.hbs @@ -5,15 +5,15 @@ title: Spring Cloud badges: - # Customize your project's badges. Delete any entries that do not apply. - custom: - - name: Source (GitHub) - url: https://github.com/spring-cloud - icon: github +# Customize your project's badges. Delete any entries that do not apply. +custom: +- name: Source (GitHub) +url: https://github.com/spring-cloud +icon: github - - name: StackOverflow - url: https://stackoverflow.com/questions/tagged/spring-cloud - icon: stackoverflow +- name: StackOverflow +url: https://stackoverflow.com/questions/tagged/spring-cloud +icon: stackoverflow --- @@ -42,7 +42,7 @@ Spring Cloud builds on Spring Boot by providing a bunch of libraries that enhance the behaviour of an application when added to the classpath. You can take advantage of the basic default behaviour to get started really quickly, and then when you need to, you can -configure or extend to create a custom solution. +configure or extend to create a custom solution. @@ -59,7 +59,8 @@ and eureka (change the artifact ids to pull in other starters): ## Features -Spring Cloud focuses on providing good out of box experience for typical use cases and extensibility mechanism to cover others. +Spring Cloud focuses on providing good out of box experience for typical use cases and extensibility mechanism to cover +others. * Distributed/versioned configuration * Service registration and discovery @@ -79,9 +80,9 @@ annotation. Example application that is a discovery client: @SpringBootApplication @EnableDiscoveryClient public class Application { - public static void main(String[] args) { - SpringApplication.run(Application.class, args); - } +public static void main(String[] args) { +SpringApplication.run(Application.class, args); +} } ``` @@ -91,119 +92,160 @@ public class Application { {% capture project_description %} -Centralized external configuration management backed by a git repository. The configuration resources map directly to Spring `Environment` but could be used by non-Spring applications if desired. +Centralized external configuration management backed by a git repository. The configuration resources map directly to +Spring `Environment` but could be used by non-Spring applications if desired. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-config" repo_url="https://github.com/spring-cloud/spring-cloud-config" project_title="Spring Cloud Config" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-config" +repo_url="https://github.com/spring-cloud/spring-cloud-config" project_title="Spring Cloud Config" +project_description=project_description %} {% capture project_description %} Integration with various Netflix OSS components (Eureka, Hystrix, Zuul, Archaius, etc.). {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-netflix" repo_url="https://github.com/spring-cloud/spring-cloud-netflix" project_title="Spring Cloud Netflix" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-netflix" +repo_url="https://github.com/spring-cloud/spring-cloud-netflix" project_title="Spring Cloud Netflix" +project_description=project_description %} {% capture project_description %} -An event bus for linking services and service instances together with distributed messaging. Useful for propagating state changes across a cluster (e.g. config change events). +An event bus for linking services and service instances together with distributed messaging. Useful for propagating +state changes across a cluster (e.g. config change events). {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-bus" repo_url="https://github.com/spring-cloud/spring-cloud-bus" project_title="Spring Cloud Bus" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-bus" +repo_url="https://github.com/spring-cloud/spring-cloud-bus" project_title="Spring Cloud Bus" +project_description=project_description %} {% capture project_description %} -Integrates your application with Pivotal Cloud Foundry. Provides a service discovery implementation and also makes it easy to implement SSO and OAuth2 protected resources. +Integrates your application with Pivotal Cloud Foundry. Provides a service discovery implementation and also makes it +easy to implement SSO and OAuth2 protected resources. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-cloudfoundry" repo_url="https://github.com/spring-cloud/spring-cloud-cloudfoundry" project_title="Spring Cloud for Cloud Foundry" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-cloudfoundry" +repo_url="https://github.com/spring-cloud/spring-cloud-cloudfoundry" project_title="Spring Cloud for Cloud Foundry" +project_description=project_description %} {% capture project_description %} Provides a starting point for building a service broker that implements the Open Service Broker API. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-open-service-broker/" repo_url="https://github.com/spring-cloud/spring-cloud-open-service-broker" project_title="Spring Cloud Open Service Broker" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-open-service-broker/" +repo_url="https://github.com/spring-cloud/spring-cloud-open-service-broker" project_title="Spring Cloud Open Service +Broker" project_description=project_description %} {% capture project_description %} -Leadership election and common stateful patterns with an abstraction and implementation for Zookeeper, Redis, Hazelcast, Consul. +Leadership election and common stateful patterns with an abstraction and implementation for Zookeeper, Redis, Hazelcast, +Consul. {% endcapture %} -{% include project_block.md site_url="/spring-cloud" repo_url="https://github.com/spring-cloud/spring-cloud-cluster" project_title="Spring Cloud Cluster" project_description=project_description %} +{% include project_block.md site_url="/spring-cloud" repo_url="https://github.com/spring-cloud/spring-cloud-cluster" +project_title="Spring Cloud Cluster" project_description=project_description %} {% capture project_description %} Service discovery and configuration management with Hashicorp Consul. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-consul" repo_url="https://github.com/spring-cloud/spring-cloud-consul" project_title="Spring Cloud Consul" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-consul" +repo_url="https://github.com/spring-cloud/spring-cloud-consul" project_title="Spring Cloud Consul" +project_description=project_description %} {% capture project_description %} Provides support for load-balanced OAuth2 rest client and authentication header relays in a Zuul proxy. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-security" repo_url="https://github.com/spring-cloud/spring-cloud-security" project_title="Spring Cloud Security" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-security" +repo_url="https://github.com/spring-cloud/spring-cloud-security" project_title="Spring Cloud Security" +project_description=project_description %} {% capture project_description %} Distributed tracing for Spring Cloud applications, compatible with Zipkin, HTrace and log-based (e.g. ELK) tracing. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-sleuth" repo_url="https://github.com/spring-cloud/spring-cloud-sleuth" project_title="Spring Cloud Sleuth" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-sleuth" +repo_url="https://github.com/spring-cloud/spring-cloud-sleuth" project_title="Spring Cloud Sleuth" +project_description=project_description %} {% capture project_description %} -A cloud-native orchestration service for composable microservice applications on modern runtimes. Easy-to-use DSL, drag-and-drop GUI, and REST-APIs together simplifies the overall orchestration of microservice based data pipelines. +A cloud-native orchestration service for composable microservice applications on modern runtimes. Easy-to-use DSL, +drag-and-drop GUI, and REST-APIs together simplifies the overall orchestration of microservice based data pipelines. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-dataflow" repo_url="https://github.com/spring-cloud/spring-cloud-dataflow" project_title="Spring Cloud Data Flow" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-dataflow" +repo_url="https://github.com/spring-cloud/spring-cloud-dataflow" project_title="Spring Cloud Data Flow" +project_description=project_description %} {% capture project_description %} -A lightweight event-driven microservices framework to quickly build applications that can connect to external systems. Simple declarative model to send and receive messages using Apache Kafka or RabbitMQ between Spring Boot apps. +A lightweight event-driven microservices framework to quickly build applications that can connect to external systems. +Simple declarative model to send and receive messages using Apache Kafka or RabbitMQ between Spring Boot apps. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-stream" repo_url="https://github.com/spring-cloud/spring-cloud-stream" project_title="Spring Cloud Stream" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-stream" +repo_url="https://github.com/spring-cloud/spring-cloud-stream" project_title="Spring Cloud Stream" +project_description=project_description %} {% capture project_description %} -Spring Cloud Stream App Starters are Spring Boot based Spring Integration applications that provide integration with external systems. +Spring Cloud Stream App Starters are Spring Boot based Spring Integration applications that provide integration with +external systems. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-stream-app-starters" repo_url="https://github.com/spring-cloud/spring-cloud-stream-app-starters" project_title="Spring Cloud Stream App Starters" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-stream-app-starters" +repo_url="https://github.com/spring-cloud/spring-cloud-stream-app-starters" project_title="Spring Cloud Stream App +Starters" project_description=project_description %} {% capture project_description %} -A short-lived microservices framework to quickly build applications that perform finite amounts of data processing. Simple declarative for adding both functional and non-functional features to Spring Boot apps. +A short-lived microservices framework to quickly build applications that perform finite amounts of data processing. +Simple declarative for adding both functional and non-functional features to Spring Boot apps. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-task" repo_url="https://github.com/spring-cloud/spring-cloud-task" project_title="Spring Cloud Task" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-task" +repo_url="https://github.com/spring-cloud/spring-cloud-task" project_title="Spring Cloud Task" +project_description=project_description %} {% capture project_description %} -Spring Cloud Task App Starters are Spring Boot applications that may be any process including Spring Batch jobs that do not run forever, and they end/stop after a finite period of data processing. +Spring Cloud Task App Starters are Spring Boot applications that may be any process including Spring Batch jobs that do +not run forever, and they end/stop after a finite period of data processing. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-task-app-starters" repo_url="https://github.com/spring-cloud/spring-cloud-task-app-starters" project_title="Spring Cloud Task App Starters" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-task-app-starters" +repo_url="https://github.com/spring-cloud/spring-cloud-task-app-starters" project_title="Spring Cloud Task App Starters" +project_description=project_description %} {% capture project_description %} Service discovery and configuration management with Apache Zookeeper. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-zookeeper" repo_url="https://github.com/spring-cloud/spring-cloud-zookeeper" project_title="Spring Cloud Zookeeper" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-zookeeper" +repo_url="https://github.com/spring-cloud/spring-cloud-zookeeper" project_title="Spring Cloud Zookeeper" +project_description=project_description %} {% capture project_description %} -Easy integration with hosted Amazon Web Services. It offers a convenient way to interact with AWS provided services using well-known Spring idioms and APIs, such as the messaging or caching API. Developers can build their application around the hosted services without having to care about infrastructure or maintenance. +Easy integration with hosted Amazon Web Services. It offers a convenient way to interact with AWS provided services +using well-known Spring idioms and APIs, such as the messaging or caching API. Developers can build their application +around the hosted services without having to care about infrastructure or maintenance. {% endcapture %} {% capture site_url %} {{ site.projects_site_url }}/spring-cloud-aws {% endcapture %} -{% include project_block.md site_url=site_url repo_url="https://github.com/spring-cloud/spring-cloud-aws" project_title="Spring Cloud for Amazon Web Services" project_description=project_description %} +{% include project_block.md site_url=site_url repo_url="https://github.com/spring-cloud/spring-cloud-aws" +project_title="Spring Cloud for Amazon Web Services" project_description=project_description %} {% capture project_description %} @@ -215,57 +257,77 @@ databases and message brokers (the project formerly known as "Spring Cloud"). {{ site.projects_site_url }}/spring-cloud-connectors {% endcapture %} -{% include project_block.md site_url=site_url repo_url="https://github.com/spring-cloud/spring-cloud-connectors" project_title="Spring Cloud Connectors" project_description=project_description %} +{% include project_block.md site_url=site_url repo_url="https://github.com/spring-cloud/spring-cloud-connectors" +project_title="Spring Cloud Connectors" project_description=project_description %} {% capture project_description %} -Spring Boot-style starter projects to ease dependency management for consumers of Spring Cloud. (Discontinued as a project and merged with the other projects after Angel.SR2.) +Spring Boot-style starter projects to ease dependency management for consumers of Spring Cloud. (Discontinued as a +project and merged with the other projects after Angel.SR2.) {% endcapture %} -{% include project_block.md site_url="https://github.com/spring-cloud/spring-cloud-starters" repo_url="https://github.com/spring-cloud/spring-cloud-starters" project_title="Spring Cloud Starters" project_description=project_description %} +{% include project_block.md site_url="https://github.com/spring-cloud/spring-cloud-starters" +repo_url="https://github.com/spring-cloud/spring-cloud-starters" project_title="Spring Cloud Starters" +project_description=project_description %} {% capture project_description %} Spring Boot CLI plugin for creating Spring Cloud component applications quickly in Groovy {% endcapture %} -{% include project_block.md site_url="https://github.com/spring-cloud/spring-cloud-cli" repo_url="https://github.com/spring-cloud/spring-cloud-cli" project_title="Spring Cloud CLI" project_description=project_description %} - +{% include project_block.md site_url="https://github.com/spring-cloud/spring-cloud-cli" +repo_url="https://github.com/spring-cloud/spring-cloud-cli" project_title="Spring Cloud CLI" +project_description=project_description %} + {% capture project_description %} -Spring Cloud Contract is an umbrella project holding solutions that help users in successfully implementing the Consumer Driven Contracts approach. +Spring Cloud Contract is an umbrella project holding solutions that help users in successfully implementing the Consumer +Driven Contracts approach. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-contract" repo_url="https://github.com/spring-cloud/spring-cloud-contract" project_title="Spring Cloud Contract" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-contract" +repo_url="https://github.com/spring-cloud/spring-cloud-contract" project_title="Spring Cloud Contract" +project_description=project_description %} {% capture project_description %} Spring Cloud Gateway is an intelligent and programmable router based on Project Reactor. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-gateway" repo_url="https://github.com/spring-cloud/spring-cloud-gateway" project_title="Spring Cloud Gateway" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-gateway" +repo_url="https://github.com/spring-cloud/spring-cloud-gateway" project_title="Spring Cloud Gateway" +project_description=project_description %} {% capture project_description %} -Spring Cloud OpenFeign provides integrations for Spring Boot apps through autoconfiguration and binding to the Spring Environment and other Spring programming model idioms. +Spring Cloud OpenFeign provides integrations for Spring Boot apps through autoconfiguration and binding to the Spring +Environment and other Spring programming model idioms. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-openfeign" repo_url="https://github.com/spring-cloud/spring-cloud-openfeign" project_title="Spring Cloud OpenFeign" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-openfeign" +repo_url="https://github.com/spring-cloud/spring-cloud-openfeign" project_title="Spring Cloud OpenFeign" +project_description=project_description %} {% capture project_description %} -Spring Cloud Pipelines provides an opinionated deployment pipeline with steps to ensure that your application can be deployed in zero downtime fashion and easilly rolled back of something goes wrong. +Spring Cloud Pipelines provides an opinionated deployment pipeline with steps to ensure that your application can be +deployed in zero downtime fashion and easilly rolled back of something goes wrong. {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-pipelines" repo_url="https://github.com/spring-cloud/spring-cloud-pipelines" project_title="Spring Cloud Pipelines" project_description=project_description %} +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-pipelines" +repo_url="https://github.com/spring-cloud/spring-cloud-pipelines" project_title="Spring Cloud Pipelines" +project_description=project_description %} {% capture project_description %} -Spring Cloud Function promotes the implementation of business logic via functions. It supports a uniform programming model across serverless providers, as well as the ability to run standalone (locally or in a PaaS). +Spring Cloud Function promotes the implementation of business logic via functions. It supports a uniform programming +model across serverless providers, as well as the ability to run standalone (locally or in a PaaS). {% endcapture %} -{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-function" repo_url="https://github.com/spring-cloud/spring-cloud-function" project_title="Spring Cloud Function" project_description=project_description %} - +{% include project_block.md site_url="https://cloud.spring.io/spring-cloud-function" +repo_url="https://github.com/spring-cloud/spring-cloud-function" project_title="Spring Cloud Function" +project_description=project_description %} + ## Release Trains Spring Cloud is an umbrella project consisting of independent projects with, in principle, different @@ -273,7 +335,7 @@ release cadences. To manage the portfolio a BOM (Bill of Materials) is published set of dependencies on the individual project (see below). The release trains have names, not versions, to avoid confusion with the sub-projects. The names are an alphabetic sequence (so you can sort them chronologically) with names of London Tube stations ("Angel" is the first -release, "Brixton" is the second). When point releases of the individual projects accumulate to +release, "Brixton" is the second). When point releases of the individual projects accumulate to a critical mass, or if there is a critical bug in one of them that needs to be available to everyone, the release train will push out "service releases" with names ending ".SRX", where "X" is a number. @@ -282,7 +344,7 @@ Release train contents: -|Component |{{lastGaTrainName}}|{{currentGaTrainName}}|{{currentSnapshotTrainName}}| +|Component |{{lastGaTrainName}}|{{currentGaTrainName}}|{{currentSnapshotTrainName}}| |--------------------------------------|-----------------|---------------------|------------------------| {{#each projects}} |{{componentName}}|{{lastGaVersion}}|{{currentGaVersion}}|{{currentSnapshotVersion}}| {{/each}} @@ -292,22 +354,26 @@ Release train contents: Finchley builds and works with Spring Boot 2.0.x, and is not expected to work with Spring Boot 1.5.x. -Note: The Dalston release train will [reach end-of-life](https://spring.io/blog/2018/06/19/spring-cloud-finchley-release-is-available) in December 2018. Edgware will follow the end-of-life cycle of Spring Boot 1.5.x. - +Note: The Dalston release train will [reach +end-of-life](https://spring.io/blog/2018/06/19/spring-cloud-finchley-release-is-available) in December 2018. Edgware +will follow the end-of-life cycle of Spring Boot 1.5.x. + The Dalston and Edgware release trains build on Spring Boot 1.5.x, and are not expected to work with Spring Boot 2.0.x. -NOTE: The Camden release train was [marked end-of-life](https://spring.io/blog/2018/06/19/spring-cloud-finchley-release-is-available). - +NOTE: The Camden release train was [marked +end-of-life](https://spring.io/blog/2018/06/19/spring-cloud-finchley-release-is-available). + The Camden release train builds on Spring Boot 1.4.x, but is also tested with 1.5.x. -NOTE: The Brixton and Angel release trains were [marked end-of-life](https://spring.io/blog/2017/07/21/spring-cloud-dalston-sr2-is-available-now#end-of-life-for-angel-and-brixton-release-trains) +NOTE: The Brixton and Angel release trains were [marked +end-of-life](https://spring.io/blog/2017/07/21/spring-cloud-dalston-sr2-is-available-now#end-of-life-for-angel-and-brixton-release-trains) (EOL) in July 2017. The Brixton release train builds on Spring Boot 1.3.x, but is also tested with 1.4.x. - + The Angel release train builds on Spring Boot 1.2.x, and is incompatible in some areas with Spring Boot 1.3.x. Brixton builds on Spring Boot 1.3.x and is similarly incompatible with 1.2.x. Some @@ -335,8 +401,9 @@ Spring dependency management plugin. > Spring Cloud. The opposite is not true: using the Cloud parent > makes it impossible, or at least unreliable, to also use the > Boot BOM to change the version of Spring Boot and its dependencies. - -> NOTE: If you find anything wrong or outdated on this page, please open an issue in [this](https://github.com/spring-projects/spring-cloud) repo. + +> NOTE: If you find anything wrong or outdated on this page, please open an issue in +[this](https://github.com/spring-projects/spring-cloud) repo. {% endcapture %} diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/pom/TestPomReader.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudMavenBomParserAccessor.java similarity index 68% rename from spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/pom/TestPomReader.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudMavenBomParserAccessor.java index d4d09a4d..606623fe 100644 --- a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/pom/TestPomReader.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudMavenBomParserAccessor.java @@ -14,21 +14,14 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.cloud.buildsystem; -import java.io.File; +import org.springframework.cloud.release.internal.buildsystem.CustomBomParser; -import org.apache.maven.model.Model; +public class SpringCloudMavenBomParserAccessor { -/** - * @author Marcin Grzejszczak - */ -public class TestPomReader { - - PomReader pomReader = new PomReader(); - - public Model readPom(File pom) { - return this.pomReader.readPom(pom); + public static CustomBomParser cloud() { + return new SpringCloudMavenBomParser(); } } diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdaterTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/cloud/docs/SpringCloudCustomProjectDocumentationUpdaterTests.java similarity index 65% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdaterTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/cloud/docs/SpringCloudCustomProjectDocumentationUpdaterTests.java index ef72e268..34143644 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ProjectDocumentationUpdaterTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/cloud/docs/SpringCloudCustomProjectDocumentationUpdaterTests.java @@ -14,13 +14,16 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.docs; +package org.springframework.cloud.release.cloud.docs; import java.io.File; import java.io.IOException; import java.net.URISyntaxException; import java.nio.file.Files; +import javax.validation.constraints.NotNull; + +import edu.emory.mathcs.backport.java.util.Collections; import org.assertj.core.api.BDDAssertions; import org.junit.Before; import org.junit.Rule; @@ -29,9 +32,12 @@ import org.junit.rules.TemporaryFolder; import org.mockito.BDDMockito; import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; +import org.springframework.cloud.release.internal.docs.DocumentationUpdater; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.TestUtils; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.template.TemplateGenerator; import org.springframework.util.FileSystemUtils; import static org.assertj.core.api.BDDAssertions.then; @@ -39,7 +45,7 @@ import static org.assertj.core.api.BDDAssertions.then; /** * @author Marcin Grzejszczak */ -public class ProjectDocumentationUpdaterTests { +public class SpringCloudCustomProjectDocumentationUpdaterTests { @Rule public TemporaryFolder tmp = new TemporaryFolder(); @@ -50,6 +56,8 @@ public class ProjectDocumentationUpdaterTests { ProjectGitHandler handler; + ProjectGitHubHandler gitHubHandler; + File clonedDocProject; ReleaserProperties properties = new ReleaserProperties(); @@ -57,7 +65,7 @@ public class ProjectDocumentationUpdaterTests { @Before public void setup() throws IOException, URISyntaxException { this.tmpFolder = this.tmp.newFolder(); - this.project = new File(ProjectDocumentationUpdaterTests.class + this.project = new File(SpringCloudCustomProjectDocumentationUpdater.class .getResource("/projects/spring-cloud-static").toURI()); TestUtils.prepareLocalRepo(); FileSystemUtils.copyRecursively(file("/projects"), this.tmpFolder); @@ -65,6 +73,7 @@ public class ProjectDocumentationUpdaterTests { file("/projects/spring-cloud-static/").toURI().toString()); this.handler = new ProjectGitHandler(this.properties); this.clonedDocProject = this.handler.cloneDocumentationProject(); + this.gitHubHandler = new ProjectGitHubHandler(this.properties); } @Test @@ -78,9 +87,8 @@ public class ProjectDocumentationUpdaterTests { file("/projects/spring-cloud-release/").toURI().toString()); BDDAssertions - .thenThrownBy(() -> new ProjectDocumentationUpdater(properties, - new ProjectGitHandler(properties)) - .updateDocsRepo(releaseTrainVersion, "vAngel.SR33")) + .thenThrownBy(() -> projectDocumentationUpdaterWithNoIndexHtml(properties) + .updateDocsRepo(releaseTrainVersion, "vAngel.SR33")) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("index.html is not present"); } @@ -94,13 +102,19 @@ public class ProjectDocumentationUpdaterTests { properties.getGit().setDocumentationUrl( file("/projects/spring-cloud-static/").toURI().toString()); - BDDAssertions.thenThrownBy(() -> new ProjectDocumentationUpdater(properties, + SpringCloudCustomProjectDocumentationUpdater customUpdater = new SpringCloudCustomProjectDocumentationUpdater( new ProjectGitHandler(properties)) { @Override String readIndexHtmlContents(File indexHtml) { return ""; } - }.updateDocsRepo(releaseTrainVersion, "vAngel.SR33")) + }; + + BDDAssertions + .thenThrownBy(() -> new DocumentationUpdater(this.handler, properties, + templateGenerator(properties), + Collections.singletonList(customUpdater)) + .updateDocsRepo(releaseTrainVersion, "vAngel.SR33")) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("The URL to the documentation repo not found"); } @@ -111,13 +125,52 @@ public class ProjectDocumentationUpdaterTests { "2.0.0.BUILD-SNAPSHOT"); ReleaserProperties properties = new ReleaserProperties(); - File updatedDocs = new ProjectDocumentationUpdater(properties, - new ProjectGitHandler(properties)).updateDocsRepo(releaseTrainVersion, - "vAngel.M7"); + File updatedDocs = projectDocumentationUpdater(properties) + .updateDocsRepo(releaseTrainVersion, "vAngel.M7"); then(updatedDocs).isNull(); } + @NotNull + private DocumentationUpdater projectDocumentationUpdater( + ReleaserProperties properties) { + return new DocumentationUpdater(this.handler, properties, + templateGenerator(properties), Collections.singletonList( + new SpringCloudCustomProjectDocumentationUpdater(this.handler) { + @Override + boolean isNewerOrEqualReleaseTrain(String storedReleaseTrain, + String firstLetterOfReleaseTrain, + String currentReleaseTrainVersion, + String firstLetterOfCurrentReleaseTrain) { + return true; + } + })); + } + + @NotNull + private DocumentationUpdater projectDocumentationUpdaterWithNoIndexHtml( + ReleaserProperties properties) { + return new DocumentationUpdater(this.handler, properties, + templateGenerator(properties), Collections.singletonList( + new SpringCloudCustomProjectDocumentationUpdater(this.handler) { + @Override + File indexHtml(File clonedDocumentationProject, + String pathToIndexHtml) { + return new File("non/existent/file"); + } + })); + } + + @NotNull + private TemplateGenerator templateGenerator(ReleaserProperties properties) { + return new TemplateGenerator(properties, this.gitHubHandler); + } + + @NotNull + private ProjectGitHandler projectGitHandler(ReleaserProperties properties) { + return new ProjectGitHandler(properties); + } + @Test public void should_not_update_current_version_in_the_docs_if_current_release_starts_with_v_and_then_lower_letter_than_the_stored_release() throws URISyntaxException, IOException { @@ -127,9 +180,9 @@ public class ProjectDocumentationUpdaterTests { properties.getGit().setDocumentationUrl( file("/projects/spring-cloud-static/").toURI().toString()); - File updatedDocs = new ProjectDocumentationUpdater(properties, - new ProjectGitHandler(properties)).updateDocsRepo(releaseTrainVersion, - "vAngel.SR33"); + File updatedDocs = new SpringCloudCustomProjectDocumentationUpdater( + new ProjectGitHandler(properties)).updateDocsRepo(this.clonedDocProject, + releaseTrainVersion, "vAngel.SR33"); String indexHtmlContent = new String( Files.readAllBytes(new File(updatedDocs, "current/index.html").toPath())); @@ -145,8 +198,8 @@ public class ProjectDocumentationUpdaterTests { properties.getGit().setDocumentationUrl(this.clonedDocProject.toURI().toString()); ProjectGitHandler handler = BDDMockito.spy(new ProjectGitHandler(properties)); - new ProjectDocumentationUpdater(properties, handler) - .updateDocsRepo(releaseTrainVersion, "vDalston.SR3"); + new SpringCloudCustomProjectDocumentationUpdater(handler).updateDocsRepo( + this.clonedDocProject, releaseTrainVersion, "vDalston.SR3"); BDDMockito.then(handler).should(BDDMockito.never()) .commit(BDDMockito.any(File.class), BDDMockito.anyString()); @@ -160,9 +213,9 @@ public class ProjectDocumentationUpdaterTests { ReleaserProperties properties = new ReleaserProperties(); properties.getGit().setDocumentationUrl(this.clonedDocProject.toURI().toString()); - File updatedDocs = new ProjectDocumentationUpdater(properties, - new ProjectGitHandler(properties)).updateDocsRepo(releaseTrainVersion, - "Angel.SR33"); + File updatedDocs = new SpringCloudCustomProjectDocumentationUpdater( + new ProjectGitHandler(properties)).updateDocsRepo(this.clonedDocProject, + releaseTrainVersion, "Angel.SR33"); String indexHtmlContent = new String( Files.readAllBytes(new File(updatedDocs, "current/index.html").toPath())); @@ -178,9 +231,8 @@ public class ProjectDocumentationUpdaterTests { ReleaserProperties properties = new ReleaserProperties(); properties.getGit().setDocumentationUrl(this.clonedDocProject.toURI().toString()); - File updatedDocs = new ProjectDocumentationUpdater(properties, - new ProjectGitHandler(properties)).updateDocsRepo(releaseTrainVersion, - "vFinchley.SR33"); + File updatedDocs = projectDocumentationUpdater(properties) + .updateDocsRepo(releaseTrainVersion, "vFinchley.SR33"); String indexHtmlContent = new String( Files.readAllBytes(new File(updatedDocs, "current/index.html").toPath())); @@ -196,9 +248,8 @@ public class ProjectDocumentationUpdaterTests { ReleaserProperties properties = new ReleaserProperties(); properties.getGit().setDocumentationUrl(this.clonedDocProject.toURI().toString()); - File updatedDocs = new ProjectDocumentationUpdater(properties, - new ProjectGitHandler(properties)).updateDocsRepo(releaseTrainVersion, - "Finchley.SR33"); + File updatedDocs = projectDocumentationUpdater(properties) + .updateDocsRepo(releaseTrainVersion, "Finchley.SR33"); String indexHtmlContent = new String( Files.readAllBytes(new File(updatedDocs, "current/index.html").toPath())); @@ -214,16 +265,15 @@ public class ProjectDocumentationUpdaterTests { properties.getGit().setDocumentationUrl(this.clonedDocProject.toURI().toString()); properties.getGit().setUpdateDocumentationRepo(false); - File updatedDocs = new ProjectDocumentationUpdater(properties, - new ProjectGitHandler(properties)).updateDocsRepo(releaseTrainVersion, - "Finchley.SR33"); + File updatedDocs = projectDocumentationUpdater(properties) + .updateDocsRepo(releaseTrainVersion, "Finchley.SR33"); then(updatedDocs).isNull(); } private File file(String relativePath) throws URISyntaxException { - return new File( - ProjectDocumentationUpdaterTests.class.getResource(relativePath).toURI()); + return new File(SpringCloudCustomProjectDocumentationUpdater.class + .getResource(relativePath).toURI()); } } 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 5eae12e4..54e9082b 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 @@ -20,6 +20,7 @@ import java.io.File; import java.io.IOException; import java.net.URISyntaxException; import java.nio.file.Files; +import java.util.Collections; import org.apache.maven.model.Model; import org.assertj.core.api.BDDAssertions; @@ -28,11 +29,12 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.pom.TestPomReader; -import org.springframework.cloud.release.internal.pom.TestUtils; +import org.springframework.cloud.release.internal.buildsystem.MavenBomParserAccessor; +import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; +import org.springframework.cloud.release.internal.tech.PomReader; import org.springframework.util.FileSystemUtils; import static org.assertj.core.api.BDDAssertions.then; @@ -45,8 +47,6 @@ public class PomUpdateAcceptanceTests { @Rule public TemporaryFolder tmp = new TemporaryFolder(); - TestPomReader testPomReader = new TestPomReader(); - File temporaryFolder; @Before @@ -60,7 +60,9 @@ public class PomUpdateAcceptanceTests { public void should_update_all_versions_for_a_release_train() throws Exception { ReleaserProperties releaserProperties = releaserProperties(); releaserProperties.getFixedVersions().put("checkstyle", "100.0.0.RELEASE"); - ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties); + ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties, + Collections.singletonList( + MavenBomParserAccessor.cloudMavenBomParser(releaserProperties))); Projects projects = projectPomUpdater.retrieveVersionsFromReleaseTrainBom(); File project = new File(this.temporaryFolder, "/spring-cloud-sleuth"); @@ -68,13 +70,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()) @@ -93,7 +94,9 @@ public class PomUpdateAcceptanceTests { public void should_not_fail_when_after_updating_a_release_version_there_still_is_a_snapshot_version() throws Exception { ReleaserProperties releaserProperties = branchReleaserProperties(); - ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties); + ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties, + Collections.singletonList( + MavenBomParserAccessor.cloudMavenBomParser(releaserProperties))); Projects projects = projectPomUpdater.retrieveVersionsFromReleaseTrainBom(); projects.add(new ProjectVersion("spring-cloud-sleuth-samples", "0.0.5.RELEASE")); File project = new File(this.temporaryFolder, @@ -115,7 +118,9 @@ public class PomUpdateAcceptanceTests { public void should_not_fail_update_when_after_updating_a_release_version_there_still_is_a_snapshot_version_in_a_non_deployable_module() throws Exception { ReleaserProperties releaserProperties = branchReleaserProperties(); - ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties); + ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties, + Collections.singletonList( + MavenBomParserAccessor.cloudMavenBomParser(releaserProperties))); Projects projects = projectPomUpdater.retrieveVersionsFromReleaseTrainBom(); File project = new File(this.temporaryFolder, "/spring-cloud-sleuth-with-unmatched-property"); @@ -131,7 +136,9 @@ public class PomUpdateAcceptanceTests { public void should_update_fail_when_after_updating_a_release_version_there_still_is_a_snapshot_version_for_boot_snapshot_version() throws Exception { ReleaserProperties releaserProperties = branchReleaserProperties(); - ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties); + ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties, + Collections.singletonList( + MavenBomParserAccessor.cloudMavenBomParser(releaserProperties))); Projects projects = projectPomUpdater.retrieveVersionsFromReleaseTrainBom(); projects.removeIf(projectVersion -> projectVersion.projectName .contains("spring-cloud-build")); @@ -147,7 +154,9 @@ public class PomUpdateAcceptanceTests { @Test public void should_not_update_a_project_that_is_not_on_the_list() throws Exception { ReleaserProperties releaserProperties = releaserProperties(); - ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties); + ProjectPomUpdater projectPomUpdater = new ProjectPomUpdater(releaserProperties, + Collections.singletonList( + MavenBomParserAccessor.cloudMavenBomParser(releaserProperties))); File beforeProcessing = pom("/projects/project/"); Projects projects = projectPomUpdater.retrieveVersionsFromReleaseTrainBom(); File project = tmpFile("/project/"); diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/ReleaserTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/ReleaserTests.java index d8ea7e37..7b87fc02 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/ReleaserTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/ReleaserTests.java @@ -31,14 +31,15 @@ import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; import org.springframework.boot.test.rule.OutputCapture; +import org.springframework.cloud.release.internal.buildsystem.GradleUpdater; +import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; import org.springframework.cloud.release.internal.docs.DocumentationUpdater; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.gradle.GradleUpdater; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.post.PostReleaseActions; -import org.springframework.cloud.release.internal.project.ProjectBuilder; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.postrelease.PostReleaseActions; +import org.springframework.cloud.release.internal.project.ProjectCommandExecutor; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.sagan.SaganUpdater; import org.springframework.cloud.release.internal.template.TemplateGenerator; @@ -59,11 +60,14 @@ public class ReleaserTests { ProjectPomUpdater projectPomUpdater; @Mock - ProjectBuilder projectBuilder; + ProjectCommandExecutor projectCommandExecutor; @Mock ProjectGitHandler projectGitHandler; + @Mock + ProjectGitHubHandler projectGitHubHandler; + @Mock TemplateGenerator templateGenerator; @@ -89,9 +93,9 @@ public class ReleaserTests { Releaser releaser(Supplier originalVersionSupplier) { return new Releaser(new ReleaserProperties(), this.projectPomUpdater, - this.projectBuilder, this.projectGitHandler, this.templateGenerator, - this.gradleUpdater, this.saganUpdater, this.documentationUpdater, - this.postReleaseActions) { + this.projectCommandExecutor, this.projectGitHandler, + this.projectGitHubHandler, this.templateGenerator, this.gradleUpdater, + this.saganUpdater, this.documentationUpdater, this.postReleaseActions) { @Override ProjectVersion originalVersion(File project) { return originalVersionSupplier.get(); @@ -101,9 +105,9 @@ public class ReleaserTests { Releaser releaser() { return new Releaser(new ReleaserProperties(), this.projectPomUpdater, - this.projectBuilder, this.projectGitHandler, this.templateGenerator, - this.gradleUpdater, this.saganUpdater, this.documentationUpdater, - this.postReleaseActions); + this.projectCommandExecutor, this.projectGitHandler, + this.projectGitHubHandler, this.templateGenerator, this.gradleUpdater, + this.saganUpdater, this.documentationUpdater, this.postReleaseActions); } @Test @@ -173,7 +177,7 @@ public class ReleaserTests { public void should_not_close_milestone_for_snapshots() { releaser().closeMilestone(new ProjectVersion("original", "1.0.0.BUILD-SNAPSHOT")); - then(this.projectGitHandler).should(never()) + then(this.projectGitHubHandler).should(never()) .closeMilestone(any(ProjectVersion.class)); } diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/GradleBomParserTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/GradleBomParserTests.java new file mode 100644 index 00000000..ba734753 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/GradleBomParserTests.java @@ -0,0 +1,123 @@ +/* + * 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.HashMap; +import java.util.Map; +import java.util.Properties; + +import org.assertj.core.api.BDDAssertions; +import org.junit.jupiter.api.Test; + +import org.springframework.cloud.release.internal.ReleaserProperties; + +class GradleBomParserTests { + + @Test + void should_read_versions_from_bom_from_properties() { + GradleBomParser parser = new GradleBomParser(new ReleaserProperties(), + new ArrayList<>()) { + @Override + public boolean isApplicable(File clonedBom) { + return true; + } + + @Override + File file(File clonedBom, String child) { + return clonedBom; + } + + @Override + Properties loadProps(File file) { + Properties properties = new Properties(); + properties.setProperty("springCloudContractVersion", "1.0.0.RELEASE"); + return properties; + } + }; + + VersionsFromBom versionsFromBom = parser.versionsFromBom(new File(".")); + + BDDAssertions.then(versionsFromBom.versionForProject("spring-cloud-contract")) + .isEqualTo("1.0.0.RELEASE"); + } + + @Test + void should_return_a_version_from_bom_with_substitution() { + Map gradleSubstitution = new HashMap<>(); + gradleSubstitution.put("verifierVersion", "spring-cloud-contract"); + ReleaserProperties releaserProperties = new ReleaserProperties(); + releaserProperties.getGradle().setGradlePropsSubstitution(gradleSubstitution); + GradleBomParser parser = new GradleBomParser(releaserProperties, + new ArrayList<>()) { + @Override + public boolean isApplicable(File clonedBom) { + return true; + } + + @Override + File file(File clonedBom, String child) { + return clonedBom; + } + + @Override + Properties loadProps(File file) { + Properties properties = new Properties(); + properties.setProperty("verifierVersion", "1.0.0.RELEASE"); + return properties; + } + }; + + VersionsFromBom versionsFromBom = parser.versionsFromBom(new File(".")); + + BDDAssertions.then(versionsFromBom.versionForProject("spring-cloud-contract")) + .isEqualTo("1.0.0.RELEASE"); + } + + @Test + void should_be_not_applicable_when_no_build_gradle_is_present() { + GradleBomParser parser = new GradleBomParser(new ReleaserProperties(), + new ArrayList<>()); + + BDDAssertions.then(parser.isApplicable(new File("."))).isFalse(); + } + + @Test + void should_be_applicable_when_build_gradle_is_present() { + GradleBomParser parser = new GradleBomParser(new ReleaserProperties(), + new ArrayList<>()) { + @Override + File file(File clonedBom, String child) { + return clonedBom; + } + }; + + BDDAssertions.then(parser.isApplicable(new File("."))).isTrue(); + } + + @Test + void should_return_empty_version_when_no_gradle_properties_is_present() { + GradleBomParser parser = new GradleBomParser(new ReleaserProperties(), + new ArrayList<>()); + + VersionsFromBom versionsFromBom = parser.versionsFromBom(new File(".")); + + BDDAssertions.then(versionsFromBom).isSameAs(VersionsFromBom.EMPTY_VERSION); + } + +} \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/LoggerToMavenLogTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/LoggerToMavenLogTests.java similarity index 98% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/LoggerToMavenLogTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/LoggerToMavenLogTests.java index 67cb1e16..e048e96f 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/LoggerToMavenLogTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/LoggerToMavenLogTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import org.junit.Test; import org.junit.runner.RunWith; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserAccessor.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserAccessor.java new file mode 100644 index 00000000..dd8c8d96 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserAccessor.java @@ -0,0 +1,31 @@ +/* + * 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 org.springframework.cloud.release.cloud.buildsystem.SpringCloudMavenBomParserAccessor; +import org.springframework.cloud.release.internal.ReleaserProperties; + +public class MavenBomParserAccessor { + + public static BomParser cloudMavenBomParser(ReleaserProperties properties) { + return new MavenBomParser(properties, + Collections.singletonList(SpringCloudMavenBomParserAccessor.cloud())); + } + +} diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/BomParserTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserTests.java similarity index 59% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/BomParserTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserTests.java index 0cef174d..c5e8b37b 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/BomParserTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.net.URISyntaxException; @@ -24,6 +24,7 @@ import org.junit.Test; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.git.GitRepoTests; +import org.springframework.cloud.release.internal.project.Project; import static org.assertj.core.api.BDDAssertions.then; import static org.assertj.core.api.BDDAssertions.thenThrownBy; @@ -31,7 +32,7 @@ import static org.assertj.core.api.BDDAssertions.thenThrownBy; /** * @author Marcin Grzejszczak */ -public class BomParserTests { +public class MavenBomParserTests { File springCloudReleaseProject; @@ -45,9 +46,11 @@ public class BomParserTests { @Test public void should_throw_exception_when_boot_pom_is_missing() { - BomParser parser = new BomParser(this.properties, new File(".")); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); + File file = new File("."); - thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class) + thenThrownBy(() -> parser.versionsFromBom(file)) + .isInstanceOf(IllegalStateException.class) .hasMessageContaining("Pom is not present"); } @@ -55,28 +58,28 @@ public class BomParserTests { public void should_throw_exception_when_null_is_passed_to_boot() { this.properties.getPom().setPomWithBootStarterParent(null); this.properties.getPom().setThisTrainBom(null); - BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class) + thenThrownBy(() -> parser.versionsFromBom(this.springCloudReleaseProject)) + .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); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class) - .hasMessageContaining( + thenThrownBy(() -> parser.versionsFromBom(this.springCloudReleaseProject)) + .isInstanceOf(IllegalStateException.class).hasMessageContaining( "The pom doesn't have a [spring-boot-starter-parent] artifact id"); } @Test public void should_populate_sc_release_version() { - BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - String scReleaseVersion = parser.allVersions() + String scReleaseVersion = parser.versionsFromBom(this.springCloudReleaseProject) .versionForProject("spring-cloud-release"); then(scReleaseVersion).isEqualTo("Dalston.BUILD-SNAPSHOT"); @@ -84,18 +87,20 @@ public class BomParserTests { @Test public void should_populate_boot_version() { - BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - String bootVersion = parser.bootVersion().bootVersion; + String bootVersion = parser.versionsFromBom(this.springCloudReleaseProject) + .versionForProject("spring-boot"); then(bootVersion).isEqualTo("1.5.1.BUILD-SNAPSHOT"); } @Test public void should_throw_exception_when_cloud_pom_is_missing() { - BomParser parser = new BomParser(this.properties, new File(".")); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class) + thenThrownBy(() -> parser.versionsFromBom(new File("."))) + .isInstanceOf(IllegalStateException.class) .hasMessageContaining("Pom is not present"); } @@ -103,42 +108,48 @@ public class BomParserTests { public void should_throw_exception_when_null_is_passed_to_cloud() { this.properties.getPom().setPomWithBootStarterParent(null); this.properties.getPom().setThisTrainBom(null); - BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class) + thenThrownBy(() -> parser.versionsFromBom(this.springCloudReleaseProject)) + .isInstanceOf(IllegalStateException.class) .hasMessageContaining("Pom is not present"); } @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); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class) - .hasMessageContaining( + thenThrownBy(() -> parser.versionsFromBom(this.springCloudReleaseProject)) + .isInstanceOf(IllegalStateException.class).hasMessageContaining( "The pom doesn't have a [spring-cloud-dependencies-parent] artifact id"); } @Test public void should_populate_cloud_version() { - BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - Versions cloudVersions = parser.versionsFromBom(); + VersionsFromBom cloudVersionsFromBom = parser + .versionsFromBom(this.springCloudReleaseProject); - then(cloudVersions.scBuildVersion).isEqualTo("1.3.1.BUILD-SNAPSHOT"); - then(cloudVersions.projects).contains(allProjects()); + then(cloudVersionsFromBom.versionForProject("spring-cloud-build")) + .isEqualTo("1.3.1.BUILD-SNAPSHOT"); + then(cloudVersionsFromBom.projects).contains(allProjects()); } @Test public void should_populate_boot_and_cloud_version() { - BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject); + BomParser parser = MavenBomParserAccessor.cloudMavenBomParser(this.properties); - Versions cloudVersions = parser.allVersions(); + VersionsFromBom cloudVersionsFromBom = parser + .versionsFromBom(this.springCloudReleaseProject); - then(cloudVersions.bootVersion).isEqualTo("1.5.1.BUILD-SNAPSHOT"); - then(cloudVersions.scBuildVersion).isEqualTo("1.3.1.BUILD-SNAPSHOT"); - then(cloudVersions.projects).contains(allProjects()); + then(cloudVersionsFromBom.versionForProject("spring-boot")) + .isEqualTo("1.5.1.BUILD-SNAPSHOT"); + then(cloudVersionsFromBom.versionForProject("spring-cloud-build")) + .isEqualTo("1.3.1.BUILD-SNAPSHOT"); + then(cloudVersionsFromBom.projects).contains(allProjects()); } private Project[] allProjects() { diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PomReaderTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java similarity index 82% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PomReaderTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java index 57b77886..1660972f 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PomReaderTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.EOFException; import java.io.File; @@ -27,6 +27,7 @@ import org.junit.Before; import org.junit.Test; import org.springframework.cloud.release.internal.git.GitRepoTests; +import org.springframework.cloud.release.internal.tech.PomReader; import static org.assertj.core.api.BDDAssertions.then; import static org.assertj.core.api.BDDAssertions.thenThrownBy; @@ -36,8 +37,6 @@ import static org.assertj.core.api.BDDAssertions.thenThrownBy; */ public class PomReaderTests { - PomReader pomReader = new PomReader(); - File springCloudReleaseProjectPom; File springCloudReleaseProject; @@ -59,7 +58,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 +66,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 +74,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/pom/PomUpdaterTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java similarity index 87% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PomUpdaterTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java index 0bcc0884..8c641298 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PomUpdaterTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.io.IOException; @@ -31,7 +31,10 @@ 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.cloud.release.internal.project.Project; +import org.springframework.cloud.release.internal.tech.PomReader; import org.springframework.util.FileSystemUtils; /** @@ -45,12 +48,14 @@ public class PomUpdaterTests { @Rule public TemporaryFolder tmp = new TemporaryFolder(); - Versions versions = new Versions("0.0.1", "0.0.2", projects()); + VersionsFromBom versionsFromBom = new VersionsFromBomBuilder() + .releaserProperties(new ReleaserProperties()).projects(projects()) + .parsers(MavenBomParserAccessor.cloudMavenBomParser(new ReleaserProperties()) + .customBomParsers()) + .retrieveFromBom(); PomUpdater pomUpdater = new PomUpdater(); - PomReader pomReader = new PomReader(); - File temporaryFolder; @Before @@ -65,7 +70,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 +78,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 +89,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 +100,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 +109,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 +118,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 +133,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 +151,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 +171,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 +190,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 +199,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 +210,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 +235,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 +257,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 +282,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 +307,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 +332,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 +357,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 +376,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 +400,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 +423,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 +439,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 +454,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 +475,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 +485,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/pom/ProjectPomUpdaterTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdaterTests.java similarity index 86% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectPomUpdaterTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdaterTests.java index 5d4ba760..e26839ab 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectPomUpdaterTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdaterTests.java @@ -14,9 +14,10 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; +import java.util.Collections; import java.util.Map; import java.util.stream.Collectors; @@ -26,6 +27,8 @@ import org.mockito.BDDMockito; import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.git.ProjectGitHandler; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak @@ -64,7 +67,8 @@ public class ProjectPomUpdaterTests { "Finchley.BUILD-SNAPSHOT"); properties.getFixedVersions().put("spring-boot", "2.0.3.RELEASE"); properties.getFixedVersions().put("spring-cloud-gateway", "2.0.1.BUILD-SNAPSHOT"); - ProjectPomUpdater updater = new ProjectPomUpdater(properties); + ProjectPomUpdater updater = new ProjectPomUpdater(properties, Collections + .singletonList(MavenBomParserAccessor.cloudMavenBomParser(properties))); Map fixedVersions = updater.fixedVersions().stream() .collect(Collectors.toMap(projectVersion -> projectVersion.projectName, @@ -74,7 +78,8 @@ public class ProjectPomUpdaterTests { .containsEntry("spring-boot-dependencies", "2.0.3.RELEASE") .containsEntry("spring-boot-starter", "2.0.3.RELEASE") .containsEntry("spring-cloud-build", "2.0.3.BUILD-SNAPSHOT") - .containsEntry("spring-cloud-dependencies", "2.0.3.BUILD-SNAPSHOT") + .containsEntry("spring-cloud-dependencies-parent", "2.0.3.BUILD-SNAPSHOT") + .containsEntry("spring-cloud-dependencies", "Finchley.BUILD-SNAPSHOT") .containsEntry("spring-cloud-release", "Finchley.BUILD-SNAPSHOT") .containsEntry("spring-cloud", "Finchley.BUILD-SNAPSHOT"); } @@ -83,7 +88,8 @@ public class ProjectPomUpdaterTests { public void should_skip_any_steps_if_there_is_no_pom_xml() { ReleaserProperties properties = new ReleaserProperties(); ProjectGitHandler handler = BDDMockito.mock(ProjectGitHandler.class); - ProjectPomUpdater updater = new ProjectPomUpdater(properties, handler); + ProjectPomUpdater updater = new ProjectPomUpdater(properties, Collections + .singletonList(MavenBomParserAccessor.cloudMavenBomParser(properties))); updater.updateProjectFromReleaseTrain(new File("target"), new Projects(), new ProjectVersion("foo", "1.0.0.RELEASE"), false); diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectVersionTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersionTests.java similarity index 98% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectVersionTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersionTests.java index d93a0e47..548e7ad5 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectVersionTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersionTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.net.URI; @@ -26,6 +26,7 @@ import org.junit.Before; import org.junit.Test; import org.springframework.cloud.release.internal.git.GitRepoTests; +import org.springframework.cloud.release.internal.project.ProjectVersion; import static org.assertj.core.api.BDDAssertions.then; import static org.assertj.core.api.BDDAssertions.thenThrownBy; @@ -49,14 +50,6 @@ public class ProjectVersionTests { this.springCloudContract = new File(scContract.getPath(), "pom.xml"); } - @Test - public void should_build_version_from_text_when_parent_suffix_is_present() { - ProjectVersion projectVersion = new ProjectVersion("foo-parent", "1.0.0"); - - then(projectVersion.version).isEqualTo("1.0.0"); - then(projectVersion.projectName).isEqualTo("foo"); - } - @Test public void should_build_version_from_text() { ProjectVersion projectVersion = new ProjectVersion("foo", "1.0.0"); diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectsTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectsTests.java similarity index 97% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectsTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectsTests.java index 4b3f76b1..47b44a5b 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/ProjectsTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/ProjectsTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.net.URISyntaxException; @@ -25,6 +25,8 @@ import java.util.Set; import org.junit.Test; import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import static org.assertj.core.api.BDDAssertions.then; import static org.assertj.core.api.BDDAssertions.thenThrownBy; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PropertyStorerTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyStorerTests.java similarity index 92% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PropertyStorerTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyStorerTests.java index 18db90c8..a47d4010 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PropertyStorerTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyStorerTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import org.apache.maven.plugin.logging.Log; import org.codehaus.mojo.versions.rewriting.ModifiedPomXMLEventReader; @@ -25,6 +25,8 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.cloud.release.internal.project.Project; + import static org.mockito.BDDMockito.then; /** diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PropertyVersionChangerTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java similarity index 90% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PropertyVersionChangerTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java index cf30cde3..36011c85 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/PropertyVersionChangerTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.util.HashSet; import java.util.Properties; @@ -27,6 +27,9 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.project.Project; + import static org.mockito.ArgumentMatchers.any; import static org.mockito.BDDMockito.then; import static org.mockito.Mockito.never; @@ -75,8 +78,9 @@ public class PropertyVersionChangerTests { .setPropertyVersionIfApplicable(any(Project.class)); } - Versions versions() { - return new Versions("", "", allProjects()); + VersionsFromBom versions() { + return new VersionsFromBomBuilder().releaserProperties(new ReleaserProperties()) + .projects(allProjects()).retrieveFromBom(); } @SuppressWarnings("unchecked") diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/TestUtils.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestUtils.java similarity index 96% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/TestUtils.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestUtils.java index e14db287..99f4b138 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/TestUtils.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestUtils.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.io.IOException; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/VersionChangeAssertions.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionChangeAssertions.java similarity index 96% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/VersionChangeAssertions.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionChangeAssertions.java index 3cffd5b3..ed454d82 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/VersionChangeAssertions.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionChangeAssertions.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.util.ArrayList; import java.util.List; 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..5dd50a87 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomTests.java @@ -0,0 +1,301 @@ +/* + * 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.cloud.buildsystem.SpringCloudMavenBomParserAccessor; +import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.project.Project; + +import static org.assertj.core.api.BDDAssertions.then; + +/** + * @author Marcin Grzejszczak + */ +public class VersionsFromBomTests { + + VersionsFromBom versionsFromBom = new VersionsFromBomBuilder() + .releaserProperties(new ReleaserProperties()).projects(projects()) + .retrieveFromBom(); + + @Test + public void should_add_boot_to_versions_when_version_is_created() { + VersionsFromBom versionsFromBom = new VersionsFromBomBuilder() + .releaserProperties(new ReleaserProperties()) + .parsers(Collections + .singletonList(SpringCloudMavenBomParserAccessor.cloud())) + .retrieveFromBom(); + 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 VersionsFromBomBuilder().releaserProperties(new ReleaserProperties()) + .parsers(Collections + .singletonList(SpringCloudMavenBomParserAccessor.cloud())) + .projects(mixedProjects()).merged(); + } + + private VersionsFromBom mixedVersions(ReleaserProperties properties) { + return new VersionsFromBomBuilder().releaserProperties(properties) + .projects(mixedProjects()).retrieveFromBom(); + } + + 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/docs/ReleaseTrainContentsGeneratorTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsGeneratorTests.java index 7b92ffc9..dca05753 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsGeneratorTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsGeneratorTests.java @@ -23,8 +23,8 @@ import org.assertj.core.api.BDDAssertions; import org.junit.Test; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdaterTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdaterTests.java index 1dec1f7c..cc00da83 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdaterTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/ReleaseTrainContentsUpdaterTests.java @@ -29,11 +29,12 @@ import org.junit.Test; import org.junit.rules.TemporaryFolder; import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; import org.springframework.cloud.release.internal.git.GitTestUtils; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.pom.TestUtils; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.template.TemplateGenerator; import org.springframework.util.FileSystemUtils; @@ -47,15 +48,18 @@ public class ReleaseTrainContentsUpdaterTests { ReleaserProperties properties = new ReleaserProperties(); - ProjectGitHandler projectGitHandler = new ProjectGitHandler(this.properties) { + ProjectGitHubHandler projectGitHubHandler = new ProjectGitHubHandler( + this.properties) { @Override public String milestoneUrl(ProjectVersion releaseVersion) { return "http://www.foo.com/"; } }; + ProjectGitHandler projectGitHandler = new ProjectGitHandler(this.properties); + TemplateGenerator templateGenerator = new TemplateGenerator(this.properties, - this.projectGitHandler); + this.projectGitHubHandler); ReleaseTrainContentsUpdater updater = new ReleaseTrainContentsUpdater(this.properties, this.projectGitHandler, this.templateGenerator); diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/RowTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/RowTests.java index 50ad3e64..190b3369 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/RowTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/docs/RowTests.java @@ -21,8 +21,8 @@ import java.util.List; import org.assertj.core.api.BDDAssertions; import org.junit.Test; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; /** * @author Marcin Grzejszczak diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GitRepoTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GitRepoTests.java index 4c0ac6d0..614ef566 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GitRepoTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GitRepoTests.java @@ -36,7 +36,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.rules.TemporaryFolder; -import org.springframework.cloud.release.internal.pom.TestUtils; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; import static org.assertj.core.api.Assertions.fail; import static org.assertj.core.api.BDDAssertions.then; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/ProjectGitHandlerTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/ProjectGitHandlerTests.java index 5278476e..9c875fc6 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/ProjectGitHandlerTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/ProjectGitHandlerTests.java @@ -25,7 +25,7 @@ import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; +import org.springframework.cloud.release.internal.project.ProjectVersion; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/CachingGithubTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/CachingGithubTests.java similarity index 99% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/CachingGithubTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/CachingGithubTests.java index ca20da9d..758ac2cf 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/CachingGithubTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/CachingGithubTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.git; +package org.springframework.cloud.release.internal.github; import com.jcabi.github.Coordinates; import com.jcabi.github.Github; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GithubIssuesTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/GithubIssuesTests.java similarity index 97% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GithubIssuesTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/GithubIssuesTests.java index caca13ec..f4eb4e79 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GithubIssuesTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/GithubIssuesTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.git; +package org.springframework.cloud.release.internal.github; import java.io.IOException; import java.util.Collections; @@ -33,8 +33,8 @@ import org.mockito.BDDMockito; import org.springframework.boot.test.rule.OutputCapture; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import static org.assertj.core.api.BDDAssertions.then; import static org.assertj.core.api.BDDAssertions.thenThrownBy; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GithubMilestonesTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/GithubMilestonesTests.java similarity index 98% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GithubMilestonesTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/GithubMilestonesTests.java index 49df2a7f..d9afc0cf 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/git/GithubMilestonesTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/github/GithubMilestonesTests.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.git; +package org.springframework.cloud.release.internal.github; import java.io.IOException; import java.net.URL; @@ -30,7 +30,7 @@ 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.pom.ProjectVersion; +import org.springframework.cloud.release.internal.project.ProjectVersion; import static org.assertj.core.api.BDDAssertions.then; import static org.assertj.core.api.BDDAssertions.thenThrownBy; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/gradle/GradleUpdaterTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/gradle/GradleUpdaterTests.java index 0b98b437..1efb5984 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/gradle/GradleUpdaterTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/gradle/GradleUpdaterTests.java @@ -29,8 +29,9 @@ import org.junit.Test; import org.junit.rules.TemporaryFolder; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.buildsystem.GradleUpdater; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.util.FileSystemUtils; import static org.assertj.core.api.BDDAssertions.then; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/VersionsTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/VersionsTests.java deleted file mode 100644 index eb4cd859..00000000 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/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.pom; - -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("", 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/post/PostReleaseActionsTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java similarity index 90% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/post/PostReleaseActionsTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java index f1a9b8a5..5441a3b4 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/post/PostReleaseActionsTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java @@ -14,10 +14,11 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.post; +package org.springframework.cloud.release.internal.postrelease; import java.io.File; import java.net.URISyntaxException; +import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; @@ -37,16 +38,16 @@ 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.ProjectPomUpdater; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; import org.springframework.cloud.release.internal.git.GitTestUtils; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.gradle.GradleUpdater; -import org.springframework.cloud.release.internal.pom.ProcessedProject; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.pom.TestPomReader; -import org.springframework.cloud.release.internal.pom.TestUtils; -import org.springframework.cloud.release.internal.project.ProjectBuilder; +import org.springframework.cloud.release.internal.project.ProcessedProject; +import org.springframework.cloud.release.internal.project.ProjectCommandExecutor; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; +import org.springframework.cloud.release.internal.tech.PomReader; import org.springframework.cloud.release.internal.versions.VersionsFetcher; import org.springframework.util.FileSystemUtils; import org.springframework.util.LinkedMultiValueMap; @@ -61,8 +62,6 @@ public class PostReleaseActionsTests { File temporaryFolder; - TestPomReader testPomReader = new TestPomReader(); - GradleUpdater gradleUpdater = BDDMockito.mock(GradleUpdater.class); ReleaserProperties properties = new ReleaserProperties(); @@ -92,11 +91,11 @@ public class PostReleaseActionsTests { } }; - ProjectPomUpdater updater = new ProjectPomUpdater(this.properties); + ProjectPomUpdater updater = new ProjectPomUpdater(this.properties, new ArrayList<>()); VersionsFetcher versionsFetcher = new VersionsFetcher(properties, updater); - ProjectBuilder builder = new ProjectBuilder(this.properties); + ProjectCommandExecutor builder = new ProjectCommandExecutor(this.properties); @Before public void setup() throws Exception { @@ -143,7 +142,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"); @@ -186,15 +185,14 @@ public class PostReleaseActionsTests { this.properties.getMetaRelease().setEnabled(true); this.properties.getGit().setReleaseTrainDocsUrl( tmpFile("spring-cloud-core-tests/").getAbsolutePath() + "/"); - this.properties.getMaven() - .setGenerateReleaseTrainDocsCommand("touch generate.log"); + this.properties.getMaven().setGenerateReleaseTrainDocsCommand("./test.sh"); PostReleaseActions actions = new PostReleaseActions(this.projectGitHandler, this.updater, this.gradleUpdater, this.builder, this.properties, versionsFetcher); 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"); @@ -253,7 +251,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 @@ -318,15 +316,16 @@ public class PostReleaseActionsTests { this.properties.getMetaRelease().setGitOrgUrl(projects); VersionsFetcher versionsFetcher = BDDMockito.mock(VersionsFetcher.class); BDDMockito.given(versionsFetcher.isLatestGa(BDDMockito.any())).willReturn(true); - AtomicReference projectBuilderStub = new AtomicReference<>(); + AtomicReference projectBuilderStub = new AtomicReference<>(); ProjectGitHandler handler = BDDMockito.mock(ProjectGitHandler.class); - ProjectBuilder projectBuilder = BDDMockito.mock(ProjectBuilder.class); + ProjectCommandExecutor projectCommandExecutor = BDDMockito + .mock(ProjectCommandExecutor.class); PostReleaseActions actions = new PostReleaseActions(handler, this.updater, this.gradleUpdater, this.builder, this.properties, versionsFetcher) { @Override - ProjectBuilder projectBuilder(ProcessedProject processedProject) { - projectBuilderStub.set(projectBuilder); - return projectBuilder; + ProjectCommandExecutor projectBuilder(ProcessedProject processedProject) { + projectBuilderStub.set(projectCommandExecutor); + return projectCommandExecutor; } }; ProjectVersion projectVersion = new ProjectVersion( @@ -343,8 +342,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/project/ProjectBuilderTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/project/ProjectCommandExecutorTests.java similarity index 70% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/project/ProjectBuilderTests.java rename to spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/project/ProjectCommandExecutorTests.java index 5e5ac059..9c0fb29e 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/project/ProjectBuilderTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/project/ProjectCommandExecutorTests.java @@ -32,8 +32,7 @@ import org.junit.rules.TemporaryFolder; import org.springframework.boot.test.rule.OutputCapture; import org.springframework.cloud.release.internal.PomUpdateAcceptanceTests; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.TestUtils; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; import org.springframework.util.FileSystemUtils; import static org.assertj.core.api.BDDAssertions.then; @@ -42,7 +41,7 @@ import static org.assertj.core.api.BDDAssertions.thenThrownBy; /** * @author Marcin Grzejszczak */ -public class ProjectBuilderTests { +public class ProjectCommandExecutorTests { @Rule public TemporaryFolder tmp = new TemporaryFolder(); @@ -60,8 +59,8 @@ public class ProjectBuilderTests { FileSystemUtils.copyRecursively(file("/projects"), this.temporaryFolder); } - ProjectBuilder projectBuilder(ReleaserProperties properties) { - return new ProjectBuilder(properties) { + ProjectCommandExecutor projectBuilder(ReleaserProperties properties) { + return new ProjectCommandExecutor(properties) { @Override ProcessExecutor executor(String workingDir) { return testExecutor(workingDir); @@ -73,9 +72,9 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_command_when_after_running_there_is_no_html_file_with_unresolved_tag() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("ls -al"); + properties.getBash().setBuildCommand("ls -al"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -87,9 +86,9 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_command_when_path_is_provided_explicitly() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("ls -al"); + properties.getBash().setBuildCommand("ls -al"); properties.setWorkingDir(new File("/foo/bar").getAbsolutePath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT"), tmpFile("/builder/resolved").getPath()); @@ -102,66 +101,63 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_build_command_for_milestone_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo foo"); + properties.getBash().setBuildCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.M1")); - then(asString(tmpFile("/builder/resolved/resolved.log"))) - .contains("foo -Pmilestone"); + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo"); } @Test public void should_successfully_execute_a_build_command_for_rc_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo foo"); + properties.getBash().setBuildCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.RC1")); - then(asString(tmpFile("/builder/resolved/resolved.log"))) - .contains("foo -Pmilestone").doesNotContain("-Pguides"); + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo") + .doesNotContain("-Pguides"); } @Test public void should_successfully_execute_a_build_command_for_release_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo foo"); + properties.getBash().setBuildCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.RELEASE")); - then(asString(tmpFile("/builder/resolved/resolved.log"))) - .contains("foo -Pcentral"); + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo"); } @Test public void should_successfully_execute_a_build_command_for_sr_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo foo"); + properties.getBash().setBuildCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.SR1")); - then(asString(tmpFile("/builder/resolved/resolved.log"))) - .contains("foo -Pcentral"); + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo"); } @Test public void should_successfully_execute_a_command_when_system_props_placeholder_is_present() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo {{systemProps}}"); - properties.getMaven().setSystemProperties("-Dhello=world -Dfoo=bar"); + properties.getBash().setBuildCommand("echo {{systemProps}}"); + properties.getBash().setSystemProperties("-Dhello=world -Dfoo=bar"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -173,9 +169,9 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_command_when_system_props_placeholder_is_present_and_there_are_no_sys_props() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo foo {{systemProps}}"); + properties.getBash().setBuildCommand("echo foo {{systemProps}}"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -186,10 +182,10 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_command_when_system_props_placeholder_is_present_without_system_props() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo {{systemProps}}"); - properties.getMaven().setSystemProperties("hello=world foo=bar"); + properties.getBash().setBuildCommand("echo {{systemProps}}"); + properties.getBash().setSystemProperties("hello=world foo=bar"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -201,10 +197,10 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_command_when_system_props_placeholder_is_present_inside_command() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo {{systemProps}} bar"); - properties.getMaven().setSystemProperties("-Dhello=world -Dfoo=bar"); + properties.getBash().setBuildCommand("echo {{systemProps}} bar"); + properties.getBash().setSystemProperties("-Dhello=world -Dfoo=bar"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -216,10 +212,10 @@ public class ProjectBuilderTests { public void should_successfully_pass_system_props_when_build_gets_executed_without_explicit_system_props() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("echo bar"); - properties.getMaven().setSystemProperties("-Dhello=world -Dfoo=bar"); + properties.getBash().setBuildCommand("echo bar"); + properties.getBash().setSystemProperties("-Dhello=world -Dfoo=bar"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -230,9 +226,9 @@ public class ProjectBuilderTests { @Test public void should_throw_exception_when_after_running_there_is_an_html_file_with_unresolved_tag() { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("ls -al"); + properties.getBash().setBuildCommand("ls -al"); properties.setWorkingDir(tmpFile("/builder/unresolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); thenThrownBy( () -> builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT"))) @@ -243,10 +239,10 @@ public class ProjectBuilderTests { @Test public void should_throw_exception_when_command_took_too_long_to_execute() { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("sleep 1"); - properties.getMaven().setWaitTimeInMinutes(0); + properties.getBash().setBuildCommand("sleep 1"); + properties.getBash().setWaitTimeInMinutes(0); properties.setWorkingDir(tmpFile("/builder/unresolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); thenThrownBy( () -> builder.build(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT"))) @@ -257,9 +253,9 @@ public class ProjectBuilderTests { @Test public void should_successfully_execute_a_deploy_command() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setDeployCommand("ls -al"); + properties.getBash().setDeployCommand("ls -al"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.deploy(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -271,9 +267,25 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_deploy_command_for_milestone_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); + properties.getBash().setDeployCommand("echo foo"); + properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); + ProjectCommandExecutor builder = projectBuilder(properties); + + builder.deploy(new ProjectVersion("foo", "1.0.0.M1")); + + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo") + .doesNotContain("-Pguides"); + } + + @Test + public void should_successfully_execute_a_deploy_command_for_milestone_version_for_maven() + throws Exception { + ReleaserProperties properties = new ReleaserProperties(); properties.getMaven().setDeployCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + new ProcessExecutor(properties.getWorkingDir()) + .runCommand(new String[] { "touch", "pom.xml" }, 1); + ProjectCommandExecutor builder = projectBuilder(properties); builder.deploy(new ProjectVersion("foo", "1.0.0.M1")); @@ -285,9 +297,25 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_deploy_command_for_rc_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); + properties.getBash().setDeployCommand("echo foo"); + properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); + ProjectCommandExecutor builder = projectBuilder(properties); + + builder.deploy(new ProjectVersion("foo", "1.0.0.RC1")); + + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo") + .doesNotContain("-Pguides"); + } + + @Test + public void should_successfully_execute_a_deploy_command_for_rc_version_for_maven() + throws Exception { + ReleaserProperties properties = new ReleaserProperties(); properties.getMaven().setDeployCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + new ProcessExecutor(properties.getWorkingDir()) + .runCommand(new String[] { "touch", "pom.xml" }, 1); + ProjectCommandExecutor builder = projectBuilder(properties); builder.deploy(new ProjectVersion("foo", "1.0.0.RC1")); @@ -299,9 +327,24 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_deploy_command_for_release_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); + properties.getBash().setDeployCommand("echo foo"); + properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); + ProjectCommandExecutor builder = projectBuilder(properties); + + builder.deploy(new ProjectVersion("foo", "1.0.0.RELEASE")); + + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo"); + } + + @Test + public void should_successfully_execute_a_deploy_command_for_release_version_for_maven() + throws Exception { + ReleaserProperties properties = new ReleaserProperties(); properties.getMaven().setDeployCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + new ProcessExecutor(properties.getWorkingDir()) + .runCommand(new String[] { "touch", "pom.xml" }, 1); + ProjectCommandExecutor builder = projectBuilder(properties); builder.deploy(new ProjectVersion("foo", "1.0.0.RELEASE")); @@ -313,24 +356,23 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_deploy_command_for_sr_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setDeployCommand("echo foo"); + properties.getBash().setDeployCommand("echo foo"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.deploy(new ProjectVersion("foo", "1.0.0.SR1")); - then(asString(tmpFile("/builder/resolved/resolved.log"))) - .contains("foo -Pcentral"); + then(asString(tmpFile("/builder/resolved/resolved.log"))).contains("foo"); } @Test public void should_successfully_execute_a_deploy_command_with_sys_props_placeholder() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setDeployCommand("echo \"{{systemProps}}\""); - properties.getMaven().setSystemProperties("-Dhello=hello-world"); + properties.getBash().setDeployCommand("echo \"{{systemProps}}\""); + properties.getBash().setSystemProperties("-Dhello=hello-world"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.deploy(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -342,10 +384,10 @@ public class ProjectBuilderTests { public void should_successfully_pass_system_props_when_deploy_gets_executed_without_explicit_system_props() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setDeployCommand("echo "); - properties.getMaven().setSystemProperties("-Dhello=hello-world"); + properties.getBash().setDeployCommand("echo "); + properties.getBash().setSystemProperties("-Dhello=hello-world"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); builder.deploy(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT")); @@ -356,10 +398,10 @@ public class ProjectBuilderTests { @Test public void should_throw_exception_when_deploy_command_took_too_long_to_execute() { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setDeployCommand("sleep 1"); - properties.getMaven().setWaitTimeInMinutes(0); + properties.getBash().setDeployCommand("sleep 1"); + properties.getBash().setWaitTimeInMinutes(0); properties.setWorkingDir(tmpFile("/builder/unresolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); thenThrownBy( () -> builder.deploy(new ProjectVersion("foo", "1.0.0.BUILD-SNAPSHOT"))) @@ -370,10 +412,10 @@ public class ProjectBuilderTests { @Test public void should_successfully_execute_a_publish_docs_command() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setPublishDocsCommands(new String[] { "ls -al", "ls -al" }); + properties.getBash().setPublishDocsCommands(new String[] { "ls -al", "ls -al" }); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); TestProcessExecutor executor = testExecutor(properties.getWorkingDir()); - ProjectBuilder builder = new ProjectBuilder(properties) { + ProjectCommandExecutor builder = new ProjectCommandExecutor(properties) { @Override ProcessExecutor executor(String workingDir) { return executor; @@ -391,12 +433,12 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_publish_docs_command_with_sys_props_placeholder() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setPublishDocsCommands( + properties.getBash().setPublishDocsCommands( new String[] { "echo {{systemProps}} 1", "echo {{systemProps}} 2" }); - properties.getMaven().setSystemProperties("-Dhello=world -Dfoo=bar"); + properties.getBash().setSystemProperties("-Dhello=world -Dfoo=bar"); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); TestProcessExecutor executor = testExecutor(properties.getWorkingDir()); - ProjectBuilder builder = new ProjectBuilder(properties) { + ProjectCommandExecutor builder = new ProjectCommandExecutor(properties) { @Override ProcessExecutor executor(String workingDir) { return executor; @@ -414,11 +456,11 @@ public class ProjectBuilderTests { public void should_successfully_execute_a_publish_docs_command_and_substitute_the_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven() + properties.getBash() .setPublishDocsCommands(new String[] { "echo '{{version}}'" }); properties.setWorkingDir(tmpFile("/builder/resolved").getPath()); TestProcessExecutor executor = testExecutor(properties.getWorkingDir()); - ProjectBuilder builder = new ProjectBuilder(properties) { + ProjectCommandExecutor builder = new ProjectCommandExecutor(properties) { @Override ProcessExecutor executor(String workingDir) { return executor; @@ -435,11 +477,11 @@ public class ProjectBuilderTests { public void should_successfully_execute_an_update_docs_command_and_substitute_the_version() throws Exception { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setGenerateReleaseTrainDocsCommand("echo '{{version}}'"); + properties.getBash().setGenerateReleaseTrainDocsCommand("echo '{{version}}'"); File resolved = tmpFile("/builder/resolved"); properties.setWorkingDir(resolved.getPath()); TestProcessExecutor executor = testExecutor(properties.getWorkingDir()); - ProjectBuilder builder = new ProjectBuilder(properties) { + ProjectCommandExecutor builder = new ProjectCommandExecutor(properties) { @Override ProcessExecutor executor(String workingDir) { return executor; @@ -455,11 +497,11 @@ public class ProjectBuilderTests { @Test public void should_throw_exception_when_publish_docs_command_took_too_long_to_execute() { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven() + properties.getBash() .setPublishDocsCommands(new String[] { "sleep 1", "sleep 1" }); - properties.getMaven().setWaitTimeInMinutes(0); + properties.getBash().setWaitTimeInMinutes(0); properties.setWorkingDir(tmpFile("/builder/unresolved").getPath()); - ProjectBuilder builder = projectBuilder(properties); + ProjectCommandExecutor builder = projectBuilder(properties); thenThrownBy(() -> builder.publishDocs("")) .hasMessageContaining("Process waiting time of [0] minutes exceeded"); @@ -468,9 +510,9 @@ public class ProjectBuilderTests { @Test public void should_throw_exception_when_process_exits_with_invalid_code() { ReleaserProperties properties = new ReleaserProperties(); - properties.getMaven().setBuildCommand("exit 1"); + properties.getBash().setBuildCommand("exit 1"); properties.setWorkingDir(tmpFile("/builder/unresolved").getPath()); - ProjectBuilder builder = new ProjectBuilder(properties) { + ProjectCommandExecutor builder = new ProjectCommandExecutor(properties) { @Override ProcessExecutor executor(String workingDir) { return new ProcessExecutor(properties.getWorkingDir()) { diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/sagan/SaganUpdaterTest.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/sagan/SaganUpdaterTest.java index 0d8603a2..709cdc1f 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/sagan/SaganUpdaterTest.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/sagan/SaganUpdaterTest.java @@ -31,7 +31,7 @@ import org.mockito.BDDMockito; import org.mockito.Mockito; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectVersion; +import org.springframework.cloud.release.internal.project.ProjectVersion; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.BDDMockito.given; diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/template/TemplateGeneratorTests.java b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/template/TemplateGeneratorTests.java index 4e91f8ed..4f5993a8 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/template/TemplateGeneratorTests.java +++ b/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/template/TemplateGeneratorTests.java @@ -24,9 +24,9 @@ import java.util.HashSet; import org.junit.Test; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import static org.assertj.core.api.BDDAssertions.then; @@ -37,7 +37,7 @@ public class TemplateGeneratorTests { ReleaserProperties props = new ReleaserProperties(); - ProjectGitHandler handler = new ProjectGitHandler(this.props) { + ProjectGitHubHandler handler = new ProjectGitHubHandler(this.props) { @Override public String milestoneUrl(ProjectVersion releaseVersion) { if (releaseVersion.projectName.equals("spring-cloud-foo")) { @@ -118,8 +118,8 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Maven Central]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth | 1.0.0.RELEASE | ([issues](https://foo.bar.com))") - .contains("| Spring Cloud Foo\t| 1.0.2.RELEASE\t|  ") + "| Spring Cloud Sleuth | 1.0.0.RELEASE | ([issues](https://foo.bar.com))") + .contains("| Spring Cloud Foo | 1.0.2.RELEASE |  ") .contains("Dalston.RELEASE").contains( "mavenBom 'org.springframework.cloud:spring-cloud-dependencies:Dalston.RELEASE'"); } @@ -143,7 +143,7 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Maven Central]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth\t| 1.0.0.RELEASE\t| ([issues](https://foo.bar.com))") + "| Spring Cloud Sleuth | 1.0.0.RELEASE | ([issues](https://foo.bar.com))") .contains("Dalston.RELEASE").contains( "mavenBom 'org.springframework.cloud:spring-cloud-dependencies:Dalston.RELEASE'"); } @@ -167,7 +167,7 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Maven Central]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth | 1.0.0.RELEASE | ([issues](https://foo.bar.com))") + "| Spring Cloud Sleuth | 1.0.0.RELEASE | ([issues](https://foo.bar.com))") .contains("Dalston.SR1").contains( "mavenBom 'org.springframework.cloud:spring-cloud-dependencies:Dalston.SR1'"); } @@ -191,7 +191,7 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Maven Central]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth | 1.0.0.RELEASE | ([issues](https://foo.bar.com))") + "| Spring Cloud Sleuth | 1.0.0.RELEASE | ([issues](https://foo.bar.com))") .contains("Dalston.SR1").contains( "mavenBom 'org.springframework.cloud:spring-cloud-dependencies:Dalston.SR1'"); } @@ -215,7 +215,7 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Spring Milestone]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth\t| 1.0.0.M1\t| ([issues](https://foo.bar.com))") + "| Spring Cloud Sleuth | 1.0.0.M1 | ([issues](https://foo.bar.com))") .contains("spring-milestones") .contains("url 'https://repo.spring.io/milestone'") .contains("Dalston.M1").contains( @@ -241,7 +241,7 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Spring Milestone]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth\t| 1.0.0.M1\t| ([issues](https://foo.bar.com))") + "| Spring Cloud Sleuth | 1.0.0.M1 | ([issues](https://foo.bar.com))") .contains("spring-milestones") .contains("url 'https://repo.spring.io/milestone'") .contains("Dalston.M1").contains( @@ -267,7 +267,7 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Spring Milestone]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth\t| 1.0.0.RC1\t| ([issues](https://foo.bar.com))") + "| Spring Cloud Sleuth | 1.0.0.RC1 | ([issues](https://foo.bar.com))") .contains("spring-milestones") .contains("url 'https://repo.spring.io/milestone'") .contains("Dalston.RC1").contains( @@ -293,7 +293,7 @@ public class TemplateGeneratorTests { .contains("The release can be found in [Spring Milestone]") .contains("### Spring Cloud Sleuth") .contains( - "| Spring Cloud Sleuth\t| 1.0.0.RC1\t| ([issues](https://foo.bar.com))") + "| Spring Cloud Sleuth | 1.0.0.RC1 | ([issues](https://foo.bar.com))") .contains("spring-milestones") .contains("url 'https://repo.spring.io/milestone'") .contains("Dalston.RC1").contains( @@ -303,7 +303,7 @@ public class TemplateGeneratorTests { @Test public void should_generate_release_notes_template_when_url_exists() throws IOException { - ProjectGitHandler handler = new ProjectGitHandler(this.props) { + ProjectGitHubHandler handler = new ProjectGitHubHandler(this.props) { @Override public String milestoneUrl(ProjectVersion releaseVersion) { return "https://foo.bar.com?closed=1"; 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 76% 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 70bdb489..beda2144 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 @@ -21,19 +21,22 @@ import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; import java.nio.file.Files; +import java.util.ArrayList; +import java.util.Collections; import org.assertj.core.api.BDDAssertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.cloud.release.internal.ReleaserProperties; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.pom.TestUtils; +import org.springframework.cloud.release.internal.buildsystem.MavenBomParserAccessor; +import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.util.FileSystemUtils; -class VersionsFetcherTests { +class VersionsFromBomFetcherTests { File temporaryFolder; @@ -52,13 +55,14 @@ 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( file("/projects/spring-cloud-release/").toURI().toString() + "/"); - ProjectPomUpdater updater = new ProjectPomUpdater(properties); + ProjectPomUpdater updater = new ProjectPomUpdater(properties, Collections + .singletonList(MavenBomParserAccessor.cloudMavenBomParser(properties))); VersionsFetcher versionsFetcher = new VersionsFetcher(properties, updater); boolean latestGa = versionsFetcher.isLatestGa(projectVersion); @@ -71,13 +75,14 @@ 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( file("/projects/spring-cloud-release/").toURI().toString() + "/"); - ProjectPomUpdater updater = new ProjectPomUpdater(properties); + ProjectPomUpdater updater = new ProjectPomUpdater(properties, Collections + .singletonList(MavenBomParserAccessor.cloudMavenBomParser(properties))); VersionsFetcher versionsFetcher = new VersionsFetcher(properties, updater); boolean latestGa = versionsFetcher.isLatestGa(projectVersion); @@ -90,13 +95,13 @@ 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( file("/projects/spring-cloud-release/").toURI().toString()); - ProjectPomUpdater updater = new ProjectPomUpdater(properties); + ProjectPomUpdater updater = new ProjectPomUpdater(properties, new ArrayList<>()); VersionsFetcher versionsFetcher = new VersionsFetcher(properties, updater); boolean latestGa = versionsFetcher.isLatestGa(projectVersion); @@ -109,7 +114,7 @@ class VersionsFetcherTests { ProjectVersion projectVersion = new ProjectVersion("spring-cloud-contract", "1.0.0.BUILD-SNAPSHOT"); ReleaserProperties properties = new ReleaserProperties(); - ProjectPomUpdater updater = new ProjectPomUpdater(properties); + ProjectPomUpdater updater = new ProjectPomUpdater(properties, new ArrayList<>()); VersionsFetcher versionsFetcher = new VersionsFetcher(properties, updater); boolean latestGa = versionsFetcher.isLatestGa(projectVersion); @@ -123,7 +128,7 @@ class VersionsFetcherTests { "1.0.0.BUILD-SNAPSHOT"); ReleaserProperties properties = new ReleaserProperties(); VersionsFetcher versionsFetcher = new VersionsFetcher(properties, - new ProjectPomUpdater(properties) { + new ProjectPomUpdater(properties, new ArrayList<>()) { @Override public Projects retrieveVersionsFromReleaseTrainBom(String branch, boolean updateFixedVersions) { @@ -137,7 +142,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-core/src/test/resources/projects/spring-cloud-core-tests/bootstrap/src/test/java/demo/BootstrapClientApplicationTests.java b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/bootstrap/src/test/java/demo/BootstrapClientApplicationTests.java index 2b2235bc..c297cbd6 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/bootstrap/src/test/java/demo/BootstrapClientApplicationTests.java +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/bootstrap/src/test/java/demo/BootstrapClientApplicationTests.java @@ -38,7 +38,8 @@ public class BootstrapClientApplicationTests { public void contextLoads() throws Exception { assertThat(2).isEqualTo(this.server.getTomcat().getMaxThreads()); // The application.yml is never read because spring.config.name=sample - assertThat("application").isEqualTo(this.server.getServlet().getApplicationDisplayName()); + assertThat("application") + .isEqualTo(this.server.getServlet().getApplicationDisplayName()); } } diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-client-decrypt/src/test/java/demo/BootstrapDecryptionClientApplicationTests.java b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-client-decrypt/src/test/java/demo/BootstrapDecryptionClientApplicationTests.java index c716cb03..c4c04465 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-client-decrypt/src/test/java/demo/BootstrapDecryptionClientApplicationTests.java +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-client-decrypt/src/test/java/demo/BootstrapDecryptionClientApplicationTests.java @@ -26,8 +26,6 @@ import org.springframework.cloud.config.client.ConfigServicePropertySourceLocato import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.junit4.SpringRunner; -import static org.junit.Assert.assertNotNull; - @RunWith(SpringRunner.class) @SpringBootTest @DirtiesContext @@ -41,7 +39,8 @@ public class BootstrapDecryptionClientApplicationTests { @Test public void contextLoads() throws Exception { - assertThat(new String[] { "http://localhost:8888" }).isEqualTo(this.config.getUri()); + assertThat(new String[] { "http://localhost:8888" }) + .isEqualTo(this.config.getUri()); // The application.yml is never read because spring.config.name=sample assertThat(this.locator).isNotNull(); } diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-retry/src/test/java/demo/StandaloneClientApplicationTests.java b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-retry/src/test/java/demo/StandaloneClientApplicationTests.java index 140c6cba..01726a9c 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-retry/src/test/java/demo/StandaloneClientApplicationTests.java +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/config-retry/src/test/java/demo/StandaloneClientApplicationTests.java @@ -52,6 +52,7 @@ import static org.junit.Assert.fail; public class StandaloneClientApplicationTests { private static ConfigurableApplicationContext context; + @Autowired private ConfigServicePropertySourceLocator locator; diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/COMMIT_EDITMSG b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/COMMIT_EDITMSG new file mode 100644 index 00000000..e6b794df --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/COMMIT_EDITMSG @@ -0,0 +1 @@ +Added script diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/commit-msg.sample b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/commit-msg.sample index b58d1184..bc8d07cb 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/commit-msg.sample +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/commit-msg.sample @@ -18,7 +18,7 @@ # This example catches duplicate Signed-off-by lines. test "" = "$(grep '^Signed-off-by: ' "$1" | - sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { - echo >&2 Duplicate Signed-off-by lines. - exit 1 + sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { + echo >&2 Duplicate Signed-off-by lines. + exit 1 } diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-commit.sample b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-commit.sample index 68d62d54..6c55be87 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-commit.sample +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-commit.sample @@ -7,12 +7,11 @@ # # To enable this hook, rename this file to "pre-commit". -if git rev-parse --verify HEAD >/dev/null 2>&1 -then - against=HEAD +if git rev-parse --verify HEAD >/dev/null 2>&1; then + against=HEAD else - # Initial commit: diff against an empty tree object - against=4b825dc642cb6eb9a060e54bf8d69288fbee4904 + # Initial commit: diff against an empty tree object + against=4b825dc642cb6eb9a060e54bf8d69288fbee4904 fi # If you want to allow non-ASCII filenames set this variable to true. @@ -25,13 +24,12 @@ exec 1>&2 # them from being added to the repository. We exploit the fact that the # printable range starts at the space character and ends with tilde. if [ "$allownonascii" != "true" ] && - # Note that the use of brackets around a tr range is ok here, (it's - # even required, for portability to Solaris 10's /usr/bin/tr), since - # the square bracket bytes happen to fall in the designated range. - test $(git diff --cached --name-only --diff-filter=A -z $against | - LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 -then - cat <<\EOF + # Note that the use of brackets around a tr range is ok here, (it's + # even required, for portability to Solaris 10's /usr/bin/tr), since + # the square bracket bytes happen to fall in the designated range. + test $(git diff --cached --name-only --diff-filter=A -z $against | + LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0; then + cat <<\EOF Error: Attempt to add a non-ASCII file name. This can cause problems if you want to work with people on other platforms. @@ -42,7 +40,7 @@ If you know what you are doing you can disable this check using: git config hooks.allownonascii true EOF - exit 1 + exit 1 fi # If there are whitespace errors, print the offending file names and fail. diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-push.sample b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-push.sample index 6187dbf4..29d0a57a 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-push.sample +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-push.sample @@ -24,30 +24,26 @@ url="$2" z40=0000000000000000000000000000000000000000 -while read local_ref local_sha remote_ref remote_sha -do - if [ "$local_sha" = $z40 ] - then - # Handle delete - : - else - if [ "$remote_sha" = $z40 ] - then - # New branch, examine all commits - range="$local_sha" - else - # Update to existing branch, examine new commits - range="$remote_sha..$local_sha" - fi +while read local_ref local_sha remote_ref remote_sha; do + if [ "$local_sha" = $z40 ]; then + # Handle delete + : + else + if [ "$remote_sha" = $z40 ]; then + # New branch, examine all commits + range="$local_sha" + else + # Update to existing branch, examine new commits + range="$remote_sha..$local_sha" + fi - # Check for WIP commit - commit=`git rev-list -n 1 --grep '^WIP' "$range"` - if [ -n "$commit" ] - then - echo >&2 "Found WIP commit in $local_ref, not pushing" - exit 1 - fi - fi + # Check for WIP commit + commit=$(git rev-list -n 1 --grep '^WIP' "$range") + if [ -n "$commit" ]; then + echo >&2 "Found WIP commit in $local_ref, not pushing" + exit 1 + fi + fi done exit 0 diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-rebase.sample b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-rebase.sample index 6cbef5c3..e2532c61 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-rebase.sample +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-rebase.sample @@ -17,20 +17,19 @@ publish=next basebranch="$1" -if test "$#" = 2 -then - topic="refs/heads/$2" +if test "$#" = 2; then + topic="refs/heads/$2" else - topic=`git symbolic-ref HEAD` || - exit 0 ;# we do not interrupt rebasing detached HEAD + topic=$(git symbolic-ref HEAD) || + exit 0 # we do not interrupt rebasing detached HEAD fi case "$topic" in -refs/heads/??/*) - ;; +refs/heads/??/*) ;; + *) - exit 0 ;# we do not interrupt others. - ;; + exit 0 # we do not interrupt others. + ;; esac # Now we are dealing with a topic branch being rebased @@ -38,34 +37,31 @@ esac # Does the topic really exist? git show-ref -q "$topic" || { - echo >&2 "No such branch $topic" - exit 1 + echo >&2 "No such branch $topic" + exit 1 } # Is topic fully merged to master? -not_in_master=`git rev-list --pretty=oneline ^master "$topic"` -if test -z "$not_in_master" -then - echo >&2 "$topic is fully merged to master; better remove it." - exit 1 ;# we could allow it, but there is no point. +not_in_master=$(git rev-list --pretty=oneline ^master "$topic") +if test -z "$not_in_master"; then + echo >&2 "$topic is fully merged to master; better remove it." + exit 1 # we could allow it, but there is no point. fi # Is topic ever merged to next? If so you should not be rebasing it. -only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` -only_next_2=`git rev-list ^master ${publish} | sort` -if test "$only_next_1" = "$only_next_2" -then - not_in_topic=`git rev-list "^$topic" master` - if test -z "$not_in_topic" - then - echo >&2 "$topic is already up to date with master" - exit 1 ;# we could allow it, but there is no point. - else - exit 0 - fi +only_next_1=$(git rev-list ^master "^$topic" ${publish} | sort) +only_next_2=$(git rev-list ^master ${publish} | sort) +if test "$only_next_1" = "$only_next_2"; then + not_in_topic=$(git rev-list "^$topic" master) + if test -z "$not_in_topic"; then + echo >&2 "$topic is already up to date with master" + exit 1 # we could allow it, but there is no point. + else + exit 0 + fi else - not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` - /usr/bin/perl -e ' + not_in_next=$(git rev-list --pretty=oneline ^${publish} "$topic") + /usr/bin/perl -e ' my $topic = $ARGV[0]; my $msg = "* $topic has commits already merged to public branch:\n"; my (%not_in_next) = map { @@ -85,7 +81,7 @@ else } } ' "$topic" "$not_in_next" "$not_in_master" - exit 1 + exit 1 fi <<\DOC_END diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-receive.sample b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-receive.sample index a1fd29ec..66107d96 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-receive.sample +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/pre-receive.sample @@ -6,19 +6,18 @@ # # To enable this hook, rename this file to "pre-receive". -if test -n "$GIT_PUSH_OPTION_COUNT" -then - i=0 - while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" - do - eval "value=\$GIT_PUSH_OPTION_$i" - case "$value" in - echoback=*) - echo "echo from the pre-receive-hook: ${value#*=}" >&2 - ;; - reject) - exit 1 - esac - i=$((i + 1)) - done +if test -n "$GIT_PUSH_OPTION_COUNT"; then + i=0 + while test "$i" -lt "$GIT_PUSH_OPTION_COUNT"; do + eval "value=\$GIT_PUSH_OPTION_$i" + case "$value" in + echoback=*) + echo "echo from the pre-receive-hook: ${value#*=}" >&2 + ;; + reject) + exit 1 + ;; + esac + i=$((i + 1)) + done fi diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/update.sample b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/update.sample index 80ba9413..68a5e634 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/update.sample +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/hooks/update.sample @@ -31,15 +31,15 @@ newrev="$3" # --- Safety check if [ -z "$GIT_DIR" ]; then - echo "Don't run this script from the command line." >&2 - echo " (if you want, you could supply GIT_DIR then run" >&2 - echo " $0 )" >&2 - exit 1 + echo "Don't run this script from the command line." >&2 + echo " (if you want, you could supply GIT_DIR then run" >&2 + echo " $0 )" >&2 + exit 1 fi if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then - echo "usage: $0 " >&2 - exit 1 + echo "usage: $0 " >&2 + exit 1 fi # --- Config @@ -53,75 +53,74 @@ allowmodifytag=$(git config --bool hooks.allowmodifytag) projectdesc=$(sed -e '1q' "$GIT_DIR/description") case "$projectdesc" in "Unnamed repository"* | "") - echo "*** Project description file hasn't been set" >&2 - exit 1 - ;; + echo "*** Project description file hasn't been set" >&2 + exit 1 + ;; esac # --- Check types # if $newrev is 0000...0000, it's a commit to delete a ref. zero="0000000000000000000000000000000000000000" if [ "$newrev" = "$zero" ]; then - newrev_type=delete + newrev_type=delete else - newrev_type=$(git cat-file -t $newrev) + newrev_type=$(git cat-file -t $newrev) fi case "$refname","$newrev_type" in - refs/tags/*,commit) - # un-annotated tag - short_refname=${refname##refs/tags/} - if [ "$allowunannotated" != "true" ]; then - echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2 - echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 - exit 1 - fi - ;; - refs/tags/*,delete) - # delete tag - if [ "$allowdeletetag" != "true" ]; then - echo "*** Deleting a tag is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/tags/*,tag) - # annotated tag - if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 - then - echo "*** Tag '$refname' already exists." >&2 - echo "*** Modifying a tag is not allowed in this repository." >&2 - exit 1 - fi - ;; - refs/heads/*,commit) - # branch - if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then - echo "*** Creating a branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/heads/*,delete) - # delete branch - if [ "$allowdeletebranch" != "true" ]; then - echo "*** Deleting a branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - refs/remotes/*,commit) - # tracking branch - ;; - refs/remotes/*,delete) - # delete tracking branch - if [ "$allowdeletebranch" != "true" ]; then - echo "*** Deleting a tracking branch is not allowed in this repository" >&2 - exit 1 - fi - ;; - *) - # Anything else (is there anything else?) - echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 - exit 1 - ;; +refs/tags/*,commit) + # un-annotated tag + short_refname=${refname##refs/tags/} + if [ "$allowunannotated" != "true" ]; then + echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2 + echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 + exit 1 + fi + ;; +refs/tags/*,delete) + # delete tag + if [ "$allowdeletetag" != "true" ]; then + echo "*** Deleting a tag is not allowed in this repository" >&2 + exit 1 + fi + ;; +refs/tags/*,tag) + # annotated tag + if [ "$allowmodifytag" != "true" ] && git rev-parse $refname >/dev/null 2>&1; then + echo "*** Tag '$refname' already exists." >&2 + echo "*** Modifying a tag is not allowed in this repository." >&2 + exit 1 + fi + ;; +refs/heads/*,commit) + # branch + if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then + echo "*** Creating a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; +refs/heads/*,delete) + # delete branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; +refs/remotes/*,commit) + # tracking branch + ;; +refs/remotes/*,delete) + # delete tracking branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a tracking branch is not allowed in this repository" >&2 + exit 1 + fi + ;; +*) + # Anything else (is there anything else?) + echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 + exit 1 + ;; esac # --- Finished diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/index b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/index index 83371279..a2ef8e34 100644 Binary files a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/index and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/index differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/HEAD b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/HEAD index 7b3645e5..7c437b1a 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/HEAD +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/HEAD @@ -1 +1,2 @@ 0000000000000000000000000000000000000000 6b833ad3b334f1ccf60e0bd27ff5781e618e79aa Marcin Grzejszczak 1540290537 +0200 clone: from git@github.com:spring-cloud/spring-cloud-core-tests.git +6b833ad3b334f1ccf60e0bd27ff5781e618e79aa aeef09d318e80a96a54332a3eccfa72d6cc56689 Marcin Grzejszczak 1566838500 +0200 commit: Added script diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/refs/heads/master b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/refs/heads/master index 7b3645e5..7c437b1a 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/refs/heads/master +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/logs/refs/heads/master @@ -1 +1,2 @@ 0000000000000000000000000000000000000000 6b833ad3b334f1ccf60e0bd27ff5781e618e79aa Marcin Grzejszczak 1540290537 +0200 clone: from git@github.com:spring-cloud/spring-cloud-core-tests.git +6b833ad3b334f1ccf60e0bd27ff5781e618e79aa aeef09d318e80a96a54332a3eccfa72d6cc56689 Marcin Grzejszczak 1566838500 +0200 commit: Added script diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/07e3e2d5db844ce7b88f3e4705d39d8acaf68f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/07e3e2d5db844ce7b88f3e4705d39d8acaf68f new file mode 100644 index 00000000..156204b0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/07e3e2d5db844ce7b88f3e4705d39d8acaf68f differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/10457896955bfea6e6a05c9cf880b759d7320f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/10457896955bfea6e6a05c9cf880b759d7320f new file mode 100644 index 00000000..d1124833 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/10457896955bfea6e6a05c9cf880b759d7320f @@ -0,0 +1,4 @@ +xmSAnÛ0ìÕ|ŧ$ph'- +´¹Xq\Th`–S#GJZÉÛȤJRQŒ ïRVÛ¸©‚¸ÜÎÌRieR¸˜\~|7>p3Sï-•[—“‹÷çüú~‹`¸HZU ¿5–×ý—“ È[ÊP;Ì¡Ñ9ÚÕ*cl¿3‚ïh —r'uØo O¯ÅÞ4°S{ÐÆCã9ÈAA>eX{ ™ÙÕ)!´ä·Ý9=KP÷=‡I½âvÅ€z¦xÝÊ÷¢!<[ïk÷y[ÔMÊW ºnþauAe‚–çî`>øsð,Ä`>Å =Êù—èâ¸5*w'§Ü5xâEüÌbý \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/425bc517960a423c57d8955fdb3b365460a881 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/425bc517960a423c57d8955fdb3b365460a881 new file mode 100644 index 00000000..4d1bf275 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/01/425bc517960a423c57d8955fdb3b365460a881 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/11cd33108da7f28c70d91542cc123a4665c47c b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/11cd33108da7f28c70d91542cc123a4665c47c new file mode 100644 index 00000000..d213c673 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/11cd33108da7f28c70d91542cc123a4665c47c differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/c8a9e576df3407af8288af8fbf5531c44dd4c9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/c8a9e576df3407af8288af8fbf5531c44dd4c9 new file mode 100644 index 00000000..fe847177 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/c8a9e576df3407af8288af8fbf5531c44dd4c9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/f03fd5487cce4ce37f01933993fca0804d5803 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/f03fd5487cce4ce37f01933993fca0804d5803 new file mode 100644 index 00000000..7b31b757 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/02/f03fd5487cce4ce37f01933993fca0804d5803 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/523674a49e04a991b08cc3cef52f19fa3d2bfb b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/523674a49e04a991b08cc3cef52f19fa3d2bfb new file mode 100644 index 00000000..5c4028a1 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/523674a49e04a991b08cc3cef52f19fa3d2bfb differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/54ec3cd6cca1aabd257bd27ea2f3d368e6d2c2 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/54ec3cd6cca1aabd257bd27ea2f3d368e6d2c2 new file mode 100644 index 00000000..86cbd96f Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/54ec3cd6cca1aabd257bd27ea2f3d368e6d2c2 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/645e8cee9e5ed0e1bc731e76e048d31687638f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/645e8cee9e5ed0e1bc731e76e048d31687638f new file mode 100644 index 00000000..8d08ca9b --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/03/645e8cee9e5ed0e1bc731e76e048d31687638f @@ -0,0 +1,4 @@ +xÝUÛn1å5ýŠ!B$v—R$.Ú¦jI"‘¶J¨O•³;I,ymËö&|;cï%!MQ‹x·ÙñÌñ93Gë©PS8|÷æõ£ô䦰Dc¹’ÇÝÃøePf*çr~ܽúü1zÛ=餣”ít(6¾Â&öa'åyÏ V±Õ†Jc®Ò„RᨤÉ +ì=ù†r^÷—Ÿ.¾^_MãóÓÑà{š´5¡C3kWÊä·:.O'“/ã>u´5žIRÑòë0ÕF͸ÀŠmýQqzEþ¦Îy|ƒ[p õ1P¨¤Xà ‚S`K­•qàZ`2‡a`©‡9ÈHŽ`Ä–(á(>ŠîÐ|ê@"æ˜$u dª(<„àÏ`­JÎV†ilf¸vð¬XÊÕsPf«.@3Ìñ%ÖW®¸[„~Ãç ×l3†A&¸&芷]¨Rä —ΓGnê~§±™“Ô€fÑ,üô^x™ÒëpK;&I³©p~$qñŠÆ^™$&O…DQëŒÊG°Œ%CI' <[÷qÆJázΔ˜&»YO°ÎnšSo;Ë2¼Z4Õ´©u…ìY‘ˆ¬dš¦álK‡‚='Áº0Ù„tK'-è-œÓö}’üêôDð©mq#¡2&ÈÑT_·¶WÖ‰NŠ’MæµÎæ«.OvêÓp_Xëù­ÀÂ;Þ)‰w*mU~[ÔMÆ«]7$–V˜E‡í ‘g^„8‡OqÒ·?[ÍËÈ•Þ½U…?=ãΓW!^Å/çMb \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0b/ab2242b6fda577c3131bc19b14c3cfde29c3fc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0b/ab2242b6fda577c3131bc19b14c3cfde29c3fc new file mode 100644 index 00000000..9d27d3fd Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0b/ab2242b6fda577c3131bc19b14c3cfde29c3fc differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/21588e05ccdf40ee8eeeaa1757d07bb6494bb3 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/21588e05ccdf40ee8eeeaa1757d07bb6494bb3 new file mode 100644 index 00000000..5b4502c5 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/21588e05ccdf40ee8eeeaa1757d07bb6494bb3 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/2f08558d3ce04a6b06b656e2485507996f6c4e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/2f08558d3ce04a6b06b656e2485507996f6c4e new file mode 100644 index 00000000..1040ca1e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/2f08558d3ce04a6b06b656e2485507996f6c4e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/fb51cc4451bb3d68e8ede17f7e4d071582aca0 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/fb51cc4451bb3d68e8ede17f7e4d071582aca0 new file mode 100644 index 00000000..be365633 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0c/fb51cc4451bb3d68e8ede17f7e4d071582aca0 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0f/33f64ea1c39c97b004ef6a033ac195960a385d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0f/33f64ea1c39c97b004ef6a033ac195960a385d new file mode 100644 index 00000000..006785f0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/0f/33f64ea1c39c97b004ef6a033ac195960a385d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/10956700d3976fd1939251ef76dbe2434701f7 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/10956700d3976fd1939251ef76dbe2434701f7 new file mode 100644 index 00000000..fb388ec8 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/10956700d3976fd1939251ef76dbe2434701f7 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/48d21548560fbc1207d86bbaaad2db6022d7e4 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/48d21548560fbc1207d86bbaaad2db6022d7e4 new file mode 100644 index 00000000..fbdc9523 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/48d21548560fbc1207d86bbaaad2db6022d7e4 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/9040e75e3792701d28f1eae6a70783aba13879 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/9040e75e3792701d28f1eae6a70783aba13879 new file mode 100644 index 00000000..da64d290 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/9040e75e3792701d28f1eae6a70783aba13879 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/9d12c26cb60ad71c7e21c8ac5da8de2aca2568 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/9d12c26cb60ad71c7e21c8ac5da8de2aca2568 new file mode 100644 index 00000000..541c0769 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/9d12c26cb60ad71c7e21c8ac5da8de2aca2568 @@ -0,0 +1,4 @@ +x¥T]oÓ0åµùW}êPçŽ!&A_Öuˆ-jÊÇ„xpœ›ÔZjÛ!«Ðþ;×Niâ«m}í{|î9÷:-u +ONNNMGðæºÚYl=yzH_ÏÁm4¥â%ðÚmµ¡u÷Ï2Jó™—R ²˜A­24!iVqA¹ÝÎÞ¡±R+8fG0ò¨Ãnkx0õ{]ÃŽïAiµEÂrY"àÀÊT ô®*%W¡‘nîéP<¸ê0tê8ç”PíAçýƒÀ]Gügë\e_L&MÓ0(3mŠIÙd'—ñ|±L‡D»K{«J´ ~®¥¡’Ó=ðŠh žÙ’7AŸÂ í9íi7F:©Š1X»†ô\3i‘ií~R­«¨öþÒ+Έ“!œÍ’8{÷ñæåêíÞÏÖëÙr/X­a¾ZžÇ›xµ¤ÕÌ–Wð*^žI3ro*ã+ ¥×³ ^‚^ô;Ç §}¿¶ +™KA¥©¢æB¡¿ QTThvÒz_-Ì<¥Rî¤ã.„~tCÏ¥I‘Î×(ÞF±ÐÆŸ‚ÙÊnnøm®YªµcIÎZ‘=òô·)Ô©Zh•Ë¢6؜֟‚ˆR×SèòRÞ0ò)ÕŠ­ÃÏœSnM&^¾‡ˆ[5Ù¾gÚÍ1!‹­f~ÕB̵rxóHk´nƒä"wø”¨tmvÜÞíPPWtˆŸ# Siÿ=¨Ï¸¢íÀLÙwOÚÈBù™ékBÝpÚÚý‹[Ñi_ýÑ0×zxà=8½âÃñ‡× ðíã_zsÚÎ:üî <£Xè]jãàQTÕ)M1ˆ’Ópôoë5 |¢½–êôÓKͳ3Nc!0ó‘6z†4ªV[Zߤp¦ì%®BôŒÚ¬‡Œ —§5f°úêuEÏ^è¬øJ‡]m(là>™ÑÔ]Ên=, é «Ázû|Ñ2£ZªQBï–*>~n +KwDƒÁ½ e¦V£4¤Y …Çmú4ÜFÑmô 0,Ey \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/cb65c3f7fb479d7d3d851b69749489ecb9f57d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/cb65c3f7fb479d7d3d851b69749489ecb9f57d new file mode 100644 index 00000000..00869ddb Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/cb65c3f7fb479d7d3d851b69749489ecb9f57d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/da4b03a553337d470c099ed7a5066937fecdb0 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/da4b03a553337d470c099ed7a5066937fecdb0 new file mode 100644 index 00000000..528682dc Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/da4b03a553337d470c099ed7a5066937fecdb0 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/e3fd26e437b71e04e367b2996b53085859d718 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/e3fd26e437b71e04e367b2996b53085859d718 new file mode 100644 index 00000000..5dbd2045 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/11/e3fd26e437b71e04e367b2996b53085859d718 @@ -0,0 +1 @@ +x=KÂ0 DY÷¾ABPe…â°aç¦.D˜8ʧNOÚ´ì&ñ›ñ¸eiaÓlWÁycïª@çØhŒFìø°ø"ß”ø(¶7÷“ ZòŸ …˜ Í’º‚ê ( òÅ<ª) Àaoñú«yУá3†¨ úDóg·ìZ2ÈbË”ýVQòôÄq¬ÙÌû£éêy1vÔcâx›yÄ肪뱗RK¥‹F~HîÐìwëºD×Õp“\ \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/79683cf7367516cf4a58a114e39c5d9357a579 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/79683cf7367516cf4a58a114e39c5d9357a579 new file mode 100644 index 00000000..51e81354 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/79683cf7367516cf4a58a114e39c5d9357a579 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/974ecb781efc46c1a17b45bb617c74efa18a16 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/974ecb781efc46c1a17b45bb617c74efa18a16 new file mode 100644 index 00000000..2e25421b Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/974ecb781efc46c1a17b45bb617c74efa18a16 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/9fbcc86f9a8f545edf3a98d71fa2a4b9f5b76b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/9fbcc86f9a8f545edf3a98d71fa2a4b9f5b76b new file mode 100644 index 00000000..9e1367de Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/9fbcc86f9a8f545edf3a98d71fa2a4b9f5b76b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/a1f01d28f5fab915642a87b89838666f39701a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/a1f01d28f5fab915642a87b89838666f39701a new file mode 100644 index 00000000..97c27bcd Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/a1f01d28f5fab915642a87b89838666f39701a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/f05030cdedb3ef85a9873886c63161d120fdc2 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/f05030cdedb3ef85a9873886c63161d120fdc2 new file mode 100644 index 00000000..7720838d Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/12/f05030cdedb3ef85a9873886c63161d120fdc2 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/0c6cbaa8929a5b3c29928741ad04caa9efad73 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/0c6cbaa8929a5b3c29928741ad04caa9efad73 new file mode 100644 index 00000000..8f8281fd Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/0c6cbaa8929a5b3c29928741ad04caa9efad73 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/20c135339b445809162b38a692ef99941f1d95 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/20c135339b445809162b38a692ef99941f1d95 new file mode 100644 index 00000000..aeec9368 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/20c135339b445809162b38a692ef99941f1d95 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/3d12d86aa3a2b7f831a0430ce4de8b28d82a51 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/3d12d86aa3a2b7f831a0430ce4de8b28d82a51 new file mode 100644 index 00000000..9b76a070 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/14/3d12d86aa3a2b7f831a0430ce4de8b28d82a51 @@ -0,0 +1,3 @@ +x¥Sßo›0Þ+ü'žÒ*…¶“¦mÕ¤fi¶¢¶‰ÒU}4p€Wc3Û„DSÿ÷ ÙšIÝËò€â³ïó÷㜠+•ÂÙÙûwo¢cŽaªš­æeeáüôìí }>€­¹dXk+¥i=ü3!µ¹Î[ž¡4˜C+sÔ}Ó¤aõ;cø†Úp%á<<…‘C †­àèÂAlU 5Û‚TZƒ„Á \ à&ÃÆ—©ºœÉ ¡ã¶êïPx0TjgÔÐlA/³ip¿ÊÚÆ|Œ¢®ëBÖS•.#±d¢Ûx:›'³¢=´ÝKÆ€Æ-×$9ÝkˆVÆR"+X×ûSj¤=«íNsËe9£ +Û1ŽkÎÕ ‘»'ƒ–…ˆ: CÙ»ÀJ.¯ªJr»ÝDBØ!e¸vûÂ"oÉ|µ‰Ú%ä—’ó§Õj.¶?`d‚.ÔJúé–èõ(˜‰Q£ñ5LÄRÖ¸…–øÍÙd°aöQ•e›úÔ옉‹WGN5.²º]ÞTe®—IÃØÈ`5fBˆøŒ@kËIs8_P;[G%«Ë1“=2ÔÀð>Ã~hÖi‚Ù±Óà‹_Q'•wS'w9î? CÌýÿ¥3ì~1$ß÷½HÚÚ;c9V¦iÒNF›haC˜ qh1ýĦåڦŞWâ&##ÚhØt)Ø-PÄo帠 \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1c/f8cc93f14e4ec7b3e6d2566653c1073f0a915f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1c/f8cc93f14e4ec7b3e6d2566653c1073f0a915f new file mode 100644 index 00000000..989e08af Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1c/f8cc93f14e4ec7b3e6d2566653c1073f0a915f differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1e/120f6fdc27b578aafd3db30500b1a0bea0d9e5 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1e/120f6fdc27b578aafd3db30500b1a0bea0d9e5 new file mode 100644 index 00000000..d7139f7b Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1e/120f6fdc27b578aafd3db30500b1a0bea0d9e5 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1e/2fae7bc4a81cc3b0c2bf94ea6b7a1497083645 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1e/2fae7bc4a81cc3b0c2bf94ea6b7a1497083645 new file mode 100644 index 00000000..ac539ba4 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/1e/2fae7bc4a81cc3b0c2bf94ea6b7a1497083645 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/20/005fb4c9b9ca7c85ff2aebf611942a041fef6b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/20/005fb4c9b9ca7c85ff2aebf611942a041fef6b new file mode 100644 index 00000000..6a209965 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/20/005fb4c9b9ca7c85ff2aebf611942a041fef6b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/20/b325dcc7a5a9eb5610fc1587bfcac9313ff1c1 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/20/b325dcc7a5a9eb5610fc1587bfcac9313ff1c1 new file mode 100644 index 00000000..4a3b9b35 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/20/b325dcc7a5a9eb5610fc1587bfcac9313ff1c1 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/22/ee771cad7c4b0f17d9b038c3d7aa6a9aebc15e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/22/ee771cad7c4b0f17d9b038c3d7aa6a9aebc15e new file mode 100644 index 00000000..a06475c9 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/22/ee771cad7c4b0f17d9b038c3d7aa6a9aebc15e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/22/f856ada5bace418b04683f231c364cc113ed41 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/22/f856ada5bace418b04683f231c364cc113ed41 new file mode 100644 index 00000000..18c6692a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/22/f856ada5bace418b04683f231c364cc113ed41 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/23/d1b12d777b8aff1473b5aee2f5897a9b5b8184 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/23/d1b12d777b8aff1473b5aee2f5897a9b5b8184 new file mode 100644 index 00000000..d1589534 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/23/d1b12d777b8aff1473b5aee2f5897a9b5b8184 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/56ddbc58516524f228483a85b0cc2e7088af8b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/56ddbc58516524f228483a85b0cc2e7088af8b new file mode 100644 index 00000000..4357d96a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/56ddbc58516524f228483a85b0cc2e7088af8b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/60f1beed2a074726a8a0e946387f8ca0c662c8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/60f1beed2a074726a8a0e946387f8ca0c662c8 new file mode 100644 index 00000000..657faa91 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/60f1beed2a074726a8a0e946387f8ca0c662c8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/cd2a2c1086906a2e399bbec584e1c93df1f4f9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/cd2a2c1086906a2e399bbec584e1c93df1f4f9 new file mode 100644 index 00000000..d89f6dad Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/cd2a2c1086906a2e399bbec584e1c93df1f4f9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/d788c5943f09a1bbd8af6010636cb6f8b422f9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/d788c5943f09a1bbd8af6010636cb6f8b422f9 new file mode 100644 index 00000000..48fb063e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/24/d788c5943f09a1bbd8af6010636cb6f8b422f9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/1bf5f968833778852f4975ed010b2ce64c2cc7 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/1bf5f968833778852f4975ed010b2ce64c2cc7 new file mode 100644 index 00000000..3a33aea6 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/1bf5f968833778852f4975ed010b2ce64c2cc7 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/223594edc1481bdbfca32225a7f1c3a66ddeb9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/223594edc1481bdbfca32225a7f1c3a66ddeb9 new file mode 100644 index 00000000..6a5ed6da Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/223594edc1481bdbfca32225a7f1c3a66ddeb9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/7953d389fc8451520f2f71552fb4476277291b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/7953d389fc8451520f2f71552fb4476277291b new file mode 100644 index 00000000..1eedbe54 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/7953d389fc8451520f2f71552fb4476277291b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/97222b8c3d4b2c49c7fc3e5288da62574320c9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/97222b8c3d4b2c49c7fc3e5288da62574320c9 new file mode 100644 index 00000000..63a854ae Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/25/97222b8c3d4b2c49c7fc3e5288da62574320c9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/26/010ebd861c7280a21e27fcf77164624d5bd15d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/26/010ebd861c7280a21e27fcf77164624d5bd15d new file mode 100644 index 00000000..02b44f74 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/26/010ebd861c7280a21e27fcf77164624d5bd15d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/26/914b5d4da8bc81fe4d5dc108190d959994824c b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/26/914b5d4da8bc81fe4d5dc108190d959994824c new file mode 100644 index 00000000..ca856deb --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/26/914b5d4da8bc81fe4d5dc108190d959994824c @@ -0,0 +1,5 @@ +x}TMoÚ@íÿŠ'‘…|Úæ!T±A…I£{l¶1»Îî8Uùï5n‚›¨> öãÍ{oÞثܬàôüâüÓà8€c˜˜bgU¶&8žžŸðÏ 5‚áM¥e²¤µ±¼nþ9Á0¼U1j‡ ”:A[ƒÆ…ŒÛœôá'Z§Œ†31„ž¯ÚmŽºG—¾ÄΔ°‘;І tÈ5”ƒT帱 Pb³)r%uŒP)Z× ÷ŒÓÁma½ŽQù~bR7/Bßô×Ä ås¿vÆ*U1[ÓY)3„Ì<£Õì +´å|®Ž&^R®6Š$Õ[oÓpÒ ¸Ï¾P‚s¬ÂXòé +”æjËQJ§FLK‹2ÔŽ|ê£S•]þpPâW©‰%:ú`Û–Z£‹Rß³õ7&t…e©•¬Œ}+”Ú‰TÆdìNHÍsX»ã’Lå“n¼ƒC‚X†ˆ&Ü’ˆj‚+Þ§î_p; ¼V–:¶ë+ý—·EY7ã¢af×lžMÿ½½¢ý¾ˆséÜQ0jË Fmî (W<ÚP߆H%K;Þ»ÏØ[sð;:£×>Rã¡"C<:è4ÏF%<µå[#×;âÂ_ûýÅvµÉͲcúÁ“´vØZš>•2w½.Ö“ôªÂ3ñ,ÁZ:~?ŸeFvûðy8öƒ?m +‘!ÍŒŽ0æB{þpyy/ÁWÖÓ_ \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/27/05064df8cd6bb37bd69acc6e7033fc2bd5d80e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/27/05064df8cd6bb37bd69acc6e7033fc2bd5d80e new file mode 100644 index 00000000..babe20ae --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/27/05064df8cd6bb37bd69acc6e7033fc2bd5d80e @@ -0,0 +1 @@ +xm‘Ánà †wÎSì\­Ë´”ãºi0íHâ*ÁÈ@²íéMs ,ÿþ?[vo±|n»‡àÉ8Ť÷Ö 2tÌÉ ÄoJÖ~ÿ4hb)ŠÓ©m›"1£ŒG/crAðÉ„Q«L˜"&ÇÉ8–k´à·˜ÿ$²â‚´H¯t…8Þý%ÜÛorå.™ŠÐË £½¿ˆÅ®cô‚s‹ƒ´C/ùU¥·1ô’¥‘×À•‰:õlÀià‚‰f†£9ñ ñxF¼xZ¿Ê’̽çni9¿5¬†îÚ®m,*U.jaË[O|¡|ÖéÊèÅÛûë×Ǥ»Ó \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/27/f3a58a7573fb5326d07fd419a444101b92b864 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/27/f3a58a7573fb5326d07fd419a444101b92b864 new file mode 100644 index 00000000..678ac04a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/27/f3a58a7573fb5326d07fd419a444101b92b864 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/28/4b968b18fec7863ce2f240144f82ba947041bb b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/28/4b968b18fec7863ce2f240144f82ba947041bb new file mode 100644 index 00000000..afe6b280 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/28/4b968b18fec7863ce2f240144f82ba947041bb differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/28/96b7f081b5147763ebbf2a0fdba61dc8636317 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/28/96b7f081b5147763ebbf2a0fdba61dc8636317 new file mode 100644 index 00000000..799076f0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/28/96b7f081b5147763ebbf2a0fdba61dc8636317 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/29/b76ab14c1aa22b2a4dea14ad58c91e20d8f817 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/29/b76ab14c1aa22b2a4dea14ad58c91e20d8f817 new file mode 100644 index 00000000..d90a5327 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/29/b76ab14c1aa22b2a4dea14ad58c91e20d8f817 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/888c165936552d97605b747cb853bcd0a7dc31 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/888c165936552d97605b747cb853bcd0a7dc31 new file mode 100644 index 00000000..f04ab9ea Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/888c165936552d97605b747cb853bcd0a7dc31 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/89d4de6653c81c21ab213f9c97da05c24cda80 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/89d4de6653c81c21ab213f9c97da05c24cda80 new file mode 100644 index 00000000..9e839d71 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/89d4de6653c81c21ab213f9c97da05c24cda80 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/af0a96ead26ce1615fb768875d9941b149f2fa b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/af0a96ead26ce1615fb768875d9941b149f2fa new file mode 100644 index 00000000..9ebed07d Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2a/af0a96ead26ce1615fb768875d9941b149f2fa differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/17d9d304d10eaf8ab29f0cd9c4b6ad7a47594a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/17d9d304d10eaf8ab29f0cd9c4b6ad7a47594a new file mode 100644 index 00000000..6b71bcfa Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/17d9d304d10eaf8ab29f0cd9c4b6ad7a47594a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/2235bce7e286b5aada0dbb6bb23da5f8cb3375 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/2235bce7e286b5aada0dbb6bb23da5f8cb3375 new file mode 100644 index 00000000..ced7b03b Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/2235bce7e286b5aada0dbb6bb23da5f8cb3375 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/301a415819e421e0679ca2448bd476ac801656 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/301a415819e421e0679ca2448bd476ac801656 new file mode 100644 index 00000000..3bc4afd8 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/2b/301a415819e421e0679ca2448bd476ac801656 @@ -0,0 +1 @@ +x1Â0 E™9E%æ¦R²12C¸‘Ö•ãHÀé ˆ‘"&{xïÛßGöU»Û®(Kлa—uh Å€I?ãÐ[G#Ö?¡#H o°pe]ÂR:ñS'Áªs²Mƒ›çC<.™9Aöå=–ðpøo_8 Á¼ê0¹.m¿žÞT=|¾Ø'[ç¨ ¹ÚëZp™#´Âíúÿ ,^ <*sœÚ9tªO,úðRô¡ÿš”T÷g«1¥ÈÉš¬^!Tê€F’#ÐhöÂú¹ZXxIµØ Ç]õ{N¦2F9?y¢÷jΩPÆ‘ž*°Úoiø[ež‚L)¤ýet Ù3Ïÿ ¡MU¹’¥¨ƒÁ-q½"aá´ßÞ›a¯—ü€vhÈGÈnŽ¿ýÅt“Ѭ!¯9Eè‹4F®£)…K÷c/iPÀŽët¶6`9-ŠE”4’‰R¤JRQŒEþ{‡”šÊMtëƒ!Š3oÞ̼¥R§ðüôïÓ¿¦O"x ]Œ(÷^<{þò)ý‚Û#hz)—À·×†Îý“eäæ=ß‹ •Å•£ NóšgäÛßLà#+´‚ìÄuÜ_OÎ<ÄA7Pñ(í ±HÂB!$^gX; +2]ÕRp•!´ÂíCœÅ3Ï=†N'sNõt14îzÒà{çjûj:mÛ–ñ@™iSNe—¾_-–ëdù”h÷n—J¢µ`ð[# ¥œ€×D+ã)‘•¼ õ) ÒÓžvk„ªœ€Õ…k¹AÏ5Ö‘6î¨j}6@¹ ¨n\ÁxžÀ*Ãùp|;QvxíW4o¡[ì¹zÐÇ:4¨Ý¡F¶ AÔŠØ=èÐbÊR¡òa”- Z÷F†ýÇîH‹('éÌ ÇŠT¯aŒ×œtã 4F^0Úô²àR¦¤@º¹è»R³LrkO"Aµ1§-siä–Øv×ð_fÇ ÄW\6!蔫@‹p…3{»ÜD£„ÆFfRê˜v^tCôïL4»«‚¨nRÚ1( ëÐÁÞÎú®fp¥ENkU¨¸ ÿï঴'d:Ý‘;3ŠïÇîj3é¼Ï¢‘ͼd¢Qq@¤›7 4»¸ߎãRfAÛ ƒ®1 +¶p#ö&Du4ÛÐÎ1"Gè#†ä<åÛí‚èót{£[ Ëð ñߟ8¥~ 5WŒ ™Ÿy'UÜQb}¨AdvC7]¶¾[·²ú6É'lS Ûé>áüL §,ˆ@¬/ÅXëÚŽÄý>ªÏ \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3d/7257e7634312e2433d345ed71b33627a28e19b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3d/7257e7634312e2433d345ed71b33627a28e19b new file mode 100644 index 00000000..902e655a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3d/7257e7634312e2433d345ed71b33627a28e19b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3f/02bbda85368e9d2578d76bd1b7d2dd98f70c0d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3f/02bbda85368e9d2578d76bd1b7d2dd98f70c0d new file mode 100644 index 00000000..68990441 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3f/02bbda85368e9d2578d76bd1b7d2dd98f70c0d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3f/ab0ebb702a6a6c9836111a102a17c2134b40a9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3f/ab0ebb702a6a6c9836111a102a17c2134b40a9 new file mode 100644 index 00000000..0824b8c5 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/3f/ab0ebb702a6a6c9836111a102a17c2134b40a9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/40/7bd6ca2865aa7ad2da29372083278debf1b797 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/40/7bd6ca2865aa7ad2da29372083278debf1b797 new file mode 100644 index 00000000..5aea5949 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/40/7bd6ca2865aa7ad2da29372083278debf1b797 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/112c92c1058ed0c7c09e21215bf7ee58d09e1d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/112c92c1058ed0c7c09e21215bf7ee58d09e1d new file mode 100644 index 00000000..173fc203 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/112c92c1058ed0c7c09e21215bf7ee58d09e1d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/5e77f8b87b7410fb2e332f5b6cebb47b7ab3b5 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/5e77f8b87b7410fb2e332f5b6cebb47b7ab3b5 new file mode 100644 index 00000000..a2e801bb Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/5e77f8b87b7410fb2e332f5b6cebb47b7ab3b5 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/f788ad3541b9bba23c35080010defe869a4d43 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/f788ad3541b9bba23c35080010defe869a4d43 new file mode 100644 index 00000000..0d12c832 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/41/f788ad3541b9bba23c35080010defe869a4d43 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/43/c1869b1f85225c2bc348f5484d45341e871f92 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/43/c1869b1f85225c2bc348f5484d45341e871f92 new file mode 100644 index 00000000..2e388248 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/43/c1869b1f85225c2bc348f5484d45341e871f92 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/44/a0c3b71edc9b6cd61dda0a9b7fe75c9486177d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/44/a0c3b71edc9b6cd61dda0a9b7fe75c9486177d new file mode 100644 index 00000000..ce657dde Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/44/a0c3b71edc9b6cd61dda0a9b7fe75c9486177d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/44/a77e7992f88f44843f0626c8d1593d451ed53e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/44/a77e7992f88f44843f0626c8d1593d451ed53e new file mode 100644 index 00000000..6ff0f22e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/44/a77e7992f88f44843f0626c8d1593d451ed53e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/4c347a24481106a559a52744cfa7d41c602939 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/4c347a24481106a559a52744cfa7d41c602939 new file mode 100644 index 00000000..bb31b4eb Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/4c347a24481106a559a52744cfa7d41c602939 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/8049c271ed9f3849d8f3b662728c3300af6b9b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/8049c271ed9f3849d8f3b662728c3300af6b9b new file mode 100644 index 00000000..c3194fe2 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/8049c271ed9f3849d8f3b662728c3300af6b9b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/83d38d6007f03325f3116ff8d3d551432b615f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/83d38d6007f03325f3116ff8d3d551432b615f new file mode 100644 index 00000000..ba16eb1a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/83d38d6007f03325f3116ff8d3d551432b615f differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/ad05561a45304f9a6d6b7e6be47ee5fcfa2636 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/ad05561a45304f9a6d6b7e6be47ee5fcfa2636 new file mode 100644 index 00000000..fae0a67d --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/45/ad05561a45304f9a6d6b7e6be47ee5fcfa2636 @@ -0,0 +1,2 @@ +x-Ž1Â0©óŠ•(è,ÑAÊ„hèxÀ%ØŽÅÙgÙ†(¿Ç!éV«Ñìö,=ŽçÓ.Çä‚m``Ü?{¥SIé@HP@ëÊS‹– NrqÍR;ØN³2õ¿sv ë6Ö‡Êöù¾ûîûÎÉ*•Áøåøù“ÑA0SõV ¾²pølüü)ý½»BPt($«€5v¥4íÃÊ$”æ2OEŽÒ`,Pû¤iÍrÊ ‘!|Am„’p˜<ƒØ¡öC¨?˜8ˆ­j`Ͷ •…Æ a¥¨ð:ÇÚ‚«u] &s„VØ•¯Pø0Tf]g”PoA•ûÙ@Üoemm^FmÛ&ÌSN”棪kÈŒN糓Ezò”h‡´ Y¡1 ñW#4µœmÕD+g‘­Xëõá)f•£Ýja…äC0ª´-Óè¸ÂX-²ÆÞQ-tÔûþÒIèOS˜§}8ž¦ótè@.çç—çp9=;›.Îç'),Ï`¶\¼ŸŸÏ— Ú}€éâ+|š/ÞI3r¯kí: …Ó /^ŠNôŽAIq·75æ¢9µ&yÃ8WÔ’:‚õZç«!‚…£T‰µ°Ìú£ÛiØsiE¤ó•*p­&QD,”¶Ä‡'¦*_üLNç¨'>°Ü*½½—YkbTj¶ÆVé«$SÊ&©?œvö8Nw1ÿ—B3®r%KÁà˜°î€DGò½@T7 ä#}¿‰úJȽ<¸‰¢ÕÜ0K²:‘rèZ…Jqx6¡½„£í¢ñ¤ÄW ‡õF#¸ø÷\Ȳ³†Óså;ƒýìkt%U 59º‘ÞEš.oÀ«ãñ€¢ytŒLºU·›)YÐ+ú,åg­Èz»7¬jðmß0$L~ûŽ”î)ý!¬Ø†˜|é.•¬2Ø@'’GíKk&ÏÐQ R†63UUè<Žÿ¿é É&ßÑãënáDµ’”Ê%xT¼{æ.m„VrÒÞ®‡ôu2öƒœ?Cåßùúwf@–9-4ÚFKØ ÷)Ç·lTÞ¯æ‘\{÷á}àhI–hQ`Ð6J¡ÑØ•ó̈›•DÈRÅýN絃…ï7»$º[&°ó°»° W× Ó&Ïã¯é;§ô!’üû`šw-÷<œ„†å±9v‰“¨·‹¢]ôÂþ)U \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/685c671d98b9f246084b5573d2e20667bbde04 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/685c671d98b9f246084b5573d2e20667bbde04 new file mode 100644 index 00000000..b551c338 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/685c671d98b9f246084b5573d2e20667bbde04 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/75c95c39f71376410fbf299721056058a7028a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/75c95c39f71376410fbf299721056058a7028a new file mode 100644 index 00000000..b3f4760b Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/75c95c39f71376410fbf299721056058a7028a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/b42db8e73abec42f87af427aa7fbf414dcfbfd b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/b42db8e73abec42f87af427aa7fbf414dcfbfd new file mode 100644 index 00000000..e31f908a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/47/b42db8e73abec42f87af427aa7fbf414dcfbfd differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/48/5bc91281552b177823505477795d82fd13a3d1 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/48/5bc91281552b177823505477795d82fd13a3d1 new file mode 100644 index 00000000..03a871b3 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/48/5bc91281552b177823505477795d82fd13a3d1 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/48/f47535c1303d038153ae84851abcca60626239 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/48/f47535c1303d038153ae84851abcca60626239 new file mode 100644 index 00000000..d696d166 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/48/f47535c1303d038153ae84851abcca60626239 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/49/2833a3ff9bf5a82996ecbd9a8f231eb76f692d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/49/2833a3ff9bf5a82996ecbd9a8f231eb76f692d new file mode 100644 index 00000000..612e8f85 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/49/2833a3ff9bf5a82996ecbd9a8f231eb76f692d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/49/e41b0e2c61267e191ecae58fce84591da7d419 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/49/e41b0e2c61267e191ecae58fce84591da7d419 new file mode 100644 index 00000000..5df02fd0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/49/e41b0e2c61267e191ecae58fce84591da7d419 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4b/3b141115ff56d4d83493f7e8bb89fe9250f274 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4b/3b141115ff56d4d83493f7e8bb89fe9250f274 new file mode 100644 index 00000000..6df62d7a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4b/3b141115ff56d4d83493f7e8bb89fe9250f274 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4b/cd2c7e3e5342522c6f8b7746870d8685d092ea b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4b/cd2c7e3e5342522c6f8b7746870d8685d092ea new file mode 100644 index 00000000..7835e5aa Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4b/cd2c7e3e5342522c6f8b7746870d8685d092ea differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4d/1c87e362ab882f012dd4048eaaa9624562083b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4d/1c87e362ab882f012dd4048eaaa9624562083b new file mode 100644 index 00000000..692e5121 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4d/1c87e362ab882f012dd4048eaaa9624562083b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4e/7364be9bad7ffcc3ce046f75c0f8b3d81c18e0 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4e/7364be9bad7ffcc3ce046f75c0f8b3d81c18e0 new file mode 100644 index 00000000..56aa5b66 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4e/7364be9bad7ffcc3ce046f75c0f8b3d81c18e0 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/5e54d0dbfdada2dfb67d8e868bb48e5329e124 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/5e54d0dbfdada2dfb67d8e868bb48e5329e124 new file mode 100644 index 00000000..dc560d0e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/5e54d0dbfdada2dfb67d8e868bb48e5329e124 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/9b11051a1e02327e15ca4cd0244e779fabbc7f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/9b11051a1e02327e15ca4cd0244e779fabbc7f new file mode 100644 index 00000000..cc417462 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/9b11051a1e02327e15ca4cd0244e779fabbc7f differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/f429466a2a10f5377438526c8511ce0407df1c b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/f429466a2a10f5377438526c8511ce0407df1c new file mode 100644 index 00000000..926becd5 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/4f/f429466a2a10f5377438526c8511ce0407df1c differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/37bc102aa7f65329b5d3cf9c1e5894cc3337db b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/37bc102aa7f65329b5d3cf9c1e5894cc3337db new file mode 100644 index 00000000..42f40fc2 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/37bc102aa7f65329b5d3cf9c1e5894cc3337db differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/745cc5616a1c134dbb8762464d16f0d8ae1ea9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/745cc5616a1c134dbb8762464d16f0d8ae1ea9 new file mode 100644 index 00000000..8943ffe8 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/745cc5616a1c134dbb8762464d16f0d8ae1ea9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/b9352be60f180b3e9e6cedc670b942a69942cd b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/b9352be60f180b3e9e6cedc670b942a69942cd new file mode 100644 index 00000000..356e97e9 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/b9352be60f180b3e9e6cedc670b942a69942cd differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/bf3c1d6afc8056227f42a56246ca63aaf9af5a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/bf3c1d6afc8056227f42a56246ca63aaf9af5a new file mode 100644 index 00000000..18db6def Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/50/bf3c1d6afc8056227f42a56246ca63aaf9af5a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/51/401846a6cf2780a52bd50afc3d1ead315ec351 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/51/401846a6cf2780a52bd50afc3d1ead315ec351 new file mode 100644 index 00000000..97ec5a15 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/51/401846a6cf2780a52bd50afc3d1ead315ec351 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/51/715f9f89d8cdf74328d8c25694b170bcbe99b6 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/51/715f9f89d8cdf74328d8c25694b170bcbe99b6 new file mode 100644 index 00000000..acafa645 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/51/715f9f89d8cdf74328d8c25694b170bcbe99b6 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/450669e7653a800d766e9eb350a07df4f661af b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/450669e7653a800d766e9eb350a07df4f661af new file mode 100644 index 00000000..c39c6984 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/450669e7653a800d766e9eb350a07df4f661af differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/7842f72663aaf32bc9bbe8c4709d25d217e73d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/7842f72663aaf32bc9bbe8c4709d25d217e73d new file mode 100644 index 00000000..aa244679 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/7842f72663aaf32bc9bbe8c4709d25d217e73d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/b0c65e622564413d50f64906b9cfbd5551ae6f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/b0c65e622564413d50f64906b9cfbd5551ae6f new file mode 100644 index 00000000..ae803406 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/52/b0c65e622564413d50f64906b9cfbd5551ae6f differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/53/80912fbb66f5bfd7e53fee55a0637daa1ec995 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/53/80912fbb66f5bfd7e53fee55a0637daa1ec995 new file mode 100644 index 00000000..70adc0c9 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/53/80912fbb66f5bfd7e53fee55a0637daa1ec995 @@ -0,0 +1,3 @@ +x…RÑnÓ0åµþŠ«>mU—ŒMBŒ¾,k‹ˆ˜Rié˜&ă“ܤÖÛØN³íß¹N#è@ˆ>Dµï=Ççœ{³Zepõîý›pÆ`K¥{#ªƒ‹ó·—gô¹·CPt)$¯·n§ Ç6 ˜GÞŠ¥ÅZY @‘æ9aÇʾ ±BI¸ÎáijNÇÒôtá)zÕBÃ{ÊAk‘8„…RÔøœ£v $äªÑµà2Gè„Û ïŒ,^ <Ž*sœÚ9tª 抛¼0öòŒ9Jg \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/55/72d7476881992748fa29d7963f98aa0162ae5a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/55/72d7476881992748fa29d7963f98aa0162ae5a new file mode 100644 index 00000000..067e2179 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/55/72d7476881992748fa29d7963f98aa0162ae5a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/56/7f2b355a468df1d93378a83b574afcce6d0c6e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/56/7f2b355a468df1d93378a83b574afcce6d0c6e new file mode 100644 index 00000000..d2b6ca3a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/56/7f2b355a468df1d93378a83b574afcce6d0c6e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/56/ab1b49248acb400882e03f26ce497fe6ecdd1e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/56/ab1b49248acb400882e03f26ce497fe6ecdd1e new file mode 100644 index 00000000..edf84951 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/56/ab1b49248acb400882e03f26ce497fe6ecdd1e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/57/3df7e0031efd9e07d22fa7b9d7b5c623dcb476 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/57/3df7e0031efd9e07d22fa7b9d7b5c623dcb476 new file mode 100644 index 00000000..3d04f68c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/57/3df7e0031efd9e07d22fa7b9d7b5c623dcb476 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/412ad107c42aef9def9fa5efebdea718c20ff8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/412ad107c42aef9def9fa5efebdea718c20ff8 new file mode 100644 index 00000000..a16da34e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/412ad107c42aef9def9fa5efebdea718c20ff8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/968f9b2a21276b497c299eff74d9b42cec071e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/968f9b2a21276b497c299eff74d9b42cec071e new file mode 100644 index 00000000..f2dab0a1 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/968f9b2a21276b497c299eff74d9b42cec071e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/974f0d95a0aac4d970f8d1419a8cd51a19b54e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/974f0d95a0aac4d970f8d1419a8cd51a19b54e new file mode 100644 index 00000000..69305850 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/58/974f0d95a0aac4d970f8d1419a8cd51a19b54e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/27da3bd9c4a3d0473368120959099cf6ad6921 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/27da3bd9c4a3d0473368120959099cf6ad6921 new file mode 100644 index 00000000..dcb6c8e7 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/27da3bd9c4a3d0473368120959099cf6ad6921 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/9ee8c973ca27b36118a7abfd49753bfa20748a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/9ee8c973ca27b36118a7abfd49753bfa20748a new file mode 100644 index 00000000..1a680ec3 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/9ee8c973ca27b36118a7abfd49753bfa20748a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/b21cbd452a5b2f0666a7d5a6cafb0195acb53f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/b21cbd452a5b2f0666a7d5a6cafb0195acb53f new file mode 100644 index 00000000..2c1e8043 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/59/b21cbd452a5b2f0666a7d5a6cafb0195acb53f @@ -0,0 +1,7 @@ +x…SMoÚ@íÿŠ'ˆÈÒ^Z.qU­FPa’(­zXÛc³ŠÙu÷#Æ­òß;k¬ÖýPÂy=óÞ¾÷fœ”*ÙìÍìÕô$€X¨ªÑ¢ØY8?›½>¥¿·`wŠ^ +ÉKàÎs÷dÁ<òZ¤( fàd†º…O ÛU&p‹Ú%áœÁȳ»Òp<÷r°ç HeÁ$a %R¬, ©ÚW¥à2E¨…ݵ÷t,^ Üw*±œÚ9ªTÞon;Ñà;k+ón:­ëšñV2Sº˜–GCfz-–«xyJ²;Ø,ÑÐøÍ M–“xE²RžØ’×m>…FªYåe×ZX!‹ •ÛškôZ3a¬‰³¤Ö¹òÞo Ü¸„aCá2Œ£xâIî¢í‡õÍîÂÍ&\m£e ë ,Ö««h­Wtzáê>F«« eFÓÁC¥½£ðybÖ†£ý×Ä §º?› +S‘‹”¬ÉÂñ¡P¨%9‚ +õ^?WC3/©{a¹m_ýÞ†Þ”¦A@9?x¢ ÷j¤BiKz +f*M¼¹æ{¬•~`‰R–Ýaö´Û¦Âù‹ZU•*™‹ÂidqK{Id=¢—I'JÚçÞƒ^ Ï2¤¥r“hóRØwçJ¶”~G>Óã'­ Y¿ø¯²àâ¯Î r m¤%§Áy‚EëíJ˜Ô£éiƒA0èúŸD +Jdôq 9Šiçdñå+p]˜1µk8ªè‘tGÏ_ÅZ=c" XÉèßI±x¹¹½^nÇL;9joƒ§ x +~£PŽ \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5a/3ebafc7eaa5e8c40ca7368a4380b876b7223ca b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5a/3ebafc7eaa5e8c40ca7368a4380b876b7223ca new file mode 100644 index 00000000..744d187a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5a/3ebafc7eaa5e8c40ca7368a4380b876b7223ca differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5c/78fcfbaa883608f92f9b6f6d81d0405713c8a3 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5c/78fcfbaa883608f92f9b6f6d81d0405713c8a3 new file mode 100644 index 00000000..6f175c29 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5c/78fcfbaa883608f92f9b6f6d81d0405713c8a3 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5c/d0b320cf839585c1bf289b86ada552db0239b3 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5c/d0b320cf839585c1bf289b86ada552db0239b3 new file mode 100644 index 00000000..8b085825 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5c/d0b320cf839585c1bf289b86ada552db0239b3 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5d/0bc4781d05d90f3cbea3a0b21e8470a0f9aafa b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5d/0bc4781d05d90f3cbea3a0b21e8470a0f9aafa new file mode 100644 index 00000000..94d859a4 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5d/0bc4781d05d90f3cbea3a0b21e8470a0f9aafa differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5e/f7b1694925c635bf8bf7f8e2ff5605c4541a14 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5e/f7b1694925c635bf8bf7f8e2ff5605c4541a14 new file mode 100644 index 00000000..bab093dc Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5e/f7b1694925c635bf8bf7f8e2ff5605c4541a14 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/bdd0e0606a0abea222a56af0d4b72f22445a07 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/bdd0e0606a0abea222a56af0d4b72f22445a07 new file mode 100644 index 00000000..f7c3a68c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/bdd0e0606a0abea222a56af0d4b72f22445a07 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/bde9259f129e7dc734d0d18ea65d61e4c7e3f6 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/bde9259f129e7dc734d0d18ea65d61e4c7e3f6 new file mode 100644 index 00000000..6fe46645 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/bde9259f129e7dc734d0d18ea65d61e4c7e3f6 @@ -0,0 +1,2 @@ +x+)JMU0´0d040031QpLÉÈOI-. .Í,IÕËJ,Kd8h¦!t{nã~¾•WYü:[¦Våσ*wKÍLÏsÎÉLÍ+q,(ÈÉLN,ÉÌÏé/†è5y}¼`óô\ßL ë™×æÙ¤ +swbê Ï,ÉN-*K-òÉ,Æa’œþõ­«þÚnfeظ`ß‚›O…ÕHD \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/c020dfaf2838ef1920f646f7bd3881b67dcd74 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/c020dfaf2838ef1920f646f7bd3881b67dcd74 new file mode 100644 index 00000000..754344ec Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/5f/c020dfaf2838ef1920f646f7bd3881b67dcd74 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/60/c776b859ce72f528fc97788f0e74648d638e4d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/60/c776b859ce72f528fc97788f0e74648d638e4d new file mode 100644 index 00000000..016891a9 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/60/c776b859ce72f528fc97788f0e74648d638e4d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/3df4da4a46cc6aba1b12baf403a9d6aef8b9a4 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/3df4da4a46cc6aba1b12baf403a9d6aef8b9a4 new file mode 100644 index 00000000..efe59c3e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/3df4da4a46cc6aba1b12baf403a9d6aef8b9a4 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/4705db59c80e6b9e92556a1131c9b8412ea290 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/4705db59c80e6b9e92556a1131c9b8412ea290 new file mode 100644 index 00000000..1e45137a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/4705db59c80e6b9e92556a1131c9b8412ea290 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/7ff09e191ebbfdb60a2b0d07448285d4ffbf4e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/7ff09e191ebbfdb60a2b0d07448285d4ffbf4e new file mode 100644 index 00000000..34072a82 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/7ff09e191ebbfdb60a2b0d07448285d4ffbf4e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/dba8d7454e83c79601994ce30f3a796664bad4 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/dba8d7454e83c79601994ce30f3a796664bad4 new file mode 100644 index 00000000..33993ddc Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/dba8d7454e83c79601994ce30f3a796664bad4 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/e27f2ef3f1f71f6662d2dc71c38cca37d2a455 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/e27f2ef3f1f71f6662d2dc71c38cca37d2a455 new file mode 100644 index 00000000..0e2df12c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/62/e27f2ef3f1f71f6662d2dc71c38cca37d2a455 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/63/123e5ba7d9b6d7113c7f3a5260f833a40e9043 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/63/123e5ba7d9b6d7113c7f3a5260f833a40e9043 new file mode 100644 index 00000000..5e7eb446 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/63/123e5ba7d9b6d7113c7f3a5260f833a40e9043 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/63/c4fc59088e2b8b61068c8504bee44588c1ed33 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/63/c4fc59088e2b8b61068c8504bee44588c1ed33 new file mode 100644 index 00000000..763e6455 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/63/c4fc59088e2b8b61068c8504bee44588c1ed33 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/65/2d5fdab1df59a05f18411e19fb48ec15d1d20d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/65/2d5fdab1df59a05f18411e19fb48ec15d1d20d new file mode 100644 index 00000000..c94ce96c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/65/2d5fdab1df59a05f18411e19fb48ec15d1d20d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/66/3871ead7de37140d3b877d68fa1f502fdaa22b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/66/3871ead7de37140d3b877d68fa1f502fdaa22b new file mode 100644 index 00000000..1b95c175 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/66/3871ead7de37140d3b877d68fa1f502fdaa22b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/68/4756480e018f36d7c54129e1c5bf553791401a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/68/4756480e018f36d7c54129e1c5bf553791401a new file mode 100644 index 00000000..c2be0cb4 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/68/4756480e018f36d7c54129e1c5bf553791401a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/69/640d209c58e7f4a21392d77e56589213443701 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/69/640d209c58e7f4a21392d77e56589213443701 new file mode 100644 index 00000000..28c81f6d --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/69/640d209c58e7f4a21392d77e56589213443701 @@ -0,0 +1,4 @@ +xÍV]Ó8Ý×öW˜jà!qÐ.y‚Øe?f–Ä«›¸­§‰mÙÎt*Äßk;Î8m ¤‘&¶Ï½¾çÜwYË%z6ÿý·_ÈË»¦F·L.ÅÅì,ŸÏ¥¬¸X_Ì>¼ÿ;{1{YL‰Òò†•Z˜ó;Ã/fkÕ9Æ»Ý.ß=Ë¥^ã§óùþtu¹(7¬¡ÆRQ²Y°ê-zËDN˜·»~{…Ÿçs¸{:™ p~n¼‡KYRëãêîúº%ráAîL63EëY1FV¬þˆþˆàÁÞ@k-[õ¦*€]n”QVš6l'õ6/kÙV¹¡ªÁ FT[¾¢¥»`“yh ÙŠñµÈX«Ù–œ€Á´KDñëçÔ2ﶿ€ý¶t !7T|¿t ˆò„Û= à3¥æʉ]¼fD1ß+©ÑÂG:¾§Pw“¢š Š>¬ÖRJ›ª4&“ÃdP3Ú2¿Ý+ô4‡ZÍÿøðæòu¶øïÕõâß·ïSy&D³ªç–]S»Á"² ÕRn[…‚o´Ò²Aš)i¸•z²Ì(y]4ÄþŠ +ºfM¤Z±î€3ã¸; #Ô¯VÃÄ@ð”Bšý¬÷ wêf±$N¨§Ý+V(Ùì¿\ìbJ »¼QRC–Âʳ‚t§´\úÄ“D®04ø„VÅ ’/[^CÛÈV—ì¯nÒ~ЀòaÊŒc\…ÝÐ[»¡8Ë_<ØqTºúfLìx¹9ª˜Q¸¯‚$|Xû°}•«º…®ë²]Æ¡ÂÌ–+ÕrÛ 7þnZcE–Á?1mÍž„ZsÒ'Y÷³Ë¥¬³ày$ߥ+¾nµáf` ÷V·0‰ügH+>Æ‚È>~O¥ûv\îÂçAŽ“½¿ïÁ±xÔèŠÜƒNß±å!Í´¬|¤}H'D0Ò\©ÊiÆûi#˜]Õü®Ë0°9tú +Høçâ»Fòír•{BᬙK–~@uõ7N†~£Ë-ïßM#¨2iaìÁ¦HþÅZ„iqÜ=dÐO­®‹øcÀyîÞíœKÝì@Þ]Ü +í*.ŒiÒÆKCÛiÑP*5eˆG'¹¤©ùi…øßwN"h@ZšÄ¾;¿Ÿ³V*…Ë«‹¯Ÿ¦gœÁ\Õ-Ê­…Ï—Wçô÷ ìAÑ ¼îìViúîß £4Ÿy+2”sp2GÝ&…5Ï(·Ÿ™ÀoÔF( ŸÙœøªã~j|zíK”ƒ?€TœAª! ¢BÀ}†µ!!S»º\f°Ûv¾ŠW} •ZNáœê¨â8¸íEƒÿm­­Í÷é´iÆ[ÉLérZu†Ìô6š/ãdyN²û´;Y¡1 ñ¯š,§à5ÉÊxJb+Þ´|J4g•—Ýha…,'`Ta®ÑkÍ…±Z¤Î¨õn€¼7.a&%c¸ “(™ø"÷Ñæçên÷ázÆ›h™Àj óU¼ˆ6Ñ*¦¯Æð+Š@bFÝÁ}­½j£ð<1oá%è¡¿v +š÷ߦÆL"#k²t¼D(ÕjIŽ F½Æ÷ÕÀÜKªÄNXnÛ¡·ÝpÔ¥içG_(ǺR¡´%=%û㤰lƒÆ^ÖNJÔlíä=9&šZ“ Bó6J?²¹4¬à™UúÀ¸¤mÕŠb¡³ªñ,ð!])Ë,É`™’÷–%í74þAÝûä¬R.gmQ‰=C§ñ‘³eûX“yz‡9q—C“ïË´Ë)_mšy'è¿òÊ[¦_z¾±3KvÄ>4µe¼}ÄÊÆ®ª(|ÖS?é8teXVQÜi0 fC©AíR:ÐFC¢óvÇïOÕÀsŒf¯- +Fý‰[ì“ÞÑ£‚DÊñéÞ-ô¤DNg¿mÜ­â¹99¥­¬Uc`Ù^&þ"zF£Kº•„!K¾&ÝI£— x þçöÌ \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/7e/e7d5b098e9a83450c74593b3cdf9a214a631c7 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/7e/e7d5b098e9a83450c74593b3cdf9a214a631c7 new file mode 100644 index 00000000..bbfa5589 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/7e/e7d5b098e9a83450c74593b3cdf9a214a631c7 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/7f/810bf6c1bae0094da57ce27cee853c2a0b4c74 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/7f/810bf6c1bae0094da57ce27cee853c2a0b4c74 new file mode 100644 index 00000000..0baad8ae Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/7f/810bf6c1bae0094da57ce27cee853c2a0b4c74 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/80/74285cbd728cc9acab61849e56d1d8ae6cdfa9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/80/74285cbd728cc9acab61849e56d1d8ae6cdfa9 new file mode 100644 index 00000000..3b7cc636 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/80/74285cbd728cc9acab61849e56d1d8ae6cdfa9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/80/88eec3ed1a40ca8b4aebc988df41c9f5983e89 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/80/88eec3ed1a40ca8b4aebc988df41c9f5983e89 new file mode 100644 index 00000000..a0ee0851 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/80/88eec3ed1a40ca8b4aebc988df41c9f5983e89 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/82/16f75d45089de99f435b1084d583c6046fef4a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/82/16f75d45089de99f435b1084d583c6046fef4a new file mode 100644 index 00000000..1533f0b5 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/82/16f75d45089de99f435b1084d583c6046fef4a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/82/bc5729b96b650c316a83a886e6ce1f7133c520 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/82/bc5729b96b650c316a83a886e6ce1f7133c520 new file mode 100644 index 00000000..bd6fdd51 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/82/bc5729b96b650c316a83a886e6ce1f7133c520 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/83/724e8d9baace89a740c038883d7c3ea02df860 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/83/724e8d9baace89a740c038883d7c3ea02df860 new file mode 100644 index 00000000..b2d22208 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/83/724e8d9baace89a740c038883d7c3ea02df860 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/84/cc3f4746967802e002afaa29239e5f5cf9a8b8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/84/cc3f4746967802e002afaa29239e5f5cf9a8b8 new file mode 100644 index 00000000..5e59f0a5 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/84/cc3f4746967802e002afaa29239e5f5cf9a8b8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/84/de6cca8989402dc7727e57708990476e167fe6 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/84/de6cca8989402dc7727e57708990476e167fe6 new file mode 100644 index 00000000..b8490d5e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/84/de6cca8989402dc7727e57708990476e167fe6 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/85/23b544eab61145ee4ca5c4ffdf1a9a2579273b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/85/23b544eab61145ee4ca5c4ffdf1a9a2579273b new file mode 100644 index 00000000..18778ffc Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/85/23b544eab61145ee4ca5c4ffdf1a9a2579273b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/46903988a0d24ec525f59e7ca51643e3bd46ca b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/46903988a0d24ec525f59e7ca51643e3bd46ca new file mode 100644 index 00000000..a5c5c2ce Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/46903988a0d24ec525f59e7ca51643e3bd46ca differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/9ff1cb27c20295c7d747ddc4a42f54db6ce1f8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/9ff1cb27c20295c7d747ddc4a42f54db6ce1f8 new file mode 100644 index 00000000..477a9472 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/9ff1cb27c20295c7d747ddc4a42f54db6ce1f8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/a35cc5698f9f5f5e26790b8428baaf16f11bbe b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/a35cc5698f9f5f5e26790b8428baaf16f11bbe new file mode 100644 index 00000000..1e2242b2 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/a35cc5698f9f5f5e26790b8428baaf16f11bbe differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/d61a366ccb18762a1342a6b9df7313bcfc1bda b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/d61a366ccb18762a1342a6b9df7313bcfc1bda new file mode 100644 index 00000000..e3825cf0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/86/d61a366ccb18762a1342a6b9df7313bcfc1bda differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/227e660aae5156fc51f489d33b450e23611170 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/227e660aae5156fc51f489d33b450e23611170 new file mode 100644 index 00000000..7662c613 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/227e660aae5156fc51f489d33b450e23611170 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/86f1d1ef84031fb18cb563aaa1c229c8ac1d76 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/86f1d1ef84031fb18cb563aaa1c229c8ac1d76 new file mode 100644 index 00000000..275b3bca Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/86f1d1ef84031fb18cb563aaa1c229c8ac1d76 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/e06c77e7a4741f55f81c2b8acfe76cf43c97cc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/e06c77e7a4741f55f81c2b8acfe76cf43c97cc new file mode 100644 index 00000000..3e2c0b4d Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/87/e06c77e7a4741f55f81c2b8acfe76cf43c97cc differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/88/341e604196fa20a93a3cf839625f6818cef430 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/88/341e604196fa20a93a3cf839625f6818cef430 new file mode 100644 index 00000000..8f8c09f1 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/88/341e604196fa20a93a3cf839625f6818cef430 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/0196e16ebf8117619704a45007328746a7c731 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/0196e16ebf8117619704a45007328746a7c731 new file mode 100644 index 00000000..508f0070 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/0196e16ebf8117619704a45007328746a7c731 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/52c7993f64ef7fa6d04abfef45d4dec447ba9d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/52c7993f64ef7fa6d04abfef45d4dec447ba9d new file mode 100644 index 00000000..4600b062 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/52c7993f64ef7fa6d04abfef45d4dec447ba9d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/88c9719cd8499876c0bb9340d1cc39f10ed9c6 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/88c9719cd8499876c0bb9340d1cc39f10ed9c6 new file mode 100644 index 00000000..4733bbfa Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/88c9719cd8499876c0bb9340d1cc39f10ed9c6 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/f8b6b3f22f94a11cd5398dd62b1d5931eb78ce b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/f8b6b3f22f94a11cd5398dd62b1d5931eb78ce new file mode 100644 index 00000000..5e835bc1 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/89/f8b6b3f22f94a11cd5398dd62b1d5931eb78ce differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8a/8fa9237e8d4d3c7a591169414811836e3ac5cd b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8a/8fa9237e8d4d3c7a591169414811836e3ac5cd new file mode 100644 index 00000000..17087b46 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8a/8fa9237e8d4d3c7a591169414811836e3ac5cd differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8a/f9597e67ea223068ac8cc4ed02968550a52e47 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8a/f9597e67ea223068ac8cc4ed02968550a52e47 new file mode 100644 index 00000000..c9113a5a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8a/f9597e67ea223068ac8cc4ed02968550a52e47 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8b/7bac5cee91811657b1fbf1038054ccbe6cda12 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8b/7bac5cee91811657b1fbf1038054ccbe6cda12 new file mode 100644 index 00000000..4ddc9a0e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8b/7bac5cee91811657b1fbf1038054ccbe6cda12 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8c/58d1f69a0e67824089fd0a982c3fc351839253 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8c/58d1f69a0e67824089fd0a982c3fc351839253 new file mode 100644 index 00000000..bbd3d3eb Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8c/58d1f69a0e67824089fd0a982c3fc351839253 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8c/b1d686e94588d64d9ba56f3d853922d669a7c9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8c/b1d686e94588d64d9ba56f3d853922d669a7c9 new file mode 100644 index 00000000..6a64a8c4 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8c/b1d686e94588d64d9ba56f3d853922d669a7c9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8e/180a276e8e4bfa288c44651e801877743c529d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8e/180a276e8e4bfa288c44651e801877743c529d new file mode 100644 index 00000000..376ef9e9 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8e/180a276e8e4bfa288c44651e801877743c529d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8f/8826477c2ac54efa42a24e4f1d4e53eb3baa57 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8f/8826477c2ac54efa42a24e4f1d4e53eb3baa57 new file mode 100644 index 00000000..b4075136 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8f/8826477c2ac54efa42a24e4f1d4e53eb3baa57 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8f/b818a646b250477e4e3eac1ea66e55b8106538 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8f/b818a646b250477e4e3eac1ea66e55b8106538 new file mode 100644 index 00000000..338dba97 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/8f/b818a646b250477e4e3eac1ea66e55b8106538 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/91/c9f4528c41270c010decd837f99d85dbb4ba8e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/91/c9f4528c41270c010decd837f99d85dbb4ba8e new file mode 100644 index 00000000..a5ef9591 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/91/c9f4528c41270c010decd837f99d85dbb4ba8e @@ -0,0 +1 @@ +x+)JMU05e040031QpKÍLÏsÎÉLÍ+q,(ÈÉLN,ÉÌÏÓËJ,Kd`tŠ>*>ËÉ&üÆÔøÛÖf! +…ïú \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/92/e89353a12573455789b028b079b54c03dd4c87 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/92/e89353a12573455789b028b079b54c03dd4c87 new file mode 100644 index 00000000..3fae1053 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/92/e89353a12573455789b028b079b54c03dd4c87 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/93/9c3ac54e2dd75545379c4875f036644e03e768 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/93/9c3ac54e2dd75545379c4875f036644e03e768 new file mode 100644 index 00000000..f43ce9e0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/93/9c3ac54e2dd75545379c4875f036644e03e768 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/93/9dc265a8bc24f1b4ac881f10aaac2016d298dc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/93/9dc265a8bc24f1b4ac881f10aaac2016d298dc new file mode 100644 index 00000000..601aef0a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/93/9dc265a8bc24f1b4ac881f10aaac2016d298dc differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/4057eb220ff7b5a035660720ea28a2f1638c34 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/4057eb220ff7b5a035660720ea28a2f1638c34 new file mode 100644 index 00000000..de4ef2db Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/4057eb220ff7b5a035660720ea28a2f1638c34 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/59ebc4eb06fbd8ad2c82291e7c4de1ebc34312 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/59ebc4eb06fbd8ad2c82291e7c4de1ebc34312 new file mode 100644 index 00000000..94457672 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/59ebc4eb06fbd8ad2c82291e7c4de1ebc34312 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/d4e2f868179a88d6a7aafcd775b1b73e15a60f b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/d4e2f868179a88d6a7aafcd775b1b73e15a60f new file mode 100644 index 00000000..45f0a36d Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/95/d4e2f868179a88d6a7aafcd775b1b73e15a60f differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/97/bc012fe27c3410a0b4ce57a3280f0be81c93a3 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/97/bc012fe27c3410a0b4ce57a3280f0be81c93a3 new file mode 100644 index 00000000..57c6352d Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/97/bc012fe27c3410a0b4ce57a3280f0be81c93a3 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/98/2a6cc3e7fbb1ae718011a8be2d1ff668fc4c79 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/98/2a6cc3e7fbb1ae718011a8be2d1ff668fc4c79 new file mode 100644 index 00000000..20870589 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/98/2a6cc3e7fbb1ae718011a8be2d1ff668fc4c79 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/99/2e446e141badfad4bf2efafa8607892167e7b8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/99/2e446e141badfad4bf2efafa8607892167e7b8 new file mode 100644 index 00000000..6542cb55 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/99/2e446e141badfad4bf2efafa8607892167e7b8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/74a89e21c624c32c2393171a4ed38362f43dc9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/74a89e21c624c32c2393171a4ed38362f43dc9 new file mode 100644 index 00000000..bc12624c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/74a89e21c624c32c2393171a4ed38362f43dc9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/74fac61b5d52bd176b7cc6848169e5df41b7bd b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/74fac61b5d52bd176b7cc6848169e5df41b7bd new file mode 100644 index 00000000..a1c6156c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/74fac61b5d52bd176b7cc6848169e5df41b7bd differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/75fa9181e0b24eee88da728dd753cdb392bd9a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/75fa9181e0b24eee88da728dd753cdb392bd9a new file mode 100644 index 00000000..8bd7bbc2 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/75fa9181e0b24eee88da728dd753cdb392bd9a differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/f54972e023a5ad469c7c90c6353d338fbaa2de b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/f54972e023a5ad469c7c90c6353d338fbaa2de new file mode 100644 index 00000000..17c99136 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9a/f54972e023a5ad469c7c90c6353d338fbaa2de differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/4bd7daeee9acb66233c35ccc00016f528b0345 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/4bd7daeee9acb66233c35ccc00016f528b0345 new file mode 100644 index 00000000..716750e8 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/4bd7daeee9acb66233c35ccc00016f528b0345 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/65acf855617b2985ad2a3770f13689e285fcc8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/65acf855617b2985ad2a3770f13689e285fcc8 new file mode 100644 index 00000000..2fb7044c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/65acf855617b2985ad2a3770f13689e285fcc8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/892482b651153eaedc763217fcf6952faf3727 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/892482b651153eaedc763217fcf6952faf3727 new file mode 100644 index 00000000..2cb10697 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/892482b651153eaedc763217fcf6952faf3727 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/f7027887cb2651965e9fbcd611371ee355f0b2 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/f7027887cb2651965e9fbcd611371ee355f0b2 new file mode 100644 index 00000000..e0e2e882 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9c/f7027887cb2651965e9fbcd611371ee355f0b2 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9d/29487d49ee0db941d8a13e02c427021defbfd4 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9d/29487d49ee0db941d8a13e02c427021defbfd4 new file mode 100644 index 00000000..f1a539e1 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9d/29487d49ee0db941d8a13e02c427021defbfd4 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9d/901fbb29aca332080be170cf704cd63d8cbf8d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9d/901fbb29aca332080be170cf704cd63d8cbf8d new file mode 100644 index 00000000..d3204a33 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9d/901fbb29aca332080be170cf704cd63d8cbf8d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9e/938321fecc3e159c33557f1d72ace32d97e90b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9e/938321fecc3e159c33557f1d72ace32d97e90b new file mode 100644 index 00000000..f3a58cf2 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9e/938321fecc3e159c33557f1d72ace32d97e90b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9e/abe4ec02f5b35e1f3418c9ae7a3c8dc2f98c21 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9e/abe4ec02f5b35e1f3418c9ae7a3c8dc2f98c21 new file mode 100644 index 00000000..16ccf751 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9e/abe4ec02f5b35e1f3418c9ae7a3c8dc2f98c21 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9f/0dc8976fcd237a63a447b9c060f6c268ab09c7 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9f/0dc8976fcd237a63a447b9c060f6c268ab09c7 new file mode 100644 index 00000000..2ee780fe --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9f/0dc8976fcd237a63a447b9c060f6c268ab09c7 @@ -0,0 +1,3 @@ +x…T]OÛ0Ýkò+®òTPq¡<¾JÑ¢¡V"eM{pÒ›Ôµ3Û!­&þû®ÝŒ•I°çÜ›Rp6>Çp SÝ쌨×Ƨgç'ôóÜASP(.·n­ û7˨ÍwÞŠ•Å´j…&4¥ /©·Ï á+´‚1;…GMúTr4ñ;݆ï@i­EÂ*!p[bã@((õ¦‘‚«¡nîéQ<xì1tá8•sjhv «ÃBà®' þY;×؋Ѩë:Æe¦M=’{Avt›Mgó|vB´û¶{%ÑZ0ø³†$;à Ñ*yAd%ï‚?µAÊ9íiwF8¡ê!X]¹Žô\WÂ:#ŠÖ½q­W¤ý°€|ã +’4‡,Oà*ͳ|èA²å—ÅýÒ»»t¾Ìf9,î`º˜_gËl1§Ó ¤óGøšÍ¯‡€äM·ñ +hŒÂû‰«`^ŽÞô׉AEy¶ –¢%ISuËk„Z?£Q¤4aý\-\yJRl„ã.„þnÃÁ”FqL>?y òÍNâ˜XhãˆOÍlc·2|ƒ6O¬ÐÚ1Z;]jU‰º5ÈfÊRlÚÇÂm“ÿ­´,w¤û™y¢Wûć¥ÔíŠ)t•[†Dä‰3‹†œèÍB,¡¡´r¸%YŠv=pgÿ(‰/ßâËw4ÿI^7mAË¥ä4ãÃÌbøÇQ_h=‡žµXÑ(Ô §½Tõ÷ÀMm¨4Švðžmƒwî`ÁuGkŒ¦]qí ÙϘí'ÊúƒwÉ0GQ"uMÿ85“øŒ’*7¯ÎÓWQúõÛ],nn’Ý´jÈNâè%Ž_âßò°«þ \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9f/77ed0204270fbc27809d1520f2f7563123320c b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9f/77ed0204270fbc27809d1520f2f7563123320c new file mode 100644 index 00000000..d2ead442 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/9f/77ed0204270fbc27809d1520f2f7563123320c differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a1/4a3a950df4cd8bddc5baa9bfa28964565f503c b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a1/4a3a950df4cd8bddc5baa9bfa28964565f503c new file mode 100644 index 00000000..5df77952 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a1/4a3a950df4cd8bddc5baa9bfa28964565f503c differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/17e8a6626fdddc294945cfa60c3dd10810c7f1 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/17e8a6626fdddc294945cfa60c3dd10810c7f1 new file mode 100644 index 00000000..5498090c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/17e8a6626fdddc294945cfa60c3dd10810c7f1 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/8e0be77a34f8625337aa00af0a3597138e1c22 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/8e0be77a34f8625337aa00af0a3597138e1c22 new file mode 100644 index 00000000..065ee8a5 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/8e0be77a34f8625337aa00af0a3597138e1c22 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/aa923834bff292a4de0b138ee68b0aad124e56 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/aa923834bff292a4de0b138ee68b0aad124e56 new file mode 100644 index 00000000..7a35918d Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/aa923834bff292a4de0b138ee68b0aad124e56 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/c7916e61bbaba1d06e9615aa80e656bb01a764 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/c7916e61bbaba1d06e9615aa80e656bb01a764 new file mode 100644 index 00000000..fbee2613 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/c7916e61bbaba1d06e9615aa80e656bb01a764 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/e268da08e5d1a5b450489ef85c1af6026b7a57 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/e268da08e5d1a5b450489ef85c1af6026b7a57 new file mode 100644 index 00000000..d0c7b791 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/e268da08e5d1a5b450489ef85c1af6026b7a57 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/ea7a9b018dc5d0c3fe233264c2c788fbaf483d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/ea7a9b018dc5d0c3fe233264c2c788fbaf483d new file mode 100644 index 00000000..60c91e92 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a4/ea7a9b018dc5d0c3fe233264c2c788fbaf483d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a5/46dbd036af810ee849d69746ef4b00ad014bea b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a5/46dbd036af810ee849d69746ef4b00ad014bea new file mode 100644 index 00000000..51681d05 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a5/46dbd036af810ee849d69746ef4b00ad014bea differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a6/478a790da7368fd603b7021406314cbf30e3ad b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a6/478a790da7368fd603b7021406314cbf30e3ad new file mode 100644 index 00000000..6e852eff Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a6/478a790da7368fd603b7021406314cbf30e3ad differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a7/5ba41fed2e989551ec02a953a45cf7a18af7c8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a7/5ba41fed2e989551ec02a953a45cf7a18af7c8 new file mode 100644 index 00000000..633081e4 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a7/5ba41fed2e989551ec02a953a45cf7a18af7c8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a7/b2fa680fa3929421169417a573e77dc52bc465 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a7/b2fa680fa3929421169417a573e77dc52bc465 new file mode 100644 index 00000000..4cc6b2f2 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a7/b2fa680fa3929421169417a573e77dc52bc465 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a8/a89b6bbde6136319f3f1d625a8f9e6f6e9aacc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a8/a89b6bbde6136319f3f1d625a8f9e6f6e9aacc new file mode 100644 index 00000000..9610f1de Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a8/a89b6bbde6136319f3f1d625a8f9e6f6e9aacc differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/72fc48d296c3646c2b85ade1b826b6a5156cd2 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/72fc48d296c3646c2b85ade1b826b6a5156cd2 new file mode 100644 index 00000000..14ebac35 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/72fc48d296c3646c2b85ade1b826b6a5156cd2 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/8ae2cddee35fd2107281c1d9afef4582f2f2fd b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/8ae2cddee35fd2107281c1d9afef4582f2f2fd new file mode 100644 index 00000000..53a1f577 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/8ae2cddee35fd2107281c1d9afef4582f2f2fd differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/b9a9a314668d4d3fb692f8dfc4ee560251fb15 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/b9a9a314668d4d3fb692f8dfc4ee560251fb15 new file mode 100644 index 00000000..9b8ca486 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/b9a9a314668d4d3fb692f8dfc4ee560251fb15 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/c4996d99434452c25dc51f033128a39fbfbc45 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/c4996d99434452c25dc51f033128a39fbfbc45 new file mode 100644 index 00000000..8906b90c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/c4996d99434452c25dc51f033128a39fbfbc45 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/fc24996247f4bc2db2984c03197c358fb210a4 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/fc24996247f4bc2db2984c03197c358fb210a4 new file mode 100644 index 00000000..723650e3 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/a9/fc24996247f4bc2db2984c03197c358fb210a4 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ab/69c38dfca3dbd22ce8ef76056f723a9f039ea8 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ab/69c38dfca3dbd22ce8ef76056f723a9f039ea8 new file mode 100644 index 00000000..2582ad62 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ab/69c38dfca3dbd22ce8ef76056f723a9f039ea8 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ac/dce9405147ec335281985c08936a2ff907c793 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ac/dce9405147ec335281985c08936a2ff907c793 new file mode 100644 index 00000000..5b2f0e70 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ac/dce9405147ec335281985c08936a2ff907c793 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ad/7466ae1885b313d73901fad5617cc5b141377b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ad/7466ae1885b313d73901fad5617cc5b141377b new file mode 100644 index 00000000..2935bf68 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ad/7466ae1885b313d73901fad5617cc5b141377b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ad/d1fc2ced5f64c92c7cb21b482d87353ec30879 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ad/d1fc2ced5f64c92c7cb21b482d87353ec30879 new file mode 100644 index 00000000..d5e0c151 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ad/d1fc2ced5f64c92c7cb21b482d87353ec30879 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ae/ef09d318e80a96a54332a3eccfa72d6cc56689 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ae/ef09d318e80a96a54332a3eccfa72d6cc56689 new file mode 100644 index 00000000..3c3cd623 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ae/ef09d318e80a96a54332a3eccfa72d6cc56689 @@ -0,0 +1 @@ +x¥Î=Ž1 @aêœÂýJÈç ­v+*á8 0Ã(„fNDÃh¿âéÉ}šÆƒó›ÞTA<¥Êœu…±Æ%™P½ÏTHleë¢Y¸éÜ!äDÄ…2‘«V¤TÌeˆµú˜¬›4î˜ ?ûùÞàÈMÆmÕËc••¯°ŸÞöwúØv¹ý‚õ!$J~p@4ò~íú]Åü—¢ÒÆ¥›Ì}PK \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/24209a10dbad154187b74a351d288005a9e78d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/24209a10dbad154187b74a351d288005a9e78d new file mode 100644 index 00000000..766061ca Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/24209a10dbad154187b74a351d288005a9e78d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/52b5bd0ad18f90cae92306181d51a189c0afe4 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/52b5bd0ad18f90cae92306181d51a189c0afe4 new file mode 100644 index 00000000..a569ae2a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/52b5bd0ad18f90cae92306181d51a189c0afe4 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/e7ade93a7a1004067d7c094922ab0bd66a42cb b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/e7ade93a7a1004067d7c094922ab0bd66a42cb new file mode 100644 index 00000000..22e77d02 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/af/e7ade93a7a1004067d7c094922ab0bd66a42cb differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b0/315c87b1cc581a12a54b07b96dc8925fcd5fc0 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b0/315c87b1cc581a12a54b07b96dc8925fcd5fc0 new file mode 100644 index 00000000..622364df Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b0/315c87b1cc581a12a54b07b96dc8925fcd5fc0 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b0/f24ef1127df040200772fb30ce48fe44abb68e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b0/f24ef1127df040200772fb30ce48fe44abb68e new file mode 100644 index 00000000..27a91809 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b0/f24ef1127df040200772fb30ce48fe44abb68e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b1/88afc70c6bef38582788459a99a7986182d1dc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b1/88afc70c6bef38582788459a99a7986182d1dc new file mode 100644 index 00000000..5dca557a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b1/88afc70c6bef38582788459a99a7986182d1dc differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b3/e2f86fa9f2c505b578d55ec9ebd144976c0821 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b3/e2f86fa9f2c505b578d55ec9ebd144976c0821 new file mode 100644 index 00000000..c9571710 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b3/e2f86fa9f2c505b578d55ec9ebd144976c0821 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/4c7852d1b04ff2fd1b63091ef51631ac272811 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/4c7852d1b04ff2fd1b63091ef51631ac272811 new file mode 100644 index 00000000..b57d82fe Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/4c7852d1b04ff2fd1b63091ef51631ac272811 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/7eb57c3f30fbbf44814063013ae2223d008409 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/7eb57c3f30fbbf44814063013ae2223d008409 new file mode 100644 index 00000000..e5e7003b Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/7eb57c3f30fbbf44814063013ae2223d008409 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/cc9ec916cd76a6a5826fe71b08e826042ed594 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/cc9ec916cd76a6a5826fe71b08e826042ed594 new file mode 100644 index 00000000..a7899c9c Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b4/cc9ec916cd76a6a5826fe71b08e826042ed594 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b6/02fa301fdd5688861011e9b8ffb05446c62468 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b6/02fa301fdd5688861011e9b8ffb05446c62468 new file mode 100644 index 00000000..6bbce5b0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b6/02fa301fdd5688861011e9b8ffb05446c62468 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b7/a716a20653e1c5ac77228a6395b58d108b41f9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b7/a716a20653e1c5ac77228a6395b58d108b41f9 new file mode 100644 index 00000000..101d3658 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b7/a716a20653e1c5ac77228a6395b58d108b41f9 @@ -0,0 +1,2 @@ +x…RÑjÛ0Ýkô—<µ!µ»Y^ê&3+ÄéJ{íkGÔ–4I®kFÿ}WŽÙÒ±<˜H÷ž£sνY­2X¼_¼ g f°Rº7¢:8¸º|ûî‚> pE—BòxëÊÐyüg‚yä­ÈQZ, •šižv¬Ìá +”„«àÎ<ët,MÏ—ž¢W-4¼©´‰CX(E€Ï9jBB®] .s„N¸ÃðÎÈâ•ÀÃÈ¡2Ç©@÷ ÊÓFàn þwpNÛaØu]ÀÉ2UX Ùð6^m’tsA²GجÑZ0ø½†,g=pM²rž‘ØšwC>•Aª9åewF8!«9XUºŽôZ aYë^¥6ºò~Ú@¹q Ó(…8ÂM”ÆéÜ“ÜÇûOÛ»=ÜG»]”ìãM +Û¬¶É:ÞÇÛ„N!Jàsœ¬ç€”MŸµñhŒÂç‰Å^Š>ô_ƒ’êþl5æ¢9Y“UË+„J=¡‘ä4šFX?WK /©pÜ W¿·ádJ!c”ó£'*°QKÆH…2ŽôTÕ†xKÃì”y 2¥\—Ñ1dϼü/„6UåJ–¢j Ž7ÄõŠ„…³a{¯Ç½^ó'„´GC>Bv}|öÓmF³†¼æaêÈ5¯•Äå(Oéác“±Ùú@rxR¢ ò,¥ÑËêë7লçÔ:™üe20­oüçÁ a~¤X²É c/ì'ÚuJr \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b7/ca9026300d3fdd9af2595367b0afb3dc9165d2 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b7/ca9026300d3fdd9af2595367b0afb3dc9165d2 new file mode 100644 index 00000000..b13cce51 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b7/ca9026300d3fdd9af2595367b0afb3dc9165d2 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/21b31c565e861f53a2b34d01fe23d902be2f6a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/21b31c565e861f53a2b34d01fe23d902be2f6a new file mode 100644 index 00000000..79d24b85 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/21b31c565e861f53a2b34d01fe23d902be2f6a @@ -0,0 +1,2 @@ +xmS]OÛ0Ý+þW}T\>&M/ ¥hÑP+5eˆG'¹M=R;³oâ¿ïÚÍ6:–‡(¾¾çøœs¼¶9œ^|ú0:p Ûl®Öç§g'üú ´F°\ÔFÕ ZZ[ÇëþËK†ä­.Ðx,¡5%ºJU0¶ßÂwt^[çòë ß]Š­ma£¶`,Aë‘9´‡•®ð¹À†@(즩µ2B§iÏéY‚xè9lNŠÛš-ØÕÛFPÔ‹†ð¬‰ÿe4êºNª(YZWê!?ºM'ÓY6=aÙ=ìÎÔè=8üÙjÇ–ó-¨†e*g±µêb>•CÞ#dwN“6Õ¼]Q§­¥öätÞÒ^j½`ïo87e`df¸J²4’ûtùu~·„ûd±HfËtšÁ|“ùì:]¦ó¯n ™=À·tv=äÌx:øܸà€Ç¨CžXÆð2 ¡ÿ™¬x?¬}ƒ…^é‚­™ªUBeŸÐv ºöa®ž–AR­7šÅÒßÛðfJ#!8çÇ@TâÆ^ +Á*¬#ÖSÉ­Ñ$—èéò}ٵƠ“‹Öܳ“} o Z9µÁκG™[K’˜GÖ>“ÌbÇ×ßÑÿ Ž8eø*F#òZ;Òè';¦=eÿ…þ>2ºù؟̲Y=«÷wŠvuYÔÊû#1Þ—)Æûg‹¦ÍùªAì†Ô•™r’.5ž”!õ&»ëf¬zxâ`>ÅA²ºä¿#&skUé¸ëàUˆWñ ^Fgd \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/343fab0cd2dba07c7b3cbbb02469e04dcbd3c9 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/343fab0cd2dba07c7b3cbbb02469e04dcbd3c9 new file mode 100644 index 00000000..8e779f64 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/343fab0cd2dba07c7b3cbbb02469e04dcbd3c9 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/b474a46196311025c6a8e7c9f53bb747befc73 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/b474a46196311025c6a8e7c9f53bb747befc73 new file mode 100644 index 00000000..a95749f4 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/b474a46196311025c6a8e7c9f53bb747befc73 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/cba47468ff99d781fc85c8ff0686611720d87c b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/cba47468ff99d781fc85c8ff0686611720d87c new file mode 100644 index 00000000..5e9f94be Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b8/cba47468ff99d781fc85c8ff0686611720d87c differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/4b21df294675f5a6e0da7a5c0a2e23183466d3 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/4b21df294675f5a6e0da7a5c0a2e23183466d3 new file mode 100644 index 00000000..ff73c5bf Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/4b21df294675f5a6e0da7a5c0a2e23183466d3 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/69510eb1c782107181a09b4ebfcff5e120ac1d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/69510eb1c782107181a09b4ebfcff5e120ac1d new file mode 100644 index 00000000..64b26fa5 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/69510eb1c782107181a09b4ebfcff5e120ac1d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/ec320a66eca056fd340056619de894e9a4d7b7 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/ec320a66eca056fd340056619de894e9a4d7b7 new file mode 100644 index 00000000..fd12ce50 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/b9/ec320a66eca056fd340056619de894e9a4d7b7 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bb/eb269763559f8a138b18dc7a31e16092177b96 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bb/eb269763559f8a138b18dc7a31e16092177b96 new file mode 100644 index 00000000..b3a8f9eb Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bb/eb269763559f8a138b18dc7a31e16092177b96 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/27392f0e73ce9aa93dcf154151cfc78b77cd1d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/27392f0e73ce9aa93dcf154151cfc78b77cd1d new file mode 100644 index 00000000..77a1b10a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/27392f0e73ce9aa93dcf154151cfc78b77cd1d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/29315f3b2e1ecac8c972352cb9aa4d582f8b06 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/29315f3b2e1ecac8c972352cb9aa4d582f8b06 new file mode 100644 index 00000000..84c234fc Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/29315f3b2e1ecac8c972352cb9aa4d582f8b06 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/6dccdc582c505732b22f1e67625b39561f491b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/6dccdc582c505732b22f1e67625b39561f491b new file mode 100644 index 00000000..1ac20844 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bc/6dccdc582c505732b22f1e67625b39561f491b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/29978a7edcd2f02644fa90165beed8a01cca81 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/29978a7edcd2f02644fa90165beed8a01cca81 new file mode 100644 index 00000000..d9f8de01 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/29978a7edcd2f02644fa90165beed8a01cca81 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/6d7601e41d763328a6fb90fd11405dd87ebc53 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/6d7601e41d763328a6fb90fd11405dd87ebc53 new file mode 100644 index 00000000..de176135 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/6d7601e41d763328a6fb90fd11405dd87ebc53 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/9b9c7805089d87771580fba42e0a760dced62d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/9b9c7805089d87771580fba42e0a760dced62d new file mode 100644 index 00000000..e7d11366 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bd/9b9c7805089d87771580fba42e0a760dced62d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/be/34b6152b679da2e544f3117341d69a8f45b4d7 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/be/34b6152b679da2e544f3117341d69a8f45b4d7 new file mode 100644 index 00000000..d1c77073 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/be/34b6152b679da2e544f3117341d69a8f45b4d7 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bf/afdf41c1fb4f2b487f620204c84a9ccca00ed1 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bf/afdf41c1fb4f2b487f620204c84a9ccca00ed1 new file mode 100644 index 00000000..4369caaf Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bf/afdf41c1fb4f2b487f620204c84a9ccca00ed1 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bf/dda449a5c0245fdd90e8901bb238013a67bc3b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bf/dda449a5c0245fdd90e8901bb238013a67bc3b new file mode 100644 index 00000000..3ad99902 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/bf/dda449a5c0245fdd90e8901bb238013a67bc3b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c0/484bb5262778ec6bc2be62e742236d565b8427 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c0/484bb5262778ec6bc2be62e742236d565b8427 new file mode 100644 index 00000000..63dc26a1 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c0/484bb5262778ec6bc2be62e742236d565b8427 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/362812db9d81bf0ea9d5044e8984957a526f9e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/362812db9d81bf0ea9d5044e8984957a526f9e new file mode 100644 index 00000000..75a17ecc Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/362812db9d81bf0ea9d5044e8984957a526f9e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/849267ee0c808e8777aaae5894575d1afc8b19 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/849267ee0c808e8777aaae5894575d1afc8b19 new file mode 100644 index 00000000..79c48659 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/849267ee0c808e8777aaae5894575d1afc8b19 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/e0bfadd1ddef749d91f9eed680bfe477506569 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/e0bfadd1ddef749d91f9eed680bfe477506569 new file mode 100644 index 00000000..5a475979 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c1/e0bfadd1ddef749d91f9eed680bfe477506569 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c2/7fd002fb181487186842a6fe9a888c8a3302f5 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c2/7fd002fb181487186842a6fe9a888c8a3302f5 new file mode 100644 index 00000000..e49cc371 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c2/7fd002fb181487186842a6fe9a888c8a3302f5 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c2/f22c9294633a83454c838e49964c6260b8bd9b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c2/f22c9294633a83454c838e49964c6260b8bd9b new file mode 100644 index 00000000..3a4eb3df Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c2/f22c9294633a83454c838e49964c6260b8bd9b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c3/14ace8bdec75c4216b40597a03327fc6730e79 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c3/14ace8bdec75c4216b40597a03327fc6730e79 new file mode 100644 index 00000000..1e69bac2 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c3/14ace8bdec75c4216b40597a03327fc6730e79 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c3/d41c86d11eeeb7fdd5a8127d1471f4ad4659c4 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c3/d41c86d11eeeb7fdd5a8127d1471f4ad4659c4 new file mode 100644 index 00000000..b77fe8cc Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c3/d41c86d11eeeb7fdd5a8127d1471f4ad4659c4 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c4/25c521360c0e90a40dea22d71b8207c85f8906 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c4/25c521360c0e90a40dea22d71b8207c85f8906 new file mode 100644 index 00000000..ebce5421 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c4/25c521360c0e90a40dea22d71b8207c85f8906 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c4/e230a0c24f76bd2a1526b089f272c5d62c858b b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c4/e230a0c24f76bd2a1526b089f272c5d62c858b new file mode 100644 index 00000000..a59339b0 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c4/e230a0c24f76bd2a1526b089f272c5d62c858b differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/38fae6414da0f76bc7207a30e55b3d3c1fa147 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/38fae6414da0f76bc7207a30e55b3d3c1fa147 new file mode 100644 index 00000000..e1837029 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/38fae6414da0f76bc7207a30e55b3d3c1fa147 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/8b845ae62895b09bdf158e8e8c85f3fbc91844 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/8b845ae62895b09bdf158e8e8c85f3fbc91844 new file mode 100644 index 00000000..5452ccdd Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/8b845ae62895b09bdf158e8e8c85f3fbc91844 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/d84e0a2010b831997e9d2cfd53959497a3a787 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/d84e0a2010b831997e9d2cfd53959497a3a787 new file mode 100644 index 00000000..4f39b612 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c5/d84e0a2010b831997e9d2cfd53959497a3a787 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/2785528127100d040a68f5d79d009bed49135e b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/2785528127100d040a68f5d79d009bed49135e new file mode 100644 index 00000000..cc7d4d06 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/2785528127100d040a68f5d79d009bed49135e differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/bcaf8eec5fc02d39ee8a41d4472f4845f73f9c b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/bcaf8eec5fc02d39ee8a41d4472f4845f73f9c new file mode 100644 index 00000000..884cd2f8 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/bcaf8eec5fc02d39ee8a41d4472f4845f73f9c differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/f91df8111ffe7bd0ee8875fea6f7b8d9f5d31d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/f91df8111ffe7bd0ee8875fea6f7b8d9f5d31d new file mode 100644 index 00000000..21a7924e Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c6/f91df8111ffe7bd0ee8875fea6f7b8d9f5d31d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c7/16cb0381821c544805bfa28b0adf2587729d72 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c7/16cb0381821c544805bfa28b0adf2587729d72 new file mode 100644 index 00000000..b189c834 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c7/16cb0381821c544805bfa28b0adf2587729d72 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c7/2b3fdf5cddb3642923df74e884c5febbdf82d5 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c7/2b3fdf5cddb3642923df74e884c5febbdf82d5 new file mode 100644 index 00000000..966f285a Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c7/2b3fdf5cddb3642923df74e884c5febbdf82d5 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c8/79e5145e7854ab3f74644ba45060a1ffa174fb b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c8/79e5145e7854ab3f74644ba45060a1ffa174fb new file mode 100644 index 00000000..624d2c23 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c8/79e5145e7854ab3f74644ba45060a1ffa174fb differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/88291c460f4c44af053d1364f62ff5536c51da b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/88291c460f4c44af053d1364f62ff5536c51da new file mode 100644 index 00000000..27fc0061 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/88291c460f4c44af053d1364f62ff5536c51da differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/9e2fc8fc029d166faef69c43f1547a5f1974ea b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/9e2fc8fc029d166faef69c43f1547a5f1974ea new file mode 100644 index 00000000..447f8fec Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/9e2fc8fc029d166faef69c43f1547a5f1974ea differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/ddc74c52f8c038d04851fc3feae09f80f54004 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/ddc74c52f8c038d04851fc3feae09f80f54004 new file mode 100644 index 00000000..a4508b18 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/c9/ddc74c52f8c038d04851fc3feae09f80f54004 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cb/2d2cfdbe2726d71ffa039968da9e9ebf0eebc1 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cb/2d2cfdbe2726d71ffa039968da9e9ebf0eebc1 new file mode 100644 index 00000000..e67b2c30 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cb/2d2cfdbe2726d71ffa039968da9e9ebf0eebc1 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cc/208085544f27646de52caf4c114b363cd6b956 b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cc/208085544f27646de52caf4c114b363cd6b956 new file mode 100644 index 00000000..0fa82ea8 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cc/208085544f27646de52caf4c114b363cd6b956 differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cd/f66a49d9af8c39b3d8a2e815934d57ff1b300a b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cd/f66a49d9af8c39b3d8a2e815934d57ff1b300a new file mode 100644 index 00000000..ea9699c4 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/cd/f66a49d9af8c39b3d8a2e815934d57ff1b300a @@ -0,0 +1 @@ +x]Ê1ƒ0 ÐÎœ¢'°  $F.ÀÒÙD°Iä¸H½=lLoy“Ó»ú”¯ = ”¢Z×6uUä¤┼86‰ïèðSl\Üó‚`¤X$ô+¶Wègö6ÃÜ:^Wÿ÷8†/ç \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ce/549642996920ea58aadfdbd6d3bb1eaa77352d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ce/549642996920ea58aadfdbd6d3bb1eaa77352d new file mode 100644 index 00000000..3f8cbbeb --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ce/549642996920ea58aadfdbd6d3bb1eaa77352d @@ -0,0 +1,2 @@ +xµUKoÜ6îY¿b=¤²RÚKÜÜ ÄAƒ&5'@‹ °(jdÒ¦H•o6¿¾)i½ëôÐKrÄ™ï1ÃθŽ~zõË«6tѹ«OJš¼»c KAAŒ“ar¥ í-Ý¥)*¦_÷!zý•®£ð‘}MôÖygÒvp~Q;K9‡W_ÖøÞÉ4²åø¯UŒSxÝ4Ò¸Ô×aòHRk×Ì«mÙÞ†-OöjG³¹‘ÚˤãMçYܳ¿QsU7ÒhäguUmès·—GÖqôlÚ<[JÊ륨¼<*k§ÁýÞí`Ãöc²Q|ùUò”!µ”¬á0¬Xô¨¨ýcûûÕöíÅ»÷mN­mrÉ°ÖVJÓzügJs™7‡a×u¥ËP¼d›x¹Z'«cÂÓî¤@c@㯖k*9í5„•±”`ëJ³Êawš[.Ë9UØŽit¬97Vó´µï\«ªýíòIð£âć¯Q's'rï®6w;¸¶Ûh½‹W l¶°Ü¬/ã]¼YÓêD븎חs@òŒºƒ‡F» +¨Üù‰ù`^‚Îô?ƒ‚ânmÌxÁ3*M–-+JµG-©"hP×ܸ¾Ì’à5·Ì[§áM—BÏ#ŸPŽµ:÷<¢PÚºîm!ø!¨zçÎ!È”t.?ÙžI²8`’d®^Î,U]Óݤ Ãx1ŽiÒ MŠ†ïç×'ðÃEÒªÕø±¼î¿œdX@ÞQ†ÚaÎÑv ¨Vcû|GëÈh¸’pX‡ýÖðô&PìM[µm<4™ƒT!à.ÃÚiÈ̶®Hé ¡%¿éÎéY‚xì9Lê·+Ô{0ÅÛFP¾ áÙx_»ÏãqÛ¶Ru’¥±å¸:rã»x:_$ós–ÝÃîu…ÎÅŸ Y¶œîAÕ,+S)‹­TÛåSZä=o‚ìÖ’']ŽÀ™Â·ÊbК“ó–ÒÆ¥Ö»öþ¶sS†Qq2„Û(‰“Q yˆ×_—÷kxˆV«h±Žç ,W0].fñ:^.xõ¢Å#|‹³ gÆÓÁ]mƒ#…<1ïÂK0„þgbPð~X»3*(ckºlT‰Pšg´šAvK.ÌÕ±À™Aò9íiWF:©²>X½r7è¹.¥uF¦¥û§jM6@¹·7Pݸ‚î0iÒ…Ñ0™&}r5]|ž_.àjxq1œ-¦“æ0žÏN§‹é|F«3ήáËtvÚ¤šQwð¶0>j£ôõÄe(^‚¾è;+òûµ-PÈ•”šÊJž!dz‹FQFP ÙHëûj‰àÒSÊåF:î‚é^ ­.ÅQôˆÜÞz¹} ¾ÈíEnÿUnt­o¼néšÚA‘èµq$ÿŒÙÂŒW†o°Ò憥Z;6âJ¡a_õÏn¦‘¨…V+™•YðF„2¬G‚¿σ¤¥Ìin6á­ÐQíxAäº\²š³hèn²‰òÃhx%Áô4„Vo«Jãƒ[,ÈìÝTºx?Œû“æGpÊ·ÉM=ãèäÑD'ùDE™ÒÌ‘sEm¦ð+Š:×úI"`«å’~Rõš™*ûþ¸Éìmíthq½°D»ÁO'uxËkt¥Q °‚:­VIšÆôÚÄYÈe¥A?^>=ÿbó³³=âÙé°ÂhÿG³½®¢¼¶Ø½·Ó$uÒ{šz‰~ú@O·b;n-V:åa¿k8ê>7b}®E˜¿Çþ¬c[#b‡ÖÅ4õuiÚXeÄÎ7¥jð.ú …Ø»- \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ff/c3a7458f4477ab312f9b8ba9e2152d281c9a0d b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ff/c3a7458f4477ab312f9b8ba9e2152d281c9a0d new file mode 100644 index 00000000..2d0e4bf4 Binary files /dev/null and b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/objects/ff/c3a7458f4477ab312f9b8ba9e2152d281c9a0d differ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/refs/heads/master b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/refs/heads/master index 3a6ec02d..95f3eaa1 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/refs/heads/master +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/git/refs/heads/master @@ -1 +1 @@ -6b833ad3b334f1ccf60e0bd27ff5781e618e79aa +aeef09d318e80a96a54332a3eccfa72d6cc56689 diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/mvnw b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/mvnw index d0275e2c..f79acbc0 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/mvnw +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/mvnw @@ -34,151 +34,158 @@ # MAVEN_SKIP_RC - flag to disable loading of mavenrc files # ---------------------------------------------------------------------------- -if [ -z "$MAVEN_SKIP_RC" ] ; then +if [ -z "$MAVEN_SKIP_RC" ]; then - if [ -f /etc/mavenrc ] ; then + if [ -f /etc/mavenrc ]; then . /etc/mavenrc fi - if [ -f "$HOME/.mavenrc" ] ; then + if [ -f "$HOME/.mavenrc" ]; then . "$HOME/.mavenrc" fi fi # OS specific support. $var _must_ be set to either true or false. -cygwin=false; -darwin=false; +cygwin=false +darwin=false mingw=false -case "`uname`" in - CYGWIN*) cygwin=true ;; - MINGW*) mingw=true;; - Darwin*) darwin=true - # - # Look for the Apple JDKs first to preserve the existing behaviour, and then look - # for the new JDKs provided by Oracle. - # - if [ -z "$JAVA_HOME" ] && [ -L /System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK ] ; then - # - # Apple JDKs - # - export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Home - fi +case "$(uname)" in +CYGWIN*) cygwin=true ;; +MINGW*) mingw=true ;; +Darwin*) + darwin=true + # + # Look for the Apple JDKs first to preserve the existing behaviour, and then look + # for the new JDKs provided by Oracle. + # + if [ -z "$JAVA_HOME" ] && [ -L /System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK ]; then + # + # Apple JDKs + # + export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Home + fi - if [ -z "$JAVA_HOME" ] && [ -L /System/Library/Java/JavaVirtualMachines/CurrentJDK ] ; then - # - # Apple JDKs - # - export JAVA_HOME=/System/Library/Java/JavaVirtualMachines/CurrentJDK/Contents/Home - fi + if [ -z "$JAVA_HOME" ] && [ -L /System/Library/Java/JavaVirtualMachines/CurrentJDK ]; then + # + # Apple JDKs + # + export JAVA_HOME=/System/Library/Java/JavaVirtualMachines/CurrentJDK/Contents/Home + fi - if [ -z "$JAVA_HOME" ] && [ -L "/Library/Java/JavaVirtualMachines/CurrentJDK" ] ; then - # - # Oracle JDKs - # - export JAVA_HOME=/Library/Java/JavaVirtualMachines/CurrentJDK/Contents/Home - fi + if [ -z "$JAVA_HOME" ] && [ -L "/Library/Java/JavaVirtualMachines/CurrentJDK" ]; then + # + # Oracle JDKs + # + export JAVA_HOME=/Library/Java/JavaVirtualMachines/CurrentJDK/Contents/Home + fi - if [ -z "$JAVA_HOME" ] && [ -x "/usr/libexec/java_home" ]; then - # - # Apple JDKs - # - export JAVA_HOME=`/usr/libexec/java_home` - fi - ;; + if [ -z "$JAVA_HOME" ] && [ -x "/usr/libexec/java_home" ]; then + # + # Apple JDKs + # + export JAVA_HOME=$(/usr/libexec/java_home) + fi + ;; esac -if [ -z "$JAVA_HOME" ] ; then - if [ -r /etc/gentoo-release ] ; then - JAVA_HOME=`java-config --jre-home` +if [ -z "$JAVA_HOME" ]; then + if [ -r /etc/gentoo-release ]; then + JAVA_HOME=$(java-config --jre-home) fi fi -if [ -z "$M2_HOME" ] ; then +if [ -z "$M2_HOME" ]; then ## resolve links - $0 may be a link to maven's home PRG="$0" # need this for relative symlinks - while [ -h "$PRG" ] ; do - ls=`ls -ld "$PRG"` - link=`expr "$ls" : '.*-> \(.*\)$'` - if expr "$link" : '/.*' > /dev/null; then + while [ -h "$PRG" ]; do + ls=$(ls -ld "$PRG") + link=$(expr "$ls" : '.*-> \(.*\)$') + if expr "$link" : '/.*' >/dev/null; then PRG="$link" else - PRG="`dirname "$PRG"`/$link" + PRG="$(dirname "$PRG")/$link" fi done - saveddir=`pwd` + saveddir=$(pwd) - M2_HOME=`dirname "$PRG"`/.. + M2_HOME=$(dirname "$PRG")/.. # make it fully qualified - M2_HOME=`cd "$M2_HOME" && pwd` + M2_HOME=$(cd "$M2_HOME" && pwd) cd "$saveddir" # echo Using m2 at $M2_HOME fi # For Cygwin, ensure paths are in UNIX format before anything is touched -if $cygwin ; then +if $cygwin; then [ -n "$M2_HOME" ] && - M2_HOME=`cygpath --unix "$M2_HOME"` + M2_HOME=$(cygpath --unix "$M2_HOME") [ -n "$JAVA_HOME" ] && - JAVA_HOME=`cygpath --unix "$JAVA_HOME"` + JAVA_HOME=$(cygpath --unix "$JAVA_HOME") [ -n "$CLASSPATH" ] && - CLASSPATH=`cygpath --path --unix "$CLASSPATH"` + CLASSPATH=$(cygpath --path --unix "$CLASSPATH") fi # For Migwn, ensure paths are in UNIX format before anything is touched -if $mingw ; then +if $mingw; then [ -n "$M2_HOME" ] && - M2_HOME="`(cd "$M2_HOME"; pwd)`" + M2_HOME="$( ( + cd "$M2_HOME" + pwd + ))" [ -n "$JAVA_HOME" ] && - JAVA_HOME="`(cd "$JAVA_HOME"; pwd)`" + JAVA_HOME="$( ( + cd "$JAVA_HOME" + pwd + ))" # TODO classpath? fi if [ -z "$JAVA_HOME" ]; then - javaExecutable="`which javac`" - if [ -n "$javaExecutable" ] && ! [ "`expr \"$javaExecutable\" : '\([^ ]*\)'`" = "no" ]; then + javaExecutable="$(which javac)" + if [ -n "$javaExecutable" ] && ! [ "$(expr \"$javaExecutable\" : '\([^ ]*\)')" = "no" ]; then # readlink(1) is not available as standard on Solaris 10. - readLink=`which readlink` - if [ ! `expr "$readLink" : '\([^ ]*\)'` = "no" ]; then - if $darwin ; then - javaHome="`dirname \"$javaExecutable\"`" - javaExecutable="`cd \"$javaHome\" && pwd -P`/javac" + readLink=$(which readlink) + if [ ! $(expr "$readLink" : '\([^ ]*\)') = "no" ]; then + if $darwin; then + javaHome="$(dirname \"$javaExecutable\")" + javaExecutable="$(cd \"$javaHome\" && pwd -P)/javac" else - javaExecutable="`readlink -f \"$javaExecutable\"`" + javaExecutable="$(readlink -f \"$javaExecutable\")" fi - javaHome="`dirname \"$javaExecutable\"`" - javaHome=`expr "$javaHome" : '\(.*\)/bin'` + javaHome="$(dirname \"$javaExecutable\")" + javaHome=$(expr "$javaHome" : '\(.*\)/bin') JAVA_HOME="$javaHome" export JAVA_HOME fi fi fi -if [ -z "$JAVACMD" ] ; then - if [ -n "$JAVA_HOME" ] ; then - if [ -x "$JAVA_HOME/jre/sh/java" ] ; then +if [ -z "$JAVACMD" ]; then + if [ -n "$JAVA_HOME" ]; then + if [ -x "$JAVA_HOME/jre/sh/java" ]; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi else - JAVACMD="`which java`" + JAVACMD="$(which java)" fi fi -if [ ! -x "$JAVACMD" ] ; then +if [ ! -x "$JAVACMD" ]; then echo "Error: JAVA_HOME is not defined correctly." >&2 echo " We cannot execute $JAVACMD" >&2 exit 1 fi -if [ -z "$JAVA_HOME" ] ; then +if [ -z "$JAVA_HOME" ]; then echo "Warning: JAVA_HOME environment variable is not set." fi @@ -187,11 +194,11 @@ CLASSWORLDS_LAUNCHER=org.codehaus.plexus.classworlds.launcher.Launcher # For Cygwin, switch paths to Windows format before running java if $cygwin; then [ -n "$M2_HOME" ] && - M2_HOME=`cygpath --path --windows "$M2_HOME"` + M2_HOME=$(cygpath --path --windows "$M2_HOME") [ -n "$JAVA_HOME" ] && - JAVA_HOME=`cygpath --path --windows "$JAVA_HOME"` + JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME") [ -n "$CLASSPATH" ] && - CLASSPATH=`cygpath --path --windows "$CLASSPATH"` + CLASSPATH=$(cygpath --path --windows "$CLASSPATH") fi # traverses directory structure from process work directory to filesystem root @@ -199,12 +206,15 @@ fi find_maven_basedir() { local basedir=$(pwd) local wdir=$(pwd) - while [ "$wdir" != '/' ] ; do - if [ -d "$wdir"/.mvn ] ; then + while [ "$wdir" != '/' ]; do + if [ -d "$wdir"/.mvn ]; then basedir=$wdir break fi - wdir=$(cd "$wdir/.."; pwd) + wdir=$( + cd "$wdir/.." + pwd + ) done echo "${basedir}" } @@ -212,7 +222,7 @@ find_maven_basedir() { # concatenates all lines of a file concat_lines() { if [ -f "$1" ]; then - echo "$(tr -s '\n' ' ' < "$1")" + echo "$(tr -s '\n' ' ' <"$1")" fi } @@ -227,15 +237,15 @@ export MAVEN_CMD_LINE_ARGS WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain echo "Running version check" -VERSION=$( sed '\!//' -e 's!.*$!!' ) +VERSION=$(sed '\!//' -e 's!.*$!!') echo "The found version is [${VERSION}]" if echo $VERSION | egrep -q 'M|RC'; then - echo Activating \"milestone\" profile for version=\"$VERSION\" - echo $MAVEN_ARGS | grep -q milestone || MAVEN_ARGS="$MAVEN_ARGS -Pmilestone" + echo Activating \"milestone\" profile for version=\"$VERSION\" + echo $MAVEN_ARGS | grep -q milestone || MAVEN_ARGS="$MAVEN_ARGS -Pmilestone" else - echo Deactivating \"milestone\" profile for version=\"$VERSION\" - echo $MAVEN_ARGS | grep -q milestone && MAVEN_ARGS=$(echo $MAVEN_ARGS | sed -e 's/-Pmilestone//') + echo Deactivating \"milestone\" profile for version=\"$VERSION\" + echo $MAVEN_ARGS | grep -q milestone && MAVEN_ARGS=$(echo $MAVEN_ARGS | sed -e 's/-Pmilestone//') fi exec "$JAVACMD" \ diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/oauth2-zuul/src/test/java/demo/ZuulApplicationTests.java b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/oauth2-zuul/src/test/java/demo/ZuulApplicationTests.java index 8074285c..5cc75497 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/oauth2-zuul/src/test/java/demo/ZuulApplicationTests.java +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/oauth2-zuul/src/test/java/demo/ZuulApplicationTests.java @@ -36,6 +36,7 @@ public class ZuulApplicationTests { @Value("${local.server.port}") int port; + private TestRestTemplate restTemplate = new TestRestTemplate(); @Test diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/scripts/runTests.sh b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/scripts/runTests.sh index ca283221..cfd4a74b 100755 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/scripts/runTests.sh +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/scripts/runTests.sh @@ -6,7 +6,7 @@ REPO_URL="${REPO_URL:-https://github.com/spring-cloud-samples/tests.git}" REPO_BRANCH="${REPO_BRANCH:-master}" if [[ -d zuul-config-discovery ]]; then REPO_LOCAL="${REPO_LOCAL:-.}" -else +else REPO_LOCAL="${REPO_LOCAL:-tests}" fi WAIT_TIME="${WAIT_TIME:-5}" @@ -15,31 +15,31 @@ DEFAULT_VERSION="${DEFAULT_VERSION:-1.0.0.BUILD-SNAPSHOT}" # Parse the script arguments while getopts ":r" opt; do - case $opt in - r) - RESET=0 - ;; - \?) - echo "Invalid option: -$OPTARG" >&2 - exit 1 - ;; - :) - echo "Option -$OPTARG requires an argument." >&2 - exit 1 - ;; - esac + case $opt in + r) + RESET=0 + ;; + \?) + echo "Invalid option: -$OPTARG" >&2 + exit 1 + ;; + :) + echo "Option -$OPTARG requires an argument." >&2 + exit 1 + ;; + esac done # Clone or update the repository if [[ ! -e "${REPO_LOCAL}/.git" ]]; then - git clone "${REPO_URL}" "${REPO_LOCAL}" - cd "${REPO_LOCAL}" + git clone "${REPO_URL}" "${REPO_LOCAL}" + cd "${REPO_LOCAL}" else - cd "${REPO_LOCAL}" - if [[ $RESET ]]; then - git reset --hard - git pull "${REPO_URL}" "${REPO_BRANCH}" - fi + cd "${REPO_LOCAL}" + if [[ $RESET ]]; then + git reset --hard + git pull "${REPO_URL}" "${REPO_BRANCH}" + fi fi ./mvnw --fail-at-end clean package diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/test.sh b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/test.sh new file mode 100755 index 00000000..6c98ed33 --- /dev/null +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-core-tests/test.sh @@ -0,0 +1 @@ +touch generate.log diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/README.adoc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/README.adoc index 1a3aca67..55acd58a 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/README.adoc +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/README.adoc @@ -1,63 +1,55 @@ // Do not edit this file (e.g. go instead to src/main/asciidoc) -Spring Cloud Release Train is a curated set of dependencies across a -range of Spring Cloud projects. You consume it by using the -spring-cloud-dependencies POM to manage dependencies in Maven or -Gradle. The release trains have names, not versions, to avoid -confusion with the sub-projects. The names are an alphabetic sequence -(so you can sort them chronologically) with names of London Tube -stations ("Angel" is the first release, "Brixton" is the second). +Spring Cloud Release Train is a curated set of dependencies across a range of Spring Cloud projects. +You consume it by using the spring-cloud-dependencies POM to manage dependencies in Maven or Gradle. +The release trains have names, not versions, to avoid confusion with the sub-projects. +The names are an alphabetic sequence (so you can sort them chronologically) with names of London Tube stations ("Angel" is the first release, "Brixton" is the second). == Contributing -Spring Cloud is released under the non-restrictive Apache 2.0 license, -and follows a very standard Github development process, using Github -tracker for issues and merging pull requests into master. If you want -to contribute even something trivial please do not hesitate, but -follow the guidelines below. +Spring Cloud is released under the non-restrictive Apache 2.0 license, and follows a very standard Github development process, using Github tracker for issues and merging pull requests into master. +If you want to contribute even something trivial please do not hesitate, but follow the guidelines below. === Sign the Contributor License Agreement + Before we accept a non-trivial patch or pull request we will need you to sign the https://cla.pivotal.io/sign/spring[Contributor License Agreement]. -Signing the contributor's agreement does not grant anyone commit rights to the main -repository, but it does mean that we can accept your contributions, and you will get an -author credit if we do. Active contributors might be asked to join the core team, and -given the ability to merge pull requests. +Signing the contributor's agreement does not grant anyone commit rights to the main repository, but it does mean that we can accept your contributions, and you will get an author credit if we do. +Active contributors might be asked to join the core team, and given the ability to merge pull requests. === Code of Conduct + This project adheres to the Contributor Covenant https://github.com/spring-cloud/spring-cloud-build/blob/master/docs/src/main/asciidoc/code-of-conduct.adoc[code of -conduct]. By participating, you are expected to uphold this code. Please report -unacceptable behavior to spring-code-of-conduct@pivotal.io. +conduct]. +By participating, you are expected to uphold this code. +Please report unacceptable behavior to spring-code-of-conduct@pivotal.io. === Code Conventions and Housekeeping -None of these is essential for a pull request, but they will all help. They can also be -added after the original pull request but before a merge. -* Use the Spring Framework code format conventions. If you use Eclipse - you can import formatter settings using the +None of these is essential for a pull request, but they will all help. +They can also be added after the original pull request but before a merge. + +* Use the Spring Framework code format conventions. +If you use Eclipse you can import formatter settings using the `eclipse-code-formatter.xml` file from the https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/master/spring-cloud-dependencies-parent/eclipse-code-formatter.xml[Spring - Cloud Build] project. If using IntelliJ, you can use the + Cloud Build] project. +If using IntelliJ, you can use the https://plugins.jetbrains.com/plugin/6546[Eclipse Code Formatter Plugin] to import the same file. * Make sure all new `.java` files to have a simple Javadoc class comment with at least an - `@author` tag identifying you, and preferably at least a paragraph on what the class is - for. -* Add the ASF license header comment to all new `.java` files (copy from existing files - in the project) -* Add yourself as an `@author` to the .java files that you modify substantially (more - than cosmetic changes). + `@author` tag identifying you, and preferably at least a paragraph on what the class is for. +* Add the ASF license header comment to all new `.java` files (copy from existing files in the project) +* Add yourself as an `@author` to the .java files that you modify substantially (more than cosmetic changes). * Add some Javadocs and, if you change the namespace, some XSD doc elements. * A few unit tests would help a lot as well -- someone has to do it. -* If no-one else is using your branch, please rebase it against the current master (or - other target branch in the main project). -* When writing a commit message please follow https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[these conventions], - if you are fixing an existing issue please add `Fixes gh-XXXX` at the end of the commit - message (where XXXX is the issue number). +* If no-one else is using your branch, please rebase it against the current master (or other target branch in the main project). +* When writing a commit message please follow https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html[these conventions], if you are fixing an existing issue please add `Fixes gh-XXXX` at the end of the commit message (where XXXX is the issue number). == Building and Deploying -Since there is no code to compile in the starters they should do not need to compile, but a compiler has to be available because they are built and deployed as JAR artifacts. To install locally: +Since there is no code to compile in the starters they should do not need to compile, but a compiler has to be available because they are built and deployed as JAR artifacts. +To install locally: ---- diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/README.adoc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/README.adoc index 454dda11..114be509 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/README.adoc +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/README.adoc @@ -6,7 +6,8 @@ include::https://raw.githubusercontent.com/spring-cloud/spring-cloud-build/maste == Building and Deploying -Since there is no code to compile in the starters they should do not need to compile, but a compiler has to be available because they are built and deployed as JAR artifacts. To install locally: +Since there is no code to compile in the starters they should do not need to compile, but a compiler has to be available because they are built and deployed as JAR artifacts. +To install locally: ---- diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/intro.adoc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/intro.adoc index 5ae66a35..eb7c9f8d 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/intro.adoc +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/intro.adoc @@ -1,7 +1,4 @@ -Spring Cloud Release Train is a curated set of dependencies across a -range of Spring Cloud projects. You consume it by using the -spring-cloud-dependencies POM to manage dependencies in Maven or -Gradle. The release trains have names, not versions, to avoid -confusion with the sub-projects. The names are an alphabetic sequence -(so you can sort them chronologically) with names of London Tube -stations ("Angel" is the first release, "Brixton" is the second). \ No newline at end of file +Spring Cloud Release Train is a curated set of dependencies across a range of Spring Cloud projects. +You consume it by using the spring-cloud-dependencies POM to manage dependencies in Maven or Gradle. +The release trains have names, not versions, to avoid confusion with the sub-projects. +The names are an alphabetic sequence (so you can sort them chronologically) with names of London Tube stations ("Angel" is the first release, "Brixton" is the second). \ No newline at end of file diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/spring-cloud-starters.adoc b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/spring-cloud-starters.adoc index 4d473a4a..2bebbf91 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/spring-cloud-starters.adoc +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-release/docs/src/main/asciidoc/spring-cloud-starters.adoc @@ -11,7 +11,8 @@ include::intro.adoc[] == Using Spring Cloud Dependencies with Spring IO Platform -The Spring IO Platform is a modular, enterprise-grade curated set of dependencies. To use the Spring Cloud Starters with Spring IO Platform, you must import the Spring Cloud Dependencies bill of materials (BOM) first. +The Spring IO Platform is a modular, enterprise-grade curated set of dependencies. +To use the Spring Cloud Starters with Spring IO Platform, you must import the Spring Cloud Dependencies bill of materials (BOM) first. To use version {springioplatformversion} of the Spring IO Platform and Spring Cloud Release Train {springcloudversion} with Maven, update the pom.xml as follows: diff --git a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-static/current/index.html b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-static/current/index.html index d499456d..0e3ecb98 100644 --- a/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-static/current/index.html +++ b/spring-cloud-release-tools-core/src/test/resources/projects/spring-cloud-static/current/index.html @@ -1,7 +1,7 @@ - + \n" + "\n" + + "Page Redirection\n" + "\n" + + "\n" + + "If you are not redirected automatically, follow the link to latest release\n"; + } + +} diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserAccessor.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserAccessor.java new file mode 100644 index 00000000..01ba1b3a --- /dev/null +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/MavenBomParserAccessor.java @@ -0,0 +1,31 @@ +/* + * 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 org.springframework.cloud.release.cloud.buildsystem.SpringCloudMavenBomParserAccessor; +import org.springframework.cloud.release.internal.ReleaserProperties; + +public class MavenBomParserAccessor { + + public static BomParser cloudMavenBomParser(ReleaserProperties properties) { + return new MavenBomParser(properties, + Collections.singletonList(SpringCloudMavenBomParserAccessor.cloud())); + } + +} diff --git a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/TestPomReader.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java similarity index 82% rename from spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/TestPomReader.java rename to spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java index d4d09a4d..ce12d9b9 100644 --- a/spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/pom/TestPomReader.java +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java @@ -14,21 +14,21 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import org.apache.maven.model.Model; +import org.springframework.cloud.release.internal.tech.PomReader; + /** * @author Marcin Grzejszczak */ public class TestPomReader { - PomReader pomReader = new PomReader(); - public Model readPom(File pom) { - return this.pomReader.readPom(pom); + return PomReader.readPom(pom); } } diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/pom/TestUtils.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestUtils.java similarity index 96% rename from spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/pom/TestUtils.java rename to spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestUtils.java index a13a6e42..8cfefb1f 100644 --- a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/pom/TestUtils.java +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestUtils.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.springframework.cloud.release.internal.pom; +package org.springframework.cloud.release.internal.buildsystem; import java.io.File; import java.io.IOException; diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/docs/TestDocumentationUpdater.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/docs/TestDocumentationUpdater.java index 5e7be08c..42c86347 100644 --- a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/docs/TestDocumentationUpdater.java +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/docs/TestDocumentationUpdater.java @@ -18,9 +18,11 @@ package org.springframework.cloud.release.internal.docs; import java.io.File; +import edu.emory.mathcs.backport.java.util.Collections; + import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.template.TemplateGenerator; /** @@ -29,9 +31,10 @@ import org.springframework.cloud.release.internal.template.TemplateGenerator; public class TestDocumentationUpdater extends DocumentationUpdater { public TestDocumentationUpdater(ReleaserProperties properties, - TestProjectDocumentationUpdater updater, + CustomProjectDocumentationUpdater updater, ProjectGitHandler handler, TestReleaseContentsUpdater testRelease) { - super(properties, updater, testRelease); + super(properties, new ProjectDocumentationUpdater(properties, handler, + Collections.singletonList(updater)), testRelease); } public static class TestReleaseContentsUpdater extends ReleaseTrainContentsUpdater { @@ -48,34 +51,4 @@ public class TestDocumentationUpdater extends DocumentationUpdater { } - public static class TestProjectDocumentationUpdater - extends ProjectDocumentationUpdater { - - private final String version; - - public TestProjectDocumentationUpdater(ReleaserProperties properties, - ProjectGitHandler gitHandler, String version) { - super(properties, gitHandler); - this.version = version; - } - - @Override - String readIndexHtmlContents(File indexHtml) { - return response(); - } - - private String response() { - return "\n" + "\n" + "\n" - + "\n" + "\n" + "\n" + "\n" - + "Page Redirection\n" + "\n" - + "\n" - + "If you are not redirected automatically, follow the link to latest release\n"; - } - - } - } diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/AcceptanceTests.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/AcceptanceTests.java index ffecd8cf..f50e44f2 100644 --- a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/AcceptanceTests.java +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/AcceptanceTests.java @@ -45,22 +45,26 @@ import org.mockito.BDDMockito; import org.mockito.Mockito; import org.springframework.boot.test.rule.OutputCapture; +import org.springframework.cloud.release.cloud.docs.SpringCloudDocsAccessor; import org.springframework.cloud.release.internal.Releaser; import org.springframework.cloud.release.internal.ReleaserProperties; +import org.springframework.cloud.release.internal.buildsystem.BomParser; +import org.springframework.cloud.release.internal.buildsystem.GradleUpdater; +import org.springframework.cloud.release.internal.buildsystem.MavenBomParserAccessor; +import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater; +import org.springframework.cloud.release.internal.buildsystem.TestPomReader; +import org.springframework.cloud.release.internal.buildsystem.TestUtils; import org.springframework.cloud.release.internal.docs.DocumentationUpdater; import org.springframework.cloud.release.internal.docs.TestDocumentationUpdater; import org.springframework.cloud.release.internal.git.GitTestUtils; import org.springframework.cloud.release.internal.git.ProjectGitHandler; -import org.springframework.cloud.release.internal.gradle.GradleUpdater; +import org.springframework.cloud.release.internal.github.ProjectGitHubHandler; import org.springframework.cloud.release.internal.options.Options; import org.springframework.cloud.release.internal.options.OptionsBuilder; -import org.springframework.cloud.release.internal.pom.ProjectPomUpdater; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; -import org.springframework.cloud.release.internal.pom.TestPomReader; -import org.springframework.cloud.release.internal.pom.TestUtils; -import org.springframework.cloud.release.internal.post.PostReleaseActions; -import org.springframework.cloud.release.internal.project.ProjectBuilder; +import org.springframework.cloud.release.internal.postrelease.PostReleaseActions; +import org.springframework.cloud.release.internal.project.ProjectCommandExecutor; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.cloud.release.internal.sagan.Project; import org.springframework.cloud.release.internal.sagan.Release; import org.springframework.cloud.release.internal.sagan.SaganClient; @@ -94,10 +98,12 @@ public class AcceptanceTests { File cloudProjectFolder; - TestProjectGitHandler gitHandler; + TestProjectGitHubHandler gitHandler; NonAssertingTestProjectGitHandler nonAssertingGitHandler; + NonAssertingTestProjectGitHubHandler nonAssertingGitHubHandler; + SaganClient saganClient = Mockito.mock(SaganClient.class); ReleaserProperties releaserProperties; @@ -694,20 +700,23 @@ public class AcceptanceTests { private Releaser defaultReleaser(String expectedVersion, String projectName, ReleaserProperties properties) { - ProjectPomUpdater pomUpdater = new ProjectPomUpdater(properties); - ProjectBuilder projectBuilder = new ProjectBuilder(properties); - TestProjectGitHandler handler = new TestProjectGitHandler(properties, + ProjectPomUpdater pomUpdater = new ProjectPomUpdater(properties, + bomParsers(properties)); + ProjectCommandExecutor projectCommandExecutor = new ProjectCommandExecutor( + properties); + ProjectGitHandler gitHandler = new ProjectGitHandler(properties); + TestProjectGitHubHandler githubHandler = new TestProjectGitHubHandler(properties, expectedVersion, projectName); - TemplateGenerator templateGenerator = new TemplateGenerator(properties, handler); + TemplateGenerator templateGenerator = new TemplateGenerator(properties, + githubHandler); GradleUpdater gradleUpdater = new GradleUpdater(properties); SaganUpdater saganUpdater = new SaganUpdater(this.saganClient, this.releaserProperties); DocumentationUpdater documentationUpdater = new TestDocumentationUpdater( properties, - new TestDocumentationUpdater.TestProjectDocumentationUpdater(properties, - handler, "Brixton.SR1"), - new TestDocumentationUpdater.TestReleaseContentsUpdater(properties, - handler, templateGenerator)) { + SpringCloudDocsAccessor.testUpdater(gitHandler, "Brixton.SR1"), + gitHandler, new TestDocumentationUpdater.TestReleaseContentsUpdater( + properties, gitHandler, templateGenerator)) { @Override public File updateDocsRepo(ProjectVersion currentProject, String bomReleaseBranch) { @@ -716,17 +725,22 @@ public class AcceptanceTests { return file; } }; - Releaser releaser = new Releaser(releaserProperties, pomUpdater, projectBuilder, - handler, templateGenerator, gradleUpdater, saganUpdater, - documentationUpdater, this.postReleaseActions); - this.gitHandler = handler; + Releaser releaser = new Releaser(releaserProperties, pomUpdater, + projectCommandExecutor, gitHandler, githubHandler, templateGenerator, + gradleUpdater, saganUpdater, documentationUpdater, + this.postReleaseActions); + this.gitHandler = githubHandler; return releaser; } private Releaser defaultMetaReleaser(ReleaserProperties properties) { - ProjectPomUpdater pomUpdater = new ProjectPomUpdater(properties); - ProjectBuilder projectBuilder = new ProjectBuilder(properties); - NonAssertingTestProjectGitHandler handler = new NonAssertingTestProjectGitHandler( + ProjectPomUpdater pomUpdater = new ProjectPomUpdater(properties, + bomParsers(properties)); + ProjectCommandExecutor projectCommandExecutor = new ProjectCommandExecutor( + properties); + NonAssertingTestProjectGitHubHandler handler = new NonAssertingTestProjectGitHubHandler( + properties); + NonAssertingTestProjectGitHandler nonAssertingGitHandler = new NonAssertingTestProjectGitHandler( properties); TemplateGenerator templateGenerator = Mockito .spy(new TemplateGenerator(properties, handler)); @@ -735,10 +749,11 @@ public class AcceptanceTests { .spy(new SaganUpdater(this.saganClient, this.releaserProperties)); DocumentationUpdater documentationUpdater = Mockito .spy(new TestDocumentationUpdater(properties, - new TestDocumentationUpdater.TestProjectDocumentationUpdater( - properties, handler, "Brixton.SR1"), + SpringCloudDocsAccessor.testUpdater(nonAssertingGitHandler, + "Brixton.SR1"), + nonAssertingGitHandler, new TestDocumentationUpdater.TestReleaseContentsUpdater( - properties, handler, templateGenerator) { + properties, nonAssertingGitHandler, templateGenerator) { @Override public File updateProjectRepo(Projects projects) { File file = super.updateProjectRepo(projects); @@ -755,16 +770,23 @@ public class AcceptanceTests { return file; } }); - Releaser releaser = Mockito.spy(new Releaser(releaserProperties, pomUpdater, - projectBuilder, handler, templateGenerator, gradleUpdater, saganUpdater, - documentationUpdater, this.postReleaseActions)); - this.nonAssertingGitHandler = handler; + Releaser releaser = Mockito + .spy(new Releaser(releaserProperties, pomUpdater, projectCommandExecutor, + nonAssertingGitHandler, handler, templateGenerator, gradleUpdater, + saganUpdater, documentationUpdater, this.postReleaseActions)); + this.nonAssertingGitHubHandler = handler; + this.nonAssertingGitHandler = nonAssertingGitHandler; this.templateGenerator = templateGenerator; this.saganUpdater = saganUpdater; this.documentationUpdater = documentationUpdater; return releaser; } + private List bomParsers(ReleaserProperties properties) { + return Collections + .singletonList(MavenBomParserAccessor.cloudMavenBomParser(properties)); + } + private ReleaserProperties releaserProperties(File project, String branch) throws URISyntaxException { ReleaserProperties releaserProperties = new ReleaserProperties(); @@ -849,7 +871,7 @@ public class AcceptanceTests { return new String(Files.readAllBytes(file.toPath())); } - class TestProjectGitHandler extends ProjectGitHandler { + class TestProjectGitHubHandler extends ProjectGitHubHandler { final String expectedVersion; @@ -861,7 +883,7 @@ public class AcceptanceTests { boolean issueCreatedInStartSpringIo = false; - TestProjectGitHandler(ReleaserProperties properties, String expectedVersion, + TestProjectGitHubHandler(ReleaserProperties properties, String expectedVersion, String projectName) { super(properties); this.expectedVersion = expectedVersion; @@ -893,7 +915,7 @@ public class AcceptanceTests { } - class NonAssertingTestProjectGitHandler extends ProjectGitHandler { + class NonAssertingTestProjectGitHubHandler extends ProjectGitHubHandler { boolean closedMilestones = false; @@ -901,9 +923,7 @@ public class AcceptanceTests { boolean issueCreatedInStartSpringIo = false; - List clonedProjects = new ArrayList<>(); - - NonAssertingTestProjectGitHandler(ReleaserProperties properties) { + NonAssertingTestProjectGitHubHandler(ReleaserProperties properties) { super(properties); } @@ -928,6 +948,16 @@ public class AcceptanceTests { return "https://foo.bar.com/" + releaseVersion.toString(); } + } + + class NonAssertingTestProjectGitHandler extends ProjectGitHandler { + + List clonedProjects = new ArrayList<>(); + + NonAssertingTestProjectGitHandler(ReleaserProperties properties) { + super(properties); + } + @Override public File cloneReleaseTrainProject() { File file = super.cloneReleaseTrainProject(); diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/ReleaserApplicationEventTests.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/ReleaserApplicationEventTests.java index 9b48022e..444b9e64 100644 --- a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/ReleaserApplicationEventTests.java +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/ReleaserApplicationEventTests.java @@ -63,6 +63,8 @@ public class ReleaserApplicationEventTests { @Configuration @EnableAutoConfiguration @ComponentScan({ "org.springframework.cloud.release.internal.options", + "org.springframework.cloud.release.cloud", + "org.springframework.cloud.release.internal.buildsystem", "org.springframework.cloud.release.internal.sagan", "org.springframework.cloud.release.internal.spring" }) static class Config { diff --git a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/SpringReleaserTests.java b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/SpringReleaserTests.java index b1f04a38..8b992b23 100644 --- a/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/SpringReleaserTests.java +++ b/spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/spring/SpringReleaserTests.java @@ -40,9 +40,9 @@ import org.springframework.cloud.release.internal.ReleaserProperties; import org.springframework.cloud.release.internal.ReleaserPropertiesAware; import org.springframework.cloud.release.internal.options.Options; import org.springframework.cloud.release.internal.options.OptionsBuilder; -import org.springframework.cloud.release.internal.pom.ProcessedProject; -import org.springframework.cloud.release.internal.pom.ProjectVersion; -import org.springframework.cloud.release.internal.pom.Projects; +import org.springframework.cloud.release.internal.project.ProcessedProject; +import org.springframework.cloud.release.internal.project.ProjectVersion; +import org.springframework.cloud.release.internal.project.Projects; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationEventPublisher;