SpringCloud/spring-cloud-release-tools
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactord buildsystem

Browse Source
This commit is contained in:
Marcin Grzejszczak
2019-08-27 17:37:21 +02:00
parent ca136b19ad
commit 3c2b870568
25 changed files with 993 additions and 848 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/SpringCloudConstants.java → spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/BomConstants.java
View File

@@ -5,7 +5,7 @@
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
@@ -14,12 +14,12 @@
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
package org.springframework.cloud.release.cloud.buildsystem;
/**
* @author Marcin Grzejszczak
*/
final class SpringCloudConstants {
final class BomConstants {
static final String SPRING_BOOT = "spring-boot";
static final String BOOT_STARTER_ARTIFACT_ID = "spring-boot-starter";
@@ -29,7 +29,7 @@ final class SpringCloudConstants {
static final String CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID = "spring-cloud-dependencies-parent";
static final String BUILD_ARTIFACT_ID = "spring-cloud-build";
private SpringCloudConstants() {
private BomConstants() {
throw new IllegalStateException("Don't instantiate a utility class");
}

141
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/cloud/buildsystem/SpringCloudBomParser.java Normal file
View File

@@ -0,0 +1,141 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.cloud.buildsystem;
import java.io.File;
import java.util.LinkedHashSet;
import java.util.Set;
import org.apache.maven.model.Model;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.buildsystem.CustomBomParser;
import org.springframework.cloud.release.internal.buildsystem.PomReader;
import org.springframework.cloud.release.internal.buildsystem.Project;
import org.springframework.cloud.release.internal.buildsystem.VersionsFromBom;
import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.BOOT_DEPENDENCIES_ARTIFACT_ID;
import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID;
import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.BUILD_ARTIFACT_ID;
import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID;
import static org.springframework.cloud.release.cloud.buildsystem.BomConstants.SPRING_BOOT;
public class SpringCloudBomParser implements CustomBomParser {
private static final Logger log = LoggerFactory.getLogger(SpringCloudBomParser.class);
@Override
public boolean isApplicable(File root, ReleaserProperties properties,
Set<Project> projects) {
return root.getName().startsWith("spring-cloud") || projects.stream()
.anyMatch(project -> BUILD_ARTIFACT_ID.equals(project.name));
}
@Override
public VersionsFromBom parseBom(File root, ReleaserProperties properties) {
VersionsFromBom springCloudBuild = springCloudBuild(root, properties);
VersionsFromBom boot = bootVersion(root, properties);
return new VersionsFromBom(properties, springCloudBuild, boot);
}
private VersionsFromBom springCloudBuild(File root, ReleaserProperties properties) {
Model model = PomReader.pom(root, properties.getPom().getThisTrainBom());
String buildArtifact = model.getParent().getArtifactId();
log.debug("[{}] artifact id is equal to [{}]",
CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildArtifact);
if (!CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID.equals(buildArtifact)) {
throw new IllegalStateException(
"The pom doesn't have a [spring-cloud-dependencies-parent] artifact id");
}
String buildVersion = model.getParent().getVersion();
log.debug("Spring Cloud Build version is equal to [{}]", buildVersion);
VersionsFromBom scBuild = new VersionsFromBom(properties);
scBuild.add(BUILD_ARTIFACT_ID, buildVersion);
scBuild.add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildVersion);
return scBuild;
}
VersionsFromBom bootVersion(File root, ReleaserProperties properties) {
String pomWithBootStarterParent = properties.getPom()
.getPomWithBootStarterParent();
Model model = PomReader.pom(root, pomWithBootStarterParent);
if (model == null) {
return VersionsFromBom.EMPTY_VERSION;
}
String bootArtifactId = model.getParent().getArtifactId();
log.debug("Boot artifact id is equal to [{}]", bootArtifactId);
if (!BomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID.equals(bootArtifactId)) {
if (log.isDebugEnabled()) {
throw new IllegalStateException("The pom doesn't have a ["
+ BomConstants.BOOT_STARTER_PARENT_ARTIFACT_ID + "] artifact id");
}
return VersionsFromBom.EMPTY_VERSION;
}
String bootVersion = model.getParent().getVersion();
log.debug("Boot version is equal to [{}]", bootVersion);
VersionsFromBom versionsFromBom = new VersionsFromBom(properties);
versionsFromBom.add(SPRING_BOOT, bootVersion);
versionsFromBom.add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion);
versionsFromBom.add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion);
return versionsFromBom;
}
@Override
public Set<Project> setVersion(Set<Project> projects, String projectName,
String version) {
Set<Project> newProjects = new LinkedHashSet<>(projects);
switch (projectName) {
case SPRING_BOOT:
case BOOT_STARTER_PARENT_ARTIFACT_ID:
case BOOT_DEPENDENCIES_ARTIFACT_ID:
updateBootVersions(newProjects, version);
break;
case BUILD_ARTIFACT_ID:
case CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID:
updateBuildVersions(newProjects, version);
break;
}
return newProjects;
}
private void updateBootVersions(Set<Project> newProjects, String version) {
remove(newProjects, SPRING_BOOT);
remove(newProjects, BOOT_DEPENDENCIES_ARTIFACT_ID);
remove(newProjects, BOOT_STARTER_PARENT_ARTIFACT_ID);
add(newProjects, SPRING_BOOT, version);
add(newProjects, BOOT_STARTER_PARENT_ARTIFACT_ID, version);
add(newProjects, BOOT_DEPENDENCIES_ARTIFACT_ID, version);
}
private void updateBuildVersions(Set<Project> newProjects, String version) {
remove(newProjects, BUILD_ARTIFACT_ID);
remove(newProjects, CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID);
add(newProjects, BUILD_ARTIFACT_ID, version);
add(newProjects, CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, version);
}
private void add(Set<Project> projects, String key, String value) {
projects.add(new Project(key, value));
}
private void remove(Set<Project> projects, String expectedProjectName) {
projects.removeIf(project -> expectedProjectName.equals(project.name));
}
}

12
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/ReleaserProperties.java
View File

@@ -67,8 +67,8 @@ public class ReleaserProperties implements Serializable {
private Versions versions = new Versions();
/**
* Project name to its version - overrides all versions retrieved from a repository
* like Spring Cloud Release.
* Project name to its version - overrides all versions retrieved from a release train
* repository like Spring Cloud Release.
*/
private Map<String, String> fixedVersions = new LinkedHashMap<>();
@@ -273,7 +273,7 @@ public class ReleaserProperties implements Serializable {
public static class Git implements Serializable {
/**
* URL to Spring Cloud Release Git repository.
* URL to a release train repository.
*/
private String releaseTrainBomUrl = "https://github.com/spring-cloud/spring-cloud-release";
@@ -283,7 +283,7 @@ public class ReleaserProperties implements Serializable {
private String documentationUrl = "https://github.com/spring-cloud/spring-cloud-static";
/**
* URL to main release train project repository.
* URL to the release train project page repository.
*/
private String springProjectUrl = "https://github.com/spring-projects/spring-cloud";
@@ -329,8 +329,8 @@ public class ReleaserProperties implements Serializable {
private String releaseTrainWikiPagePrefix = "Spring-Cloud";
/**
* Where should the Spring Cloud Release repo get cloned to. If {@code null}
* defaults to a temporary directory.
* Where should the release train repo get cloned to. If {@code null} defaults to
* a temporary directory.
*/
private String cloneDestinationDir;

92
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/BomParser.java
View File

@@ -17,7 +17,6 @@
package org.springframework.cloud.release.internal.buildsystem;
import java.io.File;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
@@ -32,11 +31,6 @@ import org.slf4j.LoggerFactory;
import org.springframework.cloud.release.internal.ReleaserProperties;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_DEPENDENCIES_ARTIFACT_ID;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.SPRING_BOOT;
/**
* Parses the poms for a given project and populates versions from a release train.
*
@@ -48,11 +42,7 @@ class BomParser {
private final File thisProjectRoot;
private final String pomWithBootStarterParent;
private final String thisTrainBom;
private final PomReader pomReader = new PomReader();
private final String thisTrainBomLocation;
private final Pattern versionPattern;
@@ -60,88 +50,36 @@ class BomParser {
BomParser(ReleaserProperties properties, File thisProjectRoot) {
this.thisProjectRoot = thisProjectRoot;
this.pomWithBootStarterParent = properties.getPom().getPomWithBootStarterParent();
this.thisTrainBom = properties.getPom().getThisTrainBom();
this.thisTrainBomLocation = properties.getPom().getThisTrainBom();
this.versionPattern = Pattern.compile(properties.getPom().getBomVersionPattern());
this.properties = properties;
}
Versions allVersions() {
Versions boot = bootVersion();
Versions cloud = versionsFromBom();
return new Versions(this.properties, allProjects(boot, cloud));
}
private Set<Project> allProjects(Versions boot, Versions cloud) {
Set<Project> allProjects = new HashSet<>();
allProjects.addAll(boot.projects);
allProjects.addAll(cloud.projects);
return allProjects;
}
// TODO: [SPRING CLOUD]
Versions bootVersion() {
Model model = pom(this.pomWithBootStarterParent);
if (model == null) {
return Versions.EMPTY_VERSION;
}
String bootArtifactId = model.getParent().getArtifactId();
log.debug("Boot artifact id is equal to [{}]", bootArtifactId);
if (!SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID
.equals(bootArtifactId)) {
throw new IllegalStateException("The pom doesn't have a ["
+ SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID
+ "] artifact id");
}
String bootVersion = model.getParent().getVersion();
log.debug("Boot version is equal to [{}]", bootVersion);
Versions versions = new Versions(this.properties);
versions.add(SPRING_BOOT, bootVersion);
versions.add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion);
versions.add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion);
return versions;
}
private Model pom(String pom) {
if (pom == null) {
throw new IllegalStateException("Pom is not present");
}
File pomFile = new File(this.thisProjectRoot, pom);
if (!pomFile.exists()) {
throw new IllegalStateException("Pom is not present");
}
return this.pomReader.readPom(pomFile);
}
// the BOM contains all versions of projects and its parent MUST be Spring Cloud
// Dependencies Parent
Versions versionsFromBom() {
Model model = pom(this.thisTrainBom);
VersionsFromBom versionsFromBom() {
Model model = PomReader.pom(thisProjectRoot, this.thisTrainBomLocation);
if (model == null) {
return Versions.EMPTY_VERSION;
return VersionsFromBom.EMPTY_VERSION;
}
// TODO: [SPRING CLOUD]
String buildArtifact = model.getParent().getArtifactId();
log.debug("[{}] artifact id is equal to [{}]",
CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, buildArtifact);
if (!CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID.equals(buildArtifact)) {
throw new IllegalStateException("The pom doesn't have a ["
+ CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID + "] artifact id");
}
String buildVersion = model.getParent().getVersion();
log.debug("Spring Cloud Build version is equal to [{}]", buildVersion);
Set<Project> projects = model.getProperties().entrySet().stream()
.filter(propertyMatchesSCPattern()).map(toProject())
.filter(propertyMatchesVersionPattern()).map(toProject())
.collect(Collectors.toSet());
String releaseTrainProjectVersion = model.getVersion();
projects.add(
new Project(this.properties.getMetaRelease().getReleaseTrainProjectName(),
releaseTrainProjectVersion));
projects.add(new Project("spring-cloud-build", buildVersion));
return new Versions(this.properties, projects);
VersionsFromBom bomVersions = new VersionsFromBom(this.properties, projects);
return new VersionsFromBom(properties, bomVersions, customVersions(projects));
}
private Predicate<Map.Entry<Object, Object>> propertyMatchesSCPattern() {
private VersionsFromBom customVersions(Set<Project> projects) {
CustomBomParser parser = CustomBomParser.parser(this.thisProjectRoot,
this.properties, projects);
return parser.parseBom(this.thisProjectRoot, this.properties);
}
private Predicate<Map.Entry<Object, Object>> propertyMatchesVersionPattern() {
return entry -> this.versionPattern.matcher(entry.getKey().toString()).matches();
}

103
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/CustomBomParser.java Normal file
View File

@@ -0,0 +1,103 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
import java.io.File;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.core.io.support.SpringFactoriesLoader;
/**
* Allows to pass in some additional BOM model to Versions mapping.
*/
public interface CustomBomParser {
/**
* Different projects can have different parsers. This method will tell whether the
* current parser should be applied or not.
* @param thisProjectRoot - location of the cloned project
* @param properties - releaser properties
* @param projects - parsed projects from the BOM
* @return {@code true} if the parser should be applied.
*/
boolean isApplicable(File thisProjectRoot, ReleaserProperties properties,
Set<Project> 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<Project> setVersion(Set<Project> projects, String projectName,
String version) {
return new LinkedHashSet<>(projects);
}
List<CustomBomParser> PARSERS = SpringFactoriesLoader
.loadFactories(CustomBomParser.class, null);
CustomBomParser NO_OP = new CustomBomParser() {
@Override
public boolean isApplicable(File thisProjectRoot, ReleaserProperties properties,
Set<Project> projects) {
return true;
}
@Override
public VersionsFromBom parseBom(File thisProjectRoot,
ReleaserProperties properties) {
return VersionsFromBom.EMPTY_VERSION;
}
};
static CustomBomParser parser(File thisProjectRoot, ReleaserProperties properties,
Set<Project> projects) {
for (CustomBomParser parser : PARSERS) {
if (parser.isApplicable(thisProjectRoot, properties, projects)) {
return parser;
}
}
return NO_OP;
}
static CustomBomParser parser(ReleaserProperties properties) {
return parser(new File(properties.getWorkingDir()), properties,
Collections.emptySet());
}
static CustomBomParser parser(ReleaserProperties properties, Set<Project> projects) {
return parser(new File(properties.getWorkingDir()), properties, projects);
}
}

23
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomReader.java
View File

@@ -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);
}
}

73
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/PomUpdater.java
View File

@@ -52,29 +52,27 @@ class PomUpdater {
private static final Logger log = LoggerFactory.getLogger(PomUpdater.class);
private final PomReader pomReader = new PomReader();
private final PomWriter pomWriter = new PomWriter();
/**
* Basing on the contents of the root pom and the versions will decide whether the
* project should be updated or not.
* @param rootFolder - root folder of the project
* @param versions - list of dependencies to be updated
* @param versionsFromBom - list of dependencies to be updated
* @return {@code true} if the project is on the list of projects to be updated
*/
boolean shouldProjectBeUpdated(File rootFolder, Versions versions) {
boolean shouldProjectBeUpdated(File rootFolder, VersionsFromBom versionsFromBom) {
File rootPom = rootPom(rootFolder);
if (!rootPom.exists()) {
return false;
}
Model model = this.pomReader.readPom(rootPom);
Model model = PomReader.readPom(rootPom);
if (model == null) {
log.info("Failed to read the model");
return false;
}
String artifactId = artifactId(model);
if (!versions.shouldBeUpdated(artifactId)) {
if (!versionsFromBom.shouldBeUpdated(artifactId)) {
log.info(
"Skipping project [{}] since it's not on the list of projects to update",
model.getArtifactId());
@@ -136,22 +134,25 @@ class PomUpdater {
}
ModelWrapper readModel(File pom) {
return new ModelWrapper(this.pomReader.readPom(pom));
return new ModelWrapper(PomReader.readPom(pom));
}
/**
* Updates the root / child module model.
* @param rootPom - root project model
* @param pom - file with the pom
* @param versions - versions to update
* @param versionsFromBom - versions to update
* @return updated model
*/
ModelWrapper updateModel(ModelWrapper rootPom, File pom, Versions versions) {
Model model = this.pomReader.readPom(pom);
ModelWrapper updateModel(ModelWrapper rootPom, File pom,
VersionsFromBom versionsFromBom) {
Model model = PomReader.readPom(pom);
List<VersionChange> sourceChanges = new ArrayList<>();
sourceChanges = updateParentIfPossible(rootPom, versions, model, sourceChanges);
sourceChanges = updateVersionIfPossible(rootPom, versions, model, sourceChanges);
return new ModelWrapper(model, sourceChanges, versions);
sourceChanges = updateParentIfPossible(rootPom, versionsFromBom, model,
sourceChanges);
sourceChanges = updateVersionIfPossible(rootPom, versionsFromBom, model,
sourceChanges);
return new ModelWrapper(model, sourceChanges, versionsFromBom);
}
/**
@@ -159,17 +160,19 @@ class PomUpdater {
* changes in the model.
* @return - the pom file
*/
File overwritePomIfDirty(ModelWrapper updatedPomModel, Versions versions, File pom) {
File overwritePomIfDirty(ModelWrapper updatedPomModel,
VersionsFromBom versionsFromBom, File pom) {
if (updatedPomModel.isDirty()) {
log.debug("There were changes in the pom so file will be overridden");
this.pomWriter.write(updatedPomModel, versions, pom);
this.pomWriter.write(updatedPomModel, versionsFromBom, pom);
log.info("Successfully stored [{}]", pom);
}
return pom;
}
private List<VersionChange> updateParentIfPossible(ModelWrapper wrapper,
Versions versions, Model model, List<VersionChange> sourceChanges) {
VersionsFromBom versionsFromBom, Model model,
List<VersionChange> sourceChanges) {
String rootProjectName = wrapper.projectName();
List<VersionChange> changes = new ArrayList<>(sourceChanges);
if (model.getParent() == null || isEmpty(model.getParent().getVersion())) {
@@ -181,11 +184,11 @@ class PomUpdater {
log.debug("Searching for a version of parent [{}:{}]", parentGroupId,
parentArtifactId);
String oldVersion = model.getParent().getVersion();
String version = versions.versionForProject(parentArtifactId);
String version = versionsFromBom.versionForProject(parentArtifactId);
log.debug("Found version is [{}]", version);
if (isEmpty(version)) {
if (hasText(model.getParent().getRelativePath())) {
version = versions.versionForProject(rootProjectName);
version = versionsFromBom.versionForProject(rootProjectName);
}
else {
log.warn("There is no info on the [{}:{}] version", parentGroupId,
@@ -209,7 +212,8 @@ class PomUpdater {
}
private List<VersionChange> updateVersionIfPossible(ModelWrapper wrapper,
Versions versions, Model model, List<VersionChange> sourceChanges) {
VersionsFromBom versionsFromBom, Model model,
List<VersionChange> sourceChanges) {
String rootProjectName = wrapper.projectName();
String rootProjectGroupId = wrapper.groupId();
List<VersionChange> changes = new ArrayList<>(sourceChanges);
@@ -224,7 +228,7 @@ class PomUpdater {
}
log.debug("Searching for a version [{}:{}]", groupId, artifactId);
String oldVersion = model.getVersion();
String version = versions.versionForProject(rootProjectName);
String version = versionsFromBom.versionForProject(rootProjectName);
log.debug("Found version is [{}]", version);
if (isEmpty(version) || isEmpty(model.getVersion())) {
log.debug(
@@ -259,19 +263,20 @@ class ModelWrapper {
final Model model;
final Versions versions;
final VersionsFromBom versionsFromBom;
final List<VersionChange> sourceChanges = new ArrayList<>();
ModelWrapper(Model model, List<VersionChange> sourceChanges, Versions versions) {
ModelWrapper(Model model, List<VersionChange> sourceChanges,
VersionsFromBom versionsFromBom) {
this.model = model;
this.versions = versions;
this.versionsFromBom = versionsFromBom;
this.sourceChanges.addAll(sourceChanges);
}
ModelWrapper(Model model) {
this.model = model;
this.versions = Versions.EMPTY_VERSION;
this.versionsFromBom = VersionsFromBom.EMPTY_VERSION;
}
String projectName() {
@@ -287,7 +292,7 @@ class ModelWrapper {
boolean isDirty() {
return !this.sourceChanges.isEmpty()
|| this.versions.shouldSetProperty(this.model.getProperties());
|| this.versionsFromBom.shouldSetProperty(this.model.getProperties());
}
}
@@ -296,7 +301,7 @@ class PomWriter {
private static final Logger log = LoggerFactory.getLogger(PomWriter.class);
void write(ModelWrapper wrapper, Versions versions, File pom) {
void write(ModelWrapper wrapper, VersionsFromBom versionsFromBom, File pom) {
try {
VersionChangerFactory versionChangerFactory = new VersionChangerFactory();
StringBuilder input = PomHelper.readXmlFile(pom);
@@ -314,8 +319,8 @@ class PomWriter {
changer.apply(versionChange);
}
log.debug("Applying properties changes to the pom [{}]", pom);
new PropertyVersionChanger(wrapper, versions, parsedPom, loggerToMavenLog)
.apply(null);
new PropertyVersionChanger(wrapper, versionsFromBom, parsedPom,
loggerToMavenLog).apply(null);
try (BufferedWriter bw = new BufferedWriter(new FileWriter(pom))) {
bw.write(input.toString());
}
@@ -349,27 +354,27 @@ class PomWriter {
class PropertyVersionChanger extends AbstractVersionChanger {
private final Versions versions;
private final VersionsFromBom versionsFromBom;
private final PropertyStorer propertyStorer;
PropertyVersionChanger(ModelWrapper wrapper, Versions versions,
PropertyVersionChanger(ModelWrapper wrapper, VersionsFromBom versionsFromBom,
ModifiedPomXMLEventReader pom, Log log) {
super(wrapper.model, pom, log);
this.versions = versions;
this.versionsFromBom = versionsFromBom;
this.propertyStorer = new PropertyStorer(log, pom);
}
PropertyVersionChanger(ModelWrapper wrapper, Versions versions,
PropertyVersionChanger(ModelWrapper wrapper, VersionsFromBom versionsFromBom,
ModifiedPomXMLEventReader pom, Log log, PropertyStorer propertyStorer) {
super(wrapper.model, pom, log);
this.versions = versions;
this.versionsFromBom = versionsFromBom;
this.propertyStorer = propertyStorer;
}
@Override
public void apply(final VersionChange versionChange) {
this.versions.projects.stream().filter(project -> {
this.versionsFromBom.projects.stream().filter(project -> {
Properties properties = getModel().getProperties();
String projectVersionKey = propertyName(project);
if (!properties.containsKey(projectVersionKey)) {

65
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Project.java Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
/**
* Represents a single project.
*
* @author Marcin Grzejszczak
*/
public class Project {
public static Project EMPTY_PROJECT = new Project("", "");
public final String name;
public final String version;
public Project(String name, String version) {
this.name = name;
this.version = version;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Project project = (Project) o;
if (this.name != null ? !this.name.equals(project.name) : project.name != null) {
return false;
}
return this.version != null ? this.version.equals(project.version)
: project.version == null;
}
@Override
public int hashCode() {
int result = this.name != null ? this.name.hashCode() : 0;
result = 31 * result + (this.version != null ? this.version.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "name=[" + this.name + "], version=[" + this.version + ']';
}
}

34
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectPomUpdater.java
View File

@@ -54,7 +54,7 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware {
private static final boolean UPDATE_FIXED_VERSIONS = true;
private static final Map<String, Versions> CACHE = new ConcurrentHashMap<>();
private static final Map<String, VersionsFromBom> CACHE = new ConcurrentHashMap<>();
private final ProjectGitHandler gitRepo;
@@ -93,33 +93,32 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware {
// TODO: I don't like this flag but don't have a better idea
public Projects retrieveVersionsFromReleaseTrainBom(String branch,
boolean updateFixedVersions) {
Versions versions = CACHE.computeIfAbsent(branch, s -> {
VersionsFromBom versionsFromBom = CACHE.computeIfAbsent(branch, s -> {
File clonedBom = this.gitRepo.cloneReleaseTrainProject();
this.gitRepo.checkout(clonedBom, branch);
BomParser releaseTrainBomParser = new BomParser(this.properties, clonedBom);
return releaseTrainBomParser.allVersions();
return releaseTrainBomParser.versionsFromBom();
});
if (updateFixedVersions) {
log.info("Will update the following versions manually [{}]",
this.properties.getFixedVersions());
this.properties.getFixedVersions().forEach(versions::setVersion);
this.properties.getFixedVersions().forEach(versionsFromBom::setVersion);
}
log.info("Retrieved the following versions\n{}", versions);
return versions.toProjectVersions();
log.info("Retrieved the following versions\n{}", versionsFromBom);
return versionsFromBom.toProjectVersions();
}
/**
* @return map of fixed versions
*/
public Projects fixedVersions() {
Set<ProjectVersion> projectVersions = this.properties.getFixedVersions()
.entrySet().stream()
.map(entry -> new ProjectVersion(entry.getKey(), entry.getValue()))
Set<Project> projects = this.properties.getFixedVersions().entrySet().stream()
.map(entry -> new Project(entry.getKey(), entry.getValue()))
.collect(Collectors.toSet());
if (log.isDebugEnabled()) {
log.debug("Will apply the following fixed versions {}", projectVersions);
log.debug("Will apply the following fixed versions {}", projects);
}
return new Versions(projectVersions, this.properties).toProjectVersions();
return new VersionsFromBom(this.properties, projects).toProjectVersions();
}
/**
@@ -134,8 +133,9 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware {
*/
public void updateProjectFromReleaseTrain(File projectRoot, Projects projects,
ProjectVersion versionFromReleaseTrain, boolean assertVersions) {
Versions versions = new Versions(projects, this.properties);
if (!this.pomUpdater.shouldProjectBeUpdated(projectRoot, versions)) {
VersionsFromBom versionsFromBom = new VersionsFromBom(this.properties,
projects.asProjects());
if (!this.pomUpdater.shouldProjectBeUpdated(projectRoot, versionsFromBom)) {
log.info("Skipping project updating");
return;
}
@@ -174,7 +174,7 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware {
private final ModelWrapper rootPom;
private final Versions versions;
private final VersionsFromBom versionsFromBom;
private final PomUpdater pomUpdater;
@@ -190,7 +190,7 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware {
ReleaserProperties properties, ProjectVersion versionFromScRelease,
boolean assertVersions) {
this.rootPom = rootPom;
this.versions = new Versions(projects, properties);
this.versionsFromBom = new VersionsFromBom(properties, projects.asProjects());
this.pomUpdater = pomUpdater;
this.properties = properties;
List<Pattern> unacceptableVersionPatterns = versionFromScRelease
@@ -212,8 +212,8 @@ public class ProjectPomUpdater implements ReleaserPropertiesAware {
return FileVisitResult.CONTINUE;
}
ModelWrapper model = this.pomUpdater.updateModel(this.rootPom, file,
this.versions);
this.pomUpdater.overwritePomIfDirty(model, this.versions, file);
this.versionsFromBom);
this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom, file);
if (this.assertVersions && !this.skipVersionAssert
&& !this.pomUpdater.hasSkipDeployment(model.model)) {
log.debug(

3
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/ProjectVersion.java
View File

@@ -81,8 +81,7 @@ public class ProjectVersion implements Comparable<ProjectVersion> {
this.artifactId = projectName;
}
else {
PomReader pomReader = new PomReader();
Model model = pomReader.readPom(project);
Model model = PomReader.readPom(project);
if (model != null) {
this.projectName = nameWithoutParent(model.getArtifactId());
this.version = model.getVersion();

297
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/Versions.java
View File

@@ -1,297 +0,0 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.project.Projects;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_DEPENDENCIES_ARTIFACT_ID;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BOOT_STARTER_PARENT_ARTIFACT_ID;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.BUILD_ARTIFACT_ID;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID;
import static org.springframework.cloud.release.internal.buildsystem.SpringCloudConstants.SPRING_BOOT;
/**
* Represents versions taken out from Spring Cloud Release pom.
*
* @author Marcin Grzejszczak
*/
class Versions {
static final Versions EMPTY_VERSION = new Versions();
String bootVersion;
String scBuildVersion;
Set<Project> projects = new HashSet<>();
ReleaserProperties properties;
private Versions() {
this.properties = new ReleaserProperties();
}
Versions(ReleaserProperties releaserProperties) {
this.properties = releaserProperties;
}
Versions(String bootVersion) {
this.bootVersion = bootVersion;
add(SPRING_BOOT, bootVersion);
add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion);
add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion);
this.properties = new ReleaserProperties();
}
Versions(String scBuildVersion, Set<Project> projects) {
this.scBuildVersion = scBuildVersion;
add(BUILD_ARTIFACT_ID, scBuildVersion);
add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, scBuildVersion);
this.projects.addAll(projects);
this.properties = new ReleaserProperties();
}
Versions(ReleaserProperties releaserProperties, Set<Project> projects) {
this.projects.addAll(projects);
this.properties = releaserProperties;
}
Versions(String bootVersion, String scBuildVersion, Set<Project> projects) {
this(new ReleaserProperties(), bootVersion, scBuildVersion, projects);
}
Versions(ReleaserProperties properties, String bootVersion, String scBuildVersion,
Set<Project> projects) {
this.properties = properties;
this.bootVersion = bootVersion;
this.scBuildVersion = scBuildVersion;
add(SPRING_BOOT, bootVersion);
add(BOOT_STARTER_PARENT_ARTIFACT_ID, bootVersion);
add(BOOT_DEPENDENCIES_ARTIFACT_ID, bootVersion);
add(BUILD_ARTIFACT_ID, scBuildVersion);
add(dependenciesParentArtifactId(), scBuildVersion);
this.projects.addAll(projects);
}
Versions(Set<ProjectVersion> versions, ReleaserProperties properties) {
this.properties = properties;
this.bootVersion = versions.stream()
.filter(projectVersion -> SPRING_BOOT.equals(projectVersion.projectName))
.findFirst().orElse(new ProjectVersion(SPRING_BOOT, "")).version;
this.scBuildVersion = versions.stream().filter(
projectVersion -> BUILD_ARTIFACT_ID.equals(projectVersion.projectName))
.findFirst().orElse(new ProjectVersion(BUILD_ARTIFACT_ID, "")).version;
versions.forEach(projectVersion -> setVersion(projectVersion.projectName,
projectVersion.version));
}
private String bomProjectName() {
return this.properties.getMetaRelease().getReleaseTrainProjectName();
}
private String dependenciesArtifactId() {
String artifactId = this.properties.getPom().getThisTrainBom();
return artifactId.split(File.separator)[0];
}
private String dependenciesParentArtifactId() {
return dependenciesArtifactId() + "-parent";
}
String versionForProject(String projectName) {
return this.projects.stream().filter(project -> nameMatches(projectName, project))
.findFirst().orElse(Project.EMPTY_PROJECT).version;
}
boolean shouldBeUpdated(String projectName) {
return this.projects.stream()
.anyMatch(project -> nameMatches(projectName, project));
}
boolean shouldSetProperty(Properties properties) {
return this.projects.stream()
.anyMatch(project -> properties.containsKey(project.name + ".version"));
}
Projects toProjectVersions() {
return this.projects.stream()
.map(project -> new ProjectVersion(project.name, project.version))
.collect(Collectors.toCollection(Projects::new));
}
/**
* The only exception is spring-cloud-dependencies (e.g. Greenwich.RELEASE) and
* spring-cloud-dependencies-parent (e.g. 2.1.0.RELEASE)
*/
private boolean nameMatches(String projectName, Project project) {
if (project.name.equals(projectName)) {
return true;
}
boolean parent = matchesNameWithSuffix(projectName, "-parent", project);
boolean bomArtifactId = comparisonOfBomArtifactAndParent(projectName, project);
return !bomArtifactId && (parent
|| matchesNameWithSuffix(projectName, "-dependencies", project));
}
private boolean comparisonOfBomArtifactAndParent(String projectName,
Project project) {
return artifactOrParent(projectName, project.name)
|| artifactOrParent(project.name, projectName);
}
private boolean artifactOrParent(String projectName, String otherProjectName) {
return projectName.equals(dependenciesArtifactId())
&& otherProjectName.equals(dependenciesParentArtifactId());
}
private boolean matchesNameWithSuffix(String projectName, String suffix,
Project project) {
boolean containsSuffix = projectName.endsWith(suffix);
if (!containsSuffix) {
return false;
}
String withoutSuffix = projectName.substring(0, projectName.indexOf(suffix));
return project.name.equals(withoutSuffix);
}
Versions setVersion(String projectName, String version) {
switch (projectName) {
case SPRING_BOOT:
case BOOT_STARTER_PARENT_ARTIFACT_ID:
case BOOT_DEPENDENCIES_ARTIFACT_ID:
updateBootVersions(version);
break;
case BUILD_ARTIFACT_ID:
case CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID:
updateBuildVersions(version);
break;
default:
if (bomVersionProjectNames().contains(projectName)) {
updateBomVersions(version);
}
else {
remove(projectName);
add(projectName, version);
}
}
return this;
}
private List<String> bomVersionProjectNames() {
List<String> names = new ArrayList<>(
this.properties.getMetaRelease().getReleaseTrainDependencyNames());
names.add(this.properties.getMetaRelease().getReleaseTrainProjectName());
return names;
}
private void updateBuildVersions(String version) {
this.scBuildVersion = version;
remove(BUILD_ARTIFACT_ID);
remove(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID);
add(BUILD_ARTIFACT_ID, version);
add(CLOUD_DEPENDENCIES_PARENT_ARTIFACT_ID, version);
}
private void updateBootVersions(String version) {
this.bootVersion = version;
remove(SPRING_BOOT);
remove(BOOT_DEPENDENCIES_ARTIFACT_ID);
remove(BOOT_STARTER_PARENT_ARTIFACT_ID);
add(SPRING_BOOT, version);
add(BOOT_STARTER_PARENT_ARTIFACT_ID, version);
add(BOOT_DEPENDENCIES_ARTIFACT_ID, version);
}
private void updateBomVersions(String version) {
remove(bomProjectName());
bomVersionProjectNames().forEach(this::remove);
add(bomProjectName(), version);
bomVersionProjectNames().forEach(s -> add(s, version));
}
public void add(String key, String value) {
this.projects.add(new Project(key, value));
}
public void remove(String expectedProjectName) {
this.projects.removeIf(project -> expectedProjectName.equals(project.name));
}
@Override
public String toString() {
return "Spring Boot Version=[" + this.bootVersion + ']'
+ "\nSpring Cloud Build Version=[" + this.scBuildVersion + ']'
+ "\nProjects=\n\t" + this.projects.stream().map(Object::toString)
.collect(Collectors.joining("\n\t"));
}
}
/**
* @author Marcin Grzejszczak
*/
class Project {
static Project EMPTY_PROJECT = new Project("", "");
final String name;
final String version;
Project(String name, String version) {
this.name = name;
this.version = version;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Project project = (Project) o;
if (this.name != null ? !this.name.equals(project.name) : project.name != null) {
return false;
}
return this.version != null ? this.version.equals(project.version)
: project.version == null;
}
@Override
public int hashCode() {
int result = this.name != null ? this.name.hashCode() : 0;
result = 31 * result + (this.version != null ? this.version.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "name=[" + this.name + "], version=[" + this.version + ']';
}
}

178
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBom.java Normal file
View File

@@ -0,0 +1,178 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.project.Projects;
/**
* Represents versions taken out from a release train POM.
*
* @author Marcin Grzejszczak
*/
public class VersionsFromBom {
public static final VersionsFromBom EMPTY_VERSION = new VersionsFromBom();
Set<Project> projects = new HashSet<>();
ReleaserProperties properties;
private VersionsFromBom() {
this.properties = new ReleaserProperties();
}
public VersionsFromBom(ReleaserProperties releaserProperties) {
this.properties = releaserProperties;
}
public VersionsFromBom(ReleaserProperties releaserProperties, Set<Project> projects) {
this.properties = releaserProperties;
projects.forEach(project -> setVersion(project.name, project.version));
}
public VersionsFromBom(ReleaserProperties releaserProperties,
VersionsFromBom... projects) {
this.properties = releaserProperties;
Arrays.stream(projects).forEach(p -> this.projects.addAll(p.projects));
}
private String bomProjectName() {
return this.properties.getMetaRelease().getReleaseTrainProjectName();
}
private String dependenciesArtifactId() {
String artifactId = this.properties.getPom().getThisTrainBom();
return artifactId.split(File.separator)[0];
}
private String dependenciesParentArtifactId() {
return dependenciesArtifactId() + "-parent";
}
public String versionForProject(String projectName) {
return this.projects.stream().filter(project -> nameMatches(projectName, project))
.findFirst().orElse(Project.EMPTY_PROJECT).version;
}
public boolean shouldBeUpdated(String projectName) {
return this.projects.stream()
.anyMatch(project -> nameMatches(projectName, project));
}
public boolean shouldSetProperty(Properties properties) {
return this.projects.stream()
.anyMatch(project -> properties.containsKey(project.name + ".version"));
}
public Projects toProjectVersions() {
return this.projects.stream()
.map(project -> new ProjectVersion(project.name, project.version))
.collect(Collectors.toCollection(Projects::new));
}
/**
* The only exception is spring-cloud-dependencies (e.g. Greenwich.RELEASE) and
* spring-cloud-dependencies-parent (e.g. 2.1.0.RELEASE)
*/
private boolean nameMatches(String projectName, Project project) {
if (project.name.equals(projectName)) {
return true;
}
boolean parent = matchesNameWithSuffix(projectName, "-parent", project);
boolean bomArtifactId = comparisonOfBomArtifactAndParent(projectName, project);
return !bomArtifactId && (parent
|| matchesNameWithSuffix(projectName, "-dependencies", project));
}
private boolean comparisonOfBomArtifactAndParent(String projectName,
Project project) {
return artifactOrParent(projectName, project.name)
|| artifactOrParent(project.name, projectName);
}
private boolean artifactOrParent(String projectName, String otherProjectName) {
return projectName.equals(dependenciesArtifactId())
&& otherProjectName.equals(dependenciesParentArtifactId());
}
private boolean matchesNameWithSuffix(String projectName, String suffix,
Project project) {
boolean containsSuffix = projectName.endsWith(suffix);
if (!containsSuffix) {
return false;
}
String withoutSuffix = projectName.substring(0, projectName.indexOf(suffix));
return project.name.equals(withoutSuffix);
}
public VersionsFromBom setVersion(String projectName, String version) {
CustomBomParser parser = CustomBomParser.parser(this.properties);
Set<Project> 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<String> bomVersionProjectNames() {
List<String> names = new ArrayList<>(
this.properties.getMetaRelease().getReleaseTrainDependencyNames());
names.add(this.properties.getMetaRelease().getReleaseTrainProjectName());
return names;
}
private void updateBomVersions(String version) {
remove(bomProjectName());
bomVersionProjectNames().forEach(this::remove);
add(bomProjectName(), version);
bomVersionProjectNames().forEach(s -> add(s, version));
}
public void add(String key, String value) {
this.projects.add(new Project(key, value));
}
public void remove(String expectedProjectName) {
this.projects.removeIf(project -> expectedProjectName.equals(project.name));
}
@Override
public String toString() {
return "Projects=\n\t" + this.projects.stream().map(Object::toString)
.collect(Collectors.joining("\n\t"));
}
}

6
spring-cloud-release-tools-core/src/main/java/org/springframework/cloud/release/internal/project/Projects.java
View File

@@ -26,6 +26,7 @@ import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.buildsystem.Project;
import org.springframework.cloud.release.internal.buildsystem.ProjectVersion;
/**
@@ -152,6 +153,11 @@ public class Projects extends HashSet<ProjectVersion> {
.collect(Collectors.joining(","));
}
public Set<Project> 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 + "]")

2
spring-cloud-release-tools-core/src/main/resources/META-INF/spring.factories Normal file
View File

@@ -0,0 +1,2 @@
org.springframework.cloud.release.internal.buildsystem.CustomBomParser=\
org.springframework.cloud.release.cloud.buildsystem.SpringCloudBomParser

13
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/PomUpdateAcceptanceTests.java
View File

@@ -28,9 +28,9 @@ import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.springframework.cloud.release.internal.buildsystem.PomReader;
import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater;
import org.springframework.cloud.release.internal.buildsystem.ProjectVersion;
import org.springframework.cloud.release.internal.buildsystem.TestPomReader;
import org.springframework.cloud.release.internal.buildsystem.TestUtils;
import org.springframework.cloud.release.internal.project.Projects;
import org.springframework.util.FileSystemUtils;
@@ -45,8 +45,6 @@ public class PomUpdateAcceptanceTests {
@Rule
public TemporaryFolder tmp = new TemporaryFolder();
TestPomReader testPomReader = new TestPomReader();
File temporaryFolder;
@Before
@@ -68,13 +66,12 @@ public class PomUpdateAcceptanceTests {
projects.forFile(project), true);
then(this.temporaryFolder).exists();
Model rootPom = this.testPomReader
.readPom(tmpFile("/spring-cloud-sleuth/pom.xml"));
Model depsPom = this.testPomReader.readPom(
Model rootPom = PomReader.readPom(tmpFile("/spring-cloud-sleuth/pom.xml"));
Model depsPom = PomReader.readPom(
tmpFile("/spring-cloud-sleuth/spring-cloud-sleuth-dependencies/pom.xml"));
Model corePom = this.testPomReader.readPom(
Model corePom = PomReader.readPom(
tmpFile("/spring-cloud-sleuth/spring-cloud-sleuth-core/pom.xml"));
Model zipkinStreamPom = this.testPomReader.readPom(tmpFile(
Model zipkinStreamPom = PomReader.readPom(tmpFile(
"/spring-cloud-sleuth/spring-cloud-sleuth-samples/spring-cloud-sleuth-sample-zipkin-stream/pom.xml"));
then(rootPom.getVersion()).isEqualTo("1.2.0.BUILD-SNAPSHOT");
then(rootPom.getProperties())

27
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/BomParserTests.java
View File

@@ -47,7 +47,7 @@ public class BomParserTests {
public void should_throw_exception_when_boot_pom_is_missing() {
BomParser parser = new BomParser(this.properties, new File("."));
thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class)
thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class)
.hasMessageContaining("Pom is not present");
}
@@ -57,17 +57,16 @@ public class BomParserTests {
this.properties.getPom().setThisTrainBom(null);
BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject);
thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class)
thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class)
.hasMessageContaining("Pom is not present");
}
@Test
public void should_throw_exception_when_boot_version_is_missing_in_pom() {
this.properties.getPom().setPomWithBootStarterParent("pom.xml");
this.properties.getPom().setThisTrainBom(null);
BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject);
thenThrownBy(parser::bootVersion).isInstanceOf(IllegalStateException.class)
thenThrownBy(parser::versionsFromBom).isInstanceOf(IllegalStateException.class)
.hasMessageContaining(
"The pom doesn't have a [spring-boot-starter-parent] artifact id");
}
@@ -76,7 +75,7 @@ public class BomParserTests {
public void should_populate_sc_release_version() {
BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject);
String scReleaseVersion = parser.allVersions()
String scReleaseVersion = parser.versionsFromBom()
.versionForProject("spring-cloud-release");
then(scReleaseVersion).isEqualTo("Dalston.BUILD-SNAPSHOT");
@@ -86,7 +85,7 @@ public class BomParserTests {
public void should_populate_boot_version() {
BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject);
String bootVersion = parser.bootVersion().versionForProject("spring-boot");
String bootVersion = parser.versionsFromBom().versionForProject("spring-boot");
then(bootVersion).isEqualTo("1.5.1.BUILD-SNAPSHOT");
}
@@ -111,7 +110,7 @@ public class BomParserTests {
@Test
public void should_throw_exception_when_cloud_version_is_missing_in_pom() {
this.properties.getPom().setPomWithBootStarterParent(null);
this.properties.getPom().setPomWithBootStarterParent("pom.xml");
this.properties.getPom().setThisTrainBom("pom.xml");
BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject);
@@ -124,24 +123,24 @@ public class BomParserTests {
public void should_populate_cloud_version() {
BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject);
Versions cloudVersions = parser.versionsFromBom();
VersionsFromBom cloudVersionsFromBom = parser.versionsFromBom();
then(cloudVersions.versionForProject("spring-cloud-build"))
then(cloudVersionsFromBom.versionForProject("spring-cloud-build"))
.isEqualTo("1.3.1.BUILD-SNAPSHOT");
then(cloudVersions.projects).contains(allProjects());
then(cloudVersionsFromBom.projects).contains(allProjects());
}
@Test
public void should_populate_boot_and_cloud_version() {
BomParser parser = new BomParser(this.properties, this.springCloudReleaseProject);
Versions cloudVersions = parser.allVersions();
VersionsFromBom cloudVersionsFromBom = parser.versionsFromBom();
then(cloudVersions.versionForProject("spring-boot"))
then(cloudVersionsFromBom.versionForProject("spring-boot"))
.isEqualTo("1.5.1.BUILD-SNAPSHOT");
then(cloudVersions.versionForProject("spring-cloud-build"))
then(cloudVersionsFromBom.versionForProject("spring-cloud-build"))
.isEqualTo("1.3.1.BUILD-SNAPSHOT");
then(cloudVersions.projects).contains(allProjects());
then(cloudVersionsFromBom.projects).contains(allProjects());
}
private Project[] allProjects() {

14
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomReaderTests.java
View File

@@ -36,8 +36,6 @@ import static org.assertj.core.api.BDDAssertions.thenThrownBy;
*/
public class PomReaderTests {
PomReader pomReader = new PomReader();
File springCloudReleaseProjectPom;
File springCloudReleaseProject;
@@ -59,7 +57,7 @@ public class PomReaderTests {
@Test
public void should_parse_a_valid_pom() {
Model pom = this.pomReader.readPom(this.springCloudReleaseProjectPom);
Model pom = PomReader.readPom(this.springCloudReleaseProjectPom);
then(pom).isNotNull();
then(pom.getArtifactId()).isEqualTo("spring-cloud-starter-build");
@@ -67,7 +65,7 @@ public class PomReaderTests {
@Test
public void should_parse_a_valid_pom_when_passing_direcory() {
Model pom = this.pomReader.readPom(this.springCloudReleaseProject);
Model pom = PomReader.readPom(this.springCloudReleaseProject);
then(pom).isNotNull();
then(pom.getArtifactId()).isEqualTo("spring-cloud-starter-build");
@@ -75,20 +73,20 @@ public class PomReaderTests {
@Test
public void should_return_null_when_file_is_missing() {
then(this.pomReader.readPom(new File("foo/bar"))).isNull();
then(PomReader.readPom(new File("foo/bar"))).isNull();
}
@Test
public void should_throw_exception_when_file_is_invalid() {
thenThrownBy(() -> this.pomReader.readPom(this.licenseFile))
thenThrownBy(() -> PomReader.readPom(this.licenseFile))
.hasMessageStartingWith("Failed to read file: ")
.hasCauseInstanceOf(XmlPullParserException.class);
}
@Test
public void should_throw_exception_when_file_is_empty() {
thenThrownBy(() -> this.pomReader.readPom(this.empty))
.hasMessageStartingWith("File [").hasMessageContaining("] is empty")
thenThrownBy(() -> PomReader.readPom(this.empty)).hasMessageStartingWith("File [")
.hasMessageContaining("] is empty")
.hasCauseInstanceOf(EOFException.class);
}

120
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PomUpdaterTests.java
View File

@@ -31,6 +31,7 @@ import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import org.springframework.boot.test.rule.OutputCapture;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.git.GitRepoTests;
import org.springframework.util.FileSystemUtils;
@@ -45,12 +46,11 @@ public class PomUpdaterTests {
@Rule
public TemporaryFolder tmp = new TemporaryFolder();
Versions versions = new Versions("0.0.1", "0.0.2", projects());
VersionsFromBom versionsFromBom = new VersionsFromBom(new ReleaserProperties(),
projects());
PomUpdater pomUpdater = new PomUpdater();
PomReader pomReader = new PomReader();
File temporaryFolder;
@Before
@@ -65,7 +65,7 @@ public class PomUpdaterTests {
File springCloudReleasePom = file("/projects/spring-cloud-release");
BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudReleasePom,
this.versions)).isFalse();
this.versionsFromBom)).isFalse();
}
@Test
@@ -73,8 +73,8 @@ public class PomUpdaterTests {
throws Exception {
File springCloud = pom("/projects/project", "pom_with_parent_suffix.xml");
BDDAssertions
.then(this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versions))
BDDAssertions.then(
this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versionsFromBom))
.isFalse();
}
@@ -84,8 +84,8 @@ public class PomUpdaterTests {
File springCloud = pom("/projects/project",
"pom_matching_with_parent_suffix.xml");
BDDAssertions
.then(this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versions))
BDDAssertions.then(
this.pomUpdater.shouldProjectBeUpdated(springCloud, this.versionsFromBom))
.isTrue();
}
@@ -95,7 +95,7 @@ public class PomUpdaterTests {
File springCloudSleuthPom = file("/projects/spring-cloud-sleuth");
BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudSleuthPom,
this.versions)).isTrue();
this.versionsFromBom)).isTrue();
}
@Test
@@ -104,7 +104,7 @@ public class PomUpdaterTests {
File springCloudSleuthPom = file("/projects/spring-cloud-sleuth/empty-folder");
BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudSleuthPom,
this.versions)).isFalse();
this.versionsFromBom)).isFalse();
}
@Test
@@ -113,9 +113,9 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/pom.xml");
ModelWrapper rootPom = model("foo");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isEqualTo(asString(originalPom));
@@ -128,13 +128,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/pom_matching_artifact.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.3.BUILD-SNAPSHOT");
}
@@ -146,13 +146,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/pom_matching_parent_v2.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(originalPom)).isNotEqualTo(asString(storedPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.3.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -166,13 +166,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/pom_matching_parent.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.3.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -185,7 +185,7 @@ public class PomUpdaterTests {
File springCloudReleasePom = file("/projects/spring-cloud-release");
BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudReleasePom,
this.versions)).isFalse();
this.versionsFromBom)).isFalse();
}
@Test
@@ -194,7 +194,7 @@ public class PomUpdaterTests {
File springCloudSleuthPom = file("/projects/spring-cloud-sleuth");
BDDAssertions.then(this.pomUpdater.shouldProjectBeUpdated(springCloudSleuthPom,
this.versions)).isTrue();
this.versionsFromBom)).isTrue();
}
@Test
@@ -205,13 +205,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/children/pom_matching_parent_v2.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.3.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -230,13 +230,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/children/pom_different_group_boot_parent.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.3.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -252,13 +252,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/children/pom_different_group.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("1.2.2.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -277,13 +277,13 @@ public class PomUpdaterTests {
"/project/children/pom_different_group_skip_deployment_prop.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("1.2.2.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -302,13 +302,13 @@ public class PomUpdaterTests {
"/project/children/pom_different_group_skip_deployment_plugin.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("1.2.2.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -327,13 +327,13 @@ public class PomUpdaterTests {
"/project/children/pom_different_group_skip_deployment_plugin_mngmnt.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth", "org.springframework.cloud");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("1.2.2.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -352,13 +352,13 @@ public class PomUpdaterTests {
ModelWrapper rootPom = model("spring-cloud-contract",
"org.springframework.cloud");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
.isEqualTo("0.0.1");
@@ -371,13 +371,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/children/pom_matching_parent.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.3.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -395,13 +395,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/children/pom_matching_properties.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.3.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -418,10 +418,10 @@ public class PomUpdaterTests {
"pom_matching_properties.xml");
File afterProcessing = tmpFile("/project/children/pom_matching_properties.xml");
ModelWrapper model = this.pomUpdater.updateModel(model("spring-cloud-sleuth"),
afterProcessing, this.versions);
afterProcessing, this.versionsFromBom);
File processedPom = this.pomUpdater.overwritePomIfDirty(model,
Versions.EMPTY_VERSION, afterProcessing);
VersionsFromBom.EMPTY_VERSION, afterProcessing);
String processedPomText = asString(processedPom);
String beforeProcessingText = asString(beforeProcessing);
@@ -434,10 +434,10 @@ public class PomUpdaterTests {
File beforeProcessing = pom("/projects/project/");
File afterProcessing = tmpFile("/project/pom.xml");
ModelWrapper model = this.pomUpdater.updateModel(model("foo"), afterProcessing,
this.versions);
this.versionsFromBom);
File processedPom = this.pomUpdater.overwritePomIfDirty(model,
Versions.EMPTY_VERSION, afterProcessing);
VersionsFromBom.EMPTY_VERSION, afterProcessing);
BDDAssertions.then(asString(processedPom)).isEqualTo(asString(beforeProcessing));
}
@@ -449,13 +449,13 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/spring-cloud-contract/pom.xml");
ModelWrapper rootPom = model("spring-cloud-contract-parent");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isNotEqualTo(asString(originalPom));
Model overriddenPomModel = this.pomReader.readPom(storedPom);
Model overriddenPomModel = PomReader.readPom(storedPom);
BDDAssertions.then(overriddenPomModel.getVersion())
.isEqualTo("0.0.2.BUILD-SNAPSHOT");
BDDAssertions.then(overriddenPomModel.getParent().getVersion())
@@ -470,9 +470,9 @@ public class PomUpdaterTests {
File pomInTemp = tmpFile("/project/pom_matching_artifact_same_version.xml");
ModelWrapper rootPom = model("spring-cloud-sleuth");
ModelWrapper model = this.pomUpdater.updateModel(rootPom, pomInTemp,
this.versions);
this.versionsFromBom);
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versions,
File storedPom = this.pomUpdater.overwritePomIfDirty(model, this.versionsFromBom,
pomInTemp);
BDDAssertions.then(asString(storedPom)).isEqualTo(asString(originalPom));
@@ -480,6 +480,8 @@ public class PomUpdaterTests {
Set<Project> projects() {
Set<Project> 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"));

6
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/PropertyVersionChangerTests.java
View File

@@ -27,6 +27,8 @@ import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.springframework.cloud.release.internal.ReleaserProperties;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.never;
@@ -75,8 +77,8 @@ public class PropertyVersionChangerTests {
.setPropertyVersionIfApplicable(any(Project.class));
}
Versions versions() {
return new Versions("", "", allProjects());
VersionsFromBom versions() {
return new VersionsFromBom(new ReleaserProperties(), allProjects());
}
@SuppressWarnings("unchecked")

34
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java
View File

@@ -1,34 +0,0 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
import java.io.File;
import org.apache.maven.model.Model;
/**
* @author Marcin Grzejszczak
*/
public class TestPomReader {
PomReader pomReader = new PomReader();
public Model readPom(File pom) {
return this.pomReader.readPom(pom);
}
}

290
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsFromBomTests.java Normal file
View File

@@ -0,0 +1,290 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
import java.util.Collections;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
import org.junit.Test;
import org.springframework.cloud.release.internal.ReleaserProperties;
import static org.assertj.core.api.BDDAssertions.then;
/**
* @author Marcin Grzejszczak
*/
public class VersionsFromBomTests {
VersionsFromBom versionsFromBom = new VersionsFromBom(new ReleaserProperties(),
projects());
@Test
public void should_add_boot_to_versions_when_version_is_created() {
VersionsFromBom versionsFromBom = new VersionsFromBom(new ReleaserProperties());
versionsFromBom.setVersion("spring-boot", "1.2.3.RELEASE");
then(versionsFromBom.projects).contains(
new Project("spring-boot", "1.2.3.RELEASE"),
new Project("spring-boot-starter-parent", "1.2.3.RELEASE"),
new Project("spring-boot-dependencies", "1.2.3.RELEASE"));
}
@Test
public void should_return_true_when_project_is_on_the_list() {
then(this.versionsFromBom.shouldBeUpdated("foo")).isTrue();
}
@Test
public void should_return_true_when_project_has_a_parent_suffix_and_project_is_on_the_list() {
then(this.versionsFromBom.shouldBeUpdated("foo-parent")).isTrue();
}
@Test
public void should_return_true_when_project_has_a_dependencies_suffix_and_project_is_on_the_list() {
then(this.versionsFromBom.shouldBeUpdated("foo-dependencies")).isTrue();
}
@Test
public void should_return_false_when_project_is_not_on_the_list() {
then(this.versionsFromBom.shouldBeUpdated("missing")).isFalse();
}
@Test
public void should_return_version_for_present_project() {
then(this.versionsFromBom.versionForProject("foo")).isEqualTo("bar");
}
@Test
public void should_return_empty_string_for_missing_project() {
then(this.versionsFromBom.versionForProject("missing")).isEmpty();
}
@Test
public void should_return_true_if_properties_contains_project_key() {
then(this.versionsFromBom.shouldSetProperty(validProps())).isTrue();
}
@Test
public void should_return_false_if_properties_does_not_contain_project_key() {
then(this.versionsFromBom.shouldSetProperty(missingProps())).isFalse();
}
@Test
public void should_update_projects_for_boot() {
VersionsFromBom versionsFromBom = mixedVersions().setVersion("spring-boot",
"3.0.0");
then(versionsFromBom.versionForProject("spring-boot")).isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-boot-starter-parent"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-boot-dependencies"))
.isEqualTo("3.0.0");
versionsFromBom = mixedVersions().setVersion("spring-boot-starter-parent",
"3.0.0");
then(versionsFromBom.versionForProject("spring-boot")).isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-boot-starter-parent"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-boot-dependencies"))
.isEqualTo("3.0.0");
versionsFromBom = mixedVersions().setVersion("spring-boot-dependencies", "3.0.0");
then(versionsFromBom.versionForProject("spring-boot")).isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-boot-starter-parent"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-boot-dependencies"))
.isEqualTo("3.0.0");
}
@Test
public void should_update_projects_for_build() {
VersionsFromBom versionsFromBom = mixedVersions().setVersion("spring-cloud-build",
"3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-build")).isEqualTo("3.0.0");
versionsFromBom = mixedVersions().setVersion("spring-cloud-build", "3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-dependencies-parent"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versionsFromBom = mixedVersions().setVersion("spring-cloud-dependencies-parent",
"3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-build")).isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-dependencies-parent"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
}
@Test
public void should_update_projects_for_spring_cloud_release() {
VersionsFromBom versionsFromBom = mixedVersions().setVersion("spring-cloud",
"3.0.0");
then(versionsFromBom.versionForProject("spring-cloud")).isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-release"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-starter"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("3.0.0");
versionsFromBom = mixedVersions().setVersion("spring-cloud-release", "3.0.0");
then(versionsFromBom.versionForProject("spring-cloud")).isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-release"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-starter"))
.isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("3.0.0");
versionsFromBom = mixedVersions().setVersion("spring-cloud-release",
"Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud"))
.isEqualTo("Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-release"))
.isEqualTo("Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-starter"))
.isEqualTo("Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.SR8");
versionsFromBom = mixedVersions().setVersion("spring-cloud-dependencies",
"Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud"))
.isEqualTo("Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-release"))
.isEqualTo("Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-starter"))
.isEqualTo("Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.SR8");
}
@Test
public void should_update_projects_for_custom_bom_only() {
VersionsFromBom versionsFromBom = mixedVersions(customBom())
.setVersion("spring-cloud", "3.0.0");
then(versionsFromBom.versionForProject("spring-cloud")).isEqualTo("3.0.0");
then(versionsFromBom.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.RELEASE");
then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty();
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versionsFromBom = mixedVersions(customBom())
.setVersion("spring-cloud-stream-starters", "Fishtown.SR4");
then(versionsFromBom.versionForProject("spring-cloud")).isEmpty();
then(versionsFromBom.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.SR4");
then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty();
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versionsFromBom = mixedVersions(customBom()).setVersion("spring-cloud-release",
"Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-release"))
.isEqualTo("Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.RELEASE");
then(versionsFromBom.versionForProject("spring-cloud")).isEmpty();
then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty();
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versionsFromBom = mixedVersions(customBom())
.setVersion("spring-cloud-dependencies", "Greenwich.SR8");
then(versionsFromBom.versionForProject("spring-cloud")).isEmpty();
then(versionsFromBom.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.RELEASE");
then(versionsFromBom.versionForProject("spring-cloud-starter")).isEmpty();
then(versionsFromBom.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.SR8");
}
@Test
public void should_update_projects_for_custom_project() {
VersionsFromBom versionsFromBom = mixedVersions().setVersion("foo", "3.0.0");
then(versionsFromBom.versionForProject("foo")).isEqualTo("3.0.0");
}
private VersionsFromBom mixedVersions() {
return new VersionsFromBom(new ReleaserProperties(), mixedProjects());
}
private VersionsFromBom mixedVersions(ReleaserProperties properties) {
return new VersionsFromBom(properties, mixedProjects());
}
private ReleaserProperties customBom() {
ReleaserProperties properties = new ReleaserProperties();
properties.getMetaRelease()
.setReleaseTrainDependencyNames(Collections.emptyList());
properties.getMetaRelease()
.setReleaseTrainProjectName("spring-cloud-stream-starters");
properties.getPom().setThisTrainBom("spring-cloud-stream-dependencies");
return properties;
}
Set<Project> projects() {
Set<Project> projects = new HashSet<>();
projects.add(new Project("foo", "bar"));
return projects;
}
Set<Project> mixedProjects() {
Set<Project> 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;
}
}

265
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/buildsystem/VersionsTests.java
View File

@@ -1,265 +0,0 @@
/*
* Copyright 2013-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.cloud.release.internal.buildsystem;
import java.util.Collections;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
import org.junit.Test;
import org.springframework.cloud.release.internal.ReleaserProperties;
import static org.assertj.core.api.BDDAssertions.then;
/**
* @author Marcin Grzejszczak
*/
public class VersionsTests {
Versions versions = new Versions(new ReleaserProperties(), projects());
@Test
public void should_add_boot_to_versions_when_version_is_created() {
then(new Versions("1.2.3.RELEASE").projects).contains(
new Project("spring-boot", "1.2.3.RELEASE"),
new Project("spring-boot-starter-parent", "1.2.3.RELEASE"),
new Project("spring-boot-dependencies", "1.2.3.RELEASE"));
}
@Test
public void should_return_true_when_project_is_on_the_list() {
then(this.versions.shouldBeUpdated("foo")).isTrue();
}
@Test
public void should_return_true_when_project_has_a_parent_suffix_and_project_is_on_the_list() {
then(this.versions.shouldBeUpdated("foo-parent")).isTrue();
}
@Test
public void should_return_true_when_project_has_a_dependencies_suffix_and_project_is_on_the_list() {
then(this.versions.shouldBeUpdated("foo-dependencies")).isTrue();
}
@Test
public void should_return_false_when_project_is_not_on_the_list() {
then(this.versions.shouldBeUpdated("missing")).isFalse();
}
@Test
public void should_return_version_for_present_project() {
then(this.versions.versionForProject("foo")).isEqualTo("bar");
}
@Test
public void should_return_empty_string_for_missing_project() {
then(this.versions.versionForProject("missing")).isEmpty();
}
@Test
public void should_return_true_if_properties_contains_project_key() {
then(this.versions.shouldSetProperty(validProps())).isTrue();
}
@Test
public void should_return_false_if_properties_does_not_contain_project_key() {
then(this.versions.shouldSetProperty(missingProps())).isFalse();
}
@Test
public void should_update_projects_for_boot() {
Versions versions = mixedVersions().setVersion("spring-boot", "3.0.0");
then(versions.versionForProject("spring-boot")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-boot-starter-parent")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-boot-dependencies")).isEqualTo("3.0.0");
versions = mixedVersions().setVersion("spring-boot-starter-parent", "3.0.0");
then(versions.versionForProject("spring-boot")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-boot-starter-parent")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-boot-dependencies")).isEqualTo("3.0.0");
versions = mixedVersions().setVersion("spring-boot-dependencies", "3.0.0");
then(versions.versionForProject("spring-boot")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-boot-starter-parent")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-boot-dependencies")).isEqualTo("3.0.0");
}
@Test
public void should_update_projects_for_build() {
Versions versions = mixedVersions().setVersion("spring-cloud-build", "3.0.0");
then(versions.versionForProject("spring-cloud-build")).isEqualTo("3.0.0");
versions = mixedVersions().setVersion("spring-cloud-build", "3.0.0");
then(versions.versionForProject("spring-cloud-dependencies-parent"))
.isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versions = mixedVersions().setVersion("spring-cloud-dependencies-parent",
"3.0.0");
then(versions.versionForProject("spring-cloud-build")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-dependencies-parent"))
.isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
}
@Test
public void should_update_projects_for_spring_cloud_release() {
Versions versions = mixedVersions().setVersion("spring-cloud", "3.0.0");
then(versions.versionForProject("spring-cloud")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-release")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-starter")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-dependencies")).isEqualTo("3.0.0");
versions = mixedVersions().setVersion("spring-cloud-release", "3.0.0");
then(versions.versionForProject("spring-cloud")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-release")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-starter")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-dependencies")).isEqualTo("3.0.0");
versions = mixedVersions().setVersion("spring-cloud-release", "Greenwich.SR8");
then(versions.versionForProject("spring-cloud")).isEqualTo("Greenwich.SR8");
then(versions.versionForProject("spring-cloud-release"))
.isEqualTo("Greenwich.SR8");
then(versions.versionForProject("spring-cloud-starter"))
.isEqualTo("Greenwich.SR8");
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.SR8");
versions = mixedVersions().setVersion("spring-cloud-dependencies",
"Greenwich.SR8");
then(versions.versionForProject("spring-cloud")).isEqualTo("Greenwich.SR8");
then(versions.versionForProject("spring-cloud-release"))
.isEqualTo("Greenwich.SR8");
then(versions.versionForProject("spring-cloud-starter"))
.isEqualTo("Greenwich.SR8");
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.SR8");
}
@Test
public void should_update_projects_for_custom_bom_only() {
Versions versions = mixedVersions(customBom()).setVersion("spring-cloud",
"3.0.0");
then(versions.versionForProject("spring-cloud")).isEqualTo("3.0.0");
then(versions.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.RELEASE");
then(versions.versionForProject("spring-cloud-starter")).isEmpty();
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versions = mixedVersions(customBom()).setVersion("spring-cloud-stream-starters",
"Fishtown.SR4");
then(versions.versionForProject("spring-cloud")).isEmpty();
then(versions.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.SR4");
then(versions.versionForProject("spring-cloud-starter")).isEmpty();
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versions = mixedVersions(customBom()).setVersion("spring-cloud-release",
"Greenwich.SR8");
then(versions.versionForProject("spring-cloud-release"))
.isEqualTo("Greenwich.SR8");
then(versions.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.RELEASE");
then(versions.versionForProject("spring-cloud")).isEmpty();
then(versions.versionForProject("spring-cloud-starter")).isEmpty();
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.RELEASE");
versions = mixedVersions(customBom()).setVersion("spring-cloud-dependencies",
"Greenwich.SR8");
then(versions.versionForProject("spring-cloud")).isEmpty();
then(versions.versionForProject("spring-cloud-stream-starters"))
.isEqualTo("Fishtown.RELEASE");
then(versions.versionForProject("spring-cloud-starter")).isEmpty();
then(versions.versionForProject("spring-cloud-dependencies"))
.isEqualTo("Greenwich.SR8");
}
@Test
public void should_update_projects_for_custom_project() {
Versions versions = mixedVersions().setVersion("foo", "3.0.0");
then(versions.versionForProject("foo")).isEqualTo("3.0.0");
}
private Versions mixedVersions() {
return new Versions("1.0.0", "2.0.0", mixedProjects());
}
private Versions mixedVersions(ReleaserProperties properties) {
return new Versions(properties, "1.0.0", "2.0.0", mixedProjects());
}
private ReleaserProperties customBom() {
ReleaserProperties properties = new ReleaserProperties();
properties.getMetaRelease()
.setReleaseTrainDependencyNames(Collections.emptyList());
properties.getMetaRelease()
.setReleaseTrainProjectName("spring-cloud-stream-starters");
properties.getPom().setThisTrainBom("spring-cloud-stream-dependencies");
return properties;
}
Set<Project> projects() {
Set<Project> projects = new HashSet<>();
projects.add(new Project("foo", "bar"));
return projects;
}
Set<Project> mixedProjects() {
Set<Project> 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;
}
}

14
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/postrelease/PostReleaseActionsTests.java
View File

@@ -38,9 +38,9 @@ import org.mockito.BDDMockito;
import org.springframework.cloud.release.internal.PomUpdateAcceptanceTests;
import org.springframework.cloud.release.internal.ReleaserProperties;
import org.springframework.cloud.release.internal.buildsystem.GradleUpdater;
import org.springframework.cloud.release.internal.buildsystem.PomReader;
import org.springframework.cloud.release.internal.buildsystem.ProjectPomUpdater;
import org.springframework.cloud.release.internal.buildsystem.ProjectVersion;
import org.springframework.cloud.release.internal.buildsystem.TestPomReader;
import org.springframework.cloud.release.internal.buildsystem.TestUtils;
import org.springframework.cloud.release.internal.git.GitTestUtils;
import org.springframework.cloud.release.internal.git.ProjectGitHandler;
@@ -61,8 +61,6 @@ public class PostReleaseActionsTests {
File temporaryFolder;
TestPomReader testPomReader = new TestPomReader();
GradleUpdater gradleUpdater = BDDMockito.mock(GradleUpdater.class);
ReleaserProperties properties = new ReleaserProperties();
@@ -143,7 +141,7 @@ public class PostReleaseActionsTests {
actions.runUpdatedTests(currentGa());
Model rootPom = this.testPomReader.readPom(new File(this.cloned, "pom.xml"));
Model rootPom = PomReader.readPom(new File(this.cloned, "pom.xml"));
BDDAssertions.then(rootPom.getVersion()).isEqualTo("Finchley.SR1");
BDDAssertions.then(rootPom.getParent().getVersion()).isEqualTo("2.0.4.RELEASE");
BDDAssertions.then(sleuthParentPomVersion()).isEqualTo("2.0.4.RELEASE");
@@ -193,7 +191,7 @@ public class PostReleaseActionsTests {
actions.generateReleaseTrainDocumentation(currentGa());
Model rootPom = this.testPomReader.readPom(new File(this.cloned, "pom.xml"));
Model rootPom = PomReader.readPom(new File(this.cloned, "pom.xml"));
BDDAssertions.then(rootPom.getVersion()).isEqualTo("Finchley.SR1");
BDDAssertions.then(rootPom.getParent().getVersion()).isEqualTo("2.0.4.RELEASE");
BDDAssertions.then(sleuthParentPomVersion()).isEqualTo("2.0.4.RELEASE");
@@ -252,7 +250,7 @@ public class PostReleaseActionsTests {
.filter(s -> s.getKey().contains("spring-cloud-core-tests")).findFirst()
.orElseThrow(() -> new IllegalStateException("Not found"));
File clonedFile = entry.getValue().get(0);
Model pomWithCloud = this.testPomReader
Model pomWithCloud = PomReader
.readPom(new File(clonedFile, "zuul-proxy-eureka/pom.xml"));
Git git = GitTestUtils.openGitProject(clonedFile);
BDDAssertions
@@ -343,8 +341,8 @@ public class PostReleaseActionsTests {
}
private String sleuthParentPomVersion() {
return this.testPomReader.readPom(new File(this.cloned, "sleuth/pom.xml"))
.getParent().getVersion();
return PomReader.readPom(new File(this.cloned, "sleuth/pom.xml")).getParent()
.getVersion();
}
Projects currentGa() {

17
spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFetcherTests.java → spring-cloud-release-tools-core/src/test/java/org/springframework/cloud/release/internal/versions/VersionsFromBomFetcherTests.java
View File

@@ -33,7 +33,7 @@ import org.springframework.cloud.release.internal.buildsystem.TestUtils;
import org.springframework.cloud.release.internal.project.Projects;
import org.springframework.util.FileSystemUtils;
class VersionsFetcherTests {
class VersionsFromBomFetcherTests {
File temporaryFolder;
@@ -52,8 +52,8 @@ class VersionsFetcherTests {
throws URISyntaxException {
ProjectVersion projectVersion = new ProjectVersion("spring-cloud-contract",
"2.5.0.RELEASE");
URI initilizrUri = VersionsFetcherTests.class.getResource("/raw/initializr.yml")
.toURI();
URI initilizrUri = VersionsFromBomFetcherTests.class
.getResource("/raw/initializr.yml").toURI();
ReleaserProperties properties = new ReleaserProperties();
properties.getVersions().setAllVersionsFileUrl(initilizrUri.toString());
properties.getGit().setReleaseTrainBomUrl(
@@ -71,8 +71,8 @@ class VersionsFetcherTests {
throws URISyntaxException {
ProjectVersion projectVersion = new ProjectVersion("spring-cloud-contract",
"1.0.0.RELEASE");
URI initilizrUri = VersionsFetcherTests.class.getResource("/raw/initializr.yml")
.toURI();
URI initilizrUri = VersionsFromBomFetcherTests.class
.getResource("/raw/initializr.yml").toURI();
ReleaserProperties properties = new ReleaserProperties();
properties.getVersions().setAllVersionsFileUrl(initilizrUri.toString());
properties.getGit().setReleaseTrainBomUrl(
@@ -90,8 +90,8 @@ class VersionsFetcherTests {
throws URISyntaxException {
ProjectVersion projectVersion = new ProjectVersion("spring-cloud-non-existant",
"1.0.0.RELEASE");
URI initilizrUri = VersionsFetcherTests.class.getResource("/raw/initializr.yml")
.toURI();
URI initilizrUri = VersionsFromBomFetcherTests.class
.getResource("/raw/initializr.yml").toURI();
ReleaserProperties properties = new ReleaserProperties();
properties.getVersions().setAllVersionsFileUrl(initilizrUri.toString());
properties.getGit().setReleaseTrainBomUrl(
@@ -137,7 +137,8 @@ class VersionsFetcherTests {
}
private File localFile(String relativePath) throws URISyntaxException {
return new File(VersionsFetcherTests.class.getResource(relativePath).toURI());
return new File(
VersionsFromBomFetcherTests.class.getResource(relativePath).toURI());
}
private File file(String relativePath) {

4
spring-cloud-release-tools-spring/src/test/java/org/springframework/cloud/release/internal/buildsystem/TestPomReader.java
View File

@@ -25,10 +25,8 @@ import org.apache.maven.model.Model;
*/
public class TestPomReader {
PomReader pomReader = new PomReader();
public Model readPom(File pom) {
return this.pomReader.readPom(pom);
return PomReader.readPom(pom);
}
}